command-setup.cpp

Go to the documentation of this file.

/*
  CommandSetup  -  Implementation of command registration and instance management

  Copyright (C)         Lumiera.org
    2017,               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.

* *****************************************************/


#include "lib/error.hpp"
#include "include/logging.h"
#include "include/lifecycle.h"
#include "steam/control/command.hpp"
#include "steam/control/command-setup.hpp"
#include "steam/control/command-instance-manager.hpp"
#include "steam/control/command-def.hpp"
#include "lib/symbol.hpp"
#include "lib/format-string.hpp"
#include "lib/util.hpp"

#include <tuple>
#include <utility>

using std::tuple;
using std::get;
using std::function;
using std::move;
using lib::Symbol;
using lumiera::LifecycleHook;
using lumiera::ON_GLOBAL_INIT;
using std::string;
using util::unConst;
using util::_Fmt;


namespace steam {
namespace control {
  namespace error = lumiera::error;
  
  namespace { // implementation details: storage for pending static command definitions...
    
    using CmdDefEntry = std::tuple<Symbol, DefinitionClosure>;
    
    std::deque<CmdDefEntry>&
    pendingCmdDefinitions()
    {
      static std::deque<CmdDefEntry> definitionQueue;
      return definitionQueue;
    }
    
  }//(End) implementation details
  
  
  
  
  
  
  CommandSetup::~CommandSetup() { }
  
  CommandSetup::CommandSetup(Symbol cmdID)
    : cmdID_(cmdID)
    { }
  
  
  CommandSetup&
  CommandSetup::operator= (DefinitionClosure definitionBlock)
  {
    if (not definitionBlock)
      throw error::Invalid ("unbound function/closure provided for CommandSetup"
                           , LERR_(BOTTOM_VALUE));
    
    pendingCmdDefinitions().emplace_front (cmdID_, move(definitionBlock));
    return *this;
  }
  
  
  size_t
  CommandSetup::pendingCnt()
  {
    return pendingCmdDefinitions().size();
  }
  
  void
  CommandSetup::invokeDefinitionClosures()
  {
    while (not pendingCmdDefinitions().empty())
      {
        CmdDefEntry& entry = pendingCmdDefinitions().back();
        Symbol& cmdID{get<Symbol>(entry)};
        DefinitionClosure& buildDefinition{get<DefinitionClosure> (entry)};
        
        TRACE (command, "defining Command(%s)...", cmdID.c());
        CommandDef def(cmdID);
        buildDefinition(def);
        pendingCmdDefinitions().pop_back();
      }
  }
  
  namespace { // automatically invoke static command definitions
    
    LifecycleHook schedule_ (ON_GLOBAL_INIT, &CommandSetup::invokeDefinitionClosures);
  }
  
  
  
  
  
  // emit dtors of embedded objects here....
  CommandInstanceManager::~CommandInstanceManager() { }
  
  CommandInstanceManager::CommandInstanceManager (CommandDispatch& dispatcher)
    : dispatcher_{dispatcher}
    , table_{2 * Command::definition_count()}
    { }
  
  
  Symbol
  CommandInstanceManager::newInstance (Symbol prototypeID, string const& invocationID)
  {
    Symbol instanceID{prototypeID, invocationID};
    Command& instance = table_[instanceID];
    if (instance)
      throw new error::Logic (_Fmt{"Attempt to create a new Command instance '%s', "
                                   "while an instance for this invocationID %s "
                                   "is currently open for parametrisation and "
                                   "not yet dispatched for execution."}
                                  % instanceID % invocationID
                             , LERR_(DUPLICATE_COMMAND)
                             );
    // create new clone from the prototype
    table_[instanceID] = move (Command::get(prototypeID).newInstance());
    ENSURE (instance, "cloning of command prototype failed");
    return instanceID;
  }
  
  
  Command
  CommandInstanceManager::getInstance (Symbol instanceID)
  {
    auto entry = table_.find(instanceID);
    if (entry == table_.end())
      return Command::get(instanceID);
    if (not entry->second)
      throw error::Logic (_Fmt{"Command instance '%s' is not (yet/anymore) active"}
                              % instanceID
                         , LERR_(LIFECYCLE));
    return entry->second;
  }
  
  
  Command
  CommandInstanceManager::getCloneOrInstance (Symbol instanceID, bool must_be_bound)
  {
    Command instance = Command::maybeGetNewInstance (instanceID);
    if (not instance)
      { // second attempt: search of a locally "opened" instance
        auto entry = table_.find(instanceID);
        if (entry == table_.end())
          throw error::Invalid(_Fmt("Command-ID \"%s\" refers neither to a "
                                    "globally registered command definition, "
                                    "nor to an previously opened command instance")
                                   % instanceID
                              , LERR_(INVALID_COMMAND));
        if (not entry->second.isValid())
          throw error::Logic (_Fmt{"Command instance '%s' is not (yet/anymore) active"}
                                  % instanceID
                             , LERR_(LIFECYCLE));
        if (not must_be_bound or entry->second.canExec())
          instance = move(entry->second);
      }
    if (must_be_bound and not instance.canExec())
      throw error::State (_Fmt{"attempt to dispatch command instance '%s' "
                               "without binding all arguments properly beforehand"}
                              % instanceID
                         , LERR_(UNBOUND_ARGUMENTS));
    
    ENSURE (instance.isValid() and
           (instance.canExec() or not must_be_bound));
    return instance;
  }
  
  
  void
  CommandInstanceManager::handOver (Command&& toDispatch)
  {
    REQUIRE (toDispatch and toDispatch.canExec());
    dispatcher_.enqueue(move (toDispatch));
    ENSURE (not toDispatch);
  }
  
  
  void
  CommandInstanceManager::dispatch (Symbol instanceID)
  {
    handOver (getCloneOrInstance (instanceID, true));
  }
  
  
  void
  CommandInstanceManager::bindAndDispatch (Symbol instanceID, Rec const& argSeq)
  {
    Command instance{getCloneOrInstance (instanceID, false)};
    REQUIRE (instance);
    instance.bindArg (argSeq);
    ENSURE (instance.canExec());
    handOver (move (instance));
  }
  
  
  bool
  CommandInstanceManager::contains (Symbol instanceID)  const
  {
    return util::contains (table_, instanceID)
       and unConst(this)->table_[instanceID].isValid();
  }
  
  
  
}} // namespace steam::control