Parameter.h

Go to the documentation of this file.

// $Id: Parameter.h 4472 2020-04-15 13:33: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_Parameter
#define DABC_Parameter
 
#ifndef DABC_Record
#include "dabc/Record.h"
#endif
 
#ifndef DABC_timing
#include "dabc/timing.h"
#endif
 
#ifndef DABC_threads
#include "dabc/threads.h"
#endif
 
#include <cstring>
 
namespace dabc {
 
   class Worker;
   class Command;
   class Manager;
   class Parameter;
 
   enum EParamEvent {
      parCreated = 0,      
      parConfigured = 1,   
      parModified = 2,     
      parDestroy = 3       
   };
 
   class ParameterContainer : public RecordContainer {
      friend class Parameter;
      friend class Worker;
      friend class Manager;
 
      protected:
 
         enum EStatistic { kindNone, kindRate, kindAverage };
 
         std::string   fKind;         
         TimeStamp     fLastChangeTm; 
         double        fInterval;     
         bool          fAsynchron;    
         EStatistic    fStatistic;    
         double        fRateValueSum; 
         double        fRateTimeSum;  
         double        fRateNumSum;   
         bool          fMonitored;    
         bool          fRecorded;     
         bool          fWaitWorker;   
         bool          fAttrModified; 
         bool          fDeliverAllEvents; 
         int           fRateWidth;    
         int           fRatePrec;     
 
 
         virtual std::string DefaultFiledName() const;
 
         virtual bool HasField(const std::string &name) const
         { LockGuard guard(ObjectMutex()); return RecordContainer::HasField(name); }
 
         virtual bool RemoveField(const std::string &name)
         { LockGuard guard(ObjectMutex()); return RecordContainer::RemoveField(name); }
 
         virtual unsigned NumFields() const
           { LockGuard guard(ObjectMutex()); return RecordContainer::NumFields(); }
 
         virtual std::string FieldName(unsigned cnt) const
            { LockGuard guard(ObjectMutex()); return RecordContainer::FieldName(cnt); }
 
         virtual RecordField GetField(const std::string &name) const;
 
         virtual bool SetField(const std::string &name, const RecordField& v);
 
         void ProcessTimeout(double last_dif);
 
         ParameterContainer(Reference worker, const std::string &name, const std::string &parkind = "", bool hidden = false);
         virtual ~ParameterContainer();
 
         inline void Modified() { FireParEvent(parModified); }
 
         virtual bool _CanChangeField(const std::string&) { return true; }
 
         void FireParEvent(int id);
 
         virtual void ObjectCleanup();
 
         bool _CalcRate(double& value, std::string& svalue);
 
         void SetSynchron(bool on, double interval = 1., bool everyevnt = false);
 
         Worker* GetWorker() const;
 
         int GetDebugLevel() const { return GetField("debug").AsInt(-1); }
 
         const std::string GetActualUnits() const;
 
         bool IsDeliverAllEvents() const;
 
         void FireModified(const std::string &svalue);
 
         virtual void BuildFieldsMap(RecordFieldsMap* cont);
 
         unsigned ConfirmFromWorker();
 
      public:
 
         virtual const char* ClassName() const { return "Parameter"; }
 
         const std::string &Kind() const;
   };
 
   // _______________________________________________________________________
 
   class Parameter : public Record {
 
      friend class Worker;
      friend class Manager;
 
      protected:
 
         virtual const char* ParReferenceKind() { return nullptr; }
 
         // These method is set parameter fields, specified in the command
         int ExecuteChange(Command cmd);
 
         bool TakeAttrModified();
 
         void FireConfigured();
 
         template<class T>
         bool verify_object(Object* src, T* &tgt)
         {
            // TODO: should we implement this method ???
            tgt = dynamic_cast<T*>(src);
            if (!tgt) return false;
            const char* refkind = ParReferenceKind();
            if (!refkind) return true;
            return tgt->Kind() == refkind;
         }
 
