cinostaskexdef.h

Go to the documentation of this file.

//******************************************************************************
//******************************************************************************
 
#ifndef INC_CINOSTASKEXDEF_H
#define INC_CINOSTASKEXDEF_H
 
//
//------------------------------------------------------------------------------
// includes
//------------------------------------------------------------------------------
 
// system
#include <inos.h>
#include <cincotype.h>
 
// C++
#include <typeinfo>
#include <memory>
// project
 
 
//------------------------------------------------------------------------------
// definitions
//------------------------------------------------------------------------------
//
typedef uint32 tMcAppError;
 
#define DF_INOS_TASKEX_MSG_PARAM_NAME_LENGTH 32
 
 
//------------------------------------------------------------------------------
// forward declarations
//------------------------------------------------------------------------------
//
 
class CINOSTaskExDef
{
    public:
        // message types
        enum EMsgTypes {
            eMsgCmd,
            eMsgCall,
            eMsgEvent,
            eMsgReply,
            eMsgUser,
            eMsgSub,
            eMsgInternal,
            eMsgMessage
        };      
 
        // reply id's. If extending this, consider doing the same
        // change/extension at CINOSTaskEx::ERplId. If extending this enum,
        // consider extending the 'inix' INCOExplorer, CIncoProcedure.cpp,
        // CIncoProcedure::TicketCompleted which has a switch case which
        // converts these values into strings.
        enum ERplId {
            eRplOk=0,
            eRplSkipped,
            eRplInComplete,
            eRplIgnored,
            eRplPaused, // Deprecated
            eRplStopped,
            eRplCanceled,
            eRplRejected,
            eRplFailed,
            eRplError,
            eRplFatal,
            eRplTimeout
        };      
 
        // array with strings for all reply id's.
        static constexpr char* const s_pReplyIdStrings[CINOSTaskExDef::eRplTimeout + 1] = {
                "OK",
                "Skipped",
                "Incomplete",
                "Ignored",
                "Paused",
                "Stopped",
                "Canceled",
                "Rejected",
                "Failed",
                "Error",
                "Fatal",
                "Timeout"
        };
};
 
class CINOSTaskExMsg;
 
 
//------------------------------------------------------------------------------
// class CINOSTaskExMsgParam
//------------------------------------------------------------------------------
 
class CINOSTaskExMsgParam
{
    public :
        enum { 
            ePrintfFormatMaxSize = 4
        };
        char* GetName()
            {return m_pName;};
        const char* GetName() const
            {return m_pName;};
        uint16 GetType() const
            {return m_uType;};
        uint32 GetFlag()
            { return m_uFlags;};        
        uint32 GetTypeSize() const
            {return m_uTypeSize;};
        const std::type_info* GetTypeInfo() const;
        void* GetValue() {
            if( m_uType == defType_pointer) {
                // don't return CPtrContainerBase, as this class should be considered
                // begin an implementation detail. Instead, return the pointer value:
                return const_cast<void*>(((CINOSTaskExMsgParam::CPtrContainerBase*)m_uValue)->GetPointer());
            }
            if (m_pValue) return m_pValue; else return m_uValue;
        };
        const void* GetValue() const
            {return const_cast<CINOSTaskExMsgParam*>(this)->GetValue();};
        template <typename T>
        T GetTypedValue() const {
            // Is this of type pointer
            if(m_uType == defType_pointer) {
                // yes -> The value is a pointer container
                CINOSTaskExMsgParam::CPtrContainerBase* pContainer =
                        (CINOSTaskExMsgParam::CPtrContainerBase*)m_uValue;
 
                // Check the type of the container
                if(*(pContainer->GetTypeInfo()) == typeid(T)) {
                    // Type is correct, call receive on the container, gets the pointer and
                    // sets back internals of the container if needed.
 
                    return ((CINOSTaskExMsgParam::CPtrContainer<T>*)pContainer)->Receive();
                    // If the compiler prints the following line:
                    //
                    // error: 'class CINOSTaskExMsgParam::CPtrContainer<void*>' has no member named 'Receive'
                    //
                    // A message parameter of type "void*" has been tried to be instantiated
                    // this is forbidden because in case of a "lost" message it
                    // is not possible to delete the according object without type
                    // information.
                    // Instead it is possible to either use type 'const void*' for
                    // constant data that doesn't need deallocation or to use the correct
                    // type (e.g. AddParam<CMyClass*>, GetResult<CMyClass*>) in which case the
                    // object will be correctly deallocated in case of a "lost" message.
                    //
                    // Don't fix this problem here, go to "instantiated from here" and change
                    // the type accordingly.
                }
                return T();
            }
            else {
                return m_pValue ? (*((T*)&m_pValue)) : (*((T*)&m_uValue));
            }
        };
 
