Command.h

Go to the documentation of this file.

// $Id: Command.h 4467 2020-04-15 12:35:01Z 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_Command
#define DABC_Command
 
#ifndef DABC_Record
#include "dabc/Record.h"
#endif
 
#ifndef DABC_timing
#include "dabc/timing.h"
#endif
 
#include <list>
 
 
namespace dabc {
 
   class CommandsQueue;
   class Worker;
   class Thread;
 
   enum CommandRes {
      cmd_false = 0,
      cmd_true = 1,
 
      cmd_timedout = -1,     // command execution timedout
      cmd_ignore   = -2,     // returned when command was ignored or rejected
      cmd_postponed = -3,    // command will be executed later
      cmd_noresult = -4,
      cmd_canceled = -5
   };
 
 
   class CommandContainer : public RecordContainer {
 
      friend class Command;
 
      protected:
 
         struct CallerRec {
            Worker       *worker{nullptr};      
            bool         *exe_ready{nullptr};   
            CallerRec() = default;
            CallerRec(Worker* w, bool* e) : worker(w), exe_ready(e) {}
            CallerRec(const CallerRec& src) : worker(src.worker), exe_ready(src.exe_ready) {}
 
            CallerRec& operator=(CallerRec& src)
            {
               worker = src.worker;
               exe_ready = src.exe_ready;
               return *this;
            }
         };
 
         std::list<CallerRec> fCallers;     
         TimeStamp            fTimeout;     
         bool                 fCanceled;    
 
         // make destructor protected that nobody can delete command directly
         CommandContainer(const std::string &name = "Command");
 
         virtual ~CommandContainer();
 
         virtual const char* ClassName() const { return "Command"; }
   };
 
   class Command : public Record {
 
      DABC_REFERENCE(Command, Record, CommandContainer)
 
      friend class CommandContainer;
      friend class CommandsQueue;
      friend class Worker;
      friend class Thread;
 
      private:
 
         void AddCaller(Worker *worker, bool *exe_ready = nullptr);
         void RemoveCaller(Worker *worker, bool *exe_ready = nullptr);
 
         bool IsLastCallerSync();
 
      protected:
 
         virtual void CreateRecord(const std::string &name) { SetObject(new CommandContainer(name)); }
 
      public:
         // Command() {}
 
         Command(const std::string &name) throw();
 
         void ChangeName(const std::string &name);
 
         friend int operator==(const Command& cmd1, const Command& cmd2)
                         { return cmd1() == cmd2(); }
 
         // set of methods to keep old interface, it is preferable to use field methods
 
         bool SetStr(const std::string &name, const char* value) { return value==0 ? RemoveField(name) : SetField(name, value); }
         bool SetStr(const std::string &name, const std::string &value) { return SetField(name, value); }
         std::string GetStr(const std::string &name, const std::string &dflt = "") const { return GetField(name).AsStr(dflt); }
 
         bool SetInt(const std::string &name, int v) { return SetField(name, v); }
         int GetInt(const std::string &name, int dflt = 0) const { return GetField(name).AsInt(dflt); }
 
         bool SetBool(const std::string &name, bool v) { return SetField(name, v); }
         bool GetBool(const std::string &name, bool dflt = false) const { return GetField(name).AsBool(dflt); }
 
         bool SetDouble(const std::string &name, double v) { return SetField(name, v); }
         double GetDouble(const std::string &name, double dflt = 0.) const { return GetField(name).AsDouble(dflt); }
 
         bool SetUInt(const std::string &name, unsigned v) { return SetField(name, v); }
         unsigned GetUInt(const std::string &name, unsigned dflt = 0) const { return GetField(name).AsUInt(dflt); }
 
         void SetPtr(const std::string &name, void* p);
         void* GetPtr(const std::string &name, void* deflt = 0) const;
 
         bool SetRef(const std::string &name, Reference ref);
 
         Reference GetRef(const std::string &name);
 
         bool SetRawData(Buffer rawdata);
 
         bool SetStrRawData(const std::string &str);
 
         Buffer GetRawData();
 
         void AddValuesFrom(const Command& cmd, bool canoverwrite = true);
 
         void SetResult(int res) { SetInt(ResultParName(), res); }
         int GetResult() const { return GetInt(ResultParName(), cmd_false); }
         void ClearResult() { RemoveField(ResultParName()); }
         bool HasResult() const { return HasField(ResultParName()); }
 
         Command& SetTimeout(double tm);
 
         bool IsTimeoutSet() const;
 
         double TimeTillTimeout(double extra = 0.) const;
 
         bool IsTimedout() const { return TimeTillTimeout() == 0.; }
 
         void ResetTimeout() { SetTimeout(-1); }
 
         bool ReadFromCmdString(const std::string &str);
 
         void SetPriority(int prio) { SetInt(PriorityParName(), prio); }
 
         int GetPriority() const;
 
         void Print(int lvl=0, const char* from = nullptr) const;
 
         void Reply(int res = cmd_noresult);
 
         void ReplyFalse() { Reply(cmd_false); }
 
         void ReplyTrue() { Reply(cmd_true); }
 
         void ReplyBool(bool res) { Reply(res ? cmd_true : cmd_false); }
 
         void ReplyTimedout() { Reply(cmd_timedout); }
 
         void Release();
 
         void Cancel();
 
         bool IsCanceled();
 
         Command& SetReceiver(const std::string &itemname)
           { SetStr(ReceiverParName(), itemname); return *this; }
 
         std::string GetReceiver() const { return GetStr(ReceiverParName()); }
         void RemoveReceiver() { RemoveField(ReceiverParName()); }
 
         static const char* ReceiverParName() { return "_Receiver_"; }
 
         static const char* ResultParName() { return "_Result_"; }
 
         static const char* PriorityParName() { return "_Priority_"; }
   };
 
 
#define DABC_COMMAND(cmd_class, cmd_name) \
   public: \
      static const char* CmdName() { return cmd_name; } \
      cmd_class() : dabc::Command(CmdName()) {} \
      cmd_class(const dabc::Command& src) : dabc::Command(src) \
        { if (!src.IsName(CmdName())) throw dabc::Exception(dabc::ex_Command, "Wrong command name in assignment constructor", src.GetName()); } \
      cmd_class& operator=(const cmd_class& cmd) { dabc::Command::operator=(cmd); return *this; } \
      cmd_class& operator=(const dabc::Command& cmd) { \
         if (!cmd.IsName(CmdName())) throw dabc::Exception(dabc::ex_Command, "Wrong command name in assignment operator", cmd.GetName()); \
         dabc::Command::operator=(cmd); return *this;  \
      }
 
}
 
#endif