TupleLookupByTag.h

Go to the documentation of this file.

#ifndef LARDATA_UTILITIES_TUPLELOOKUPBYTAG_H
#define LARDATA_UTILITIES_TUPLELOOKUPBYTAG_H

// LArSoft libraries
#include "larcorealg/CoreUtils/MetaUtils.h"

// C/C++ standard libraries
#include <cstddef> // std::size_t
#include <tuple>
#include <type_traits>

namespace util {

  namespace details {

    //--------------------------------------------------------------------------
    // forward declaration of implementation details
    //--------------------------------------------------------------------------
    //---  General utilities
    //--------------------------------------------------------------------------
    template <typename Target, typename... T>
    struct count_type_in_list_impl;

    template <typename Target, typename... T>
    struct type_is_in_impl;

    //--------------------------------------------------------------------------
    //---  Courtesy traits
    //--------------------------------------------------------------------------
    template <typename Tuple>
    struct has_duplicate_types_unwrapper;

    //--------------------------------------------------------------------------
    //---  Tagging
    //--------------------------------------------------------------------------
    template <typename Tagged, typename = void>
    struct TagExtractorImpl;

    //--------------------------------------------------------------------------

  } // namespace details

  //--- BEGIN Metaprogramming --------------------------------------------------

  template <typename Target, typename... T>
  using count_type_in_list = details::count_type_in_list_impl<Target, T...>;

  template <typename Target, typename... T>
  constexpr unsigned int count_type_in_list_v = count_type_in_list<Target, T...>();

  template <std::size_t N, typename... T>
  using typelist_element_type = std::tuple_element<N, std::tuple<T...>>;

  template <std::size_t N, typename... T>
  using typelist_element_t = typename typelist_element_type<N, T...>::type;

  template <typename Target, typename... T>
  using type_is_in = details::type_is_in_impl<Target, T...>;

  template <typename Target, typename... T>
  constexpr bool type_is_in_v = type_is_in<Target, T...>();

  template <typename Target, typename Tuple>
  struct count_type_in_tuple;

  //--- END Metaprogramming ----------------------------------------------------

  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template <typename SrcTuple,
            template <typename T, typename...>
            class Extractor,
            template <typename...> class TargetClass = std::tuple>
  struct extract_to_tuple_type;

  template <typename SrcTuple,
            template <typename T, typename...>
            class Extractor,
            template <typename...> class TargetClass = std::tuple>
  using extract_to_tuple_type_t =
    typename extract_to_tuple_type<SrcTuple, Extractor, TargetClass>::type;

  template <typename Tuple, template <typename...> class TargetClass = std::tuple>
  using to_tuple = extract_to_tuple_type<Tuple, self_type, TargetClass>;

  template <typename Tuple, template <typename...> class TargetClass = std::tuple>
  using to_tuple_t = typename to_tuple<Tuple, TargetClass>::type;

  //----------------------------------------------------------------------------
  template <template <typename T, typename...> class Extractor, typename Target, typename Tuple>
  struct index_of_extracted_type;

  template <template <typename T, typename...> class Extractor, typename Target, typename Tuple>
  constexpr std::size_t index_of_extracted_type_v =
    index_of_extracted_type<Extractor, Target, Tuple>();

  template <typename Target, typename Tuple>
  using index_of_type = index_of_extracted_type<self_type, Target, Tuple>;

  template <typename Target, typename Tuple>
  constexpr std::size_t index_of_type_v = index_of_type<Target, Tuple>();

  //----------------------------------------------------------------------------
  template <template <typename T, typename...> class Extractor, typename Target, typename Tuple>
  using type_with_extracted_type =
    std::tuple_element<index_of_extracted_type_v<Extractor, Target, Tuple>, Tuple>;

  template <template <typename T, typename...> class Extractor, typename Target, typename Tuple>
  using type_with_extracted_type_t =
    typename type_with_extracted_type<Extractor, Target, Tuple>::type;

  //----------------------------------------------------------------------------
  template <template <typename T, typename...> class Extractor, typename Target, typename Tuple>
  struct has_extracted_type;

  template <template <typename T, typename...> class Extractor, typename Target, typename Tuple>
  constexpr bool has_extracted_type_v = has_extracted_type<Extractor, Target, Tuple>();

