command-invocation.hpp

Go to the documentation of this file.

/*
  COMMAND-INVOCATION.hpp  -  shortcuts and helpers for calling Steam-Layer commands

   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_INVOCACTION_H
#define CONTROL_COMMAND_INVOCACTION_H

#include "steam/control/command.hpp"
#include "steam/control/handling-pattern.hpp"
#include "steam/control/argument-tuple-accept.hpp"

#include <utility>



namespace steam {
namespace control {
  
  using namespace lib::meta;
  
  
  
  namespace com { 
                 //    define transient invoker objects, to allow for arbitrary bindings
    
    template<typename SIG>
    struct _DefineBindFunc
      {
        typedef ExecResult SIG_Bind(int);
      };
    
    
    template<typename SIG>
    struct CommandInvoker
      : AcceptArgumentTuple< typename _DefineBindFunc<SIG>::SIG_Bind
                           , CommandInvoker<SIG>
                           >
      {
        Command com_;
        
        CommandInvoker (Command c)
          : com_(c)
          { }
        
        
        template<typename TYPES>
        ExecResult
        bindArg (Tuple<TYPES> const& args)
          {
            com_.bindArg(args);
            ASSERT (com_.canExec());
            return com_();
          }
      };
    
    
    
    struct RuntimeCheckedCommandInvoker
      {
        Command com_;
        
        RuntimeCheckedCommandInvoker (Command c)
          : com_(c)
          { }
        
        
        template<typename...ARGS>
        ExecResult
        operator() (ARGS&& ...args)
          {
            com_.bind (std::forward<ARGS> (args)...);
            return com_();
          }
      };
  }
  
  
  
  inline
  com::RuntimeCheckedCommandInvoker
  invoke (Symbol cmdID)
  {
    Command command = Command::get (cmdID);
    ASSERT (command);
    return com::RuntimeCheckedCommandInvoker (command);
  }
  
  
  inline
  com::RuntimeCheckedCommandInvoker
  invoke (const char* cmdID)
  {
    return invoke(Symbol(cmdID));
  }
  
  
}} // namespace steam::control
#endif