ProviderPack.h

Go to the documentation of this file.

#ifndef LARCOREALG_COREUTILS_PROVIDERPACK_H
#define LARCOREALG_COREUTILS_PROVIDERPACK_H


// C/C++ standard library
#include <tuple>
#include <type_traits>
#include <limits>


namespace lar {
  
  namespace details {
    
    template <typename... Types>
    struct has_duplicate_types;
    
    
    template <typename Derived, typename... Bases>
    constexpr std::size_t indexOfBaseOf();
    
    template <typename Derived, typename... Bases>
    constexpr std::size_t indexOfDerivedFrom();
    
    template <typename Derived, typename... Bases>
    constexpr std::size_t findBaseOf();
    
    template <typename Derived, typename... Bases>
    constexpr std::size_t findDerivedFrom();
    
    template <typename Derived, typename... Bases>
    constexpr std::size_t hasBaseOf()
      { return indexOfBaseOf<Derived, Bases...>() < sizeof...(Bases); }
    
    template <typename Derived, typename... Bases>
    constexpr std::size_t hasDerivedFrom()
      { return indexOfDerivedFrom<Derived, Bases...>() < sizeof...(Bases); }
    
    
    template
      <typename DestPack, typename SourcePack, typename... ExtractProviders>
    struct SetFrom;
 
  } // namespace details
  
  
  template <typename... Providers>
  class ProviderPack {
    static_assert(!details::has_duplicate_types<Providers...>::value,
      "Providers in ProviderPack are repeated");
    
    using this_type = ProviderPack<Providers...>; 
    
    using tuple_type = std::tuple<Providers const*...>;
    
      public:
    
    ProviderPack() = default;
    
    ProviderPack(Providers const* ...provider_ptrs): providers(provider_ptrs...)
      {}
    
    template<typename... OtherProviders>
    ProviderPack(ProviderPack<OtherProviders...> const& from)
      {
        details::SetFrom
          <this_type, ProviderPack<OtherProviders...>, Providers...>
          (*this, from);
      }

    template<typename... OtherProviders>
    ProviderPack(OtherProviders const*... providers)
      {
        details::SetFrom
          <this_type, ProviderPack<OtherProviders...>, Providers...>
          (*this, ProviderPack<OtherProviders...>(providers...));
      }

    template<typename... PackProviders, typename... OtherProviders>
    ProviderPack(
      ProviderPack<PackProviders...> const& fromPack,
      OtherProviders const*... providers
      );
    
    
    template <typename Provider>
    Provider const* get() const
      {
        constexpr auto providerIndex
          = details::findDerivedFrom<Provider, Providers...>();
        return std::get<providerIndex>(providers);
      } // get<>()
    
    
    template <typename Provider>
    void set(Provider const* provider_ptr)
      {
        constexpr auto providerIndex
          = details::findDerivedFrom<Provider, Providers...>();
        std::get<providerIndex>(providers) = provider_ptr;
      } // set<>()
    
    template <typename Provider>
    static constexpr bool has()
      { return details::hasDerivedFrom<Provider, Providers...>(); }
    
    
    template <typename... OtherProviders>
    bool operator== (ProviderPack<OtherProviders...> const& other) const;
    
    template <typename... OtherProviders>
    bool operator!= (ProviderPack<OtherProviders...> const& other) const;
    
    
    template <typename... OtherProviders>
    static constexpr bool containsProviders();
    
      private:
    
    tuple_type providers; 
    
  }; // class ProviderPack
  
  
  template <typename... Providers>
  ProviderPack<Providers...> makeProviderPack(Providers const* ...providers)
    { return ProviderPack<Providers...>(providers...); }
  
  
  template <typename... PackProviders, typename... MoreProviders>
  ProviderPack<PackProviders..., MoreProviders...> expandProviderPack(
    ProviderPack<PackProviders...> const& pack,
    MoreProviders const* ...providers
    )
    { return { pack, providers... }; }
  
  
} // namespace lar


//------------------------------------------------------------------------------
//--- Implementation details
//---
namespace lar {
  namespace details {
    
    template <bool Value>
    using bool_constant = std::integral_constant<bool, Value>; // also in C++17
    
    template <std::size_t Value>
    using index_constant = std::integral_constant<std::size_t, Value>;
    
    //--------------------------------------------------------------------------
    //--- has_type, has_duplicate_types, are_same_types
    //---
    template <typename Target, typename... Types>
    struct has_type;
    