  template <typename Target, typename Tuple>
  using has_type = has_extracted_type<self_type, Target, Tuple>;

  template <typename Target, typename Tuple>
  constexpr bool has_type_v = has_type<Target, Tuple>();

  //----------------------------------------------------------------------------
  template <template <typename T, typename...> class Extractor, typename Target, typename Tuple>
  auto getByExtractedType(Tuple const& data) -> decltype(auto);

  template <template <typename T, typename...> class Extractor, typename Tuple>
  struct has_duplicate_extracted_types
    : public details::has_duplicate_types_unwrapper<extract_to_tuple_type_t<Tuple, Extractor>> {};

  template <template <typename T, typename...> class Extractor, typename Tuple>
  constexpr bool has_duplicate_extracted_types_v =
    has_duplicate_extracted_types<Extractor, Tuple>();

  template <typename Tuple>
  using has_duplicate_types = has_duplicate_extracted_types<self_type, Tuple>;

  template <typename Tuple>
  constexpr bool has_duplicate_types_v = has_duplicate_types<Tuple>();

  template <template <typename T, typename...> class Extractor, typename Target, typename Tuple>
  struct count_extracted_types;

  template <template <typename T, typename...> class Extractor, typename Target, typename Tuple>
  constexpr unsigned int count_extracted_types_v =
    count_extracted_types<Extractor, Target, Tuple>();

  template <typename Target, typename Tuple>
  using count_types = count_extracted_types<self_type, Target, Tuple>;

  template <typename Target, typename Tuple>
  constexpr unsigned int count_types_v = count_types<Target, Tuple>();


  template <typename T, typename Tag>
  struct TaggedType : public T {

    // Forward all constructors
    template <typename... Args>
    TaggedType(Args&&... args) : T(std::forward<Args>(args)...)
    {}

    using tag = Tag;       
    using tagged_type = T; 

  }; // struct TaggedType

  template <typename T, typename Tag>
  struct add_tag {
    using type = TaggedType<std::remove_reference_t<T>, Tag>;
  };

  template <typename T, typename Tag>
  using add_tag_t = typename add_tag<T, Tag>::type;

  template <typename Tagged>
  struct remove_tag {
    using type = Tagged;
  };

  template <typename T, typename Tag>
  struct remove_tag<TaggedType<T, Tag>> {
    using type = typename TaggedType<T, Tag>::tagged_type;
  };

  template <typename Tagged>
  using remove_tag_t = typename remove_tag<Tagged>::type;

  template <typename Tag, typename T>
  auto makeTagged(T& obj) -> decltype(auto)
  {
    return static_cast<add_tag_t<T, Tag>&>(obj);
  }

  template <typename Tag, typename T>
  auto makeTagged(T const& obj) -> decltype(auto)
  {
    return static_cast<add_tag_t<T const, Tag> const&>(obj);
  }

  template <typename Tag, typename T>
  auto makeTagged(T const&& obj) -> decltype(auto)
  {
    return add_tag_t<T, Tag>(obj); /* copy, since it's constant */
  }

  template <typename Tag, typename T>
  auto makeTagged(T&& obj) -> decltype(auto)
  {
    return add_tag_t<T, Tag>(std::move(obj));
  }

  template <typename Tagged>
  auto removeTag(Tagged& tagged) -> decltype(auto)
  {
    return static_cast<remove_tag_t<Tagged>&>(tagged);
  }

  template <typename Tagged>
  auto removeTag(Tagged const& tagged) -> decltype(auto)
  {
    return static_cast<remove_tag_t<Tagged> const&>(tagged);
  }

  template <typename Tagged>
  auto removeTag(Tagged const&& tagged) -> decltype(auto)
  {
    return static_cast<remove_tag_t<Tagged> const&&>(tagged);
  }

  template <typename Tagged>
  auto removeTag(Tagged&& tagged) -> decltype(auto)
  {
    return static_cast<remove_tag_t<Tagged>&&>(tagged);
  }

  template <std::size_t...>
  struct TagN {};

  template <typename Tagged>
  struct TagExtractor : public details::TagExtractorImpl<Tagged> {};

  template <typename Tagged>
  using tag_of = TagExtractor<Tagged>;

  template <typename Tagged>
  using tag_of_t = typename tag_of<Tagged>::type;

