From 027533a695b1a2a3413a6947e67ba94b51b651fc Mon Sep 17 00:00:00 2001
From: "Michael X. Grey" <grey@openrobotics.org>
Date: Tue, 7 Apr 2020 15:34:58 +0800
Subject: [PATCH 1/7] Remove the use of the aggregator

---
 include/ignition/physics/TemplateHelpers.hh   |  2 +-
 .../physics/detail/DeclareDerivedType.hh      |  4 +-
 .../ignition/physics/detail/FeatureList.hh    | 50 ++++++++++++++++---
 3 files changed, 47 insertions(+), 9 deletions(-)

diff --git a/include/ignition/physics/TemplateHelpers.hh b/include/ignition/physics/TemplateHelpers.hh
index 2f7a2b3d1..a184246c4 100644
--- a/include/ignition/physics/TemplateHelpers.hh
+++ b/include/ignition/physics/TemplateHelpers.hh
@@ -98,7 +98,7 @@ namespace ignition
     }; \
     \
     template <typename PolicyT, typename FeaturesT> \
-    using type = typename Implementation<InFeature, PolicyT, FeaturesT>::type; \
+    struct type : virtual Implementation<InFeature, PolicyT, FeaturesT>::type { }; \
   };
 
 #endif
diff --git a/include/ignition/physics/detail/DeclareDerivedType.hh b/include/ignition/physics/detail/DeclareDerivedType.hh
index 2825dc295..23595d499 100644
--- a/include/ignition/physics/detail/DeclareDerivedType.hh
+++ b/include/ignition/physics/detail/DeclareDerivedType.hh
@@ -41,10 +41,10 @@
     public: template <typename PolicyT, typename FeaturesT> \
     class Using : \
       public virtual ::ignition::physics::detail::ExtractAPI< \
-        Select ## Derived, FeaturesT>:: \
+        Select ## Derived, typename FeaturesT::FeatureTuple>:: \
             template type<PolicyT, FeaturesT>, \
       public virtual ::ignition::physics::detail::ExtractAPI< \
-        ::ignition::physics::detail:: Select ## Base, FeaturesT>:: \
+        ::ignition::physics::detail:: Select ## Base,  typename FeaturesT::FeatureTuple>:: \
             template type<PolicyT, FeaturesT> \
     { \
       public: using Identifier = Derived ## Identifier; \
diff --git a/include/ignition/physics/detail/FeatureList.hh b/include/ignition/physics/detail/FeatureList.hh
index bba4d2b3c..5d51daa81 100644
--- a/include/ignition/physics/detail/FeatureList.hh
+++ b/include/ignition/physics/detail/FeatureList.hh
@@ -364,12 +364,50 @@ namespace ignition
       };
 
       /////////////////////////////////////////////////
-      template <template<typename> class Selector, typename FeatureListT>
-      struct ExtractAPI
+      template<template<typename> class Selector, typename Feature>
+      struct SplitFeatures;
+
+      /////////////////////////////////////////////////
+      template <template<typename> class Selector, typename FeatureTuple>
+      struct ExtractAPI;
+
+      template <template<typename> class Selector, typename... Features>
+      struct ExtractAPI<Selector, std::tuple<Features...>>
       {
         public: template<typename... T>
         class type : public virtual
-            Aggregate<Selector, FeatureListT>::template type<T...> { };
+            SplitFeatures<Selector, Features>::template type<T...>... { };
+      };
+
+      /////////////////////////////////////////////////
+      template <template<typename> class Selector, typename Feature>
+      struct SplitFeatures
+      {
+        template <typename F, typename = ::ignition::physics::void_t<>>
+        struct Implementation
+        {
+          template <typename... T>
+          struct type :
+              virtual Selector<F>::template type<T...>,
+              virtual Implementation<typename F::RequiredFeatures>::template type<T...> { };
+        };
+
+        template <>
+        struct Implementation<void, ::ignition::physics::void_t<>>
+        {
+          template <typename... T>
+          using type = Empty;
+        };
+
+        template <typename F>
+        struct Implementation<F, ::ignition::physics::void_t<typename F::FeatureTuple>>
+        {
+          template <typename... T>
+          using type = typename ExtractAPI<Selector, typename F::FeatureTuple>::template type<T...>;
+        };
+
+        template <typename... T>
+        using type = typename Implementation<Feature>::template type<T...>;
       };
     }
 
@@ -464,7 +502,7 @@ namespace ignition
   } \
   template <typename PolicyT, typename FeaturesT> \
   class X : public ::ignition::physics::detail::ExtractAPI< \
