typeseq-util.hpp

Go to the documentation of this file.

/*
  TYPESEQ-UTIL.hpp  -  basic metaprogramming utilities for type sequences
 
   Copyright (C)
     2009,            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_TYPESEQ_UTIL_H
#define LIB_META_TYPESEQ_UTIL_H
 
#include "lib/meta/typelist.hpp"
#include "lib/meta/typelist-manip.hpp"
#include "lib/meta/util.hpp"
 
 
 
namespace lib {
namespace meta {
  
  
  template<class X>
  constexpr size_t
  indexOfType()
  {
    static_assert (not sizeof(X), "Type not found in type-sequence");
    return 0;
  }
  
  template<class X, class T, class... TYPES>
  constexpr size_t
  indexOfType()
  {
    if constexpr (std::is_same_v<X,T>)
      return 0;
    else
      return 1 + indexOfType<X,TYPES...>();
  }
  
  template<class... TYPES>
  struct count
    : SizConst<sizeof...(TYPES)>
  { };
  template<class... TYPES>
  struct count<Types<TYPES...>>
    : SizConst<sizeof...(TYPES)>
  { };
  
  
  template<class T, class TYPES>
  struct Prepend;
  
  template<typename T, typename...TYPES>
  struct Prepend<T, Types<TYPES...>>
  {
    using Seq  = Types<T, TYPES...>;
    using List = Types<T, TYPES...>::List;
  };
  
  
  
  template<class H, class T>
  struct Types< Node<H,T> >
    {
      using List = Node<H,T>;
      using Seq  = Prepend< H
                          , typename Types<T>::Seq
                          >::Seq;
    };
  template<>
  struct Types<Nil>
    {
      using List = Nil;
      using Seq  = Types<>;
    };
  template<>
  struct Types<NilNode>
    : Types<Nil>
    { };
  
  
  
  
  
  template<class TYPES>
  struct Split;
  
  template<typename T1, typename...TS>
  struct Split<Types<T1,TS...> >
  {
    using List = Types<T1,TS...>::List;
    
    using Head  = T1;
    using First = Types<T1>;
    using Tail  = Types<TS...>;
    
    // for finding the end we need the help of typelist-util.hpp
    
    using PrefixList = PickLast<List>::List;
    using TailList   = Tail::List;
    
    using Prefix     = Types<PrefixList>::Seq;
    using End        = PickLast<List>::Type;
    using Last       = Types<End>;
  };
  
  template<>
  struct Split<Types<>>
  {
    using List  = Nil;
    
    using Head  = Nil;
    using First = Types<>;
    using Tail  = Types<>;
    
    // for finding the end we need the help of typelist-util.hpp
    
    using PrefixList = Nil;
    using TailList   = Nil;
    
    using Prefix     = Types<>;
    using Last       = Types<>;
    using End        = Nil;
  };
  
  
  
  
  template<class TYPES, uint i=1>
  class Shifted
    {
      using Tail = Split<TYPES>::Tail;
    public:
      using Type = Shifted<Tail,i-1>::Type;
      using Head = Split<Type>::Head;
    };
  
  template<class TYPES>
  struct Shifted<TYPES,0>
    {
      using Type = TYPES;
      using Head = Split<Type>::Head;       
    };
  
  
  
  template<typename...TYPES, size_t i>
  struct Pick<Types<TYPES...>, i>
    {
      using Type = Shifted<Types<TYPES...>, i>::Head;
    };
  
  
  
  template<typename T, size_t N>
  struct Repeat
    {
      using Rem = Repeat<T, N-1>::Seq;
      using Seq = Prepend<T,Rem>::Seq;
    };
  
  template<typename T>
  struct Repeat<T,0>
    {
      using Seq = Types<>;
    };
  
  
  
}} // namespace lib::meta
#endif