  template <typename SrcTuple>
  using extract_tags = extract_to_tuple_type<SrcTuple, TagExtractor>;

  template <typename SrcTuple>
  using extract_tags_t = typename extract_tags<SrcTuple>::type;

  template <typename Tag, typename Tuple>
  using index_of_tag = index_of_extracted_type<TagExtractor, Tag, Tuple>;

  template <typename Tag, typename Tuple>
  constexpr std::size_t index_of_tag_v = index_of_tag<Tag, Tuple>();

  template <typename Tag, typename Tuple>
  using type_with_tag = type_with_extracted_type<TagExtractor, Tag, Tuple>;

  template <typename Tag, typename Tuple>
  using type_with_tag_t = typename type_with_tag<Tag, Tuple>::type;

  template <typename Tag, typename Tuple>
  using has_tag = has_extracted_type<TagExtractor, Tag, Tuple>;

  template <typename Tag, typename Tuple>
  constexpr bool has_tag_v = has_tag<Tag, Tuple>();

  template <typename Tag, typename Tuple>
  using count_tags = count_extracted_types<TagExtractor, Tag, Tuple>;

  template <typename Tag, typename Tuple>
  constexpr unsigned int count_tags_v = count_tags<Tag, Tuple>();

  template <typename Tuple>
  using has_duplicate_tags = has_duplicate_extracted_types<TagExtractor, Tuple>;

  template <typename Tuple>
  constexpr bool has_duplicate_tags_v = has_duplicate_tags<Tuple>();

  template <typename Tag, typename Tuple>
  auto getByTag(Tuple const& data) -> decltype(auto)
  {
    return getByExtractedType<TagExtractor, Tag>(data);
  }


} // namespace util

//------------------------------------------------------------------------------
//---  Template implementation
//------------------------------------------------------------------------------
namespace util {

  namespace details {

    //--------------------------------------------------------------------------
    //
    // CAUTION: prolonged exposition to this code may result into loss of sight.
    //
    //--------------------------------------------------------------------------
    //--- implementation details (most are not documented)
    //--------------------------------------------------------------------------
    //--- General utilities
    //--------------------------------------------------------------------------
    template <typename Target, typename... T>
    struct count_type_in_list_impl : public std::integral_constant<unsigned int, 0U> {};

    template <typename Target, typename First, typename... Others>
    struct count_type_in_list_impl<Target, First, Others...>
      : public std::integral_constant<unsigned int,
                                      count_type_in_list_impl<Target, Others...>::value> {};

    template <typename Target, typename... Others>
    struct count_type_in_list_impl<Target, Target, Others...>
      : public std::integral_constant<unsigned int,
                                      count_type_in_list_impl<Target, Others...>::value + 1> {};

    //--------------------------------------------------------------------------
    //--- Courtesy traits
    //--------------------------------------------------------------------------

    //--------------------------------------------------------------------------
    //---  Tagging
    //--------------------------------------------------------------------------

    //--------------------------------------------------------------------------

    //--------------------------------------------------------------------------
    template <typename Target, typename... T>
    struct type_is_in_impl : public std::false_type {};

    template <typename Target, typename First, typename... Others>
    struct type_is_in_impl<Target, First, Others...>
      : public std::integral_constant<bool, type_is_in_impl<Target, Others...>::value> {};

    template <typename Target, typename... Others>
    struct type_is_in_impl<Target, Target, Others...> : public std::true_type {};

    //--------------------------------------------------------------------------
    template <template <typename...> class TargetClass,
              template <typename T, typename...>
              class Extractor,
              typename Tuple,
              std::size_t I,
              std::size_t N,
              typename... T>
    struct extract_to_tuple_type_impl {
      using type = typename extract_to_tuple_type_impl<
        TargetClass,
        Extractor,
        Tuple,
        (I + 1),
        N,
        T...,
        typename Extractor<std::tuple_element_t<I, Tuple>>::type>::type;
    }; // extract_to_tuple_type_impl

    template <template <typename...> class TargetClass,
              template <typename T, typename...>
              class Extractor,
              typename Tuple,
              std::size_t N,
              typename... T>
    struct extract_to_tuple_type_impl<TargetClass, Extractor, Tuple, N, N, T...> {
      using type = TargetClass<T...>;
    }; // extract_to_tuple_type_impl<N>

    //--------------------------------------------------------------------------

