cinostaskextmpl.h

Go to the documentation of this file.

//******************************************************************************
//******************************************************************************
 
#ifndef INC_CINOSTASKEXTMPL_H
#define INC_CINOSTASKEXTMPL_H
 
//
//------------------------------------------------------------------------------
// includes
//------------------------------------------------------------------------------
//
// system
//
#include <inos.h>
#include <cinoseventlogger.h>
#include <cinostaskexdef.h>
 
 
template<typename T>
class TINOSTaskExValDef
{
public:
    TINOSTaskExValDef (const char* Name,
            T Value,
            T Min,
            T Max,
            const char* Unit = "",
            uint32 Characteristics = 0,
            uint32 Flags = 0)
    :
        m_pName(Name),
        m_Value(Value),
        m_Min(Min),
        m_Max(Max),
        m_pUnit(Unit),
        m_uCharacteristics(Characteristics),
        m_uFlags(Flags),
        m_pComboData(nullptr) {};
 
    TINOSTaskExValDef (const char* Name,
            const char* ComboData,
            T Value,
            T Min,
            T Max,
            const char* Unit = "",
            uint32 Characteristics = 0,
            uint32 Flags = 0)
    :
        m_pName(Name),
        m_Value(Value),
        m_Min(Min),
        m_Max(Max),
        m_pUnit(Unit),
        m_uCharacteristics(Characteristics),
        m_uFlags(Flags),
        m_pComboData(ComboData) {};
 
    CINOSTaskExMsgDefaultParam*  AddToMsg(CINOSTaskExMsg& aMsg) {
        CINOSTaskExMsgDefaultParam* pParam = aMsg.AddDefaultParam(m_pName, m_Value);
        pParam->SetMaxValue((real64)m_Max);
        pParam->SetMinValue((real64)m_Min);
        pParam->SetUnit(m_pUnit);
        pParam->SetCharacteristics(m_uCharacteristics);
        pParam->SetFlag(m_uFlags);
        pParam->SetComboData(m_pComboData);
        return pParam;
    };
 
private:
    const char* m_pName;
    T m_Value;
    T m_Min;
    T m_Max;
    const char* m_pUnit;
    uint32 m_uCharacteristics;
    uint32 m_uFlags;
    const char* m_pComboData;
 
};
 
template<typename T>
class TINOSTaskExValDef<T*>
{
public:
    TINOSTaskExValDef (const char* Name,
            T* Value,
            uint32 Flags = 0)
    :
        m_pName(Name),
        m_Value(Value),
        m_uFlags(Flags){};
 
    CINOSTaskExMsgDefaultParam*  AddToMsg(CINOSTaskExMsg& aMsg) {
        CINOSTaskExMsgDefaultParam* pParam = aMsg.AddDefaultParam(m_pName, m_Value);
        pParam->SetFlag(m_uFlags);
        return pParam;
    };
 
private:
    const char* m_pName;
    T* m_Value;
    uint32 m_uFlags;
};
 
 
template<>
class TINOSTaskExValDef<const char*>
{
public:
    TINOSTaskExValDef(const char* Name,
                const char* Default,
                const char* ComboData = nullptr,
                uint32 Flags = 0) :
        m_pName(Name),
        m_Value(Default),
        m_pComboData(ComboData),
        m_uFlags(Flags) {};
 
    CINOSTaskExMsgDefaultParam*  AddToMsg(CINOSTaskExMsg& aMsg) {
            CINOSTaskExMsgDefaultParam* pParam = aMsg.AddDefaultParam(m_pName, m_Value);
            pParam->SetComboData(m_pComboData);
            pParam->SetFlag(m_uFlags);
            return pParam;
    }
 
private:
    const char*  m_pName;
    const char*  m_Value;
    const char* m_pComboData;
    uint32 m_uFlags;
};
 
template<>
class TINOSTaskExValDef<bool>
{
public:
    TINOSTaskExValDef(const char* Name,
            bool Value,
            uint32 Characteristics = 0,
            uint32 Flags = 0) :
        m_pName(Name),
        m_Value(Value),
        m_uCharacteristics(Characteristics),
        m_uFlags(Flags) {};
 