-        detail::Select ## X, FeaturesT> \
+        detail::Select ## X, typename FeaturesT::FeatureTuple> \
           ::template type<PolicyT, FeaturesT>, \
       public virtual Entity<PolicyT, FeaturesT> \
   { \
@@ -527,12 +565,12 @@ namespace ignition
       struct ImplementationSelector
       {
         public: template <typename PolicyT>
-        using type = typename T::template Implementation<PolicyT>;
+        struct type : virtual T::template Implementation<PolicyT> { };
       };
 
       template <typename PolicyT, typename List>
       using ExtractImplementation =
-        typename ExtractAPI<ImplementationSelector, List>
+        typename ExtractAPI<ImplementationSelector, typename List::FeatureTuple>
             ::template type<PolicyT>;
     }
   }

From f42517c454837fbc17d90dcfb2103c1f5818185d Mon Sep 17 00:00:00 2001
From: "Michael X. Grey" <grey@openrobotics.org>
Date: Wed, 8 Apr 2020 13:49:05 +0800
Subject: [PATCH 2/7] Use flat and lean inheritance structure

---
 .../physics/detail/DeclareDerivedType.hh      |   4 +-
 .../ignition/physics/detail/FeatureList.hh    | 214 +++++++++++++++---
 src/FilterTuple_TEST.cc                       |   6 +-
 3 files changed, 185 insertions(+), 39 deletions(-)

diff --git a/include/ignition/physics/detail/DeclareDerivedType.hh b/include/ignition/physics/detail/DeclareDerivedType.hh
index 23595d499..2825dc295 100644
--- a/include/ignition/physics/detail/DeclareDerivedType.hh
+++ b/include/ignition/physics/detail/DeclareDerivedType.hh
@@ -41,10 +41,10 @@
     public: template <typename PolicyT, typename FeaturesT> \
     class Using : \
       public virtual ::ignition::physics::detail::ExtractAPI< \
-        Select ## Derived, typename FeaturesT::FeatureTuple>:: \
+        Select ## Derived, FeaturesT>:: \
             template type<PolicyT, FeaturesT>, \
       public virtual ::ignition::physics::detail::ExtractAPI< \