    // TODO try alternative simple implementation:
    template <typename SrcTuple,
              template <typename T, typename...>
              class Extractor,
              template <typename...>
              class TargetClass,
              std::size_t... I>
    struct extract_to_tuple_type_impl_simple {
      using type = TargetClass<typename Extractor<std::tuple_element_t<I, SrcTuple>>::type...>;
    }; // extract_to_tuple_type_impl<N>

    //--------------------------------------------------------------------------

    // Part of implementation for `index_of_extracted_type`.
    template <template <typename T, typename...> class Extractor,
              typename Target,
              std::size_t I,
              typename Elem,
              typename Tuple>
    struct index_of_extracted_type_impl;

    // Part of implementation for `index_of_extracted_type`.
    template <template <typename T, typename...> class Extractor,
              typename Target,
              std::size_t N,
              std::size_t I,
              typename Tuple>
    struct index_of_extracted_type_checked
      : public index_of_extracted_type_impl<
          Extractor,
          Target,
          I,
          typename Extractor<std::tuple_element_t<I, Tuple>>::type,
          Tuple> {};

    // Part of implementation for `index_of_extracted_type`.
    template <template <typename T, typename...> class Extractor,
              typename Target,
              std::size_t N,
              typename Tuple>
    struct index_of_extracted_type_checked<Extractor, Target, N, N, Tuple>
      : public std::integral_constant<std::size_t, N> {};
    template <template <typename T, typename...> class Extractor,
              typename Target,
              std::size_t I,
              typename Elem,
              typename Tuple>
    struct index_of_extracted_type_impl
      : public index_of_extracted_type_checked<Extractor,
                                               Target,
                                               std::tuple_size<Tuple>::value,
                                               (I + 1),
                                               Tuple> {};

    // Part of implementation for `index_of_extracted_type`.
    template <template <typename T, typename...> class Extractor,
              typename Target,
              std::size_t I,
              typename Tuple>
    struct index_of_extracted_type_impl<Extractor, Target, I, Target, Tuple>
      : public std::integral_constant<std::size_t, I> {
      static constexpr std::size_t N = std::tuple_size<Tuple>();
      static_assert(I < N, "Internal logic error.");
    };

    // Part of implementation for `index_of_extracted_type`.
    template <template <typename T, typename...> class Extractor,
              typename Target,
              std::size_t N,
              std::size_t After,
              typename Tuple>
    struct index_of_extracted_type_checked_after
      : public index_of_extracted_type_checked<Extractor, Target, N, (After + 1), Tuple> {};

    // Part of implementation for `index_of_extracted_type`.
    template <template <typename T, typename...> class Extractor,
              typename Target,
              std::size_t N,
              typename Tuple>
    struct index_of_extracted_type_checked_after<Extractor, Target, N, N, Tuple>
      : public std::integral_constant<std::size_t, N> {};

    // Part of implementation for `index_of_extracted_type`.
    // This implementation relies on std::tuple_size and std::tuple_element;
    // an implementation assuming Tuple to be std::tuple would be more efficient...
    template <template <typename T, typename...> class Extractor, typename Target, typename Tuple>
    struct index_of_type_base
      : public std::integral_constant<std::size_t,
                                      index_of_extracted_type_checked<Extractor,
                                                                      Target,
                                                                      std::tuple_size<Tuple>::value,
                                                                      0U,
                                                                      Tuple>::value> {};

    // Part of implementation for `index_of_extracted_type`.
    template <template <typename T, typename...> class Extractor, typename Target, typename Tuple>
    struct index_of_type_helper {
      static constexpr std::size_t N = std::tuple_size<Tuple>::value;
      static constexpr std::size_t value = index_of_type_base<Extractor, Target, Tuple>();

      static_assert(value < N, "The specified tuple does not have the sought type.");
      static_assert(index_of_extracted_type_checked_after<Extractor, Target, N, value, Tuple>() >=
                      N,
                    "The specified tuple has more than one element with the sought type.");
    }; // struct index_of_type_helper

    //--------------------------------------------------------------------------
    // Part of implementation of `has_duplicate_types`.
    template <typename Tuple, typename... T>
    struct has_duplicate_types_impl : public std::false_type {};