    template <typename Target, typename First, typename... Others>
    struct has_type<Target, First, Others...>: has_type<Target, Others...> {};
    
    template <typename Target, typename... Others>
    struct has_type<Target, Target, Others...>: std::true_type {};
    
    template <typename Target>
    struct has_type<Target>: std::false_type {};
    
    
    //--------------------------------------------------------------------------
    template <typename Key, typename... Types>
    struct has_duplicate_types<Key, Types...>:
      public bool_constant
        <has_type<Key, Types...>() || has_duplicate_types<Types...>()>
      {};
    
    template <>
    struct has_duplicate_types<>: public std::false_type {};
    
    
    //--------------------------------------------------------------------------
    template <typename... Types>
    struct are_types_contained;
    
    template <typename... Types>
    struct are_same_types {
      
      template <typename... AsTypes>
      static constexpr bool as()
        {
          return (sizeof...(Types) == sizeof...(AsTypes))
            && are_types_contained<Types...>::template in<AsTypes...>();
        }
      
    }; // are_same_types
    
    
    template <typename First, typename... OtherTypes>
    struct are_types_contained<First, OtherTypes...> {
      template <typename... AsTypes>
      static constexpr bool in()
        {
          return are_types_contained<OtherTypes...>::template in<AsTypes...>()
            && has_type<First, AsTypes...>();
        }
    };
    
    template <typename First>
    struct are_types_contained<First> {
      template <typename... AsTypes>
      static constexpr bool in()
        { return has_type<First, AsTypes...>(); }
    };

    
    template <typename T>
    struct is_provider_pack: public std::false_type {};
    
    template <typename... Providers>
    struct is_provider_pack<ProviderPack<Providers...>>: public std::true_type
      {};
    
    
    template <typename APack, typename BPack>
    struct have_same_provider_types: public std::false_type {};
    
    template <typename... AProviders, typename... BProviders>
    struct have_same_provider_types
      <ProviderPack<AProviders...>, ProviderPack<BProviders...>>
      : public std::integral_constant
        <bool, are_same_types<AProviders...>::template as<BProviders...>()>
      {};
    
    
    // --- BEGIN impementation of findDerivedFrom() ----------------------------
    // 
    // This is the implementation of findDerivedFrom() and findBaseOf().
    // The functions are expected to assert that there is exactly one answer to
    // a matching condition: for findDerivedFrom() that answer is which is the
    // derived class of Base among Derived, for findBaseOf() is the opposite.
    // 
    // The implementation finds and returns the index of first class matching
    // the condition, and it asserts that the answer is valid.
    // It also finds the index of the next class matching the condition, just to
    // assert that it is not valid (that is, there is no other matching class).
    // 
    // The class returning the index of the first matching class is implemented
    // recursively, on a class taking the target class, the first of the
    // candidate classes, and then all the others in a parameter pack.
    // When the first candidate satisfies the condition, then the recursion is
    // over. In the simplest case, where we are just looking for a specific
    // class, the condition (the Target is the same as the First Candidate) can
    // be implied and the compiler can implement it directly with parameter
    // matching. In our cases the condition is non-trivial and we use a
    // two-level recursion: the outer level, the "dispatcher", invokes a
    // different "answer" class whether the condition is true or false. In the
    // former case a result is presented; in the other case recursion ensues,
    // back to the dispatcher. The dispatcher can also terminate the recursion
    // when no answer is found. If recursion is terminated without a match, an
    // invalid index is returned.
    // 
    // The class returning the next matching class is simply skipping a number
    // of candidates, and then behaving like the one looking for the first
    // matching candidate.
    //
    
    //
    // class to find the first matching class
    //
    template <
      template <typename A, typename B> class Match,
      typename Target, bool IsMatch, typename... Candidates
      >
    struct findFirstMatching_answer;
    
    template <
      template <typename A, typename B> class Match,
      typename Target, typename... Candidates
      >
    struct findFirstMatching_answer<Match, Target, true, Candidates...>
      : public index_constant<0U>
    {};
    
    template <
      template <typename A, typename B> class Match,
      typename Target, typename... Candidates
      >
    struct findFirstMatching_dispatcher;
    
    // end-of-recursion
    template <
      template <typename A, typename B> class Match,
      typename Target
      >
    struct findFirstMatching_dispatcher<Match, Target>
      : findFirstMatching_answer<Match, Target, true>
    {};
    