-        ::ignition::physics::detail:: Select ## Base,  typename FeaturesT::FeatureTuple>:: \
+        ::ignition::physics::detail:: Select ## Base, FeaturesT>:: \
             template type<PolicyT, FeaturesT> \
     { \
       public: using Identifier = Derived ## Identifier; \
diff --git a/include/ignition/physics/detail/FeatureList.hh b/include/ignition/physics/detail/FeatureList.hh
index 5d51daa81..2dbbf1186 100644
--- a/include/ignition/physics/detail/FeatureList.hh
+++ b/include/ignition/physics/detail/FeatureList.hh
@@ -172,7 +172,7 @@ namespace ignition
       class ExtractFeatures
           : public VerifyFeatures<F>
       {
-        public: using Result = std::tuple<F>;
+        public: using type = std::tuple<F>;
       };
 
       /// \private This specialization of ExtractFeatures is used to wipe away
@@ -182,7 +182,7 @@ namespace ignition
       class ExtractFeatures<std::tuple<F...>>
           : public VerifyFeatures<F...>
       {
-        public: using Result = std::tuple<F...>;
+        public: using type = std::tuple<F...>;
       };
 
       /// \private This specialization of ExtractFeatures is used to wipe away
@@ -195,7 +195,7 @@ namespace ignition
               void_t<typename SomeFeatureList::Features>>
           : public VerifyFeatures<typename SomeFeatureList::Features>
       {
-        public: using Result = typename SomeFeatureList::Features;
+        public: using type = typename SomeFeatureList::Features;
       };
 
       /// \private This specialization skips over any void entries. This allows
@@ -204,22 +204,30 @@ namespace ignition
       template <>
       class ExtractFeatures<void>
       {
-        public: using Result = std::tuple<>;
+        public: using type = std::tuple<>;
       };
 
       /////////////////////////////////////////////////
-      template <typename DiscardTuple, typename InputTuple>
+      template <typename DiscardTuple>
+      struct RedundantTupleFilter
+      {
+        template <typename T>
+        struct Apply : TupleContainsBase<T, DiscardTuple> { };
+      };
+
+      /////////////////////////////////////////////////
+      template <template <typename> class Filter, typename InputTuple>
       struct FilterTuple;
 
       /////////////////////////////////////////////////
-      template <typename DiscardTuple, typename... InputTypes>
-      struct FilterTuple<DiscardTuple, std::tuple<InputTypes...>>
+      template <template <typename> class Filter, typename... InputTypes>
+      struct FilterTuple<Filter, std::tuple<InputTypes...>>
       {
-        using Result = decltype(std::tuple_cat(
+        using type = decltype(std::tuple_cat(
             std::conditional_t<
               // If the input type is a base class of anything that should be
               // discared ...
-              TupleContainsBase<InputTypes, DiscardTuple>::value,
+              Filter<InputTypes>::value,
               // ... then we should leave it out of the final tuple ...
               std::tuple<>,
               // ... otherwise, include it.
@@ -228,6 +236,112 @@ namespace ignition
             >()...));
       };
 
+      /////////////////////////////////////////////////
+      template <typename DiscardTuple>
+      struct SubtractTuple
+      {
+        template <typename T>
+        using Filter =
+            typename RedundantTupleFilter<DiscardTuple>::template Apply<T>;
+
+        template <typename FromTuple>
+        struct From : FilterTuple<Filter, FromTuple> { };
+      };
+
+      /////////////////////////////////////////////////
+      template <typename InputTuple>
+      struct RemoveTupleRedundancies;
+
+      template <typename... InputTupleArgs>
+      struct RemoveTupleRedundancies<std::tuple<InputTupleArgs...>>
+      {
+        template <typename PartialResultInput, typename...>
+        struct Impl;
+
+        template <typename PartialResultInput>
+        struct Impl<PartialResultInput>
+        {
+          using type = std::tuple<>;
+        };
+
+        template <typename ParentResultInput, typename F1, typename... Others>
+        struct Impl<ParentResultInput, F1, Others...>
+        {
+          using PartialResult =
+              std::conditional_t<
+                TupleContainsBase<F1, ParentResultInput>::value,
+                std::tuple<>,
+                std::tuple<F1>
+              >;
+
+          using AggregateResult = decltype(std::tuple_cat(
+              ParentResultInput(), PartialResult()));
+
+          using type = decltype(std::tuple_cat(
+              PartialResult(),
+              typename Impl<AggregateResult, Others...>::type()));
+        };
+
+        using type = typename Impl<std::tuple<>, InputTupleArgs...>::type;
+      };
+      /////////////////////////////////////////////////
+      template <typename FeatureTuple, typename = void_t<>>
+      struct FlattenFeatures;
+
+      /////////////////////////////////////////////////
+      template <typename FeatureOrList, typename = void_t<>>
+      struct ExpandFeatures
+      {
+        using type = std::conditional_t<
+            std::is_void_v<typename FeatureOrList::RequiredFeatures>,
+            std::tuple<FeatureOrList>,
+            decltype(std::tuple_cat(
+              std::tuple<FeatureOrList>(),
+              typename FlattenFeatures<
+                typename FeatureOrList::RequiredFeatures>::type()))
+        >;
+      };
+
+      /////////////////////////////////////////////////
+      template <typename List>
+      struct ExpandFeatures<List, void_t<typename List::Features>>
+      {
+        using type = typename FlattenFeatures<typename List::Features>::type;
+      };
+
+      /////////////////////////////////////////////////
+      template <typename FeatureListT>
+      struct FlattenFeatures<FeatureListT, void_t<typename FeatureListT::FeatureTuple>>
+      {
+        using type =
+            typename FlattenFeatures<typename FeatureListT::FeatureTuple>::type;
+      };
+
+      /////////////////////////////////////////////////
+      template <typename... Features>
+      struct FlattenFeatures<std::tuple<Features...>, void_t<>>
+      {
+        using type = decltype(std::tuple_cat(
+            typename ExpandFeatures<Features>::type()...));
+      };
+
+      /////////////////////////////////////////////////
+      template <>
+      struct FlattenFeatures<void>
+      {
+        using type = std::tuple<>;
+      };
+
+      /////////////////////////////////////////////////
+      template <typename FeatureListT>
+      struct FlatLeanFeatureTuple
+      {
+        using type =
+          typename RemoveTupleRedundancies<
+            typename FlattenFeatures<typename FeatureListT::Features>::type
+          >::type;
+      };
+
       /////////////////////////////////////////////////
       /// \private CombineListsImpl provides the implementation of CombineLists.
       /// This helper implementation structure allows us to filter out repeated
@@ -238,7 +352,7 @@ namespace ignition
       template <typename PartialResultInput>
       struct CombineListsImpl<PartialResultInput>
       {
-        using Result = std::tuple<>;
+        using type = std::tuple<>;
       };
 
       template <typename ParentResultInput, typename F1, typename... Others>
@@ -247,28 +361,27 @@ namespace ignition
         // Add the features of the feature list F1, while filtering out any
         // repeated features.
         using InitialResult =
-            typename FilterTuple<
-              ParentResultInput,
-              typename ExtractFeatures<F1>::Result
-            >::Result;
+            typename SubtractTuple<ParentResultInput>
+            ::template From<typename ExtractFeatures<F1>::type>::type;
 
         // Add the features that are required by F1, while filtering out any
         // repeated features.
         using PartialResult = decltype(std::tuple_cat(
             InitialResult(),
-            typename FilterTuple<
-              decltype(std::tuple_cat(ParentResultInput(), InitialResult())),
-              typename ExtractFeatures<typename F1::RequiredFeatures>::Result
-            >::Result()));
+            typename SubtractTuple<
+              decltype(std::tuple_cat(ParentResultInput(), InitialResult()))>
+              ::template From<
+                typename ExtractFeatures<typename F1::RequiredFeatures>::type
+            >::type()));
 
         // Define the tuple that the child should use to filter its list
         using ChildFilter =
             decltype(std::tuple_cat(ParentResultInput(), PartialResult()));
 
         // Construct the final result
-        using Result = decltype(std::tuple_cat(
+        using type = decltype(std::tuple_cat(
             PartialResult(),
-            typename CombineListsImpl<ChildFilter, Others...>::Result()));
+            typename CombineListsImpl<ChildFilter, Others...>::type()));
       };
 
       /// \private CombineLists is used to take variadic lists of features,