      public:
 
         DABC_REFERENCE(Parameter, Record, ParameterContainer)
 
         
         RecordField Value() const { return GetField(""); }
 
         bool SetValue(const RecordField& v) { return SetField("", v); }
 
         bool Dflt(const RecordField& v) { return Value().null() ? SetValue(v) : false; }
 
         bool NeedTimeout();
 
         bool IsMonitored();
 
         Reference GetWorker() const;
 
         Parameter &SetSynchron(bool on, double interval = 1., bool everyevnt = false);
 
         Parameter &SetRatemeter(bool synchron = false, double interval = 1.0);
 
         bool IsRatemeter() const;
 
         Parameter &DisableRatemeter();
 
         Parameter &SetAverage(bool synchron = false, double interval = 1.0);
 
         Parameter &DisableAverage();
 
         bool IsAverage() const;
 
         Parameter &SetMonitored(bool on = true);
 
         Parameter &SetDebugOutput(bool on = true, int level = 1) { return SetDebugLevel(on ? level : -1); }
         Parameter &SetDebugLevel(int level = 1) { SetField("debug", level); return *this; }
         int GetDebugLevel() const;
 
         Parameter &SetWidthPrecision(unsigned width, unsigned prec);
 
         Parameter &SetUnits(const std::string &unit) { SetField("units", unit); return *this; }
 
         const std::string GetUnits() const { return GetField("units").AsStr(); }
 
         const std::string GetActualUnits() const;
 
         void SetLowerLimit(double low) { SetField("low", low); }
         double GetLowerLimit() const { return GetField("low").AsDouble(); }
 
         void SetUpperLimit(double up) { SetField("up", up); }
         double GetUpperLimit() const { return GetField("up").AsDouble(); }
 
         Parameter& SetLimits(double low, double up) { SetLowerLimit(low); SetUpperLimit(up); return *this; }
 
         Parameter &SetFld(const std::string &name, const RecordField &v) { SetField(name, v); return *this; }
 
         const std::string Kind() const;
 
         void FireModified();
 
         void ScanParamFields(RecordFieldsMap* cont)
         {
            if (GetObject())
               GetObject()->BuildFieldsMap(cont);
         }
 
         bool SubmitSetValue(const RecordField& v);
   };
 
   // ___________________________________________________________________________________
 
   class InfoParameter : public Parameter {
 
      protected:
         // by this we indicate that only parameter specified as info can be referenced
         virtual const char* ParReferenceKind() { return infokind(); }
 
      public:
 
         DABC_REFERENCE(InfoParameter, Parameter, ParameterContainer)
 
         void SetInfo(const std::string &info) { SetValue(info); }
         std::string GetInfo() const { return Value().AsStr(); }
 
         void SetColor(const std::string &name) { SetField("color", name); }
         std::string GetColor() const { return GetField("color").AsStr("Green"); }
 
         void SetVerbosity(int level) { SetField("verbosity", level); }
         int GetVerbosity() const { return GetField("verbosity").AsInt(1); }
 
         static const char* infokind() { return "info"; }
   };
 
   // _______________________________________________________________________________
 
   class CommandDefinition : public Record {
 
      protected:
         // by this we indicate that only parameter specified as info can be referenced
 
         std::string ArgName(int n) const;
 
      public:
 
         DABC_REFERENCE(CommandDefinition, Record, RecordContainer)
 
         CommandDefinition& AddArg(const std::string &name, const std::string &kind = "string", bool required = true, const RecordField& dflt = RecordField());
 
         CommandDefinition& SetArgMinMax(const std::string &name, const RecordField& min, const RecordField& max);
 
         int NumArgs() const;
 
         int FindArg(const std::string &name) const;
 
         bool HasArg(const std::string &name) const { return FindArg(name) >=0; }
 
         bool GetArg(int n, std::string& name, std::string& kind, bool& required, std::string& dflt) const;
 
         Command MakeCommand() const;
   };
 
}
 
#endif