    CINOSTaskExMsgDefaultParam*  AddToMsg(CINOSTaskExMsg& aMsg) {
            CINOSTaskExMsgDefaultParam* pParam = aMsg.AddDefaultParam(m_pName, m_Value);
            pParam->SetCharacteristics(m_uCharacteristics);
            pParam->SetFlag(m_uFlags);
            return pParam;
    }
 
private:
    const char*  m_pName;
    bool  m_Value;
    uint32 m_uCharacteristics;
    uint32 m_uFlags;
};
 
 
//------------------------------------------------------------------------------
class CINOSTaskExCmdHookBase {
public:
    typedef bool (CINOSTaskEx::*tPreDispatchFunctionBase)(CINOSTaskExMsg* apMsg);
 
    typedef void (CINOSTaskEx::*tOnMsgDoneFunctionBase)(CINOSTaskExMsg* apMsg, CINOSTaskExDef::ERplId aRplId, tMcAppError aAppError);
 
    const char* GetName() const {
        return m_cName;
    }
 
    int operator < (CINOSTaskExCmdHookBase& aHook)
        { return (strcmp(m_cName,aHook.GetName())<0);}
    int operator == (CINOSTaskExCmdHookBase& aHook)
        { return (strcmp(m_cName, aHook.GetName())==0);}
    int operator < (const char* aName)
        { return (strcmp(m_cName,   aName)<0);}
    int operator == (const char* aName)
        { return (strcmp(m_cName, aName)==0);}
 
    virtual tPreDispatchFunctionBase GetPreDispatchFunction() const = 0;
 
    virtual tOnMsgDoneFunctionBase GetOnMsgDoneFunction() const = 0;
 
    virtual ~CINOSTaskExCmdHookBase() {};
 
protected:
    //  see TINOSTaskExCmdHook for further information
    CINOSTaskExCmdHookBase(const char* apName, CINOSTaskEx& aTask) {
        strncpy(m_cName, apName, sizeof(m_cName));
        aTask.RegisterHook(this);
    }
private:
    inosName64 m_cName;
};
 
 
 
//------------------------------------------------------------------------------
template <typename ObjectType>
class TINOSTaskExCmdHook : public CINOSTaskExCmdHookBase {
public:
    typedef bool (ObjectType::*tPreDispatchFunction)(CINOSTaskExMsg* apMsg);
 
    typedef void (ObjectType::*tOnMsgDoneFunction)(CINOSTaskExMsg* apMsg, CINOSTaskExDef::ERplId aRplId, tMcAppError aAppError);
 
    TINOSTaskExCmdHook(
            const char* apName,
            ObjectType& aTask,
            tPreDispatchFunction apPreDispatchFunction = nullptr,
            tOnMsgDoneFunction apMsgDoneFunction = nullptr
        ) :
        CINOSTaskExCmdHookBase(apName,aTask),
        m_PreDispatchFunction(apPreDispatchFunction),
        m_MsgDoneFunction(apMsgDoneFunction)
    {};
 
 
    virtual tPreDispatchFunctionBase GetPreDispatchFunction() const {
        if(dynamic_cast<ObjectType*>(::ActualTask()) != nullptr) {
            return tPreDispatchFunctionBase(m_PreDispatchFunction);
        }
        return nullptr;
    };
 
    virtual tOnMsgDoneFunctionBase GetOnMsgDoneFunction() const {
        if(dynamic_cast<ObjectType*>(::ActualTask()) != nullptr) {
            return tOnMsgDoneFunctionBase(m_MsgDoneFunction);
        }
        return nullptr;
    };
 
    virtual ~TINOSTaskExCmdHook() {};
 
private:
    tPreDispatchFunction m_PreDispatchFunction;
 
    tOnMsgDoneFunction m_MsgDoneFunction;
};
 
 
 
 
//------------------------------------------------------------------------------
// class CINOSTaskExCmdBase
//------------------------------------------------------------------------------
 
class CINOSTaskExCmdBase
{
    // friends
    friend class CINOSTaskEx;
 
public:
 
    typedef bool (CINOSTaskEx::*tPreDispatchFunction)(CINOSTaskExMsg* apMsg);
 