    template <
      template <typename A, typename B> class Match,
      typename Target, typename FirstCandidate, typename... OtherCandidates
      >
    struct findFirstMatching_dispatcher
      <Match, Target, FirstCandidate, OtherCandidates...>
      : public findFirstMatching_answer<
        Match,
        Target,
        Match<FirstCandidate, Target>::value,
        FirstCandidate,
        OtherCandidates...
      >
    {};
    
    template <
      template <typename A, typename B> class Match,
      typename Target, typename FirstCandidate, typename... OtherCandidates
      >
    struct findFirstMatching_answer
      <Match, Target, false, FirstCandidate, OtherCandidates...>
      : public index_constant
        <(1U + findFirstMatching_dispatcher<Match, Target, OtherCandidates...>::value)>
    {};
    
    template <
      template <typename A, typename B> class Match,
      typename Target, typename... Candidates
      >
    struct findFirstMatching_impl
      : findFirstMatching_dispatcher<Match, Target, Candidates...>
    {
        private:
      static constexpr auto _index
        = findFirstMatching_dispatcher<Match, Target, Candidates...>();
    }; // struct findFirstMatching_impl
    
    
    //
    // class to apply findFirstMatching_impl after skipping some candidates
    //
    template <
      unsigned int NSkip,
      template <typename A, typename B> class Match,
      typename Target, typename... Candidates
      >
    struct findNextMatching_impl;
    
    // recursion: peel one
    template <
      unsigned int NSkip,
      template <typename A, typename B> class Match,
      typename Target, typename FirstCandidate, typename... OtherCandidates
      >
    struct findNextMatching_impl
      <NSkip, Match, Target, FirstCandidate, OtherCandidates...>
      : index_constant<(
        1U
        + findNextMatching_impl
          <(NSkip - 1U), Match, Target, OtherCandidates...>::value
      )>
    {
      static_assert(NSkip > 0U, "Implementation error: no arguments to skip!");
    };
    
    // end-of-recursion: skipped enough
    template <
      template <typename A, typename B> class Match,
      typename Target, typename FirstCandidate, typename... OtherCandidates
      >
    struct findNextMatching_impl
      <0U, Match, Target, FirstCandidate, OtherCandidates...>
      : findFirstMatching_impl
        <Match, Target, FirstCandidate, OtherCandidates...>
    {};
    
    // end-of-recursion: all arguments skipped
    template <
      unsigned int NSkip,
      template <typename A, typename B> class Match,
      typename Target
      >
    struct findNextMatching_impl<NSkip, Match, Target>
      : findFirstMatching_impl<Match, Target>
      {};
    
    //
    // class finding a match and asserting its existence and unicity
    //
    template <
      template <typename A, typename B> class Match,
      typename Target, typename... Candidates
      >
    struct findTheMatching_impl
      : findFirstMatching_impl<Match, Target, Candidates...>
    {
        private:
      static constexpr auto _index
        = findFirstMatching_dispatcher<Match, Target, Candidates...>();
      
      static_assert(
        findNextMatching_impl<_index + 1U, Match, Target, Candidates...>()
          >= sizeof...(Candidates),
        "Multiple candidate classes match the Target one"
        );
    }; // struct findTheMatching_impl
    
    //
    // implementations with concrete matching conditions
    //
    template <typename Derived, typename... Bases>
    constexpr std::size_t indexOfBaseOf()
      { return findTheMatching_impl<std::is_base_of, Derived, Bases...>(); }
    
    template <typename Derived, typename... Bases>
    constexpr std::size_t findBaseOf()
      { 
        constexpr std::size_t index = indexOfBaseOf<Derived, Bases...>(); 
        static_assert(
          index < sizeof...(Bases),
          "Target is not derived from any of the available classes"
          );
        return index;
      } // findBaseOf()
    
    // this matching condition is the mirror of std::is_base_of
    template <typename Derived, typename Base>
    struct is_derived_of: std::is_base_of<Base, Derived> {};
    
    template <typename Base, typename... Derived>
    constexpr std::size_t indexOfDerivedFrom()
      { return findTheMatching_impl<is_derived_of, Base, Derived...>(); }
    
    template <typename Base, typename... Derived>
    constexpr std::size_t findDerivedFrom()
      { 
        constexpr std::size_t index = indexOfDerivedFrom<Base, Derived...>(); 
        static_assert(
          index < sizeof...(Derived),
          "Target is not base of any of the available classes"
          );
        return index;
      } // findDerivedFrom()
    
