command-signature.hpp

Go to the documentation of this file.

/*
  COMMAND-SIGNATURE.hpp  -  deriving suitable command function signatures
 
   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_SIGNATURE_H
#define CONTROL_COMMAND_SIGNATURE_H
 
#include "lib/meta/function.hpp"
#include "lib/meta/typelist.hpp"
#include "lib/meta/typelist-manip.hpp"
#include "lib/meta/typeseq-util.hpp"
 
#include <functional>
 
 
 
namespace lumiera {
namespace error {
  LUMIERA_ERROR_DECLARE (UNBOUND_ARGUMENTS); 
  LUMIERA_ERROR_DECLARE (MISSING_MEMENTO);  
}}
 
namespace steam {
namespace control {
  
  using std::function;
  
  using lib::meta::BuildFunType;
  using lib::meta::_Fun;
  using lib::meta::Types;
  using lib::meta::Append;
  using lib::meta::PickLast;
  
  
  template<typename SIG, typename MEM>
  class CommandSignature
    {
      using Args            = _Fun<SIG>::Args;
      using ArgList         = Args::List;
      using ExtendedArglist = Append<ArgList, MEM>::List;
      using ExtendedArgs    = Types<ExtendedArglist>::Seq;
      
    public:
      using OperateSig = BuildFunType<void, Args>::Sig;
      using CaptureSig = BuildFunType<MEM,  Args>::Sig;
      using UndoOp_Sig = BuildFunType<void, ExtendedArgs>::Sig;
      using CmdArgs    = Args;
      using Memento    = MEM;
    };
  
  
  
  
  template<typename SIG>
  class UndoSignature
    {
      // preparation:  dissect the function signature into arguments and result
      using Args = _Fun<SIG>::Args;
      using Ret  = _Fun<SIG>::Ret;
      
      template<typename RET, typename ARG>
      struct Case
        {
          using Memento = RET;
          
          using ExtendedArglist = Append<ARG, Memento>::List;
          using ExtendedArgs    = Types<ExtendedArglist>::Seq;
          
          using OperateSig = BuildFunType<void, ARG>::Sig;
          using CaptureSig = BuildFunType<Ret,ARG>::Sig;
          using UndoOp_Sig = BuildFunType<void, ExtendedArgs>::Sig;
        };
      template<typename ARG>
      struct Case<void,ARG>
        {
          using Args = ARG::List;
          
          using Memento          = PickLast<Args>::Type;
          using OperationArglist = PickLast<Args>::List;
          using OperationArgs    = Types<OperationArglist>::Seq;
          
          using OperateSig = BuildFunType<void, OperationArgs>::Sig;
          using CaptureSig = BuildFunType<Ret,OperationArgs>::Sig;
          using UndoOp_Sig = BuildFunType<void, ARG>::Sig;
        };
      
    public:
      using CaptureSig = Case<Ret,Args>::CaptureSig;
      using UndoOp_Sig = Case<Ret,Args>::UndoOp_Sig;
      using OperateSig = Case<Ret,Args>::OperateSig;
      using Memento    = Case<Ret,Args>::Memento;
    };
  
  
  
}} // namespace steam::control
#endif