    virtual void SetPreDispatcher(const CINOSTaskExCmdHookBase* apPreDispatchHook) {
        if(ActualTask() == m_pTask) {
            m_pPreDispatchFunction = apPreDispatchHook->GetPreDispatchFunction();
        }
    };
 
 
    typedef void (CINOSTaskEx::*tOnMsgDoneFunction)(CINOSTaskExMsg* apMsg, CINOSTaskExDef::ERplId aRplId, tMcAppError aAppError);
 
 
    virtual void SetOnMsgDone(const CINOSTaskExCmdHookBase* apOnMsgDoneHook) {
        if(ActualTask() == m_pTask) {
            m_pMsgDoneFunction = apOnMsgDoneHook->GetOnMsgDoneFunction();
        }
    }
 
 
    virtual uint32 AddCommand(bool abDeleteOnRemove = false)
        {
            if(m_pTask== nullptr) {
                return INOS_MCMSG_CODE_TSKEX_CMD_NO_TASK;
            }
            auto pCmdMsg = new CINOSTaskExMsg(this->m_CommandMsg);
            pCmdMsg->SetFlags(this->m_CommandMsg.GetFlags());
            m_uReferenceCount = abDeleteOnRemove ? 1 : 0;
            m_pRegisterMsg = pCmdMsg;
 
            // Crate a new message from prototype message and add the command with the needed parameters
            m_pTask->AddCommand(pCmdMsg, m_uCharacteristics, m_uKeyLevel, m_bRegisterInco);
            return 0;
        };
 
    virtual uint32 AddCommand(
            uint64 aChar,               // characteristics of object
            uint16 aKeyLevel,           // keylevel of object
            bool abRegisterInco=true,
            bool abDeleteOnRemove = false)
        {
 
            if(m_pTask== nullptr) {
                return INOS_MCMSG_CODE_TSKEX_CMD_NO_TASK;
            }
            auto pCmdMsg = new CINOSTaskExMsg(this->m_CommandMsg);
 
            m_uReferenceCount = abDeleteOnRemove ? 1 : 0;
            m_pRegisterMsg = pCmdMsg;
 
            this->m_pTask->AddCommand(pCmdMsg,
                        aChar, aKeyLevel, abRegisterInco);
            return 0;
        };
 
    inline CINOSTaskExMsg* CreateMsg(CINOSSync* apSync=DF_INOS_SYNCHRONOUS) {
        auto pMsg = new CINOSTaskExMsg(CINOSTaskExDef::eMsgCall, (uintptr) this, apSync);
        pMsg->AddFlags(this->m_CommandMsg.GetFlags());
        return pMsg;
    }
 
    const char* GetOption() const {
        return m_pOption;
    }
 
    const char* GetName() {
        return m_CommandMsg.GetName(false);
    }
 
    void SetName(const char* apName) {
        return m_CommandMsg.SetName(apName);
    }
 
    CINOSTaskExMsg& GetMsg() {
        return m_CommandMsg;
    }
 
    void SetTask(CINOSTaskEx* apTask) {
        m_pTask = apTask;
    }
 
    void AddParam(const char* apName, real64 arValue, real64 arMin,
        real64 arMax, const char* apUnit = "", uint32 auChar = 0, uint32 auFlags = 0)
    {
 
        auto pParam = m_CommandMsg.AddDefaultParam(apName, arValue);
        pParam->SetMinValue(arMin);
        pParam->SetMaxValue(arMax);
        pParam->SetUnit(apUnit);
        pParam->SetCharacteristics(auChar);
        pParam->SetFlag(auFlags);
        // end AddParam
    }
    void AddParam(const char* apName, const char* apValue,
                const char* apComboData=nullptr, uint32 auFlags = 0) {
        auto pParam = m_CommandMsg.AddDefaultParam(apName, apValue);
        pParam->SetFlag(auFlags);
        if(apComboData) {
            pParam->SetComboData(apComboData);
        }
    }
 
 
    void AddParam(const char* apName, bool abValue, uint32 auFlags = 0) {
        auto pParam = m_CommandMsg.AddDefaultParam(apName, abValue);
        pParam->SetFlag(auFlags);
    }
 
    // TODO !OI! Add the other add param variants as in the CINOSTaskEx, arguments should be
    // exactly the same to allow easy migration
 
 
    void SetAllowedStates(uint32 auStateBitmap) {
        m_uAllowedStates= auStateBitmap;
    }
 
    int operator < (CINOSTaskExCmdBase& aTaskExMsg)
        { return (strcmp(m_CommandMsg.GetName(), aTaskExMsg.m_CommandMsg.GetName())<0);}
    int operator == (CINOSTaskExCmdBase& aTaskExMsg)
        { return (strcmp(m_CommandMsg.GetName(), aTaskExMsg.m_CommandMsg.GetName())==0);}
    int operator < (const char* aName)
        { return (strcmp(m_CommandMsg.GetName(),    aName)<0);}
    int operator == (const char* aName)
        { return (strcmp(m_CommandMsg.GetName(), aName)==0);}
 