    // --- END impementation of findDerivedFrom() ------------------------------
    
    
    //--------------------------------------------------------------------------
    //--- SetFrom
    //---
    template <
      typename DestPack, typename SourcePack,
      typename FirstProvider, typename... OtherProviders
      >
    struct SetFrom<DestPack, SourcePack, FirstProvider, OtherProviders...> {
      SetFrom(DestPack& pack, SourcePack const& from)
        {
          pack.set(from.template get<FirstProvider>());
          SetFrom<DestPack, SourcePack, OtherProviders...>(pack, from);
        }
    }; // SetFrom<First, Others...>
    
    template <typename DestPack, typename SourcePack>
    struct SetFrom<DestPack, SourcePack> {
      SetFrom(DestPack&, SourcePack const&) {}
    };

    //--------------------------------------------------------------------------
    //--- Compare
    //---
    template <typename Provider, typename APack, typename BPack>
    bool haveSameProvider(APack const& a, BPack const& b) {
      static_assert(is_provider_pack<APack>() && is_provider_pack<BPack>(),
        "This class needs two ProviderPack template types.");
      return a.template get<Provider>() == b.template get<Provider>();
    } // haveSameProvider()
    
    
    template <typename APack, typename BPack>
    struct ProviderPackComparerBase {
      
      static_assert(have_same_provider_types<APack, BPack>(),
        "The specified provider packs have different types.");
      
    }; // ProviderPackComparerBase
    
    
    template <typename APack, typename BPack, typename... Providers>
    struct ProviderPackComparer;
    
    template
      <typename APack, typename BPack, typename First, typename... Others>
    struct ProviderPackComparer<APack, BPack, First, Others...>
      : ProviderPackComparerBase<APack, BPack>
    {
      static bool compare (APack const& a, BPack const& b)
        {
          return haveSameProvider<First>(a, b)
            && ProviderPackComparer<APack, BPack, Others...>::compare(a, b);
        }
    }; // ProviderPackComparer<APack, BPack, First, Others...>
    
    template
      <typename APack, typename BPack, typename First>
    struct ProviderPackComparer<APack, BPack, First>
      : ProviderPackComparerBase<APack, BPack>
    {
      static bool compare (APack const& a, BPack const& b)
        { return haveSameProvider<First>(a, b); }
    }; // ProviderPackComparer<APack, BPack, First>
    
    
    //--------------------------------------------------------------------------

  } // namespace details
  
  
  //----------------------------------------------------------------------------
  //--- ProviderPack
  //---
  
  template <typename... Providers>
  template<typename... PackProviders, typename... OtherProviders>
  ProviderPack<Providers...>::ProviderPack(
    ProviderPack<PackProviders...> const& fromPack,
    OtherProviders const*... providers
    )
  {
    
    // verify that the list of providers in argument is the exact one we need
    static_assert(
      details::are_same_types<Providers...>
        ::template as<PackProviders..., OtherProviders...>(),
      "The providers types in the arguments do not match the ones needed."
      );
    
    // copy all the providers from the provider pack
    details::SetFrom
      <this_type, ProviderPack<PackProviders...>, PackProviders...>
      (*this, fromPack);
    
    // put the other providers in a temporary parameter pack, and copy it
    // (this is convenience, a direct implementation would be probably better)
    details::SetFrom
      <this_type, ProviderPack<OtherProviders...>, OtherProviders...>
      (*this, makeProviderPack(providers...));
    
  } // ProviderPack<Providers...>::ProviderPack(ProviderPack, OtherProviders...)
  
  
  //----------------------------------------------------------------------------
  template <typename... Providers>
  template <typename... OtherProviders>
  bool ProviderPack<Providers...>::operator==
    (ProviderPack<OtherProviders...> const& other) const
  {
    return details::ProviderPackComparer<
      ProviderPack<Providers...>, ProviderPack<OtherProviders...>, Providers...
      >::compare(*this, other);
  }
  
  
  template <typename... Providers>
  template <typename... OtherProviders>
  bool ProviderPack<Providers...>::operator!=
    (ProviderPack<OtherProviders...> const& other) const
    { return !(*this == other); }
  
 
  //----------------------------------------------------------------------------
  template <typename... Providers>
  template <typename... OfferedProviders>
  constexpr bool ProviderPack<Providers...>::containsProviders() {
    return details::are_types_contained<Providers...>
      ::template in<OfferedProviders...>();
  } // ProviderPack<>::containsProviders()
  
  
  //----------------------------------------------------------------------------
  
} // namespace lar

#endif // LARCOREALG_COREUTILS_PROVIDERPACK_H