tuple-helper.hpp

Go to the documentation of this file.

/*
  TUPLE-HELPER.hpp  -  metaprogramming utilities for type and data tuples
 
   Copyright (C)
     2016,            Hermann Vosseler <Ichthyostega@web.de>
 
 **Lumiera** is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
 Free Software Foundation; either version 2 of the License, or (at your
 option) any later version. See the file COPYING for further details.
 
*/
 
 
#ifndef LIB_META_TUPLE_HELPER_H
#define LIB_META_TUPLE_HELPER_H
 
#include "lib/meta/typelist.hpp"
#include "lib/meta/typelist-util.hpp"
#include "lib/meta/typeseq-util.hpp"
#include "lib/meta/variadic-helper.hpp"
#include "lib/meta/util.hpp"
 
#include <tuple>
#include <utility>
#include <functional>
 
 
namespace util { // forward declaration
  
  template<typename TY>
  std::string
  toString (TY const& val)  noexcept;
}
 
 
namespace lib {
namespace meta {
  
  template<typename T>
  struct is_Tuple
    : std::false_type
    { };
  
  template<typename...TYPES>
  struct is_Tuple<std::tuple<TYPES...>>
    : std::true_type
    { };
  
  template<typename...TYPES>
  struct is_Tuple<const std::tuple<TYPES...>>
    : std::true_type
    { };
  
  using std::remove_cv_t;
  using std::is_reference_v;
  using std::remove_reference_t;
  
  
  template<class TUP>
  concept tuple_sized = requires
    {
      { std::tuple_size<TUP>::value } -> std::convertible_to<size_t>;
    };
  
  
  template<class TUP, std::size_t idx>
  concept tuple_adl_accessible = requires(TUP tup)
    {
      typename std::tuple_element_t<idx, TUP>;
      { get<idx>(tup) } -> std::convertible_to<std::tuple_element_t<idx, TUP>&>;
    };
  
  template<class TUP, std::size_t idx>
  concept tuple_mem_accessible = requires(TUP tup)
    {
      typename std::tuple_element_t<idx, TUP>;
      { tup.template get<idx>() } -> std::convertible_to<std::tuple_element_t<idx, TUP>&>;
    };
  
  template<class TUP, std::size_t idx>
  concept tuple_element_accessible = tuple_mem_accessible<TUP,idx> or tuple_adl_accessible<TUP,idx>;
  
  template<class TUP>
  concept tuple_accessible =
    tuple_sized<TUP> and
    WithIdxSeq<std::tuple_size_v<TUP>>::andAll([](auto idx)
                                                {
                                                 return tuple_element_accessible<TUP,idx>;
                                                });
  
  
  template<class TUP>
  concept tuple_like = not is_reference_v<TUP>
                   and tuple_sized<remove_cv_t<TUP>>
                   and tuple_accessible<remove_cv_t<TUP>>;
  
  
  template<std::size_t idx, class TUP>
                            requires(tuple_like<std::remove_reference_t<TUP>>)
  decltype(auto)
  getElm (TUP&& tup)
  {
    using Tup = std::remove_reference_t<TUP>;
    static_assert (0 < std::tuple_size_v<Tup>);
    if constexpr (tuple_mem_accessible<Tup,0>)
      {
        if constexpr (std::is_reference_v<TUP>)
          return tup.template get<idx>();
        else
          { // return value copy when tuple given as RValue
            using Elm = std::tuple_element_t<idx, TUP>;
            Elm elm(tup.template get<idx>());
            return elm;
          }
      }
    else
      {     // ▽▽▽ ADL
        using std::get;
        return get<idx> (std::forward<TUP> (tup));
      }
  }
  
  
  
  
  namespace { // apply to tuple-like : helpers...
    
    template<typename FUN, typename TUP, size_t...Idx>
    constexpr decltype(auto)
    __unpack_and_apply (FUN&& f, TUP&& tup, std::index_sequence<Idx...>)
    {
      return std::invoke (std::forward<FUN> (f)
                         ,getElm<Idx> (std::forward<TUP>(tup))...
                         );
    }
    
    
    template<template<typename...> class META, class FUN, class TUP>
    struct _InvokeMetafunTup
      {
        using Tupl = std::decay_t<TUP>;
        using Elms = ElmTypes<Tupl>::Seq;
        using Args = Prepend<FUN, Elms>::Seq;
        using Type = RebindVariadic<META, Args>::Type;
      };
    template<template<typename...> class META, class FUN, class TUP>
    struct _InvokeMetafunTup<META, FUN, TUP&>
      {
        using Tupl = std::decay_t<TUP>;
        using Elms = typename ElmTypes<Tupl>::template Apply<std::add_lvalue_reference_t>;
        using Args = Prepend<FUN, Elms>::Seq;
        using Type = RebindVariadic<META, Args>::Type;
      };
    