    virtual ~CINOSTaskExCmdBase() {
            if(m_pOption != nullptr) {
                delete [] m_pOption;
            }
        }
 
    //  is removed, the object will be alive until all calls of commands are completed.
    //  It is used by the corresponding message objects in their constructor.
    void Claim() {
        // If reference count is 0 this is a "static" object or member object.
        if(m_uReferenceCount != 0) {
            m_uReferenceCount++;
        }
    }
 
    //  is deleted, in case the command was removed during a call of this command.
    //  It is used by the corresponding message objects in their destructor.
    void Release(CINOSTaskExMsg* apMsg = nullptr) {
        // is the msg the registered message?
        if(apMsg == this->m_pRegisterMsg) {
            // null the registered message to avoid using dangling pointer
            this->m_pRegisterMsg = nullptr;
        }
 
        // If reference count is 0 this is a "static" object or member object.
        if(m_uReferenceCount != 0) {
            uint32 uCount = (uint32)(m_uReferenceCount--);
 
            // Was the caller the last reference of this object?
            if(uCount == 1) {
                // Yes, delete it
                DeleteCommand();
            }
        }
    }
 
 
 
 
protected:
    virtual void Dispatch(CINOSTaskExMsg* apMsg) = 0;
 
    virtual void DispatchTmd(CINOSTaskExMsg* apMsg) = 0;
 
    bool PreDispatch(CINOSTaskExMsg* apMsg)  {
        // Check if the command has a valid task
        if(m_pTask == nullptr) {
            ActualTaskEx()->MsgDone(apMsg, INOS_MCMSG_CODE_TSKEX_CMD_NO_TASK);
            return false;
        }
        if(this->m_uAllowedStates & (1 << m_pTask->CINOSTaskEx::GetState())) {
            if(m_pPreDispatchFunction != nullptr) {
                return (m_pTask->*m_pPreDispatchFunction)(apMsg);
            }
            return true;
        }
        return false;
    }
 
    void OnMsgDone(CINOSTaskExMsg* apMsg, CINOSTaskExDef::ERplId aRplId, tMcAppError aAppError) {
        if(m_pMsgDoneFunction && m_pTask != nullptr) {
            (m_pTask->*m_pMsgDoneFunction)(apMsg, aRplId,aAppError );
        }
    };
 
 
    //  see CINOSTaskExCmd or CINOSTaskExCmdMsg for further information
    CINOSTaskExCmdBase(const char* apName, CINOSTaskEx* apTask, uint32 auStateBitmap,
            const char* apOption, uint64 auCharacteristics, uint16 auKeyLevel,
            bool abRegisterInco) :
            m_pTask(apTask),
            m_uCharacteristics(auCharacteristics),
            m_uKeyLevel(auKeyLevel),
            m_bRegisterInco(abRegisterInco),
            m_CommandMsg(CINOSTaskExDef::eMsgCall, (uintptr) this),
            m_uAllowedStates(auStateBitmap),
            m_uReferenceCount(0)
        {
            if(apName != nullptr) {
                m_CommandMsg.SetName(apName);
            }
            if(apOption != nullptr) {
              const size_t uBufLen = strlen(apOption) + 1;
                char* pOption = new char[uBufLen];
                strncpy(pOption, apOption, uBufLen);
                m_pOption = pOption;
            }
        };
 
    bool CheckParams(size_t count, ...) {
        auto pParam = m_CommandMsg.GetFirstParamPtr(false);
        va_list args;
        va_start(args, count);
        for (size_t ix = 0; ix < count; ix++) {
            if(pParam == nullptr || pParam->GetType() !=  va_arg(args, int32)) {
                INOS_ERROR("CINOSTaskExCmdBase::CheckParams type mismatch");
                return false;
            }
            pParam = pParam->GetNext();
        }
        va_end(args);
 
        return pParam == nullptr;
    }
 
    //  other task than the task of this command.
    virtual void DeleteCommand() {
        // Actual task os 'own' task?
        if(::ActualTask() == m_pTask) {
            // yes -> just delete this
            delete this;
        }
        else {
            // no -> dispatch and let the task delete this object.
            auto pMsg = new CINOSTaskExMsg(CINOSTaskExDef::eMsgInternal,
                    CINOSTaskEx::eIntDeleteCommand, DF_INOS_ASYNCHRONOUS);
            pMsg->AddParam<CINOSTaskExCmdBase*>(this);
            m_pTask->PutMsg(pMsg);
        }
    };
 
