generator.hpp

Go to the documentation of this file.

/*
  GENERATOR.hpp  -  metaprogramming utilities for generating classes and interfaces
 
   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.
 
====================================================================
This code is heavily inspired by  
 The Loki Library (loki-lib/trunk/include/loki/Sequence.h)
    Copyright (c) 2001 by Andrei Alexandrescu
    Copyright (c) 2005 by Peter Kümmel
    This Loki code accompanies the book:
    Alexandrescu, Andrei. "Modern C++ Design: Generic Programming
        and Design Patterns Applied". 
        Copyright (c) 2001. Addison-Wesley. ISBN 0201704315
        
  Loki Copyright Notice: 
  Permission to use, copy, modify, distribute and sell this software for any
  purpose is hereby granted without fee, provided that the above copyright
  notice appear in all copies and that both that copyright notice and this
  permission notice appear in supporting documentation.
  The author makes no representations about the suitability of this software
  for any purpose. It is provided "as is" without express or implied warranty.
*/
 
 
#ifndef LIB_META_GENERATOR_H
#define LIB_META_GENERATOR_H
 
#include "lib/meta/typelist.hpp"
 
 
 
namespace lib {
namespace meta{
    
    template
      < class TYPES                  // List of Types
      , template<class> class _X_   //  your-template-goes-here
      , class BASE = Nil           //   Base class at end of chain
      >
    class InstantiateForEach;
    
    
    template<template<class> class _X_, class BASE>
    class InstantiateForEach<Nil, _X_, BASE>
      : public BASE
      {
      public:
        using Unit = BASE;
        using Next = Nil;
      };
    
    
    template
      < class TY, typename TYPES
      , template<class> class _X_
      , class BASE
      >
    class InstantiateForEach<Node<TY, TYPES>, _X_, BASE>
      : public _X_<TY>,
        public InstantiateForEach<TYPES, _X_, BASE>
      { 
      public:
        using Unit = _X_<TY>;
        using Next = InstantiateForEach<TYPES,_X_>;
      };
    
    
    template<typename T>
    struct InheritFrom : T
      { };
    
    
    
    
    template
      < class TYPES                      // List of Types
      , template<class,class> class _X_ //  your-template-goes-here
      , class BASE = Nil          //   Base class at end of chain
      >
    class InstantiateChained;
    
    
    template<template<class,class> class _X_, class BASE>
    class InstantiateChained<Nil, _X_, BASE>
      : public BASE
      {
      public:
        using Unit = BASE;
        using Next = Nil;
      };
    
    
    template
      < class TY, typename TYPES
      , template<class,class> class _X_
      , class BASE
      >
    class InstantiateChained<Node<TY, TYPES>, _X_, BASE>
      : public _X_< TY
                  , InstantiateChained<TYPES, _X_, BASE>
                  >
      {
      public:
        using Next = InstantiateChained<TYPES,_X_,BASE>;
        using Unit = _X_<TY,Next>;
      };
    
    
    
    template
      < class TYPES                           // List of Types
      , template<class,class,uint> class _X_ //  your-template-goes-here
      , class BASE = Nil                    //   Base class at end of chain
      , uint i = 0                         //    incremented on each instantiation
      >
    class InstantiateWithIndex;
    
    
    template< template<class,class,uint> class _X_
            , class BASE
            , uint i
            >
    class InstantiateWithIndex<Nil, _X_, BASE, i>
      : public BASE
      {
      public:
        using Unit = BASE;
        using Next = Nil;
        enum{ COUNT = i };
      };
    
    
    template
      < class TY, typename TYPES
      , template<class,class,uint> class _X_
      , class BASE
      , uint i
      >
    class InstantiateWithIndex<Node<TY, TYPES>, _X_, BASE, i>
      : public _X_< TY
                  , InstantiateWithIndex<TYPES, _X_, BASE, i+1 >
                  , i
                  >
      {
      public:
        using Next = InstantiateWithIndex<TYPES,_X_,BASE,i+1>;
        using Unit = _X_<TY,Next,i>;
        enum{ COUNT = Next::COUNT };
      };
    
    
}} // namespace lib::meta
#endif