Merge branch 'master' into openvdb_cmd

Author: danrbailey

openvdb/openvdb/TypeList.h

@@ -112,36 +112,85 @@ struct TSHasTypeImpl<TypeList<T, Ts...>, T, Idx>
 };
 
 
-/// @brief    Remove any duplicate types from a @c TypeList.
-/// @details  This implementation effectively rebuilds a @c TypeList by starting
-///           with an empty @c TypeList and recursively defining an expanded
-///           @c TypeList for every type (first to last), only if the type does
-///           not already exist in the new @c TypeList. This has the effect of
-///           dropping all but the first of duplicate types.
-/// @note     Each type must define a new instantiation of this object.
-/// @tparam ListT The starting @c TypeList, usually (but not limited to) an
-///               empty @c TypeList
-/// @tparam Ts    The list of types to make unique
-template <typename ListT, typename... Ts>
-struct TSMakeUniqueImpl {
-    using type = ListT;
+/// @brief  Similar to TsAppendImpl but only appends types to a list if the
+///   type does not alreay exist in the list.
+/// @details Defines a new @c TypeList with non-unique types appended
+/// @tparam U      Type to append
+/// @tparam ListT  The @c TypeList to append to
+template <typename U, typename ListT,
+  bool ListContainsType = TSHasTypeImpl<ListT, U>::Value>
+struct TSAppendUniqueImpl;
+
+/// @brief  Partial specialization where the currently evaluating type @c U in
+///   a @c TypeList already exists in the list. Returns the unmodified list.
+/// @tparam U  Type to append
+/// @tparam Ts Other types within the @c TypeList
+template <typename U, typename... Ts>
+struct TSAppendUniqueImpl<U, TypeList<Ts...>, true> {
+private:
+    using RemovedU = typename TypeList<Ts...>::template Remove<U>;
+public:
+    /// @note  It's simpler to remove the current type U and append the rest by
+    ///   just having "using type = TypeList<Ts...>". However this ends up with
+    ///   with keeping the last seen type rather than the first which this
+    ///   method historically did. e.g:
+    ///      TypeList<float, int, float>::Unique<> can become:
+    ///        a)  TypeList<float, int>  currently
+    ///        b)  TypeList<int, float>  if we used the afformentioned technique
+    ///  Might be useful to have both? Complexity in (a) is currently linear so
+    ///  this shouldn't be a problem, but be careful this doesn't change.
+    //using type = TypeList<Ts...>;
+    using type = typename TypeList<U>::template Append<RemovedU>;
+};
+
+/// @brief  Partial specialization where the currently evaluating type @c U in
+///   a @c TypeList does not exists in the list. Returns the appended list.
+/// @tparam U  Type to append
+/// @tparam Ts Other types within the @c TypeList
+template <typename U, typename... Ts>
+struct TSAppendUniqueImpl<U, TypeList<Ts...>, false> {
+    using type = TypeList<U, Ts...>;
+};
+
+/// @brief    Reconstruct a @c TypeList containing only unique types.
+/// @details  This implementation effectively rebuilds a @c TypeList by
+///   starting with an empty @c TypeList and recursively defining an expanded
+///   @c TypeList for every type (first to last), only if the type does not
+///   already exist in the new @c TypeList. This has the effect of dropping all
+///   but the first of duplicate types.
+/// @warning  This implementation previously used an embdedded std::conditional
+///   which resulted in drastically slow compilation times. If you're changing
+///   this implementation make sure to profile compile times with larger lists.
+/// @tparam Ts Types within the @c TypeList
+template <typename... Ts>
+struct TSRecurseAppendUniqueImpl;
+
+/// @brief  Terminate type recursion when the end of a @c TypeList is reached.
+template <>
+struct TSRecurseAppendUniqueImpl<> {
+    using type = TypeList<>;
+};
+
+/// @brief  Merge and unpack an initial @c TypeList from the first argument if
+///   such a @c TypeList has been provided.
+/// @tparam Ts      Types within the first @c TypeList
+/// @tparam OtherTs Other types
+template <typename... Ts, typename... OtherTs>
+struct TSRecurseAppendUniqueImpl<TypeList<Ts...>, OtherTs...> {
+    using type = typename TSRecurseAppendUniqueImpl<OtherTs..., Ts...>::type;
 };
 
-/// @brief  Partial specialization for type packs, where by the next type @c U
-///         is checked in the existing type set @c Ts for duplication. If the
-///         type does not exist, it is added to the new @c TypeList definition,
-///         otherwise it is dropped. In either case, this class is recursively
-///         defined with the remaining types @c Us.
-/// @tparam Ts  Current types in the @c TypeList
-/// @tparam U   Type to check for duplication in @c Ts
-/// @tparam Us  Remaining types
-template <typename... Ts, typename U, typename... Us>
-struct TSMakeUniqueImpl<TypeList<Ts...>, U, Us...>
+/// @brief  Recursively call TSRecurseAppendUniqueImpl with each type in the
+///   provided @c TypeLists, rebuilding a new list with only the unique set
+///   of types.
+/// @tparam U  Next type to check for uniqueness and append
+/// @tparam Ts Remaining types within the @c TypeList
+template <typename U, typename... Ts>
+struct TSRecurseAppendUniqueImpl<U, Ts...>
 {
-    using type = typename std::conditional<
-        TSHasTypeImpl<TypeList<Ts...>, U>::Value,
-        typename TSMakeUniqueImpl<TypeList<Ts...>, Us...>::type,
-        typename TSMakeUniqueImpl<TypeList<Ts..., U>, Us...>::type  >::type;
+    using type = typename TSAppendUniqueImpl<U,
+            typename TSRecurseAppendUniqueImpl<Ts...>::type
+        >::type;
 };
 
 
@@ -351,6 +400,10 @@ template<typename OpT> inline void TSForEachImpl(OpT) {}
 template<typename OpT, typename T, typename... Ts>
 inline void TSForEachImpl(OpT op) { op(T()); TSForEachImpl<OpT, Ts...>(op); }
 
+template<template <typename> class OpT> inline void TSForEachImpl() {}
+template<template <typename> class OpT, typename T, typename... Ts>
+inline void TSForEachImpl() { OpT<T>()(); TSForEachImpl<OpT, Ts...>(); }
+
 } // namespace internal
 
 /// @endcond
