RscVariantBase.hpp

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
#pragma once
#include "Arp/Base/Core/Arp.hpp"
#include "Arp/Base/Rsc/Commons/Rsc.hpp"
#include "Arp/Base/Rsc/Commons/RscType.hpp"
#include "Arp/Base/Rsc/Commons/RscTypeDeduction.hpp"
#include "Arp/Base/Rsc/Commons/RscArrayInfo.hpp"
#include "Arp/Base/Rsc/Commons/RscStructInfo.hpp"
#include "Arp/Base/Commons/Exceptions/InvalidCastException.hpp"
#include "Arp/Base/Commons/Exceptions/NotSupportedException.hpp"
 
// forwards
namespace Arp::Base::Rsc::Commons::Internal
{
class RscVariantAccessor;
}
 
namespace Arp::Base::Rsc::Commons
{
 
// forwards
class RscStringBase;
 
// type imports
using Arp::Base::Rsc::Commons::Services::RscReader;
using Arp::Base::Rsc::Commons::Services::RscWriter;
 
 
class ARP_EXPORT RscVariantBase
{
    friend class Arp::Base::Rsc::Commons::Internal::RscVariantAccessor;
 
public: // usings
    using ReadFieldFunction     = std::function<void(RscType fieldType, RscVariantBase& value)>;        
    using WriteFieldFunction    = std::function<void(RscType fieldType, const RscVariantBase& value)>;  
    using ReadElementFunction   = std::function<void(RscType elementType, RscVariantBase& value)>;      
    using WriteElementFunction  = std::function<void(RscType elementType, const RscVariantBase& value)>;
 
public: // construction
    RscVariantBase(RscType type = RscType::None);
    RscVariantBase(RscType type, byte* pBuffer);
    RscVariantBase(RscType type, char* pBuffer, size_t bufferSize);
    RscVariantBase(const RscStringBase& data);
    RscVariantBase(const RscArrayInfo& arrayInfo);
    RscVariantBase(const RscStructInfo& structInfo);
 
    // canonical construction/destruction/assignment
    RscVariantBase(const RscVariantBase& arg);
    RscVariantBase(RscVariantBase&& arg)noexcept;
    RscVariantBase& operator=(const RscVariantBase& arg);
    RscVariantBase& operator=(RscVariantBase&& arg)noexcept;
    ~RscVariantBase(void);
 
public: // assign operators
    RscVariantBase& operator=(const String& value);
    RscVariantBase& operator=(const char* value);
    RscVariantBase& operator=(const char8u* value);
 
    template<class T>   RscVariantBase& operator=(const T& value);
    template<int N>     RscVariantBase& operator=(const RscString<N>& value);
    template<int N>     RscVariantBase& operator=(const RscSecureString<N>& value);
 
public: // setter/getter operations
    void        SetType(RscType value);
    RscType     GetType(void)const;
    RscType     GetValueType(void)const;
    bool        IsComplexType(void)const;
    bool        IsArray(void)const;
    bool        IsStruct(void)const;
    bool        IsFormattable(void)const;
    size_t      GetDataSize(void)const;
    size_t      GetMaxStringSize(void)const;
    size_t      GetBufferSize(void)const;
    RscType     GetArrayElementType(void)const;
    size_t      GetArraySize(void)const;
    size_t      GetArrayDimensions(void)const;
    size_t      GetArrayFieldCount(void)const;
    size_t      GetFieldCount(void) const;
    byte*       GetDataAddress(void);
    const byte* GetDataAddress(void)const;
    const char* GetChars(void)const;
 
public: // operations
    void        Assign(const char* input, RscType rscType = RscType::String);
    void        Assign(const char* input, size_t length, RscType rscType = RscType::String);
    void        Assign(const char16* input, size_t length);
    void        Assign(const String& value);
    void        CopyTo(String& value)const;
    String      ToString(void)const;
    void        Clear(bool clearBuffer = false);
    bool        Equals(const RscVariantBase& arg)const;
 
public: // RSC operations
    void Read(RscReader& reader, bool omitTag);
    void Write(RscWriter& writer, bool omitTag)const;
 
public: // type-info operations
    bool                    HasArrayInfo(void)const;
    void                    SetArrayInfo(const RscArrayInfo& arrayInfo);
    void                    SetArrayInfo(size_t size, RscType elementType = RscType::None, size_t dimensions = 1, size_t fieldCount = 0);
    RscArrayInfo&           GetArrayInfo(void);
    const RscArrayInfo&     GetArrayInfo(void)const;
    bool                    HasStructInfo(void)const;
    void                    SetStructInfo(size_t fieldCount);
    RscStructInfo&          GetStructInfo(void);
    const RscStructInfo&    GetStructInfo(void)const;
    bool                    HasReadElementFunction(void)const;
    ReadElementFunction     GetReadElementFunction(void)const;
    void                    SetReadElementFunction(ReadElementFunction& function);
    bool                    HasWriteElementFunction(void)const;
    WriteElementFunction    GetWriteElementFunction(void)const;
    void                    SetWriteElementFunction(WriteElementFunction& function)const;
    void                    ResetComplexTypeInfo(void);
 
public: // template operations
    template<int N>   void      Assign(char value[N]);
    template<int N>   void      Assign(const char value[N]);
    template<int N>   void      Assign(const RscString<N>& value);
    template<int N>   void      Assign(const RscSecureString<N>& value);
    template<class T> void      Assign(const T& value);
    template<class T> void      CopyTo(T& value)const;
    template<class T> T         GetValue(void)const;
    template<class T> T*        GetValueAddress(void);
    template<class T> const T*  GetValueAddress(void)const;
 
protected: // methods accessible by RscVariantAccessor and derived class RscVariant<N>
    void        SetBufferInfo(byte* pDataBuffer, size_t dataBufferSize, bool isDynamicString);
    bool        HasReader(void)const;
    bool        HasWriter(void)const;
    void        SetReader(RscReader& reader);
    void        SetWriter(RscWriter& writer)const;
    RscReader*  GetReader(void)const;
    RscWriter*  GetWriter(void)const;
 
private: // methods
    bool            ProvidesDynamicString(void)const;
    String&         GetDynamicString(void);
    const String&   GetDynamicString(void)const;
 
private: // static methods
    static size_t   DetermineBufferSize(RscType type);
 
private: // nested types
    struct ComplexTypeInfo
    {
        friend class RscVariantBase;
 
