ModuleAsync.h

Go to the documentation of this file.

// $Id: ModuleAsync.h 4210 2019-02-12 19:55:03Z 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_ModuleAsync
#define DABC_ModuleAsync
 
#ifndef DABC_Module
#include "dabc/Module.h"
#endif
 
namespace dabc {
 
   class ModuleAsync : public Module {
      private:
         virtual bool DoStart();
 
         virtual void ProcessItemEvent(ModuleItem* item, uint16_t evid);
 
      protected:
         ModuleAsync(const std::string &name, Command cmd = nullptr) : Module(name, cmd) { }
 
         virtual ~ModuleAsync();
 
         bool CanSend(unsigned indx = 0) const
            { return indx < fOutputs.size() ? fOutputs[indx]->CanSend() : false; }
 
         unsigned NumCanSend(unsigned indx = 0) const
            { return indx < fOutputs.size() ? fOutputs[indx]->NumCanSend() : false; }
 
         void ActivateOutput(unsigned port = 0);
 
         bool Send(unsigned indx, Buffer& buf)
         {
            if (indx < fOutputs.size())
               return fOutputs[indx]->Send(buf);
            buf.Release();
            return false;
         }
 
         inline bool Send(Buffer& buf)
           { return Send(0, buf); }
 
         bool CanRecv(unsigned indx = 0) const
            { return indx < fInputs.size() ? fInputs[indx]->CanRecv() : false; }
 
         unsigned NumCanRecv(unsigned indx = 0) const
           { return indx < fInputs.size() ? fInputs[indx]->NumCanRecv() : 0; }
 
         BufferSize_t TotalSizeCanRecv(unsigned indx = 0) const
            { return indx < fInputs.size() ? fInputs[indx]->TotalSizeCanRecv() : 0; }
 
         Buffer Recv(unsigned indx = 0)
            { return indx < fInputs.size() ? fInputs[indx]->Recv() : Buffer(); }
 
         bool RecvQueueFull(unsigned port = 0);
 
         void SignalRecvWhenFull(unsigned port = 0);
 
         void ActivateInput(unsigned port = 0);
 
         Buffer RecvQueueItem(unsigned port = 0, unsigned nbuf = 0);
 
         bool SkipInputBuffers(unsigned indx = 0, unsigned nbuf = 1)
         { return indx < fInputs.size() ? fInputs[indx]->SkipBuffers(nbuf) : false; }
 
         bool CanTakeBuffer(unsigned pool = 0)
         { return pool < fPools.size() ? fPools[pool]->CanTakeBuffer() : false; }
 
         unsigned NumCanTake(unsigned pool = 0) const
            { return pool < fPools.size() ? fPools[pool]->NumCanTake() : 0; }
 
         Buffer TakeBuffer(unsigned pool = 0)
         { return (pool < fPools.size()) ? fPools[pool]->TakeBuffer() : ((pool==0) ? TakeDfltBuffer() : Buffer()); }
 
         Buffer PoolQueueItem(unsigned pool = 0, unsigned nbuf = 0);
 
         void ActivatePool(unsigned pool);
 
         // here is a list of methods,
         // which can be reimplemented in user code
 
         // Level 1: Or one can redefine one or several following methods to
         // react on specific events only
 
         virtual void ProcessInputEvent(unsigned port);
 
 
         virtual void ProcessOutputEvent(unsigned port);
 
 
         virtual void ProcessPoolEvent(unsigned pool);
 
         virtual void ProcessConnectEvent(const std::string &name, bool on) {}
 
         virtual void ProcessTimerEvent(unsigned timer) {}
 
         virtual void ProcessUserEvent(unsigned item) {}
 
 
         // Level 2: One could process each buffer
         // at this level user gets process calls for each new buffer
 
         virtual bool ProcessRecv(unsigned port = 0) { return false; }
 
         virtual bool ProcessSend(unsigned port = 0) { return false; }
 
         virtual bool ProcessBuffer(unsigned pool = 0) { return false; }
 
      public:
 
         virtual const char* ClassName() const { return "ModuleAsync"; }
 
   };
 
   // ____________________________________________________________
 
   class ModuleAsyncRef : public ModuleRef {
      DABC_REFERENCE(ModuleAsyncRef, ModuleRef, ModuleAsync)
   };
 
};
 
#endif