    template<class FUN, class TUP>
    inline constexpr bool can_nothrow_invoke_tup = _InvokeMetafunTup<std::is_nothrow_invocable,FUN,TUP>::Type::value;
  }
  
  template<class FUN, class TUP>   requires(tuple_like<remove_reference_t<TUP>>)
  constexpr decltype(auto)
  apply (FUN&& f, TUP&& tup)  noexcept (can_nothrow_invoke_tup<FUN,TUP> )
  {
    using Indices = std::make_index_sequence<std::tuple_size_v<std::remove_reference_t<TUP>>>;
    
    return __unpack_and_apply (std::forward<FUN> (f)
                              ,std::forward<TUP> (tup)
                              ,Indices{}
                              );
  }
  
  
  template<class TUP, class FUN>   requires(tuple_like<remove_reference_t<TUP>>)
  constexpr void
  forEach (TUP&& tuple, FUN fun)
  {
           lib::meta::apply ([&fun]<typename...ELMS>(ELMS&&... elms)
                                  {
                                    (fun (std::forward<ELMS>(elms)), ...);
                                  }
                            ,std::forward<TUP> (tuple));
  }
  
  template<class TUP, class FUN>   requires(tuple_like<remove_reference_t<TUP>>)
  constexpr auto
  mapEach (TUP&& tuple, FUN fun)
  {
    return lib::meta::apply ([&fun]<typename...ELMS>(ELMS&&... elms)
                                  {  //..construct the type explicitly (make_tuple would decay fun result types)
                                    using Tuple = std::tuple<decltype(fun (std::forward<ELMS>(elms))) ...>;
                                    return Tuple (fun (std::forward<ELMS>(elms)) ...);
                                  }
                            ,std::forward<TUP> (tuple));
  }
  
  
  
  template<tuple_like TUP>
  struct ElmTypes<TUP>
    {
      template<typename>
      struct Extract;
      template<size_t...idx>
      struct Extract<std::index_sequence<idx...>>
        {
          using ElmTypes = Types<std::tuple_element_t<idx,TUP> ...>;
        };
      
      static constexpr size_t SIZ = std::tuple_size_v<TUP>;
      
      using Idx = std::make_index_sequence<SIZ>;
      using Seq = Extract<Idx>::ElmTypes;
      using Tup = RebindVariadic<std::tuple, Seq>::Type;
      
      template<template<class> class META>
      using Apply = ElmTypes<Seq>::template Apply<META>;
      
      template<template<typename...> class O>
      using Rebind = RebindVariadic<O, Seq>::Type;
      
      template<template<class> class PRED>
      using AndAll = ElmTypes<Apply<PRED>>::template Rebind<std::__and_>;
      
      template<template<class> class PRED>
      using OrAll  = ElmTypes<Apply<PRED>>::template Rebind<std::__or_>;
    };
  
  
  
  
  
  namespace { // rebinding helper to create std::tuple from a type sequence
    
    template<typename SEQ>
    struct BuildTupleType
      : std::false_type
      { };
    
    template<typename...TYPES>
    struct BuildTupleType<Types<TYPES...>>
      {
        using Type = std::tuple<TYPES...>;
      };
    
    template<class H, typename TAIL>
    struct BuildTupleType<Node<H, TAIL>>
      {
        using Seq  = Types<Node<H,TAIL>>::Seq;
        using Type = BuildTupleType<Seq>::Type;
      };
    
    template<>
    struct BuildTupleType<Nil>
      {
        using Type = std::tuple<>;
      };
  }
  
  
  template<typename TYPES>
  using Tuple = BuildTupleType<TYPES>::Type;
  
  
  using std::tuple_size;
  using std::tuple_element;
  
  
  
