cinostaskex.h

Go to the documentation of this file.

//******************************************************************************
//******************************************************************************
 
#ifndef INC_CINOSTASKEX_H
#define INC_CINOSTASKEX_H
 
//
//------------------------------------------------------------------------------
// includes
//------------------------------------------------------------------------------
//
// system
#include <inos.h>
#include <inos_lib.h>
#include <cinosbus.h>
#include <cinosmcnvram.h>
#include <cmcresult.h>
#include <cinostaskexdef.h>
#include <cincotype.h>
#include <cinoseventloggerdef.h>
#include <cinostaskexstatesdef.h>
#include <cinosmcdata.h>
 
#ifdef INOS_INCOV
#include <cincovdispatcher.h>
#endif
//
// C++
#include <unordered_map>
#include <string>
#include <atomic>
 
//
// project
//
//------------------------------------------------------------------------------
// defines
//------------------------------------------------------------------------------
//
#ifdef _MSC_VER
#define INOS_TASKEX_MESSAGE( apFormat, ... ) \
    InternLog( DF_INOS_EVENT_LOGGER_LEVEL_TASKMSG, \
            DF_INOS_EVENT_LOGGER_FONT_COLOR_BLUE, apFormat, __VA_ARGS__ )
#else
#define INOS_TASKEX_MESSAGE( apFormat, aArgs... ) \
    InternLog( DF_INOS_EVENT_LOGGER_LEVEL_TASKMSG, \
            DF_INOS_EVENT_LOGGER_FONT_COLOR_BLUE, apFormat, ##aArgs )
#endif
//
#define DF_INOS_TASKEX_MAX_CMD      128 // max. number of commands (for statistics)
#define DF_INOS_TASKEX_MAX_AND_TRG  4   // max. number of 'and' trigger
#define DF_INOS_TASKEX_MAX_TRG_VAL_NAME 256 // max. allowed trigger value name length
#define DF_INOS_TASKEX_STARTUP_PRIO DF_INOS_TASK_PRIO_USER_HIGHEST  // taskex startup priority
 
#define INOS_MCLOG_REPLY_EX(aMsg,rpl,err)                                                               \
    {                                                                                                   \
        if( CINOSEventLogger::Instance().IsLevelActive(DF_INOS_EVENT_LOGGER_LEVEL_TASKMSG) ) {          \
            if (!aMsg->GetNoTrace()) {                                                                  \
                double tim = double(0.000001)*g_pTarget->ConvertToNanoSeconds(GetSystemTicks());        \
                InternLog( DF_INOS_EVENT_LOGGER_LEVEL_TASKMSG,                                          \
                        DF_INOS_EVENT_LOGGER_FONT_COLOR_BLUE,                                           \
                        "RPL:TimStp,%f:Rec,%s:Id," PFIID ":Snd,%s:Que,%1.6fms:Typ," PFU32 ":Ret," PF0X32,\
                        tim, GetName(), aMsg->GetId(), GetName(), tim, (uint32)rpl, (uint32) err);\
            }                                                                                           \
        }                                                                                               \
    }
 
// macro to 'force' a mclog conform message reply in the eventlog
#define INOS_MCLOG_REPLY(aMsg) INOS_MCLOG_REPLY_EX(aMsg,eRplOk,0)
 
//------------------------------------------------------------------------------
// forward declarations
//------------------------------------------------------------------------------
 
class CINOSMcMessage;
class CINOSMcNvRam;
class CINOSMcData;
class CINOSMcDataInst;
class CINOSTaskEx;
class CINOSTaskExCmdBase;
class CINOSTaskExCmdHookBase;
 
#ifdef INOS_INCOV
class CINCOVServerSession;
class CINCOVOperation;
class SINCOVLazyContext;
#endif
 
//------------------------------------------------------------------------------
// class CINOSTaskExMsgTrigger
//------------------------------------------------------------------------------
//
class CINOSTaskExMsgTrigger
{
    friend class CINOSTaskEx;
    friend class CINOSTaskExMsg;
    
    // public members
    public :
        enum {
            eTypVar,
            eTypEvent,
            eTypTicks
        };
        uint32 GetType()
            { return m_uType;};
     
    // protected members
    protected :
        explicit CINOSTaskExMsgTrigger (uint32 auType)
            { m_uType = auType;};
        virtual ~CINOSTaskExMsgTrigger()
            {};
        uint32 m_uType;
 
    DECLARE_DYNAMIC(CINOSTaskExMsgTrigger);
};
//
//------------------------------------------------------------------------------
// class CINOSTaskExMsgTriggerVar
//------------------------------------------------------------------------------
//
class CINOSTaskExMsgTriggerVar : public CINOSTaskExMsgTrigger
{
    friend class CINOSTaskEx;
    friend class CINOSTaskExMsg;
 
    // public members
    public :
        CINOSTaskExMsgTriggerVar (const char* apVarName, const char* apCompare,
            real64 arValue);
        CINOSTaskExMsgTriggerVar (const char* apVarName, const char* apCompare,
            const char* apValue);
        virtual ~CINOSTaskExMsgTriggerVar();
        const char* GetName()
            { return &m_cName[0];};
        const char* GetCompare()
            { return &m_cCompare[0];};
        real64 GetValue(CINOSMcData* apData=0);
 
    // protected members
    protected :
        char m_cName[64];
        char m_cCompare[8];
        real64 m_rValue;
        char* m_pValue;
 
    DECLARE_DYNAMIC(CINOSTaskExMsgTriggerVar);
};
//
//------------------------------------------------------------------------------
// class CINOSTaskExMsgTriggerEvent
//------------------------------------------------------------------------------
//
class CINOSTaskExMsgTriggerEvent : public CINOSTaskExMsgTrigger
{
    friend class CINOSTaskEx;
    friend class CINOSTaskExMsg;
 
    // public members
    public :
        CINOSTaskExMsgTriggerEvent (const char* apSynName, real64 arParamValue, 
            const char* apParamType, const char* apTaskName, const char* apCmdName,
            const char* apEventName);
        CINOSTaskExMsgTriggerEvent (const char* apSynName, const char* apParamValue, 
            const char* apParamType, const char* apTaskName, const char* apCmdName,
            const char* apEventName);
        virtual ~CINOSTaskExMsgTriggerEvent();
        const char* GetSynName()
            { return &m_cSynName[0];};
        const char* GetTaskName()
            { return &m_cTaskName[0];};
        const char* GetCmdName()
            { return &m_cCmdName[0];};
        const char* GetEventName()
            { return &m_cEventName[0];};
        const char* GetParamType()
            { return &m_cParamType[0];};
        real64 GetParamValue(CINOSMcData* apData=0);
    
    // protected members
    protected :
        inosName32 m_cSynName;
        inosName64 m_cTaskName;
        inosName64 m_cCmdName;
        inosName32 m_cEventName;
        char m_cParamType[8];
        real64 m_rParamValue;
        char* m_pParamValue;
 
    DECLARE_DYNAMIC(CINOSTaskExMsgTriggerEvent);
};
//
//------------------------------------------------------------------------------
// class CINOSTaskExMsgTriggerTicks
//------------------------------------------------------------------------------
//
class CINOSTaskExMsgTriggerTicks : public CINOSTaskExMsgTrigger
{
    friend class CINOSTaskEx;
    friend class CINOSTaskExMsg;
 
    // public members
    public :
        CINOSTaskExMsgTriggerTicks (const char* apSynName, real64 arParamValue, 
            const char* apParamType, uint64 auBusTicks, uint8 auBusId);
        virtual ~CINOSTaskExMsgTriggerTicks()
            {};
        const char* GetSynName()
            { return &m_cSynName[0];};
        const char* GetParamType()
            { return &m_cParamType[0];};
        real64 GetParamValue()
            { return m_rParamValue;};
        uint64 GetBusTicks()
            { return m_uBusTicks;};
        uint64 GetBusId()
            { return m_uBusId;};
        void AdjTicksMs(int32 aiMs);
        void AdjTicks(int32 aiTicks)
            { m_uBusTicks += aiTicks;};
 
    // protected members
    protected :
        inosName32 m_cSynName;
        char m_cParamType[8];
        real64 m_rParamValue;
        uint64 m_uBusTicks;
        //; bus id
        uint8 m_uBusId;
 
    DECLARE_DYNAMIC(CINOSTaskExMsgTriggerTicks);
};
//
//------------------------------------------------------------------------------
// class CINOSTaskExMsgNode
//------------------------------------------------------------------------------
//
class CINOSTaskExMsgNode
{
    friend class CINOSTaskEx;
    CINOSTaskExMsgNode (CINOSTaskEx* apTask, CINOSTaskExMsg* apMsg)
        { m_pTask = apTask; m_pMsg = apMsg; m_pNext=0;};
    CINOSTaskEx* m_pTask;   
    CINOSTaskExMsg* m_pMsg; 
    CINOSTaskExMsgNode* m_pNext;    
    DECLARE_DYNAMIC(CINOSTaskExMsgNode);
};
//
//------------------------------------------------------------------------------
// class CINOSTaskExDeferredMsg
//------------------------------------------------------------------------------
//
class CINOSTaskExDeferredMsg
{
public:
    virtual CINOSTaskExMsg* GetMsg() { return m_pMsg; };
 
private:
    friend class CINOSTaskEx;
    friend class CINOSMcModule;
    friend class CINOSMcRobot;
    CINOSTaskExDeferredMsg (CINOSTaskExMsg* apMsg, tMsgId auReplyId, void* apHandler,
        void* apObject, bool abHandlesCommands)
        { m_pMsg = apMsg; m_uReplyId = auReplyId; m_pHandler = apHandler;
          m_pObject = apObject; m_pNext=0; m_pPrev = 0;
          m_bHandlesCommands = abHandlesCommands;};
    virtual ~CINOSTaskExDeferredMsg() {}
    CINOSTaskExMsg* m_pMsg; 
    tMsgId m_uReplyId;
    void* m_pHandler;   
    void* m_pObject;    
    bool m_bHandlesCommands;
    CINOSTaskExDeferredMsg* m_pNext;    
    CINOSTaskExDeferredMsg* m_pPrev;    
    DECLARE_DYNAMIC(CINOSTaskExDeferredMsg);
};
//
//------------------------------------------------------------------------------
// class CINOSTaskExCmdDesc
//------------------------------------------------------------------------------
//
class CINOSTaskExCmdDesc
{
    friend class CINOSTaskEx;
    CINOSTaskExCmdDesc ();
    uint32 m_uCount;
    nvuint32* m_pCount;
    uint64 m_uStart;
    uint64 m_uTime; 
    uint64 m_uTotal;    
    DECLARE_DYNAMIC(CINOSTaskExCmdDesc);
};
 
 
//------------------------------------------------------------------------------
// class CINOSTaskExMsg
//------------------------------------------------------------------------------
//
class CINOSTaskEx;
class CINOSTaskExMsg
{
    //--- user interface ---------------------------------------------------
 
    // public member functions
    public :
        CINOSTaskExMsg(uint32 auMsgType, uintptr auMsgCode,
            CINOSSync* apSync = DF_INOS_ASYNCHRONOUS);
        CINOSTaskExMsg(uint32 auMsgType, const char* apMsgName, uintptr auMsgCode=0);
        CINOSTaskExMsg(const CINOSTaskExMsg& aMsg);
        ~CINOSTaskExMsg();
        
        void FstParam()
            { m_pTmpParam = 0;};
        void LstParam()
            { CINOSTaskExMsgParam* p = m_pParam;
                while (p->m_pNext)  p = p->m_pNext;
                m_pTmpParam = p;
            };
        template<class T> CINOSTaskExMsgParam* AddParam(T);
        template<class T> CINOSTaskExMsgParam* AddParam(const char* apName, T);
        template<class T> CINOSTaskExMsgDefaultParam* AddDefaultParam(const char* apName, T aValue);
        CINOSTaskExMsgParam* AddParam(const char* apName, char* apValue);
        CINOSTaskExMsgParam* AddParam(const char* apName, const char* apValue);      
        CINOSTaskExMsgParam* AddParam (CINOSTaskExMsgParam* apParam);
        CINOSTaskExMsgParam* AddJsonParam(const char* apJson);
 
        template<class T> T GetParam();
        template<class T> T GetFirstParam();
        char* GetParam();
        CINOSTaskExMsgParam* GetParamPtr() {
            return iGetParam();
        }
        char* GetFirstParam();
        CINOSTaskExMsgParam* GetFirstParamPtr(bool abUseInternalIterator = true);
        uint32 GetParamCnt() const
            {return m_uParamCnt;};
 
        void FstResult()
            { m_pTmpResult = 0;};
        template<class T> void AddResult(T, const char* apResultName = NULL);
        void AddResult(char* apValue, const char* apResultName = NULL);
        void AddResult(const char* apValue, const char* apResultName = NULL);
 
        template<class T> void InsertResult(T, const char* apResultName = NULL);
        void InsertResult(char* apValue, const char* apResultName = NULL);
        void InsertResult(const char* apValue, const char* apResultName = NULL);
 
        template<class T> void AppendResult(T, const char* apResultName = NULL);
        void AppendResult(char* apValue, const char* apResultName = NULL);
        void AppendResult(const char* apValue, const char* apResultName = NULL);
 
        tMcAppError AddIncoItemAsResult(CINCOItem* apItem, bool abBitAsNumber = false);
        void MoveResultsFromMcResult(CMcResult& aResult);
        void MoveResultsToParams(CINOSTaskExMsg& aMsg);
        void MoveParamsFromMsg(CINOSTaskExMsg* apMsg);
        void AddResultsFromMsgParams(CINOSTaskExMsg* apMsg);
        void AddResults(CINOSTaskExMsgParam* apMsgParam);
 
        template<class T> T GetResult();
        char* GetResult();
        uint32 GetResultCount() const;
        CINOSTaskExMsgParam* GetFirstResultPtr();
        void DestroyParams();
        void DestroyResults();
        void SetTrigger(real64 arValue);
        void SetTrigger(uint64 auBusTicks, uint8 auBusId);
        void SetTrigger(const char* apVarName, const char* apCompare,
            real64 arValue);
        void SetTrigger(const char* apVarName, const char* apCompare,
            const char* apValue);
        void SetTrigger(const char* apSynName, real64 arParamValue, 
            const char* apParamType, const char* apTaskName, const char* apCmdName,
            const char* apEventName);
        void SetTrigger(const char* apSynName, const char* apParamValue, 
            const char* apParamType, const char* apTaskName, const char* apCmdName,
            const char* apEventName);
        void SetTrigger(const char* apSynName, real64 arParamValue, 
            const char* apParamType, uint64 auBusTicks, uint8 auBusId);
        CINOSTaskExMsgTrigger* GetTrigger()
            { return m_pTrigger;};      
        void RemTrigger()
            { if (m_pTrigger) {delete m_pTrigger; m_pTrigger = 0;}};        
 
        void AndTrigger(const char* apSynName, real64 arParamValue, 
            const char* apParamType, const char* apTaskName, const char* apCmdName,
            const char* apEventName);
        void AndTrigger(const char* apSynName, real64 arParamValue, 
            const char* apParamType, uint64 auBusTicks, uint8 auBusId);
        CINOSTaskExMsgTrigger* GetAndTrigger(uint32 auIndex=0);
        void RemAndTrigger(uint32 auIndex=0, bool abDelete = true);
 
        void SetSender(CINOSTask* apSender)
            { m_pSender = apSender;};
        void SetUser(void* apUser)
            { m_pUser = apUser;};
        void SetData(CINOSMcDataInst* apData)
            { m_pData = apData;};
        void SetSync(CINOSSync* apSync)
            { m_pSync = apSync;};
        void SetId(tMsgId aId)
            { m_Id = aId;};
        tMsgId GetId() const
            { return m_Id;};
        uint32 GetMsgType() const
            { return m_uType;};
        void SetMsgCode(uintnbr auMsgCode)
            { m_uMsgCode = auMsgCode;};
        uintnbr GetMsgCode() const
            { return m_uMsgCode;};
        void SetMsgSubCode(uint32 auMsgSubCode)
            { m_uMsgSubCode = auMsgSubCode;};
        uint32 GetMsgSubCode() const
            { return m_uMsgSubCode;};
        CINOSTaskExCmdBase* GetCommand() const
            {  return m_uType == CINOSTaskExDef::eMsgCall ?
                    (CINOSTaskExCmdBase*)m_uMsgCode :
                    nullptr;
            }
        void SetRetValue(uint32 auRetValue)
            { m_uRetValue = auRetValue;};
        uint32 GetRetValue() const
            { return m_uRetValue;};
        CINOSTask* GetSender() const
            { return m_pSender;};
        uint32 GetSenderId() const
            { if (nullptr != m_pSender) return m_pSender->GetTaskId(); else return 0;};
        CINOSTaskEx* GetReceiver() const
            { return m_pReceiver;};
        uint32 GetReceiverId() const
            { if (nullptr != m_pReceiver) return ((CINOSTask*)m_pReceiver)->GetTaskId(); else return 0;};
        void* GetUser() const
            { return m_pUser;};
        CINOSMcDataInst* GetData() const
            { return m_pData;};
        CINOSSync* GetSync() const
            { return m_pSync;};
        uint32 GetFlags()
            { return m_uFlags;};
        void SetFlags(uint32 auFlags)
            { m_uFlags = auFlags;};
        void AddFlags(uint32 auFlags)
            { m_uFlags |= auFlags;};
        void SetDeferred()
            { m_uFlags |= eMsgFlgDeferred;};
        bool GetDeferred() const
            { return (m_uFlags & eMsgFlgDeferred)!=0;};
        bool GetDone() const
            { return (m_uFlags & eMsgFlgDone)!=0;};
        bool GetPending() const
            { return (m_uFlags & eMsgFlgPending)!=0;};
        void SetPending()
            { m_uFlags |= eMsgFlgPending;};
        bool GetCanceled() const
            { return (m_uFlags & eMsgFlgCanceled)!=0;};
        void SetCanceled()
            { m_uFlags |= eMsgFlgCanceled;};
        void SetPersistent()
            { m_uFlags |= eMsgFlgPersistent;};
        bool GetPersistent() const
            { return (m_uFlags & eMsgFlgPersistent)!=0;};
        void SetFlushResistent()
            { m_uFlags |= eMsgFlgFlushResistent;};
        bool GetFlushResistent() const
            { return (m_uFlags & eMsgFlgFlushResistent)!=0;};
        bool GetSingle() const
            { return (m_uFlags & eMsgFlgSingle)!=0;};
        void SetSingle()
            { m_uFlags |= eMsgFlgSingle;};
        bool GetNoTrace() const
            {
            return (m_uFlags & eMsgFlgNoTrace)!=0 ||
                (m_pData && (m_pData->GetFlag() & CINOSMcDataInst::eFlgNoTrace));
            };
        void SetNoTrace()
            { m_uFlags |= eMsgFlgNoTrace;};
        bool GetStatic() const
            { return (m_uFlags & eMsgFlgStatic)!=0;};
        void SetStatic()
            {
                m_uFlags |= eMsgFlgStatic;
                INOS_CONCURRENCY_CHECK_FREE(this); // static messages may be used by other tasks.
            };
        void ClearStatic()
            { m_uFlags &= ~eMsgFlgStatic;};
        bool GetAlwaysSyncSignal() const
            { return (m_uFlags & eMsgFlgAlwaysSyncSignal)!=0;};
        void SetAlwaysSyncSignal()
            { m_uFlags |= eMsgFlgAlwaysSyncSignal;};
        bool GetAlwaysReply() const
            { return (m_uFlags & eMsgFlgAlwaysReply)!=0;};
        void SetAlwaysReply()
            { m_uFlags |= eMsgFlgAlwaysReply;};
        void SetName(const char* apName)
            { inos_strncpy(m_cName, apName, sizeof(m_cName));};
        char* GetName(bool abResolveIfEmpty = false);
        void SetInfo(const char* apInfo)
            { inos_strncpy(m_cInfo, apInfo, sizeof(m_cInfo));};
        char* GetInfo()
            { return &m_cInfo[0];};
        void SetBusTicks(uint64 auBusTicks)
            { m_uBusTicks = auBusTicks;};
        uint64 GetBusTicks() const
            { return m_uBusTicks;};
        uint64 GetQueueTicks() const
            { return m_uQueueTicks;};
        void SetBusId(uint8 auBusId)
            { m_uBusId = auBusId;};
        uint8 GetBusId() const
            { return (uint8)m_uBusId;};
        void SetIdInfo(tMsgId auIdInfo)
            { m_uIdInfo = auIdInfo;};
        tMsgId GetIdInfo() const
            { return m_uIdInfo;};
        CINOSTaskExMsgParam* GetParam(const char* apName);
        void DontCreateMcLogTraces();
        bool AreMcLogTracesRequested() const;
#ifdef INOS_INCOV
        bool GetINCOV(CINCOVServerSession*& opSession, CINCOVOperation*& opOperation);
        void ReleaseINCOV(CINCOVServerSession& aSession);
        bool InINCOVContext() const {
            return (m_pIncovContext ? true : false);
        }
#else
        bool InINCOVContext() const {
            return false;
        }
#endif
 
        // msg flags
        enum EMsgFlag {
            eMsgFlgNone = 0x00000000,
            eMsgFlgSyncron = 0x00000001,
            eMsgFlgDeferred = 0x00000002,
            eMsgFlgPending = 0x00000004,
            eMsgFlgCanceled = 0x00000008,
            eMsgFlgPersistent = 0x00000010,
            eMsgFlgFlushResistent = 0x00000020,
            // The msg receiver can handle additional parameter, that are not 
            // specified in the prototype message object
            eMsgFlgHasEllipsis = 0x00000040, 
            // Only one instance of the according message is allowed at any time
            // (e.g. in the message queue or currently running). note that this
            // won't work if the message code (i.e. the enum value) is 0.
            eMsgFlgSingle = 0x00000080,
            // don't give an event log trace, e.g. for inco worker commands
            eMsgFlgNoTrace = 0x00000100,
            eMsgFlgStatic = 0x00000200,
            // message has oversized result
            eMsgFlgOversizedResult = 0x00000400,
            eMsgFlgAlwaysSyncSignal = 0x00000800,
            eMsgFlgAlwaysReply = 0x00001000,
            eMsgFlgDone = 0x80000000
        }; 
 
    //--- internals --------------------------------------------------------
 
    friend class CINOSTaskEx;
    // needs to have access to the first msg param (without tranparently reset 
    // any internal data, such as m_pTmpParam)
    friend class CINOSTaskExTracer;
    #if defined(INOS_COORDINATOR_SUPPORT)
    friend class CINOSMcCoord;
    #endif
    #if defined(INOS_LUAINTERPRETER)
    friend class CINOSMcLua;
    friend class CINOSMcLuaTask;
 
    #endif
    friend class CINOSMcModule;
    friend class CINOSMcMessage;
    friend class CMcResult;
    friend class CINOSTaskExMsgTest;
    friend class CINOSTaskExMsgHistory;
    
    // public members
    public:
        int operator < (CINOSTaskExMsg& aTaskExMsg)
            { return (strcmp(GetName(), aTaskExMsg.GetName())<0);}
        int operator == (CINOSTaskExMsg& aTaskExMsg)
            { return (strcmp(GetName(), aTaskExMsg.GetName())==0);}
        int operator < (const char* aName)
            { return (strcmp(GetName(), aName)<0);}
        int operator == (const char* aName)
            { return (strcmp(GetName(), aName)==0);}
 
 
        CINOSTaskExMsgParam* iAddParam(CINOSTaskExMsgParam* apParam);
 
    // private methods
    private:
        CINOSTaskExMsgParam* iGetParam();
        void iAddResult (CINOSTaskExMsgParam* apResult);
        void iInsertResult (CINOSTaskExMsgParam* apResult);
        void iAppendResult (CINOSTaskExMsgParam* apResult);
        CINOSTaskExMsgParam* iGetResult();
#ifdef INOS_INCOV
        void CopyIncovContext(SINCOVContext* apSrc);
        void CopyIncovContext(SINCOVLazyContext* apSrc);
#endif
    // private members
    private:
        #if defined(INOS_TASKEXMSG_NAME_EXTENDED_LENGTH)
        inosName128 m_cName;
        #else
        inosName64 m_cName;
        #endif
        inosName64 m_cInfo;
        uint64 m_uQueueTicks;
        uint64 m_uBusTicks;
        uint16 m_uType;
        uint16 m_uBusId;
        tMsgId m_Id;
        tMsgId m_uIdInfo;
        uintptr m_uMsgCode;
        uint32 m_uMsgSubCode;
        uint32 m_uRetValue;
        uint32 m_uFlags;
        uint32 m_uParamCnt;
        void* m_pUser;
        CINOSMcDataInst* m_pData;
        CINOSSync* m_pSync;
        CINOSTaskExMsgParam* m_pParam;
        CINOSTaskExMsgParam* m_pTmpParam;
        CINOSTaskExMsgParam* m_pResult;
        CINOSTaskExMsgParam* m_pTmpResult;
        CINOSTaskExMsgTrigger* m_pTrigger;
        uint32 m_uAndTriggerInd;
        CINOSTaskExMsgTrigger* m_pAndTrigger[DF_INOS_TASKEX_MAX_AND_TRG];
        CINOSTask* m_pSender;
        CINOSTaskEx* m_pReceiver;
        bool            m_bCreateMcLogTraces;
 
#ifdef INOS_INCOV
        SINCOVLazyContext* m_pIncovContext = nullptr;
#endif
    public:
        INOS_CONCURRENCY_CHECK_DECLARE;
    private:
    DECLARE_DYNAMIC(CINOSTaskExMsg);
};
template<> const char* CINOSTaskExMsg::GetParam<const char*>();
template<> char* CINOSTaskExMsg::GetParam<char*>();
 
//------------------------------------------------------------------------------
// class CINOSTaskExMsg
//------------------------------------------------------------------------------
//
class CINOSTaskExMsgUser : public CINOSTaskExMsg
{
    //--- user interface ---------------------------------------------------
 
    // public member functions
    public :
        CINOSTaskExMsgUser(uint32 auMsgCode, uint32 auFlags=0)
            : CINOSTaskExMsg(CINOSTaskExDef::eMsgUser, auMsgCode, DF_INOS_ASYNCHRONOUS)
        {
            // set static
            SetStatic();
            // set additional flags
            AddFlags(auFlags);
        }
 
    DECLARE_DYNAMIC(CINOSTaskExMsgUser);
};
 
//------------------------------------------------------------------------------
// class CINOSTaskEx
//------------------------------------------------------------------------------
//
class CINOSTaskEx : public CINOSTask
{
    //--- user interface ---------------------------------------------------
 
    // public member functions
    public :
        uint32 GetState();
        virtual void SetState(uint32 auState)
            { m_uState = auState;};
        bool IsCmdBusy(uintptr auCmdCode);
        bool IsCmdDeferred(uint32 auCmdCode);
        virtual bool IsCmdAllowed(CINOSTaskExMsg* apMsg)
            { return false;};
        const char* GetParam() const
            { return &m_cParam[0];};
        const char* GetType() const
            { return &m_cType[0];};
        const char* GetAliasName() const
            { return &m_cAliasName[0];};
        void SetAliasName(const char* apAlias)
            { inos_strncpy(&m_cAliasName[0], apAlias, sizeof(m_cAliasName));};
        virtual const char* GetIncoName();
        virtual const char* GetTreeName()
            { return m_pTreeName;};
        
        enum {
            eSourceIdMsg = 255,
            eSourceIdLua = 254,
            eSourceIdFastLoad = 253,
        };
        uint32 GetSourceId()
            { return m_uSourceId; };
 
        CINOSTaskEx* GetParent() const
            { return m_pParent;};
        static tMsgId GetMsgId();
        static tMsgId GetMsgId(uint32 auId, uint32 auMask);
 
        virtual CMcResult Startup(real64 arStage);
        
        bool GetCommand(const char* apName) const;
        bool GetOption(const char* apName) const;
        bool GetOption(const char* apBase, const char* apName) const;  
        bool GetOption(const char* apParams, const char* apBase, const char* apName) const;
        bool GetOptionEx(const char* apBase) const;
        bool GetOptionStr(const char* apBase, char* apResult, uint32 auSize) const;
        bool GetOptionStr(const char* apParams, const char* apBase, char* apResult, uint32 auSize) const;
        bool GetOptionNbr(const char* apBase, uintnbr& auNumber) const;
        bool GetOptionNbr(const char* apParams, const char* apBase, uintnbr& auNumber) const;
        bool GetOption(uint32 auOption) const
            {return (m_uOptions & auOption)!=0;};
        bool GetFlag(const char* apName)  const;
        bool GetFlag(uint64 auFlag) const
            { return (GetFlags() & auFlag)!=0;};
        uint64 GetFlags()  const
            { return m_uFlags; };
        bool GetRequest(uint32 auRequest)  const
            { return (m_uRequests & auRequest)!=0;};
        bool GetCritical(uint32 auCritical)  const
            { return (m_uCriticals & auCritical)!=0;};
 
        virtual CMcResult SetFlag(const char* apName, CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
        virtual CMcResult ClrFlag(const char* apName, CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
        virtual CMcResult StopMsg(tMsgId atMsgId, CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
 
        virtual CMcResult SetIdleTimeout(uint32 auIdleTimeout, CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
        uint32 GetIdleTimeout() const
            { return m_uIdleTimeout; };
 
        void SetDispatchFlag(uint32 auFlag)
            { INOS_OR(m_uDispatchFlags, auFlag); };
        void ClrDispatchFlag(uint32 auFlag)
            { INOS_AND(m_uDispatchFlags, ~auFlag); };
        uint32 GetDispatchFlag() const
            { return m_uDispatchFlags; };
 
        virtual uint32 Shutdown(CINOSSync* apSync=DF_INOS_SYNCHRONOUS) override;
        #ifdef INOS_MULTICORE
        void _SwitchCore();
        virtual CMcResult SwitchCore(uint32 auCoreId, CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
        #endif
 
        virtual tMsgId PutCmd(uint32 auCommand);
        virtual CMcResult PutMsg(CINOSTaskExMsg* apMsg, tMsgId aMsgId=0);
 
        virtual CMcResult PutMsgEx(CINOSTaskExMsg* apMsg, uint32 auFlags, tMsgId aMsgId=0);
 
        virtual void PutReply(CINOSTaskExMsg* apMsg, tMsgId aMsgId);
        virtual CINOSTaskQueue* GetMsgQueue()
            { return m_pMsgQueue;};
 
        CINOSTaskExMsg* GetActMsg() {return m_pActMsg;};
 
        virtual const CINOSTaskExMsg* GetCommandMsg(const char* apName)
            { return m_pCommands->Find(apName);};
 
        virtual CINOSTaskExMsg* CreateMsgFromCommand(const char* apName,
                CINOSSync* apSync = DF_INOS_ASYNCHRONOUS);
 
        template<typename... ParamType>
         CMcResult CallCommand(const char* apName,
                ParamType... aParams,
                CINOSSync* apSync = DF_INOS_SYNCHRONOUS)
        {
            // Actual task is different to this task?
            if(ActualTask() != this) {
                // yes -> lock the commands to protect from modification
                m_CommandsMutex.Request();
            }
 
            // Get the message
            CINOSTaskExMsg* pCmdMsg = m_pCommands->Find(apName);
            if(nullptr == pCmdMsg) {
                if(ActualTask() != this) {
                    m_CommandsMutex.Release();
                }
                // Not found, return error
                return CMcResult((tMcAppError)INOS_MCMSG_CODE_TSKEX_UNKNOWN);
            }
            // Create call message
            CINOSTaskExMsg* pCallMsg = new CINOSTaskExMsg(pCmdMsg->GetMsgType(),
                    pCmdMsg->GetMsgCode(), apSync);
 
            // Copy sub-code
            pCallMsg->SetMsgSubCode(pCmdMsg->GetMsgSubCode());
 
            // Set Name
            pCallMsg->SetName(apName);
 
            // Add the params
            CINOSTaskExMsgParam* ParamArray[sizeof...(aParams)] =
                { (pCallMsg->AddParam(aParams))... };
 
            // check params
            auto pParam = pCmdMsg->GetFirstParamPtr(false);
            for(uint32 uIx = 0; uIx < sizeof...(aParams); uIx ++) {
                // extra params provided?
                if(nullptr == pParam) {
                    // yes -> allowed?
                    if((pCmdMsg->GetFlags() & CINOSTaskExMsg::eMsgFlgHasEllipsis)
                        == 0) {
                        // Not allowed -> Return error
                        delete pCallMsg;
                        return CMcResult((tMcAppError)INOS_MCMSG_CODE_TSKEX_WRONG_PARAMS);
                    }
                    break;
                }
                // Check type
                if(pParam->GetType() != ParamArray[uIx]->GetType() ||
                        pParam->GetTypeInfo() != ParamArray[uIx]->GetTypeInfo()) {
                    // Wrong type -> return error
                    delete pCallMsg;
                    return CMcResult((tMcAppError)INOS_MCMSG_CODE_TSKEX_WRONG_PARAMS);
                }
                pParam = pParam->GetNext();
            }
            // check for further needed params
            while(nullptr != pParam) {
                // further param mandatory?
                if(pParam->GetFlag() &  CINOSTaskExMsgParam::eFlgMandatory) {
                    // yes -> return error
                    delete pCallMsg;
                    return CMcResult((tMcAppError)INOS_MCMSG_CODE_TSKEX_PARAM_MISSING);
                }
                // Copy the default param
                pCallMsg->AddParam(pParam);
                pParam = pParam->GetNext();
            }
 
            // Release commands mutex
            if(ActualTask() != this) {
                m_CommandsMutex.Release();
            }
 
            // Finally put the message to call the command
            return PutMsg(pCallMsg);
        }
 
        virtual const CINOSTaskExCmdHookBase* GetCommandHook(const char* apName)
            { return m_CommandHookRegister.Find(apName);};
 
        virtual CINCOObject* GetRegister(CINCOObject* apObject=0);
        virtual CINCOObject* SetCmdObj(CINCOObject* apCmd);
        virtual CINCOObject* GetCmdObj();
        virtual CINCOObject* GetPropObj();
        virtual CINCOObject* GetOptionsObj()
            { return m_pOptions;};
        virtual CINCOObject* GetFlagsObj()
            { return m_pFlags;};
        virtual CINCOObject* GetRequestsObj()
            { return m_pRequests;};
        virtual CINCOObject* GetCriticalsObj()
            { return m_pCriticals;};
        virtual CINCOObject* GetActObj();
        virtual CINCOObject* GetStatObj();
 
        virtual void AddProp(CINCOItem* apItem); 
        virtual void AddProp(const char* apName); 
        virtual void AddProp(); 
        virtual void AddProp(const char* apName, nvreal64& aMember, 
            real64 arDefault, real64 arMin, real64 arMax, const char* apUnit,
            uint32 auDigits, uint32 auCharactristics = defCharShowFix);
        virtual void AddProp(const char* apName, nvuint32& aMember, 
            uint32 auDefault, uint32 auMin, uint32 auMax, const char* apUnit,
            uint32 auCharacteristics=defCharShowDec); 
        virtual void AddProp(const char* apName, nvstring& aMember, 
            const char* apDefault="", const char* apComboData=NULL);
        virtual void AddProp(const char* apName, nvlstring& aMember, 
            const char* apDefault="");
        virtual void AddProp(const char* apName, nvbool& aMember,
            bool abDefault, uint32 auCharactristics=defCharShowDec);
        virtual void RemProp(const char* apName); 
    
        virtual void AddActual(CINCOItem* apItem); 
        virtual void AddActual(const char* apName); 
        virtual void AddActual(); 
        virtual void AddActual(const char* apName, nvreal64& aMember, 
            real64 arDefault, real64 arMin, real64 arMax, const char* apUnit,
            uint32 auDigits); 
        virtual void AddActual(const char* apName, nvuint32& aMember, 
            uint32 auDefault, uint32 auMin, uint32 auMax, const char* apUnit,
            uint32 auCharacteristics=defCharShowDec); 
        virtual void AddActual(const char* apName, nvstring& aMember, 
            const char* apDefault=nullptr, const char* apComboData=nullptr);
        virtual void AddActual(const char* apName, nvlstring& aMember,
            const char* apDefault=nullptr);
        virtual void AddActual(const char* apName, nvbool& aMember,
            bool abDefault, uint32 auCharactristics=defCharShowDec);
        virtual void RemActual(const char* apName);
 
        virtual CINOSTaskExMsg* CreateMsg(CINOSTaskExMsg* apMsg, 
            CINOSMcDataInst* apData, const char* apAlias);
 
        constexpr static int GetLastCmd() {
            return eCmdINOSTaskExLast;
        }
        constexpr static int GetLastUsr() {
            return eUsrINOSTaskExLast;
        }
        friend CINOSMcMessage* GetMessageHnd(bool abSearch);
        CINOSMcMessage* GetMessageHndEx();
        void SetMessageHnd(CINOSMcMessage* apMessageHnd)
            {m_pMessageHnd = apMessageHnd;};
        friend tMcAppError SendMessage(uint32 auMsgType, uint32 auMsgCode,
            uint32 auFlags, CINOSMcData* apInfo);
        friend tMcAppError SendMessage(uint32 auMsgType, uint32 auMsgCode,
            uint32 auFlags, const char* apText, CINOSMcData* apInfo);
        friend tMcAppError SendMessageEx(uint32 auMsgType, uint32 auMsgCode,
            uint32 auFlags, const char* apProperties);
        friend tMcAppError SendMessageEx(uint32 auMsgType, uint32 auMsgCode,
            uint32 auFlags, CINOSMcData* apInfo, const char* apProperties);
        friend CMcResult PostMessage(uint32 auMsgType, uint32 auMsgCode,
            uint32 auFlags, CINOSMcData* apInfo);
        friend CMcResult PostMessage(uint32 auMsgType, uint32 auMsgCode,
            uint32 auFlags, const char* apText, CINOSMcData* apInfo);
        virtual CMcResult PostMessage(uint32 auMsgType, uint32 auMsgCode,
            uint32 auFlags, CINOSMcData* apInfo=0);
        virtual CMcResult PostMessage(uint32 auMsgType, uint32 auMsgCode,
            uint32 auFlags, const char* apText, CINOSMcData* apInfo=0);
        friend CMcResult PostMessageEx(uint32 auMsgType, uint32 auMsgCode,
            uint32 auFlags, const char* apProperties);
        friend CMcResult PostMessageEx(uint32 auMsgType, uint32 auMsgCode,
            uint32 auFlags, CINOSMcData* apInfo, const char* apProperties);
        friend CMcResult ModifyMessage(tMsgId aiId, uint32 auMsgType, uint32 auMsgCode,
            uint32 auFlags, CINOSMcData* apInfo, const char* apText);
        virtual CMcResult ModifyMessage(tMsgId aiId, uint32 auMsgType, uint32 auMsgCode,
            uint32 auFlags, CINOSMcData* apInfo=0, const char* apText=nullptr);
        friend CMcResult ModifyMessageEx(tMsgId aiId, uint32 auMsgType, uint32 auMsgCode,
            uint32 auFlags, const char* apProperties);
        friend CMcResult ModifyMessageEx(tMsgId aiId, uint32 auMsgType, uint32 auMsgCode,
            uint32 auFlags, CINOSMcData* apInfo, const char* apProperties);
 
        friend CMcResult AckMessage(tMsgId aMsgId, uint32 auFlags);
        friend CMcResult AckMessageDelayed(tMsgId aMsgId, uint32 auFlags, uint32 auTime);
        friend CMcResult AckMessage(uint32 auMsgCode, uint32 auFlags, uint32 auMask);
        friend CMcResult AckMessageDelayed(uint32 auMsgCode, uint32 auFlags, uint32 auMask, uint32 auTime);
        friend CMcResult AckMessage(const CINOSTask* apOwner, uint32 auMsgType, uint32 auFlag);
        friend CMcResult RequestListen(uint32 auMsgType, uint32 auSetId, uint32 auAckId);
        friend CMcResult ReleaseListen();
 
        friend CINOSMcNvRamGrp* GetNvRamGrp(bool abSearch);
 
#if defined(INOS_TIMINIG_CHECKS_SUSPEND)
        uint32 GetSuspendTimingCheckLimit() const {
            return m_uSuspendTimingCheckLimit;
        }
        void SetSuspendTimingCheckLimit(uint32 auLimit) {
            m_uSuspendTimingCheckLimit = auLimit;
        }
#endif
 
    // public enumerations
    public :
 
        enum {
            eMsgCmd=CINOSTaskExDef::eMsgCmd,
            eMsgCall=CINOSTaskExDef::eMsgCall,
            eMsgEvent=CINOSTaskExDef::eMsgEvent,
            eMsgReply=CINOSTaskExDef::eMsgReply,
            eMsgUser=CINOSTaskExDef::eMsgUser,
            eMsgSub=CINOSTaskExDef::eMsgSub,
            eMsgInternal=CINOSTaskExDef::eMsgInternal,
            eMsgMessage=CINOSTaskExDef::eMsgMessage
        };      
 
        enum ERplId {
            eRplOk=CINOSTaskExDef::eRplOk,
            eRplSkipped=CINOSTaskExDef::eRplSkipped,
            eRplInComplete=CINOSTaskExDef::eRplInComplete,
            eRplIgnored=CINOSTaskExDef::eRplIgnored,
            eRplPaused=CINOSTaskExDef::eRplPaused,
            eRplStopped=CINOSTaskExDef::eRplStopped,
            eRplCanceled=CINOSTaskExDef::eRplCanceled,
            eRplRejected=CINOSTaskExDef::eRplRejected,
            eRplFailed=CINOSTaskExDef::eRplFailed,
            eRplError=CINOSTaskExDef::eRplError,
            eRplFatal=CINOSTaskExDef::eRplFatal,
            eRplTimeout=CINOSTaskExDef::eRplTimeout
        };      
 
        // command codes
        enum {
            eCmdINOSTaskExFirst,
            eCmdFailure,
            eCmdStartup,
            eCmdShutdown,
            eCmdShutdownRequest,
            eCmdSwitchCore,
            eCmdSetFlag,
            eCmdClrFlag,
            eCmdStopMsg,
            eCmdSetIdleTimeout,
            eCmdINOSTaskExLast
        };      
 
        // user command codes
        enum {
            eUsrINOSTaskExFirst,
            eUsrMsgDone,
            eUsrNvUpdate,
            eUsrIdleTimeout,
            eUsrINOSTaskExLast
        };      
 
        // internal command codes
        enum {
            eIntINOSTaskExFirst,
            eIntAddCommand,
            eIntRemCommand,
            eIntDeleteCommand,
            eIntGetCommands,
            eIntGetProp,
            eIntSetProp,
            eIntAddProp,
            eIntGetActual,
            eIntSetActual,
            eIntAddActual,
            eIntINOSTaskExLast
        };
 
        // message command codes
        enum {
            eMessageAdd,
            eMessageRemove,
            eMessageModify,
            eMessageAcknowledge,
        };
 
    public:
 
        // event codes
        enum {
            eEvtTicks,
            eEvtNs
        };      
 
        // states
        enum {
            eStaStartup = DEF_eStaStartup,
            eStaOff     = DEF_eStaOff,
            eStaWait    = DEF_eStaWait,
            eStaOn      = DEF_eStaOn,
            eStaReady   = DEF_eStaReady,
            eStaBusy    = DEF_eStaBusy,
            eStaError   = DEF_eStaError,
            eStaINOSTaskExLast
        };      
 
        // options
        enum {
            eOptOwner = 0x00000001,         // owner protection (obsolete)
            eOptStat = 0x00000002,          // statistics support
            eOptMsg = 0x00000004,           // message handler
            eOptNvR = 0x00000008,           // nvram handler
            eOptOvld = 0x0000010,           // overloaded command names
            eOptCaS = 0x0000020,            // check for asynch result support
            eOptResTsk2 = 0x0000040,        // reserved for future use
            eOptResTsk3 = 0x0000080         // reserved for future use
        };      
 
        // flags (R - read only, W - read/write)
        enum {
            eFlgError   = 0x00000001,       // R error pending          
            eFlgFatal   = 0x00000002,       // R fatal error pending
            eFlgEmergency=0x00000004,       // R emergency pending          
            eFlgSTO     = 0x00000008,       // R safe torque off (STO) pending
            eFlgResTsk4 = 0x00000010,       // reserved for future use
            eFlgResTsk5 = 0x00000020,       // reserved for future use
            eFlgResTsk6 = 0x00000040,       // reserved for future use
            eFlgResTsk7 = 0x00000080        // reserved for future use
        };      
 
        // requests
        enum {
            eReqResTsk0 = 0x00000001,       // reserved for future use
            eReqResTsk1 = 0x00000002,       // reserved for future use
            eReqResTsk2 = 0x00000004,       // reserved for future use
            eReqResTsk3 = 0x00000008,       // reserved for future use
            eReqResTsk4 = 0x00000010,       // reserved for future use
            eReqResTsk5 = 0x00000020,       // reserved for future use
            eReqResTsk6 = 0x00000040,       // reserved for future use
            eReqResTsk7 = 0x00000080        // reserved for future use
        };      
 
        // critical sections
        enum {
            eCrtSendMsg = 0x00000001,       // send message pending
            eCrtResTsk1 = 0x00000002,       // reserved for future use
            eCrtResTsk2 = 0x00000004,       // reserved for future use
            eCrtResTsk3 = 0x00000008,       // reserved for future use
            eCrtResTsk4 = 0x00000010,       // reserved for future use
            eCrtResTsk5 = 0x00000020,       // reserved for future use
            eCrtResTsk6 = 0x00000040,       // reserved for future use
            eCrtResTsk7 = 0x00000080        // reserved for future use
        };
        
        // dispatch flags
        enum {
            eDispFlagINCOSync = 0x00000001, 
        };      
 
        // Flags to use in PutMsgEx/AddToInputQueue
        enum eTaskExMsgFlags {
            eMsgFlagNone   = 0x00000000,    //
            eMsgFlagNoWait = 0x00000001,    
        };
 
        // Enum to be used to determine how to dispatch a message
        enum EDispatchStyle {
            eDispatchNone,
            eDispatchNormal,
            eDispatchInternal,
            eDispatchPre
        };
 
 
    //--- internals --------------------------------------------------------
 
    friend void _INI_0000_CINOSTaskEx();
    friend void _INI_0201_CINOSTaskEx();
    friend void _INI_0510_CINOSTaskEx();
    friend class CINOSTaskExState;
    friend class CINOSMcSync;
    friend class CINOSMcModule;
    friend class CINOSMcRobot;
    #if defined(INOS_COORDINATOR_SUPPORT)
    friend class CINOSMcCoord;
    #endif
    friend class CINOSMcLua; 
    friend class CINOSMcMessage;
    friend class CINOSTaskExMsg;
    friend class CINOSTaskExMsgTest;
    friend class CINOSEventLogger;
    
    // constructor / destructor
    public :
        CINOSTaskEx (const char* apName, const char* apParam=0, 
            uint32 aStackSize=defDefaultStackSize,
            uint32 aPriority=defLowestPriority, bool aFloatingPoint=true,
            uint32 aTimeSlice=defDefaultTimeSlice, bool aInterruptsDisabled=false);
        CINOSTaskEx (const char* apName, const char* apType, const char* apParam=0,
            uint32 aStackSize=defDefaultStackSize,
            uint32 aPriority=defLowestPriority, bool aFloatingPoint=true,
            uint32 aTimeSlice=defDefaultTimeSlice, bool aInterruptsDisabled=false);
        virtual ~CINOSTaskEx();
 
    // public members (used by container class)
    public:
        virtual void PostCreate(void* apParent);
        virtual bool PreDestroy(bool& bDeleteSelf);
 
        int operator < (CINOSTaskEx& aTaskEx)
            { return (strcasecmp(GetTreeName(), aTaskEx.GetTreeName())<0);}
        int operator == (CINOSTaskEx& aTaskEx)
            { return (strcasecmp(GetTreeName(), aTaskEx.GetTreeName())==0);}
        int operator < (const char* aName)
            { return (strcasecmp(GetTreeName(), aName)<0);}
        int operator == (const char* aName)
            { return (strcasecmp(GetTreeName(), aName)==0);}
 
    // private member functions
    private :
        static intnbr HandleTicksTriggers0(void*, intnbr);
        static intnbr HandleTicksTriggers1(void*, intnbr);
        static intnbr HandleTicksTriggers2(void*, intnbr);
        static intnbr HandleTicksTriggers3(void*, intnbr);
        static void HandleTicksTriggers(uint8 auBusId);
        uint32* GetEvtLevel(const uint32 auBitNumber) { 
            const uint8 uArrayIndex = (uint8)(auBitNumber / 32);
            return &m_pLevel[uArrayIndex];
        }
        inline uint32 IsLevelActive(const uint32 auBitNumber) const {
            const uint8 uArrayIndex = (uint8)(auBitNumber / 32);
            const uint32 uLevel = (uint32)(1 << (auBitNumber % 32));            
            return (m_pLevel[uArrayIndex] & uLevel);
        }
 
    // protected member functions
    protected :
        void Create();          
        virtual void Action() override;
        //  Implements pre dispatch callback support for commands of type TINOSTaskExCmd. 
        virtual bool PreDispatchMsg(CINOSTaskExMsg* apMsg);
 
        virtual void PostDispatchMsg() {};
        virtual bool DispatchCmd(CINOSTaskExMsg* apMsg);
        virtual bool DispatchTmd(CINOSTaskExMsg* apMsg);
        virtual bool DispatchEvent(CINOSTaskExMsg* apMsg);
        virtual bool DispatchReply(CINOSTaskExMsg* apMsg);
        virtual bool DispatchUser(CINOSTaskExMsg* apMsg);
        virtual bool DispatchSub(CINOSTaskExMsg* apMsg);
        virtual bool DispatchInternal(CINOSTaskExMsg* apMsg);
        virtual bool DispatchMessage(CINOSTaskExMsg* apMsg);
        virtual bool DispatchOther(CINOSTaskExMsg* apMsg);
 
        virtual void iFailure(CINOSTaskExMsg* apMsg);
 
        virtual void iStartup(CINOSTaskExMsg* apMsg);
        virtual void iStartup(real64 arStage);
        virtual bool iPostStartup();
        virtual uint32 iAddRegisteredCommands();
 
        virtual void iShutdown(CINOSTaskExMsg* apMsg);
        virtual void iShutdownRequest(CINOSTaskExMsg* apMsg);
        #ifdef INOS_MULTICORE
        virtual uint32 iSwitchCore(uint8 auCoreId);
        virtual void iSwitchCore(CINOSTaskExMsg* apMsg);
        #endif
 
        virtual void iSetFlag(CINOSTaskExMsg* apMsg);
        virtual void iiSetFlag(const char* apName);
        virtual void iClrFlag(CINOSTaskExMsg* apMsg);
        virtual void iStopMsg(CINOSTaskExMsg* apMsg);
        virtual void iSetIdleTimeout(CINOSTaskExMsg* apMsg);
        virtual void iHandleIdleTimeout();
        void iCheckIdleTimeout();
 
        virtual void iCancelDeferred();
 
        virtual void iAddCommand(CINOSTaskExMsg* apMsg);
 
        virtual void iRemCommand(CINOSTaskExMsg* apMsg);
 
        virtual void iDeleteCommand(CINOSTaskExMsg* apMsg);
 
        virtual void iGetCommands(CINOSTaskExMsg* apMsg);
 
        virtual void iGetProp(CINOSTaskExMsg* apMsg);
 
        virtual void iSetProp(CINOSTaskExMsg* apMsg);
 
        virtual void iAddProp(CINOSTaskExMsg* apMsg);
 
        virtual void iGetActual(CINOSTaskExMsg* apMsg);
 
        virtual void iSetActual(CINOSTaskExMsg* apMsg);
 
        virtual void iAddActual(CINOSTaskExMsg* apMsg);
 
        static uint32 iSetIncoItemsFromParamStruct(CINCOItem* apIncoItem,
                long alOffset, CINOSTaskExMsgParam* apParams, bool abOverwrite,
                inosName128& oErrorItemName);
 
        virtual void iMessageAdd(CINOSTaskExMsg* apMsg);
        virtual void iMessageRemove(CINOSTaskExMsg* apMsg);
        virtual void iMessageModify(CINOSTaskExMsg* apMsg);
        virtual void iMessageAcknowledge(CINOSTaskExMsg* apMsg);
 
        void Reply(CINOSTaskExMsg* apMsg, uint32 auReply, tMcAppError aAppError=0);
        template<class T> void ReplyParam(uint32 auReply, T);
        
        virtual void SetTreeName(const char* apTreeName)
            { m_pTreeName = apTreeName;};
        virtual const char* GetStateText();
 
        virtual void MsgDone(tMsgId aMsgId, tMcAppError aAppError = 0);
        // special public declaration (method is public but just callable in the
        // own task context)
        public:         
        virtual void MsgDone(CINOSTaskExMsg* apMsg, tMcAppError aAppError = 0);
        virtual void MsgDone(CINOSTaskExMsg* apMsg, ERplId aRplId, tMcAppError aAppError = 0);
        // protected again
        virtual void MsgDonePnd(CINOSTaskExMsg* apMsg, tMcAppError aAppError = 0);
        virtual void MsgDonePnd(CINOSTaskExMsg* apMsg, ERplId aRplId, tMcAppError aAppError = 0);
        virtual void MsgInComplete(CINOSTaskExMsg* apMsg, tMcAppError aAppError = 0);
        virtual void MsgIgnored(CINOSTaskExMsg* apMsg, tMcAppError aAppError = 0);
        virtual void MsgPaused(CINOSTaskExMsg* apMsg, tMcAppError aAppError = 0);
        virtual void MsgStopped(CINOSTaskExMsg* apMsg, tMcAppError aAppError = 0);
        virtual void MsgCanceled(CINOSTaskExMsg* apMsg, tMcAppError aAppError = 0);
        virtual void MsgRejected(CINOSTaskExMsg* apMsg, tMcAppError aAppError = 0);
        virtual void MsgFailed(CINOSTaskExMsg* apMsg, tMcAppError aAppError = 0);
        virtual void MsgError(CINOSTaskExMsg* apMsg, tMcAppError aAppError);
        virtual void MsgFatal(CINOSTaskExMsg* apMsg, tMcAppError aAppError);
 
        // special public declaration (method is public but just callable in the
        // own task context)
        public:         
        virtual tMsgId MsgDefer(CINOSTaskExMsg* apMsg, void* apHandler=0,
                            void* apObject=0, bool abHandlesCommands = false);
        virtual tMsgId MsgDefer(CINOSTaskExMsg* apMsg, tMsgId aMsgId,
            void* apHandler=0, void* apObject=0, bool abHandlesCommands = false);
        // protected again
        protected:
        //  tasks than the module task
        virtual void iUsrMsgDone(CINOSTaskExMsg* apMsg);
        friend void MsgEvent(CINOSTaskExMsg* apMsg, const char* apName, 
            uint64 auTicks, uint8 auBusId);
        friend void MsgEventFlg(CINOSTaskExMsg* apMsg, const char* apName, 
            uint64 auTicks, uint8 auBusId, uint32 auFlags);
        friend void MsgEvent(CINOSTaskExMsg* apMsg, const char* apName, 
            uint32 auMs);
        friend void MsgEventFlg(CINOSTaskExMsg* apMsg, const char* apName, 
            uint32 auFlags, uint32 auMs);
 
        virtual void FlushTmd(tMsgId aId=0);
 
        protected:
        virtual void _AddCommand(CINOSTaskExMsg* apMsg, CINCOObject* apMsgCmdObj,
                int16 aiOrder = 0);
        // special public declaration (method is public but just callable in the
        // own task context)
        public:         
        virtual void AddCommand(const char* apName, uint32 auCode,  CINCOProcedure* apProc);
        virtual void AddCommand(CINOSTaskExMsg* apMsg,
                        uint64 aChar=0,             // characteristics of object
                        uint16 aKeyLevel=cKeyLevelMin,  // keylevel of object
                        bool abRegisterInco=true);
        virtual void AddCommand(CINOSTaskExMsg* apMsg, CINCOObject* apMsgCmdObj);
        virtual void AddCommand(const char* apName, uint32 auCode, uint32 auType=eMsgCmd);
        virtual void RemCommand(const char* apName);
        virtual void AddParam(const char* apName, real64 arValue, real64 arMin, 
            real64 arMax, const char* apUnit, uint32 auChar, uint32 auFlags = 0);
        virtual void AddParam(const char* apName, const char* apValue, uint32 auFlags = 0);
        virtual void AddParam(const char* apName, const char* apValue, 
            const char* apComboData, uint32 auFlags = 0);
        virtual void AddParam(const char* apName, const char* apUnit, 
            uint32 auValue, uint32 auMin, uint32 auMax, uint32 auChar, uint32 auFlags = 0);
        virtual void AddParam_int32(const char* apName, const char* apUnit, 
            int32 aiValue, int32 aiMin, int32 aiMax, uint32 auChar, uint32 auFlags = 0);
        // NOTE: we cannot overload AddParam for this like uint32, as this would break
        // compatibility with existing code (compiler complains about ambiguous calls)
        virtual void AddParam_uint64(const char* apName, const char* apUnit,
            uint64 auValue, uint64 auMin, uint64 auMax, uint32 auChar, uint32 auFlags = 0);
        virtual void AddParam_int64(const char* apName, const char* apUnit,
            int64 aiValue, int64 aiMin, int64 aiMax, uint32 auChar, uint32 auFlags = 0);
        virtual void AddParam(const char* apName, const char* apComboData,
            uint32 auValue, uint32 auMin, uint32 auMax, const char* apUnit,
            uint32 auChar, uint32 auFlags = 0);   
        virtual void AddParam(const char* apName, bool abValue, uint32 auChar,
            uint32 auFlags = 0);
        template <typename T>
        void AddParam(CINCOItem* apItem, T aValue, uint32 auFlags = 0) {
            // ensure this method is only called in our own context
            ASSERT_ALWAYS(ActualTask()==this);
            // add param to actual message
            CINOSTaskExMsgParam* param=m_pTmpMsg->AddParam(apItem->GetName(), aValue);
            param->m_uFlags = auFlags;
            // add inco registration
            if (m_pActMsgObj) {
                m_pActMsgObj->Add(apItem, (int16)(m_uActParamCount++));
            } // end if
        }
        void ProcedureArgCheck(CINCOObject& aObject,
                const char* apParamName, const uint32 auExpectedIncoType);
        virtual void AddEllipsis();
        virtual void AddChildCommand(const char* apModuleName, 
                                     const char* apFunctionName, 
                                     CINOSTaskExMsg* apCmdMsg,
                                     bool abRegisterInco = true) {};
        virtual void RemChildCommand(const char* apModuleName,
                                             const char* apFunctionName) {};
        virtual void AddChildModule(const char* apModuleName) {};
        virtual void RemChildModule(const char* apModuleName) {};
 
        //  or may be added later
        void RegisterCommand(CINOSTaskExCmdBase* apCommand);
 
        void RegisterHook(CINOSTaskExCmdHookBase* apHook);
 
        // protected again
        protected:
        virtual void AdjTrigger(CINOSTaskExMsg* apMsg);
        
        CINOSTaskExDeferredMsg* GetDeferredMsg(tMsgId auReplyId);
        void RemDeferredMsg(CINOSTaskExDeferredMsg* apDef);
 
        CINOSTaskExMsg* GetDeferredMsgCmd(uint32 auCmdCode);
 
        char* GetMsgName(CINOSTaskExMsg* apMsg);
        
        void SetParent(CINOSTaskEx* apParent)
            { m_pParent = apParent;};
        
        void MptHook();
        void NvUpdate();
        virtual void iNvUpdate(CINOSTaskExMsg* apMsg);
 
        virtual void SetFlag(uint64 auFlag, bool abUpdateState = false)
            {
                m_uFlags |= auFlag;
            };
        virtual void ClrFlag(uint64 auFlag, bool abUpdateState = false)
            {
                m_uFlags &= ~auFlag;
            };
        virtual void SetRequest(uint32 auRequest)
            { INOS_OR(m_uRequests, auRequest); };
        virtual void ClrRequest(uint32 auRequest)
            { INOS_AND(m_uRequests, ~auRequest); };
        void SetCritical(uint32 auCritical)
            { INOS_OR(m_uCriticals, auCritical); };
        void ClrCritical(uint32 auCritical)
            { INOS_AND(m_uCriticals, ~auCritical); };
 
        virtual CINOSSync* GetSync() override
            { return &m_sSyncCall; };
        virtual void SetCallResult(CMcResult aResult) override
            { m_SyncCallResult = aResult;};
        virtual CMcResult GetCallResult() override
            { return m_SyncCallResult;};
 
        void RequestCritical()
            { m_sCritical.Request();};
        void ReleaseCritical()
            { m_sCritical.Release();};
 
        bool AddToInputQueue(CINOSTaskExMsg* apMsg, uint32 auFlags=0);
 
        virtual void MsgCompleted(CINOSTaskExMsg*& apMsg);
 
        uint8 GetRequestedPriority()
            { return m_uReqPriority; };
        void SetRequestedPriority(uint8 auPrio)
            { m_uReqPriority = auPrio; };
 
 
        void HandleTriggerMsg(CINOSTaskExMsg* apMsg, EDispatchStyle aeDispStyle);
 
        static void INCOItemToMessageResult(CINCOItem* apItem,
                const char* apParentPath, CINOSTaskExMsg* apMsg);
 
        static void INCOItemsToMessageResults(CINCOItem* apItem,
                const char* apParentPath, CINOSTaskExMsg* apMsg);
 
        CINOSTaskExMsg* GetTmpMsg() { return m_pTmpMsg; }
 
#if defined(INOS_TIMINIG_CHECKS_SUSPEND)
        virtual void OnResume(uint32 auLastState, uint32 auElapsedUs, void* apSync) override;
#endif
 
    // public static functions
    public :
        static CINOSHook* AddMsgDoneHook(void* apHandler, void* apObject = NULL);
 
        static void RemoveMsgDoneHook(CINOSHook* apHook);
 
        static uint32 EncodeReplyCode(uint32 auReply, tMcAppError aAppError);
 
    // protected static functions
    protected :
 
        static void CallMsgDoneHooks(CINOSTaskExMsg* apMsg, ERplId aRplId, tMcAppError aAppError);
 
    // private members
    private :
        inosName32 m_cType;
        inosName32 m_cAliasName;
        char m_cParam[1024];
        uint32 m_uSavState;
        CINOSTaskEx* m_pParent{};
        CINOSMcMessage* m_pMessageHnd{};
        CINOSMcNvRamGrp* m_pNvRamGrp;
        uintptr m_uDispatchCmdId;
        const char* m_pTreeName;
    protected :
        CINCOObject* m_pRegister;
        uint32 m_uOptions;
        std::atomic<uint64> m_uFlags;
        uint32 m_uRequests;
        uint32 m_uCriticals;
        uint32 m_uState;
    // private members
    private :
        uint32 m_uIdleTimeout;
        uint32 m_uIdleTimeoutAct;
        CINOSxmsHandler* m_pIdleTimeoutHook = nullptr;
#if defined(INOS_TIMINIG_CHECKS_SUSPEND)
    protected :
        uint32 m_uSuspendTimingCheckLimit = DF_INOS_TIMINIG_CHECKS_SUSPEND_MAX_TIME_US;
#endif
    // private members
    private :
        #if defined(INOS_KERNEL_MSGID_64)
        static std::atomic<tMsgId> m_MsgId;
        #else
        static tMsgId m_MsgId;
        #endif
        CINOSTaskQueue* m_pMsgQueue;
        CINOSTaskExMsg* m_pTmpMsg;
        CINOSTaskExMsg* m_pActMsg;
        CINOSTaskExMsg* m_pSavMsg;
        CINOSTaskExMsgUser* m_pMsgUsrIdleTimeout;
        CINOSTaskExMsgUser* m_pMsgUsrNvUpdate;
        CINCOObject* m_pActMsgObj;
        uint32 m_uActParamCount;
        // if the commands binary tree is modified (add or remove) or if
        // the access to the command is from a different task.
        CINOSMutex m_CommandsMutex;
        TINOSNameBalancedBinaryTree<CINOSTaskExMsg>* m_pCommands;
        TINOSNameBalancedBinaryTree<CINOSTaskExCmdBase> m_CommandRegister;
        TINOSNameBalancedBinaryTree<CINOSTaskExCmdHookBase> m_CommandHookRegister;
        CINOSTaskExDeferredMsg* m_pDeferredMsg;
        uint32 m_uCmdCount;
        int16 m_iCurCmdOrder = 1;
        int16 m_iCurCmdRegOrder = 1;
 
        CINOSTaskExCmdDesc* m_pCmdDesc[DF_INOS_TASKEX_MAX_CMD];
        uintid m_uMptHookId;
        uint32 m_uMptState;
        uint64 m_uMptTimeBase;
        uint64 m_uStaTotal;
        uint64 m_uStaTime[eStaINOSTaskExLast];
        nvuint64* m_pNvStaTime[eStaINOSTaskExLast];
        uint8 m_uNvStaIndex;
        CINOSxmsHandler* m_pNvUpdateHook = nullptr;
        uint8 m_uReqPriority;
 
        CINCOObject* m_pCmd;
        CINCOObject* m_pProp;
        CINCOObject* m_pOptions;
        CINCOObject* m_pFlags;
        CINCOObject* m_pRequests;
        CINCOObject* m_pCriticals;
        CINCOObject* m_pAct;
        CINCOObject* m_pStat;
        CINCOObject* m_pStatState;
        CINCOObject* m_pStatCmd;
 
        CINOSSync* m_pStartupSync;
        CINOSMutex m_sCritical;
        CINOSSync m_sSyncCall;
        CMcResult m_SyncCallResult;
 
        uint32 m_uDispatchFlags;
 
        uint32 m_uPutMsgFlags;
 
        // nvprop helpers
 
    // we use protected members here to give descendents a chance to work
    // with their own nv variable flavours
    protected:
        CINCOObject* m_pNvInitObj;
        uint32 m_uPropOrder;
        uint32 m_uActOrder;
 
    private:
        uint32 m_pLevel[DF_INOS_EVENT_LOGGER_LEVEL_ARRAY_SIZE];
        
        CINOSTaskExMsg* m_pDeferedStartupMsg = nullptr;
 
        struct SDynamicItem {
        public:
            SDynamicItem(CINOSMcVal* apValue, const char* apName, const char* apUnit,
                    const char* apComboData) :
                m_pMcValue(apValue) {
 
                // Copy the name
                const size_t cBufSize = strlen(apName) + 1;
                m_pName = new char[cBufSize];
                strncpy(m_pName, apName, cBufSize);
 
                // Copy the unit, if any
                if (apUnit != nullptr && apUnit[0] != '\0') {
                    const size_t cBufSize = strlen(apUnit) + 1;
                    m_pUnit = new char[cBufSize];
                    strncpy(m_pUnit, apUnit, cBufSize);
                }
                else {
                    m_pUnit = nullptr;
                }
 
                // Do we have combo data?
                if (apComboData != nullptr) {
                    // yes -> Copy the combo data in new buffer
                    const size_t cBufSize = strlen(apComboData) + 1;
                    m_pComboData = new char[cBufSize];
                    strncpy(m_pComboData, apComboData, cBufSize);
                }
                else {
                    // no -> set pointer to null
                    m_pComboData = nullptr;
                }
            };
 
            SDynamicItem(SDynamicItem&& aItem) :
                m_pMcValue(aItem.m_pMcValue),
                m_pName(aItem.m_pName),
                m_pUnit(aItem.m_pUnit),
                m_pComboData(aItem.m_pComboData)
            {
                // As ownership is moved, old pointers need to be reset to avoid
                // double deletes
                aItem.m_pMcValue = nullptr;
                aItem.m_pName = nullptr;
                aItem.m_pUnit = nullptr;
                aItem.m_pComboData = nullptr;
            };
 
            ~SDynamicItem() {
                // Delete members if needed
                if(m_pMcValue != nullptr) {
                    delete m_pMcValue;
                }
                if(m_pName != nullptr) {
                    delete [] m_pName;
                }
                if(m_pUnit != nullptr) {
                    delete [] m_pUnit;
                }
                if(m_pComboData != nullptr) {
                    delete [] m_pComboData;
                }
            }
 
            CINOSMcVal* m_pMcValue;
            char* m_pName;
            char* m_pUnit;
            char* m_pComboData;
        };
 
        std::unordered_map <std::string, SDynamicItem> m_DynamicProps;
        std::unordered_map <std::string, SDynamicItem> m_DynamicActuals;
 
        uint32 m_uSourceId;
        uint32 m_uSourceIdChild;
        static uint32 g_uSourceId;
 
    // private static members
    private :
        static uint32 m_uTicksMsgValid[DF_INOS_BUS_MAX_NUMBER];
        #if defined(INOS_MULTICORE)
        static CINOSTaskExMsgNode* m_pTicksMsg[DF_INOS_MAX_CORES][DF_INOS_BUS_MAX_NUMBER];
        #else
        static CINOSTaskExMsgNode* m_pTicksMsg[DF_INOS_BUS_MAX_NUMBER];
        #endif
        static CINOSTaskExMsgNode* m_pVarMsg;
        static CINOSHooks s_MsgDoneHooks;
        static CINOSMutex s_MsgDoneHooksLock;
 
    DECLARE_DYNAMIC(CINOSTaskEx);
};
 
class CINOSTaskExTracer {
    private:
        CINOSTaskExTracer();
 
    public:
        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);
        static void McLog(CINOSTaskExMsg& aMsg);
 
};
 
/* gcc 10.x does not allow friends with default parameters */
CINOSMcMessage* GetMessageHnd(bool abSearch=true);
tMcAppError SendMessage(uint32 auMsgType, uint32 auMsgCode, uint32 auFlags, CINOSMcData* apInfo=0);
tMcAppError SendMessage(uint32 auMsgType, uint32 auMsgCode, uint32 auFlags, const char* apText, CINOSMcData* apInfo=0);
CMcResult PostMessage(uint32 auMsgType, uint32 auMsgCode, uint32 auFlags, CINOSMcData* apInfo=0);
CMcResult PostMessage(uint32 auMsgType, uint32 auMsgCode, uint32 auFlags, const char* apText, CINOSMcData* apInfo=0);
CMcResult ModifyMessage(tMsgId aiId, uint32 auMsgType, uint32 auMsgCode, uint32 auFlags, CINOSMcData* apInfo=0, const char* apText=nullptr);
CMcResult AckMessage(const CINOSTask* apOwner, uint32 auMsgType=0xffffffff, uint32 auFlag=0);
CINOSMcNvRamGrp* GetNvRamGrp(bool abSearch=true);
void MsgEvent(CINOSTaskExMsg* apMsg, const char* apName, uint32 auMs=0);
void MsgEventFlg(CINOSTaskExMsg* apMsg, const char* apName, uint32 auFlags, uint32 auMs=0);
 
// gcc 4.x.x needs additinal 'extern' declaration for friends
extern CINOSMcNvRamGrp* GetNvRamGrp(bool abSearch);
extern CINOSMcMessage* GetMessageHnd(bool abSearch);
extern void MsgEvent(CINOSTaskExMsg* apMsg, const char* apName, uint64 auTicks, uint8 auBusId);
extern void MsgEvent(CINOSTaskExMsg* apMsg, const char* apName, uint32 auMs);
extern void MsgEventFlg(CINOSTaskExMsg* apMsg, const char* apName, uint64 auTicks, uint8 auBusId, uint32 auFlags);
extern void MsgEventFlg(CINOSTaskExMsg* apMsg, const char* apName, uint32 auFlags, uint32 auMs);
extern CMcResult PostMessage(uint32 auMsgType, uint32 auMsgCode, uint32 auFlags, CINOSMcData* apInfo);
extern CMcResult PostMessage(uint32 auMsgType, uint32 auMsgCode, uint32 auFlags, const char* apFormat, CINOSMcData* apInfo);
extern CMcResult PostMessageEx(uint32 auMsgType, uint32 auMsgCode, uint32 auFlags, const char* apProperties);
extern CMcResult PostMessageEx(uint32 auMsgType, uint32 auMsgCode, uint32 auFlags, CINOSMcData* apInfo, const char* apProperties);
extern CMcResult ModifyMessage(tMsgId aiId, uint32 auMsgType, uint32 auMsgCode, uint32 auFlags, CINOSMcData* apInfo);
extern CMcResult ModifyMessageEx(tMsgId aiId, uint32 auMsgType, uint32 auMsgCode, uint32 auFlags, const char* apProperties);
extern CMcResult ModifyMessageEx(tMsgId aiId, uint32 auMsgType, uint32 auMsgCode, uint32 auFlags, CINOSMcData* apInfo, const char* apProperties);
extern tMcAppError SendMessage(uint32 auMsgType, uint32 auMsgCode, uint32 auFlags, CINOSMcData* apInfo);
extern tMcAppError SendMessage(uint32 auMsgType, uint32 auMsgCode, uint32 auFlags, const char* apFormat, CINOSMcData* apInfo);
extern tMcAppError SendMessageEx(uint32 auMsgType, uint32 auMsgCode, uint32 auFlags, const char* apProperties);
extern tMcAppError SendMessageEx(uint32 auMsgType, uint32 auMsgCode, uint32 auFlags, CINOSMcData* apInfo, const char* apProperties);
extern CMcResult AckMessage(tMsgId auMsgId, uint32 auFlags);
extern CMcResult AckMessageDelayed(tMsgId aMsgId, uint32 auFlags, uint32 auTime);
extern CMcResult AckMessage(uint32 auMsgCode, uint32 auFlags, uint32 auMask);
extern CMcResult AckMessageDelayed(uint32 auMsgCode, uint32 auFlags, uint32 auMask, uint32 auTime);
 
//------------------------------------------------------------------------------
// template function implementations
//------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------
//
template<class T> CINOSTaskExMsgParam* CINOSTaskExMsg::AddParam(T aValue)
{
    // create param
    CINOSTaskExMsgParam* p = new CINOSTaskExMsgParam(aValue, nullptr, InINCOVContext());
    return iAddParam(p);
 
    // end CINOSTaskExMsg::AddParam
}
 
//------------------------------------------------------------------------------
//
template<class T> CINOSTaskExMsgParam* CINOSTaskExMsg::AddParam(const char* apName, T aValue)
{
    // create param
    CINOSTaskExMsgParam* p = new CINOSTaskExMsgParam(aValue, apName, InINCOVContext());
    // add it at the end of the list
    return iAddParam(p);
 
    // end CINOSTaskExMsg::AddParam
}
 
//------------------------------------------------------------------------------
//
template<class T> CINOSTaskExMsgDefaultParam* CINOSTaskExMsg::AddDefaultParam(const char* apName, T aValue)
{
    // create param
    CINOSTaskExMsgDefaultParam* p = new CINOSTaskExMsgDefaultParam(aValue);
    p->SetName(apName);
    // add it at the end of the list
    iAddParam(p);
    return p;
    // end CINOSTaskExMsg::AddParam
}
//------------------------------------------------------------------------------
//
template<class T> T CINOSTaskExMsg::GetParam ()
{
    // get pointer to param
    CINOSTaskExMsgParam* p = iGetParam();
    // did we get one ?
    if (p) {
        // yes -> return result
        // (work around for gcc bug 1058: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=1058) 
        return p->CINOSTaskExMsgParam::template GetTypedValue<T>();
    } // end if
    else {
        // no -> return "zero"
        return T();
    }
    // end CINOSTaskExMsg::GetParam
}
 
//------------------------------------------------------------------------------
//
template<class T> T CINOSTaskExMsg::GetFirstParam ()
{
    // reset internal pointer
    m_pTmpParam = 0;
    // call main
    // (work around for gcc bug 1058: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=1058) 
    T val = CINOSTaskExMsg::template GetParam<T>();
    return val;
 
    // end CINOSTaskExMsg::GetFirstParam
}
 
//------------------------------------------------------------------------------
//
template<class T> void CINOSTaskExMsg::AddResult(T aValue, const char* apResultName /*= NULL*/)
{
    // create param
    CINOSTaskExMsgParam* p = new CINOSTaskExMsgParam(aValue, apResultName, InINCOVContext());
    // add it at the end of the list
    iAddResult(p);  
 
} // end CINOSTaskExMsg::AddResult
 
//------------------------------------------------------------------------------
//
template<class T> void CINOSTaskExMsg::InsertResult(T aValue, const char* apResultName /*= NULL*/)
{
    // create param
    CINOSTaskExMsgParam* p = new CINOSTaskExMsgParam(aValue, apResultName, InINCOVContext());
    // insert it at the beginning of the list
    iInsertResult(p);
 
} // end CINOSTaskExMsg::InsertResult
 
//------------------------------------------------------------------------------
//
template<class T> void CINOSTaskExMsg::AppendResult(T aValue, const char* apResultName /*= NULL*/)
{
    // create param
    CINOSTaskExMsgParam* p = new CINOSTaskExMsgParam(aValue, apResultName, InINCOVContext());
    // add it at the end of the list
    iAppendResult(p);
 
} // end CINOSTaskExMsg::AppendResult
 
//------------------------------------------------------------------------------
//
template<class T> T CINOSTaskExMsg::GetResult ()
{
    // get pointer to param
    CINOSTaskExMsgParam* p = iGetResult();
    // did we get one ?
    if (p) {
        // yes -> return result
        // (work around for gcc bug 1058: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=1058) 
        return p->CINOSTaskExMsgParam::template GetTypedValue<T>();
    } // end if
    else {
        // no -> return "zero"
        return (T) 0;
    }
    // end CINOSTaskExMsg::GetResult
}
 
//------------------------------------------------------------------------------
//
template<class T> void CINOSTaskEx::ReplyParam(uint32 auReply, T aValue)
{
    // ensure that we have a command
    if (m_pActMsg){
        // get pointer to sender of actual command
        CINOSTask* snd = m_pActMsg->m_pSender;
        // reply only allowed if task exists and was inherited from CINOSTaskEx
        if (snd && (snd->mClassSize == sizeof(CINOSTaskEx))){
            // create reply 
            CINOSTaskExMsg* pRpl = new CINOSTaskExMsg(eMsgReply, auReply);
            // copy also user data to reply
            pRpl->SetUser(m_pActMsg->GetUser());
            // add requested param
            pRpl->AddParam(aValue);
            // and put it into the sender's queue
            ((CINOSTaskEx*)snd)->PutReply(pRpl, m_pActMsg->m_Id);
        } // end if
    } // end if
 
    // end CINOSTaskEx::Reply
}
 
inline CINOSTaskEx* ActualTaskEx()
{
    CINOSTask* pTask = ActualTask();
    if (pTask->GetClassSize() == sizeof(CINOSTaskEx)) {
        return static_cast<CINOSTaskEx*>(pTask);
    }
    else {
        return nullptr;
    }
}
 
//------------------------------------------------------------------------------
// class definition
//------------------------------------------------------------------------------
//
class CINOSMcSync : public CINOSSync
{
    //--- user interface ---------------------------------------------------
 
    // public members
    public:
        CINOSMcSync(CINOSTaskExMsg* apMsg, void* apHandler=NULL, void* apObject=NULL);
 
    //--- internals --------------------------------------------------------
 
    // protected members
    protected :
        virtual void Signal();
 
    // private members
    private :
        CINOSTaskEx* m_pTask;
        tMsgId m_MsgId;
 
    DECLARE_DYNAMIC(CINOSMcSync);
};
 
//------------------------------------------------------------------------------
// class definition
//------------------------------------------------------------------------------
// Helper sync object that implements a event queue. This can be used
// if a task needs to wait for an event of a command synchronously.
class CINOSMcSyncEvent : public CINOSSync
{
    //--- user interface ---------------------------------------------------
 
    // public members
    public:
        CINOSMcSyncEvent();
 
        virtual ~CINOSMcSyncEvent();
 
        ICACHE virtual bool MsgEvent(CINOSTaskExMsg* apMsg) override;
 
        virtual CINOSTaskQueue* GetEventQueue() { return m_pEventQueue; };
 
        // deletes all events that occur before that event
        // is never nullptr as the function waits forever for the event.
        virtual CINOSTaskExMsg* WaitForEvent(const char* apEventName);
 
    // private members
    private :
        CINOSTaskQueue* m_pEventQueue;
 
    DECLARE_DYNAMIC(CINOSMcSyncEvent);
};
 
 
//------------------------------------------------------------------------------
// class definition
//------------------------------------------------------------------------------
//
class CINOSMcSyncMsg : public CINOSSync
{
    private:
        CINOSMcSyncMsg(CINOSTaskEx& aTask, CINOSTaskExMsg* apMsg);
    public:
        static CINOSMcSyncMsg* Create(CINOSTaskEx& aTask,
                CINOSTaskExMsg* apMsg);
        /* Overwritten to perform specific stuff. */
        virtual void Signal();
 
    private:
        CINOSTaskEx& m_Task;
        CINOSTaskExMsg* m_pMsg;
 
        DECLARE_DYNAMIC(CINOSMcSyncMsg)
};
 
//------------------------------------------------------------------------------
// CINCOTaskExProcedure
//------------------------------------------------------------------------------
 
class CINCOTaskExProcedure : public CINCOProcedure 
{   
    // constructor
    public:
        CINCOTaskExProcedure(
            char*   apName,             // object name
            uint32 auMsgType,
            uintptr auMsgCode,
            uint32 auMsgSubCode,
            uint32 auMsgFlags,
            CINOSTaskEx* apTask,                       
            uint32 auNumberOfParameters, // number of parameters
            uint32 auTypeOfParameters,  // first 16 bit long paras / string;
            //  after float paras
            uint32 auIntTypeOfParameters, // first 16 bit signed, second 16 bit bool
            uint64 auChar,              // characteristics of object
            uint16 auKeyLevel           // keylevel of object
        );     
        
        // call procedure
        virtual void  Call(void* aParameters=0, void* aResult=0, long aOffset=0,bool aCallProcEx=true) override;
#ifdef INOS_FAST_CALLPROCEDURE
        // call procedure consolidated
        virtual void Call(CINCOParamReader& aParameters, CINCOResult& aResult, long aOffset=0) override;
#endif
 
    protected:     
        CINOSTaskEx* m_pTask;
        uint32 m_uMsgType;
        uintptr m_uMsgCode;
        uint32 m_uMsgSubCode;
        uint32 m_uMsgFlags;
        uint32 m_uSubTypeOfParameters;
 
    
    DECLARE_DYNAMIC(CINCOTaskExProcedure);
};
 
//------------------------------------------------------------------------------
// Include CINCOTaskEx templates. Must be at the bottom of the file to
// avoid cyclic includes.
//------------------------------------------------------------------------------
 
#include <cinostaskextmpl.h>
 
 
//------------------------------------------------------------------------------
 
#endif  // INC_CINOSTASKEX_H
 
 
//------------------------------------------------------------------------------
// end of file