From 9007909d07a5019257ce8836d1592945f8cf99ca Mon Sep 17 00:00:00 2001
From: Thomas Nixon <tom@tomn.co.uk>
Date: Wed, 16 Nov 2022 16:15:01 +0000
Subject: [PATCH 1/9] auto base: rework for smaller code size

- make Combine corecursive with HasParameters so that the tail stays
  encoded as a list of parameter classes, rather than the full
  inheritance structure

- avoid using CombineRaw by adding more combination classes that inherit
  from two bases

- avoid virtual base in variant parameter

- add tests for variant parameters

- move more of the details out of the main header

- move tag types out of template parameters

- turn flags into types to cut down on symbols
---
 include/adm/detail/auto_base.hpp        | 179 ++++++------------
 include/adm/detail/auto_base_detail.hpp | 235 ++++++++++++++++++++++--
 tests/auto_base_tests.cpp               |  86 ++++++---
 3 files changed, 334 insertions(+), 166 deletions(-)

diff --git a/include/adm/detail/auto_base.hpp b/include/adm/detail/auto_base.hpp
index d8d07262..a6583bc9 100644
--- a/include/adm/detail/auto_base.hpp
+++ b/include/adm/detail/auto_base.hpp
@@ -44,113 +44,56 @@ namespace adm {
     // chained, with the actual inheritance happening in CombineRaw. When
     // combining A and B we have an inheritance hierarchy like:
     //
-    // Combine<A, B>
-    //  -> ApplyIf<CombineGetSetHas<A, B>, X>
-    //      -> ApplyIf<CombineIsDefaultUnset<A, B>, Y>
-    //          -> CombineRaw<A, B>
-    //              -> A
-    //              -> B
+    // To enable all combinations without making the dreaded diamond, these are
+    // chained, with the actual inheritance happening in one of the Combine*B
+    // classes. When combining two or more classes we have an inheritance
+    // hierarchy like:
     //
-    // where X and Y are the flags controlling whether Combine* is applied or
-    // not.
+    // Combine<Head, Tail...> { B = HasParameters<Tail...> }
+    // -> CombineGetSetHas<A, B>
+    //    -> CombineIsDefaultUnsetB<A, B>
+    //       -> A
+    //       -> B
     //
-    // Combine is used by HasParameters, which recursively combines many *Base
-    // classes.
+    // Combine is used co-recursively by HasParameters, which combines many
+    // *Base classes.
     //
     // For variant types, there is one base class which implements the methods
     // for the variant type (e.g. OptionalParameter<variant<...>>), and one
     // base class for each of the types T in the variant, e.g.
     // VariantTypeParameter<Param, T>.
     //
-    // VariantTypeParameter classes must inherit from OptionalParameter in
-    // order to access the variant (through the get/set methods). This could be
-    // implemented by templating VariantTypeParameter on the list of types of
-    // the variant, and each inheriting from the next, but each of these
-    // classes is to be explicitly instantiated, and the meaning of these
-    // parameters in the explicit instantiations would not be clear.
+    // These are combined together using VariantParameter. This works similarly
+    // to HasParameters -- the VariantTypeParameter for the first type in the
+    // variant inherits from the VariantTypeParameter from the next, and so on,
+    // until the OptionalParameter<variant<...>>. This structure is necessary
+    // because the methids in VariantTypeParameter need to cahh the methods on
+    // the OptionalParameter<variant<...>>, so must inherit from it.
+    //
+    // For example, if we have P = OptionalParameter<variant<A, B, C>>, then
+    // VariantParameter is:
     //
-    // Instead, each VariantTypeParameter inherits from OptionalParameter, and
-    // virtual inheritance is used to avoid ambiguity. These are then combined
-    // together in VariantParameter using HasParameters, so that only one type
-    // has to be added to the base class list to cover the whole variant.
+    // VariantParameter<P> = VariantTypeParameter<P, A>
     //
-    // For clarity, if we have P = OptionalParameter<variant<A, B>>, then the
-    // inheritance structure looks like:
+    // And the inheritance structure looks like:
     //
-    // VariantParameter<P>
-    //  -> VariantTypeParameter<P, A>
-    //      -> P
-    //  -> VariantTypeParameter<P, B>
-    //      -> P
+    // VariantTypeParameter<P, A>
+    // -> VariantTypeParameter<P, B>
+    //    -> VariantTypeParameter<P, C>
+    //       -> P
 
 #ifndef IN_DOXYGEN
 
     struct Flags {
-      static constexpr bool has_get_set_has = false;
-      static constexpr bool has_isDefault_unset = false;
-      static constexpr bool has_add_remove = false;
-    };
-
-    /// a subclass of Base, with using declarations for set, get and has in A
-    /// and B
-    template <typename A, typename B, typename Base>
-    struct CombineGetSetHas : public Base {
-      using A::get;
-      using B::get;
-
-      using A::set;
-      using B::set;
-
-      using A::has;
-      using B::has;
-    };
-
-    /// a subclass of Base, with using declarations for isDefault and unset in A
-    /// and B
-    template <typename A, typename B, typename Base>
-    struct CombineIsDefaultUnset : public Base {
-      using A::isDefault;
-      using B::isDefault;
-
-      using A::unset;
-      using B::unset;
-    };
-
-    /// a subclass of Base, with using declarations for add and remove in A and
-    /// B
-    template <typename A, typename B, typename Base>
-    struct CombineAddRemove : public Base {
-      using A::add;
-      using B::add;
-
-      using A::remove;
-      using B::remove;
-    };
-
-    /// a subclass of A and B, with methods according to their Flags
-    template <typename A, typename B>
-    struct Combine
-        : public ApplyIf<
-              A::has_add_remove && B::has_add_remove, CombineAddRemove, A, B,
-              ApplyIf<A::has_get_set_has && B::has_get_set_has,
-                      CombineGetSetHas, A, B,
-                      ApplyIf<A::has_isDefault_unset && B::has_isDefault_unset,
-                              CombineIsDefaultUnset, A, B, CombineRaw<A, B>>>> {
-      static constexpr bool has_get_set_has =
-          A::has_get_set_has || B::has_get_set_has;
-      static constexpr bool has_isDefault_unset =
-          A::has_isDefault_unset || B::has_isDefault_unset;
-      static constexpr bool has_add_remove =
-          A::has_add_remove || B::has_add_remove;
+      using has_get_set_has = std::false_type;
+      using has_isDefault_unset = std::false_type;
+      using has_add_remove = std::false_type;
     };
 
     /// make a class derived from the given base classes, combining the
     /// get, set, has, isDefault and unset overloads
-    template <typename B, typename... BTail>
-    struct HasParameters : public Combine<B, HasParameters<BTail...>> {};
-
-    template <typename B>
-    struct HasParameters<B> : public B {};
+    template <typename... Bases>
+    using HasParameters = typename HasParametersT<Bases...>::type;
 
     /// Get the default value of T parameters. Specialise this to add custom
     /// defaults.
@@ -161,12 +104,13 @@ namespace adm {
 
     /// base class with set/get/has methods for a required parameter of type T
     /// combine these together using HasParameters
-    template <typename T,
-              typename Tag = typename detail::ParameterTraits<T>::tag>
+    template <typename T>
     class RequiredParameter : public Flags {
+      using Tag = typename detail::ParameterTraits<T>::tag;
+
      public:
       using ParameterType = T;
-      static constexpr bool has_get_set_has = true;
+      using has_get_set_has = std::true_type;
 
       ADM_BASE_EXPORT T get(Tag) const { return value_; }
       ADM_BASE_EXPORT void set(T value) { value_ = std::move(value); }
@@ -179,13 +123,14 @@ namespace adm {
     /// base class with set/get/has/isDefault/unset methods for an optional
     /// parameter of type T with no default. combine these together using
     /// HasParameters
-    template <typename T,
-              typename Tag = typename detail::ParameterTraits<T>::tag>
+    template <typename T>
     class OptionalParameter : public Flags {
+      using Tag = typename detail::ParameterTraits<T>::tag;
+
      public:
       using ParameterType = T;
-      static constexpr bool has_get_set_has = true;
-      static constexpr bool has_isDefault_unset = true;
+      using has_get_set_has = std::true_type;
+      using has_isDefault_unset = std::true_type;
 
       ADM_BASE_EXPORT T get(Tag) const { return value_.get(); }
       ADM_BASE_EXPORT void set(T value) { value_ = std::move(value); }
@@ -200,13 +145,14 @@ namespace adm {
     /// base class with set/get/has/isDefault/unset methods for an optional
     /// parameter of type T, which has a default provided by DefaultParameter.
     /// combine these together using HasParameters
-    template <typename T,
-              typename Tag = typename detail::ParameterTraits<T>::tag>
+    template <typename T>
     class DefaultParameter : public Flags {
+      using Tag = typename detail::ParameterTraits<T>::tag;
+
      public:
       using ParameterType = T;
-      static constexpr bool has_get_set_has = true;
-      static constexpr bool has_isDefault_unset = true;
+      using has_get_set_has = std::true_type;
+      using has_isDefault_unset = std::true_type;
 
       ADM_BASE_EXPORT T get(Tag) const {
         return boost::get_optional_value_or(value_, getDefault<T>());
@@ -230,16 +176,16 @@ namespace adm {
     /// base class for storage of multiple elements in a std::vector.
     /// T should be a std::vector<Something>, as this is what the tag is
     /// associated with.
-    template <typename T,
-              typename Tag = typename detail::ParameterTraits<T>::tag>
+    template <typename T>
     class VectorParameter : public Flags {
       using Value = typename T::value_type;
+      using Tag = typename detail::ParameterTraits<T>::tag;
 
      public:
       using ParameterType = T;
-      static constexpr bool has_get_set_has = true;
-      static constexpr bool has_isDefault_unset = true;
-      static constexpr bool has_add_remove = true;
+      using has_get_set_has = std::true_type;
+      using has_isDefault_unset = std::true_type;
+      using has_add_remove = std::true_type;
 
       ADM_BASE_EXPORT T get(Tag) const { return value_; }
       ADM_BASE_EXPORT void set(T value) { value_ = std::move(value); }
@@ -278,46 +224,39 @@ namespace adm {
     /// OptionalParameter<boost::variant<...>>, and T should be one of the
     /// types of the variant.
     template <typename VariantParam, typename T>
-    class VariantTypeParameter : public virtual VariantParam {
+    class VariantTypeParameter
+        : public VariantTypeParameterBase<VariantParam, T> {
       using Variant = typename VariantParam::ParameterType;
       using Tag = typename detail::ParameterTraits<T>::tag;
       using VariantTag = typename detail::ParameterTraits<Variant>::tag;
 
      public:
-      using VariantParam::get;
+      using VariantTypeParameterBase<VariantParam, T>::get;
       ADM_BASE_EXPORT T get(Tag) const {
         return boost::get<T>(get(VariantTag{}));
       }
 
-      using VariantParam::set;
+      using VariantTypeParameterBase<VariantParam, T>::set;
       ADM_BASE_EXPORT void set(T value) {
         return VariantParam::set(std::move(value));
       }
 
-      using VariantParam::has;
+      using VariantTypeParameterBase<VariantParam, T>::has;
       ADM_BASE_EXPORT bool has(Tag) const {
         return has(VariantTag{}) && get(VariantTag()).type() == typeid(T);
       }
 
-      using VariantParam::isDefault;
+      using VariantTypeParameterBase<VariantParam, T>::isDefault;
       ADM_BASE_EXPORT bool isDefault(Tag) const {
         return isDefault(VariantTag()) && get(VariantTag()).type() == typeid(T);
       }
 
-      using VariantParam::unset;
+      using VariantTypeParameterBase<VariantParam, T>::unset;
       ADM_BASE_EXPORT void unset(Tag) {
         if (has(Tag{})) unset(VariantTag{});
       }
     };
 
-    template <typename VariantParam, typename VariantParameter>
-    struct VariantParameterHelper;
-
-    template <typename VariantParam, typename... Ts>
-    struct VariantParameterHelper<VariantParam, boost::variant<Ts...>> {
-      using type = HasParameters<VariantTypeParameter<VariantParam, Ts>...>;
-    };
-
     /// Wrapper which has methods for each type in a variant parameter.
     ///
     /// This should be used in HasParameters, with VariantParam being a
@@ -328,8 +267,8 @@ namespace adm {
     /// - OptionalParameter<V> (not VariantParameter<...>)
     /// - One VariantParameter<OptionalParameter<V>, T> for each T in V.
     template <typename VariantParam>
-    using VariantParameter = typename VariantParameterHelper<
-        VariantParam, typename VariantParam::ParameterType>::type;
+    using VariantParameter = VariantTypeParameter<
+        VariantParam, VariantFirstType<typename VariantParam::ParameterType>>;
 
     /// Helper containing templated wrapper methods like `has<Param>()` around
     /// overloaded `has(ParamTag)` type methods defined in T.
diff --git a/include/adm/detail/auto_base_detail.hpp b/include/adm/detail/auto_base_detail.hpp
index 0d9d94ed..24e320b5 100644
--- a/include/adm/detail/auto_base_detail.hpp
+++ b/include/adm/detail/auto_base_detail.hpp
@@ -1,31 +1,230 @@
+#include "boost/variant.hpp"
 
 namespace adm {
   namespace detail {
-    /// Combine A and B using F is defined_in_both
-    template <bool defined_in_both,
-              template <typename A, typename B, typename Base> class F,
-              typename A, typename B, typename Base>
-    struct ApplyIfT;
+    /// get the first type parameter of a variant
+    template <typename V>
+    struct VariantFirstTypeT;
 
-    template <template <typename A, typename B, typename Base> class F,
-              typename A, typename B, typename Base>
-    struct ApplyIfT<false, F, A, B, Base> {
-      using type = Base;
+    template <typename T, typename... Ts>
+    struct VariantFirstTypeT<boost::variant<T, Ts...>> {
+      using type = T;
     };
 
-    template <template <typename A, typename B, typename Base> class F,
-              typename A, typename B, typename Base>
-    struct ApplyIfT<true, F, A, B, Base> {
-      using type = F<A, B, Base>;
-    };
+    template <typename V>
+    using VariantFirstType = typename VariantFirstTypeT<V>::type;
 
-    template <bool defined_in_both,
-              template <typename A, typename B, typename Base> class F,
-              typename A, typename B, typename Base>
-    using ApplyIf = typename ApplyIfT<defined_in_both, F, A, B, Base>::type;
+    // HasParameters implementation
 
     /// subclass of A and B
     template <typename A, typename B>
     struct CombineRaw : public A, public B {};
+
+    /// a subclass of Base, with using declarations for set, get and has in A
+    /// and B
+    template <typename A, typename B, typename Base>
+    struct CombineGetSetHas : public Base {
+      using A::get;
+      using B::get;
+
+      using A::set;
+      using B::set;
+
+      using A::has;
+      using B::has;
+    };
+
+    /// a subclass of A and B, with using declarations for set, get and has
+    template <typename A, typename B>
+    struct CombineGetSetHasB : public A, public B {
+      using A::get;
+      using B::get;
+
+      using A::set;
+      using B::set;
+
+      using A::has;
+      using B::has;
+    };
+
+    /// a subclass of Base, with using declarations for isDefault and unset in A
+    /// and B
+    template <typename A, typename B, typename Base>
+    struct CombineIsDefaultUnset : public Base {
+      using A::isDefault;
+      using B::isDefault;
+
+      using A::unset;
+      using B::unset;
+    };
+
+    /// a subclass of A and B, with using declarations for isDefault and unset
+    template <typename A, typename B>
+    struct CombineIsDefaultUnsetB : public A, public B {
+      using A::isDefault;
+      using B::isDefault;
+
+      using A::unset;
+      using B::unset;
+    };
+
+    /// a subclass of Base, with using declarations for add and remove in A and
+    /// B
+    template <typename A, typename B, typename Base>
+    struct CombineAddRemove : public Base {
+      using A::add;
+      using B::add;
+
+      using A::remove;
+      using B::remove;
+    };
+
+    /// a subclass of A and B, with using declarations for add and remove
+    template <typename A, typename B>
+    struct CombineAddRemoveB : public A, public B {
+      using A::add;
+      using B::add;
+
+      using A::remove;
+      using B::remove;
+    };
+
+    /// helper to combine any number of Parameter classes
+    ///
+    /// this is seperate from Combine so that for one Base (the base case) the
+    /// class can be returned directly without subclassesg
+    template <typename... Bases>
+    struct HasParametersT;
+
+    /// make a base class for Combine which chains the Combine classes
+    template <typename A, typename... Tail>
+    struct MakeCombineBase {
+      using Base = typename HasParametersT<Tail...>::type;
+
+      // need to combine if both bases have the same methods
+      using combine_add_remove =
+          std::integral_constant<bool, typename A::has_add_remove() &&
+                                           typename Base::has_add_remove()>;
+      using combine_get_set_has =
+          std::integral_constant<bool, typename A::has_get_set_has() &&
+                                           typename Base::has_get_set_has()>;
+      using combine_isDefault_unset =
+          std::integral_constant<bool,
+                                 typename A::has_isDefault_unset() &&
+                                     typename Base::has_isDefault_unset()>;
+
+      // chain up to three Combine* classes for the above parameters
+      //
+      // the rules for these are:
+      // - if paramers need combining, then
+      //   - if it's the last in the chain, use Combine*B to inherit from A and Base
+      //   - otherwise, use Combine* with A and Base, inheriting from the next class in the chain
+      // - otherwise use the next class in the chain (ot CombineRaw)
+
+      using IsDefaultUnsetCombined =
+          std::conditional_t<combine_isDefault_unset::value,
+                             CombineIsDefaultUnsetB<A, Base>,
+                             CombineRaw<A, Base>>;
+
+      using GetSetHasCombined = std::conditional_t<
+          combine_get_set_has::value,
+          std::conditional_t<!combine_isDefault_unset::value,
+                             CombineGetSetHasB<A, Base>,
+                             CombineGetSetHas<A, Base, IsDefaultUnsetCombined>>,
+          IsDefaultUnsetCombined>;
+
+      using AddRemoveCombined = std::conditional_t<
+          combine_add_remove::value,
+          std::conditional_t<!(combine_isDefault_unset::value ||
+                               combine_get_set_has::value),
+                             CombineAddRemoveB<A, Base>,
+                             CombineAddRemove<A, Base, GetSetHasCombined>>,
+          GetSetHasCombined>;
+
+      using type = AddRemoveCombined;
+    };
+
+    /// a subclass of at least two Parameter classes, with methods according to
+    /// their Flags
+    template <typename A, typename... Tail>
+    struct Combine : public MakeCombineBase<A, Tail...>::type {
+     private:
+      using Base = typename HasParametersT<Tail...>::type;
+
+     public:
+      using has_get_set_has =
+          std::integral_constant<bool, typename A::has_get_set_has() ||
+                                           typename Base::has_get_set_has()>;
+      using has_isDefault_unset =
+          std::integral_constant<bool,
+                                 typename A::has_isDefault_unset() ||
+                                     typename Base::has_isDefault_unset()>;
+      using has_add_remove =
+          std::integral_constant<bool, typename A::has_add_remove() ||
+                                           typename Base::has_add_remove()>;
+    };
+
+    template <typename Ba, typename Bb, typename... BTail>
+    struct HasParametersT<Ba, Bb, BTail...> {
+      using type = Combine<Ba, Bb, BTail...>;
+    };
+
+    template <typename B>
+    struct HasParametersT<B> {
+      using type = B;
+    };
+
+    // VariantTypeParameter implementation
+
+    template <typename VariantParam, typename T>
+    class VariantTypeParameter;
+
+    /// implementation of VariantTypeParameterBase, called with the variant
+    /// parameter type, the current type of the variant to find the base for,
+    /// and the list of types in the variant
+    ///
+    /// This finds T in Ts, and returns a VariantTypeParameter with the next
+    /// type in the list, or P
+    template <typename VariantParam, typename T, typename...>
+    struct VariantTypeParameterBaseT;
+
+    /// base case: for the last type, inherit from VariantParam
+    template <typename VariantParam, typename T, typename Last>
+    struct VariantTypeParameterBaseT<VariantParam, T, Last> {
+      using type = VariantParam;
+    };
+
+    /// recursive case
+    template <typename VariantParam, typename T, typename Current,
+              typename Next, typename... Rest>
+    struct VariantTypeParameterBaseT<VariantParam, T, Current, Next, Rest...> {
+      // if the first type in the list is T, then return a VariantTypeParameter
+      // for the next type, otherwise remove one and recurse
+      using type =
+          std::conditional_t<std::is_same<T, Current>::value,
+                             VariantTypeParameter<VariantParam, Next>,
+                             typename VariantTypeParameterBaseT<
+                                 VariantParam, T, Next, Rest...>::type>;
+    };
+
+    /// wrapper around VariantTypeParameterBaseT which extracts the types from
+    /// the variant
+    template <typename VariantParam, typename T, typename Variant>
+    struct VariantTypeParameterBaseMatch;
+
+    template <typename VariantParam, typename T, typename... VariantTypes>
+    struct VariantTypeParameterBaseMatch<VariantParam, T,
+                                         boost::variant<VariantTypes...>> {
+      using type = typename VariantTypeParameterBaseT<VariantParam, T,
+                                                      VariantTypes...>::type;
+    };
+
+    /// the base type for VariantTypeParameter<P<variant<Ts...>>, T>
+    ///
+    /// This is a  VariantTypeParameter for the next type in Ts, or
+    /// P<variant<Ts...>>
+    template <typename VariantParam, typename T>
+    using VariantTypeParameterBase = typename VariantTypeParameterBaseMatch<
+        VariantParam, T, typename VariantParam::ParameterType>::type;
   }  // namespace detail
 }  // namespace adm
diff --git a/tests/auto_base_tests.cpp b/tests/auto_base_tests.cpp
index cd99d8e0..ca290de2 100644
--- a/tests/auto_base_tests.cpp
+++ b/tests/auto_base_tests.cpp
@@ -26,6 +26,16 @@ namespace adm {
   using Vectors = std::vector<Vector>;
   ADD_TRAIT(Vectors, VectorsTag);
 
+  struct VariantATag {};
+  using VariantA = detail::NamedType<int, VariantATag>;
+
+  struct VariantBTag {};
+  using VariantB = detail::NamedType<int, VariantBTag>;
+
+  struct VariantTag {};
+  using Variant = boost::variant<VariantA, VariantB>;
+  ADD_TRAIT(Variant, VariantTag);
+
   namespace detail {
     template <>
     Default getDefault<Default>() {
@@ -37,15 +47,18 @@ namespace adm {
     template class DefaultParameter<Default>;
     template class VectorParameter<Vectors>;
 
+    template class VariantTypeParameter<OptionalParameter<Variant>, VariantA>;
+    template class VariantTypeParameter<OptionalParameter<Variant>, VariantB>;
+    template class OptionalParameter<Variant>;
+
     using Base =
         HasParameters<RequiredParameter<Required>, OptionalParameter<Optional>,
-                      DefaultParameter<Default>, VectorParameter<Vectors>>;
+                      DefaultParameter<Default>, VectorParameter<Vectors>,
+                      VariantParameter<OptionalParameter<Variant>>>;
   };  // namespace detail
 
-  // standard wrapper around Base providing templated methods. not really
-  // needed for testing, but we might want to replace these with a template in
-  // the future, and this shows how it will typically be used.
-  struct TestElement : private detail::Base {
+  struct TestElement : private detail::Base,
+                       private detail::AddWrapperMethods<TestElement> {
     template <typename... Parameters>
     explicit TestElement(Parameters... namedArgs) {
       detail::setNamedOptionHelper(this, std::move(namedArgs)...);
@@ -55,35 +68,17 @@ namespace adm {
     using detail::Base::remove;
     using detail::Base::set;
 
-    template <typename Parameter>
-    Parameter get() const {
-      using Tag = typename detail::ParameterTraits<Parameter>::tag;
-      return get(Tag());
-    }
-
-    template <typename Parameter>
-    bool has() const {
-      using Tag = typename detail::ParameterTraits<Parameter>::tag;
-      return has(Tag());
-    }
-
-    template <typename Parameter>
-    bool isDefault() const {
-      using Tag = typename detail::ParameterTraits<Parameter>::tag;
-      return isDefault(Tag());
-    }
-
-    template <typename Parameter>
-    void unset() {
-      using Tag = typename detail::ParameterTraits<Parameter>::tag;
-      return unset(Tag());
-    }
+    using detail::AddWrapperMethods<TestElement>::get;
+    using detail::AddWrapperMethods<TestElement>::has;
+    using detail::AddWrapperMethods<TestElement>::unset;
+    using detail::AddWrapperMethods<TestElement>::isDefault;
 
    private:
     using detail::Base::get;
     using detail::Base::has;
     using detail::Base::isDefault;
     using detail::Base::unset;
+    friend class detail::AddWrapperMethods<TestElement>;
   };
 
 };  // namespace adm
@@ -166,3 +161,38 @@ TEST_CASE("vector") {
   REQUIRE(e.get<Vectors>() == Vectors{});
   REQUIRE(!e.isDefault<Vectors>());
 }
+
+TEST_CASE("variant") {
+  TestElement e;
+
+  REQUIRE(!e.has<Variant>());
+  REQUIRE(!e.has<VariantA>());
+  REQUIRE(!e.has<VariantB>());
+  REQUIRE(!e.isDefault<Variant>());
+
+  e.set(Variant{VariantA{5}});
+  REQUIRE(boost::get<VariantA>(e.get<Variant>()) == VariantA{5});
+  REQUIRE(e.get<VariantA>() == VariantA{5});
+  REQUIRE(e.has<Variant>());
+  REQUIRE(e.has<VariantA>());
+  REQUIRE(!e.has<VariantB>());
+  REQUIRE(!e.isDefault<Variant>());
+  REQUIRE(!e.isDefault<VariantA>());
+
+  e.unset<VariantA>();
+  REQUIRE(!e.has<Variant>());
+  REQUIRE(!e.isDefault<Variant>());
+
+  e.set(Variant{VariantB{5}});
+  REQUIRE(boost::get<VariantB>(e.get<Variant>()) == VariantB{5});
+  REQUIRE(e.get<VariantB>() == VariantB{5});
+  REQUIRE(e.has<Variant>());
+  REQUIRE(e.has<VariantB>());
+  REQUIRE(!e.has<VariantA>());
+  REQUIRE(!e.isDefault<Variant>());
+  REQUIRE(!e.isDefault<VariantB>());
+
+  e.unset<VariantB>();
+  REQUIRE(!e.has<Variant>());
+  REQUIRE(!e.isDefault<Variant>());
+}

From 334927459df85ee673f281e994a9e154ecbceb0a Mon Sep 17 00:00:00 2001
From: Thomas Nixon <tom@tomn.co.uk>
Date: Thu, 17 Nov 2022 18:27:10 +0000
Subject: [PATCH 2/9] auto base: implement find_item manually

---
 include/adm/detail/auto_base.hpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/include/adm/detail/auto_base.hpp b/include/adm/detail/auto_base.hpp
index a6583bc9..30e8219b 100644
--- a/include/adm/detail/auto_base.hpp
+++ b/include/adm/detail/auto_base.hpp
@@ -211,10 +211,10 @@ namespace adm {
      private:
       T value_;
       ADM_BASE_EXPORT typename T::iterator find_item(Value const& item) {
-        return std::find_if(
-            value_.begin(), value_.end(), [&item](Value const& val) {
-              return ParameterCompare<Value>::compare(item, val);
-            });
+        auto it = value_.begin();
+        for (; it != value_.end(); it++)
+          if (ParameterCompare<Value>::compare(item, *it)) break;
+        return it;
       }
     };
 

From ad9a90f6008d40c4c6a8f016b78ec5ac116cfdf7 Mon Sep 17 00:00:00 2001
From: Thomas Nixon <tom@tomn.co.uk>
Date: Fri, 18 Nov 2022 10:38:27 +0000
Subject: [PATCH 3/9] move range validators to implementation file

---
 include/adm/detail/named_type_validators.hpp | 59 ++++++++++++++------
 src/CMakeLists.txt                           |  1 +
 src/detail/named_type_validators.cpp         | 10 ++++
 3 files changed, 54 insertions(+), 16 deletions(-)
 create mode 100644 src/detail/named_type_validators.cpp

diff --git a/include/adm/detail/named_type_validators.hpp b/include/adm/detail/named_type_validators.hpp
index ed97b267..21f1bfc9 100644
--- a/include/adm/detail/named_type_validators.hpp
+++ b/include/adm/detail/named_type_validators.hpp
@@ -3,6 +3,7 @@
 #include <sstream>
 #include <stdexcept>
 #include <string>
+#include "adm/export.h"
 
 namespace adm {
 
@@ -24,6 +25,45 @@ namespace adm {
 
   namespace detail {
 
+    /// helpers for range validation; this does not have the range as part of
+    /// the type, so reduces duplication
+    template <typename T>
+    struct ValidateRangeHelper {
+      static void validateRange(const T& value, int minValue, int maxValue) {
+        if (value > static_cast<T>(maxValue) ||
+            value < static_cast<T>(minValue)) {
+          std::stringstream msg;
+          msg << "'" << value << "'"
+              << " is not in range [" << minValue << "," << maxValue << "]";
+          throw OutOfRangeError(msg.str());
+        }
+      }
+
+      static void validateMin(const T& value, int minValue) {
+        if (value < static_cast<T>(minValue)) {
+          std::stringstream msg;
+          msg << "'" << value << "'' is not bigger than '" << minValue << "'";
+          throw OutOfRangeError(msg.str());
+        }
+      }
+
+      static void validateMax(const T& value, int maxValue) {
+        if (value > static_cast<T>(maxValue)) {
+          std::stringstream msg;
+          msg << "'" << value << "'' is not smaller than '" << maxValue << "'";
+          throw OutOfRangeError(msg.str());
+        }
+      }
+    };
+
+    extern template struct ADM_EXPORT_TEMPLATE_METHODS
+        ValidateRangeHelper<float>;
+    extern template struct ADM_EXPORT_TEMPLATE_METHODS
+        ValidateRangeHelper<double>;
+    extern template struct ADM_EXPORT_TEMPLATE_METHODS ValidateRangeHelper<int>;
+    extern template struct ADM_EXPORT_TEMPLATE_METHODS
+        ValidateRangeHelper<unsigned>;
+
     struct DefaultValidator {
       template <typename T>
       static void validate(const T&) {
@@ -35,12 +75,7 @@ namespace adm {
     struct RangeValidator {
       template <typename T>
       static void validate(const T& value) {
-        if (value > maxValue || value < minValue) {
-          std::stringstream msg;
-          msg << "'" << value << "'"
-              << " is not in range [" << minValue << "," << maxValue << "]";
-          throw OutOfRangeError(msg.str());
-        }
+        ValidateRangeHelper<T>::validateRange(value, minValue, maxValue);
       }
     };
 
@@ -48,11 +83,7 @@ namespace adm {
     struct MinValidator {
       template <typename T>
       static void validate(const T& value) {
-        if (value < minValue) {
-          std::stringstream msg;
-          msg << "'" << value << "'' is not bigger than '" << minValue << "'";
-          throw OutOfRangeError(msg.str());
-        }
+        ValidateRangeHelper<T>::validateMin(value, minValue);
       }
     };
 
@@ -60,11 +91,7 @@ namespace adm {
     struct MaxValidator {
       template <typename T>
       static void validate(const T& value) {
-        if (value > maxValue) {
-          std::stringstream msg;
-          msg << "'" << value << "'' is not smaller than '" << maxValue << "'";
-          throw OutOfRangeError(msg.str());
-        }
+        ValidateRangeHelper<T>::validateMax(value, maxValue);
       }
     };
 
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 931a0dfb..998e9151 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -64,6 +64,7 @@ add_library(adm
   private/xml_writer.cpp
   private/xml_parser.cpp
   detail/id_assigner.cpp
+  detail/named_type_validators.cpp
   parse.cpp
   write.cpp
   ${CMAKE_CURRENT_BINARY_DIR}/resources.hpp
diff --git a/src/detail/named_type_validators.cpp b/src/detail/named_type_validators.cpp
new file mode 100644
index 00000000..d2e3138c
--- /dev/null
+++ b/src/detail/named_type_validators.cpp
@@ -0,0 +1,10 @@
+#include <adm/detail/named_type_validators.hpp>
+
+namespace adm {
+  namespace detail {
+    template struct ValidateRangeHelper<float>;
+    template struct ValidateRangeHelper<double>;
+    template struct ValidateRangeHelper<int>;
+    template struct ValidateRangeHelper<unsigned>;
+  }  // namespace detail
+}  // namespace adm

From 353989e682acf366b2d82c4b206ae2518ae02c1b Mon Sep 17 00:00:00 2001
From: Thomas Nixon <tom@tomn.co.uk>
Date: Fri, 18 Nov 2022 11:41:15 +0000
Subject: [PATCH 4/9] don't use boost format in errors

---
 include/adm/errors.hpp |  1 -
 src/errors.cpp         | 24 +++++++++---------------
 2 files changed, 9 insertions(+), 16 deletions(-)

diff --git a/include/adm/errors.hpp b/include/adm/errors.hpp
index 323481ba..82f93680 100644
--- a/include/adm/errors.hpp
+++ b/include/adm/errors.hpp
@@ -1,6 +1,5 @@
 #pragma once
 #include <stdexcept>
-#include <boost/format.hpp>
 #include <boost/optional.hpp>
 #include <adm/elements/audio_object_id.hpp>
 #include <adm/elements/audio_channel_format_id.hpp>
diff --git a/src/errors.cpp b/src/errors.cpp
index e431fceb..4b8afe5e 100644
--- a/src/errors.cpp
+++ b/src/errors.cpp
@@ -1,5 +1,4 @@
 #include "adm/errors.hpp"
-#include <boost/format.hpp>
 
 namespace adm {
   namespace error {
@@ -20,10 +19,9 @@ namespace adm {
     std::string AudioTrackUidMutuallyExclusiveReferences::formatMessage(
         AudioChannelFormatId audioChannelFormatRef,
         AudioTrackFormatId audioTrackFormatRef) const {
-      return boost::str(boost::format("Mutually-exclusive AudioTrackUid "
-                                      "references detected: %1% and %2%") %
-                        formatId(audioChannelFormatRef) %
-                        formatId(audioTrackFormatRef));
+      return "Mutually-exclusive AudioTrackUid references detected: " +
+             formatId(audioChannelFormatRef) + " and " +
+             formatId(audioTrackFormatRef);
     }
 
     AudioObjectReferenceCycle::AudioObjectReferenceCycle(
@@ -32,10 +30,8 @@ namespace adm {
 
     std::string AudioObjectReferenceCycle::formatMessage(
         AudioObjectId referent, AudioObjectId reference) const {
-      return boost::str(
-          boost::format(
-              "Cyclic AudioObject reference detected from %1% to %2%") %
-          formatId(referent) % formatId(reference));
+      return "Cyclic AudioObject reference detected from " +
+             formatId(referent) + " to " + formatId(reference);
     }
 
     XmlParsingError::XmlParsingError(const std::string& message,
@@ -48,7 +44,7 @@ namespace adm {
     std::string XmlParsingError::formatMessage(
         const std::string& message, boost::optional<int> line) const {
       if (line) {
-        return boost::str(boost::format("%1% (:%2%)") % message % line.get());
+        return message + " (:" + std::to_string(line.get()) + ")";
       } else {
         return message;
       }
@@ -59,7 +55,7 @@ namespace adm {
         : XmlParsingError(formatMessage(id), line) {}
 
     std::string XmlParsingDuplicateId::formatMessage(const std::string& id) {
-      return boost::str(boost::format("Duplicate Id %1% found") % id);
+      return "Duplicate Id " + id + " found";
     }
 
     XmlParsingUnresolvedReference::XmlParsingUnresolvedReference(
@@ -68,7 +64,7 @@ namespace adm {
 
     std::string XmlParsingUnresolvedReference::formatMessage(
         const std::string& id) {
-      return boost::str(boost::format("Id %1% could not be resolved") % id);
+      return "Id " + id + " could not be resolved";
     }
 
     XmlParsingUnexpectedAttrError::XmlParsingUnexpectedAttrError(
@@ -78,9 +74,7 @@ namespace adm {
 
     std::string XmlParsingUnexpectedAttrError::formatMessage(
         const std::string& attr, const std::string& value) {
-      return boost::str(
-          boost::format("Unexpected value \"%2%\" found in attribute %1%") %
-          attr % value);
+      return "Unexpected value \"" + value + "\" found in attribute " + attr;
     }
 
   }  // namespace error

From 4638f517eed4d6e78f8d10f1ed251c099cde3823 Mon Sep 17 00:00:00 2001
From: Thomas Nixon <tom@tomn.co.uk>
Date: Fri, 18 Nov 2022 12:04:13 +0000
Subject: [PATCH 5/9] don't use boost::format for timecode parsing

---
 src/elements/time.cpp    | 21 ++++++++++++---------
 tests/adm_time_tests.cpp |  2 ++
 2 files changed, 14 insertions(+), 9 deletions(-)

diff --git a/src/elements/time.cpp b/src/elements/time.cpp
index d4ca738e..c55e6c99 100644
--- a/src/elements/time.cpp
+++ b/src/elements/time.cpp
@@ -1,6 +1,5 @@
 #include "adm/elements/time.hpp"
 #include <boost/integer/common_factor.hpp>
-#include <boost/format.hpp>
 #include <iomanip>
 #include <regex>
 #include <sstream>
@@ -43,22 +42,26 @@ namespace adm {
   }
 
   Time parseTimecode(const std::string& timecode) {
-    const static std::regex commonFormat(
-        "(\\d{2}):(\\d{2}):(\\d{2}).(\\d{1,9})");
+    const static std::regex commonFormat("(\\d{2}):(\\d{2}):(\\d{2}).(\\d+)");
     const static std::regex fractionalFormat(
         "(\\d{2}):(\\d{2}):(\\d{2}).(\\d+)S(\\d+)");
 
     std::smatch timecodeMatch;
     if (std::regex_match(timecode, timecodeMatch, commonFormat)) {
-      // add trailing zeros to string
-      auto nanoseconds =
-          boost::str(boost::format("%1%") %
-                     boost::io::group(std::setw(9), std::left,
-                                      std::setfill('0'), timecodeMatch[4]));
+      // parse number of nanoseconds as if it always had 9 digits
+      const std::string& ns_str = timecodeMatch[4];
+      int ns;
+      if (ns_str.size() > 9)
+        ns = stoi(ns_str.substr(0, 9));
+      else {
+        ns = stoi(ns_str);
+        for (size_t i = ns_str.size(); i < 9; i++) ns *= 10;
+      }
+
       return std::chrono::hours(stoi(timecodeMatch[1])) +
              std::chrono::minutes(stoi(timecodeMatch[2])) +
              std::chrono::seconds(stoi(timecodeMatch[3])) +
-             std::chrono::nanoseconds(stoi(nanoseconds));
+             std::chrono::nanoseconds(ns);
     } else if (std::regex_match(timecode, timecodeMatch, fractionalFormat)) {
       int64_t seconds = 3600 * stoi(timecodeMatch[1]) +
                         60 * stoi(timecodeMatch[2]) +
diff --git a/tests/adm_time_tests.cpp b/tests/adm_time_tests.cpp
index 2e325b44..fe932881 100644
--- a/tests/adm_time_tests.cpp
+++ b/tests/adm_time_tests.cpp
@@ -27,6 +27,8 @@ TEST_CASE("adm_time") {
             Time(std::chrono::nanoseconds(100000000)));
     REQUIRE(parseTimecode("00:00:00.000000001") ==
             Time(std::chrono::nanoseconds(1)));
+    REQUIRE(parseTimecode("00:00:00.0000000010") ==
+            Time(std::chrono::nanoseconds(1)));
   }
 
   // check fractional

From c3772acd4c5adffd557a25a46c68e51231670786 Mon Sep 17 00:00:00 2001
From: Thomas Nixon <tom@tomn.co.uk>
Date: Fri, 18 Nov 2022 15:31:02 +0000
Subject: [PATCH 6/9] add missing header

---
 include/adm/elements/audio_pack_format_hoa.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/include/adm/elements/audio_pack_format_hoa.hpp b/include/adm/elements/audio_pack_format_hoa.hpp
index 9749f55f..76cf17f1 100644
--- a/include/adm/elements/audio_pack_format_hoa.hpp
+++ b/include/adm/elements/audio_pack_format_hoa.hpp
@@ -1,6 +1,7 @@
 /// @file audio_pack_format_hoa.hpp
 #pragma once
 
+#include "adm/elements/common_parameters.hpp"
 #include "adm/elements/screen_ref.hpp"
 #include "adm/elements/normalization.hpp"
 #include "adm/elements/nfc_ref_dist.hpp"

From dbc1ce4170b3db365d7dba3aa9634d3508099d17 Mon Sep 17 00:00:00 2001
From: Thomas Nixon <tom@tomn.co.uk>
Date: Mon, 21 Nov 2022 14:21:08 +0000
Subject: [PATCH 7/9] export named type validator exceptions

---
 include/adm/detail/named_type_validators.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/include/adm/detail/named_type_validators.hpp b/include/adm/detail/named_type_validators.hpp
index 21f1bfc9..04984e53 100644
--- a/include/adm/detail/named_type_validators.hpp
+++ b/include/adm/detail/named_type_validators.hpp
@@ -7,17 +7,17 @@
 
 namespace adm {
 
-  struct OutOfRangeError : public std::runtime_error {
+  struct ADM_EXPORT OutOfRangeError : public std::runtime_error {
     explicit OutOfRangeError(const char* msg) : std::runtime_error(msg) {}
     explicit OutOfRangeError(const std::string& msg)
         : std::runtime_error(msg) {}
   };
-  struct InvalidValueError : public std::runtime_error {
+  struct ADM_EXPORT InvalidValueError : public std::runtime_error {
     explicit InvalidValueError(const char* msg) : std::runtime_error(msg) {}
     explicit InvalidValueError(const std::string& msg)
         : std::runtime_error(msg) {}
   };
-  struct InvalidStringError : public std::runtime_error {
+  struct ADM_EXPORT InvalidStringError : public std::runtime_error {
     explicit InvalidStringError(const char* msg) : std::runtime_error(msg) {}
     explicit InvalidStringError(const std::string& msg)
         : std::runtime_error(msg) {}

From 7dd90c91b5471e1db70d8961b309fa5259e3fe50 Mon Sep 17 00:00:00 2001
From: Thomas Nixon <tom@tomn.co.uk>
Date: Mon, 21 Nov 2022 17:38:33 +0000
Subject: [PATCH 8/9] don't force spilling to stack in range validators

---
 include/adm/detail/named_type_validators.hpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/include/adm/detail/named_type_validators.hpp b/include/adm/detail/named_type_validators.hpp
index 04984e53..af11b31e 100644
--- a/include/adm/detail/named_type_validators.hpp
+++ b/include/adm/detail/named_type_validators.hpp
@@ -29,7 +29,7 @@ namespace adm {
     /// the type, so reduces duplication
     template <typename T>
     struct ValidateRangeHelper {
-      static void validateRange(const T& value, int minValue, int maxValue) {
+      static void validateRange(T value, int minValue, int maxValue) {
         if (value > static_cast<T>(maxValue) ||
             value < static_cast<T>(minValue)) {
           std::stringstream msg;
@@ -39,7 +39,7 @@ namespace adm {
         }
       }
 
-      static void validateMin(const T& value, int minValue) {
+      static void validateMin(T value, int minValue) {
         if (value < static_cast<T>(minValue)) {
           std::stringstream msg;
           msg << "'" << value << "'' is not bigger than '" << minValue << "'";
@@ -47,7 +47,7 @@ namespace adm {
         }
       }
 
-      static void validateMax(const T& value, int maxValue) {
+      static void validateMax(T value, int maxValue) {
         if (value > static_cast<T>(maxValue)) {
           std::stringstream msg;
           msg << "'" << value << "'' is not smaller than '" << maxValue << "'";
@@ -74,7 +74,7 @@ namespace adm {
     template <int minValue, int maxValue>
     struct RangeValidator {
       template <typename T>
-      static void validate(const T& value) {
+      static void validate(T value) {
         ValidateRangeHelper<T>::validateRange(value, minValue, maxValue);
       }
     };
@@ -82,7 +82,7 @@ namespace adm {
     template <int minValue>
     struct MinValidator {
       template <typename T>
-      static void validate(const T& value) {
+      static void validate(T value) {
         ValidateRangeHelper<T>::validateMin(value, minValue);
       }
     };
@@ -90,7 +90,7 @@ namespace adm {
     template <int maxValue>
     struct MaxValidator {
       template <typename T>
-      static void validate(const T& value) {
+      static void validate(T value) {
         ValidateRangeHelper<T>::validateMax(value, maxValue);
       }
     };

From b8ba39e40af29ee5288e3d25391009d479f9a18c Mon Sep 17 00:00:00 2001
From: Thomas Nixon <tom@tomn.co.uk>
Date: Mon, 21 Nov 2022 18:32:10 +0000
Subject: [PATCH 9/9] don't use getElements in lookupById

---
 include/adm/utilities/lookup.hpp |  4 ++--
 src/document.cpp                 | 32 ++++++++++++++++----------------
 2 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/include/adm/utilities/lookup.hpp b/include/adm/utilities/lookup.hpp
index 4cdab26a..3b557962 100644
--- a/include/adm/utilities/lookup.hpp
+++ b/include/adm/utilities/lookup.hpp
@@ -20,8 +20,8 @@ namespace adm {
     return elements;
   }
 
-  template <typename Element, typename ElementId, typename ElementRange>
-  std::shared_ptr<Element> lookupById(const ElementRange& range,
+  template <typename Element, typename ElementId, typename Elements>
+  std::shared_ptr<Element> lookupById(const Elements& range,
                                       const ElementId& id) {
     for (auto& element : range) {
       if (element->template get<ElementId>() == id) {
diff --git a/src/document.cpp b/src/document.cpp
index 58099975..98ebc68a 100644
--- a/src/document.cpp
+++ b/src/document.cpp
@@ -400,76 +400,76 @@ namespace adm {
 
   // ---- lookup elements ---- //
   std::shared_ptr<AudioProgramme> Document::lookup(const AudioProgrammeId& id) {
-    return lookupById<AudioProgramme>(getElements<AudioProgramme>(), id);
+    return lookupById<AudioProgramme>(audioProgrammes_, id);
   }
   std::shared_ptr<const AudioProgramme> Document::lookup(
       const AudioProgrammeId& id) const {
-    return lookupById<const AudioProgramme>(getElements<AudioProgramme>(), id);
+    return lookupById<const AudioProgramme>(audioProgrammes_, id);
   }
 
   std::shared_ptr<AudioContent> Document::lookup(const AudioContentId& id) {
-    return lookupById<AudioContent>(getElements<AudioContent>(), id);
+    return lookupById<AudioContent>(audioContents_, id);
   }
   std::shared_ptr<const AudioContent> Document::lookup(
       const AudioContentId& id) const {
-    return lookupById<const AudioContent>(getElements<AudioContent>(), id);
+    return lookupById<const AudioContent>(audioContents_, id);
   }
 
   std::shared_ptr<AudioObject> Document::lookup(const AudioObjectId& id) {
-    return lookupById<AudioObject>(getElements<AudioObject>(), id);
+    return lookupById<AudioObject>(audioObjects_, id);
   }
   std::shared_ptr<const AudioObject> Document::lookup(
       const AudioObjectId& id) const {
-    return lookupById<const AudioObject>(getElements<AudioObject>(), id);
+    return lookupById<const AudioObject>(audioObjects_, id);
   }
 
   std::shared_ptr<AudioPackFormat> Document::lookup(
       const AudioPackFormatId& id) {
-    return lookupById<AudioPackFormat>(getElements<AudioPackFormat>(), id);
+    return lookupById<AudioPackFormat>(audioPackFormats_, id);
   }
   std::shared_ptr<const AudioPackFormat> Document::lookup(
       const AudioPackFormatId& id) const {
-    return lookupById<const AudioPackFormat>(getElements<AudioPackFormat>(),
+    return lookupById<const AudioPackFormat>(audioPackFormats_,
                                              id);
   }
 
   std::shared_ptr<AudioChannelFormat> Document::lookup(
       const AudioChannelFormatId& id) {
-    return lookupById<AudioChannelFormat>(getElements<AudioChannelFormat>(),
+    return lookupById<AudioChannelFormat>(audioChannelFormats_,
                                           id);
   }
   std::shared_ptr<const AudioChannelFormat> Document::lookup(
       const AudioChannelFormatId& id) const {
     return lookupById<const AudioChannelFormat>(
-        getElements<const AudioChannelFormat>(), id);
+        audioChannelFormats_, id);
   }
 
   std::shared_ptr<AudioStreamFormat> Document::lookup(
       const AudioStreamFormatId& id) {
-    return lookupById<AudioStreamFormat>(getElements<AudioStreamFormat>(), id);
+    return lookupById<AudioStreamFormat>(audioStreamFormats_, id);
   }
   std::shared_ptr<const AudioStreamFormat> Document::lookup(
       const AudioStreamFormatId& id) const {
-    return lookupById<const AudioStreamFormat>(getElements<AudioStreamFormat>(),
+    return lookupById<const AudioStreamFormat>(audioStreamFormats_,
                                                id);
   }
 
   std::shared_ptr<AudioTrackFormat> Document::lookup(
       const AudioTrackFormatId& id) {
-    return lookupById<AudioTrackFormat>(getElements<AudioTrackFormat>(), id);
+    return lookupById<AudioTrackFormat>(audioTrackFormats_, id);
   }
   std::shared_ptr<const AudioTrackFormat> Document::lookup(
       const AudioTrackFormatId& id) const {
-    return lookupById<const AudioTrackFormat>(getElements<AudioTrackFormat>(),
+    return lookupById<const AudioTrackFormat>(audioTrackFormats_,
                                               id);
   }
 
   std::shared_ptr<AudioTrackUid> Document::lookup(const AudioTrackUidId& id) {
-    return lookupById<AudioTrackUid>(getElements<AudioTrackUid>(), id);
+    return lookupById<AudioTrackUid>(audioTrackUids_, id);
   }
   std::shared_ptr<const AudioTrackUid> Document::lookup(
       const AudioTrackUidId& id) const {
-    return lookupById<const AudioTrackUid>(getElements<AudioTrackUid>(), id);
+    return lookupById<const AudioTrackUid>(audioTrackUids_, id);
   }
 
   template <typename Element>