@@ -421,7 +474,7 @@ struct TypeList
     /// }
     /// @endcode
     template<typename ListT = TypeList<>>
-    using Unique = typename typelist_internal::TSMakeUniqueImpl<ListT, Ts...>::type;
+    using Unique = typename typelist_internal::TSRecurseAppendUniqueImpl<ListT, Ts...>::type;
 
     /// @brief Append types, or the members of another TypeList, to this list.
     /// @details Example:
@@ -499,6 +552,25 @@ struct TypeList
     template <size_t First, size_t Last>
     using RemoveByIndex = typename typelist_internal::TSRemoveIndicesImpl<Self, First, Last>::type;
 
+    /// @brief Invoke a templated class operator on each type in this list. Use
+    ///   this method if you only need access to the type for static methods.
+    /// @code
+    /// #include <typeinfo>
+    ///
+    /// template <typename T>
+    /// struct PintTypes() {
+    ///     inline void operator()() { std::cout << typeid(T).name() << std::endl; }
+    /// };
+    ///
+    /// using MyTypes = openvdb::TypeList<int, float, double>;
+    /// MyTypes::foreach<PintTypes>(); // "i, f, d" (exact output is compiler-dependent)
+    /// @endcode
+    ///
+    /// @note OpT must be a templated class. It is created and invoked for each
+    ///   type in this list.
+    template<template <typename> class OpT>
+    static void foreach() { typelist_internal::TSForEachImpl<OpT, Ts...>(); }
+
     /// @brief Invoke a templated, unary functor on a value of each type in this list.
     /// @details Example:
     /// @code

openvdb/openvdb/openvdb.cc