    template <typename Tuple, typename First, typename... Others>
    struct has_duplicate_types_impl<Tuple, First, Others...>
      : public std::integral_constant<bool,
                                      (count_type_in_tuple<First, Tuple>::value > 1U) ||
                                        has_duplicate_types_impl<Tuple, Others...>::value> {};

    // Part of implementation of `has_duplicate_types`.
    template <typename... T>
    struct has_duplicate_types_unwrapper<std::tuple<T...>>
      : public has_duplicate_types_impl<std::tuple<T...>, T...> {};

    //--------------------------------------------------------------------------
    // Part of implementation of `count_extracted_types` (might be exposed...).
    template <template <typename T, typename...> class Extractor, typename Target, typename... Tags>
    struct count_tags_in_list
      : public count_type_in_list<typename Extractor<Target>::type, Tags...> {};

    template <template <typename T, typename...> class Extractor,
              typename Target,
              typename... TagTuple>
    struct count_tags_in_tuple;

    template <template <typename T, typename...> class Extractor, typename Target, typename... Tags>
    struct count_tags_in_tuple<Extractor, Target, std::tuple<Tags...>>
      : public count_type_in_tuple<typename Extractor<Target>::type, Tags...> {};

    //--------------------------------------------------------------------------
    //--- Tag traits
    //--------------------------------------------------------------------------
    template <typename Tagged, typename /* = void */>
    struct TagExtractorImpl {
      static_assert(always_false_type<Tagged>(), "This type is not tagged.");
    };

    template <typename Tagged>
    struct TagExtractorImpl<
      Tagged,
      std::enable_if_t<always_true_type<typename std::remove_reference_t<Tagged>::tag>::value>> {
      using type = typename std::remove_reference_t<Tagged>::tag;
    };

    //--------------------------------------------------------------------------

  } // namespace details

  //----------------------------------------------------------------------------
  //--- Implementation of the exposed traits
  //----------------------------------------------------------------------------
  //--- General utilities
  //----------------------------------------------------------------------------
  template <typename Target, typename Tuple>
  struct count_type_in_tuple {
    static_assert(always_false_type<Tuple>(),
                  "count_type_in_tuple requires an instance of std::tuple");
  };

  // specialization: only works for std::tuples
  template <typename Target, typename... T>
  struct count_type_in_tuple<Target, std::tuple<T...>> : public count_type_in_list<Target, T...> {};

  //----------------------------------------------------------------------------
  //--- Courtesy traits
  //----------------------------------------------------------------------------
  template <typename SrcTuple,
            template <typename T, typename...>
            class Extractor,
            template <typename...>
            class TargetClass /* = std::tuple */
            >
  struct extract_to_tuple_type {
  private:
    static constexpr std::size_t N = std::tuple_size<SrcTuple>();

  public:
    using type =
      typename details::extract_to_tuple_type_impl<TargetClass, Extractor, SrcTuple, 0U, N>::type;
  }; // extract_to_tuple_type

  //----------------------------------------------------------------------------
  template <template <typename T, typename...> class Extractor, typename Target, typename Tuple>
  struct index_of_extracted_type
    : public std::integral_constant<
        std::size_t,
        details::index_of_type_helper<Extractor, Target, Tuple>::value> {};

  //----------------------------------------------------------------------------
  template <template <typename T, typename...> class Extractor, typename Target, typename Tuple>
  struct has_extracted_type
    : public std::integral_constant<bool,
                                    (details::index_of_type_base<Extractor, Target, Tuple>::value <
                                     std::tuple_size<Tuple>::value)> {};

  //----------------------------------------------------------------------------
  template <template <typename T, typename...> class Extractor, typename Target, typename Tuple>
  struct count_extracted_types
    : public count_type_in_tuple<Target, extract_to_tuple_type_t<Tuple, Extractor>> {};

  //----------------------------------------------------------------------------
  template <template <typename T, typename...> class Extractor, typename Target, typename Tuple>
  auto getByExtractedType(Tuple const& data) -> decltype(auto)
  {
    using std::get;
    return get<index_of_extracted_type_v<Extractor, Target, Tuple>>(data);
  }

  //----------------------------------------------------------------------------
  //--- Tagging utilities
  //----------------------------------------------------------------------------

  //----------------------------------------------------------------------------
} // namespace util

//------------------------------------------------------------------------------

#endif // LARDATA_UTILITIES_TUPLELOOKUPBYTAG_H