    private: // nested types
        struct ComplexVariantInfo
        {
            RscArrayInfo    arrayInfo{};    
            RscStructInfo   structInfo{};   
        };
        ComplexVariantInfo              complexVariantInfo{};           
        RscReader*                      pReader = nullptr;              
        mutable RscWriter*              pWriter = nullptr;              
        ReadElementFunction*            pReadElementFunction = nullptr; 
        mutable WriteElementFunction*   pWriteElementFunction = nullptr;
    };
 
protected: // fields
    RscType         type = RscType::None;           
    byte*           pBuffer = nullptr;              
    size_t          bufferSize = 0;                 
    bool            providesDynamicString = false;  
    String          dynamicString;                  
    ComplexTypeInfo typeInfo;                       
};
 
// inline methods of class RscVariantBase
 
template<int N>
inline void RscVariantBase::Assign(char value[N])
{
    this->Assign(value, 0);
}
 
template<int N>
inline void RscVariantBase::Assign(const char value[N])
{
    this->Assign(value, 0);
}
 
template<int N>
inline void RscVariantBase::Assign(const RscString<N>& value)
{
    this->Assign(value.CStr(), value.GetLength());
}
 
template<int N>
inline void RscVariantBase::Assign(const RscSecureString<N>& value)
{
    this->Assign(value.CStr(), value.GetLength(), RscType::SecureString);
}
 
template<class T>
inline void RscVariantBase::Assign(const T& value)
{
    RscType rscType = RscTypeDeduction::GetFrom(value);
    if (rscType == RscType::None)
    {
        throw NotSupportedException("RscVariant does not support type '{}'.", TypeName<T>());
    }
    // else
    if constexpr (std::is_trivially_copy_assignable_v<T>&& (alignof(T) > alignof(RscVariantBase)))
    {
        std::memcpy(GetValueAddress<T>(), std::addressof(value), sizeof(T));
    }
    else
    {
        *this->GetValueAddress<T>() = value;
    }
    this->SetType(rscType);
}
 
template<class T>
inline T RscVariantBase::GetValue()const
{
    T result;
    this->CopyTo(result);
    return result;
}
 
template<class T>
inline T* RscVariantBase::GetValueAddress()
{
    return reinterpret_cast<T*>(this->pBuffer);
}
 
template<class T>
inline const T* RscVariantBase::GetValueAddress()const
{
    return reinterpret_cast<const T*>(this->pBuffer);
}
 
template<class T>
inline void RscVariantBase::CopyTo(T& value)const
{
    RscType argType = RscTypeDeduction::GetFrom(value);
    if (this->GetValueType() != argType)
    {
        throw InvalidCastException("Cannot copy value to argument: RscVariant contains data type {0} but arg is of type {1}", this->GetType(), argType);
    }
    if constexpr (std::is_trivially_copy_assignable_v<T>&& (alignof(T) > alignof(RscVariantBase)))
    {
        std::memcpy(std::addressof(value), this->GetValueAddress<T>(), sizeof(T));
    }
    else
    {
        value = *this->GetValueAddress<T>();
    }
}
 
template<class T>
inline RscVariantBase& RscVariantBase::operator=(const T& value)
{
    this->Assign(value);
    return *this;
}
 
template<int N>
inline RscVariantBase& RscVariantBase::operator=(const RscString<N>& value)
{
    this->Assign(value.CStr(), value.GetLength());
    return *this;
}
 
template<int N>
inline RscVariantBase& RscVariantBase::operator=(const RscSecureString<N>& value)
{
    this->Assign(value.CStr(), value.GetLength());
    return *this;
}
 
} // end of namespace Arp::Base::Rsc::Commons