command-op-closure.hpp

Go to the documentation of this file.

/*
  COMMAND-OP-CLOSURE.hpp  -  implementation the closure for a command operation
 
   Copyright (C)
     2009,            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 CONTROL_COMMAND_OP_CLOSURE_H
#define CONTROL_COMMAND_OP_CLOSURE_H
 
#include "lib/meta/function.hpp"
#include "lib/meta/function-closure.hpp"
#include "lib/meta/tuple-helper.hpp"
#include "lib/meta/tuple-record-init.hpp"
#include "lib/meta/maybe-compare.hpp"
#include "steam/control/command-closure.hpp"
#include "steam/control/argument-erasure.hpp"
#include "lib/typed-allocation-manager.hpp"
#include "lib/format-cout.hpp"
 
#include <memory>
#include <functional>
#include <sstream>
#include <string>
 
 
 
 
namespace steam {
namespace control {
  
  using lib::meta::_Fun;
  using lib::meta::Tuple;
  using lib::meta::BuildTupleAccessor;
  using lib::meta::buildTuple;
  using lib::meta::Nil;
  
  using lib::TypedAllocationManager;
  using std::function;
  using std::ostream;
  using std::string;
  
  
  
  
  
  
  template
    < typename TY
    , class BASE
    , class TUP
    , uint idx
    >
  class ParamAccessor
    : public BASE
    {
      TY      & element()        { return std::get<idx> (*this); }
      TY const& element()  const { return std::get<idx> (*this); }
      
    public:
      using BASE::BASE;
      
      
      
      
      ostream&
      dump (ostream& output)  const
        {
          return BASE::dump (output << element() << ',');
        }
    };
    
  template<class TUP, uint n>
  class ParamAccessor<Nil, TUP, TUP, n>   
    : public TUP
    {
    public:
      ParamAccessor (TUP const& tup)
        : TUP(tup)
        { }
      
      ParamAccessor& operator= (ParamAccessor const&)  =delete;
      ParamAccessor& operator= (ParamAccessor&&)       =delete;
      ParamAccessor (ParamAccessor const&)             =default;
      ParamAccessor (ParamAccessor&&)                  =default;
      
      
      
      ostream&
      dump (ostream& output)  const
        {
          return output;
        }
    };
  
  
  
  template<typename SIG>
  class OpClosure
    {
      using Args    = _Fun<SIG>::Args;
      using Builder = BuildTupleAccessor<ParamAccessor, Args>;
      
      using ParamStorageTuple = Builder::Product;
      
      ParamStorageTuple params_;
      bool activated_;
      
    public:
      using ArgTuple = Tuple<Args>;
      
      
      OpClosure()
        : params_(Tuple<Args>())
        , activated_(false)
        { }
      
      explicit
      OpClosure (ArgTuple const& args)
        : params_(args)
        , activated_(true)
        { }
      
      OpClosure& operator= (OpClosure const&)  =delete;
      OpClosure& operator= (OpClosure&&)       =delete;
      OpClosure (OpClosure const&)             =default;
      OpClosure (OpClosure&&)                  =default;
      
      
      bool
      isValid ()  const
        {
          return activated_;
        }
      
      
      void
      invoke (CmdFunctor const& unboundFunctor)
        {
          ArgTuple& paramTuple{params_};
          std::apply (unboundFunctor.getFun<SIG>(), paramTuple);
        }
      
      
      
      operator string()  const
        {
          std::ostringstream buff;
          params_.dump (buff << "OpClosure(" );
          
          string dumped (buff.str());
          if (10 < dumped.length())
            // remove trailing comma...
            return dumped.substr (0, dumped.length()-1) +")";
          else
            return dumped+")";
        }
    };
  
  
  
  
}} // namespace steam::control
#endif /*CONTROL_COMMAND_OP_CLOSURE_H*/