ConnectionRequest.h

Go to the documentation of this file.

// $Id: ConnectionRequest.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_ConnectionRequest
#define DABC_ConnectionRequest
 
#ifndef DABC_Parameter
#include "dabc/Parameter.h"
#endif
 
#ifndef DABC_Command
#include "dabc/Command.h"
#endif
 
#ifndef DABC_ConfigBase
#include "dabc/ConfigBase.h"
#endif
 
namespace dabc {
 
   class Device;
   class Port;
   class Module;
   class ConnectionManager;
   class ConnectionRequest;
   class ConnectionRequestFull;
 
 
   class ConnectionObject : public ParameterContainer {
      public:
 
         enum EState {
            sInit,          
            sPending,       
            sConnecting,    
            sConnected,     
            sDisconnected,  
            sBroken,        
            sFailed         
         };
 
      protected:
 
         friend class Port;
         friend class ConnectionManager;
         friend class ConnectionRequest;
         friend class ConnectionRequestFull;
 
         EState        fConnState;    
 
         std::string   fLocalUrl;     
 
         std::string   fPoolName;     
 
         // these are fields used only by connection manager and devices from their threads
         // connection manager for a time of connection keep reference on the connection
         // object and use these fields for establishing of connection
         // these fields used by conn mgr and devices, therefore protected by mutex
 
         int          fProgress;
 
         std::string  fServerId;     
         std::string  fClientId;     
         Reference    fCustomData;   
         std::string  fConnId;       
         Command      fRemoteCmd;    
         int          fInlineDataSize;   
 
         // these fields and methods used only by connection manager
         // therefore it is enough to have reference on it (no mutex required)
         double       fAccDelay;    
         double       fSetDelay;    
 
         std::string  fAllowedField;  
 
         ConnectionObject(Reference port, const std::string &localurl);
         virtual ~ConnectionObject();
 
         virtual bool _CanChangeField(const std::string&);
 
         virtual std::string DefaultFiledName() const;
 
         void ChangeState(EState state, bool force);
 
         ConnectionObject::EState GetState();
 
         void SetDelay(double v, bool force = false)
         {
            if (force) {
               fSetDelay = 0.;
               fAccDelay = v;
            } else {
               if (v>0) fSetDelay = v;
                   else fSetDelay = 0.;
               fAccDelay = 0.;
            }
         }
 
         double CheckDelay(double shift)
         {
            if (fSetDelay > 0.) {
               fAccDelay = fSetDelay;
               fSetDelay = 0;
               return fAccDelay;
            }
 
            fAccDelay -= shift;
            return fAccDelay;
         }
 
      public:
         virtual const char* ClassName() const { return "ConnectionObject"; }
 
         static const char* ObjectName() { return "Connection"; }
 
         static const char* GetStateName(EState state);
   };
 
 
#define GET_PAR_FIELD( field_name, defvalue ) \
    if (GetObject()) { \
       LockGuard guard(GetObject()->fObjectMutex); \
       return GetObject()-> field_name; \
    } \
    return defvalue;
 
#define SET_PAR_FIELD( field_name, value ) \
  if (GetObject()) { \
     LockGuard guard(GetObject()->fObjectMutex); \
     GetObject()-> field_name = value; \
   }
 
 
   // _______________________________________________________________________________
 
   class ConnectionRequest : public Parameter {
 
      friend class Port;
      friend class Module;
      friend class ConnectionManager;
 
      DABC_REFERENCE(ConnectionRequest, Parameter, ConnectionObject)
 
      
      virtual ~ConnectionRequest() { ChangeState(ConnectionObject::sPending, false); }
 
      ConnectionObject::EState GetState() const { return GetObject() ? GetObject()->GetState() : ConnectionObject::sInit; }
 
      Reference GetPort() const { return Reference(GetObject() ? GetObject()->GetParent() : 0); }
 
      std::string GetLocalUrl() const { GET_PAR_FIELD(fLocalUrl,"") }
 
      std::string GetPoolName() const { GET_PAR_FIELD(fPoolName,"") }
      void SetPoolName(const std::string &name) { SET_PAR_FIELD(fPoolName, name) }
 
      std::string GetRemoteUrl() const { return GetField("url").AsStr(); }
 
      bool IsServerSide() const { return GetField("server").AsBool(false); }
 
      bool IsOptional() const { return GetField(xmlOptionalAttr).AsBool(false); }
 
      std::string GetConnDevice() const { return GetField(xmlDeviceAttr).AsStr(); }
 
      std::string GetConnThread() const { return GetField(xmlThreadAttr).AsStr(); }
 
      bool GetUseAckn() const { return GetField(xmlUseacknAttr).AsBool(false); }
 
      double GetConnTimeout() const { return GetField(xmlTimeoutAttr).AsDouble(10.); }
 
      // fields can be changed only in initial state right after creation of the request
      void SetRemoteUrl(const std::string &url) { SetField("url", url); }
 
      void SetServerSide(bool isserver = true) { SetField("server", isserver); }
 
      void SetConnDevice(const std::string &dev) { SetField(xmlDeviceAttr, dev); }
 
      void SetOptional(bool on = true) { SetField(xmlOptionalAttr, on); }
 
      void SetUseAckn(bool on = true) { SetField(xmlUseacknAttr, on); }
 
      void SetConnTimeout(double tm) { SetField(xmlTimeoutAttr, tm); }
 
      void SetConnThread(const std::string &name) { SetField(xmlThreadAttr, name); }
 
      void SetConfigFromXml(XMLNodePointer_t node);
 
      protected:
 
      void ChangeState(ConnectionObject::EState state, bool force);
 
      void SetInitState() { ChangeState(ConnectionObject::sInit, true); }
 
      void SetAllowedField(const std::string &name = "");
 
      virtual const char* ParReferenceKind() { return "connection"; }
 
   };
 
}
 
 
#endif