@@ -3,9 +3,7 @@
 
 #include "openvdb.h"
 #include "io/DelayedLoadMetadata.h"
-//#ifdef OPENVDB_ENABLE_POINTS
 #include "points/PointDataGrid.h"
-//#endif
 #include "tools/PointIndexGrid.h"
 #include "util/logging.h"
 
@@ -54,6 +52,11 @@ std::mutex sInitMutex;
 std::atomic<bool> sIsInitialized{false};
 }
 
+/// @todo  Change registerX() methods to simply be register()...
+template <typename GridT> struct RegisterGrid { inline void operator()() { GridT::registerGrid(); } };
+template <typename MetaT> struct RegisterMeta { inline void operator()() { MetaT::registerType(); } };
+template <typename MapT>  struct RegisterMap  { inline void operator()() { MapT::registerMap(); } };
+
 void
 initialize()
 {
@@ -65,65 +68,29 @@ initialize()
 
     // Register metadata.
     Metadata::clearRegistry();
-    BoolMetadata::registerType();
-    DoubleMetadata::registerType();
-    FloatMetadata::registerType();
-    Int32Metadata::registerType();
-    Int64Metadata::registerType();
-    StringMetadata::registerType();
-    Vec2IMetadata::registerType();
-    Vec2SMetadata::registerType();
-    Vec2DMetadata::registerType();
-    Vec3IMetadata::registerType();
-    Vec3SMetadata::registerType();
-    Vec3DMetadata::registerType();
-    Vec4IMetadata::registerType();
-    Vec4SMetadata::registerType();
-    Vec4DMetadata::registerType();
-    Mat4SMetadata::registerType();
-    Mat4DMetadata::registerType();
+    MetaTypes::foreach<RegisterMeta>();
 
     // Register maps
     math::MapRegistry::clear();
-    math::AffineMap::registerMap();
-    math::UnitaryMap::registerMap();
-    math::ScaleMap::registerMap();
-    math::UniformScaleMap::registerMap();
-    math::TranslationMap::registerMap();
-    math::ScaleTranslateMap::registerMap();
-    math::UniformScaleTranslateMap::registerMap();
-    math::NonlinearFrustumMap::registerMap();
+    MapTypes::foreach<RegisterMap>();
 
     // Register common grid types.
     GridBase::clearRegistry();
-    BoolGrid::registerGrid();
-    MaskGrid::registerGrid();
-    FloatGrid::registerGrid();
-    DoubleGrid::registerGrid();
-    Int32Grid::registerGrid();
-    Int64Grid::registerGrid();
+    GridTypes::foreach<RegisterGrid>();
+
     // @note String grids types are deprecated but we still register them
     //   as supported serializable types for backward compatibility. This
     //   will likely be removed in a future major version
 OPENVDB_NO_DEPRECATION_WARNING_BEGIN
     StringGrid::registerGrid();
 OPENVDB_NO_DEPRECATION_WARNING_END
-    Vec3IGrid::registerGrid();
-    Vec3SGrid::registerGrid();
-    Vec3DGrid::registerGrid();
 
     // Register types associated with point index grids.
     Metadata::registerType(typeNameAsString<PointIndex32>(), Int32Metadata::createMetadata);
     Metadata::registerType(typeNameAsString<PointIndex64>(), Int64Metadata::createMetadata);
-    tools::PointIndexGrid::registerGrid();
 
     // Register types associated with point data grids.
-//#ifdef OPENVDB_ENABLE_POINTS
     points::internal::initialize();
-//#endif
-
-    // Register delay load metadata
-    io::DelayedLoadMetadata::registerType();
 
 #ifdef OPENVDB_USE_BLOSC
     blosc_init();
@@ -166,10 +133,7 @@ __pragma(warning(default:1711))
     Metadata::clearRegistry();
     GridBase::clearRegistry();
     math::MapRegistry::clear();
-
-//#ifdef OPENVDB_ENABLE_POINTS
     points::internal::uninitialize();
-//#endif
 
 #ifdef OPENVDB_USE_BLOSC
     // We don't want to destroy Blosc, because it might have been