typelist-manip.hpp

Go to the documentation of this file.

/*
  TYPELIST-MANIP.hpp  -  Utils for working with lists-of-types

  Copyright (C)         Lumiera.org
    2008,               Hermann Vosseler <Ichthyostega@web.de>

  This program 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.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/


#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
      {
        typedef NullType Type;  
      };
    template<class TY, class TYPES>
    struct Pick<Node<TY,TYPES>, 0>
      {
        typedef TY Type;  
      };
    template<class TY, class TYPES, size_t i>
    struct Pick<Node<TY,TYPES>, i>
      {
        typedef typename Pick<TYPES, i-1>::Type Type;
      };
    
    
    
    
    template<class TY, template<class> class _TRANS_>
    struct Apply                           { typedef TY List; };
    
    template< class TY, class TYPES
            , template<class> class _TRANS_
            >
    struct Apply<Node<TY,TYPES>, _TRANS_ > { typedef Node< typename _TRANS_<TY>::Type
                                                         , typename Apply<TYPES,_TRANS_>::List
                                                         > List; };
    
    
    template<bool, class T, class TAIL>
    struct CondNode                        { typedef TAIL  Next; };
    
    template<class T, class TAIL>
    struct CondNode<true, T, TAIL>         { typedef Node<T,TAIL>  Next; };
    
    template< class TYPES 
            , template<class> class _P_    
            >
    struct Filter;
    
    template<template<class> class _P_>
    struct Filter<NullType,_P_>            { typedef NullType  List; };
    
    template< class TY, class TYPES
            , template<class> class _P_
            >
    struct Filter<Node<TY,TYPES>,_P_>      { typedef typename CondNode< _P_<TY>::value
                                                                      , TY
                                                                      , typename Filter<TYPES,_P_>::List
                                                                      >::Next      
                                                                      List; };
    
    
    template<class TY1, class TY2>
    struct Append                          { typedef Node<TY1, typename Append<TY2,NullType>::List>  List; };
    
    template< class TY, class TYPES
            , class TAIL
            >
    struct Append<Node<TY,TYPES>, TAIL>    { typedef Node<TY,  typename Append<TYPES,  TAIL>::List>  List; };
    
    template<class TY, class TYPES>
    struct Append<NullType, Node<TY,TYPES>>    { typedef Node<TY,TYPES>   List; };
    
    template<class TY, class TYPES>
    struct Append<Node<TY,TYPES>, NullType>    { typedef Node<TY,TYPES>   List; };
    
    template<class TY1>
    struct Append<TY1,NullType>            { typedef Node<TY1,NullType>   List; };
    
    template<class TY2>
    struct Append<NullType,TY2>            { typedef Node<TY2,NullType>   List; };
    
    template<>
    struct Append<NullType,NullType>       { typedef NullType             List; };
    
    
    
    
    template<class TYPES>
    struct SplitLast;
    
    template<>
    struct SplitLast<NullType>             { typedef NullType Type;
                                             typedef NullType List; };
    template<class TY>
    struct SplitLast<Node<TY,NullType>>    { typedef TY       Type;
                                             typedef NullType List; };
    
    template<class TY, class TYPES>
    struct SplitLast<Node<TY,TYPES>>       { typedef typename SplitLast<TYPES>::Type Type;
                                             typedef typename Append< TY,
                                                                      typename SplitLast<TYPES>::List
                                                                    >::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>  { typedef Node<B, typename Splice<BS, OVERLAY, i-1>::List>  List;
                                             typedef Node<B, typename Splice<BS, OVERLAY, i-1>::Front> Front;
                                             typedef         typename Splice<BS, OVERLAY, i-1>::Back   Back; };
    
    template<class B, class BS,
             class O, class OS >
    struct Splice<Node<B,BS>,Node<O,OS>,0> { typedef Node<O, typename Splice<BS,OS, 0>::List>          List;
                                             typedef NullType                                          Front;
                                             typedef         typename Splice<BS,OS, 0>::Back           Back; };
    
    template<class B, class BS>
    struct Splice<Node<B,BS>, NullType, 0> { typedef Node<B, BS> List;
                                             typedef NullType    Front;
                                             typedef Node<B, BS> Back; };
    
    template<class XX, uint i>
    struct Splice<NullType, XX, i>         { typedef NullType    List;
                                             typedef NullType    Front;
                                             typedef NullType    Back; };
    
    
    
    
    template<class TYPES>
    struct Dissect;
    
    template<class T, class TYPES>
    struct Dissect<Node<T,TYPES>>
      {
        typedef Node<T,TYPES>                  List;  
        typedef T                              Head;  
        typedef Node<T,NullType>               First; 
        typedef TYPES                          Tail;  
        typedef typename SplitLast<List>::List Prefix;
        typedef typename SplitLast<List>::Type End;   
        typedef Node<End,NullType>             Last;  
      };
    
    template<>
    struct Dissect<NullType>
      {
        typedef NullType                       List;
        typedef NullType                       Head;
        typedef NullType                       First;
        typedef NullType                       Tail;
        typedef NullType                       Prefix;
        typedef NullType                       End;
        typedef NullType                       Last;
      };
    
    
    
    
    template<class T, class TY>
    struct PrefixAll                       { typedef Node< typename Append<T,TY>::List, NullType>  List; };
    
    template<class T>
    struct PrefixAll<T, NullType>          { typedef NullType  List; };
    
    template<class T>
    struct PrefixAll<T, NodeNull>          { typedef Node< typename Append<T,NodeNull>::List, NullType>  List; };
    
    template< class T
            , class TY, class TYPES
            >
    struct PrefixAll<T, Node<TY,TYPES>>    { typedef Node< typename Append<T,TY>::List
                                                         , typename PrefixAll<T,TYPES>::List
                                                         >     List; };
    
    
    
    
    template<class TY1,class TY2>
    struct Distribute                      { typedef typename PrefixAll<TY1,TY2>::List  List; };
    
    template<class TY>
    struct Distribute<NullType,TY>         { typedef NullType List; };
    
    template< class TY, class TYPES
            , class TAIL
            >
    struct Distribute<Node<TY,TYPES>,TAIL> { typedef typename Append< typename PrefixAll<TY,TAIL>::List
                                                                    , typename Distribute<TYPES,TAIL>::List
                                                                    >::List                    
                                                                    List; };
    
    
    
    template< class X
            , template<class> class _ENUM_>
    struct Combine                         { typedef typename Distribute< typename _ENUM_<X>::List
                                                                        , Node<NullType,NullType>
                                                                        >::List  List; };
    template< template<class> class _ENUM_>
    struct Combine<NullType, _ENUM_ >      { typedef NodeNull                    List; };
    
    template< class TY, class TYPES
            , template<class> class _ENUM_>
    struct Combine<Node<TY,TYPES>,_ENUM_>  { typedef typename Distribute< typename _ENUM_<TY>::List
                                                                        , typename Combine<TYPES,_ENUM_>::List
                                                                        >::List  List; };
    
    template<class F>
    struct FlagOnOff
      { 
        typedef Node<F, Node<NullType,NullType>>  List;
      };
    
    
    template<class FLAGS>
    struct CombineFlags
      { 
        typedef typename Combine<FLAGS, FlagOnOff>::List  List;
      };
    
    
    
    
}} // namespace lib::meta
#endif