command-signature.hpp

Go to the documentation of this file.

/*
  COMMAND-SIGNATURE.hpp  -  deriving suitable command function signatures

  Copyright (C)         Lumiera.org
    2009,               Hermann Vosseler <Ichthyostega@web.de>

  This program 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.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/


#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::SplitLast;
  
  
  template<typename SIG, typename MEM>
  class CommandSignature
    {
      using Args            = typename _Fun<SIG>::Args;
      using ArgList         = typename Args::List;
      using ExtendedArglist = typename Append<ArgList, MEM>::List;
      using ExtendedArgs    = typename Types<ExtendedArglist>::Seq;
      
    public:
      using OperateSig = typename BuildFunType<void, Args>::Sig;
      using CaptureSig = typename BuildFunType<MEM,  Args>::Sig;
      using UndoOp_Sig = typename 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 = typename _Fun<SIG>::Args;
      using Ret  = typename _Fun<SIG>::Ret;
      
      template<typename RET, typename ARG>
      struct Case
        {
          using Memento = RET;
          
          using ExtendedArglist = typename Append<ARG, Memento>::List;
          using ExtendedArgs    = typename Types<ExtendedArglist>::Seq;
          
          using OperateSig = typename BuildFunType<void, ARG>::Sig;
          using CaptureSig = typename BuildFunType<Ret,ARG>::Sig;
          using UndoOp_Sig = typename BuildFunType<void, ExtendedArgs>::Sig;
        };
      template<typename ARG>
      struct Case<void,ARG>
        {
          using Args = typename ARG::List;
          
          using Memento          = typename SplitLast<Args>::Type;
          using OperationArglist = typename SplitLast<Args>::List;
          using OperationArgs    = typename Types<OperationArglist>::Seq;
          
          using OperateSig = typename BuildFunType<void, OperationArgs>::Sig;
          using CaptureSig = typename BuildFunType<Ret,OperationArgs>::Sig;
          using UndoOp_Sig = typename BuildFunType<void, ARG>::Sig;
        };
      
    public:
      using CaptureSig = typename Case<Ret,Args>::CaptureSig;
      using UndoOp_Sig = typename Case<Ret,Args>::UndoOp_Sig;
      using OperateSig = typename Case<Ret,Args>::OperateSig;
      using Memento    = typename Case<Ret,Args>::Memento;
    };
  
  
  
}} // namespace steam::control
#endif