    CINOSTaskEx* m_pTask;
 
    tPreDispatchFunction m_pPreDispatchFunction = nullptr;
 
    tOnMsgDoneFunction m_pMsgDoneFunction = nullptr;
 
    //  if AddCommand is called with no arguments.
    uint64 m_uCharacteristics = 0;
 
    uint64 m_uIsStructureBitmap = 0;
 
    //  if AddCommand is called with no arguments.
    uint16 m_uKeyLevel = cKeyLevelMin;          // keylevel of object
    //  if AddCommand is called with no arguments.
    bool m_bRegisterInco = true;
 
    CINOSTaskExMsg m_CommandMsg;
 
    CINOSTaskExMsg* m_pRegisterMsg = nullptr;
 
    uint32 m_uAllowedStates;
    //  at startup.
    const char* m_pOption = nullptr;
 
    // object was not dynamically created and must not be deleted.
    std::atomic_ulong m_uReferenceCount;
};
 
//------------------------------------------------------------------------------
// class TINOSTaskExCmdDyn
//------------------------------------------------------------------------------
 
template<class ObjectType>
class TINOSTaskExCmdDyn : public CINOSTaskExCmdBase
{
public:
    typedef void (ObjectType::*tCommandFunction)(CINOSTaskExMsg* apMsg);
 
    template<typename... ParamType>
    CMcResult operator() (ParamType... Params, CINOSSync* apSync=DF_INOS_SYNCHRONOUS) {
        if(m_pTask == nullptr) {
            return CMcResult((tMcAppError)INOS_MCMSG_CODE_TSKEX_CMD_NO_TASK);
        }
        if(m_pObject == nullptr) {
            return CMcResult((tMcAppError)INOS_MCMSG_CODE_TSKEX_CMD_NO_OBJECT);
        }
 
        // Check the params
        if(!this->CheckParams(sizeof...(Params), (int32)TINCOType<ParamType>::eType...)) {
            CMcResult r(INOS_MCMSG_CODE_TSKEX_WRONG_PARAMS);
            return r;
        }
 
        CINOSTaskExMsg* pMsg = CINOSTaskExCmdBase::CreateMsg(apSync);
        CINOSTaskExMsgParam* dummy[sizeof...(Params)] = { AddParam(pMsg, Params)... };
        (void)dummy; // Suppress compiler warning
 
        // Check for errors set in AddParam (e.g. JSON parse errors).
        uint32 uRet = pMsg->GetRetValue();
        if(uRet != 0) {
            delete pMsg;
            CMcResult r(uRet);
            return r;
        }
 
        return this->m_pTask->PutMsg(pMsg);
    }
 
                tCommandFunction apFunction,
                tCommandFunction apFunctionTmd,
                ObjectType& aObject,
                uint32 auStateBitmap = 0xFFFFFFFF,
                const char* apOption = "",
                uint64 auCharacteristics = 0,
                uint16 auKeyLevel = cKeyLevelMin,
                bool abRegisterInco = true) :
        CINOSTaskExCmdBase(apName, &aObject, auStateBitmap, apOption,
                auCharacteristics, auKeyLevel, abRegisterInco),
        m_pObject(&aObject),
        m_pFunction(apFunction),
        m_pFunctionTmd(apFunctionTmd){}
 
 
 
    virtual ~TINOSTaskExCmdDyn() {}
 
 
protected:
    virtual void Dispatch(CINOSTaskExMsg* apMsg) override{
 
        // Check if object is set
        if(this->m_pObject == nullptr) {
            // Don't use internal task pointer as this could be the wrong one or not set
            ActualTaskEx()->MsgError(apMsg, INOS_MCMSG_CODE_TSKEX_CMD_NO_OBJECT);
            return;
        }
 
        // Check if function is set
        if(m_pFunction == nullptr) {
            // Don't use internal task pointer as this could be the wrong one or not set
            ActualTaskEx()->MsgError(apMsg, INOS_MCMSG_CODE_TSKEX_CMD_NO_FUNCTION);
            return;
        }
 
        // Call the function
        (this->m_pObject->*m_pFunction)(apMsg);
    }
 
    virtual void DispatchTmd(CINOSTaskExMsg* apMsg) override {
        if(m_pFunctionTmd) {
            (this->m_pObject->*m_pFunctionTmd)(apMsg);
        }
    }
 
    ObjectType* m_pObject;
 
    private:
    //  message of this command is dispatched.
    tCommandFunction m_pFunction = nullptr;
    //  this command msg is put into the queue even if the msg has a trigger.
    tCommandFunction m_pFunctionTmd = nullptr;
 
};
 
