session-command-service.cpp

Go to the documentation of this file.

/*
  SessionCommandService  -  public service to invoke commands on the session
 
   Copyright (C)
     2016,            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.
 
* *****************************************************************/
 
#include "steam/control/session-command-service.hpp"
#include "steam/control/command.hpp"
#include "include/logging.h"
#include "lib/depend.hpp"
#include "lib/symbol.hpp"
#include "lib/util.hpp"
 
extern "C" {
#include "common/interface-descriptor.h"
}
 
#include <string>
 
 
 
 
namespace steam {
namespace control {
  
  using lib::Symbol;
  using std::string;
  
   
  Symbol
  SessionCommandService::cycle (Symbol cmdID, string const& invocationID)
  {
    return instanceManager_.newInstance(cmdID, invocationID);
  }
  
  
  void
  SessionCommandService::trigger (Symbol cmdID, Rec const& argSeq)
  {
    instanceManager_.getInstance(cmdID)
                    .bindArg(argSeq);
    instanceManager_.dispatch(cmdID);
  }
  
  
  void 
  SessionCommandService::bindArg (Symbol cmdID, Rec const& argSeq)
  {
    instanceManager_.getInstance(cmdID)
                    .bindArg(argSeq);
  }
  
  
  void
  SessionCommandService::invoke (Symbol cmdID)
  {
    instanceManager_.dispatch(cmdID);
  }
  
  
  namespace { // facade implementation details
    
    
    /* ================== define an lumieraorg_GuiNotification instance ======================= */
    
    LUMIERA_INTERFACE_INSTANCE (lumieraorg_interfacedescriptor, 0
                               ,lumieraorg_SessionCommandFacade_descriptor
                               , NULL, NULL, NULL
                               , LUMIERA_INTERFACE_INLINE (name,
                                                           const char*, (LumieraInterface ifa),
                                                             { (void)ifa;  return "SessionCommand"; }
                                                          )
                               , LUMIERA_INTERFACE_INLINE (brief,
                                                           const char*, (LumieraInterface ifa),
                                                             { (void)ifa;  return "Session Interface: invoke pre-defined commands to operate on the session"; }
                                                          )
                               , LUMIERA_INTERFACE_INLINE (homepage,
                                                           const char*, (LumieraInterface ifa),
                                                             { (void)ifa;  return "http://www.lumiera.org/develompent.html" ;}
                                                          )
                               , LUMIERA_INTERFACE_INLINE (version,
                                                           const char*, (LumieraInterface ifa),
                                                             { (void)ifa;  return "0.3~pre"; }
                                                          )
                               , LUMIERA_INTERFACE_INLINE (author,
                                                           const char*, (LumieraInterface ifa),
                                                             { (void)ifa;  return "Hermann Vosseler"; }
                                                          )
                               , LUMIERA_INTERFACE_INLINE (email,
                                                           const char*, (LumieraInterface ifa),
                                                             { (void)ifa;  return "Ichthyostega@web.de"; }
                                                          )
                               , LUMIERA_INTERFACE_INLINE (copyright,
                                                           const char*, (LumieraInterface ifa),
                                                             {
                                                               (void)ifa;
                                                               return
                                                                 "Copyright (C)\n"
                                                                 "  2016,            Hermann Vosseler <Ichthyostega@web.de>";
                                                             }
                                                          )
                               , LUMIERA_INTERFACE_INLINE (license,
                                                           const char*, (LumieraInterface ifa),
                                                             {
                                                               (void)ifa;
                                                               return
                                                                 "**Lumiera** is free software; you can redistribute it and/or modify it\n"
                                                                 "under the terms of the GNU General Public License as published by the\n"
                                                                 "Free Software Foundation; either version 2 of the License, or (at your\n"
                                                                 "option) any later version. See the file COPYING for further details."
                                                                 ;
                                                             }
                                                          )
                               , LUMIERA_INTERFACE_INLINE (state,
                                                           int, (LumieraInterface ifa),
                                                             {(void)ifa;  return LUMIERA_INTERFACE_EXPERIMENTAL; }
                                                          )
                               , LUMIERA_INTERFACE_INLINE (versioncmp,
                                                           int, (const char* a, const char* b),
                                                             {(void)a;(void)b;  return 0;}  
                                                          )
                               );
    
    
    
    
    
    using LERR_(LIFECYCLE);
    
    lib::Depend<SessionCommandService> _instance; 
    
    
    
    LUMIERA_INTERFACE_INSTANCE (lumieraorg_SessionCommand, 0
                               ,lumieraorg_SessionCommandService
                               , LUMIERA_INTERFACE_REF(lumieraorg_interfacedescriptor, 0, lumieraorg_SessionCommandFacade_descriptor)
                               , NULL /* on  open  */
                               , NULL /* on  close */
                               , LUMIERA_INTERFACE_INLINE (cycle,
                                                           const char*, (const char* cmdID, const char* invocationID),
                                                             {
                                                               if (!_instance)
                                                                 return lumiera_error_set (LUMIERA_ERROR_LIFECYCLE, cmdID);
                                                               else
                                                                 return _instance().cycle(cmdID, invocationID);
                                                             }
                                                          )
                               , LUMIERA_INTERFACE_INLINE (trigger,
                                                           void, (const char* cmdID, const void* args),
                                                             {
                                                               if (!_instance) lumiera_error_set (LUMIERA_ERROR_LIFECYCLE, cmdID);
                                                               else
                                                                 _instance().trigger(cmdID, *static_cast<Rec const *> (args));
                                                             }
                                                          )
                               , LUMIERA_INTERFACE_INLINE (bindArg,
                                                           void, (const char* cmdID, const void* args),
                                                             {
                                                               if (!_instance) lumiera_error_set (LUMIERA_ERROR_LIFECYCLE, cmdID);
                                                               else
                                                                 _instance().bindArg(cmdID, *static_cast<Rec const *> (args));
                                                             }
                                                          )
                               , LUMIERA_INTERFACE_INLINE (invoke,
                                                           void, (const char* cmdID),
                                                             {
                                                               if (!_instance) lumiera_error_set (LUMIERA_ERROR_LIFECYCLE, cmdID);
                                                               else
                                                                 _instance().invoke(cmdID);
                                                             }
                                                          )
                               );
    
    
    
  } // (END) facade implementation details
  
  
  
  SessionCommandService::SessionCommandService (CommandDispatch& dispatcherLoopInterface)
    : dispatcher_{dispatcherLoopInterface}
    , instanceManager_{dispatcher_}
    , serviceInstance_{ LUMIERA_INTERFACE_REF (lumieraorg_SessionCommand, 0, lumieraorg_SessionCommandService)}
    {
      INFO (stage, "SessionCommand Facade opened.");
    }
  
  
  
  
}} // namespace steam::control