        template <typename T>
        uint32 SetTypedValue(T aValue) {
            if(m_uType !=  TINCOType<T>::eType) {
                return 1; // TODO error code
            }
 
            // Is param of type pointer
            if(m_uType == defType_pointer) {
                auto pContainer = (CINOSTaskExMsgParam::CPtrContainerBase*)m_uValue;
                pContainer->SetPointer(aValue);
                // If the compiler prints the following line:
                //
                // error: no matching function for call to 'CINOSTaskExMsgParam::CPtrContainer<void*>::SetPointer(void*)'
                //
                // A message parameter of type "void*" has been tried to be instantiated
                // this is forbidden because in case of a "lost" message it
                // is not possible to delete the according object without type
                // information.
                // Instead it is possible to either use type 'const void*' for
                // constant data that does not need deallocation or use the correct
                // type (e.g. AddParam<CINOSMcDataInst*>) in which case the
                // object will be correctly deallocated in case of a "lost" message.
                //
                // Don't fix this problem here, go to "instantiated from here" and change
                // the type accordingly.
            }
            else {
                SetValue(&aValue, sizeof(T), false);
            }
            return INOS_OK;
        }
 
        uint32 SetTypedValue(const char* value) {
            SetValue(value, false);
            return INOS_OK;
 
        }
 
        uint32 GetValueBufferSize()
            {if (m_pValue) return m_pPartition->GetPartitionSize(); else return sizeof(m_uValue);};
        void SetValue(const char* apValue, bool abInINCOVContext);
        void SetValue(const void* apValue, const uint32 auDataLength, bool abInINCOVContext);
        void SetName(const char* apName);
        virtual void SetFlag(uint32 auFlag) {
            INOS_OR(m_uFlags, auFlag);
        }
        virtual void ClearFlag(uint32 auFlag) {
            INOS_AND(m_uFlags, ~auFlag);
        }
        bool IsNumber() const
            {return (m_uType != defType_string);}
        bool IsString() const
            {return (m_uType == defType_string);} 
        void ToString(char* apDest, uint32 aSize);
        void AddPrintfFormat(char*& apDest, bool abWithReadabilitySupport);
        int32 ToINCOValue(uint16* apINCOType, uint8* apINCOValue, 
            const uint32 auBufferSize, const uint32 auDataLength, const bool abCut = false) const;
        CINOSTaskExMsgParam* GetNext() const
            { return m_pNext; }
        void SetNext(CINOSTaskExMsgParam* apParam)
                { m_pNext = apParam;  }
        enum {
            eFlgMandatory = 0x00000001,
            eFlgNoSubstitution = 0x00000002,
            eFlgOversized = 0x00000004,
            eFlgStructure = 0x0000008,
        };
        
        // Dummy implementations of additional methods in CINOSTaskExMsgDefaultParam
        virtual real64 GetMinValue() { return REAL64MIN;};
        virtual real64 GetMaxValue() { return REAL64MAX;};
        virtual const char* GetUnit() { return "";};
        virtual uint64 GetCharacteristics() { return 0;};
        virtual const char* GetComboData() { return NULL;};
        
