typelist-manip.hpp

Go to the documentation of this file.

/*
  TYPELIST-MANIP.hpp  -  Utils for working with lists-of-types
 
   Copyright (C)
     2008,            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_TYPELIST_MANIP_H
#define LIB_META_TYPELIST_MANIP_H
 
 
 
#include "lib/meta/typelist.hpp"
 
#include <sys/types.h>
 
namespace lib {
namespace meta {
    
    
    template<class TYPES, size_t i>
    struct Pick
      {
        using Type = Nil;
      };
    template<class TY, class TYPES>
    struct Pick<Node<TY,TYPES>, 0>
      {
        using Type = TY;
      };
    template<class TY, class TYPES, size_t i>
    struct Pick<Node<TY,TYPES>, i>
      {
        using Type = Pick<TYPES, i-1>::Type;
      };
    
    
    
    
    template<class TY, template<class> class _TRANS_>
    struct Apply                           { using List = TY; };
    
    template< class TY, class TYPES
            , template<class> class _TRANS_
            >
    struct Apply<Node<TY,TYPES>, _TRANS_ > { using List = Node< typename _TRANS_<TY>::Type
                                                              , typename Apply<TYPES,_TRANS_>::List
                                                              >;};
    
    
    template<bool, class T, class TAIL>
    struct CondNode                        { using Next = TAIL; };
    
    template<class T, class TAIL>
    struct CondNode<true, T, TAIL>         { using Next = Node<T,TAIL>; };
    
    template< class TYPES
            , template<class> class _P_    
            >
    struct Filter;
    
    template<template<class> class _P_>
    struct Filter<Nil,_P_>                 { using List = Nil; };
    
    template< class TY, class TYPES
            , template<class> class _P_
            >
    struct Filter<Node<TY,TYPES>,_P_>      { using List = CondNode< _P_<TY>::value
                                                                  , TY
                                                                  , typename Filter<TYPES,_P_>::List
                                                                  >::Next
                                                                  ; };
    
    
    template<class TY1, class TY2>
    struct Append                          { using List = Node<TY1, typename Append<TY2,Nil>::List>; };
    
    template< class TY, class TYPES
            , class TAIL
            >
    struct Append<Node<TY,TYPES>, TAIL>    { using List = Node<TY,  typename Append<TYPES,  TAIL>::List>; };
    
    template<class TY, class TYPES>
    struct Append<Nil, Node<TY,TYPES>>     { using List = Node<TY,TYPES>; };
    
    template<class TY, class TYPES>
    struct Append<Node<TY,TYPES>, Nil>     { using List = Node<TY,TYPES>; };
    
    template<class TY1>
    struct Append<TY1,Nil>                 { using List = Node<TY1,Nil>; };
    
    template<class TY2>
    struct Append<Nil,TY2>                 { using List = Node<TY2,Nil>; };
    
    template<>
    struct Append<Nil,Nil>                 { using List = Nil; };
    
    
    
    
    template<class TYPES>
    struct PickLast;
    
    template<>
    struct PickLast<Nil>                   { using Type = Nil;
                                             using List = Nil; };
    template<class TY>
    struct PickLast<Node<TY,Nil>>          { using Type = TY;
                                             using List = Nil; };
    
    template<class TY, class TYPES>
    struct PickLast<Node<TY,TYPES>>        { using Type = PickLast<TYPES>::Type;
                                             using List = Append< TY
                                                                , typename PickLast<TYPES>::List
                                                                >::List
                                                                ; };
    
    
    
    template<class BASE, class OVERLAY, uint i=0>
    struct Splice;
    
    template<class B, class BS,
             class OVERLAY,
             uint i>
    struct Splice<Node<B,BS>, OVERLAY, i>  { using List  = Node<B, typename Splice<BS, OVERLAY, i-1>::List>;
                                             using Front = Node<B, typename Splice<BS, OVERLAY, i-1>::Front>;
                                             using Back  =         typename Splice<BS, OVERLAY, i-1>::Back; };
    
    template<class B, class BS,
             class O, class OS >
    struct Splice<Node<B,BS>,Node<O,OS>,0> { using List  = Node<O, typename Splice<BS,OS, 0>::List>;
                                             using Front = Nil;
                                             using Back  =         typename Splice<BS,OS, 0>::Back; };
    
    template<class B, class BS>
    struct Splice<Node<B,BS>, Nil, 0>      { using List  = Node<B, BS>;
                                             using Front = Nil;
                                             using Back  = Node<B, BS>; };
    
    template<class XX, uint i>
    struct Splice<Nil, XX, i>              { using List  = Nil;
                                             using Front = Nil;
                                             using Back  = Nil; };
    
    template<class LI, uint l>
    using Prefix = Splice<LI, Nil, l>::Front;
    
    template<class LI, uint p>
    using Suffix = Splice<LI, Nil, p>::Back;
    
    
    
    
    template<class TYPES>
    struct Dissect;
    
    template<class T, class TYPES>
    struct Dissect<Node<T,TYPES>>
      {
        using   List = Node<T,TYPES>;                     
        using   Head = T;                                 
        using  First = Node<T,Nil>;                       
        using   Tail = TYPES;                             
        using Prefix = PickLast<List>::List;              
        using    End = PickLast<List>::Type;              
        using   Last = Node<End,Nil>;                     
      };
    
    template<>
    struct Dissect<Nil>
      {
        using   List = Nil;
        using   Head = Nil;
        using  First = Nil;
        using   Tail = Nil;
        using Prefix = Nil;
        using    End = Nil;
        using   Last = Nil;
      };
    
    
    
    
    template<class T, class TY>
    struct PrefixAll                       { using List = Node< typename Append<T,TY>::List, Nil>; };
    
    template<class T>
    struct PrefixAll<T, Nil>               { using List = Nil; };
    
    template<class T>
    struct PrefixAll<T, NilNode>           { using List = Node< typename Append<T, NilNode>::List, Nil>; };
    
    template< class T
            , class TY, class TYPES
            >
    struct PrefixAll<T, Node<TY,TYPES>>    { using List = Node< typename Append<T,TY>::List
                                                              , typename PrefixAll<T,TYPES>::List
                                                              >;};
    
    
    
    
    template<class TY1,class TY2>
    struct Distribute                      { using List = PrefixAll<TY1,TY2>::List; };
    
    template<class TY>
    struct Distribute<Nil,TY>              { using List = Nil; };
    
    template< class TY, class TYPES
            , class TAIL
            >
    struct Distribute<Node<TY,TYPES>,TAIL> { using List = Append< typename PrefixAll<TY,TAIL>::List
                                                                , typename Distribute<TYPES,TAIL>::List
                                                                >::List
                                                                ; };
    
    
    
    template< class X
            , template<class> class _ENUM_>
    struct Combine                         { using List = Distribute< typename _ENUM_<X>::List
                                                                    , NilNode
                                                                    >::List; };
    template< template<class> class _ENUM_>
    struct Combine<Nil, _ENUM_ >           { using List = NilNode; };
    
    template< class TY, class TYPES
            , template<class> class _ENUM_>
    struct Combine<Node<TY,TYPES>,_ENUM_>  { using List = Distribute< typename _ENUM_<TY>::List
                                                                    , typename Combine<TYPES,_ENUM_>::List
                                                                    >::List; };
    
    template<class F>
    struct FlagOnOff
      {
        using List = Node<F, NilNode>;
      };
    
    
    template<class FLAGS>
    struct CombineFlags
      {
        using List = Combine<FLAGS, FlagOnOff>::List;
      };
    
    
    
    
}} // namespace lib::meta
#endif