ModuleItem.h

Go to the documentation of this file.

// $Id: ModuleItem.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_ModuleItem
#define DABC_ModuleItem
 
#ifndef DABC_Worker
#include "dabc/Worker.h"
#endif
 
namespace dabc {
 
   class Module;
   class ModuleAsync;
   class ModuleSync;
 
   enum EModuleItemType {
           mitInpPort,   // input port
           mitOutPort,   // output port
           mitPool,      // pool handle
           mitParam,     // parameter
           mitTimer,     // timer
           mitConnTimer, // timer to reconnect ports
           mitUser       // item to produce/receive user-specific events
    };
 
   enum EModuleEvents {
           evntModuleNone = Worker::evntFirstSystem,
           evntInput,
           evntOutput,
           evntInputReinj,
           evntOutputReinj,
           evntTimeout,
           evntPortConnect,
           evntPortDisconnect,
           evntPortError,           // produce when port on other side disconnects with error
           evntConnStart,           // event produce when other side of connection is stared
           evntConnStop,            // event produce when other side of connection is stopped
           evntModuleLast,          // last event id, used by Module itself
           evntUser = Worker::evntFirstUser
   };
 
   enum EModelItemConsts {
           moduleitemMinId = 1,         // minimum possible id of item
           moduleitemMaxId = 65534,     // maximum possible id of item
           moduleitemAnyId = 65535      // special id to identify any item (used in WaitForEvent)
   };
 
   class ModuleItem : public Worker {
      friend class Module;
      friend class ModuleAsync;
      friend class ModuleSync;
 
      protected:
 
         int         fItemType;  // kind of the item
         unsigned    fItemId;    // sequence id of the item in complete items list
         unsigned    fSubId;     // sequence number of input/output/pool/timer port, used by module
 
         ModuleItem(int typ, Reference parent, const std::string &name);
 
         virtual bool ItemNeedThread() const { return false; }
 
         void SetItemId(unsigned id) { fItemId = id; }
         void SetItemSubId(unsigned id) { fSubId = id; SetWorkerCfgId((int)id); }
 
         void SetItemPriority(int pri = -1) { SetWorkerPriority((pri < 0) ? 1 : pri); }
 
         virtual void DoStart() {}
         virtual void DoStop() {}
 
         virtual void DoCleanup() {}
 
         void StopModule();
 
         void StartModule();
 
      public:
         virtual ~ModuleItem();
 
         inline int GetType() const { return fItemType; }
         inline unsigned ItemId() const { return fItemId; }
         inline unsigned ItemSubId() const { return fSubId; }
   };
 
 
   // _____________________________________________________________________
 
   class ModuleItemRef : public WorkerRef {
      DABC_REFERENCE(ModuleItemRef, WorkerRef, ModuleItem)
 
      WorkerRef GetModule() const;
 
      unsigned ItemId() const { return GetObject() ? GetObject()->ItemId() : 0; }
 
      unsigned ItemSubId() const { return GetObject() ? GetObject()->ItemSubId() : 0; }
 
      std::string InfoParName() const;
   };
 
   // ==================================================================================
 
   class Timer : public ModuleItem {
 
      friend class Module;
 
      protected:
         bool        fSysTimer;   
         double      fPeriod;   // period of timer events
         long        fCounter;  // number of generated events
         bool        fActive;   // is timer active
         bool        fSynhron; // indicate if timer tries to keep number of events per second
         double      fInaccuracy; // accumulated inaccuracy of timer in synchron mode
         WorkerRef   fTimerSrc;   // source for the timer
 
         virtual bool ItemNeedThread() const { return !IsSysTimer(); }
 
         bool IsSysTimer() const { return fSysTimer; }
 
         void SingleShoot(double delay) { ActivateTimeout(delay); }
 
         virtual ~Timer();
 
         double GetPeriod() const { return fPeriod; }
         void SetPeriod(double v) { fPeriod = v; }
 
         bool IsSynchron() const { return fSynhron; }
         void SetSynchron(bool on = true) { fSynhron = on; }
 
         long GetCounter() const { return fCounter; }
 
         virtual void DoStart();
         virtual void DoStop();
         virtual void DoCleanup() { fTimerSrc.Release(); }
 
         virtual double ProcessTimeout(double last_diff);
 
      private:
         Timer(Reference parent, bool systimer, const std::string &name, double timeout = -1., bool synchron = false);
 
   };
 
   // ==================================================================================
 
   class ConnTimer : public ModuleItem {
      friend class Module;
 
      protected:
 
         std::string fPortName;        
         bool fErrorFlag;              
 
         virtual bool ItemNeedThread() const { return true; }
 
         virtual double ProcessTimeout(double last_diff);
 
         void Activate(double period) { ActivateTimeout(period); }
 
      private:
 
         ConnTimer(Reference parent, const std::string &name, const std::string &portname);
   };
 
}
 
#endif