        template <typename T>
        CINOSTaskExMsgParam(T aValue, const char* apName = NULL, bool abInINCOVContext = false) {
            m_pValue = NULL; m_uFlags = 0; m_pNext = 0;
            SetName(apName);
            m_uType = TINCOType<T>::eType;
            // Is param of type pointer
            if(m_uType == defType_pointer) {
                // Yes -> Create a pointer container
                static_assert(sizeof(CPtrContainer<T>) <= sizeof(m_uValue), "PtrContainer doesn't fit into preallocated buffer.");
                m_uTypeSize = sizeof(CPtrContainer<T>);
                // Create a container for the pointer in place, 32 Bytes should
                // be fairly enough for the CPtrContainer
                new (&(m_uValue)) CPtrContainer<T>(std::move(aValue));
                // If the compiler prints the following line:
                //
                // error: no matching function for call to 'CINOSTaskExMsgParam::CPtrContainer<void*>::CPtrContainer(void*&)'
                //
                // A message parameter of type "void*" has been tried to be instantiated
                // this is forbidden because in case of a "lost" message it
                // is not possible to delete the according object without type
                // information.
                // Instead it is possible to either use type 'const void*' for
                // constant data that does not need deallocation or use the correct
                // type (e.g. AddParam<CINOSMcDataInst*>) in which case the
                // object will be correctly deallocated in case of a "lost" message.
                //
                // Don't fix this problem here, go to "instantiated from here" and change
                // the type accordingly.
            }
            else {
                m_uTypeSize = sizeof(aValue);
 
                SetValue(&aValue, sizeof(T), false);
            }
        }
        CINOSTaskExMsgParam(char* aValue, const char* apName = NULL, bool abInINCOVContext = false) {
            m_pValue = NULL; m_uFlags = 0; m_pNext = 0;
            SetName(apName);
            m_uType = defType_string;
            m_uTypeSize = 0;
            SetValue(aValue, abInINCOVContext);
        }
        CINOSTaskExMsgParam(const char* aValue, const char* apName = NULL, bool abInINCOVContext = false) {
            m_pValue = NULL; m_uFlags = 0; m_pNext = 0;
            SetName(apName);
            m_uType = defType_string;
            m_uTypeSize = 0;
            SetValue(aValue, abInINCOVContext);
        }
        CINOSTaskExMsgParam(CINOSTaskExMsgParam&& a)
            :   m_uFlags(std::move(a.m_uFlags)),
                m_uType(std::move(a.m_uType)),
                m_uTypeSize(std::move(a.m_uTypeSize)),
                m_pValue(std::move(a.m_pValue)),
                m_pPartition(std::move(a.m_pPartition)),
                m_pNext(std::move(a.m_pNext))
        {
            SetName(a.m_cName);
            if( !m_pValue ) {
                memcpy(m_uValue, a.m_uValue, m_uTypeSize);
            }
        }
 
        virtual CINOSTaskExMsgParam* Clone() {
            return new CINOSTaskExMsgParam(*this);
        }
        virtual ~CINOSTaskExMsgParam();
 
    private :
        void AllocExBuffer();
        void FreeExBuffer();
 
    private :
 
        friend class CINOSTaskEx;
        friend class CINOSTaskExMsg;
        friend class CINOSTaskExMsgDefaultParam;
        friend class CINOSTaskExTracer;
        friend class CINOSEvtLogMsgArg;
        friend class CMcResult;
        friend class CMcResultStream;
        friend class CINOSMovePath;
 
        CINOSTaskExMsgParam()
            { m_cName[0] = 0; m_uFlags = 0; m_pNext = 0; m_pValue = 0;
            m_uTypeSize = 0; m_uType = defType_Invalid;
            memset(m_uValue, 0, sizeof(m_uValue));};
        CINOSTaskExMsgParam(const CINOSTaskExMsgParam& aMsgParam);
 
 
        char m_cName[DF_INOS_TASKEX_MSG_PARAM_NAME_LENGTH];
        char* m_pName = m_cName;
        uint32 m_uFlags;
        uint16 m_uType;
        uint16 m_uTypeSize;
        double m_uValue[4];
        void* m_pValue;
        CINOSPartitionMemory* m_pPartition = nullptr;
        CINOSTaskExMsgParam* m_pNext;
 
        //------------------------------------------------------------------------------
        // local class declaration
        //------------------------------------------------------------------------------
        //
        // CPtrContainerBase is the abstract base of all pointer containers
        class CPtrContainerBase
        {
        public:
            CPtrContainerBase(const std::type_info* aTypeInfo) :
                    m_pTypeInfo(aTypeInfo)  {};
 
            virtual ~CPtrContainerBase() {};
 
            // Returns the pointer value
            virtual const void* GetPointer() { return nullptr; };
 
            template <typename T>
            bool SetPointer(T pPointer) {
                if(&typeid(T) != m_pTypeInfo) {
                    return false;
                }
                reinterpret_cast<CPtrContainer<T>*>(this)->iSetPointer(pPointer);
                return true;
            };
 
            // To avoid compilation errors we need to implement the double variant
            // directly, even it is never called
            bool SetPointer(double pPointer) {
                return false;
            };
 
            // Get the type info, used for type checking or for reflection.
            const std::type_info* GetTypeInfo() { return m_pTypeInfo; };
        private:
            const std::type_info* m_pTypeInfo;
        };
 
        // CPtrContainer<T> is the type specific derived class for each type.
        // The non-specialiced template is for non-pointer types. It
        // Should never be instantiated. Only pointer type variants should be
        // instantiated. The template still needs to be a valid class to avoid
        // compiler warnings.
        template <class T>
        class CPtrContainer : CPtrContainerBase
        {
        public:
            // Constructer yields an assert, it should never be called.
            explicit CPtrContainer(T aValue) :
                CPtrContainerBase((const std::type_info*)NULL) { ASSERT_ALWAYS(false);  };
            virtual ~CPtrContainer() {};
 
