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 T, class TYPES>
  struct Prepend;
  
  template< typename T01
          , typename T02
          , typename T03
          , typename T04
          , typename T05
          , typename T06
          , typename T07
          , typename T08
          , typename T09
          , typename T10
          , typename T11
          , typename T12
          , typename T13
          , typename T14
          , typename T15
          , typename T16
          , typename T17
          , typename T18
          , typename T19
          , typename T20
          , typename IGN
          >
  struct Prepend<T01, Types<     T02,T03,T04,T05
                           , T06,T07,T08,T09,T10
                           , T11,T12,T13,T14,T15
                           , T16,T17,T18,T19,T20
                           , IGN
                           > >
  {
    typedef Types< T01,T02,T03,T04,T05
                 , T06,T07,T08,T09,T10
                 , T11,T12,T13,T14,T15
                 , T16,T17,T18,T19,T20 > Seq;
    
    typedef typename Seq::List          List;
  };
  
  
  
  template<class H, class T>
  struct Types< Node<H,T> >
    {
      typedef Node<H,T> List;
      
      typedef typename Prepend< H
                              , typename Types<T>::Seq
                              >::Seq  Seq;
    };
  
  
  
  
  
  
  template<class TYPES>
  struct Split;
  
  template< typename T01
          , typename T02
          , typename T03
          , typename T04
          , typename T05
          , typename T06
          , typename T07
          , typename T08
          , typename T09
          , typename T10
          , typename T11
          , typename T12
          , typename T13
          , typename T14
          , typename T15
          , typename T16
          , typename T17
          , typename T18
          , typename T19
          , typename T20
          >
  struct Split<Types< T01,T02,T03,T04,T05
                    , T06,T07,T08,T09,T10
                    , T11,T12,T13,T14,T15
                    , T16,T17,T18,T19,T20
                    > >
  {
    typedef typename 
            Types< T01,T02,T03,T04,T05
                 , T06,T07,T08,T09,T10
                 , T11,T12,T13,T14,T15
                 , T16,T17,T18,T19,T20
                 >::List                 List;
    
    typedef        T01                   Head;
    typedef Types< T01                 > First;
    typedef Types<     T02,T03,T04,T05
                 , T06,T07,T08,T09,T10
                 , T11,T12,T13,T14,T15
                 , T16,T17,T18,T19,T20 > Tail;

    // for finding the end we need the help of typelist-util.hpp
    
    typedef typename SplitLast<List>::List  PrefixList;
    typedef typename Tail::List             TailList;
    
    typedef typename Types<PrefixList>::Seq Prefix;
    typedef typename SplitLast<List>::Type  End;
    typedef Types<End>                      Last;
  };
  
  
  
  
  template<class TYPES, uint i=1>
  class Shifted
    {
      typedef typename Split<TYPES>::Tail Tail;
    public:
      typedef typename Shifted<Tail,i-1>::Type Type;
      typedef typename Split<Type>::Head       Head;
    };
  
  template<class TYPES>
  struct Shifted<TYPES,0>
    { 
      typedef TYPES                      Type;
      typedef typename Split<Type>::Head Head;
    };
  
  
  
  template<typename...TYPES, size_t i>
  struct Pick<Types<TYPES...>, i>
    {
      using Type = typename lib::meta::Shifted<Types<TYPES...>, i>::Head;
    };
  
  
  
  
  
}} // namespace lib::meta
#endif