@@ -280,7 +393,7 @@ namespace ignition
       struct CombineLists
       {
         public: using Result =
-            typename CombineListsImpl<std::tuple<>, FeatureLists...>::Result;
+            typename CombineListsImpl<std::tuple<>, FeatureLists...>::type;
       };
 
       /////////////////////////////////////////////////
@@ -368,28 +481,45 @@ namespace ignition
       struct SplitFeatures;
 
       /////////////////////////////////////////////////
-      template <template<typename> class Selector, typename FeatureTuple>
-      struct ExtractAPI;
-
-      template <template<typename> class Selector, typename... Features>
-      struct ExtractAPI<Selector, std::tuple<Features...>>
+      template <template<typename> class Selector, typename FeatureListT>
+      struct ExtractAPI
       {
-        public: template<typename... T>
-        class type : public virtual
-            SplitFeatures<Selector, Features>::template type<T...>... { };
+        template <typename FeatureTuple>
+        struct Impl;
+
+        template <typename... Features>
+        struct Impl<std::tuple<Features...>>
+        {
+          template <typename... T>
+          class type : public virtual
+              Selector<Features>::template type<T...>... { };
+        };
+
+        template <typename T>
+        struct Filter : std::is_same<Selector<T>, Empty> { };
+
+        template <typename... T>
+        using type =
+          typename Impl<
+            typename FilterTuple<
+              Filter,
+              typename FlatLeanFeatureTuple<FeatureListT>::type
+            >::type
+          >::template type<T...>;
       };
 
       /////////////////////////////////////////////////
       template <template<typename> class Selector, typename Feature>
       struct SplitFeatures
       {
+        template <typename, typename> struct WithRequiredFeatures;
+
         template <typename F, typename = ::ignition::physics::void_t<>>
         struct Implementation
         {
           template <typename... T>
-          struct type :
-              virtual Selector<F>::template type<T...>,
-              virtual Implementation<typename F::RequiredFeatures>::template type<T...> { };
+          using type = typename WithRequiredFeatures<
+              F, typename F::RequiredFeatures>::template type<T...>;
         };
 
         template <>
@@ -406,6 +536,22 @@ namespace ignition
           using type = typename ExtractAPI<Selector, typename F::FeatureTuple>::template type<T...>;
         };
 
+        template <typename F, typename R>
+        struct WithRequiredFeatures
+        {
+          template <typename... T>
+          struct type :
+              virtual Selector<F>::template type<T...>,
+              virtual Implementation<typename F::RequiredFeatures>::template type<T...> { };
+        };
+
+        template <typename F>
+        struct WithRequiredFeatures<F, void>
+        {
+          template <typename... T>
+          using type = typename Selector<F>::template type<T...>;
+        };
+
         template <typename... T>
         using type = typename Implementation<Feature>::template type<T...>;
       };
@@ -502,7 +648,7 @@ namespace ignition
   } \
   template <typename PolicyT, typename FeaturesT> \
   class X : public ::ignition::physics::detail::ExtractAPI< \
-        detail::Select ## X, typename FeaturesT::FeatureTuple> \
+        detail::Select ## X, FeaturesT> \
           ::template type<PolicyT, FeaturesT>, \
       public virtual Entity<PolicyT, FeaturesT> \
   { \
@@ -570,7 +716,7 @@ namespace ignition
 
       template <typename PolicyT, typename List>
       using ExtractImplementation =
-        typename ExtractAPI<ImplementationSelector, typename List::FeatureTuple>
+        typename ExtractAPI<ImplementationSelector, List>
             ::template type<PolicyT>;
     }
   }
