Module.h

Go to the documentation of this file.

// $Id: Module.h 4471 2020-04-15 13:19:26Z linev $
 
/************************************************************
 * The Data Acquisition Backbone Core (DABC)                *
 ************************************************************
 * Copyright (C) 2009 -                                     *
 * GSI Helmholtzzentrum fuer Schwerionenforschung GmbH      *
 * Planckstr. 1, 64291 Darmstadt, Germany                   *
 * Contact:  http://dabc.gsi.de                             *
 ************************************************************
 * This software can be used under the GPL license          *
 * agreements as stated in LICENSE.txt file                 *
 * which is part of the distribution.                       *
 ************************************************************/
 
#ifndef DABC_Module
#define DABC_Module
 
#ifndef DABC_Worker
#include "dabc/Worker.h"
#endif
 
#ifndef DABC_Port
#include "dabc/Port.h"
#endif
 
 
namespace dabc {
 
   class Manager;
   class ModuleSync;
   class ModuleAsync;
   class ModuleRef;
 
   class Module : public Worker {
 
      friend class Manager;
      friend class ModuleItem;
      friend class Timer;
      friend class ConnTimer;
      friend class ModuleSync;
      friend class ModuleAsync;
      friend class ModuleRef;
 
      protected:
 
         bool                       fRunState;      
         std::vector<ModuleItem*>   fItems;         
         std::vector<InputPort*>    fInputs;        
         std::vector<OutputPort*>   fOutputs;       
         std::vector<PoolHandle*>   fPools;         
         std::vector<Timer*>        fTimers;        
         std::vector<ModuleItem*>   fUsers;         
         unsigned                   fSysTimerIndex; 
         bool                       fAutoStop;      
         dabc::Reference            fDfltPool;      
         std::string                fInfoParName;   
         std::string                fPublishPars;   
 
      private:
 
         Module(const std::string &name, Command cmd);
         virtual ~Module();
 
         void AddModuleItem(ModuleItem* item);
         void RemoveModuleItem(ModuleItem* item);
 
         Buffer TakeDfltBuffer();
 
         inline PoolHandle* Pool(unsigned n = 0) const { return n < fPools.size() ? fPools[n] : 0; }
         inline OutputPort* Output(unsigned n = 0) const { return n < fOutputs.size() ? fOutputs[n] : 0; }
         inline InputPort* Input(unsigned n = 0) const { return n < fInputs.size() ? fInputs[n] : 0; }
 
 
      protected:
 
         virtual void ObjectCleanup();
 
         virtual bool DoStop();
         virtual bool DoStart();
 
         virtual void OnThreadAssigned();
         virtual int PreviewCommand(Command cmd);
 
         virtual void SetModulePriority(int pri = -1);
 
         virtual void ProcessEvent(const EventId&);
 
         virtual double ProcessTimeout(double last_diff);
 
         virtual bool Find(ConfigIO &cfg);
 
         virtual void BuildFieldsMap(RecordFieldsMap* cont);
 
         bool Start();
 
         inline bool IsRunning() const { return fRunState; }
 
         bool Stop();
 
         void SetAutoStop(bool on = true) { fAutoStop = on; }
 
 
         unsigned CreatePoolHandle(const std::string &poolname, unsigned queue = 10);
 
         unsigned CreateInput(const std::string &name, unsigned queue = 10);
         unsigned CreateOutput(const std::string &name, unsigned queue = 10);
 
         unsigned CreateTimer(const std::string &name, double period_sec = -1., bool synchron = false);
 
         unsigned CreateUserItem(const std::string &name);
 
 
         void EnsurePorts(unsigned numinp = 0, unsigned numout = 0, const std::string &poolname = "");
 
         bool BindPorts(const std::string &inpname, const std::string &outname);
 
 
         // these are new methods, which should be protected
         unsigned NumOutputs() const { return fOutputs.size(); }
         bool IsValidOutput(unsigned indx = 0) const { return indx < fOutputs.size(); }
         bool IsOutputConnected(unsigned indx = 0) const { return indx < fOutputs.size() ? fOutputs[indx]->IsConnected() : false; }
         unsigned OutputQueueCapacity(unsigned indx = 0) const { return indx < fOutputs.size() ? fOutputs[indx]->QueueCapacity() : 0; }
         unsigned FindOutput(const std::string &name) const;
         std::string OutputName(unsigned indx = 0, bool fullname = false) const;
 
         unsigned NumInputs() const { return fInputs.size(); }
         bool IsValidInput(unsigned indx = 0) const { return indx < fInputs.size(); }
         bool IsInputConnected(unsigned indx = 0) const { return indx < fInputs.size() ? fInputs[indx]->IsConnected() : false; }
         bool InputQueueFull(unsigned indx = 0) const { return indx < fInputs.size() ? fInputs[indx]->QueueFull() : false; }
         unsigned InputQueueCapacity(unsigned indx = 0) const { return indx < fInputs.size() ? fInputs[indx]->QueueCapacity() : 0; }
         unsigned FindInput(const std::string &name) const;
         std::string InputName(unsigned indx = 0, bool fullname = false) const;
 
