RscVariant.hxx

 
//
//  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/RscGuid.hpp"
#include "Arp/Base/Rsc/Commons/RscString.hxx"
#include "Arp/Base/Rsc/Commons/RscVersion.hpp"
#include "Arp/Base/Rsc/Commons/RscTypeInfo.hpp"
#include "Arp/Base/Rsc/Commons/RscSecureString.hxx"
#include "Arp/Base/Rsc/Commons/RscVariantBase.hpp"
#include "Arp/Base/Rsc/Commons/RscTypeDeduction.hpp"
 
namespace Arp::Base::Rsc::Commons
{
 
template<int N = 0>
class RscVariant : public RscVariantBase
{
    friend class Arp::Base::Rsc::Commons::Internal::RscVariantAccessor;
 
public: // construction
    RscVariant(void);
    RscVariant(RscType type); // no explicit here, is used by unit tests heavily
    explicit RscVariant(const String& value);
    explicit RscVariant(const char* value);
    explicit RscVariant(const char8u* value);
    explicit RscVariant(const char16* input, size_t length);
 
    template<int M>     explicit RscVariant(const RscString<M>& value);
    template<int M>     explicit RscVariant(const RscSecureString<M>& value);
    template<int M>     explicit RscVariant(const char value[M]);
    template<int M>     explicit RscVariant(char value[M]);
    template<class T>   explicit RscVariant(const T& value);
 
    // canonical construction/destruction/assignment
    RscVariant(const RscVariant& arg);
    RscVariant(RscVariant&& arg)noexcept;
    RscVariant& operator=(const RscVariant& arg);
    RscVariant& operator=(RscVariant&& arg)noexcept;
    ~RscVariant(void);
 
public: // assign operators
    RscVariant& operator=(const String& value);
    RscVariant& operator=(const char* value);
    RscVariant& operator=(const char8u* value);
 
    template<class T>   RscVariant& operator=(const T& value);
    template<int M>     RscVariant& operator=(const RscString<M>& value);
    template<int M>     RscVariant& operator=(const RscSecureString<M>& value);
 
private: // construction
    RscVariant(size_t arraySize, RscType elementType, size_t dimensions = 1, size_t fieldCount = 0);
    RscVariant(size_t arraySize, RscType elementType, RscWriter& writer, size_t dimensions, size_t fieldCount);
    RscVariant(size_t arraySize, RscType elementType, ReadElementFunction& function, size_t dimensions = 1, size_t fieldCount = 0);
    RscVariant(size_t arraySize, RscType elementType, WriteElementFunction& function, size_t dimensions = 1, size_t fieldCount = 0);
    RscVariant(size_t fieldCount, ReadElementFunction& function);
    RscVariant(size_t fieldCount, WriteElementFunction& function);
    RscVariant(size_t fieldCount, RscReader& reader);
    RscVariant(size_t fieldCount, RscWriter& writer);
    RscVariant(const RscStructInfo& info);
 
public: // Static factory operations
    static RscVariant CreateStructVariant(size_t fieldCount);
    static RscVariant CreateStructVariant(size_t fieldCount, ReadElementFunction& readFunction);
    static RscVariant CreateStructVariant(size_t fieldCount, WriteElementFunction& writeFunction);
    static RscVariant CreateArrayVariant(size_t arraySize, RscType elementType, size_t dimensions = 1, size_t fieldCount = 0);
    static RscVariant CreateArrayVariant(size_t arraySize, RscType elementType, ReadElementFunction& readFunction, size_t dimensions = 1, size_t fieldCount = 0);
    static RscVariant CreateArrayVariant(size_t arraySize, RscType elementType, WriteElementFunction& writeFunction, size_t dimensions = 1, size_t fieldCount = 0);
 
public: // global friend operators (shall be defined implicit inline due to EXPORT on Windows)
 
    friend std::ostream& operator<<(std::ostream& os, const RscVariant& arg)
    {
        os << arg.ToString();
        return os;
    }
 
private: // Static factory operations
    static RscVariant CreateStructVariant(size_t fieldCount, RscReader& reader);
    static RscVariant CreateStructVariant(size_t fieldCount, RscWriter& writer);
    static RscVariant CreateArrayVariant(size_t arraySize, RscType elementType, RscWriter& writer, size_t dimensions = 1, size_t fieldCount = 0);
 
public: // compare operators
    bool operator==(const RscVariant& arg)const;
    bool operator!=(const RscVariant& arg)const;
 
private: // static/const fields
    static const size_t maxPrimitiveSize    = 8;
    static const size_t maxStringSize       = static_cast<size_t>(N);
    static const size_t stringBufferSize    = static_cast<size_t>(N + 1);
    static const size_t minBufferSize       = std::max(maxPrimitiveSize, std::max(sizeof(String), std::max(sizeof(RscGuid), sizeof(RscVersion))));
    static const size_t bufferSize          = std::max(minBufferSize, stringBufferSize);
 
private: // fields
    std::array<byte, bufferSize> buffer{};
};
 
} // end of namespace Arp::Base::Rsc::Commons
 
// include inline code of RscVariant
#include "Arp/Base/Rsc/Commons/RscVariant.ipp"