diff --git a/src/FilterTuple_TEST.cc b/src/FilterTuple_TEST.cc
index 233b99327..a385800d1 100644
--- a/src/FilterTuple_TEST.cc
+++ b/src/FilterTuple_TEST.cc
@@ -27,10 +27,10 @@ class ClassD : public ClassB { };
 using Filter = std::tuple<ClassA, ClassD>;
 using Input = std::tuple<ClassB, ClassC, ClassD, ClassA>;
 
-using Result = ignition::physics::detail::FilterTuple<Filter, Input>::Result;
+using Result = ignition::physics::detail::SubtractTuple<Filter>::From<Input>::type;
 
 using UnfilteredResult =
-    ignition::physics::detail::FilterTuple<std::tuple<>, Input>::Result;
+    ignition::physics::detail::SubtractTuple<std::tuple<>>::From<Input>::type;
 
 TEST(FilterTuple_TEST, FilterTupleResult)
 {
@@ -46,7 +46,7 @@ TEST(FilterTuple_TEST, FilterTupleResult)
 
 using SingleCombineLists =
   ignition::physics::detail::CombineListsImpl<
-      std::tuple<>, ClassA>::Result;
+      std::tuple<>, ClassA>::type;
 
 using SingleCombineListsInitial =
   ignition::physics::detail::CombineListsImpl<

From 0c0103a0baa96d8954bafbfa01c7b1eecdfb5f85 Mon Sep 17 00:00:00 2001
From: "Michael X. Grey" <grey@openrobotics.org>
Date: Wed, 8 Apr 2020 16:12:11 +0800
Subject: [PATCH 3/7] Remove all unnecessary template instantiations

---
 include/ignition/physics/TemplateHelpers.hh   |  2 +-
 .../ignition/physics/detail/FeatureList.hh    | 83 ++++++++++++-------
 2 files changed, 56 insertions(+), 29 deletions(-)

diff --git a/include/ignition/physics/TemplateHelpers.hh b/include/ignition/physics/TemplateHelpers.hh
index a184246c4..2f7a2b3d1 100644
--- a/include/ignition/physics/TemplateHelpers.hh
+++ b/include/ignition/physics/TemplateHelpers.hh
@@ -98,7 +98,7 @@ namespace ignition
     }; \
     \
     template <typename PolicyT, typename FeaturesT> \
-    struct type : virtual Implementation<InFeature, PolicyT, FeaturesT>::type { }; \
+    using type = typename Implementation<InFeature, PolicyT, FeaturesT>::type; \
   };
 
 #endif
diff --git a/include/ignition/physics/detail/FeatureList.hh b/include/ignition/physics/detail/FeatureList.hh
index 2dbbf1186..f978febb5 100644
--- a/include/ignition/physics/detail/FeatureList.hh
+++ b/include/ignition/physics/detail/FeatureList.hh
@@ -255,6 +255,9 @@ namespace ignition
       template <typename... InputTupleArgs>
       struct RemoveTupleRedundancies<std::tuple<InputTupleArgs...>>
       {
+        template <typename T>
+        struct wrap { };
+
         template <typename PartialResultInput, typename...>
         struct Impl;
 
@@ -269,9 +272,9 @@ namespace ignition
         {
           using PartialResult =
               std::conditional_t<
-                TupleContainsBase<F1, ParentResultInput>::value,
+                TupleContainsBase<wrap<F1>, ParentResultInput>::value,
                 std::tuple<>,
-                std::tuple<F1>
+                std::tuple<wrap<F1>>
               >;
 
           using AggregateResult = decltype(std::tuple_cat(
@@ -282,7 +285,19 @@ namespace ignition
               typename Impl<AggregateResult, Others...>::type()));
         };
 
-        using type = typename Impl<std::tuple<>, InputTupleArgs...>::type;
+        template <typename Tuple>
+        struct unwrap;
+
+        template <typename... T>
+        struct unwrap<std::tuple<wrap<T>...>>
+        {
+          using type = std::tuple<T...>;
+        };
+
+        using type =
+          typename unwrap<
+            typename Impl<std::tuple<>, InputTupleArgs...>::type
+          >::type;
       };
       /////////////////////////////////////////////////
       template <typename FeatureTuple, typename = void_t<>>
@@ -332,16 +347,6 @@ namespace ignition
         using type = std::tuple<>;
       };
 
