INOS
cinostaskex.h
Go to the documentation of this file.
1 //******************************************************************************
26 //******************************************************************************
27 
28 #ifndef INC_CINOSTASKEX_H
29 #define INC_CINOSTASKEX_H
30 
31 //
32 //------------------------------------------------------------------------------
33 // includes
34 //------------------------------------------------------------------------------
35 //
36 // system
37 #include <inos.h>
38 #include <inos_lib.h>
39 #include <cinosbus.h>
40 #include <cinosmcnvram.h>
41 #include <cmcresult.h>
42 #include <cinostaskexdef.h>
43 #include <cincotype.h>
44 #include <cinoseventloggerdef.h>
45 #include <cinostaskexstatesdef.h>
46 #include <cinosmcdata.h>
47 
48 #ifdef INOS_INCOV
49 #include <cincovdispatcher.h>
50 #endif
51 //
52 // C++
53 #include <unordered_map>
54 #include <string>
55 #include <atomic>
56 
57 //
58 // project
59 //
60 //------------------------------------------------------------------------------
61 // defines
62 //------------------------------------------------------------------------------
63 //
64 #ifdef _MSC_VER
65 #define INOS_TASKEX_MESSAGE( apFormat, ... ) \
66  InternLog( DF_INOS_EVENT_LOGGER_LEVEL_TASKMSG, \
67  DF_INOS_EVENT_LOGGER_FONT_COLOR_BLUE, apFormat, __VA_ARGS__ )
68 #else
69 #define INOS_TASKEX_MESSAGE( apFormat, aArgs... ) \
70  InternLog( DF_INOS_EVENT_LOGGER_LEVEL_TASKMSG, \
71  DF_INOS_EVENT_LOGGER_FONT_COLOR_BLUE, apFormat, ##aArgs )
72 #endif
73 //
74 #define DF_INOS_TASKEX_MAX_CMD 128 // max. number of commands (for statistics)
75 #define DF_INOS_TASKEX_MAX_AND_TRG 4 // max. number of 'and' trigger
76 #define DF_INOS_TASKEX_MAX_TRG_VAL_NAME 256 // max. allowed trigger value name length
77 #define DF_INOS_TASKEX_STARTUP_PRIO DF_INOS_TASK_PRIO_USER_HIGHEST // taskex startup priority
78 
79 #define INOS_MCLOG_REPLY_EX(aMsg,rpl,err) \
80  { \
81  if( CINOSEventLogger::Instance().IsLevelActive(DF_INOS_EVENT_LOGGER_LEVEL_TASKMSG) ) { \
82  if (!aMsg->GetNoTrace()) { \
83  double tim = double(0.000001)*g_pTarget->ConvertToNanoSeconds(GetSystemTicks()); \
84  InternLog( DF_INOS_EVENT_LOGGER_LEVEL_TASKMSG, \
85  DF_INOS_EVENT_LOGGER_FONT_COLOR_BLUE, \
86  "RPL:TimStp,%f:Rec,%s:Id," PFIID ":Snd,%s:Que,%1.6fms:Typ," PFU32 ":Ret," PF0X32,\
87  tim, GetName(), aMsg->GetId(), GetName(), tim, (uint32)rpl, (uint32) err);\
88  } \
89  } \
90  }
91 
92 // macro to 'force' a mclog conform message reply in the eventlog
93 #define INOS_MCLOG_REPLY(aMsg) INOS_MCLOG_REPLY_EX(aMsg,eRplOk,0)
94 
95 //------------------------------------------------------------------------------
96 // forward declarations
97 //------------------------------------------------------------------------------
98 
99 class CINOSMcMessage;
100 class CINOSMcNvRam;
101 class CINOSMcData;
102 class CINOSMcDataInst;
103 class CINOSTaskEx;
104 class CINOSTaskExCmdBase;
105 class CINOSTaskExCmdHookBase;
106 
107 #ifdef INOS_INCOV
108 class CINCOVServerSession;
109 class CINCOVOperation;
110 class SINCOVLazyContext;
111 #endif
112 
113 //------------------------------------------------------------------------------
114 // class CINOSTaskExMsgTrigger
115 //------------------------------------------------------------------------------
116 //
117 class CINOSTaskExMsgTrigger
118 {
119  friend class CINOSTaskEx;
120  friend class CINOSTaskExMsg;
121 
122  // public members
123  public :
125  enum {
126  eTypVar,
127  eTypEvent,
128  eTypTicks
129  };
131  uint32 GetType()
132  { return m_uType;};
133 
134  // protected members
135  protected :
137  explicit CINOSTaskExMsgTrigger (uint32 auType)
138  { m_uType = auType;};
140  virtual ~CINOSTaskExMsgTrigger()
141  {};
143  uint32 m_uType;
144 
146  DECLARE_DYNAMIC(CINOSTaskExMsgTrigger);
147 };
148 //
149 //------------------------------------------------------------------------------
150 // class CINOSTaskExMsgTriggerVar
151 //------------------------------------------------------------------------------
152 //
153 class CINOSTaskExMsgTriggerVar : public CINOSTaskExMsgTrigger
154 {
155  friend class CINOSTaskEx;
156  friend class CINOSTaskExMsg;
157 
158  // public members
159  public :
161  CINOSTaskExMsgTriggerVar (const char* apVarName, const char* apCompare,
162  real64 arValue);
164  CINOSTaskExMsgTriggerVar (const char* apVarName, const char* apCompare,
165  const char* apValue);
167  virtual ~CINOSTaskExMsgTriggerVar();
169  const char* GetName()
170  { return &m_cName[0];};
172  const char* GetCompare()
173  { return &m_cCompare[0];};
175  real64 GetValue(CINOSMcData* apData=0);
176 
177  // protected members
178  protected :
180  char m_cName[64];
182  char m_cCompare[8];
184  real64 m_rValue;
186  char* m_pValue;
187 
189  DECLARE_DYNAMIC(CINOSTaskExMsgTriggerVar);
190 };
191 //
192 //------------------------------------------------------------------------------
193 // class CINOSTaskExMsgTriggerEvent
194 //------------------------------------------------------------------------------
195 //
196 class CINOSTaskExMsgTriggerEvent : public CINOSTaskExMsgTrigger
197 {
198  friend class CINOSTaskEx;
199  friend class CINOSTaskExMsg;
200 
201  // public members
202  public :
204  CINOSTaskExMsgTriggerEvent (const char* apSynName, real64 arParamValue,
205  const char* apParamType, const char* apTaskName, const char* apCmdName,
206  const char* apEventName);
208  CINOSTaskExMsgTriggerEvent (const char* apSynName, const char* apParamValue,
209  const char* apParamType, const char* apTaskName, const char* apCmdName,
210  const char* apEventName);
212  virtual ~CINOSTaskExMsgTriggerEvent();
214  const char* GetSynName()
215  { return &m_cSynName[0];};
217  const char* GetTaskName()
218  { return &m_cTaskName[0];};
220  const char* GetCmdName()
221  { return &m_cCmdName[0];};
223  const char* GetEventName()
224  { return &m_cEventName[0];};
226  const char* GetParamType()
227  { return &m_cParamType[0];};
229  real64 GetParamValue(CINOSMcData* apData=0);
230 
231  // protected members
232  protected :
234  inosName32 m_cSynName;
236  inosName64 m_cTaskName;
238  inosName64 m_cCmdName;
240  inosName32 m_cEventName;
242  char m_cParamType[8];
244  real64 m_rParamValue;
246  char* m_pParamValue;
247 
249  DECLARE_DYNAMIC(CINOSTaskExMsgTriggerEvent);
250 };
251 //
252 //------------------------------------------------------------------------------
253 // class CINOSTaskExMsgTriggerTicks
254 //------------------------------------------------------------------------------
255 //
256 class CINOSTaskExMsgTriggerTicks : public CINOSTaskExMsgTrigger
257 {
258  friend class CINOSTaskEx;
259  friend class CINOSTaskExMsg;
260 
261  // public members
262  public :
264  CINOSTaskExMsgTriggerTicks (const char* apSynName, real64 arParamValue,
265  const char* apParamType, uint64 auBusTicks, uint8 auBusId);
267  virtual ~CINOSTaskExMsgTriggerTicks()
268  {};
270  const char* GetSynName()
271  { return &m_cSynName[0];};
273  const char* GetParamType()
274  { return &m_cParamType[0];};
276  real64 GetParamValue()
277  { return m_rParamValue;};
279  uint64 GetBusTicks()
280  { return m_uBusTicks;};
282  uint64 GetBusId()
283  { return m_uBusId;};
285  void AdjTicksMs(int32 aiMs);
287  void AdjTicks(int32 aiTicks)
288  { m_uBusTicks += aiTicks;};
289 
290  // protected members
291  protected :
293  inosName32 m_cSynName;
295  char m_cParamType[8];
297  real64 m_rParamValue;
299  uint64 m_uBusTicks;
300  //; bus id
301  uint8 m_uBusId;
302 
304  DECLARE_DYNAMIC(CINOSTaskExMsgTriggerTicks);
305 };
306 //
307 //------------------------------------------------------------------------------
308 // class CINOSTaskExMsgNode
309 //------------------------------------------------------------------------------
310 //
311 class CINOSTaskExMsgNode
312 {
313  friend class CINOSTaskEx;
315  CINOSTaskExMsgNode (CINOSTaskEx* apTask, CINOSTaskExMsg* apMsg)
316  { m_pTask = apTask; m_pMsg = apMsg; m_pNext=0;};
318  CINOSTaskEx* m_pTask;
320  CINOSTaskExMsg* m_pMsg;
322  CINOSTaskExMsgNode* m_pNext;
324  DECLARE_DYNAMIC(CINOSTaskExMsgNode);
325 };
326 //
327 //------------------------------------------------------------------------------
328 // class CINOSTaskExDeferredMsg
329 //------------------------------------------------------------------------------
330 //
331 class CINOSTaskExDeferredMsg
332 {
333 public:
334  virtual CINOSTaskExMsg* GetMsg() { return m_pMsg; };
335 
336 private:
337  friend class CINOSTaskEx;
338  friend class CINOSMcModule;
339  friend class CINOSMcRobot;
341  CINOSTaskExDeferredMsg (CINOSTaskExMsg* apMsg, tMsgId auReplyId, void* apHandler,
342  void* apObject, bool abHandlesCommands)
343  { m_pMsg = apMsg; m_uReplyId = auReplyId; m_pHandler = apHandler;
344  m_pObject = apObject; m_pNext=0; m_pPrev = 0;
345  m_bHandlesCommands = abHandlesCommands;};
347  virtual ~CINOSTaskExDeferredMsg() {}
349  CINOSTaskExMsg* m_pMsg;
351  tMsgId m_uReplyId;
353  void* m_pHandler;
355  void* m_pObject;
357  bool m_bHandlesCommands;
359  CINOSTaskExDeferredMsg* m_pNext;
361  CINOSTaskExDeferredMsg* m_pPrev;
363  DECLARE_DYNAMIC(CINOSTaskExDeferredMsg);
364 };
365 //
366 //------------------------------------------------------------------------------
367 // class CINOSTaskExCmdDesc
368 //------------------------------------------------------------------------------
369 //
370 class CINOSTaskExCmdDesc
371 {
372  friend class CINOSTaskEx;
374  CINOSTaskExCmdDesc ();
376  uint32 m_uCount;
378  nvuint32* m_pCount;
380  uint64 m_uStart;
382  uint64 m_uTime;
384  uint64 m_uTotal;
386  DECLARE_DYNAMIC(CINOSTaskExCmdDesc);
387 };
388 
389 
390 //------------------------------------------------------------------------------
391 // class CINOSTaskExMsg
392 //------------------------------------------------------------------------------
393 //
394 class CINOSTaskEx;
395 class CINOSTaskExMsg
396 {
397  //--- user interface ---------------------------------------------------
398 
399  // public member functions
400  public :
402  CINOSTaskExMsg(uint32 auMsgType, uintptr auMsgCode,
403  CINOSSync* apSync = DF_INOS_ASYNCHRONOUS);
405  CINOSTaskExMsg(uint32 auMsgType, const char* apMsgName, uintptr auMsgCode=0);
407  CINOSTaskExMsg(const CINOSTaskExMsg& aMsg);
409  ~CINOSTaskExMsg();
410 
412  void FstParam()
413  { m_pTmpParam = 0;};
415  void LstParam()
416  { CINOSTaskExMsgParam* p = m_pParam;
417  while (p->m_pNext) p = p->m_pNext;
418  m_pTmpParam = p;
419  };
421  template<class T> CINOSTaskExMsgParam* AddParam(T);
423  template<class T> CINOSTaskExMsgParam* AddParam(const char* apName, T);
425  template<class T> CINOSTaskExMsgDefaultParam* AddDefaultParam(const char* apName, T aValue);
427  CINOSTaskExMsgParam* AddParam(const char* apName, char* apValue);
429  CINOSTaskExMsgParam* AddParam(const char* apName, const char* apValue);
431  CINOSTaskExMsgParam* AddParam (CINOSTaskExMsgParam* apParam);
433  CINOSTaskExMsgParam* AddJsonParam(const char* apJson);
434 
436  template<class T> T GetParam();
438  template<class T> T GetFirstParam();
440  char* GetParam();
441  CINOSTaskExMsgParam* GetParamPtr() {
442  return iGetParam();
443  }
445  char* GetFirstParam();
446  CINOSTaskExMsgParam* GetFirstParamPtr(bool abUseInternalIterator = true);
448  uint32 GetParamCnt() const
449  {return m_uParamCnt;};
450 
452  void FstResult()
453  { m_pTmpResult = 0;};
458  template<class T> void AddResult(T, const char* apResultName = NULL);
462  void AddResult(char* apValue, const char* apResultName = NULL);
466  void AddResult(const char* apValue, const char* apResultName = NULL);
467 
473  template<class T> void InsertResult(T, const char* apResultName = NULL);
478  void InsertResult(char* apValue, const char* apResultName = NULL);
483  void InsertResult(const char* apValue, const char* apResultName = NULL);
484 
490  template<class T> void AppendResult(T, const char* apResultName = NULL);
495  void AppendResult(char* apValue, const char* apResultName = NULL);
500  void AppendResult(const char* apValue, const char* apResultName = NULL);
501 
503  tMcAppError AddIncoItemAsResult(CINCOItem* apItem, bool abBitAsNumber = false);
506  void MoveResultsFromMcResult(CMcResult& aResult);
509  void MoveResultsToParams(CINOSTaskExMsg& aMsg);
511  void MoveParamsFromMsg(CINOSTaskExMsg* apMsg);
513  void AddResultsFromMsgParams(CINOSTaskExMsg* apMsg);
518  void AddResults(CINOSTaskExMsgParam* apMsgParam);
519 
521  template<class T> T GetResult();
523  char* GetResult();
525  uint32 GetResultCount() const;
527  CINOSTaskExMsgParam* GetFirstResultPtr();
529  void DestroyParams();
531  void DestroyResults();
533  void SetTrigger(real64 arValue);
535  void SetTrigger(uint64 auBusTicks, uint8 auBusId);
537  void SetTrigger(const char* apVarName, const char* apCompare,
538  real64 arValue);
540  void SetTrigger(const char* apVarName, const char* apCompare,
541  const char* apValue);
543  void SetTrigger(const char* apSynName, real64 arParamValue,
544  const char* apParamType, const char* apTaskName, const char* apCmdName,
545  const char* apEventName);
547  void SetTrigger(const char* apSynName, const char* apParamValue,
548  const char* apParamType, const char* apTaskName, const char* apCmdName,
549  const char* apEventName);
551  void SetTrigger(const char* apSynName, real64 arParamValue,
552  const char* apParamType, uint64 auBusTicks, uint8 auBusId);
554  CINOSTaskExMsgTrigger* GetTrigger()
555  { return m_pTrigger;};
557  void RemTrigger()
558  { if (m_pTrigger) {delete m_pTrigger; m_pTrigger = 0;}};
559 
561  void AndTrigger(const char* apSynName, real64 arParamValue,
562  const char* apParamType, const char* apTaskName, const char* apCmdName,
563  const char* apEventName);
565  void AndTrigger(const char* apSynName, real64 arParamValue,
566  const char* apParamType, uint64 auBusTicks, uint8 auBusId);
568  CINOSTaskExMsgTrigger* GetAndTrigger(uint32 auIndex=0);
570  void RemAndTrigger(uint32 auIndex=0, bool abDelete = true);
571 
573  void SetSender(CINOSTask* apSender)
574  { m_pSender = apSender;};
576  void SetUser(void* apUser)
577  { m_pUser = apUser;};
579  void SetData(CINOSMcDataInst* apData)
580  { m_pData = apData;};
582  void SetSync(CINOSSync* apSync)
583  { m_pSync = apSync;};
585  void SetId(tMsgId aId)
586  { m_Id = aId;};
588  tMsgId GetId() const
589  { return m_Id;};
591  uint32 GetMsgType() const
592  { return m_uType;};
594  void SetMsgCode(uintnbr auMsgCode)
595  { m_uMsgCode = auMsgCode;};
597  uintnbr GetMsgCode() const
598  { return m_uMsgCode;};
600  void SetMsgSubCode(uint32 auMsgSubCode)
601  { m_uMsgSubCode = auMsgSubCode;};
603  uint32 GetMsgSubCode() const
604  { return m_uMsgSubCode;};
605  CINOSTaskExCmdBase* GetCommand() const
606  { return m_uType == CINOSTaskExDef::eMsgCall ?
607  (CINOSTaskExCmdBase*)m_uMsgCode :
608  nullptr;
609  }
611  void SetRetValue(uint32 auRetValue)
612  { m_uRetValue = auRetValue;};
614  uint32 GetRetValue() const
615  { return m_uRetValue;};
617  CINOSTask* GetSender() const
618  { return m_pSender;};
619  uint32 GetSenderId() const
620  { if (nullptr != m_pSender) return m_pSender->GetTaskId(); else return 0;};
622  CINOSTaskEx* GetReceiver() const
623  { return m_pReceiver;};
624  uint32 GetReceiverId() const
625  { if (nullptr != m_pReceiver) return ((CINOSTask*)m_pReceiver)->GetTaskId(); else return 0;};
627  void* GetUser() const
628  { return m_pUser;};
630  CINOSMcDataInst* GetData() const
631  { return m_pData;};
633  CINOSSync* GetSync() const
634  { return m_pSync;};
636  uint32 GetFlags()
637  { return m_uFlags;};
639  void SetFlags(uint32 auFlags)
640  { m_uFlags = auFlags;};
642  void AddFlags(uint32 auFlags)
643  { m_uFlags |= auFlags;};
645  void SetDeferred()
646  { m_uFlags |= eMsgFlgDeferred;};
648  bool GetDeferred() const
649  { return (m_uFlags & eMsgFlgDeferred)!=0;};
651  bool GetDone() const
652  { return (m_uFlags & eMsgFlgDone)!=0;};
654  bool GetPending() const
655  { return (m_uFlags & eMsgFlgPending)!=0;};
657  void SetPending()
658  { m_uFlags |= eMsgFlgPending;};
660  bool GetCanceled() const
661  { return (m_uFlags & eMsgFlgCanceled)!=0;};
663  void SetCanceled()
664  { m_uFlags |= eMsgFlgCanceled;};
666  void SetPersistent()
667  { m_uFlags |= eMsgFlgPersistent;};
669  bool GetPersistent() const
670  { return (m_uFlags & eMsgFlgPersistent)!=0;};
672  void SetFlushResistent()
673  { m_uFlags |= eMsgFlgFlushResistent;};
675  bool GetFlushResistent() const
676  { return (m_uFlags & eMsgFlgFlushResistent)!=0;};
678  bool GetSingle() const
679  { return (m_uFlags & eMsgFlgSingle)!=0;};
681  void SetSingle()
682  { m_uFlags |= eMsgFlgSingle;};
684  bool GetNoTrace() const
685  {
686  return (m_uFlags & eMsgFlgNoTrace)!=0 ||
687  (m_pData && (m_pData->GetFlag() & CINOSMcDataInst::eFlgNoTrace));
688  };
690  void SetNoTrace()
691  { m_uFlags |= eMsgFlgNoTrace;};
693  bool GetStatic() const
694  { return (m_uFlags & eMsgFlgStatic)!=0;};
696  void SetStatic()
697  {
698  m_uFlags |= eMsgFlgStatic;
699  INOS_CONCURRENCY_CHECK_FREE(this); // static messages may be used by other tasks.
700  };
702  void ClearStatic()
703  { m_uFlags &= ~eMsgFlgStatic;};
704  bool GetAlwaysSyncSignal() const
705  { return (m_uFlags & eMsgFlgAlwaysSyncSignal)!=0;};
707  void SetAlwaysSyncSignal()
708  { m_uFlags |= eMsgFlgAlwaysSyncSignal;};
709  bool GetAlwaysReply() const
710  { return (m_uFlags & eMsgFlgAlwaysReply)!=0;};
712  void SetAlwaysReply()
713  { m_uFlags |= eMsgFlgAlwaysReply;};
715  void SetName(const char* apName)
716  { inos_strncpy(m_cName, apName, sizeof(m_cName));};
725  char* GetName(bool abResolveIfEmpty = false);
727  void SetInfo(const char* apInfo)
728  { inos_strncpy(m_cInfo, apInfo, sizeof(m_cInfo));};
730  char* GetInfo()
731  { return &m_cInfo[0];};
733  void SetBusTicks(uint64 auBusTicks)
734  { m_uBusTicks = auBusTicks;};
736  uint64 GetBusTicks() const
737  { return m_uBusTicks;};
739  uint64 GetQueueTicks() const
740  { return m_uQueueTicks;};
742  void SetBusId(uint8 auBusId)
743  { m_uBusId = auBusId;};
745  uint8 GetBusId() const
746  { return (uint8)m_uBusId;};
748  void SetIdInfo(tMsgId auIdInfo)
749  { m_uIdInfo = auIdInfo;};
751  tMsgId GetIdInfo() const
752  { return m_uIdInfo;};
754  CINOSTaskExMsgParam* GetParam(const char* apName);
760  void DontCreateMcLogTraces();
763  bool AreMcLogTracesRequested() const;
764 #ifdef INOS_INCOV
765  bool GetINCOV(CINCOVServerSession*& opSession, CINCOVOperation*& opOperation);
769  void ReleaseINCOV(CINCOVServerSession& aSession);
770  bool InINCOVContext() const {
771  return (m_pIncovContext ? true : false);
772  }
773 #else
774  bool InINCOVContext() const {
775  return false;
776  }
777 #endif
778 
779  // msg flags
780  enum EMsgFlag {
781  eMsgFlgNone = 0x00000000,
782  eMsgFlgSyncron = 0x00000001,
783  eMsgFlgDeferred = 0x00000002,
784  eMsgFlgPending = 0x00000004,
785  eMsgFlgCanceled = 0x00000008,
786  eMsgFlgPersistent = 0x00000010,
787  eMsgFlgFlushResistent = 0x00000020,
788  // The msg receiver can handle additional parameter, that are not
789  // specified in the prototype message object
790  eMsgFlgHasEllipsis = 0x00000040,
791  // Only one instance of the according message is allowed at any time
792  // (e.g. in the message queue or currently running). note that this
793  // won't work if the message code (i.e. the enum value) is 0.
794  eMsgFlgSingle = 0x00000080,
795  // don't give an event log trace, e.g. for inco worker commands
796  eMsgFlgNoTrace = 0x00000100,
797  eMsgFlgStatic = 0x00000200,
798  // message has oversized result
799  eMsgFlgOversizedResult = 0x00000400,
800  eMsgFlgAlwaysSyncSignal = 0x00000800,
801  eMsgFlgAlwaysReply = 0x00001000,
802  eMsgFlgDone = 0x80000000
803  };
804 
805  //--- internals --------------------------------------------------------
806 
807  friend class CINOSTaskEx;
808  // needs to have access to the first msg param (without tranparently reset
809  // any internal data, such as m_pTmpParam)
810  friend class CINOSTaskExTracer;
811  #if defined(INOS_COORDINATOR_SUPPORT)
812  friend class CINOSMcCoord;
813  #endif
814  #if defined(INOS_LUAINTERPRETER)
815  friend class CINOSMcLua;
816  friend class CINOSMcLuaTask;
817 
818  #endif
819  friend class CINOSMcModule;
820  friend class CINOSMcMessage;
821  friend class CMcResult;
822  friend class CINOSTaskExMsgTest;
823  friend class CINOSTaskExMsgHistory;
824 
825  // public members
826  public:
828  int operator < (CINOSTaskExMsg& aTaskExMsg)
829  { return (strcmp(GetName(), aTaskExMsg.GetName())<0);}
830  int operator == (CINOSTaskExMsg& aTaskExMsg)
831  { return (strcmp(GetName(), aTaskExMsg.GetName())==0);}
832  int operator < (const char* aName)
833  { return (strcmp(GetName(), aName)<0);}
834  int operator == (const char* aName)
835  { return (strcmp(GetName(), aName)==0);}
836 
837 
839  CINOSTaskExMsgParam* iAddParam(CINOSTaskExMsgParam* apParam);
840 
841  // private methods
842  private:
844  CINOSTaskExMsgParam* iGetParam();
846  void iAddResult (CINOSTaskExMsgParam* apResult);
849  void iInsertResult (CINOSTaskExMsgParam* apResult);
852  void iAppendResult (CINOSTaskExMsgParam* apResult);
854  CINOSTaskExMsgParam* iGetResult();
855 #ifdef INOS_INCOV
856  void CopyIncovContext(SINCOVContext* apSrc);
859  void CopyIncovContext(SINCOVLazyContext* apSrc);
860 #endif
861  // private members
862  private:
864  #if defined(INOS_TASKEXMSG_NAME_EXTENDED_LENGTH)
865  inosName128 m_cName;
866  #else
867  inosName64 m_cName;
868  #endif
869  inosName64 m_cInfo;
872  uint64 m_uQueueTicks;
874  uint64 m_uBusTicks;
876  uint16 m_uType;
878  uint16 m_uBusId;
880  tMsgId m_Id;
882  tMsgId m_uIdInfo;
884  uintptr m_uMsgCode;
886  uint32 m_uMsgSubCode;
888  uint32 m_uRetValue;
890  uint32 m_uFlags;
892  uint32 m_uParamCnt;
894  void* m_pUser;
896  CINOSMcDataInst* m_pData;
898  CINOSSync* m_pSync;
900  CINOSTaskExMsgParam* m_pParam;
902  CINOSTaskExMsgParam* m_pTmpParam;
904  CINOSTaskExMsgParam* m_pResult;
906  CINOSTaskExMsgParam* m_pTmpResult;
908  CINOSTaskExMsgTrigger* m_pTrigger;
910  uint32 m_uAndTriggerInd;
912  CINOSTaskExMsgTrigger* m_pAndTrigger[DF_INOS_TASKEX_MAX_AND_TRG];
914  CINOSTask* m_pSender;
918  CINOSTaskEx* m_pReceiver;
921  bool m_bCreateMcLogTraces;
922 
923 #ifdef INOS_INCOV
924  SINCOVLazyContext* m_pIncovContext = nullptr;
926 #endif
927  public:
928  INOS_CONCURRENCY_CHECK_DECLARE;
929  private:
931  DECLARE_DYNAMIC(CINOSTaskExMsg);
932 };
934 template<> const char* CINOSTaskExMsg::GetParam<const char*>();
935 template<> char* CINOSTaskExMsg::GetParam<char*>();
936 
937 //------------------------------------------------------------------------------
938 // class CINOSTaskExMsg
939 //------------------------------------------------------------------------------
940 //
941 class CINOSTaskExMsgUser : public CINOSTaskExMsg
942 {
943  //--- user interface ---------------------------------------------------
944 
945  // public member functions
946  public :
948  CINOSTaskExMsgUser(uint32 auMsgCode, uint32 auFlags=0)
949  : CINOSTaskExMsg(CINOSTaskExDef::eMsgUser, auMsgCode, DF_INOS_ASYNCHRONOUS)
950  {
951  // set static
952  SetStatic();
953  // set additional flags
954  AddFlags(auFlags);
955  }
956 
958  DECLARE_DYNAMIC(CINOSTaskExMsgUser);
959 };
960 
961 //------------------------------------------------------------------------------
962 // class CINOSTaskEx
963 //------------------------------------------------------------------------------
964 //
965 class CINOSTaskEx : public CINOSTask
966 {
967  //--- user interface ---------------------------------------------------
968 
969  // public member functions
970  public :
972  uint32 GetState();
974  virtual void SetState(uint32 auState)
975  { m_uState = auState;};
977  bool IsCmdBusy(uintptr auCmdCode);
979  bool IsCmdDeferred(uint32 auCmdCode);
982  virtual bool IsCmdAllowed(CINOSTaskExMsg* apMsg)
983  { return false;};
985  const char* GetParam() const
986  { return &m_cParam[0];};
988  const char* GetType() const
989  { return &m_cType[0];};
991  const char* GetAliasName() const
992  { return &m_cAliasName[0];};
994  void SetAliasName(const char* apAlias)
995  { inos_strncpy(&m_cAliasName[0], apAlias, sizeof(m_cAliasName));};
997  virtual const char* GetIncoName();
999  virtual const char* GetTreeName()
1000  { return m_pTreeName;};
1001 
1003  enum {
1004  eSourceIdMsg = 255,
1005  eSourceIdLua = 254,
1006  eSourceIdFastLoad = 253,
1007  };
1009  uint32 GetSourceId()
1010  { return m_uSourceId; };
1011 
1013  CINOSTaskEx* GetParent() const
1014  { return m_pParent;};
1016  static tMsgId GetMsgId();
1019  static tMsgId GetMsgId(uint32 auId, uint32 auMask);
1020 
1022  virtual CMcResult Startup(real64 arStage);
1023 
1025  bool GetCommand(const char* apName) const;
1027  bool GetOption(const char* apName) const;
1029  bool GetOption(const char* apBase, const char* apName) const;
1031  bool GetOption(const char* apParams, const char* apBase, const char* apName) const;
1034  bool GetOptionEx(const char* apBase) const;
1036  bool GetOptionStr(const char* apBase, char* apResult, uint32 auSize) const;
1038  bool GetOptionStr(const char* apParams, const char* apBase, char* apResult, uint32 auSize) const;
1040  bool GetOptionNbr(const char* apBase, uintnbr& auNumber) const;
1042  bool GetOptionNbr(const char* apParams, const char* apBase, uintnbr& auNumber) const;
1044  bool GetOption(uint32 auOption) const
1045  {return (m_uOptions & auOption)!=0;};
1047  bool GetFlag(const char* apName) const;
1049  bool GetFlag(uint64 auFlag) const
1050  { return (GetFlags() & auFlag)!=0;};
1052  uint64 GetFlags() const
1053  { return m_uFlags; };
1055  bool GetRequest(uint32 auRequest) const
1056  { return (m_uRequests & auRequest)!=0;};
1058  bool GetCritical(uint32 auCritical) const
1059  { return (m_uCriticals & auCritical)!=0;};
1060 
1062  virtual CMcResult SetFlag(const char* apName, CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
1064  virtual CMcResult ClrFlag(const char* apName, CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
1066  virtual CMcResult StopMsg(tMsgId atMsgId, CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
1067 
1072  virtual CMcResult SetIdleTimeout(uint32 auIdleTimeout, CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
1073  uint32 GetIdleTimeout() const
1074  { return m_uIdleTimeout; };
1075 
1079  void SetDispatchFlag(uint32 auFlag)
1080  { INOS_OR(m_uDispatchFlags, auFlag); };
1082  void ClrDispatchFlag(uint32 auFlag)
1083  { INOS_AND(m_uDispatchFlags, ~auFlag); };
1085  uint32 GetDispatchFlag() const
1086  { return m_uDispatchFlags; };
1087 
1089  virtual uint32 Shutdown(CINOSSync* apSync=DF_INOS_SYNCHRONOUS) override;
1090  #ifdef INOS_MULTICORE
1091  void _SwitchCore();
1094  virtual CMcResult SwitchCore(uint32 auCoreId, CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
1095  #endif
1096 
1098  virtual tMsgId PutCmd(uint32 auCommand);
1100  virtual CMcResult PutMsg(CINOSTaskExMsg* apMsg, tMsgId aMsgId=0);
1101 
1108  virtual CMcResult PutMsgEx(CINOSTaskExMsg* apMsg, uint32 auFlags, tMsgId aMsgId=0);
1109 
1111  virtual void PutReply(CINOSTaskExMsg* apMsg, tMsgId aMsgId);
1113  virtual CINOSTaskQueue* GetMsgQueue()
1114  { return m_pMsgQueue;};
1115 
1117  CINOSTaskExMsg* GetActMsg() {return m_pActMsg;};
1118 
1120  virtual const CINOSTaskExMsg* GetCommandMsg(const char* apName)
1121  { return m_pCommands->Find(apName);};
1122 
1130  virtual CINOSTaskExMsg* CreateMsgFromCommand(const char* apName,
1131  CINOSSync* apSync = DF_INOS_ASYNCHRONOUS);
1132 
1144  template<typename... ParamType>
1145  CMcResult CallCommand(const char* apName,
1146  ParamType... aParams,
1147  CINOSSync* apSync = DF_INOS_SYNCHRONOUS)
1148  {
1149  // Actual task is different to this task?
1150  if(ActualTask() != this) {
1151  // yes -> lock the commands to protect from modification
1152  m_CommandsMutex.Request();
1153  }
1154 
1155  // Get the message
1156  CINOSTaskExMsg* pCmdMsg = m_pCommands->Find(apName);
1157  if(nullptr == pCmdMsg) {
1158  if(ActualTask() != this) {
1159  m_CommandsMutex.Release();
1160  }
1161  // Not found, return error
1162  return CMcResult((tMcAppError)INOS_MCMSG_CODE_TSKEX_UNKNOWN);
1163  }
1164  // Create call message
1165  CINOSTaskExMsg* pCallMsg = new CINOSTaskExMsg(pCmdMsg->GetMsgType(),
1166  pCmdMsg->GetMsgCode(), apSync);
1167 
1168  // Copy sub-code
1169  pCallMsg->SetMsgSubCode(pCmdMsg->GetMsgSubCode());
1170 
1171  // Set Name
1172  pCallMsg->SetName(apName);
1173 
1174  // Add the params
1175  CINOSTaskExMsgParam* ParamArray[sizeof...(aParams)] =
1176  { (pCallMsg->AddParam(aParams))... };
1177 
1178  // check params
1179  auto pParam = pCmdMsg->GetFirstParamPtr(false);
1180  for(uint32 uIx = 0; uIx < sizeof...(aParams); uIx ++) {
1181  // extra params provided?
1182  if(nullptr == pParam) {
1183  // yes -> allowed?
1184  if((pCmdMsg->GetFlags() & CINOSTaskExMsg::eMsgFlgHasEllipsis)
1185  == 0) {
1186  // Not allowed -> Return error
1187  delete pCallMsg;
1188  return CMcResult((tMcAppError)INOS_MCMSG_CODE_TSKEX_WRONG_PARAMS);
1189  }
1190  break;
1191  }
1192  // Check type
1193  if(pParam->GetType() != ParamArray[uIx]->GetType() ||
1194  pParam->GetTypeInfo() != ParamArray[uIx]->GetTypeInfo()) {
1195  // Wrong type -> return error
1196  delete pCallMsg;
1197  return CMcResult((tMcAppError)INOS_MCMSG_CODE_TSKEX_WRONG_PARAMS);
1198  }
1199  pParam = pParam->GetNext();
1200  }
1201  // check for further needed params
1202  while(nullptr != pParam) {
1203  // further param mandatory?
1204  if(pParam->GetFlag() & CINOSTaskExMsgParam::eFlgMandatory) {
1205  // yes -> return error
1206  delete pCallMsg;
1207  return CMcResult((tMcAppError)INOS_MCMSG_CODE_TSKEX_PARAM_MISSING);
1208  }
1209  // Copy the default param
1210  pCallMsg->AddParam(pParam);
1211  pParam = pParam->GetNext();
1212  }
1213 
1214  // Release commands mutex
1215  if(ActualTask() != this) {
1216  m_CommandsMutex.Release();
1217  }
1218 
1219  // Finally put the message to call the command
1220  return PutMsg(pCallMsg);
1221  }
1222 
1224  virtual const CINOSTaskExCmdHookBase* GetCommandHook(const char* apName)
1225  { return m_CommandHookRegister.Find(apName);};
1226 
1228  virtual CINCOObject* GetRegister(CINCOObject* apObject=0);
1230  virtual CINCOObject* SetCmdObj(CINCOObject* apCmd);
1232  virtual CINCOObject* GetCmdObj();
1234  virtual CINCOObject* GetPropObj();
1236  virtual CINCOObject* GetOptionsObj()
1237  { return m_pOptions;};
1239  virtual CINCOObject* GetFlagsObj()
1240  { return m_pFlags;};
1242  virtual CINCOObject* GetRequestsObj()
1243  { return m_pRequests;};
1245  virtual CINCOObject* GetCriticalsObj()
1246  { return m_pCriticals;};
1248  virtual CINCOObject* GetActObj();
1250  virtual CINCOObject* GetStatObj();
1251 
1253  virtual void AddProp(CINCOItem* apItem);
1255  virtual void AddProp(const char* apName);
1257  virtual void AddProp();
1259  virtual void AddProp(const char* apName, nvreal64& aMember,
1260  real64 arDefault, real64 arMin, real64 arMax, const char* apUnit,
1261  uint32 auDigits, uint32 auCharactristics = defCharShowFix);
1263  virtual void AddProp(const char* apName, nvuint32& aMember,
1264  uint32 auDefault, uint32 auMin, uint32 auMax, const char* apUnit,
1265  uint32 auCharacteristics=defCharShowDec);
1267  virtual void AddProp(const char* apName, nvstring& aMember,
1268  const char* apDefault="", const char* apComboData=NULL);
1270  virtual void AddProp(const char* apName, nvlstring& aMember,
1271  const char* apDefault="");
1273  virtual void AddProp(const char* apName, nvbool& aMember,
1274  bool abDefault, uint32 auCharactristics=defCharShowDec);
1276  virtual void RemProp(const char* apName);
1277 
1279  virtual void AddActual(CINCOItem* apItem);
1281  virtual void AddActual(const char* apName);
1283  virtual void AddActual();
1285  virtual void AddActual(const char* apName, nvreal64& aMember,
1286  real64 arDefault, real64 arMin, real64 arMax, const char* apUnit,
1287  uint32 auDigits);
1289  virtual void AddActual(const char* apName, nvuint32& aMember,
1290  uint32 auDefault, uint32 auMin, uint32 auMax, const char* apUnit,
1291  uint32 auCharacteristics=defCharShowDec);
1293  virtual void AddActual(const char* apName, nvstring& aMember,
1294  const char* apDefault=nullptr, const char* apComboData=nullptr);
1296  virtual void AddActual(const char* apName, nvlstring& aMember,
1297  const char* apDefault=nullptr);
1299  virtual void AddActual(const char* apName, nvbool& aMember,
1300  bool abDefault, uint32 auCharactristics=defCharShowDec);
1302  virtual void RemActual(const char* apName);
1303 
1305  virtual CINOSTaskExMsg* CreateMsg(CINOSTaskExMsg* apMsg,
1306  CINOSMcDataInst* apData, const char* apAlias);
1307 
1309  constexpr static int GetLastCmd() {
1310  return eCmdINOSTaskExLast;
1311  }
1313  constexpr static int GetLastUsr() {
1314  return eUsrINOSTaskExLast;
1315  }
1317  friend CINOSMcMessage* GetMessageHnd(bool abSearch);
1319  CINOSMcMessage* GetMessageHndEx();
1321  void SetMessageHnd(CINOSMcMessage* apMessageHnd)
1322  {m_pMessageHnd = apMessageHnd;};
1324  friend tMcAppError SendMessage(uint32 auMsgType, uint32 auMsgCode,
1325  uint32 auFlags, CINOSMcData* apInfo);
1327  friend tMcAppError SendMessage(uint32 auMsgType, uint32 auMsgCode,
1328  uint32 auFlags, const char* apText, CINOSMcData* apInfo);
1330  friend tMcAppError SendMessageEx(uint32 auMsgType, uint32 auMsgCode,
1331  uint32 auFlags, const char* apProperties);
1333  friend tMcAppError SendMessageEx(uint32 auMsgType, uint32 auMsgCode,
1334  uint32 auFlags, CINOSMcData* apInfo, const char* apProperties);
1336  friend CMcResult PostMessage(uint32 auMsgType, uint32 auMsgCode,
1337  uint32 auFlags, CINOSMcData* apInfo);
1339  friend CMcResult PostMessage(uint32 auMsgType, uint32 auMsgCode,
1340  uint32 auFlags, const char* apText, CINOSMcData* apInfo);
1342  virtual CMcResult PostMessage(uint32 auMsgType, uint32 auMsgCode,
1343  uint32 auFlags, CINOSMcData* apInfo=0);
1345  virtual CMcResult PostMessage(uint32 auMsgType, uint32 auMsgCode,
1346  uint32 auFlags, const char* apText, CINOSMcData* apInfo=0);
1348  friend CMcResult PostMessageEx(uint32 auMsgType, uint32 auMsgCode,
1349  uint32 auFlags, const char* apProperties);
1351  friend CMcResult PostMessageEx(uint32 auMsgType, uint32 auMsgCode,
1352  uint32 auFlags, CINOSMcData* apInfo, const char* apProperties);
1354  friend CMcResult ModifyMessage(tMsgId aiId, uint32 auMsgType, uint32 auMsgCode,
1355  uint32 auFlags, CINOSMcData* apInfo, const char* apText);
1357  virtual CMcResult ModifyMessage(tMsgId aiId, uint32 auMsgType, uint32 auMsgCode,
1358  uint32 auFlags, CINOSMcData* apInfo=0, const char* apText=nullptr);
1360  friend CMcResult ModifyMessageEx(tMsgId aiId, uint32 auMsgType, uint32 auMsgCode,
1361  uint32 auFlags, const char* apProperties);
1363  friend CMcResult ModifyMessageEx(tMsgId aiId, uint32 auMsgType, uint32 auMsgCode,
1364  uint32 auFlags, CINOSMcData* apInfo, const char* apProperties);
1365 
1367  friend CMcResult AckMessage(tMsgId aMsgId, uint32 auFlags);
1368  friend CMcResult AckMessageDelayed(tMsgId aMsgId, uint32 auFlags, uint32 auTime);
1370  friend CMcResult AckMessage(uint32 auMsgCode, uint32 auFlags, uint32 auMask);
1371  friend CMcResult AckMessageDelayed(uint32 auMsgCode, uint32 auFlags, uint32 auMask, uint32 auTime);
1373  friend CMcResult AckMessage(const CINOSTask* apOwner, uint32 auMsgType, uint32 auFlag);
1375  friend CMcResult RemMessage(const CINOSTask* apOwner);
1377  friend CMcResult RequestListen(uint32 auMsgType, uint32 auSetId, uint32 auAckId);
1379  friend CMcResult ReleaseListen();
1380 
1382  friend CINOSMcNvRamGrp* GetNvRamGrp(bool abSearch);
1383 
1384 #if defined(INOS_TIMINIG_CHECKS_SUSPEND)
1385  uint32 GetSuspendTimingCheckLimit() const {
1387  return m_uSuspendTimingCheckLimit;
1388  }
1390  void SetSuspendTimingCheckLimit(uint32 auLimit) {
1391  m_uSuspendTimingCheckLimit = auLimit;
1392  }
1393 #endif
1394 
1395  // public enumerations
1396  public :
1397 
1399  enum {
1400  eMsgCmd=CINOSTaskExDef::eMsgCmd,
1401  eMsgCall=CINOSTaskExDef::eMsgCall,
1402  eMsgEvent=CINOSTaskExDef::eMsgEvent,
1403  eMsgReply=CINOSTaskExDef::eMsgReply,
1404  eMsgUser=CINOSTaskExDef::eMsgUser,
1405  eMsgSub=CINOSTaskExDef::eMsgSub,
1406  eMsgInternal=CINOSTaskExDef::eMsgInternal,
1407  eMsgMessage=CINOSTaskExDef::eMsgMessage
1408  };
1409 
1411  enum ERplId {
1412  eRplOk=CINOSTaskExDef::eRplOk,
1413  eRplSkipped=CINOSTaskExDef::eRplSkipped,
1414  eRplInComplete=CINOSTaskExDef::eRplInComplete,
1415  eRplIgnored=CINOSTaskExDef::eRplIgnored,
1416  eRplPaused=CINOSTaskExDef::eRplPaused,
1417  eRplStopped=CINOSTaskExDef::eRplStopped,
1418  eRplCanceled=CINOSTaskExDef::eRplCanceled,
1419  eRplRejected=CINOSTaskExDef::eRplRejected,
1420  eRplFailed=CINOSTaskExDef::eRplFailed,
1421  eRplError=CINOSTaskExDef::eRplError,
1422  eRplFatal=CINOSTaskExDef::eRplFatal,
1423  eRplTimeout=CINOSTaskExDef::eRplTimeout
1424  };
1425 
1426  // command codes
1427  enum {
1428  eCmdINOSTaskExFirst,
1429  eCmdFailure,
1430  eCmdStartup,
1431  eCmdShutdown,
1432  eCmdShutdownRequest,
1433  eCmdSwitchCore,
1434  eCmdSetFlag,
1435  eCmdClrFlag,
1436  eCmdStopMsg,
1437  eCmdSetIdleTimeout,
1438  eCmdINOSTaskExLast
1439  };
1440 
1441  // user command codes
1442  enum {
1443  eUsrINOSTaskExFirst,
1444  eUsrMsgDone,
1445  eUsrNvUpdate,
1446  eUsrIdleTimeout,
1447  eUsrINOSTaskExLast
1448  };
1449 
1450  // internal command codes
1451  enum {
1452  eIntINOSTaskExFirst,
1453  eIntAddCommand,
1454  eIntRemCommand,
1455  eIntDeleteCommand,
1456  eIntGetCommands,
1457  eIntGetProp,
1458  eIntSetProp,
1459  eIntAddProp,
1460  eIntGetActual,
1461  eIntSetActual,
1462  eIntAddActual,
1463  eIntINOSTaskExLast
1464  };
1465 
1466  // message command codes
1467  enum {
1468  eMessageAdd,
1469  eMessageRemove,
1470  eMessageModify,
1471  eMessageAcknowledge,
1472  };
1473 
1474  public:
1475 
1476  // event codes
1477  enum {
1478  eEvtTicks,
1479  eEvtNs
1480  };
1481 
1482  // states
1483  enum {
1484  eStaStartup = DEF_eStaStartup,
1485  eStaOff = DEF_eStaOff,
1486  eStaWait = DEF_eStaWait,
1487  eStaOn = DEF_eStaOn,
1488  eStaReady = DEF_eStaReady,
1489  eStaBusy = DEF_eStaBusy,
1490  eStaError = DEF_eStaError,
1491  eStaINOSTaskExLast
1492  };
1493 
1494  // options
1495  enum {
1496  eOptOwner = 0x00000001, // owner protection (obsolete)
1497  eOptStat = 0x00000002, // statistics support
1498  eOptMsg = 0x00000004, // message handler
1499  eOptNvR = 0x00000008, // nvram handler
1500  eOptOvld = 0x0000010, // overloaded command names
1501  eOptCaS = 0x0000020, // check for asynch result support
1502  eOptResTsk2 = 0x0000040, // reserved for future use
1503  eOptResTsk3 = 0x0000080 // reserved for future use
1504  };
1505 
1506  // flags (R - read only, W - read/write)
1507  enum {
1508  eFlgError = 0x00000001, // R error pending
1509  eFlgFatal = 0x00000002, // R fatal error pending
1510  eFlgEmergency=0x00000004, // R emergency pending
1511  eFlgSTO = 0x00000008, // R safe torque off (STO) pending
1512  eFlgResTsk4 = 0x00000010, // reserved for future use
1513  eFlgResTsk5 = 0x00000020, // reserved for future use
1514  eFlgResTsk6 = 0x00000040, // reserved for future use
1515  eFlgResTsk7 = 0x00000080 // reserved for future use
1516  };
1517 
1518  // requests
1519  enum {
1520  eReqResTsk0 = 0x00000001, // reserved for future use
1521  eReqResTsk1 = 0x00000002, // reserved for future use
1522  eReqResTsk2 = 0x00000004, // reserved for future use
1523  eReqResTsk3 = 0x00000008, // reserved for future use
1524  eReqResTsk4 = 0x00000010, // reserved for future use
1525  eReqResTsk5 = 0x00000020, // reserved for future use
1526  eReqResTsk6 = 0x00000040, // reserved for future use
1527  eReqResTsk7 = 0x00000080 // reserved for future use
1528  };
1529 
1530  // critical sections
1531  enum {
1532  eCrtSendMsg = 0x00000001, // send message pending
1533  eCrtResTsk1 = 0x00000002, // reserved for future use
1534  eCrtResTsk2 = 0x00000004, // reserved for future use
1535  eCrtResTsk3 = 0x00000008, // reserved for future use
1536  eCrtResTsk4 = 0x00000010, // reserved for future use
1537  eCrtResTsk5 = 0x00000020, // reserved for future use
1538  eCrtResTsk6 = 0x00000040, // reserved for future use
1539  eCrtResTsk7 = 0x00000080 // reserved for future use
1540  };
1541 
1542  // dispatch flags
1543  enum {
1544  eDispFlagINCOSync = 0x00000001,
1545  };
1546 
1547  // Flags to use in PutMsgEx/AddToInputQueue
1548  enum eTaskExMsgFlags {
1549  eMsgFlagNone = 0x00000000, //
1550  eMsgFlagNoWait = 0x00000001,
1551  };
1552 
1553  // Enum to be used to determine how to dispatch a message
1554  enum EDispatchStyle {
1555  eDispatchNone,
1556  eDispatchNormal,
1557  eDispatchInternal,
1558  eDispatchPre
1559  };
1560 
1561 
1562  //--- internals --------------------------------------------------------
1563 
1564  friend void _INI_0000_CINOSTaskEx();
1565  friend void _INI_0201_CINOSTaskEx();
1566  friend void _INI_0510_CINOSTaskEx();
1567  friend class CINOSTaskExState;
1568  friend class CINOSMcSync;
1569  friend class CINOSMcModule;
1570  friend class CINOSMcRobot;
1571  #if defined(INOS_COORDINATOR_SUPPORT)
1572  friend class CINOSMcCoord;
1573  #endif
1574  friend class CINOSMcLua;
1575  friend class CINOSMcMessage;
1576  friend class CINOSTaskExMsg;
1577  friend class CINOSTaskExMsgTest;
1578  friend class CINOSEventLogger;
1579 
1580  // constructor / destructor
1581  public :
1583  CINOSTaskEx (const char* apName, const char* apParam=0,
1584  uint32 aStackSize=defDefaultStackSize,
1585  uint32 aPriority=defLowestPriority, bool aFloatingPoint=true,
1586  uint32 aTimeSlice=defDefaultTimeSlice, bool aInterruptsDisabled=false);
1588  CINOSTaskEx (const char* apName, const char* apType, const char* apParam=0,
1589  uint32 aStackSize=defDefaultStackSize,
1590  uint32 aPriority=defLowestPriority, bool aFloatingPoint=true,
1591  uint32 aTimeSlice=defDefaultTimeSlice, bool aInterruptsDisabled=false);
1593  virtual ~CINOSTaskEx();
1594 
1595  // public members (used by container class)
1596  public:
1598  virtual void PostCreate(void* apParent);
1600  virtual bool PreDestroy(bool& bDeleteSelf);
1601 
1603  int operator < (CINOSTaskEx& aTaskEx)
1604  { return (strcasecmp(GetTreeName(), aTaskEx.GetTreeName())<0);}
1605  int operator == (CINOSTaskEx& aTaskEx)
1606  { return (strcasecmp(GetTreeName(), aTaskEx.GetTreeName())==0);}
1607  int operator < (const char* aName)
1608  { return (strcasecmp(GetTreeName(), aName)<0);}
1609  int operator == (const char* aName)
1610  { return (strcasecmp(GetTreeName(), aName)==0);}
1611 
1612  // private member functions
1613  private :
1615  static intnbr HandleTicksTriggers0(void*, intnbr);
1616  static intnbr HandleTicksTriggers1(void*, intnbr);
1617  static intnbr HandleTicksTriggers2(void*, intnbr);
1618  static intnbr HandleTicksTriggers3(void*, intnbr);
1619  static void HandleTicksTriggers(uint8 auBusId);
1623  uint32* GetEvtLevel(const uint32 auBitNumber) {
1625  const uint8 uArrayIndex = (uint8)(auBitNumber / 32);
1626  return &m_pLevel[uArrayIndex];
1627  }
1630  inline uint32 IsLevelActive(const uint32 auBitNumber) const {
1631  const uint8 uArrayIndex = (uint8)(auBitNumber / 32);
1632  const uint32 uLevel = (uint32)(1 << (auBitNumber % 32));
1633  return (m_pLevel[uArrayIndex] & uLevel);
1634  }
1635 
1636  // protected member functions
1637  protected :
1639  void Create();
1641  virtual void Action() override;
1643  // Implements pre dispatch callback support for commands of type TINOSTaskExCmd.
1644  virtual bool PreDispatchMsg(CINOSTaskExMsg* apMsg);
1645 
1647  virtual void PostDispatchMsg() {};
1649  virtual bool DispatchCmd(CINOSTaskExMsg* apMsg);
1651  virtual bool DispatchTmd(CINOSTaskExMsg* apMsg);
1653  virtual bool DispatchEvent(CINOSTaskExMsg* apMsg);
1655  virtual bool DispatchReply(CINOSTaskExMsg* apMsg);
1657  virtual bool DispatchUser(CINOSTaskExMsg* apMsg);
1659  virtual bool DispatchSub(CINOSTaskExMsg* apMsg);
1661  virtual bool DispatchInternal(CINOSTaskExMsg* apMsg);
1663  virtual bool DispatchMessage(CINOSTaskExMsg* apMsg);
1665  virtual bool DispatchOther(CINOSTaskExMsg* apMsg);
1666 
1668  virtual void iFailure(CINOSTaskExMsg* apMsg);
1669 
1671  virtual void iStartup(CINOSTaskExMsg* apMsg);
1673  virtual void iStartup(real64 arStage);
1675  virtual bool iPostStartup();
1677  virtual uint32 iAddRegisteredCommands();
1678 
1680  virtual void iShutdown(CINOSTaskExMsg* apMsg);
1681  virtual void iShutdownRequest(CINOSTaskExMsg* apMsg);
1683  #ifdef INOS_MULTICORE
1684  virtual uint32 iSwitchCore(uint8 auCoreId);
1685  virtual void iSwitchCore(CINOSTaskExMsg* apMsg);
1686  #endif
1687 
1689  virtual void iSetFlag(CINOSTaskExMsg* apMsg);
1690  virtual void iiSetFlag(const char* apName);
1692  virtual void iClrFlag(CINOSTaskExMsg* apMsg);
1694  virtual void iStopMsg(CINOSTaskExMsg* apMsg);
1696  virtual void iSetIdleTimeout(CINOSTaskExMsg* apMsg);
1698  virtual void iHandleIdleTimeout();
1700  void iCheckIdleTimeout();
1701 
1703  virtual void iCancelDeferred();
1704 
1706  virtual void iAddCommand(CINOSTaskExMsg* apMsg);
1707 
1709  virtual void iRemCommand(CINOSTaskExMsg* apMsg);
1710 
1712  virtual void iDeleteCommand(CINOSTaskExMsg* apMsg);
1713 
1715  virtual void iGetCommands(CINOSTaskExMsg* apMsg);
1716 
1718  virtual void iGetProp(CINOSTaskExMsg* apMsg);
1719 
1721  virtual void iSetProp(CINOSTaskExMsg* apMsg);
1722 
1724  virtual void iAddProp(CINOSTaskExMsg* apMsg);
1725 
1727  virtual void iGetActual(CINOSTaskExMsg* apMsg);
1728 
1730  virtual void iSetActual(CINOSTaskExMsg* apMsg);
1731 
1733  virtual void iAddActual(CINOSTaskExMsg* apMsg);
1734 
1736  static uint32 iSetIncoItemsFromParamStruct(CINCOItem* apIncoItem,
1737  long alOffset, CINOSTaskExMsgParam* apParams, bool abOverwrite,
1738  inosName128& oErrorItemName);
1739 
1741  virtual void iMessageAdd(CINOSTaskExMsg* apMsg);
1743  virtual void iMessageRemove(CINOSTaskExMsg* apMsg);
1745  virtual void iMessageModify(CINOSTaskExMsg* apMsg);
1747  virtual void iMessageAcknowledge(CINOSTaskExMsg* apMsg);
1748 
1750  void Reply(CINOSTaskExMsg* apMsg, uint32 auReply, tMcAppError aAppError=0);
1752  template<class T> void ReplyParam(uint32 auReply, T);
1753 
1755  virtual void SetTreeName(const char* apTreeName)
1756  { m_pTreeName = apTreeName;};
1758  virtual const char* GetStateText();
1759 
1761  virtual void MsgDone(tMsgId aMsgId, tMcAppError aAppError = 0);
1762  // special public declaration (method is public but just callable in the
1763  // own task context)
1764  public:
1766  virtual void MsgDone(CINOSTaskExMsg* apMsg, tMcAppError aAppError = 0);
1768  virtual void MsgDone(CINOSTaskExMsg* apMsg, ERplId aRplId, tMcAppError aAppError = 0);
1769  // protected again
1771  virtual void MsgDonePnd(CINOSTaskExMsg* apMsg, tMcAppError aAppError = 0);
1773  virtual void MsgDonePnd(CINOSTaskExMsg* apMsg, ERplId aRplId, tMcAppError aAppError = 0);
1775  virtual void MsgInComplete(CINOSTaskExMsg* apMsg, tMcAppError aAppError = 0);
1777  virtual void MsgIgnored(CINOSTaskExMsg* apMsg, tMcAppError aAppError = 0);
1779  virtual void MsgPaused(CINOSTaskExMsg* apMsg, tMcAppError aAppError = 0);
1781  virtual void MsgStopped(CINOSTaskExMsg* apMsg, tMcAppError aAppError = 0);
1783  virtual void MsgCanceled(CINOSTaskExMsg* apMsg, tMcAppError aAppError = 0);
1785  virtual void MsgRejected(CINOSTaskExMsg* apMsg, tMcAppError aAppError = 0);
1787  virtual void MsgFailed(CINOSTaskExMsg* apMsg, tMcAppError aAppError = 0);
1789  virtual void MsgError(CINOSTaskExMsg* apMsg, tMcAppError aAppError);
1791  virtual void MsgFatal(CINOSTaskExMsg* apMsg, tMcAppError aAppError);
1792 
1793  // special public declaration (method is public but just callable in the
1794  // own task context)
1795  public:
1797  virtual tMsgId MsgDefer(CINOSTaskExMsg* apMsg, void* apHandler=0,
1798  void* apObject=0, bool abHandlesCommands = false);
1801  virtual tMsgId MsgDefer(CINOSTaskExMsg* apMsg, tMsgId aMsgId,
1802  void* apHandler=0, void* apObject=0, bool abHandlesCommands = false);
1803  // protected again
1804  protected:
1806  // tasks than the module task
1807  virtual void iUsrMsgDone(CINOSTaskExMsg* apMsg);
1809  friend void MsgEvent(CINOSTaskExMsg* apMsg, const char* apName,
1810  uint64 auTicks, uint8 auBusId);
1812  friend void MsgEventFlg(CINOSTaskExMsg* apMsg, const char* apName,
1813  uint64 auTicks, uint8 auBusId, uint32 auFlags);
1815  friend void MsgEvent(CINOSTaskExMsg* apMsg, const char* apName,
1816  uint32 auMs);
1818  friend void MsgEventFlg(CINOSTaskExMsg* apMsg, const char* apName,
1819  uint32 auFlags, uint32 auMs);
1820 
1822  virtual void FlushTmd(tMsgId aId=0);
1823 
1824  protected:
1826  virtual void _AddCommand(CINOSTaskExMsg* apMsg, CINCOObject* apMsgCmdObj,
1827  int16 aiOrder = 0);
1828  // special public declaration (method is public but just callable in the
1829  // own task context)
1830  public:
1832  virtual void AddCommand(const char* apName, uint32 auCode, CINCOProcedure* apProc);
1834  virtual void AddCommand(CINOSTaskExMsg* apMsg,
1835  uint64 aChar=0, // characteristics of object
1836  uint16 aKeyLevel=cKeyLevelMin, // keylevel of object
1837  bool abRegisterInco=true);
1839  virtual void AddCommand(CINOSTaskExMsg* apMsg, CINCOObject* apMsgCmdObj);
1841  virtual void AddCommand(const char* apName, uint32 auCode, uint32 auType=eMsgCmd);
1843  virtual void RemCommand(const char* apName);
1845  virtual void AddParam(const char* apName, real64 arValue, real64 arMin,
1846  real64 arMax, const char* apUnit, uint32 auChar, uint32 auFlags = 0);
1848  virtual void AddParam(const char* apName, const char* apValue, uint32 auFlags = 0);
1850  virtual void AddParam(const char* apName, const char* apValue,
1851  const char* apComboData, uint32 auFlags = 0);
1853  virtual void AddParam(const char* apName, const char* apUnit,
1854  uint32 auValue, uint32 auMin, uint32 auMax, uint32 auChar, uint32 auFlags = 0);
1856  virtual void AddParam_int32(const char* apName, const char* apUnit,
1857  int32 aiValue, int32 aiMin, int32 aiMax, uint32 auChar, uint32 auFlags = 0);
1859  // NOTE: we cannot overload AddParam for this like uint32, as this would break
1860  // compatibility with existing code (compiler complains about ambiguous calls)
1861  virtual void AddParam_uint64(const char* apName, const char* apUnit,
1862  uint64 auValue, uint64 auMin, uint64 auMax, uint32 auChar, uint32 auFlags = 0);
1864  virtual void AddParam_int64(const char* apName, const char* apUnit,
1865  int64 aiValue, int64 aiMin, int64 aiMax, uint32 auChar, uint32 auFlags = 0);
1867  virtual void AddParam(const char* apName, const char* apComboData,
1868  uint32 auValue, uint32 auMin, uint32 auMax, const char* apUnit,
1869  uint32 auChar, uint32 auFlags = 0);
1871  virtual void AddParam(const char* apName, bool abValue, uint32 auChar,
1872  uint32 auFlags = 0);
1880  template <typename T>
1881  void AddParam(CINCOItem* apItem, T aValue, uint32 auFlags = 0) {
1882  // ensure this method is only called in our own context
1883  ASSERT_ALWAYS(ActualTask()==this);
1884  // add param to actual message
1885  CINOSTaskExMsgParam* param=m_pTmpMsg->AddParam(apItem->GetName(), aValue);
1886  param->m_uFlags = auFlags;
1887  // add inco registration
1888  if (m_pActMsgObj) {
1889  m_pActMsgObj->Add(apItem, (int16)(m_uActParamCount++));
1890  } // end if
1891  }
1892  void ProcedureArgCheck(CINCOObject& aObject,
1893  const char* apParamName, const uint32 auExpectedIncoType);
1895  virtual void AddEllipsis();
1897  virtual void AddChildCommand(const char* apModuleName,
1898  const char* apFunctionName,
1899  CINOSTaskExMsg* apCmdMsg,
1900  bool abRegisterInco = true) {};
1902  virtual void RemChildCommand(const char* apModuleName,
1903  const char* apFunctionName) {};
1905  virtual void AddChildModule(const char* apModuleName) {};
1907  virtual void RemChildModule(const char* apModuleName) {};
1908 
1910  // or may be added later
1911  void RegisterCommand(CINOSTaskExCmdBase* apCommand);
1912 
1914  void RegisterHook(CINOSTaskExCmdHookBase* apHook);
1915 
1916  // protected again
1917  protected:
1919  virtual void AdjTrigger(CINOSTaskExMsg* apMsg);
1920 
1922  CINOSTaskExDeferredMsg* GetDeferredMsg(tMsgId auReplyId);
1924  void RemDeferredMsg(CINOSTaskExDeferredMsg* apDef);
1925 
1927  CINOSTaskExMsg* GetDeferredMsgCmd(uint32 auCmdCode);
1928 
1930  char* GetMsgName(CINOSTaskExMsg* apMsg);
1931 
1933  void SetParent(CINOSTaskEx* apParent)
1934  { m_pParent = apParent;};
1935 
1937  void MptHook();
1939  void NvUpdate();
1940  virtual void iNvUpdate(CINOSTaskExMsg* apMsg);
1941 
1943  virtual void SetFlag(uint64 auFlag, bool abUpdateState = false)
1944  {
1945  m_uFlags |= auFlag;
1946  };
1948  virtual void ClrFlag(uint64 auFlag, bool abUpdateState = false)
1949  {
1950  m_uFlags &= ~auFlag;
1951  };
1953  virtual void SetRequest(uint32 auRequest)
1954  { INOS_OR(m_uRequests, auRequest); };
1956  virtual void ClrRequest(uint32 auRequest)
1957  { INOS_AND(m_uRequests, ~auRequest); };
1959  void SetCritical(uint32 auCritical)
1960  { INOS_OR(m_uCriticals, auCritical); };
1962  void ClrCritical(uint32 auCritical)
1963  { INOS_AND(m_uCriticals, ~auCritical); };
1964 
1966  virtual CINOSSync* GetSync() override
1967  { return &m_sSyncCall; };
1969  virtual void SetCallResult(CMcResult aResult) override
1970  { m_SyncCallResult = aResult;};
1972  virtual CMcResult GetCallResult() override
1973  { return m_SyncCallResult;};
1974 
1976  void RequestCritical()
1977  { m_sCritical.Request();};
1979  void ReleaseCritical()
1980  { m_sCritical.Release();};
1981 
1990  bool AddToInputQueue(CINOSTaskExMsg* apMsg, uint32 auFlags=0);
1991 
1997  virtual void MsgCompleted(CINOSTaskExMsg*& apMsg);
1998 
2000  uint8 GetRequestedPriority()
2001  { return m_uReqPriority; };
2003  void SetRequestedPriority(uint8 auPrio)
2004  { m_uReqPriority = auPrio; };
2005 
2006 
2008  void HandleTriggerMsg(CINOSTaskExMsg* apMsg, EDispatchStyle aeDispStyle);
2009 
2025  static void INCOItemToMessageResult(CINCOItem* apItem,
2026  const char* apParentPath, CINOSTaskExMsg* apMsg);
2027 
2046  static void INCOItemsToMessageResults(CINCOItem* apItem,
2047  const char* apParentPath, CINOSTaskExMsg* apMsg);
2048 
2050  CINOSTaskExMsg* GetTmpMsg() { return m_pTmpMsg; }
2051 
2052 #if defined(INOS_TIMINIG_CHECKS_SUSPEND)
2053  virtual void OnResume(uint32 auLastState, uint32 auElapsedUs, void* apSync) override;
2055 #endif
2056 
2057  // public static functions
2058  public :
2065  static CINOSHook* AddMsgDoneHook(void* apHandler, void* apObject = NULL);
2066 
2071  static void RemoveMsgDoneHook(CINOSHook* apHook);
2072 
2073  static uint32 EncodeReplyCode(uint32 auReply, tMcAppError aAppError);
2074 
2075  // protected static functions
2076  protected :
2077 
2081  static void CallMsgDoneHooks(CINOSTaskExMsg* apMsg, ERplId aRplId, tMcAppError aAppError);
2082 
2083  // private members
2084  private :
2086  inosName32 m_cType;
2088  inosName32 m_cAliasName;
2090  char m_cParam[1024];
2092  uint32 m_uSavState;
2094  CINOSTaskEx* m_pParent{};
2096  CINOSMcMessage* m_pMessageHnd{};
2098  CINOSMcNvRamGrp* m_pNvRamGrp;
2100  uintptr m_uDispatchCmdId;
2102  const char* m_pTreeName;
2103  protected :
2105  CINCOObject* m_pRegister;
2107  uint32 m_uOptions;
2109  std::atomic<uint64> m_uFlags;
2111  uint32 m_uRequests;
2113  uint32 m_uCriticals;
2115  uint32 m_uState;
2116  // private members
2117  private :
2121  uint32 m_uIdleTimeout;
2122  uint32 m_uIdleTimeoutAct;
2124  CINOSxmsHandler* m_pIdleTimeoutHook = nullptr;
2125 #if defined(INOS_TIMINIG_CHECKS_SUSPEND)
2126  protected :
2128  uint32 m_uSuspendTimingCheckLimit = DF_INOS_TIMINIG_CHECKS_SUSPEND_MAX_TIME_US;
2129 #endif
2130  // private members
2131  private :
2133  #if defined(INOS_KERNEL_MSGID_64)
2134  static std::atomic<tMsgId> m_MsgId;
2135  #else
2136  static tMsgId m_MsgId;
2137  #endif
2138  CINOSTaskQueue* m_pMsgQueue;
2141  CINOSTaskExMsg* m_pTmpMsg;
2143  CINOSTaskExMsg* m_pActMsg;
2145  CINOSTaskExMsg* m_pSavMsg;
2147  CINOSTaskExMsgUser* m_pMsgUsrIdleTimeout;
2149  CINOSTaskExMsgUser* m_pMsgUsrNvUpdate;
2151  CINCOObject* m_pActMsgObj;
2153  uint32 m_uActParamCount;
2155  // if the commands binary tree is modified (add or remove) or if
2156  // the access to the command is from a different task.
2157  CINOSMutex m_CommandsMutex;
2159  TINOSNameBalancedBinaryTree<CINOSTaskExMsg>* m_pCommands;
2161  TINOSNameBalancedBinaryTree<CINOSTaskExCmdBase> m_CommandRegister;
2163  TINOSNameBalancedBinaryTree<CINOSTaskExCmdHookBase> m_CommandHookRegister;
2165  CINOSTaskExDeferredMsg* m_pDeferredMsg;
2167  uint32 m_uCmdCount;
2169  int16 m_iCurCmdOrder = 1;
2171  int16 m_iCurCmdRegOrder = 1;
2172 
2174  CINOSTaskExCmdDesc* m_pCmdDesc[DF_INOS_TASKEX_MAX_CMD];
2176  uintid m_uMptHookId;
2178  uint32 m_uMptState;
2180  uint64 m_uMptTimeBase;
2182  uint64 m_uStaTotal;
2184  uint64 m_uStaTime[eStaINOSTaskExLast];
2186  nvuint64* m_pNvStaTime[eStaINOSTaskExLast];
2188  uint8 m_uNvStaIndex;
2190  CINOSxmsHandler* m_pNvUpdateHook = nullptr;
2192  uint8 m_uReqPriority;
2193 
2195  CINCOObject* m_pCmd;
2197  CINCOObject* m_pProp;
2199  CINCOObject* m_pOptions;
2201  CINCOObject* m_pFlags;
2203  CINCOObject* m_pRequests;
2205  CINCOObject* m_pCriticals;
2207  CINCOObject* m_pAct;
2209  CINCOObject* m_pStat;
2211  CINCOObject* m_pStatState;
2213  CINCOObject* m_pStatCmd;
2214 
2218  CINOSSync* m_pStartupSync;
2220  CINOSMutex m_sCritical;
2222  CINOSSync m_sSyncCall;
2224  CMcResult m_SyncCallResult;
2225 
2230  uint32 m_uDispatchFlags;
2231 
2233  uint32 m_uPutMsgFlags;
2234 
2235  // nvprop helpers
2236 
2237  // we use protected members here to give descendents a chance to work
2238  // with their own nv variable flavours
2239  protected:
2241  CINCOObject* m_pNvInitObj;
2243  uint32 m_uPropOrder;
2245  uint32 m_uActOrder;
2246 
2247  private:
2252  uint32 m_pLevel[DF_INOS_EVENT_LOGGER_LEVEL_ARRAY_SIZE];
2253 
2255  CINOSTaskExMsg* m_pDeferedStartupMsg = nullptr;
2256 
2260  struct SDynamicItem {
2261  public:
2262  SDynamicItem(CINOSMcVal* apValue, const char* apName, const char* apUnit,
2263  const char* apComboData) :
2264  m_pMcValue(apValue) {
2265 
2266  // Copy the name
2267  const size_t cBufSize = strlen(apName) + 1;
2268  m_pName = new char[cBufSize];
2269  strncpy(m_pName, apName, cBufSize);
2270 
2271  // Copy the unit, if any
2272  if (apUnit != nullptr && apUnit[0] != '\0') {
2273  const size_t cBufSize = strlen(apUnit) + 1;
2274  m_pUnit = new char[cBufSize];
2275  strncpy(m_pUnit, apUnit, cBufSize);
2276  }
2277  else {
2278  m_pUnit = nullptr;
2279  }
2280 
2281  // Do we have combo data?
2282  if (apComboData != nullptr) {
2283  // yes -> Copy the combo data in new buffer
2284  const size_t cBufSize = strlen(apComboData) + 1;
2285  m_pComboData = new char[cBufSize];
2286  strncpy(m_pComboData, apComboData, cBufSize);
2287  }
2288  else {
2289  // no -> set pointer to null
2290  m_pComboData = nullptr;
2291  }
2292  };
2293 
2294  SDynamicItem(SDynamicItem&& aItem) :
2295  m_pMcValue(aItem.m_pMcValue),
2296  m_pName(aItem.m_pName),
2297  m_pUnit(aItem.m_pUnit),
2298  m_pComboData(aItem.m_pComboData)
2299  {
2300  // As ownership is moved, old pointers need to be reset to avoid
2301  // double deletes
2302  aItem.m_pMcValue = nullptr;
2303  aItem.m_pName = nullptr;
2304  aItem.m_pUnit = nullptr;
2305  aItem.m_pComboData = nullptr;
2306  };
2307 
2308  ~SDynamicItem() {
2309  // Delete members if needed
2310  if(m_pMcValue != nullptr) {
2311  delete m_pMcValue;
2312  }
2313  if(m_pName != nullptr) {
2314  delete [] m_pName;
2315  }
2316  if(m_pUnit != nullptr) {
2317  delete [] m_pUnit;
2318  }
2319  if(m_pComboData != nullptr) {
2320  delete [] m_pComboData;
2321  }
2322  }
2323 
2324  CINOSMcVal* m_pMcValue;
2325  char* m_pName;
2326  char* m_pUnit;
2327  char* m_pComboData;
2328  };
2329 
2331  std::unordered_map <std::string, SDynamicItem> m_DynamicProps;
2332  std::unordered_map <std::string, SDynamicItem> m_DynamicActuals;
2333 
2335  uint32 m_uSourceId;
2337  uint32 m_uSourceIdChild;
2339  static uint32 g_uSourceId;
2340 
2341  // private static members
2342  private :
2344  static uint32 m_uTicksMsgValid[DF_INOS_BUS_MAX_NUMBER];
2346  #if defined(INOS_MULTICORE)
2347  static CINOSTaskExMsgNode* m_pTicksMsg[DF_INOS_MAX_CORES][DF_INOS_BUS_MAX_NUMBER];
2348  #else
2349  static CINOSTaskExMsgNode* m_pTicksMsg[DF_INOS_BUS_MAX_NUMBER];
2350  #endif
2351  static CINOSTaskExMsgNode* m_pVarMsg;
2354  static CINOSHooks s_MsgDoneHooks;
2356  static CINOSMutex s_MsgDoneHooksLock;
2357 
2359  DECLARE_DYNAMIC(CINOSTaskEx);
2360 };
2361 
2364 class CINOSTaskExTracer {
2365  private:
2367  CINOSTaskExTracer();
2368 
2369  public:
2382  static void MsgFctCall(CINOSTaskExMsg& aMsg,
2383  const uint32 auTraceLevel = DF_INOS_EVENT_LOGGER_LEVEL_TASKCMD,
2384  const uint32 auTraceColor = DF_INOS_EVENT_LOGGER_FONT_COLOR_GREEN,
2385  CINCOObject* apCmd = NULL);
2388  static void McLog(CINOSTaskExMsg& aMsg);
2389 
2390 };
2391 
2392 /* gcc 10.x does not allow friends with default parameters */
2393 CINOSMcMessage* GetMessageHnd(bool abSearch=true);
2394 tMcAppError SendMessage(uint32 auMsgType, uint32 auMsgCode, uint32 auFlags, CINOSMcData* apInfo=0);
2395 tMcAppError SendMessage(uint32 auMsgType, uint32 auMsgCode, uint32 auFlags, const char* apText, CINOSMcData* apInfo=0);
2396 CMcResult PostMessage(uint32 auMsgType, uint32 auMsgCode, uint32 auFlags, CINOSMcData* apInfo=0);
2397 CMcResult PostMessage(uint32 auMsgType, uint32 auMsgCode, uint32 auFlags, const char* apText, CINOSMcData* apInfo=0);
2398 CMcResult ModifyMessage(tMsgId aiId, uint32 auMsgType, uint32 auMsgCode, uint32 auFlags, CINOSMcData* apInfo=0, const char* apText=nullptr);
2399 CMcResult AckMessage(const CINOSTask* apOwner, uint32 auMsgType=0xffffffff, uint32 auFlag=0);
2400 CINOSMcNvRamGrp* GetNvRamGrp(bool abSearch=true);
2401 void MsgEvent(CINOSTaskExMsg* apMsg, const char* apName, uint32 auMs=0);
2402 void MsgEventFlg(CINOSTaskExMsg* apMsg, const char* apName, uint32 auFlags, uint32 auMs=0);
2403 
2404 // gcc 4.x.x needs additinal 'extern' declaration for friends
2405 extern CINOSMcNvRamGrp* GetNvRamGrp(bool abSearch);
2406 extern CINOSMcMessage* GetMessageHnd(bool abSearch);
2407 extern void MsgEvent(CINOSTaskExMsg* apMsg, const char* apName, uint64 auTicks, uint8 auBusId);
2408 extern void MsgEvent(CINOSTaskExMsg* apMsg, const char* apName, uint32 auMs);
2409 extern void MsgEventFlg(CINOSTaskExMsg* apMsg, const char* apName, uint64 auTicks, uint8 auBusId, uint32 auFlags);
2410 extern void MsgEventFlg(CINOSTaskExMsg* apMsg, const char* apName, uint32 auFlags, uint32 auMs);
2411 extern CMcResult PostMessage(uint32 auMsgType, uint32 auMsgCode, uint32 auFlags, CINOSMcData* apInfo);
2412 extern CMcResult PostMessage(uint32 auMsgType, uint32 auMsgCode, uint32 auFlags, const char* apFormat, CINOSMcData* apInfo);
2413 extern CMcResult PostMessageEx(uint32 auMsgType, uint32 auMsgCode, uint32 auFlags, const char* apProperties);
2414 extern CMcResult PostMessageEx(uint32 auMsgType, uint32 auMsgCode, uint32 auFlags, CINOSMcData* apInfo, const char* apProperties);
2415 extern CMcResult ModifyMessage(tMsgId aiId, uint32 auMsgType, uint32 auMsgCode, uint32 auFlags, CINOSMcData* apInfo);
2416 extern CMcResult ModifyMessageEx(tMsgId aiId, uint32 auMsgType, uint32 auMsgCode, uint32 auFlags, const char* apProperties);
2417 extern CMcResult ModifyMessageEx(tMsgId aiId, uint32 auMsgType, uint32 auMsgCode, uint32 auFlags, CINOSMcData* apInfo, const char* apProperties);
2418 extern tMcAppError SendMessage(uint32 auMsgType, uint32 auMsgCode, uint32 auFlags, CINOSMcData* apInfo);
2419 extern tMcAppError SendMessage(uint32 auMsgType, uint32 auMsgCode, uint32 auFlags, const char* apFormat, CINOSMcData* apInfo);
2420 extern tMcAppError SendMessageEx(uint32 auMsgType, uint32 auMsgCode, uint32 auFlags, const char* apProperties);
2421 extern tMcAppError SendMessageEx(uint32 auMsgType, uint32 auMsgCode, uint32 auFlags, CINOSMcData* apInfo, const char* apProperties);
2422 extern CMcResult AckMessage(tMsgId auMsgId, uint32 auFlags);
2423 extern CMcResult AckMessageDelayed(tMsgId aMsgId, uint32 auFlags, uint32 auTime);
2424 extern CMcResult AckMessage(uint32 auMsgCode, uint32 auFlags, uint32 auMask);
2425 extern CMcResult AckMessageDelayed(uint32 auMsgCode, uint32 auFlags, uint32 auMask, uint32 auTime);
2426 
2427 //------------------------------------------------------------------------------
2428 // template function implementations
2429 //------------------------------------------------------------------------------
2430 
2431 //------------------------------------------------------------------------------
2432 //
2433 template<class T> CINOSTaskExMsgParam* CINOSTaskExMsg::AddParam(T aValue)
2434 {
2435  // create param
2436  CINOSTaskExMsgParam* p = new CINOSTaskExMsgParam(aValue, nullptr, InINCOVContext());
2437  return iAddParam(p);
2438 
2439  // end CINOSTaskExMsg::AddParam
2440 }
2441 
2442 //------------------------------------------------------------------------------
2443 //
2444 template<class T> CINOSTaskExMsgParam* CINOSTaskExMsg::AddParam(const char* apName, T aValue)
2445 {
2446  // create param
2447  CINOSTaskExMsgParam* p = new CINOSTaskExMsgParam(aValue, apName, InINCOVContext());
2448  // add it at the end of the list
2449  return iAddParam(p);
2450 
2451  // end CINOSTaskExMsg::AddParam
2452 }
2453 
2454 //------------------------------------------------------------------------------
2455 //
2456 template<class T> CINOSTaskExMsgDefaultParam* CINOSTaskExMsg::AddDefaultParam(const char* apName, T aValue)
2457 {
2458  // create param
2459  CINOSTaskExMsgDefaultParam* p = new CINOSTaskExMsgDefaultParam(aValue);
2460  p->SetName(apName);
2461  // add it at the end of the list
2462  iAddParam(p);
2463  return p;
2464  // end CINOSTaskExMsg::AddParam
2465 }
2466 //------------------------------------------------------------------------------
2467 //
2468 template<class T> T CINOSTaskExMsg::GetParam ()
2469 {
2470  // get pointer to param
2471  CINOSTaskExMsgParam* p = iGetParam();
2472  // did we get one ?
2473  if (p) {
2474  // yes -> return result
2475  // (work around for gcc bug 1058: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=1058)
2476  return p->CINOSTaskExMsgParam::template GetTypedValue<T>();
2477  } // end if
2478  else {
2479  // no -> return "zero"
2480  return T();
2481  }
2482  // end CINOSTaskExMsg::GetParam
2483 }
2484 
2485 //------------------------------------------------------------------------------
2486 //
2487 template<class T> T CINOSTaskExMsg::GetFirstParam ()
2488 {
2489  // reset internal pointer
2490  m_pTmpParam = 0;
2491  // call main
2492  // (work around for gcc bug 1058: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=1058)
2493  T val = CINOSTaskExMsg::template GetParam<T>();
2494  return val;
2495 
2496  // end CINOSTaskExMsg::GetFirstParam
2497 }
2498 
2499 //------------------------------------------------------------------------------
2500 //
2501 template<class T> void CINOSTaskExMsg::AddResult(T aValue, const char* apResultName /*= NULL*/)
2502 {
2503  // create param
2504  CINOSTaskExMsgParam* p = new CINOSTaskExMsgParam(aValue, apResultName, InINCOVContext());
2505  // add it at the end of the list
2506  iAddResult(p);
2507 
2508 } // end CINOSTaskExMsg::AddResult
2509 
2510 //------------------------------------------------------------------------------
2511 //
2512 template<class T> void CINOSTaskExMsg::InsertResult(T aValue, const char* apResultName /*= NULL*/)
2513 {
2514  // create param
2515  CINOSTaskExMsgParam* p = new CINOSTaskExMsgParam(aValue, apResultName, InINCOVContext());
2516  // insert it at the beginning of the list
2517  iInsertResult(p);
2518 
2519 } // end CINOSTaskExMsg::InsertResult
2520 
2521 //------------------------------------------------------------------------------
2522 //
2523 template<class T> void CINOSTaskExMsg::AppendResult(T aValue, const char* apResultName /*= NULL*/)
2524 {
2525  // create param
2526  CINOSTaskExMsgParam* p = new CINOSTaskExMsgParam(aValue, apResultName, InINCOVContext());
2527  // add it at the end of the list
2528  iAppendResult(p);
2529 
2530 } // end CINOSTaskExMsg::AppendResult
2531 
2532 //------------------------------------------------------------------------------
2533 //
2534 template<class T> T CINOSTaskExMsg::GetResult ()
2535 {
2536  // get pointer to param
2537  CINOSTaskExMsgParam* p = iGetResult();
2538  // did we get one ?
2539  if (p) {
2540  // yes -> return result
2541  // (work around for gcc bug 1058: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=1058)
2542  return p->CINOSTaskExMsgParam::template GetTypedValue<T>();
2543  } // end if
2544  else {
2545  // no -> return "zero"
2546  return (T) 0;
2547  }
2548  // end CINOSTaskExMsg::GetResult
2549 }
2550 
2551 //------------------------------------------------------------------------------
2552 //
2553 template<class T> void CINOSTaskEx::ReplyParam(uint32 auReply, T aValue)
2554 {
2555  // ensure that we have a command
2556  if (m_pActMsg){
2557  // get pointer to sender of actual command
2558  CINOSTask* snd = m_pActMsg->m_pSender;
2559  // reply only allowed if task exists and was inherited from CINOSTaskEx
2560  if (snd && (snd->mClassSize == sizeof(CINOSTaskEx))){
2561  // create reply
2562  CINOSTaskExMsg* pRpl = new CINOSTaskExMsg(eMsgReply, auReply);
2563  // copy also user data to reply
2564  pRpl->SetUser(m_pActMsg->GetUser());
2565  // add requested param
2566  pRpl->AddParam(aValue);
2567  // and put it into the sender's queue
2568  ((CINOSTaskEx*)snd)->PutReply(pRpl, m_pActMsg->m_Id);
2569  } // end if
2570  } // end if
2571 
2572  // end CINOSTaskEx::Reply
2573 }
2574 
2577 inline CINOSTaskEx* ActualTaskEx()
2578 {
2579  CINOSTask* pTask = ActualTask();
2580  if (pTask->GetClassSize() == sizeof(CINOSTaskEx)) {
2581  return static_cast<CINOSTaskEx*>(pTask);
2582  }
2583  else {
2584  return nullptr;
2585  }
2586 }
2587 
2588 //------------------------------------------------------------------------------
2589 // class definition
2590 //------------------------------------------------------------------------------
2591 //
2592 class CINOSMcSync : public CINOSSync
2593 {
2594  //--- user interface ---------------------------------------------------
2595 
2596  // public members
2597  public:
2599  CINOSMcSync(CINOSTaskExMsg* apMsg, void* apHandler=NULL, void* apObject=NULL);
2600 
2601  //--- internals --------------------------------------------------------
2602 
2603  // protected members
2604  protected :
2606  virtual void Signal() override;
2607 
2608  // private members
2609  private :
2611  CINOSTaskEx* m_pTask;
2613  tMsgId m_MsgId;
2614 
2616  DECLARE_DYNAMIC(CINOSMcSync);
2617 };
2618 
2619 //------------------------------------------------------------------------------
2620 // class definition
2621 //------------------------------------------------------------------------------
2622 // Helper sync object that implements a event queue. This can be used
2623 // if a task needs to wait for an event of a command synchronously.
2624 class CINOSMcSyncEvent : public CINOSSync
2625 {
2626  //--- user interface ---------------------------------------------------
2627 
2628  // public members
2629  public:
2631  CINOSMcSyncEvent();
2632 
2633  virtual ~CINOSMcSyncEvent();
2634 
2636  ICACHE virtual bool MsgEvent(CINOSTaskExMsg* apMsg) override;
2637 
2639  virtual CINOSTaskQueue* GetEventQueue() { return m_pEventQueue; };
2640 
2642  // deletes all events that occur before that event
2643  // is never nullptr as the function waits forever for the event.
2644  virtual CINOSTaskExMsg* WaitForEvent(const char* apEventName);
2645 
2646  // private members
2647  private :
2649  CINOSTaskQueue* m_pEventQueue;
2650 
2652  DECLARE_DYNAMIC(CINOSMcSyncEvent);
2653 };
2654 
2655 
2656 //------------------------------------------------------------------------------
2657 // class definition
2658 //------------------------------------------------------------------------------
2659 //
2682 class CINOSMcSyncMsg : public CINOSSync
2683 {
2684  private:
2687  CINOSMcSyncMsg(CINOSTaskEx& aTask, CINOSTaskExMsg* apMsg);
2688  public:
2698  static CINOSMcSyncMsg* Create(CINOSTaskEx& aTask,
2699  CINOSTaskExMsg* apMsg);
2700  /* Overwritten to perform specific stuff. */
2701  virtual void Signal() override;
2702 
2703  private:
2704  CINOSTaskEx& m_Task;
2705  CINOSTaskExMsg* m_pMsg;
2706 
2707  DECLARE_DYNAMIC(CINOSMcSyncMsg)
2708 };
2709 
2710 //------------------------------------------------------------------------------
2711 // CINCOTaskExProcedure
2712 //------------------------------------------------------------------------------
2713 
2714 class CINCOTaskExProcedure : public CINCOProcedure
2715 {
2716  // constructor
2717  public:
2718  CINCOTaskExProcedure(
2719  char* apName, // object name
2720  uint32 auMsgType,
2721  uintptr auMsgCode,
2722  uint32 auMsgSubCode,
2723  uint32 auMsgFlags,
2724  CINOSTaskEx* apTask,
2725  uint32 auNumberOfParameters, // number of parameters
2726  uint32 auTypeOfParameters, // first 16 bit long paras / string;
2727  // after float paras
2728  uint32 auIntTypeOfParameters, // first 16 bit signed, second 16 bit bool
2729  uint64 auChar, // characteristics of object
2730  uint16 auKeyLevel // keylevel of object
2731  );
2732 
2733  // call procedure
2734  virtual void Call(void* aParameters=0, void* aResult=0, long aOffset=0,bool aCallProcEx=true) override;
2735 #ifdef INOS_FAST_CALLPROCEDURE
2736  // call procedure consolidated
2737  virtual void Call(CINCOParamReader& aParameters, CINCOResult& aResult, long aOffset=0) override;
2738 #endif
2739 
2740  protected:
2741  CINOSTaskEx* m_pTask;
2742  uint32 m_uMsgType;
2743  uintptr m_uMsgCode;
2744  uint32 m_uMsgSubCode;
2745  uint32 m_uMsgFlags;
2746  uint32 m_uSubTypeOfParameters;
2747 
2748 
2749  DECLARE_DYNAMIC(CINCOTaskExProcedure);
2750 };
2751 
2752 //------------------------------------------------------------------------------
2753 // Include CINCOTaskEx templates. Must be at the bottom of the file to
2754 // avoid cyclic includes.
2755 //------------------------------------------------------------------------------
2756 
2757 #include <cinostaskextmpl.h>
2758 
2759 
2760 //------------------------------------------------------------------------------
2761 
2762 #endif // INC_CINOSTASKEX_H
2763 
2764 
2765 //------------------------------------------------------------------------------
2766 // end of file
CINOSTaskEx::Create
void Create()
do main creation work
CINOSTaskExMsgTriggerVar
Definition: cinostaskex.h:153
CINOSTaskExMsg::GetPersistent
bool GetPersistent() const
get persistent flag
Definition: cinostaskex.h:669
CINOSMutex::Request
ICACHE uint32 Request(uint32 aTimeout=INOS_WAIT_FOREVER)
CINOSMutex
Definition: cinosmutex.h:35
tMsgId
int32 tMsgId
Definition: inostype.h:186
CINOSTaskExMsg::GetSync
CINOSSync * GetSync() const
get pointer to sync object
Definition: cinostaskex.h:633
CINOSTaskExMsgTrigger::~CINOSTaskExMsgTrigger
virtual ~CINOSTaskExMsgTrigger()
destructor
Definition: cinostaskex.h:140
CINOSTaskExMsg::SetAlwaysReply
void SetAlwaysReply()
Set notrace flag.
Definition: cinostaskex.h:712
ActualTask
CINOSTask * ActualTask()
CINOSTaskEx::GetLastUsr
constexpr static int GetLastUsr()
return last taskex user id
Definition: cinostaskex.h:1313
CINOSTaskEx::GetOptionStr
bool GetOptionStr(const char *apBase, char *apResult, uint32 auSize) const
return option string belonging to apBase 'apBase=optionstring'
CINOSTaskExMsgTriggerTicks::~CINOSTaskExMsgTriggerTicks
virtual ~CINOSTaskExMsgTriggerTicks()
destructor
Definition: cinostaskex.h:267
CINOSTaskEx::GetDeferredMsg
CINOSTaskExDeferredMsg * GetDeferredMsg(tMsgId auReplyId)
get pointer to deferred message with given reply id
CINOSTaskExMsgTriggerEvent::GetCmdName
const char * GetCmdName()
get cmd name
Definition: cinostaskex.h:220
CINOSTaskEx::DispatchInternal
virtual bool DispatchInternal(CINOSTaskExMsg *apMsg)
dispatch internal message
CINOSTaskExMsg::GetCanceled
bool GetCanceled() const
get canceled flag
Definition: cinostaskex.h:660
CINOSTaskEx::m_uOptions
uint32 m_uOptions
task options
Definition: cinostaskex.h:2107
CINOSTaskExMsgTriggerEvent::m_cCmdName
inosName64 m_cCmdName
command name
Definition: cinostaskex.h:238
CINOSTaskEx::MsgInComplete
virtual void MsgInComplete(CINOSTaskExMsg *apMsg, tMcAppError aAppError=0)
message incomplete
CINOSTaskEx::iMessageAdd
virtual void iMessageAdd(CINOSTaskExMsg *apMsg)
internal message add
CINOSTaskExMsg::GetDeferred
bool GetDeferred() const
get deferred flag
Definition: cinostaskex.h:648
CINOSTaskExMsg::SetDeferred
void SetDeferred()
get deferred flag
Definition: cinostaskex.h:645
CINOSTaskEx::ClrFlag
virtual void ClrFlag(uint64 auFlag, bool abUpdateState=false)
clr flag
Definition: cinostaskex.h:1948
CINOSTaskExMsg::SetId
void SetId(tMsgId aId)
set message id
Definition: cinostaskex.h:585
CINOSTaskExMsg::FstResult
void FstResult()
reset internal pointer to first result
Definition: cinostaskex.h:452
CINOSTaskExMsg::ClearStatic
void ClearStatic()
Clear static flag.
Definition: cinostaskex.h:702
CINOSTaskEx::ClrFlag
virtual CMcResult ClrFlag(const char *apName, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
clear flag apName
CINOSMcSync::CINOSMcSync
CINOSMcSync(CINOSTaskExMsg *apMsg, void *apHandler=NULL, void *apObject=NULL)
constructor
CINOSTaskEx::GetFlag
bool GetFlag(uint64 auFlag) const
return true if flag available
Definition: cinostaskex.h:1049
CINOSTaskEx::m_pRegister
CINCOObject * m_pRegister
pointer to my inco registration
Definition: cinostaskex.h:2105
CINOSTaskEx::iMessageModify
virtual void iMessageModify(CINOSTaskExMsg *apMsg)
internal message modify
CINOSTaskExMsg::GetFirstParam
T GetFirstParam()
get first param
Definition: cinostaskex.h:2487
CINOSTaskExMsgTriggerVar::~CINOSTaskExMsgTriggerVar
virtual ~CINOSTaskExMsgTriggerVar()
destructor
CINOSTaskEx::RemActual
virtual void RemActual(const char *apName)
remove object actual apName
CINOSTaskEx::GetLastCmd
constexpr static int GetLastCmd()
return last taskex command id
Definition: cinostaskex.h:1309
CINOSTaskExMsg::DestroyParams
void DestroyParams()
destroys all params
CINOSTaskExMsgTriggerVar::DECLARE_DYNAMIC
DECLARE_DYNAMIC(CINOSTaskExMsgTriggerVar)
dynamic object handling
CINOSTaskExMsg::AddResults
void AddResults(CINOSTaskExMsgParam *apMsgParam)
CINOSTaskEx::AddParam
virtual void AddParam(const char *apName, real64 arValue, real64 arMin, real64 arMax, const char *apUnit, uint32 auChar, uint32 auFlags=0)
add param to command. You can use REAL64MIN/MAX to allow all possible values.
CINOSTaskExMsgTrigger::CINOSTaskExMsgTrigger
CINOSTaskExMsgTrigger(uint32 auType)
constructor
Definition: cinostaskex.h:137
CINOSTaskEx::DispatchCmd
virtual bool DispatchCmd(CINOSTaskExMsg *apMsg)
dispatch command message
CINOSTaskExMsg::CINOSTaskExMsg
CINOSTaskExMsg(uint32 auMsgType, uintptr auMsgCode, CINOSSync *apSync=DF_INOS_ASYNCHRONOUS)
constructor
CINOSTaskExMsgTriggerTicks::GetSynName
const char * GetSynName()
get syn name
Definition: cinostaskex.h:270
CINOSTaskEx::RemChildModule
virtual void RemChildModule(const char *apModuleName)
remove child command
Definition: cinostaskex.h:1907
CINOSTaskExMsg::AddParam
CINOSTaskExMsgParam * AddParam(T)
add param
Definition: cinostaskex.h:2433
CINOSTaskEx::iAddActual
virtual void iAddActual(CINOSTaskExMsg *apMsg)
reply to actual message
CINOSMcSync::Signal
virtual void Signal() override
overloaded signal
CINOSTaskEx::SetCallResult
virtual void SetCallResult(CMcResult aResult) override
set sync call result
Definition: cinostaskex.h:1969
CINOSTaskEx::PostMessageEx
friend CMcResult PostMessageEx(uint32 auMsgType, uint32 auMsgCode, uint32 auFlags, const char *apProperties)
post message
CINOSTaskExMsgTriggerTicks::m_rParamValue
real64 m_rParamValue
value
Definition: cinostaskex.h:297
CINOSTaskEx::GetNvRamGrp
friend CINOSMcNvRamGrp * GetNvRamGrp(bool abSearch)
get nvram group
CINOSTaskEx::GetOptionEx
bool GetOptionEx(const char *apBase) const
CINOSTaskExMsg::GetFlags
uint32 GetFlags()
get flags
Definition: cinostaskex.h:636
CINOSTaskEx::GetCriticalsObj
virtual CINCOObject * GetCriticalsObj()
get pointer to 'Criticals' inco folder
Definition: cinostaskex.h:1245
CINOSTaskExMsg::SetPending
void SetPending()
set pending flag
Definition: cinostaskex.h:657
CINOSTaskEx::Action
virtual void Action() override
main action
CINOSTaskExMsg::GetId
tMsgId GetId() const
get message id
Definition: cinostaskex.h:588
CINOSTaskEx::AddChildCommand
virtual void AddChildCommand(const char *apModuleName, const char *apFunctionName, CINOSTaskExMsg *apCmdMsg, bool abRegisterInco=true)
add child command
Definition: cinostaskex.h:1897
CINOSTaskEx::_AddCommand
virtual void _AddCommand(CINOSTaskExMsg *apMsg, CINCOObject *apMsgCmdObj, int16 aiOrder=0)
add inco command
CINOSTaskExMsg::iAddParam
CINOSTaskExMsgParam * iAddParam(CINOSTaskExMsgParam *apParam)
internal addparam
CINOSTaskExMsgTriggerVar::GetCompare
const char * GetCompare()
get compare
Definition: cinostaskex.h:172
CINOSTaskExMsg::GetNoTrace
bool GetNoTrace() const
Get notrace flag.
Definition: cinostaskex.h:684
CINOSTaskEx::DispatchOther
virtual bool DispatchOther(CINOSTaskExMsg *apMsg)
dispatch other message
DF_INOS_MAX_CORES
#define DF_INOS_MAX_CORES
Definition: inosdefine.h:164
CINOSTaskExMsg::SetFlushResistent
void SetFlushResistent()
set flush resistant flag
Definition: cinostaskex.h:672
CINOSTaskEx::GetStateText
virtual const char * GetStateText()
return actual state text
CINCOTaskExProcedure
Definition: cinostaskex.h:2714
CINOSTaskExMsgTriggerVar::m_pValue
char * m_pValue
value
Definition: cinostaskex.h:186
CINOSTaskExMsg::AppendResult
void AppendResult(T, const char *apResultName=NULL)
Definition: cinostaskex.h:2523
INOS_MCMSG_CODE_TSKEX_WRONG_PARAMS
uint32 INOS_MCMSG_CODE_TSKEX_WRONG_PARAMS
Definition: inoserror.h:1680
CINOSTaskExMsg::AreMcLogTracesRequested
bool AreMcLogTracesRequested() const
CINOSTaskExTracer::McLog
static void McLog(CINOSTaskExMsg &aMsg)
CINOSTaskExMsgParam::GetNext
CINOSTaskExMsgParam * GetNext() const
Definition: cinostaskexdef.h:284
CINOSTaskEx::HandleTriggerMsg
void HandleTriggerMsg(CINOSTaskExMsg *apMsg, EDispatchStyle aeDispStyle)
handle message with a trigger
CINOSTaskEx::SetAliasName
void SetAliasName(const char *apAlias)
set alias name
Definition: cinostaskex.h:994
CINOSTaskEx::SetCritical
void SetCritical(uint32 auCritical)
set critical
Definition: cinostaskex.h:1959
CINOSTaskEx::iFailure
virtual void iFailure(CINOSTaskExMsg *apMsg)
internal command handling failure
CINOSTaskExCmdBase
Definition: cinostaskextmpl.h:434
CINOSTaskEx::m_uPropOrder
uint32 m_uPropOrder
prop folder order
Definition: cinostaskex.h:2243
CINOSMcSyncEvent::GetEventQueue
virtual CINOSTaskQueue * GetEventQueue()
Gets the message queue from the sync object.
Definition: cinostaskex.h:2639
INOS_OR
#define INOS_OR(variable, mask)
Definition: inosmacro.h:201
CINOSTaskExMsgTriggerEvent::GetEventName
const char * GetEventName()
get event name
Definition: cinostaskex.h:223
CINOSTaskEx::GetCommand
bool GetCommand(const char *apName) const
return true if command 'aName' is requested in params
CINOSTaskEx::SetCmdObj
virtual CINCOObject * SetCmdObj(CINCOObject *apCmd)
set pointer to 'Cmd' inco folder and return old one
CINOSTaskExMsgTriggerTicks::CINOSTaskExMsgTriggerTicks
CINOSTaskExMsgTriggerTicks(const char *apSynName, real64 arParamValue, const char *apParamType, uint64 auBusTicks, uint8 auBusId)
constructor
CINOSTaskEx::iStopMsg
virtual void iStopMsg(CINOSTaskExMsg *apMsg)
stop message
ActualTaskEx
CINOSTaskEx * ActualTaskEx()
Definition: cinostaskex.h:2577
CINOSTaskExMsg::GetSender
CINOSTask * GetSender() const
get pointer to sender
Definition: cinostaskex.h:617
CINOSTaskExMsgTriggerTicks::GetParamValue
real64 GetParamValue()
get param value
Definition: cinostaskex.h:276
CINOSTaskEx::m_uFlags
std::atomic< uint64 > m_uFlags
task flags
Definition: cinostaskex.h:2109
CINOSTaskExMsg::AddResult
void AddResult(T, const char *apResultName=NULL)
Definition: cinostaskex.h:2501
CINOSTaskEx::ReplyParam
void ReplyParam(uint32 auReply, T)
reply to actual message with param
Definition: cinostaskex.h:2553
CINOSTaskExMsg::RemAndTrigger
void RemAndTrigger(uint32 auIndex=0, bool abDelete=true)
remove 'and' message trigger
CINOSTaskExMsg::DontCreateMcLogTraces
void DontCreateMcLogTraces()
CINOSTaskExMsg::SetInfo
void SetInfo(const char *apInfo)
set info
Definition: cinostaskex.h:727
CINOSTaskEx::GetDispatchFlag
uint32 GetDispatchFlag() const
set dispatch flag. see SetDispatchFlag for further information
Definition: cinostaskex.h:1085
CINOSTaskEx::GetRequestedPriority
uint8 GetRequestedPriority()
get requested priority
Definition: cinostaskex.h:2000
CINOSTaskExMsg::GetResultCount
uint32 GetResultCount() const
Get the count of results.
CINOSTaskEx::GetCmdObj
virtual CINCOObject * GetCmdObj()
get pointer to 'Cmd' inco folder
CINOSTaskExMsg::SetStatic
void SetStatic()
Set static flag.
Definition: cinostaskex.h:696
CINOSTaskEx::ReleaseCritical
void ReleaseCritical()
release critical section
Definition: cinostaskex.h:1979
CINOSTaskExMsg::AddIncoItemAsResult
tMcAppError AddIncoItemAsResult(CINCOItem *apItem, bool abBitAsNumber=false)
add the value of an INCO item as result
CINOSTaskExMsg::SetBusTicks
void SetBusTicks(uint64 auBusTicks)
set busticks
Definition: cinostaskex.h:733
CINOSTaskEx::IsCmdDeferred
bool IsCmdDeferred(uint32 auCmdCode)
return true if task has a deferred command 'auCmdCode'
CINOSTaskEx::PutMsgEx
virtual CMcResult PutMsgEx(CINOSTaskExMsg *apMsg, uint32 auFlags, tMsgId aMsgId=0)
Put a message with flags to adjust behaviour.
CINOSTaskExMsg::SetTrigger
void SetTrigger(real64 arValue)
set message trigger [ms]
CINOSTaskEx::AddProp
virtual void AddProp()
add object property to the 'Prop' folder
CINOSMutex::Release
ICACHE void Release(bool aSuspend=false, uint32 auState=defINOSTaskPureSuspended)
CINOSTaskEx::GetOptionNbr
bool GetOptionNbr(const char *apBase, uintnbr &auNumber) const
return option number belonging to apBase 'apBase=number'
CINOSTaskEx::MsgEvent
friend void MsgEvent(CINOSTaskExMsg *apMsg, const char *apName, uint64 auTicks, uint8 auBusId)
return an informational event to the sender of apMsg
CINOSTaskEx::iHandleIdleTimeout
virtual void iHandleIdleTimeout()
internal handle idle timeout
CINOSTaskEx::GetPropObj
virtual CINCOObject * GetPropObj()
get pointer to 'Prop' inco folder
CINOSTaskExMsgTriggerEvent::GetParamType
const char * GetParamType()
get paramtype
Definition: cinostaskex.h:226
CINOSTaskExMsgTriggerEvent::DECLARE_DYNAMIC
DECLARE_DYNAMIC(CINOSTaskExMsgTriggerEvent)
dynamic object handling
CINOSTaskEx::iAddProp
virtual void iAddProp(CINOSTaskExMsg *apMsg)
internal set property
CINOSTaskEx::iSetActual
virtual void iSetActual(CINOSTaskExMsg *apMsg)
internal set actual
CINOSTaskExMsg::SetName
void SetName(const char *apName)
set name
Definition: cinostaskex.h:715
CINOSMcSyncMsg::Create
static CINOSMcSyncMsg * Create(CINOSTaskEx &aTask, CINOSTaskExMsg *apMsg)
CINOSTaskEx::GetCritical
bool GetCritical(uint32 auCritical) const
return true if critical set
Definition: cinostaskex.h:1058
DF_INOS_ASYNCHRONOUS
#define DF_INOS_ASYNCHRONOUS
Definition: inosmacro.h:337
CINOSTaskExMsgNode
Definition: cinostaskex.h:311
CINOSTaskEx::GetRequest
bool GetRequest(uint32 auRequest) const
return true if request set
Definition: cinostaskex.h:1055
CINOSTaskExMsg::RemTrigger
void RemTrigger()
remove trigger from message
Definition: cinostaskex.h:557
CINOSTaskEx::SetState
virtual void SetState(uint32 auState)
set state
Definition: cinostaskex.h:974
CINOSTaskExMsg::GetBusTicks
uint64 GetBusTicks() const
get busticks
Definition: cinostaskex.h:736
CINOSTaskEx::CreateMsgFromCommand
virtual CINOSTaskExMsg * CreateMsgFromCommand(const char *apName, CINOSSync *apSync=DF_INOS_ASYNCHRONOUS)
create a new message from command name or NULL if command not found. To call a command directly the t...
CINOSTaskExMsg::GetMsgCode
uintnbr GetMsgCode() const
get message code
Definition: cinostaskex.h:597
CINOSTaskEx::DispatchMessage
virtual bool DispatchMessage(CINOSTaskExMsg *apMsg)
dispatch message message
CINOSTaskExMsgTriggerEvent::GetTaskName
const char * GetTaskName()
get task name
Definition: cinostaskex.h:217
CINOSTaskEx::AddMsgDoneHook
static CINOSHook * AddMsgDoneHook(void *apHandler, void *apObject=NULL)
Add a hook to call some member function when MsgDone() gets called. This function is thread-safe.
CINOSTaskEx::MsgEventFlg
friend void MsgEventFlg(CINOSTaskExMsg *apMsg, const char *apName, uint64 auTicks, uint8 auBusId, uint32 auFlags)
return an informational event to the sender of apMsg
CINOSTaskEx::PostCreate
virtual void PostCreate(void *apParent)
called after creation
CINOSTaskExMsg::SetAlwaysSyncSignal
void SetAlwaysSyncSignal()
Set notrace flag.
Definition: cinostaskex.h:707
CINOSTaskEx::DispatchSub
virtual bool DispatchSub(CINOSTaskExMsg *apMsg)
dispatch sub message
CINOSTaskEx::CreateMsg
virtual CINOSTaskExMsg * CreateMsg(CINOSTaskExMsg *apMsg, CINOSMcDataInst *apData, const char *apAlias)
create message from apMsg
CINOSTaskExMsgTriggerVar::m_cCompare
char m_cCompare[8]
compare string
Definition: cinostaskex.h:182
CINOSTaskExMsg::GetData
CINOSMcDataInst * GetData() const
get pointer to material
Definition: cinostaskex.h:630
CINOSTaskExMsgTriggerTicks::GetBusId
uint64 GetBusId()
get bus id
Definition: cinostaskex.h:282
CINOSTaskEx::MsgPaused
virtual void MsgPaused(CINOSTaskExMsg *apMsg, tMcAppError aAppError=0)
message paused. Deprecated!
CINOSTaskEx::MsgDefer
virtual tMsgId MsgDefer(CINOSTaskExMsg *apMsg, void *apHandler=0, void *apObject=0, bool abHandlesCommands=false)
defer message and return according MsgId
CINOSTaskEx::GetParent
CINOSTaskEx * GetParent() const
get parent
Definition: cinostaskex.h:1013
CINOSMcSyncEvent::MsgEvent
virtual ICACHE bool MsgEvent(CINOSTaskExMsg *apMsg) override
overloaded signal
CINOSTaskEx::MsgCompleted
virtual void MsgCompleted(CINOSTaskExMsg *&apMsg)
CINOSTaskExMsgParam
Definition: cinostaskexdef.h:128
CINOSTaskExMsg::MoveResultsToParams
void MoveResultsToParams(CINOSTaskExMsg &aMsg)
CINOSTaskEx::AddParam
void AddParam(CINCOItem *apItem, T aValue, uint32 auFlags=0)
Definition: cinostaskex.h:1881
CINOSTaskExMsg::GetUser
void * GetUser() const
get pointer to user data
Definition: cinostaskex.h:627
CINOSTaskEx::iClrFlag
virtual void iClrFlag(CINOSTaskExMsg *apMsg)
internal clear flag
CINOSTaskExMsg::SetSingle
void SetSingle()
set single flag
Definition: cinostaskex.h:681
CINOSTaskExMsgTriggerEvent::m_cTaskName
inosName64 m_cTaskName
task name
Definition: cinostaskex.h:236
CINOSTaskEx
Definition: cinostaskex.h:965
CINOSTaskExMsgTriggerEvent::m_rParamValue
real64 m_rParamValue
value
Definition: cinostaskex.h:244
CINOSTaskExMsgTrigger
Definition: cinostaskex.h:117
CINOSTaskEx::ClrCritical
void ClrCritical(uint32 auCritical)
clr critical
Definition: cinostaskex.h:1962
CINOSTaskExMsgTriggerTicks::AdjTicks
void AdjTicks(int32 aiTicks)
adjust bus ticks
Definition: cinostaskex.h:287
CINOSTaskExMsg::GetResult
T GetResult()
get result
Definition: cinostaskex.h:2534
CINOSTaskEx::iMessageRemove
virtual void iMessageRemove(CINOSTaskExMsg *apMsg)
internal message remove
CINOSTaskEx::ModifyMessage
friend CMcResult ModifyMessage(tMsgId aiId, uint32 auMsgType, uint32 auMsgCode, uint32 auFlags, CINOSMcData *apInfo, const char *apText)
modify message
CINOSMcSyncEvent
Definition: cinostaskex.h:2624
CINOSTaskEx::GetMessageHnd
friend CINOSMcMessage * GetMessageHnd(bool abSearch)
get message handler
CINOSTaskExMsg::MoveParamsFromMsg
void MoveParamsFromMsg(CINOSTaskExMsg *apMsg)
Moves all params of apMsg to this message.
CINOSTaskExMsgTriggerVar::GetValue
real64 GetValue(CINOSMcData *apData=0)
get value
CINOSTaskExMsg::SetFlags
void SetFlags(uint32 auFlags)
set flags
Definition: cinostaskex.h:639
CINOSTaskEx::iCheckIdleTimeout
void iCheckIdleTimeout()
internal check idle timeout
CINOSTaskExMsg::GetFirstResultPtr
CINOSTaskExMsgParam * GetFirstResultPtr()
Get pointer to iterate over results.
CINOSTaskEx::MsgCanceled
virtual void MsgCanceled(CINOSTaskExMsg *apMsg, tMcAppError aAppError=0)
message canceled
CINOSTaskExMsgTriggerVar::m_cName
char m_cName[64]
variable name
Definition: cinostaskex.h:180
CINOSTaskEx::iSetIdleTimeout
virtual void iSetIdleTimeout(CINOSTaskExMsg *apMsg)
internal set idle timeout
CINOSTaskEx::PostMessage
friend CMcResult PostMessage(uint32 auMsgType, uint32 auMsgCode, uint32 auFlags, CINOSMcData *apInfo)
post message
CINOSTaskExMsgTriggerTicks::m_cParamType
char m_cParamType[8]
param type
Definition: cinostaskex.h:295
CINOSTaskEx::PutReply
virtual void PutReply(CINOSTaskExMsg *apMsg, tMsgId aMsgId)
put reply message to queue
CINOSTaskEx::GetAliasName
const char * GetAliasName() const
get pointer to alias name
Definition: cinostaskex.h:991
CINOSTaskEx::GetOption
bool GetOption(const char *apName) const
return true if option 'aName' is requested in params
CINOSTaskExMsg::GetDone
bool GetDone() const
get touched flag
Definition: cinostaskex.h:651
CINOSTaskEx::GetStatObj
virtual CINCOObject * GetStatObj()
get pointer to 'Stat' inco folder
CINOSTaskEx::NvUpdate
void NvUpdate()
nvram update
CINOSTaskEx::DispatchEvent
virtual bool DispatchEvent(CINOSTaskExMsg *apMsg)
dispatch event message
CINOSTaskEx::GetMsgId
static tMsgId GetMsgId()
get system wide unique message id
CINOSTaskEx::DispatchUser
virtual bool DispatchUser(CINOSTaskExMsg *apMsg)
dispatch user message
CINOSTaskExMsg::InsertResult
void InsertResult(T, const char *apResultName=NULL)
Definition: cinostaskex.h:2512
CINOSTaskEx::iDeleteCommand
virtual void iDeleteCommand(CINOSTaskExMsg *apMsg)
internal delete command (only used for commands of type call)
CINOSTaskEx::GetMsgName
char * GetMsgName(CINOSTaskExMsg *apMsg)
get message name
CINOSTaskEx::PostDispatchMsg
virtual void PostDispatchMsg()
PostDispatchMsg.
Definition: cinostaskex.h:1647
CINOSTaskEx::AckMessage
friend CMcResult AckMessage(tMsgId aMsgId, uint32 auFlags)
ack message
CINOSTaskEx::operator<
int operator<(CINOSTaskEx &aTaskEx)
binary tree operators
Definition: cinostaskex.h:1603
CINOSTaskEx::GetType
const char * GetType() const
get pointer to type
Definition: cinostaskex.h:988
CINOSTaskExMsg::SetCanceled
void SetCanceled()
set canceled flag
Definition: cinostaskex.h:663
cinostaskexdef.h
CINOSTaskEx::SendMessage
friend tMcAppError SendMessage(uint32 auMsgType, uint32 auMsgCode, uint32 auFlags, CINOSMcData *apInfo)
send message
CINOSTaskEx::~CINOSTaskEx
virtual ~CINOSTaskEx()
destructor
CINOSTaskEx::GetOptionsObj
virtual CINCOObject * GetOptionsObj()
get pointer to 'Options' inco folder
Definition: cinostaskex.h:1236
CINOSTaskExMsg::SetSync
void SetSync(CINOSSync *apSync)
set pointer to sync object
Definition: cinostaskex.h:582
CINOSTaskEx::iUsrMsgDone
virtual void iUsrMsgDone(CINOSTaskExMsg *apMsg)
internal user message done, used to handle message dones from other
CINOSTaskEx::iSetProp
virtual void iSetProp(CINOSTaskExMsg *apMsg)
internal set property
CINOSTaskEx::MsgStopped
virtual void MsgStopped(CINOSTaskExMsg *apMsg, tMcAppError aAppError=0)
message stopped
INOS_AND
#define INOS_AND(variable, mask)
Definition: inosmacro.h:210
CINOSTaskEx::AddActual
virtual void AddActual()
add object property to the 'Act' folder
CINOSTaskExMsgUser::DECLARE_DYNAMIC
DECLARE_DYNAMIC(CINOSTaskExMsgUser)
dynamic object handling
CINOSTaskEx::GetCallResult
virtual CMcResult GetCallResult() override
get sync call result
Definition: cinostaskex.h:1972
CINOSTaskExMsg::~CINOSTaskExMsg
~CINOSTaskExMsg()
destructor
CINOSTaskEx::GetRequestsObj
virtual CINCOObject * GetRequestsObj()
get pointer to 'Requests' inco folder
Definition: cinostaskex.h:1242
CINOSTaskExMsg::GetTrigger
CINOSTaskExMsgTrigger * GetTrigger()
get message trigger
Definition: cinostaskex.h:554
CINOSTaskEx::RegisterCommand
void RegisterCommand(CINOSTaskExCmdBase *apCommand)
register a command that will be added at startup (depending in the option)
CINOSTaskExMsgTriggerEvent::GetSynName
const char * GetSynName()
get syn name
Definition: cinostaskex.h:214
CINOSTaskExMsg::FstParam
void FstParam()
reset internal pointer to first param
Definition: cinostaskex.h:412
cinosbus.h
Short comment.
CINOSTaskExMsg::GetPending
bool GetPending() const
get pending flag
Definition: cinostaskex.h:654
CINOSTaskExMsg::GetAndTrigger
CINOSTaskExMsgTrigger * GetAndTrigger(uint32 auIndex=0)
get 'and' message trigger
CINOSTaskExMsg::GetParamCnt
uint32 GetParamCnt() const
get number of param's
Definition: cinostaskex.h:448
CINOSTaskExDef
Definition: cinostaskexdef.h:69
CINOSTaskEx::m_uActOrder
uint32 m_uActOrder
act folder order
Definition: cinostaskex.h:2245
CINOSTaskEx::AddCommand
virtual void AddCommand(const char *apName, uint32 auCode, CINCOProcedure *apProc)
add inco command
CINOSTaskExMsg::SetSender
void SetSender(CINOSTask *apSender)
set pointer to sender
Definition: cinostaskex.h:573
CINOSTaskEx::GetFlag
bool GetFlag(const char *apName) const
return true if flag 'aName' is requested in params
CINOSTaskExMsgUser::CINOSTaskExMsgUser
CINOSTaskExMsgUser(uint32 auMsgCode, uint32 auFlags=0)
constructor
Definition: cinostaskex.h:948
CINOSTaskEx::IsCmdBusy
bool IsCmdBusy(uintptr auCmdCode)
return true if task is actual command 'auCmdCode' busy
CINOSTaskExTracer::MsgFctCall
static void MsgFctCall(CINOSTaskExMsg &aMsg, const uint32 auTraceLevel=DF_INOS_EVENT_LOGGER_LEVEL_TASKCMD, const uint32 auTraceColor=DF_INOS_EVENT_LOGGER_FONT_COLOR_GREEN, CINCOObject *apCmd=NULL)
CINOSTaskEx::MsgIgnored
virtual void MsgIgnored(CINOSTaskExMsg *apMsg, tMcAppError aAppError=0)
message ignored
CINOSTaskEx::m_uRequests
uint32 m_uRequests
task requests
Definition: cinostaskex.h:2111
CINOSTaskEx::SetMessageHnd
void SetMessageHnd(CINOSMcMessage *apMessageHnd)
set message handler
Definition: cinostaskex.h:1321
CINOSTaskEx::GetParam
const char * GetParam() const
get pointer to param
Definition: cinostaskex.h:985
CINOSTaskExMsgTriggerVar::CINOSTaskExMsgTriggerVar
CINOSTaskExMsgTriggerVar(const char *apVarName, const char *apCompare, real64 arValue)
constructor
CINOSTaskEx::iSetIncoItemsFromParamStruct
static uint32 iSetIncoItemsFromParamStruct(CINCOItem *apIncoItem, long alOffset, CINOSTaskExMsgParam *apParams, bool abOverwrite, inosName128 &oErrorItemName)
Helper function for commands that set INCO items from a parameter stucture.
CINOSTaskExDeferredMsg
Definition: cinostaskex.h:331
CINOSTaskEx::m_uState
uint32 m_uState
task state
Definition: cinostaskex.h:2115
CINOSTaskEx::iSetFlag
virtual void iSetFlag(CINOSTaskExMsg *apMsg)
internal switch core
CINOSTaskEx::CallMsgDoneHooks
static void CallMsgDoneHooks(CINOSTaskExMsg *apMsg, ERplId aRplId, tMcAppError aAppError)
Call hooks to notify observers about MsgDone, passing all arguments for inspection....
CINOSTaskEx::GetSync
virtual CINOSSync * GetSync() override
get task sync object
Definition: cinostaskex.h:1966
INOS_MCMSG_CODE_TSKEX_UNKNOWN
uint32 INOS_MCMSG_CODE_TSKEX_UNKNOWN
Definition: inoserror.h:1680
CINOSTaskEx::GetOption
bool GetOption(uint32 auOption) const
return true if option available
Definition: cinostaskex.h:1044
CINOSTaskExMsgTriggerTicks::AdjTicksMs
void AdjTicksMs(int32 aiMs)
adjust bus ticks
CINOSTaskExMsgTriggerVar::GetName
const char * GetName()
get var name
Definition: cinostaskex.h:169
cinostaskextmpl.h
Helper class and templates definition for CINOSTaskEx.
CINOSTaskEx::DispatchReply
virtual bool DispatchReply(CINOSTaskExMsg *apMsg)
dispatch reply message
CINOSTaskEx::INCOItemToMessageResult
static void INCOItemToMessageResult(CINCOItem *apItem, const char *apParentPath, CINOSTaskExMsg *apMsg)
Add value of INCO item to results of apMsg.
tMcAppError
uint32 tMcAppError
Definition: cinostaskexdef.h:53
CINOSTaskExMsg::AddResultsFromMsgParams
void AddResultsFromMsgParams(CINOSTaskExMsg *apMsg)
Removes all params of apMsgParam and adds them to the results of this message.
CINOSTaskEx::RemCommand
virtual void RemCommand(const char *apName)
remove command
CINOSTaskEx::MsgError
virtual void MsgError(CINOSTaskExMsg *apMsg, tMcAppError aAppError)
message error
CINOSTaskExMsg::GetMsgSubCode
uint32 GetMsgSubCode() const
get message code
Definition: cinostaskex.h:603
CINOSTaskExMsgTriggerTicks::m_cSynName
inosName32 m_cSynName
sync name
Definition: cinostaskex.h:288
CINOSTaskExMsgTriggerTicks::GetBusTicks
uint64 GetBusTicks()
get bus ticks
Definition: cinostaskex.h:279
CINOSTaskExMsg::SetPersistent
void SetPersistent()
set persistent flag
Definition: cinostaskex.h:666
CINOSTaskExMsg::SetNoTrace
void SetNoTrace()
Set notrace flag.
Definition: cinostaskex.h:690
CINOSTaskExMsg::GetMsgType
uint32 GetMsgType() const
get message type
Definition: cinostaskex.h:591
CINOSTaskExMsgTriggerEvent::CINOSTaskExMsgTriggerEvent
CINOSTaskExMsgTriggerEvent(const char *apSynName, real64 arParamValue, const char *apParamType, const char *apTaskName, const char *apCmdName, const char *apEventName)
constructor
CINOSTaskEx::SetParent
void SetParent(CINOSTaskEx *apParent)
set parent pointer
Definition: cinostaskex.h:1933
CINOSTaskEx::GetFlags
uint64 GetFlags() const
return all flags
Definition: cinostaskex.h:1052
CINOSMcSyncMsg::Signal
virtual void Signal() override
Put object into the signaled state.
CINOSTaskEx::FlushTmd
virtual void FlushTmd(tMsgId aId=0)
remove triggered messages auId of type eMsgCmd or all if auId==0
INOS_MCMSG_CODE_TSKEX_PARAM_MISSING
uint32 INOS_MCMSG_CODE_TSKEX_PARAM_MISSING
Definition: inoserror.h:1680
CINOSMcSyncMsg
Definition: cinostaskex.h:2682
CINOSTaskEx::iAddCommand
virtual void iAddCommand(CINOSTaskExMsg *apMsg)
internal add command
CINOSTaskEx::iMessageAcknowledge
virtual void iMessageAcknowledge(CINOSTaskExMsg *apMsg)
internal message acknowledge
CINOSTaskExMsg::GetParam
T GetParam()
get param
Definition: cinostaskex.h:2468
CINOSTaskEx::RemProp
virtual void RemProp(const char *apName)
remove object property apName
CINOSTaskExMsgTriggerEvent::m_cParamType
char m_cParamType[8]
param type
Definition: cinostaskex.h:242
CINOSTaskEx::RequestCritical
void RequestCritical()
request critical section
Definition: cinostaskex.h:1976
CINOSTaskEx::iRemCommand
virtual void iRemCommand(CINOSTaskExMsg *apMsg)
internal add command
CINOSTaskEx::MsgRejected
virtual void MsgRejected(CINOSTaskExMsg *apMsg, tMcAppError aAppError=0)
message rejected
CINOSTaskEx::Shutdown
virtual uint32 Shutdown(CINOSSync *apSync=DF_INOS_SYNCHRONOUS) override
shutdown task
CINOSTaskExMsgTriggerTicks::m_uBusTicks
uint64 m_uBusTicks
bus ticks
Definition: cinostaskex.h:299
CINOSTaskExMsg::AddJsonParam
CINOSTaskExMsgParam * AddJsonParam(const char *apJson)
add params form JSON string
CINOSTaskExMsg::GetReceiver
CINOSTaskEx * GetReceiver() const
get pointer to receiver task
Definition: cinostaskex.h:622
CINOSTaskEx::MsgFailed
virtual void MsgFailed(CINOSTaskExMsg *apMsg, tMcAppError aAppError=0)
message failed
CINOSTaskEx::GetTreeName
virtual const char * GetTreeName()
get requested binary tree name
Definition: cinostaskex.h:999
CINOSTaskExMsg::AddFlags
void AddFlags(uint32 auFlags)
add flags
Definition: cinostaskex.h:642
DF_INOS_TIMINIG_CHECKS_SUSPEND_MAX_TIME_US
#define DF_INOS_TIMINIG_CHECKS_SUSPEND_MAX_TIME_US
Definition: inosdefault.h:265
CINOSTaskExMsg::GetSingle
bool GetSingle() const
get single flag
Definition: cinostaskex.h:678
CINOSTaskEx::ModifyMessageEx
friend CMcResult ModifyMessageEx(tMsgId aiId, uint32 auMsgType, uint32 auMsgCode, uint32 auFlags, const char *apProperties)
modify message
DF_INOS_SYNCHRONOUS
#define DF_INOS_SYNCHRONOUS
Definition: inosmacro.h:332
CINOSTaskEx::PutMsg
virtual CMcResult PutMsg(CINOSTaskExMsg *apMsg, tMsgId aMsgId=0)
put message to queue and return command id
CINOSTaskEx::INCOItemsToMessageResults
static void INCOItemsToMessageResults(CINCOItem *apItem, const char *apParentPath, CINOSTaskExMsg *apMsg)
Add the value of the INCO item apItem and all its children (if any) as named results to the message (...
CINOSTaskEx::AddParam_int32
virtual void AddParam_int32(const char *apName, const char *apUnit, int32 aiValue, int32 aiMin, int32 aiMax, uint32 auChar, uint32 auFlags=0)
Add int32 parameter to command. You can use INT32MIN/MAX to allow all possible values.
CINOSTaskEx::iCancelDeferred
virtual void iCancelDeferred()
internal cancel all deferred messages
CINOSTaskEx::GetTmpMsg
CINOSTaskExMsg * GetTmpMsg()
Get temporary message (used for subclasses overriding AddCommand)
Definition: cinostaskex.h:2050
CINOSTaskEx::CallCommand
CMcResult CallCommand(const char *apName, ParamType... aParams, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
calls a command given the command name. The function can be called using less than defined parameters...
Definition: cinostaskex.h:1145
CINOSTaskEx::RemoveMsgDoneHook
static void RemoveMsgDoneHook(CINOSHook *apHook)
Remove a previously added MsgDone() hook. This function is thread-safe.
CINOSTaskEx::GetCommandHook
virtual const CINOSTaskExCmdHookBase * GetCommandHook(const char *apName)
get pointer to command hook apName or NULL if not found
Definition: cinostaskex.h:1224
CINOSTaskExCmdHookBase
Definition: cinostaskextmpl.h:262
CINOSTaskEx::DispatchTmd
virtual bool DispatchTmd(CINOSTaskExMsg *apMsg)
dispatch triggered command message
CINOSTaskEx::AddChildModule
virtual void AddChildModule(const char *apModuleName)
add child command
Definition: cinostaskex.h:1905
CINOSTaskExMsgTriggerTicks::DECLARE_DYNAMIC
DECLARE_DYNAMIC(CINOSTaskExMsgTriggerTicks)
dynamic object handling
CINOSTaskExMsgTriggerTicks::GetParamType
const char * GetParamType()
get paramtype
Definition: cinostaskex.h:273
CINOSTaskEx::MsgDonePnd
virtual void MsgDonePnd(CINOSTaskExMsg *apMsg, tMcAppError aAppError=0)
message done (and set 'pending' flag)
CINOSTaskEx::MsgFatal
virtual void MsgFatal(CINOSTaskExMsg *apMsg, tMcAppError aAppError)
message fatal error
CINOSTaskEx::m_uCriticals
uint32 m_uCriticals
task critical sections
Definition: cinostaskex.h:2113
CINOSTaskEx::AdjTrigger
virtual void AdjTrigger(CINOSTaskExMsg *apMsg)
adjust trigger
CINOSTaskEx::SetFlag
virtual CMcResult SetFlag(const char *apName, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
set flag apName
CINOSTaskExMsg::SetMsgCode
void SetMsgCode(uintnbr auMsgCode)
get message code
Definition: cinostaskex.h:594
CINOSTaskEx::Startup
virtual CMcResult Startup(real64 arStage)
startup task (always asynchronous)
CINOSTaskExMsg::DestroyResults
void DestroyResults()
destroys all result params
CINOSxmsHandler
Definition: inos_1ms.h:90
CINOSTaskEx::GetRegister
virtual CINCOObject * GetRegister(CINCOObject *apObject=0)
get pointer to inco registration
CINOSTaskExMsg::GetRetValue
uint32 GetRetValue() const
get return value. !!!OBSOLETE!!! Will be removed soon
Definition: cinostaskex.h:614
CINOSTaskExCmdDesc
Definition: cinostaskex.h:370
CINOSTaskEx::GetActMsg
CINOSTaskExMsg * GetActMsg()
get pointer to actually handled message
Definition: cinostaskex.h:1117
CINOSTaskEx::iGetActual
virtual void iGetActual(CINOSTaskExMsg *apMsg)
internal get actual
CINOSTaskEx::iStartup
virtual void iStartup(CINOSTaskExMsg *apMsg)
internal startup task
CINOSTaskEx::MptHook
void MptHook()
measure hook
CINOSTaskEx::GetSourceId
uint32 GetSourceId()
get source id
Definition: cinostaskex.h:1009
CINOSTaskEx::RemDeferredMsg
void RemDeferredMsg(CINOSTaskExDeferredMsg *apDef)
remove deferred message from list
CINOSTaskEx::ClrDispatchFlag
void ClrDispatchFlag(uint32 auFlag)
clr dispatch flag. see SetDispatchFlag for further information
Definition: cinostaskex.h:1082
CINOSTaskExMsg::MoveResultsFromMcResult
void MoveResultsFromMcResult(CMcResult &aResult)
CINOSTaskEx::m_pNvInitObj
CINCOObject * m_pNvInitObj
pointer to temporary nvobj
Definition: cinostaskex.h:2241
CINOSTaskExMsgDefaultParam
Definition: cinostaskexdef.h:609
CINOSTaskEx::AddParam_int64
virtual void AddParam_int64(const char *apName, const char *apUnit, int64 aiValue, int64 aiMin, int64 aiMax, uint32 auChar, uint32 auFlags=0)
Add int64 parameter to command. You can use INT64MIN/MAX to allow all possible values.
CINOSTaskExMsg::GetBusId
uint8 GetBusId() const
get busid
Definition: cinostaskex.h:745
CINOSTaskExMsgTriggerEvent::m_cSynName
inosName32 m_cSynName
sync name
Definition: cinostaskex.h:234
CINOSTaskEx::RemMessage
friend CMcResult RemMessage(const CINOSTask *apOwner)
rem message
CINOSTaskExMsg::SetUser
void SetUser(void *apUser)
set pointer to user data
Definition: cinostaskex.h:576
CINOSTaskEx::PreDestroy
virtual bool PreDestroy(bool &bDeleteSelf)
called before destruction (return false if destruction not allowed)
CINOSTaskEx::RequestListen
friend CMcResult RequestListen(uint32 auMsgType, uint32 auSetId, uint32 auAckId)
request listen
CINOSMcSync
Definition: cinostaskex.h:2592
CINOSTaskEx::SetFlag
virtual void SetFlag(uint64 auFlag, bool abUpdateState=false)
set flag
Definition: cinostaskex.h:1943
CINOSTaskEx::ERplId
ERplId
reply id's
Definition: cinostaskex.h:1411
CINOSTaskEx::ReleaseListen
friend CMcResult ReleaseListen()
request listen
CINOSTaskExMsgTriggerTicks
Definition: cinostaskex.h:256
CINOSTaskExTracer
Definition: cinostaskex.h:2364
CINOSTaskEx::MsgDone
virtual void MsgDone(tMsgId aMsgId, tMcAppError aAppError=0)
message done (used for deferred messages)
CINOSMcSyncEvent::CINOSMcSyncEvent
CINOSMcSyncEvent()
constructor
CINOSTaskExMsg::operator<
int operator<(CINOSTaskExMsg &aTaskExMsg)
binary tree operators
Definition: cinostaskex.h:828
CINOSSync
Definition: inos_syn.h:66
CINOSTaskEx::iGetCommands
virtual void iGetCommands(CINOSTaskExMsg *apMsg)
internal get commands
CINOSTaskExMsg::GetIdInfo
tMsgId GetIdInfo() const
get id info
Definition: cinostaskex.h:751
CINOSTaskExMsg::SetBusId
void SetBusId(uint8 auBusId)
set busid
Definition: cinostaskex.h:742
CINOSTaskEx::SendMessageEx
friend tMcAppError SendMessageEx(uint32 auMsgType, uint32 auMsgCode, uint32 auFlags, const char *apProperties)
send message
CINOSTaskEx::CINOSTaskEx
CINOSTaskEx(const char *apName, const char *apParam=0, uint32 aStackSize=defDefaultStackSize, uint32 aPriority=defLowestPriority, bool aFloatingPoint=true, uint32 aTimeSlice=defDefaultTimeSlice, bool aInterruptsDisabled=false)
constructor
CINOSTaskExMsg::AddDefaultParam
CINOSTaskExMsgDefaultParam * AddDefaultParam(const char *apName, T aValue)
add default param
Definition: cinostaskex.h:2456
DECLARE_DYNAMIC
#define DECLARE_DYNAMIC(aClass)
Definition: cinospartitionmemory.h:328
CINOSTaskExMsg
Definition: cinostaskex.h:395
CINOSTaskEx::iShutdown
virtual void iShutdown(CINOSTaskExMsg *apMsg)
internal shutdown task
CINOSMcSyncEvent::WaitForEvent
virtual CINOSTaskExMsg * WaitForEvent(const char *apEventName)
Waits for an event of given and returns the message, the return.
CINOSTaskExMsgTriggerEvent::~CINOSTaskExMsgTriggerEvent
virtual ~CINOSTaskExMsgTriggerEvent()
destructor
CINOSTaskEx::SetDispatchFlag
void SetDispatchFlag(uint32 auFlag)
Definition: cinostaskex.h:1079
CINOSTaskExMsg::GetFlushResistent
bool GetFlushResistent() const
get flush resistent flag
Definition: cinostaskex.h:675
CINOSTaskExMsg::SetData
void SetData(CINOSMcDataInst *apData)
set pointer to data
Definition: cinostaskex.h:579
CINOSTaskEx::GetMessageHndEx
CINOSMcMessage * GetMessageHndEx()
get message handler
CINOSTaskExMsgTriggerEvent::GetParamValue
real64 GetParamValue(CINOSMcData *apData=0)
get param value
CINOSTaskExMsgTrigger::GetType
uint32 GetType()
return trigger type
Definition: cinostaskex.h:131
CINOSTaskEx::GetState
uint32 GetState()
get state
CINOSTaskEx::PreDispatchMsg
virtual bool PreDispatchMsg(CINOSTaskExMsg *apMsg)
Pre dispatcher.
CINOSTaskEx::GetActObj
virtual CINCOObject * GetActObj()
get pointer to 'Act' inco folder
CINOSTaskEx::iGetProp
virtual void iGetProp(CINOSTaskExMsg *apMsg)
internal get property
CINOSTaskEx::GetDeferredMsgCmd
CINOSTaskExMsg * GetDeferredMsgCmd(uint32 auCmdCode)
get pointer to deferred message with given command code
CINOSTaskEx::Reply
void Reply(CINOSTaskExMsg *apMsg, uint32 auReply, tMcAppError aAppError=0)
reply to actual message
CINOSTaskExMsg::SetMsgSubCode
void SetMsgSubCode(uint32 auMsgSubCode)
get message code
Definition: cinostaskex.h:600
CINOSTaskExMsg::GetInfo
char * GetInfo()
get info
Definition: cinostaskex.h:730
CINOSTaskExMsg::LstParam
void LstParam()
reset internal pointer to the last param
Definition: cinostaskex.h:415
CINOSTaskEx::AddParam_uint64
virtual void AddParam_uint64(const char *apName, const char *apUnit, uint64 auValue, uint64 auMin, uint64 auMax, uint32 auChar, uint32 auFlags=0)
Add uint64 parameter to command. You can use UINT64MIN/MAX to allow all possible values.
CINOSTaskExMsg::AndTrigger
void AndTrigger(const char *apSynName, real64 arParamValue, const char *apParamType, const char *apTaskName, const char *apCmdName, const char *apEventName)
add 'and' message trigger
CINOSTaskEx::StopMsg
virtual CMcResult StopMsg(tMsgId atMsgId, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
stop message
CINOSTaskExMsg::SetIdInfo
void SetIdInfo(tMsgId auIdInfo)
set id info
Definition: cinostaskex.h:748
CINOSTaskEx::RegisterHook
void RegisterHook(CINOSTaskExCmdHookBase *apHook)
register a command hook which can be set to a command later
CINOSTaskExMsgTriggerEvent::m_cEventName
inosName32 m_cEventName
event name
Definition: cinostaskex.h:240
CINOSTaskEx::iAddRegisteredCommands
virtual uint32 iAddRegisteredCommands()
add registered commands (done between startup and post startup)
CINOSTaskEx::SetRequestedPriority
void SetRequestedPriority(uint8 auPrio)
set requested priority
Definition: cinostaskex.h:2003
CINOSTaskEx::AddEllipsis
virtual void AddEllipsis()
Add ellipsis to command.
CINOSTaskExMsgTriggerVar::m_rValue
real64 m_rValue
value
Definition: cinostaskex.h:184
CINOSTaskExMsgTrigger::DECLARE_DYNAMIC
DECLARE_DYNAMIC(CINOSTaskExMsgTrigger)
dynamic object handling
CINOSTaskExMsgTriggerEvent::m_pParamValue
char * m_pParamValue
value
Definition: cinostaskex.h:246
CINOSTaskEx::RemChildCommand
virtual void RemChildCommand(const char *apModuleName, const char *apFunctionName)
remove child command
Definition: cinostaskex.h:1902
CINOSTaskEx::SetRequest
virtual void SetRequest(uint32 auRequest)
set request
Definition: cinostaskex.h:1953
CINOSTaskExMsgTrigger::m_uType
uint32 m_uType
trigger type
Definition: cinostaskex.h:141
CINOSTaskEx::GetCommandMsg
virtual const CINOSTaskExMsg * GetCommandMsg(const char *apName)
get pointer to command apName or NULL if not found
Definition: cinostaskex.h:1120
CINOSTaskExMsg::GetStatic
bool GetStatic() const
Get notrace flag.
Definition: cinostaskex.h:693
CINOSTaskExMsg::SetRetValue
void SetRetValue(uint32 auRetValue)
set return value. !!!OBSOLETE!!! Will be removed soon
Definition: cinostaskex.h:611
CINOSTaskExMsgUser
Definition: cinostaskex.h:941
CINOSTaskEx::AddToInputQueue
bool AddToInputQueue(CINOSTaskExMsg *apMsg, uint32 auFlags=0)
CINOSTaskEx::SetIdleTimeout
virtual CMcResult SetIdleTimeout(uint32 auIdleTimeout, CINOSSync *apSync=DF_INOS_SYNCHRONOUS)
ASSERT_ALWAYS
#define ASSERT_ALWAYS(f)
Definition: inosmacro.h:696
CINOSTaskEx::IsCmdAllowed
virtual bool IsCmdAllowed(CINOSTaskExMsg *apMsg)
Definition: cinostaskex.h:982
CINOSTaskEx::GetIncoName
virtual const char * GetIncoName()
get requested inco folder name
CINOSTaskExMsgTriggerEvent
Definition: cinostaskex.h:196
CINOSTaskEx::PutCmd
virtual tMsgId PutCmd(uint32 auCommand)
put command to queue and return command id
CINOSTaskEx::ClrRequest
virtual void ClrRequest(uint32 auRequest)
clr request
Definition: cinostaskex.h:1956
CINOSTaskEx::GetFlagsObj
virtual CINCOObject * GetFlagsObj()
get pointer to 'Flags' inco folder
Definition: cinostaskex.h:1239
CINOSTaskEx::GetMsgQueue
virtual CINOSTaskQueue * GetMsgQueue()
get pointer to message queue
Definition: cinostaskex.h:1113
CINOSTaskExMsg::GetName
char * GetName(bool abResolveIfEmpty=false)
CINOSTaskEx::SetTreeName
virtual void SetTreeName(const char *apTreeName)
set requested binary tree name
Definition: cinostaskex.h:1755
CINOSTaskEx::iPostStartup
virtual bool iPostStartup()
internal post startup
CINOSTaskExMsg::GetQueueTicks
uint64 GetQueueTicks() const
get QueueTicks
Definition: cinostaskex.h:739
CINOSTask
Definition: cinostask.h:51