RscVariant.hxx

//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Commons/Exceptions/Exceptions.h"
#include "Arp/System/Rsc/Services/Rsc.h"
#include "Arp/System/Rsc/Services/RscGuid.hpp"
#include "Arp/System/Rsc/Services/RscVersion.hpp"
#include "Arp/System/Rsc/Services/RscString.hxx"
#include "Arp/System/Rsc/Services/SecureString.hxx"
#include <cstring>
#include <cstddef>

namespace Arp { namespace System { namespace Rsc { namespace Services
{

using namespace Arp::System::Commons;

// forwards
class RscArrayReader;
class RscArrayWriter;
class RemotingReader;
class RemotingWriter;
template<int N> class RscStructReader;
template<int N> class RscStructWriter;
template<class T, bool IsClass, bool IsSerializable> class RscValueAdapter;

template<int MaxStringSize = 0>
class RscVariant
{
public: // typedefs/friends
    friend class RscArrayReader;
    friend class RscArrayWriter;
    template<int N> friend class RscStructReader;
    template<int N> friend class RscStructWriter;
    template<class T, bool IsClass, bool IsSerializable> friend class RscValueAdapter;
    template<int N> friend class SecureString;

    using ReadElementFunction = std::function<RscType(RscType expectedType, byte* pValue)>;
    using WriteElementFunction = std::function<void(RscType valueType, const byte* pValue)>;
    using Uuid = Arp::System::Commons::Configuration::Uuid;

public: // construction/destruction
    RscVariant(RscType type = RscType::None);

    template <class T>
    RscVariant(const T& value);

    RscVariant(const String& value);

    RscVariant(const char* value);

    template<int N>
    RscVariant(const RscString<N>& value);

    template<int N>
    RscVariant(const SecureString<N>& value);

    RscVariant(size_t arraySize, RscType arrayElementType, size_t dimensions = 1, size_t fieldCount = 0);

    RscVariant(size_t arraySize, RscType arrayElementType, ReadElementFunction* pFunction, size_t dimensions = 1, size_t fieldCount = 0);

    RscVariant(size_t arraySize, RscType arrayElementType, WriteElementFunction* pFunction, size_t dimensions = 1, size_t fieldCount = 0);

    RscVariant(size_t fieldCount, ReadElementFunction* pFunction);

    RscVariant(const RscVariant<MaxStringSize>&) = default;

    RscVariant(RscVariant&&) = default;

public: // Static factory operations
    static RscVariant<MaxStringSize> CreateStructVariant(size_t fieldCount);

    static RscVariant<MaxStringSize> CreateArrayVariant(size_t arraySize, RscType elementType, size_t dimensions = 1, size_t fieldCount = 0);

private: // static factory operations
    static RscVariant<MaxStringSize> CreateStructVariant(size_t fieldCount, RemotingWriter& writer);
    static RscVariant<MaxStringSize> CreateArrayVariant(size_t arraySize, RscType elementType, RemotingWriter& writer, size_t dimensions = 1, size_t fieldCount = 0);

public: // operators
    template <class T>
    RscVariant& operator=(const T& value);
    RscVariant& operator=(const String& value);
    RscVariant& operator=(const char* value);
    template<int N>
    RscVariant& operator=(const RscString<N>& value);
    template<int N>
    RscVariant& operator=(const SecureString<N>& value);
    RscVariant& operator=(const RscVariant& value) = default;
    RscVariant& operator=(RscVariant&&) = default;
    bool operator==(const RscVariant& value)const;
    bool operator!=(const RscVariant& value)const;

public: // getter/setter
    RscType     GetType(void)const;

    RscType     GetValueType(void)const;

    RscType     GetArrayElementType(void)const;

    size_t     GetArrayDimensions(void)const;

    size_t GetFieldCount(void) const;

    const char* GetChars(void)const;

    void        SetWriteElementFunction(WriteElementFunction* pFunction) const;

    const byte* GetDataAddress(void)const;

    byte*       GetDataAddress(void);

    void        SetType(RscType rscType);

public: // operations
    template<class T>
    T       GetValue(void)const;

    template<class T>
    void    CopyTo(T& value)const;

