RscVariant.hxx

 
//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Commons/Exceptions/Exceptions.h"
#include "Arp/System/Commons/Encoding/Utf16.hpp"
#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>
#include <sstream>
#include <iomanip>
 
namespace Arp { namespace System { namespace Rsc { namespace Services
{
 
// 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);
 
    RscVariant(const char16* input, size_t length, RscType type = RscType::Utf8String);
 
    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&&)noexcept = 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&&)noexcept = 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;
 
    void    Assign(const char16 * input, size_t length, RscType rscType = RscType::Utf8String);
 
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* input, size_t length, RscType rscType = 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>
inline RscVariant<MaxStringSize>::RscVariant(const char16* input, size_t length, RscType type)
{
    this->Assign(input, length, type);
}
 
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 = std::char_traits<char>::length(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(), SecureStrnlen(value.CStr(), N), 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* input, size_t length, RscType rscType)
{
    if (length >= MaxStringSize)
    {
        throw ArgumentException("Cannot copy string: argument string length {} exceeds MaxStringSize {}", length, MaxStringSize);
    }
    if (rscType != RscType::Utf8String && rscType != RscType::SecureString)
    {
        throw NotSupportedException("RscType '{}' not supported for Strings", rscType);
    }
    SecureStrncpy(reinterpret_cast<char*>(this->buffer), MaxStringSize, input, length);
    this->buffer[length] = static_cast<byte>(0);
    this->type = rscType;
}
 
template<int MaxStringSize>
inline void RscVariant<MaxStringSize>::Assign(const char16* input, size_t length, RscType rscType)
{
    using Arp::System::Commons::Encoding::Utf16;
    using Arp::System::Commons::Encoding::EncodingResult;
 
    if (rscType != RscType::Utf8String)
    {
        throw NotSupportedException("RscType '{}' not supported for UTF16 strings", rscType);
    }
    this->type = rscType;
    size_t resultLength = 0;
    EncodingResult result = Utf16::ConvertToUtf8(input, length, reinterpret_cast<char*>(this->buffer), MaxStringSize - 1, resultLength);
    if ((result != EncodingResult::Success) && (result != EncodingResult::NoConversion))
    {
        throw ArgumentException("Cannot convert UTF16 string, encoding result = {}", result);
    }
    this->buffer[resultLength] = 0_b;
}
 
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:
            return reinterpret_cast<const DateTime*>(pValue)->ToIso8601String();
        case RscType::Bool:
        {
            std::ostringstream oss;
            oss << std::boolalpha << *reinterpret_cast<const bool*>(pValue);
            if (oss.fail())
            {
                throw InvalidOperationException("Value of RscVariant is not of type bool.");
            }
            return oss.str();
        }
        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