//------------------------------------------------------------------------------
// template class TINOSTaskExCmdBase
//------------------------------------------------------------------------------
 
template<class ObjectType, typename... ParamType>
class TINOSTaskExCmdBaseParam : public CINOSTaskExCmdBase
{
public:
    CMcResult operator() (ParamType... Params, CINOSSync* apSync=DF_INOS_SYNCHRONOUS) {
        // Check if command ready to be called
        if(m_pTask == nullptr) {
            return CMcResult((tMcAppError)INOS_MCMSG_CODE_TSKEX_CMD_NO_TASK);
        }
        if(m_pObject == nullptr) {
            return CMcResult((tMcAppError)INOS_MCMSG_CODE_TSKEX_CMD_NO_OBJECT);
        }
 
        // now create the message
        CINOSTaskExMsg* pMsg = CINOSTaskExCmdBase::CreateMsg(apSync);
        CINOSTaskExMsgParam* dummy[sizeof...(Params)] = { AddParam(pMsg, Params)... };
        (void)dummy; // Suppress compiler warning
 
        // Check for errors set in AddParam (e.g. JSON parse errors).
        uint32 uRet = pMsg->GetRetValue();
        if(uRet != 0) {
            delete pMsg;
            CMcResult r(uRet);
            return r;
        }
 
        return this->m_pTask->PutMsg(pMsg);
    }
 
 
    virtual uint32 AddCommand(bool abDeleteOnRemove = false) override
        {
            if(CINOSTaskExCmdBase::CheckParams(sizeof...(ParamType), (int32)TINCOType<ParamType>::eType...)) {
                return CINOSTaskExCmdBase::AddCommand(abDeleteOnRemove);
            }
            return INOS_MCMSG_CODE_TSKEX_WRONG_PARAMS;
        };
 
    virtual uint32  AddCommand(
            uint64 aChar,               // characteristics of object
            uint16 aKeyLevel,           // keylevel of object
            bool abRegisterInco=true,
            bool abDeleteOnRemove = false) override
        {
            if(CINOSTaskExCmdBase::CheckParams(sizeof...(ParamType), (int32)TINCOType<ParamType>::eType...)) {
                return CINOSTaskExCmdBase::AddCommand(aChar, aKeyLevel, abRegisterInco, abDeleteOnRemove);
            }
            return INOS_MCMSG_CODE_TSKEX_WRONG_PARAMS;
        };
 
    virtual void SetDefaults(ParamType... Default) {
        this->m_CommandMsg.FstParam();
        uint32 dummy[sizeof...(Default)] = {
            ( this->m_CommandMsg.GetParamPtr()->SetTypedValue(Default))... };
        (void)dummy;
 
        if(this->m_pRegisterMsg) {
            this->m_pRegisterMsg->FstParam();
            uint32 dummy[sizeof...(Default)] = {
            ( this->m_pRegisterMsg->GetParamPtr()->SetTypedValue(Default))... };
            (void)dummy;
        }
    }
 
    virtual ~TINOSTaskExCmdBaseParam() {}
 
protected:
    //  see CINOSTaskExCmd or CINOSTaskExCmdMsg for further information
    TINOSTaskExCmdBaseParam(const char* apName,
            CINOSTaskEx* apTask,
            ObjectType* apObject,
            TINOSTaskExValDef<ParamType>... apDefaultParams,
            uint32 auStateBitmap,
            const char* apOption,
            uint64 auCharacteristics,
            uint16 auKeyLevel,
            bool abRegisterInco) :
        CINOSTaskExCmdBase(apName, apTask, auStateBitmap, apOption,
                auCharacteristics, auKeyLevel, abRegisterInco),
        m_pObject(apObject)
    {
        CINOSTaskExMsgDefaultParam* params[sizeof...(apDefaultParams)] = { apDefaultParams.AddToMsg(this->m_CommandMsg)...};
 
        for(uint32 uIx = 0; uIx < sizeof...(apDefaultParams); uIx++) {
            if((params[uIx]->GetFlag() & CINOSTaskExMsgParam::eFlgStructure) != 0) {
                this->m_uIsStructureBitmap |= (1<<uIx);
            }
        }
        this->m_uAllowedStates = auStateBitmap;
 
        INOS_CONCURRENCY_CHECK_FREE(&this->m_CommandMsg);
 
        // name and task available ?
        if(this->m_pTask != nullptr && apName != nullptr) {
            // yes -> add this command to command registry
            this->m_pTask->CINOSTaskEx::RegisterCommand(this);
        }
    };
    template<typename T>
    CINOSTaskExMsgParam* AddParam(CINOSTaskExMsg* apMsg, T aValue) {
        return apMsg->AddParam(aValue);
    }
 