    String  ToString(void)const;

private: // Setter/Getter for internal use and friend classes
    RscArrayInformation&        GetArrayInformation(void);
    const RscArrayInformation&  GetArrayInformation(void) const;
    RscStructInformation&       GetStructInformation(void);
    const RscStructInformation& GetStructInformation(void) const;

private: // methods
    void    Assign(const char*, size_t len, RscType type = RscType::Utf8String);
    void    InitComplexTypeInfo(void);
    bool    ContainsTypeInformation(void) const;
    size_t  GetSize(void)const;

private: // nested types
    struct ComplexTypeInfo
    {
        union
        {
            RscArrayInformation  arrayInformation;
            RscStructInformation structInformation;
        };
        RemotingReader*                     pReader = nullptr;
        mutable RemotingWriter*             pWriter = nullptr;
        ReadElementFunction*                pReadElementFunction = nullptr;
        mutable WriteElementFunction*       pWriteElementFunction = nullptr;
    };

private: // static fields
    static const size_t maxPrimitiveSize = 8;
#ifdef ARP_SYSTEM_RSC_SUPPORT_VERSION_GUID_AS_OBJECT
    static const size_t minBufferSize = std::max(maxPrimitiveSize, std::max(sizeof(RscGuid), sizeof(RscVersion)));
#else
    static const size_t minBufferSize = maxPrimitiveSize;
#endif // ARP_SYSTEM_RSC_SUPPORT_VERSION_GUID_AS_OBJECT