            T Receive() { 
                // Originally, it was 'return T();', which caused warning with gcc7, 
                // complaining that the returned value may be uninitialized. This matches
                // the explanation here, and thus the following solution: 
                // http://stackoverflow.com/questions/2143022/how-to-correctly-initialize-variable-of-template-type
                return T{};
            }
 
            // Dummy implementation for all non pointer types
            virtual void iSetPointer(T pPointer) {};
 
        };
 
        // CPtrContainer<T*> is the partial specialization for non-const pointers
        // it implements all members and deletes the date on destruction if
        // needed.
        template <class T>
        class CPtrContainer<T*> : CPtrContainerBase
        {
        public:
            explicit CPtrContainer(T* apPointer) :
                CPtrContainerBase(&typeid(T*)),
                m_pPointer(apPointer) {};
 
            virtual ~CPtrContainer() {
                if(m_pPointer)
                    delete m_pPointer;
            };
 
            // Receive returns the pointer and invalidates the internal
            // pointer to avoid double deletes.
            T* Receive() {
                T* pTemp = m_pPointer;
                m_pPointer = NULL;
                return pTemp;
            };
            virtual const void* GetPointer() override { return m_pPointer; };
 
            virtual void iSetPointer(T* pPointer) {
                if(m_pPointer)
                    delete m_pPointer;
                m_pPointer = (T*)pPointer;
            };
        private:
            T* m_pPointer;
        };
 
        // CPtrContainer<const T*> is the partial specialization for const pointers
        // it implements all members and does not delete the data on destruction if
        // needed.
        template <class T>
        class CPtrContainer<const T*> : CPtrContainerBase
        {
        public:
            explicit CPtrContainer(const T* apPointer) :
                CPtrContainerBase(&typeid(const T*)),
                m_pPointer(apPointer) {};
 
            virtual ~CPtrContainer() {};
 
            // Returns the pointer, no need to invalidate the pointer,
            // as no delete is performed on const pointers.
            const T* Receive() { return m_pPointer; }
            virtual const void* GetPointer() override { return m_pPointer; }
            virtual void iSetPointer(const T* pPointer) {
                        m_pPointer = (T*)pPointer;
                    };
 
        private:
            const T* m_pPointer;
        };
 
        // CPtrContainer<std::shared_ptr<T>> is the partial specialization for sharder_ptr pointers
        // it implements all members and does not delete the data (unles the ref count is 0)
        template <class T>
        class CPtrContainer<std::shared_ptr<T>> : CPtrContainerBase
        {
        public:
            explicit CPtrContainer(std::shared_ptr<T> apPointer) :
                CPtrContainerBase(&typeid(std::shared_ptr<T>)),
                m_ShrdPtr(std::move(apPointer)) {};
 
            virtual ~CPtrContainer() {};
 
            // Don't allow casting shared pointer to void
            std::shared_ptr<T> Receive() { return m_ShrdPtr; }
 
            virtual void iSetPointer(std::shared_ptr<T> pPointer) {
 
            };
 
        private:
            std::shared_ptr<T> m_ShrdPtr;
        };
 
    DECLARE_DYNAMIC(CINOSTaskExMsgParam);
};
 
//------------------------------------------------------------------------------
// TTemplate specialization for CINOSTaskExMsgParam::GetTypedValue for types 
// char* and const  char*
//------------------------------------------------------------------------------
// 
// They are needed for GetResult<char*> and GetResult<const char*> to work.
// They are not needed for GetParam as GetParam with strings is over
// loaded and not a template specialization.
template <>
char* CINOSTaskExMsgParam::GetTypedValue() const;
 