-      /////////////////////////////////////////////////
-      template <typename FeatureListT>
-      struct FlatLeanFeatureTuple
-      {
-        using type =
-          typename RemoveTupleRedundancies<
-            typename FlattenFeatures<typename FeatureListT::Features>::type
-          >::type;
-      };
-
       /////////////////////////////////////////////////
       /// \private CombineListsImpl provides the implementation of CombineLists.
       /// This helper implementation structure allows us to filter out repeated
@@ -484,28 +489,50 @@ namespace ignition
       template <template<typename> class Selector, typename FeatureListT>
       struct ExtractAPI
       {
-        template <typename FeatureTuple>
-        struct Impl;
+        template <typename FeatureTuple, typename... T>
+        struct Select;
 
-        template <typename... Features>
-        struct Impl<std::tuple<Features...>>
+        template <typename... Features, typename... T>
+        struct Select<std::tuple<Features...>, T...>
         {
-          template <typename... T>
-          class type : public virtual
-              Selector<Features>::template type<T...>... { };
+          using type =
+            typename RemoveTupleRedundancies<
+              std::tuple<typename Selector<Features>::template type<T...>...>
+            >::type;
         };
 
         template <typename T>
         struct Filter : std::is_same<Selector<T>, Empty> { };
 
         template <typename... T>
-        using type =
-          typename Impl<
-            typename FilterTuple<
-              Filter,
-              typename FlatLeanFeatureTuple<FeatureListT>::type
-            >::type
-          >::template type<T...>;
+        using Bases =
+            typename Select<
+              typename FilterTuple<
+                Filter,
+                typename FlattenFeatures<FeatureListT>::type
+              >::type,
+              T...
+            >::type;
+
+        template <typename... T>
+        struct S : std::tuple_size<Bases<T...>> { };
+
+        template <typename... T>
+        using IndexSequence = std::make_index_sequence<S<T...>::value>;
+
+        template <typename>
+        struct Impl;
+
+        template <std::size_t... I>
+        struct Impl<std::index_sequence<I...>>
+        {
+          template<typename... T>
+          class type
+              : public virtual std::tuple_element<I, Bases<T...>>::type... { };
+        };
+
+        template <typename... T>
+        using type = typename Impl<IndexSequence<T...>>::template type<T...>;
       };
 
       /////////////////////////////////////////////////
@@ -711,7 +738,7 @@ namespace ignition
       struct ImplementationSelector
       {
         public: template <typename PolicyT>
-        struct type : virtual T::template Implementation<PolicyT> { };
+        using type = typename T::template Implementation<PolicyT>;
       };
 
       template <typename PolicyT, typename List>

From b4815cc6744b72b280d2631fc6e489f059bd7451 Mon Sep 17 00:00:00 2001
From: "Michael X. Grey" <grey@openrobotics.org>
Date: Wed, 8 Apr 2020 19:28:09 +0800
Subject: [PATCH 4/7] Remove unnecessary code

---
 dartsim/src/plugin.cc                         |  1 -
 .../ignition/physics/detail/FeatureList.hh    | 52 -------------------
 2 files changed, 53 deletions(-)

diff --git a/dartsim/src/plugin.cc b/dartsim/src/plugin.cc
index c2db3fdbd..e9c68cd36 100644
--- a/dartsim/src/plugin.cc
+++ b/dartsim/src/plugin.cc
@@ -46,7 +46,6 @@ struct DartsimFeatures : FeatureList<
 > { };
 
 class Plugin :
-    public virtual Implements3d<DartsimFeatures>,
     public virtual Base,
     public virtual CustomFeatures,
     public virtual EntityManagementFeatures,
diff --git a/include/ignition/physics/detail/FeatureList.hh b/include/ignition/physics/detail/FeatureList.hh
index f978febb5..e26ffb01a 100644
--- a/include/ignition/physics/detail/FeatureList.hh
+++ b/include/ignition/physics/detail/FeatureList.hh
@@ -481,10 +481,6 @@ namespace ignition
                   typename GetNext<Iterable>::n>::template type<T...> { };
       };
 
-      /////////////////////////////////////////////////
-      template<template<typename> class Selector, typename Feature>
-      struct SplitFeatures;
-
       /////////////////////////////////////////////////
       template <template<typename> class Selector, typename FeatureListT>
       struct ExtractAPI
@@ -534,54 +530,6 @@ namespace ignition
         template <typename... T>
         using type = typename Impl<IndexSequence<T...>>::template type<T...>;
       };
