ModuleSync.h

Go to the documentation of this file.

// $Id: ModuleSync.h 3862 2018-05-11 10:06:18Z 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_ModuleSync
#define DABC_ModuleSync
 
#ifndef DABC_Module
#include "dabc/Module.h"
#endif
 
 
namespace dabc {
 
   class ModuleSync : public Module {
      private:
         bool           fTmoutExcept;
 
         bool           fDisconnectExcept;
 
         bool           fSyncCommands;
 
         CommandsQueue* fNewCommands;
 
         ModuleItem*   fWaitItem;
 
         uint16_t      fWaitId;
 
         bool          fWaitRes;
 
         bool          fInsideMainLoop;
 
         virtual void DoWorkerMainLoop();
 
         virtual void DoWorkerAfterMainLoop();
 
         /* Internal - central method for blocking functionality.
          * Block main loop and waits for dedicated event.
          * Keep processing of other events or commands.
          * Used in framework to rise exceptions when module should be stopped */
         bool WaitItemEvent(double& tmout,
                            ModuleItem* item = 0,
                            uint16_t *resevid = 0,
                            ModuleItem** resitem = 0);
 
         void AsyncProcessCommands();
 
         virtual int PreviewCommand(Command cmd);
 
         virtual void ProcessItemEvent(ModuleItem* item, uint16_t evid);
 
      protected:
 
         void StopUntilRestart();
 
         virtual void ObjectCleanup();
 
         ModuleSync(const std::string &name, Command cmd = nullptr);
 
         virtual ~ModuleSync();
 
         bool ModuleWorking(double timeout = 0.);
 
         virtual void MainLoop() = 0;
 
         uint16_t WaitEvent(double timeout = -1);
 
         bool WaitConnect(const std::string &name, double timeout = -1);
 
         bool WaitInput(unsigned indx, unsigned minqueuesize = 1, double timeout = -1);
 
         bool CanRecv(unsigned indx = 0) const
            { return indx < fInputs.size() ? fInputs[indx]->CanRecv() : false; }
 
         Buffer Recv(unsigned indx = 0, double timeout = -1);
 
         bool Send(unsigned indx, Buffer& buf, double timeout = -1);
 
         bool Send(Buffer& buf, double timeout = -1)
            { return Send(0, buf, timeout); }
 
         Buffer RecvFromAny(unsigned* port = 0, double timeout = -1);
 
         Buffer TakeBuffer(unsigned pool = 0, double timeout = -1);
 
         void SetTmoutExcept(bool on = true) { fTmoutExcept = on; }
 
         bool IsTmoutExcept() const { return fTmoutExcept; }
 
         void SetDisconnectExcept(bool on = true) { fDisconnectExcept = on; }
 
         bool IsDisconnectExcept() const { return fDisconnectExcept; }
 
         void SetSyncCommands(bool on = true) { fSyncCommands = on; }
 
         bool IsSyncCommands() const { return fSyncCommands; }
 
      public:
 
         virtual const char* ClassName() const { return "ModuleSync"; }
 
   };
}
 
#endif