template <>
const char* CINOSTaskExMsgParam::GetTypedValue() const;
//------------------------------------------------------------------------------
// Template class specialization for CPtrContainer<void*>
//------------------------------------------------------------------------------
// This class constructor is intentionally private. Type "void*" should not be
// used with this template, instead "const void*" or any specific pointer type
// should be used.
template <>
class CINOSTaskExMsgParam::CPtrContainer<void*> : CINOSTaskExMsgParam::CPtrContainerBase
{
private:
    CPtrContainer() : CPtrContainerBase(NULL)  {};
public: 
    virtual const void* GetPointer() override {return NULL; };
};
// If the compiler prints the following lines:
//
// error: cannot allocate an object of abstract type 'CINOSTaskExMsgParam::CPtrContainer<void*>'
// note: error: no matching function for call to 'CINOSTaskExMsgParam::CPtrContainer<void*>::CPtrContainer(void*&)'
// note: note: candidates are: CINOSTaskExMsgParam::CPtrContainer<void*>::CPtrContainer()
// note: CINOSTaskExMsgParam::CPtrContainer<void*>::CPtrContainer(const CINOSTaskExMsgParam::CPtrContainer<void*>&)
//
// A message parameter of type "void*" has been tried to be instantiated
// this is forbidden because in case of a "lost" message it
// is not possible to delete the according object.
// Instead it is possible to either use type 'const void*' for
// constant data that doesn't need deallocation or use the correct
// type (e.g. AddParam<CINOSMcDataInst*>) in which case the
// object will be correctly deallocated in case of a "lost" message.
//
// Don't fix this problem here, go to "instantiated from here" and change
// the type accordingly.
 
//------------------------------------------------------------------------------
// class CINOSTaskExMsgDefaultParam
//------------------------------------------------------------------------------
 
class CINOSTaskExMsgDefaultParam : public CINOSTaskExMsgParam
{
public:
    // Param object with additional format value like inco characteristics
    // unit and combo data min/max values for default param objects.
    virtual real64 GetMinValue() override { return m_rMinValue;};
    virtual void SetMinValue(real64 aMinValue) { m_rMinValue = aMinValue;};
 
    virtual real64 GetMaxValue() override { return m_rMaxValue;};
    virtual void SetMaxValue(real64 aMaxValue) { m_rMaxValue = aMaxValue;};
 
    virtual const char* GetUnit() override { return m_pUnit != NULL ? m_pUnit : "";};
    virtual void SetUnit(const char* apUnit);
 
    virtual uint64 GetCharacteristics() override { return m_uCharacteristics;};
    virtual void SetCharacteristics(uint64 auCharacteristics) { m_uCharacteristics = auCharacteristics;};
 
    virtual const char* GetComboData() override { return m_pComboData;};
    virtual void SetComboData(const char* apComboData);
 
    friend class CINOSTaskExMsg;
 
    CINOSTaskExMsgDefaultParam() :
        CINOSTaskExMsgParam(),
        m_rMinValue(REAL64MIN),
        m_rMaxValue(REAL64MAX),
        m_uCharacteristics(0),
        m_pUnit(NULL),
        m_pComboData(NULL) {};
    CINOSTaskExMsgDefaultParam(const CINOSTaskExMsgDefaultParam& a) :
        CINOSTaskExMsgParam(*((const CINOSTaskExMsgParam*)&a)),
        m_rMinValue(a.m_rMinValue),
        m_rMaxValue(a.m_rMaxValue),
        m_uCharacteristics(a.m_uCharacteristics),
        m_pUnit(NULL),
        m_pComboData(NULL)
    {
        SetUnit(a.m_pUnit);
        SetComboData(a.m_pComboData);
    };
    template <typename T>
    explicit CINOSTaskExMsgDefaultParam(T aValue) :
        CINOSTaskExMsgParam(aValue),
        m_rMinValue(REAL64MIN),
        m_rMaxValue(REAL64MAX),
        m_uCharacteristics(0),
        m_pUnit(NULL),
        m_pComboData(NULL) {};
    explicit CINOSTaskExMsgDefaultParam(char* aValue) :
        CINOSTaskExMsgParam(aValue),
        m_rMinValue(REAL64MIN),
        m_rMaxValue(REAL64MAX),
        m_uCharacteristics(0),
        m_pUnit(NULL),
        m_pComboData(NULL) {};
    explicit CINOSTaskExMsgDefaultParam(const char* aValue) :
        CINOSTaskExMsgParam(aValue),
        m_rMinValue(REAL64MIN),
        m_rMaxValue(REAL64MAX),
        m_uCharacteristics(0),
        m_pUnit(NULL),
        m_pComboData(NULL) {};
 
    virtual CINOSTaskExMsgParam* Clone() override {
        return new CINOSTaskExMsgDefaultParam(*this);
    }
 
    virtual ~CINOSTaskExMsgDefaultParam();
 
private:
    real64 m_rMinValue;
    real64 m_rMaxValue;
    uint64 m_uCharacteristics;
    char* m_pUnit;
    char* m_pComboData;
    DECLARE_DYNAMIC(CINOSTaskExMsgDefaultParam);
};
 
//------------------------------------------------------------------------------
 
#endif  // INC_CINOSTASKEXDEF_H
 
 
//------------------------------------------------------------------------------
// end of file