-
-      /////////////////////////////////////////////////
-      template <template<typename> class Selector, typename Feature>
-      struct SplitFeatures
-      {
-        template <typename, typename> struct WithRequiredFeatures;
-
-        template <typename F, typename = ::ignition::physics::void_t<>>
-        struct Implementation
-        {
-          template <typename... T>
-          using type = typename WithRequiredFeatures<
-              F, typename F::RequiredFeatures>::template type<T...>;
-        };
-
-        template <>
-        struct Implementation<void, ::ignition::physics::void_t<>>
-        {
-          template <typename... T>
-          using type = Empty;
-        };
-
-        template <typename F>
-        struct Implementation<F, ::ignition::physics::void_t<typename F::FeatureTuple>>
-        {
-          template <typename... T>
-          using type = typename ExtractAPI<Selector, typename F::FeatureTuple>::template type<T...>;
-        };
-
-        template <typename F, typename R>
-        struct WithRequiredFeatures
-        {
-          template <typename... T>
-          struct type :
-              virtual Selector<F>::template type<T...>,
-              virtual Implementation<typename F::RequiredFeatures>::template type<T...> { };
-        };
-
-        template <typename F>
-        struct WithRequiredFeatures<F, void>
-        {
-          template <typename... T>
-          using type = typename Selector<F>::template type<T...>;
-        };
-
-        template <typename... T>
-        using type = typename Implementation<Feature>::template type<T...>;
-      };
     }
 
     /////////////////////////////////////////////////

From e8f0b76d6958caa5245b1bb1ac6965df4b7e47d4 Mon Sep 17 00:00:00 2001
From: "Michael X. Grey" <grey@openrobotics.org>
Date: Thu, 9 Apr 2020 22:24:43 +0800
Subject: [PATCH 5/7] Fix code check

---
 include/ignition/physics/detail/FeatureList.hh | 3 ++-
 src/FilterTuple_TEST.cc                        | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/include/ignition/physics/detail/FeatureList.hh b/include/ignition/physics/detail/FeatureList.hh
index e26ffb01a..5cc133ca5 100644
--- a/include/ignition/physics/detail/FeatureList.hh
+++ b/include/ignition/physics/detail/FeatureList.hh
@@ -326,7 +326,8 @@ namespace ignition
 
       /////////////////////////////////////////////////
       template <typename FeatureListT>
-      struct FlattenFeatures<FeatureListT, void_t<typename FeatureListT::FeatureTuple>>
+      struct FlattenFeatures<
+          FeatureListT, void_t<typename FeatureListT::FeatureTuple>>
       {
         using type =
             typename FlattenFeatures<typename FeatureListT::FeatureTuple>::type;
diff --git a/src/FilterTuple_TEST.cc b/src/FilterTuple_TEST.cc
index a385800d1..adcedf7e6 100644
--- a/src/FilterTuple_TEST.cc
+++ b/src/FilterTuple_TEST.cc
@@ -27,7 +27,8 @@ class ClassD : public ClassB { };
 using Filter = std::tuple<ClassA, ClassD>;
 using Input = std::tuple<ClassB, ClassC, ClassD, ClassA>;
 
-using Result = ignition::physics::detail::SubtractTuple<Filter>::From<Input>::type;
+using Result = ignition::physics::detail::SubtractTuple<Filter>
+    ::From<Input>::type;
 
 using UnfilteredResult =
     ignition::physics::detail::SubtractTuple<std::tuple<>>::From<Input>::type;

From d3755b99240365d2398f67fee1eb5ac2b3ff803e Mon Sep 17 00:00:00 2001
From: "Michael X. Grey" <grey@openrobotics.org>
Date: Thu, 9 Apr 2020 22:45:37 +0800
Subject: [PATCH 6/7] Add a unit test for FlattenFeatures

---
 include/ignition/physics/detail/FeatureList.hh | 16 ++++++++++++++++
 src/FeatureList_TEST.cc                        |  7 +++++++
 2 files changed, 23 insertions(+)

diff --git a/include/ignition/physics/detail/FeatureList.hh b/include/ignition/physics/detail/FeatureList.hh
index 5cc133ca5..0397cca6e 100644
--- a/include/ignition/physics/detail/FeatureList.hh
+++ b/include/ignition/physics/detail/FeatureList.hh
@@ -208,6 +208,8 @@ namespace ignition
       };
 
       /////////////////////////////////////////////////
