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 <tuple>
#include <type_traits>
#include <cstddef> // std::size_t

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 Tuple>
    struct has_duplicate_types_unwrapper;
    
    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