    CINOSTaskExMsgParam* AddParam(CINOSTaskExMsg* apMsg, const char* pValue) {
        if((this->m_uIsStructureBitmap & (1<< apMsg->GetParamCnt())) != 0) {
            return apMsg->AddJsonParam(pValue);
        }
        else {
            return apMsg->AddParam(pValue);
        }
    }
 
    ObjectType* m_pObject;
 
};
 
 
//------------------------------------------------------------------------------
// template class TINOSTaskExCmd
//------------------------------------------------------------------------------
template<class ObjectType, typename... ParamType>
class TINOSTaskExCmd : public TINOSTaskExCmdBaseParam<ObjectType, ParamType...>
{
public:
    typedef void (ObjectType::*tCommandFunction)(ParamType... Params);
 
 
    TINOSTaskExCmd(const char* apName,
            tCommandFunction apFunction,
            tCommandFunction apFunctionTmd,
            ObjectType& aObject,
            TINOSTaskExValDef<ParamType>... apParamDefinitions,
            uint32 auStateBitmap = 0xFFFFFFFF,
            const char* apOption = nullptr,
            uint64 auCharacteristics = 0,
            uint16 auKeyLevel = cKeyLevelMin,
            bool abRegisterInco = true) :
        TINOSTaskExCmdBaseParam<ObjectType, ParamType...>(apName, &aObject, &aObject, apParamDefinitions...,
                auStateBitmap, apOption, auCharacteristics, auKeyLevel, abRegisterInco),
        m_pFunction(apFunction),
        m_pFunctionTmd(apFunctionTmd) {};
 
    TINOSTaskExCmd(const char* apName,
            CINOSTaskEx* apTask,
            ObjectType* apObject,
            tCommandFunction apFunction,
            tCommandFunction apFunctionTmd,
            TINOSTaskExValDef<ParamType>... apParamDefinitions,
            uint32 auStateBitmap = 0xFFFFFFFF,
            const char* apOption = nullptr,
            uint64 auCharacteristics = 0,
            uint16 auKeyLevel = cKeyLevelMin,
            bool abRegisterInco = true) :
        TINOSTaskExCmdBaseParam<ObjectType, ParamType...>(apName, apTask, apObject, apParamDefinitions...,
                auStateBitmap, apOption, auCharacteristics, auKeyLevel, abRegisterInco),
        m_pFunction(apFunction),
        m_pFunctionTmd(apFunctionTmd) {};
 
    // This helper struct is needed to get ordered calls to GetParam
    struct CallStruct {
        // Constructor that simply calls the given function with the given params
        CallStruct(ObjectType& Object, tCommandFunction function, ParamType... Params) {
            (Object.*function)(Params...);
        }
    };
 
    virtual ~TINOSTaskExCmd() { }
 
protected:
    virtual void Dispatch(CINOSTaskExMsg* apMsg) {
 
        // Check if object is set
        if(this->m_pObject == nullptr) {
            // Don't use internal task pointer as this could be the wrong one or not set
            ActualTaskEx()->MsgError(apMsg, INOS_MCMSG_CODE_TSKEX_CMD_NO_OBJECT);
            return;
        }
 
        // Check if function is set
        if(m_pFunction == nullptr) {
            // Don't use internal task pointer as this could be the wrong one or not set
            ActualTaskEx()->MsgError(apMsg, INOS_MCMSG_CODE_TSKEX_CMD_NO_FUNCTION);
            return;
        }
 
        // Use list-initialization "{}" to get the parameters from the message
        // as list-initialization is guaranteed to be ordered
        // Function call "()" unfortunately not ordered and some compilers then call
        // GetParam in the wrong order!
        CallStruct dummy = {*(this->m_pObject), m_pFunction, apMsg->GetParam<ParamType>()...};
        (void)dummy;
    }
 