  template<typename...TYPES>
  struct RebindTupleTypes
    {
      using Seq  = Types<TYPES...>::Seq;
      using List = Seq::List;
    };
  template<typename...TYPES>
  struct RebindTupleTypes<std::tuple<TYPES...>>
    {
      using Seq  = Types<TYPES...>::Seq;
      using List = Seq::List;
    };
  
  
  
  
  
  
  
  template< typename TYPES
          , template<class,class, size_t> class _ElmMapper_
          >
  struct TupleConstructor
    : Tuple<TYPES>
    {
      using SequenceIterator = BuildIdxIter<TYPES>::Ascending;
      
      template<size_t idx, class SRC>
      static auto
      mapElm (SRC&& init)   
        {
          return _ElmMapper_<std::decay_t<SRC>
                            ,Tuple<TYPES>
                            , idx
                            >{std::forward<SRC> (init)};
        }
      
    protected:
      template<class SRC, size_t...idx>
      TupleConstructor (SRC&& initVals, IndexSeq<idx...>)
        : Tuple<TYPES> {mapElm<idx> (std::forward<SRC>(initVals)) ...}
        { }
      
      
    public:
      template<class SRC>
      TupleConstructor (SRC&& values)
        : TupleConstructor (std::forward<SRC>(values), SequenceIterator())
        { }
    };
  
  
  template<class SRC, class TAR>
  struct ElementExtractor;
  
 
  template<class SRC, class TAR, size_t i>
  using ExtractArg = ElementExtractor<SRC, TAR>::template Access<i>;
  
  
  template<typename TYPES, class SRC>
  Tuple<TYPES>
  buildTuple (SRC&& values)
  {
    return TupleConstructor<TYPES, ExtractArg>{std::forward<SRC> (values)};
  }
 
 
  
  
  
  
  
  
  template
    < template<class,class,class, uint> class _X_   
    , typename TYPES                                
    , class TUP =Tuple<TYPES>                       
    , uint i = 0                                    
    >
  class BuildTupleAccessor
    {
      // prepare recursion...
      using Head         = Split<TYPES>::Head;
      using Tail         = Split<TYPES>::Tail;
      using NextBuilder  = BuildTupleAccessor<_X_, Tail,TUP, i+1>;
      using NextAccessor = NextBuilder::Product;
    public:
      
      using Product = _X_< Head            // the type to use for this accessor
                         , NextAccessor    // the base type to inherit from
                         , TUP             // the tuple type we build upon
                         , i               // current element index
                         >;
    };
  
  
  template
    < template<class,class,class, uint> class _X_
    , class TUP
    , uint i
    >
  class BuildTupleAccessor< _X_, Types<>, TUP, i>
    {
    public:
      using Product = _X_<Nil, TUP, TUP, i>;   // Note: i == tuple size
    };
  
  
  
  template
    < typename TY
    , class BASE
    , class TUP
    , uint idx
    >
  struct TupleElementDisplayer
    : BASE
    {
      using BASE::BASE;
      
      std::string
      dump (std::string const& prefix ="(")  const
        {
          return BASE::dump (prefix + util::toString(std::get<idx>(*this))+",");
        }
    };
  
  template<class TUP, uint n>
  struct TupleElementDisplayer<Nil, TUP, TUP, n>
    : TUP
    {
      TupleElementDisplayer (TUP const& tup)
        : TUP(tup)
        { }
      
      std::string
      dump (std::string const& prefix ="(")  const
        {
          if (1 < prefix.length())
            // remove the trailing comma
            return prefix.substr (0, prefix.length()-1) +")";
          else
            return prefix+")";
        }
    };
  
  
  template<typename...TYPES>
  inline std::string
  dump (std::tuple<TYPES...> const& tuple)
  {
    using BuildAccessor = BuildTupleAccessor<TupleElementDisplayer, Types<TYPES...>>;
    using Displayer     = BuildAccessor::Product ;
    
    return static_cast<Displayer const&> (tuple)
          .dump();
  }
  
  
  
}} // namespace lib::meta
 
 
// add a specialisation to enable tuple string conversion
namespace util {
  
  template<typename...TYPES>
  struct StringConv<std::tuple<TYPES...>>
    {
      static std::string
      invoke (std::tuple<TYPES...> const& tuple) noexcept
        try {
          return "«"+typeStr(tuple)
               + "»──" + lib::meta::dump (tuple);
        }
        catch(...) { return FAILURE_INDICATOR; }
    };
  
  
} // namespace util
#endif /*LIB_META_TUPLE_HELPER_H*/