+      /// \private This struct wraps the TupleContainsBase class to create a
+      /// tuple filter that can be passed to FilterTuple.
       template <typename DiscardTuple>
       struct RedundantTupleFilter
       {
@@ -220,6 +222,9 @@ namespace ignition
       struct FilterTuple;
 
       /////////////////////////////////////////////////
+      /// \private This class will apply a Filter to a tuple and produce a new
+      /// tuple that only includes the tuple elements which were ignored by the
+      /// Filter.
       template <template <typename> class Filter, typename... InputTypes>
       struct FilterTuple<Filter, std::tuple<InputTypes...>>
       {
@@ -237,6 +242,8 @@ namespace ignition
       };
 
       /////////////////////////////////////////////////
+      /// \private Use this struct to remove the tuple elements of one tuple
+      /// from another tuple
       template <typename DiscardTuple>
       struct SubtractTuple
       {
@@ -244,11 +251,16 @@ namespace ignition
         using Filter =
             typename RedundantTupleFilter<DiscardTuple>::template Apply<T>;
 
+        /// This struct will contain a nested struct called `type` which will be
+        /// a tuple with all the elements of FromTuple that are not present in
+        /// DiscardTuple
         template <typename FromTuple>
         struct From : FilterTuple<Filter, FromTuple> { };
       };
 
       /////////////////////////////////////////////////
+      /// \private This template takes in a tuple as InputTuple and gives back
+      /// a tuple where every element type is only present once.
       template <typename InputTuple>
       struct RemoveTupleRedundancies;
 
@@ -299,11 +311,15 @@ namespace ignition
             typename Impl<std::tuple<>, InputTupleArgs...>::type
           >::type;
       };
+
       /////////////////////////////////////////////////
+      /// \private This template is used to take a hierarchy of FeatureLists and
+      /// flatten them into a single tuple.
       template <typename FeatureTuple, typename = void_t<>>
       struct FlattenFeatures;
 
       /////////////////////////////////////////////////
+      /// \private This template is a helper for FlattenFeatures
       template <typename FeatureOrList, typename = void_t<>>
       struct ExpandFeatures
       {
diff --git a/src/FeatureList_TEST.cc b/src/FeatureList_TEST.cc
index 295f8b95e..ce3ddc78c 100644
--- a/src/FeatureList_TEST.cc
+++ b/src/FeatureList_TEST.cc
@@ -231,6 +231,13 @@ TEST(FeatureList_TEST, Hierarchy)
   // This test makes sure that a hierarchy of FeatureLists can compile.
   // As long as the line below can compile, the test is passed.
   HierarchyLevel3();
+
+  using Level3Tuple = detail::FlattenFeatures<HierarchyLevel3>::type;
+  EXPECT_TRUE((detail::TupleContainsBase<FeatureA, Level3Tuple>::value));
+  EXPECT_TRUE((detail::TupleContainsBase<FeatureB, Level3Tuple>::value));
+  EXPECT_TRUE((detail::TupleContainsBase<FeatureC, Level3Tuple>::value));
+  EXPECT_TRUE((detail::TupleContainsBase<Conflict1, Level3Tuple>::value));
+  EXPECT_TRUE((detail::TupleContainsBase<Conflict2, Level3Tuple>::value));
 }
 
 int main(int argc, char **argv)

From 346ee841c5fc785faac0559b8bf304175f218fd9 Mon Sep 17 00:00:00 2001
From: Grey <grey@osrfoundation.org>
Date: Mon, 13 Apr 2020 17:02:49 +0800
Subject: [PATCH 7/7] Make a template easier for MSVC

---
 .../ignition/physics/detail/FeatureList.hh    | 24 +++++++++----------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/include/ignition/physics/detail/FeatureList.hh b/include/ignition/physics/detail/FeatureList.hh
index 0397cca6e..ba9531a9a 100644
--- a/include/ignition/physics/detail/FeatureList.hh
+++ b/include/ignition/physics/detail/FeatureList.hh
@@ -264,12 +264,21 @@ namespace ignition
       template <typename InputTuple>
       struct RemoveTupleRedundancies;
 
+      template <typename T>
+      struct wrap { };
+
+      template <typename Tuple>
+      struct unwrap;
+
+      template <typename... T>
+      struct unwrap<std::tuple<wrap<T>...>>
+      {
+        using type = std::tuple<T...>;
+      };
+
       template <typename... InputTupleArgs>
       struct RemoveTupleRedundancies<std::tuple<InputTupleArgs...>>
       {
-        template <typename T>
-        struct wrap { };
-
         template <typename PartialResultInput, typename...>
         struct Impl;
 
@@ -297,15 +306,6 @@ namespace ignition
               typename Impl<AggregateResult, Others...>::type()));
         };
 
-        template <typename Tuple>
-        struct unwrap;
-
-        template <typename... T>
-        struct unwrap<std::tuple<wrap<T>...>>
-        {
-          using type = std::tuple<T...>;
-        };
-
         using type =
           typename unwrap<
             typename Impl<std::tuple<>, InputTupleArgs...>::type