command-impl.hpp

Go to the documentation of this file.

/*
  COMMAND-IMPL.hpp  -  Steam-Layer command implementation (top level)

  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_IMPL_H
#define CONTROL_COMMAND_IMPL_H

#include "steam/control/command.hpp"
#include "steam/control/command-closure.hpp"
#include "steam/control/command-mutation.hpp"
#include "lib/format-string.hpp"
#include "lib/nocopy.hpp"

#include <memory>
#include <functional>


namespace steam {
namespace control {
  
  using util::_Fmt;
  using std::function;
  using std::shared_ptr;
  
  
  
  class CommandImpl
    : util::NonCopyable
    {
      Mutation do_;
      UndoMutation undo_;
      
      shared_ptr<CmdClosure> pClo_;
      
      HandlingPattern::ID defaultPatt_;
      
      
      template<typename ARG>
      struct _Type
        {
          typedef typename ARG::SIG_op SIG_op;
          typedef typename ARG::SIG_cap SIG_cap;
          typedef typename ARG::SIG_undo SIG_undo;
          
          typedef function<SIG_op> Func_op;
          typedef function<SIG_cap> Func_cap;
          typedef function<SIG_undo> Func_undo;
        };
#define _TY(_ID_) typename _Type<ARG>::_ID_
      
    public:
      template<typename ARG>
      CommandImpl (shared_ptr<ARG> pStorageHolder
                  ,_TY (Func_op) const& operFunctor
                  ,_TY (Func_cap) const& captFunctor
                  ,_TY (Func_undo) const& undoFunctor
                  )
        : do_(operFunctor)
        , undo_(pStorageHolder->tie (undoFunctor, captFunctor))
        , pClo_(pStorageHolder)
        , defaultPatt_(HandlingPattern::defaultID())
        { }
      
#undef _TY
      
      
     ~CommandImpl();
      
      
      CommandImpl (CommandImpl const& orig
                  ,UndoMutation const& newUndo
                  ,shared_ptr<CmdClosure> const& newClosure)
        : do_{orig.do_}
        , undo_{newUndo}
        , pClo_{newClosure}
        , defaultPatt_{orig.defaultPatt_}
        , cmdID{orig.cmdID}
        { }
      
      explicit operator bool()  const { return isValid(); }
      
      
      Symbol cmdID;
      
      
      void
      prepareClone (CommandImplCloneBuilder& visitor)  const
        {
          ASSERT (pClo_);
          pClo_->accept(visitor);
        }
      
      
    public: /* === implementation of command functionality === */
      
      void
      setArguments (Arguments& args)
        {                                                              
          pClo_->bindArguments (args);
        }
      
      void
      setArguments (lib::diff::Rec const& paramData)
        {                                                              
          pClo_->bindArguments (paramData);
        }
      
      void
      discardArguments()
        {
          pClo_->unbindArguments();
        }
      
      void invokeOperation() { do_(*pClo_); }
      void invokeCapture()   { undo_.captureState(*pClo_); }
      void invokeUndo()      { undo_(*pClo_); }
      
      
      
      typedef HandlingPattern::ID PattID;
      
      PattID
      getDefaultHandlingPattern()  const
        {
          return defaultPatt_;
        }
      
      PattID
      setHandlingPattern (PattID newID)
        {
          PattID currID = defaultPatt_;
          defaultPatt_ = newID;
          return currID;
        }
      
      
      
      /* === diagnostics === */
      
      bool
      isValid()  const    
        {
          return bool(pClo_) 
             and HandlingPattern::get(defaultPatt_).isValid();
        }
      
      bool
      canExec()  const    
        {
          return isValid()
             and pClo_->isValid();
        }
      
      bool
      canUndo()  const    
        {
          return isValid() and pClo_->isCaptured();
        }
      
      operator string()  const
        {
          return _Fmt("Cmd|valid:%s, exec:%s, undo:%s |%s")
                     % isValid()
                     % canExec()
                     % canUndo()
                     % (pClo_? string(*pClo_) : util::FAILURE_INDICATOR);
        }
    };
  
  
  
  
  
}} // namespace steam::control
#endif