ProviderPack.h

Go to the documentation of this file.

#ifndef LARCOREALG_COREUTILS_PROVIDERPACK_H
#define LARCOREALG_COREUTILS_PROVIDERPACK_H

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

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