nodewiring-config.hpp

Go to the documentation of this file.

/*
  NODEWIRING-CONFIG.hpp  -  Helper for representing and selecting the wiring case

   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 ENGINE_NODEWIRING_CONFIG_H
#define ENGINE_NODEWIRING_CONFIG_H


#include "lib/meta/configflags.hpp"
#include "lib/meta/util.hpp"
#include "lib/util.hpp"

#include <functional>
#include <bitset>
#include <map>


namespace steam {
namespace engine {
namespace config {
  
  using util::contains;
  using lib::meta::FlagInfo;
  
  using lib::meta::CONFIG_FLAGS_MAX;
  
  typedef size_t IxID;                 
  
  
  template< template<class CONF> class Factory
          , typename FUNC       
          , typename PAR       
          >
  class ConfigSelector
    {
      typedef std::function<FUNC> FacFunction;
      
      template<class FAC>
      struct FactoryHolder 
        : private FAC,
          public FacFunction
        {
          FactoryHolder(PAR p) 
            : FAC(p),
              FacFunction (static_cast<FAC&> (*this))
            { }  
        };
      
      
      typedef std::shared_ptr<FacFunction> PFunc;
      typedef std::map<IxID, PFunc> ConfigTable;
      
      ConfigTable possibleConfig_; 
      
      
      struct FactoryTableBuilder
        {
          PAR ctor_param_;
          ConfigTable& factories_;
          
          FactoryTableBuilder (ConfigTable& tab, PAR p)
            : ctor_param_(p), 
              factories_(tab) { }
          
          
          /* === visitation interface === */
          
          typedef void Ret;
          
          template<class CONF>
          void
          visit (IxID code)
            {
              PFunc pFactory (new FactoryHolder<Factory<CONF>> (ctor_param_));
              factories_[code] = pFactory;
            }
          
          void done()  {}
        };
      
      
    public:
      template<class CONFS>
      ConfigSelector(CONFS const&, PAR factory_ctor_param)
        {
          FactoryTableBuilder buildTable(this->possibleConfig_,
                                         factory_ctor_param );
          // store a new Factory instance
          // for each possible Flag-Configuration  
          FlagInfo<CONFS>::accept (buildTable);
        }
      
      FacFunction&
      operator[] (IxID configFlags) 
        {
          if (contains (possibleConfig_, configFlags))
            return *possibleConfig_[configFlags];
          else
            throw lumiera::error::Invalid("ConfigSelector: No preconfigured factory for config-bits="
                                         +std::bitset<CONFIG_FLAGS_MAX>(configFlags).to_string());
        }
    };
  
  
  
  
  using lib::meta::Yes_t;
  using lib::meta::No_t;
  
  template<template<class> class _CandidateTemplate_>
  struct Instantiation
    {
      
      template<class X>
      class Test
        {
          typedef _CandidateTemplate_<X> Instance;
          
          template<class U>
          static Yes_t check(typename U::is_defined *);
          template<class U>
          static No_t  check(...);
          
        public:
          static const bool value = (sizeof(Yes_t)==sizeof(check<Instance>(0)));
        };
    };
  
  
  
}}} // namespace steam::engine::config
#endif