    static const size_t bufferSize = minBufferSize < (size_t)MaxStringSize ? (size_t)MaxStringSize : minBufferSize;

private: // fields
    union
    {
        ComplexTypeInfo  typeInfo;
        byte             buffer[bufferSize];
    };
    RscType type = RscType::None;
};


// inline methods of RscType helper
template<int N>
inline constexpr RscType GetRscTypeFrom(const RscVariant<N>& /*value*/)
{
    return RscType::Object;
}

// inline methods of class RscVariant

template<int MaxStringSize>
inline RscVariant<MaxStringSize>::RscVariant(RscType typeArg)
    : type(typeArg)
{
}

template<int MaxStringSize>
template<class T>
inline RscVariant<MaxStringSize>::RscVariant(const T& value)
{
    this->operator=(value);
}

template<int MaxStringSize>
inline RscVariant<MaxStringSize>::RscVariant(const String& value)
    : type(RscType::Utf8String)
{
    this->operator=(value);
}

template<int MaxStringSize>
inline RscVariant<MaxStringSize>::RscVariant(const char* value)
{
    this->operator=(value);
}

template<int MaxStringSize>
template<int N>
inline RscVariant<MaxStringSize>::RscVariant(const RscString<N>& value)
{
    this->operator=(value);
}

template<int MaxStringSize>
template<int N>
inline RscVariant<MaxStringSize>::RscVariant(const SecureString<N>& value)
{
    this->operator=(value);
}

template<int MaxStringSize>
inline RscVariant<MaxStringSize>::RscVariant(size_t arraySize, RscType arrayElementType, size_t dimensions, size_t fieldCount)
    : type(RscType::Array)
{
    if(arrayElementType == RscType::Struct && fieldCount == 0)
    {
        throw ArgumentException::Create("fieldCount", fieldCount, "fieldCount has to be set for struct element types");
    }
    this->GetArrayInformation() = RscArrayInformation(arraySize, arrayElementType, dimensions, fieldCount);
    this->typeInfo.pReader = nullptr;
    this->typeInfo.pWriter = nullptr;
    this->typeInfo.pReadElementFunction = nullptr;
    this->typeInfo.pWriteElementFunction = nullptr;
}

template<int MaxStringSize>
inline RscVariant<MaxStringSize>::RscVariant(size_t arraySize, RscType arrayElementType, ReadElementFunction* pFunction, size_t dimensions, size_t fieldCount)
    : type(RscType::Array)
{
    if(arrayElementType == RscType::Struct && fieldCount == 0)
    {
        throw ArgumentException::Create("fieldCount", fieldCount, "fieldCount has to be set for struct element types");
    }
    this->GetArrayInformation() = RscArrayInformation(arraySize, arrayElementType, dimensions, fieldCount);
    this->typeInfo.pReader = nullptr;
    this->typeInfo.pWriter = nullptr;
    this->typeInfo.pReadElementFunction = pFunction;
    this->typeInfo.pWriteElementFunction = nullptr;
}

template<int MaxStringSize>
inline RscVariant<MaxStringSize>::RscVariant(size_t arraySize, RscType arrayElementType, WriteElementFunction* pFunction, size_t dimensions, size_t fieldCount)
    : type(RscType::Array)
{
    if(arrayElementType == RscType::Struct && fieldCount == 0)
    {
        throw ArgumentException::Create("fieldCount", fieldCount, "fieldCount has to be set for struct element types");
    }
    this->GetArrayInformation() = RscArrayInformation(arraySize, arrayElementType, dimensions, fieldCount);
    this->typeInfo.pReader = nullptr;
    this->typeInfo.pWriter = nullptr;
    this->typeInfo.pReadElementFunction = nullptr;
    this->typeInfo.pWriteElementFunction = pFunction;
}

template<int MaxStringSize>
inline RscVariant<MaxStringSize>::RscVariant(size_t fieldCount, ReadElementFunction* pFunction)
    : type(RscType::Struct)
{
    this->InitComplexTypeInfo();
    this->GetStructInformation() = RscStructInformation(fieldCount);
    this->typeInfo.pReadElementFunction = pFunction;
}

template<int MaxStringSize>
inline RscType RscVariant<MaxStringSize>::GetType()const
{
    return this->type;
}

template<int MaxStringSize>
inline RscType RscVariant<MaxStringSize>::GetValueType()const
{
    switch (this->type)
    {
        case RscType::IecTime:
            return RscType::Int32;
        case RscType::IecTime64:
        case RscType::IecDate64:
        case RscType::IecDateTime64:
        case RscType::IecTimeOfDay64:
            return RscType::Int64;
        default:
            // no mapping
            return this->type;
    }
}

template<int MaxStringSize>
inline RscType RscVariant<MaxStringSize>::GetArrayElementType()const
{
    return this->GetArrayInformation().ElementType;
}

template<int MaxStringSize>
inline const RscArrayInformation& RscVariant<MaxStringSize>::GetArrayInformation(void) const
{
    if(this->GetType() != RscType::Array)
    {
        throw InvalidOperationException("RscVariant doesn't contain array information");
    }
    return this->typeInfo.arrayInformation;
}

template<int MaxStringSize>
inline RscArrayInformation& RscVariant<MaxStringSize>::GetArrayInformation(void)
{
    if(this->GetType() != RscType::Array)
    {
        throw InvalidOperationException("RscVariant doesn't contain array information");
    }
    return this->typeInfo.arrayInformation;
}

template<int MaxStringSize>
inline const RscStructInformation& RscVariant<MaxStringSize>::GetStructInformation(void) const
{
    if(this->GetType() != RscType::Struct)
    {
        throw InvalidOperationException("RscVariant doesn't contain struct information");
    }
    return this->typeInfo.structInformation;
}

template<int MaxStringSize>
inline RscStructInformation& RscVariant<MaxStringSize>::GetStructInformation(void)
{
    if(this->GetType() != RscType::Struct)
    {
        throw InvalidOperationException("RscVariant doesn't contain struct information");
    }
    return this->typeInfo.structInformation;
}

template<int MaxStringSize>
inline size_t RscVariant<MaxStringSize>::GetArrayDimensions(void) const
{
    return this->GetArrayInformation().Dimensions;
}

template<int MaxStringSize>
inline size_t RscVariant<MaxStringSize>::GetFieldCount(void) const
{
    return this->GetStructInformation().FieldCount;
}

template<int MaxStringSize>
inline byte* RscVariant<MaxStringSize>::GetDataAddress()
{
    return this->buffer;
}

template<int MaxStringSize>
inline const byte* RscVariant<MaxStringSize>::GetDataAddress()const
{
    return this->buffer;
}

template<int MaxStringSize>
inline void RscVariant<MaxStringSize>::SetType(RscType rscType)
{
    this->type = rscType;
}

template<int MaxStringSize>
inline bool RscVariant<MaxStringSize>::ContainsTypeInformation(void) const
{
    return (this->type == RscType::Struct || this->type == RscType::Array);
}

template<int MaxStringSize>
template<class T>
inline RscVariant<MaxStringSize>& RscVariant<MaxStringSize>::operator=(const T& value)
{
    this->type = GetRscType<T>();
    if(this->type == RscType::None)
    {
        throw NotSupportedException("Cannot assign from argument: Type of argument is not supported");
    }
#ifndef ARP_SYSTEM_RSC_SUPPORT_VERSION_GUID_AS_OBJECT
    if (this->type == RscType::Version || this->type == RscType::Guid)
    {
        throw NotImplementedException("Type RscVersion and RscGuid are currently not supported by RscVariant");
    }
#endif // ARP_SYSTEM_RSC_SUPPORT_VERSION_GUID_AS_OBJECT
*reinterpret_cast<T*>(this->buffer) = value;
return *this;
}

template<int MaxStringSize>
inline RscVariant<MaxStringSize> RscVariant<MaxStringSize>::CreateStructVariant(size_t fieldCount)
{
    RscVariant<MaxStringSize> result(RscType::Struct);
    result.InitComplexTypeInfo();
    result.GetStructInformation().FieldCount = fieldCount;
    return result;
}

template<int MaxStringSize>
inline RscVariant<MaxStringSize> RscVariant<MaxStringSize>::CreateArrayVariant(size_t arraySize, RscType elementType, size_t dimensions, size_t fieldCount)
{
    RscVariant<MaxStringSize> result(arraySize, elementType, dimensions, fieldCount);
    return result;
}

template<int MaxStringSize>
inline RscVariant<MaxStringSize> RscVariant<MaxStringSize>::CreateStructVariant(size_t fieldCount, RemotingWriter& writer)
{
    RscVariant<MaxStringSize> result = RscVariant<MaxStringSize>::CreateStructVariant(fieldCount);
    result.typeInfo.pWriter = &writer;
    return result;
}

template<int MaxStringSize>
inline RscVariant<MaxStringSize> RscVariant<MaxStringSize>::CreateArrayVariant(size_t arraySize, RscType elementType, RemotingWriter& writer, size_t dimensions, size_t fieldCount)
{
    RscVariant<MaxStringSize> result(arraySize, elementType, dimensions, fieldCount);
    result.typeInfo.pWriter = &writer;
    return result;
}

template<int MaxStringSize>
inline RscVariant<MaxStringSize>& RscVariant<MaxStringSize>::operator=(const String& value)
{
    size_t len = value.Length();
    this->Assign(value.CStr(), len);
    return *this;
}

template<int MaxStringSize>
inline RscVariant<MaxStringSize>& RscVariant<MaxStringSize>::operator=(const char* value)
{
    size_t len = strlen(value);
    this->Assign(value, len);
    return *this;
}

template<int MaxStringSize>
template<int N>
inline RscVariant<MaxStringSize>& RscVariant<MaxStringSize>::operator=(const RscString<N>& value)
{
    this->Assign(value.CStr(), strlen(value.CStr()), RscType::Utf8String);
    return *this;
}

template<int MaxStringSize>
template<int N>
inline RscVariant<MaxStringSize>& RscVariant<MaxStringSize>::operator=(const SecureString<N>& value)
{
    this->Assign(value.CStr(), strlen(value.CStr()), RscType::SecureString);
    return *this;
}

template<int MaxStringSize>
inline void RscVariant<MaxStringSize>::Assign(const char* value, size_t len, RscType typeArg)
{
    if (len >= MaxStringSize)
    {
        throw ArgumentException("Cannot copy string: argument string length {0} exceeds MaxStringSize {1}", len, MaxStringSize);
    }
    if (typeArg != RscType::Utf8String && typeArg != RscType::SecureString)
    {
        throw NotSupportedException("RscType '{0}' not supported", typeArg);
    }
    memcpy(this->buffer, value, len);
    this->buffer[len] = '\0';
    this->type = typeArg;
}

template<int MaxStringSize>
inline bool RscVariant<MaxStringSize>::operator==(const RscVariant& value)const
{
    if (this->GetType() != value.GetType())
    {
        return false;
    }

    if (this->GetSize() != value.GetSize())
    {
        return false;
    }

    if (memcmp(this->buffer, value.buffer, this->GetSize()) != 0)
    {
        return false;
    }

    if (this->GetType() == RscType::Utf8String)
    {
        if (strcmp((char*)this->buffer, (char*)value.buffer) != 0)
        {
            return false;
        }
    }

    return true;
}

template<int MaxStringSize>
inline bool RscVariant<MaxStringSize>::operator!=(const RscVariant& value)const
{
    return !(*this == value);
}

template<int MaxStringSize>
inline void RscVariant<MaxStringSize>::InitComplexTypeInfo(void)
{
    // needed, because elements of union are not initialized
    this->typeInfo.pReader               = nullptr;
    this->typeInfo.pWriter               = nullptr;
    this->typeInfo.pReadElementFunction  = nullptr;
    this->typeInfo.pWriteElementFunction = nullptr;
}

template<int MaxStringSize>
template<class T>
inline void RscVariant<MaxStringSize>::CopyTo(T& value) const
{
    RscType argType = GetRscType<T>();
    if(this->GetValueType() != argType)
    {
        throw InvalidCastException("Cannot copy value to argument: RscVariant contains data type {0} but arg is of type {1}", this->type, argType);
    }
    value = *reinterpret_cast<const T*>(this->buffer);
}

template<int MaxStringSize>
inline const char* RscVariant<MaxStringSize>::GetChars() const
{
    if (this->type != RscType::Utf8String && this->type != RscType::SecureString && this->type != RscType::AnsiString)
    {
        throw InvalidCastException("Cannot convert to string: RscVariant is of type {0}", this->type);
    }
    return reinterpret_cast<const char*>(this->buffer);
}

template<int MaxStringSize>
inline void RscVariant<MaxStringSize>::SetWriteElementFunction(WriteElementFunction * pFunction) const
{
    if(this->type != RscType::Array && this->type != RscType::Struct)
    {
        throw InvalidOperationException("Method only allowed for array and struct objects");
    }
    this->typeInfo.pWriteElementFunction = pFunction;
}

template<int MaxStringSize>
template<class T>
inline T RscVariant<MaxStringSize>::GetValue()const
{
    T result;
    this->CopyTo(result);
    return result;
}

template<int MaxStringSize>
inline String RscVariant<MaxStringSize>::ToString()const
{
    const byte* pValue = this->GetDataAddress();

    switch (this->type)
    {
        case RscType::SecureString:
        case RscType::AnsiString:
        case RscType::Utf8String:
            return reinterpret_cast<const char*>(pValue);
        case RscType::DateTime:
            throw NotImplementedException("RscVariant::ToString() not yet implemented for type '{0}'", type);
        case RscType::Bool:
            return std::to_string(*reinterpret_cast<const bool*>(pValue));
        case RscType::Char:
            return std::to_string(*reinterpret_cast<const char16*>(pValue));
        case RscType::Int16:
            return std::to_string(*reinterpret_cast<const int16*>(pValue));
        case RscType::Int32:
        case RscType::IecTime:
            return std::to_string(*reinterpret_cast<const int32*>(pValue));
        case RscType::Int8:
            return std::to_string(*reinterpret_cast<const int8*>(pValue));
        case RscType::Int64:
        case RscType::IecTime64:
        case RscType::IecDate64:
        case RscType::IecDateTime64:
        case RscType::IecTimeOfDay64:
            return std::to_string(*reinterpret_cast<const int64*>(pValue));
        case RscType::None:
        case RscType::Null:
            return String::Empty;
        case RscType::Real32:
            return std::to_string(*reinterpret_cast<const float*>(pValue));
        case RscType::Real64:
            return std::to_string(*reinterpret_cast<const double*>(pValue));
        case RscType::Uint16:
            return std::to_string(*reinterpret_cast<const uint16*>(pValue));
        case RscType::Uint32:
            return std::to_string(*reinterpret_cast<const uint32*>(pValue));
        case RscType::Uint64:
            return std::to_string(*reinterpret_cast<const uint64*>(pValue));
        case RscType::Uint8:
            return std::to_string(*reinterpret_cast<const uint8*>(pValue));
        case RscType::Version:
            return reinterpret_cast<const RscVersion*>(pValue)->ToString();
        case RscType::Guid:
            return reinterpret_cast<const RscGuid*>(pValue)->ToString();
        case RscType::Void:
            return String::Empty;
        default:
            // case RscType::Array:
            throw NotSupportedException("RscVariant::ToString() not supported for type '{0}'", type);
    }
}

template<int MaxStringSize>
inline size_t RscVariant<MaxStringSize>::GetSize(void)const
{
    switch (this->GetValueType())
    {
    case RscType::Void:
        return 0;
        break;
    case RscType::Bool:
    case RscType::Int8:
    case RscType::Uint8:
        return 1;
        break;
    case RscType::Char:
    case RscType::Int16:
    case RscType::Uint16:
        return 2;
        break;
    case RscType::Int32:
    case RscType::Uint32:
    case RscType::Real32:
    case RscType::IecTime:
        return 4;
        break;
    case RscType::Int64:
    case RscType::Uint64:
    case RscType::Real64:
    case RscType::DateTime:
    case RscType::IecTime64:
    case RscType::IecDate64:
    case RscType::IecDateTime64:
    case RscType::IecTimeOfDay64:
        return 8;
        break;
    case RscType::Utf8String:
        return strlen((char*)this->buffer);
        break;
    case RscType::Array:
    {
        return sizeof(RscArrayInformation);
        break;
    }
    case RscType::Struct:
    {
        return sizeof(RscStructInformation);
        break;
    }
    case RscType::SecureString:
    default:
        throw NotSupportedException("RscType {0} not supported.", this->GetValueType());
    }
}

}}}} // end of namespace Arp::System::Rsc::Services