         unsigned NumPools() const { return fPools.size(); }
         bool IsValidPool(unsigned indx = 0) const { return indx < fPools.size(); }
         bool IsPoolConnected(unsigned indx = 0) const { return indx < fPools.size() ? fPools[indx]->IsConnected() : false; }
         unsigned FindPool(const std::string &name) const;
         std::string PoolName(unsigned indx = 0, bool fullname = false) const;
         bool IsAutoPool(unsigned indx = 0) const { return indx<fPools.size() ? fPools[indx]->QueueCapacity() > 0 : false; }
 
 
         PortRef FindPort(const std::string &name) const;
         bool IsPortConnected(const std::string &name) const;
 
         bool DisconnectPort(const std::string &name, bool witherr = false);
 
         void DisconnectAllPorts(bool witherr = false);
 
         bool SubmitCommandToTransport(const std::string &portname, Command cmd);
 
         unsigned PortQueueCapacity(const std::string &name) const { return FindPort(name).QueueCapacity(); }
         bool SetPortSignaling(const std::string &name, Port::EventsProducing signal);
         bool SetPortRatemeter(const std::string &name, const Parameter& ref);
         bool SetPortLoopLength(const std::string &name, unsigned cnt);
 
         unsigned FindTimer(const std::string &name);
         bool IsValidTimer(unsigned indx) const { return indx < fTimers.size(); }
         unsigned NumTimers() const { return fTimers.size(); }
         std::string TimerName(unsigned n = 0, bool fullname = false) const;
 
         void ShootTimer(unsigned indx, double delay_sec = 0.)
         {
            if (indx < fTimers.size()) {
               if (indx == fSysTimerIndex) ActivateTimeout(delay_sec);
                                      else fTimers[indx]->SingleShoot(delay_sec);
            }
         }
 
         void ShootTimer(const std::string &name, double delay_sec = 0.)
           {  ShootTimer(FindTimer(name), delay_sec); }
 
         ModuleItem* GetItem(unsigned id) const { return id<fItems.size() ? fItems[id] : 0; }
 
         unsigned FindUserItem(const std::string &name);
         bool IsValidUserItem(unsigned indx) const { return indx < fUsers.size(); }
         std::string UserItemName(unsigned indx = 0, bool fullname = false) const;
         EventId ConstructUserItemEvent(unsigned indx = 0)
         { return EventId(evntUser, 0, indx < fUsers.size() ? fUsers[indx]->ItemId() : 0); }
 
 
         virtual Parameter CreatePar(const std::string &name, const std::string &kind = "");
 
         void SetInfoParName(const std::string &name);
 
 
         // TODO: move to respective module classes
         bool CanSendToAllOutputs(bool exclude_disconnected = true) const;
         void SendToAllOutputs(Buffer& buf);
 
 
         void ProduceInputEvent(unsigned indx = 0, unsigned cnt = 1);
         void ProduceOutputEvent(unsigned indx = 0, unsigned cnt = 1);
         void ProducePoolEvent(unsigned indx = 0, unsigned cnt = 1);
         void ProduceUserItemEvent(unsigned indx = 0, unsigned cnt = 1);
 
 
         // =================== can be reimplemented in derived classes ===============
 
 
         // user must redefine method when it want to execute commands.
         // If method return true or false (cmd_true or cmd_false),
         // command considered as executed and will be replied
         // Any other arguments (cmd_postponed) means that execution
         // will be postponed in the module itself
         // User must call Module::ExecuteCommand() to enable processing of standard commands
         virtual int ExecuteCommand(Command cmd) { return dabc::Worker::ExecuteCommand(cmd); }
 
 
         // This is place of user code when command completion is arrived
         // User can implement any analysis of command data in this method
         // If returns true, command object will be delete automatically,
         // otherwise ownership delegated to user.
         // In that case command must be at some point replied - means user should call cmd.Reply(res) method.
         virtual bool ReplyCommand(Command cmd) { return dabc::Worker::ReplyCommand(cmd); }
 
 
         // these two methods called before start and after stop of module
         // disregard of module has its own mainloop or not
         virtual void BeforeModuleStart() {}
         virtual void AfterModuleStop() {}
         virtual void ModuleCleanup() {}
 
         // generic users event processing function
         virtual void ProcessItemEvent(ModuleItem* item, uint16_t evid) {}
 
         virtual void ProcessConnectionActivated(const std::string &name, bool on) {}
 
      public:
 
         virtual const char* ClassName() const { return "Module"; }
 
         std::string GetInfoParName() const;
 
   };
 
   // ___________________________________________________________________
 
 
   class ModuleRef : public WorkerRef {
 
      DABC_REFERENCE(ModuleRef, WorkerRef, Module)
 
      friend class Manager;
 
      protected:
 
      public:
 
         bool IsRunning() const { return GetObject() ? GetObject()->IsRunning() : false; }
 
         bool Start() { return Execute("StartModule"); }
 
         bool Stop() { return Execute("StopModule"); }
 
         bool CheckConnected() { return Execute("CheckConnected"); }
 
         bool IsInputConnected(unsigned ninp);
 
         bool IsOutputConnected(unsigned ninp);
 
         unsigned NumInputs();
 
         unsigned NumOutputs();
 
         PortRef FindPort(const std::string &name);
 
         bool IsPortConnected(const std::string &name);
 
         std::string InputName(unsigned n = 0, bool itemname = true);
 
         std::string OutputName(unsigned n = 0, bool itemname = true);
 
         bool ConnectPoolHandles();
 
         std::string InfoParName() const
            {  return null() ? std::string() : GetObject()->GetInfoParName(); }
 
   };
 
};
 
#endif