generator-test.cpp

Go to the documentation of this file.

/*
  Generator(Test)  -  build an interface + implementation directed by a typelis
 
   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.
 
* *****************************************************************/
 
 
#include "lib/test/run.hpp"
#include "lib/format-string.hpp"
#include "lib/meta/generator.hpp"
 
#include <iostream>
#include <string>
 
using util::_Fmt;
using std::string;
using std::cout;
 
// GCC > 13 warns at class definition when a new overload shadows an inherited virtual function.
// While theoretically correct, this warning is besides the point when an interface is assembled
// by metaprogramming from a chain of template instantiations, driven by a type list
// See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=109740
_Pragma("GCC diagnostic push") \
_Pragma("GCC diagnostic ignored \"-Woverloaded-virtual\"")
 
 
namespace lib  {
namespace meta {
namespace test {
  
  template<int I>
  struct Block
    {
      static string name;
      string talk()   { return "__"+name+"__"; }
    };
  
  
  
  template<int I>
  string Block<I>::name = _Fmt("Block<%2i>") % I;
  
  
  
  template<class X>
  class TakeIt
    {
    public:
      virtual void eat (X& x) = 0;
      virtual ~TakeIt() { }
    };
  
  template<class X, class BASE>
  class DoIt
    : public BASE
    {
    protected:
      DoIt ()         { cout << "ctor DoIt<"<< X::name << " >\n";}
      virtual ~DoIt() { cout << "dtor DoIt<"<< X::name << " >\n";}
    public:
      void eat (X& x) { cout << "devouring" << x.talk() << "\n";}
      using BASE::eat; // prevent shadowing
    };
  
  using TheTypes = Types< Block<1>
                        , Block<2>
                        , Block<3>
                        , Block<5>
                        , Block<8>
                        , Block<13>
                        >::List;
  
  typedef InstantiateForEach<TheTypes,TakeIt>  TheInterface;
  
  
  struct BaseImpl : public TheInterface
    {
      void eat() { cout << "gulp!\n"; }
    };
  
  typedef InstantiateChained<TheTypes,DoIt, BaseImpl>  NumberBabbler;
  
  
  /*********************************************************************/
  class TypeListGenerator_test : public Test
    {
      virtual void
      run (Arg)
        {
          NumberBabbler me_can_has_more_numberz;
          
          CHECK (INSTANCEOF (TheInterface, &me_can_has_more_numberz));
          
          TheTypes::Tail::Head                          b2;   //  Block<2>
          TheTypes::Tail::Tail::Tail::Head              b5;   //  Block<5>
          TheTypes::Tail::Tail::Tail::Tail::Tail::Head  b13;  //  Block<13>
          
          me_can_has_more_numberz.eat (b2);
          me_can_has_more_numberz.eat (b5);
          
          TakeIt<Block<13>>& subInterface = me_can_has_more_numberz;
          
          subInterface.eat (b13);
          me_can_has_more_numberz.eat();
          
          INFO (test, "SizeOf = %zu", sizeof(me_can_has_more_numberz));
        }
    };
  
  
  LAUNCHER (TypeListGenerator_test, "unit common");
  
  
  
}}} // namespace lib::meta::test