    virtual void DispatchTmd(CINOSTaskExMsg* apMsg) {
        if(m_pFunctionTmd) {
            // Use list-initialization "{}" to get the parameters from the message
            // as list-initialization is guaranteed to be ordered
            // Function call "()" unfortunately not ordered and some compilers then call
            // GetParam in the wrong order!
            CallStruct dummy = {*(this->m_pObject), m_pFunctionTmd, apMsg->GetParam<ParamType>()...};
            (void)dummy;
        }
    }
 
private:
 
    //  message of this command is dispatched.
    tCommandFunction m_pFunction = nullptr;
    //  this command msg is put into the queue even if the msg has a trigger.
    tCommandFunction m_pFunctionTmd = nullptr;
 
};
 
//------------------------------------------------------------------------------
// template class TINOSTaskExCmdMsg
//------------------------------------------------------------------------------
template<class ObjectType, typename... ParamType>
class TINOSTaskExCmdMsg : public TINOSTaskExCmdBaseParam<ObjectType, ParamType...>
{
public:
    typedef void (ObjectType::*tCommandFunction)(CINOSTaskExMsg* apMsg);
 
    private:
    //  message of this command is dispatched.
    tCommandFunction m_pFunction;
    //  this command msg is put into the queue even if the msg has a trigger.
    tCommandFunction m_pFunctionTmd;
 
    public:
 
    TINOSTaskExCmdMsg(const char* apName,
            tCommandFunction apFunction,
            tCommandFunction apFunctionTmd,
            ObjectType& aObject,
            TINOSTaskExValDef<ParamType>... apDefaultParams,
            uint32 auStateBitmap = 0xFFFFFFFF,
            const char* apOption = nullptr,
            uint64 auCharacteristics = 0,
            uint16 auKeyLevel = cKeyLevelMin,
            bool abRegisterInco = true) :
            TINOSTaskExCmdBaseParam<ObjectType, ParamType...>(apName, &aObject, &aObject, apDefaultParams...,
                auStateBitmap, apOption, auCharacteristics, auKeyLevel, abRegisterInco),
        m_pFunction(apFunction),
        m_pFunctionTmd(apFunctionTmd)  {};
 
    TINOSTaskExCmdMsg(const char* apName,
            CINOSTaskEx* apTask,
            ObjectType* apObject,
            tCommandFunction apFunction,
            tCommandFunction apFunctionTmd,
            TINOSTaskExValDef<ParamType>... apDefaultParams,
            uint32 auStateBitmap = 0xFFFFFFFF,
            const char* apOption = nullptr,
            uint64 auCharacteristics = 0,
            uint16 auKeyLevel = cKeyLevelMin,
            bool abRegisterInco = true) :
            TINOSTaskExCmdBaseParam<ObjectType, ParamType...>(apName, apTask, apObject, apDefaultParams...,
                auStateBitmap, apOption, auCharacteristics, auKeyLevel, abRegisterInco),
        m_pFunction(apFunction),
        m_pFunctionTmd(apFunctionTmd)  {};
 
 
 
    virtual ~TINOSTaskExCmdMsg () { }
 
 
protected:
 
    virtual void Dispatch(CINOSTaskExMsg* apMsg) override {
 
        // Check if object is set
        if(this->m_pObject == nullptr) {
            // Don't use internal task pointer as this could be the wrong one or not set
            ActualTaskEx()->MsgError(apMsg, INOS_MCMSG_CODE_TSKEX_CMD_NO_OBJECT);
            return;
        }
 
        // Check if function is set
        if(m_pFunction == nullptr) {
            // Don't use internal task pointer as this could be the wrong one or not set
            ActualTaskEx()->MsgError(apMsg, INOS_MCMSG_CODE_TSKEX_CMD_NO_FUNCTION);
            return;
        }
 
        // Call the function
        (this->m_pObject->*m_pFunction)(apMsg);
    }
 
    virtual void DispatchTmd(CINOSTaskExMsg* apMsg) override {
        if(m_pFunctionTmd) {
            (this->m_pObject->*m_pFunctionTmd)(apMsg);
        }
    }
 
 
 
 
 
};
 
//------------------------------------------------------------------------------
 
#endif  // INC_CINOSTASKEXTMPL_H
 
 
//------------------------------------------------------------------------------
// end of file