RscWriter.hpp

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
#pragma once
#include "Arp/Base/Core/Arp.hpp"
#include "Arp/Base/Core/PimplPtr.hxx"
#include "Arp/Base/Core/Enum.hxx"
#include "Arp/Base/Commons/Io/Stream.hpp"
#include "Arp/Base/Rsc/Commons/Rsc.hpp"
#include "Arp/Base/Rsc/Commons/RscString.hxx"
#include "Arp/Base/Rsc/Commons/RscVariant.hxx"
#include "Arp/Base/Rsc/Commons/RscStream.hpp"
#include "Arp/Base/Rsc/Commons/RscStreamWriter.hpp"
#include "Arp/Base/Rsc/Commons/RscException.hpp"
#include "Arp/Base/Rsc/Commons/RscTypeInfo.hpp"
#include "Arp/Base/Rsc/Commons/RscTypeDeduction.hpp"
#include "Arp/Base/Rsc/Commons/Services/StructInfo.hxx"
#include "Arp/Base/Rsc/Commons/Services/RscConcepts.hpp"
#include <array>
#include <vector>
 
namespace Arp::Base::Rsc::Commons::Services
{
 
using Arp::Base::Commons::Io::Stream;
 
class ARP_EXPORT RscWriter
{
public: // Impl forward declaration
    class Impl;
 
public: // construction
    explicit RscWriter(Stream& remoteStream);
 
    // canonical construction/destruction/assignment
    RscWriter(const RscWriter& arg);
    RscWriter(RscWriter&& arg)noexcept;
    RscWriter& operator=(const RscWriter& arg);
    RscWriter& operator=(RscWriter&& arg)noexcept;
    ~RscWriter(void);
 
public: // setter/getter operations
    RscStream       GetStream(void);
    RscStreamWriter GetStreamWriter(void);
 
public: // concrete operations used by RscGenerator
    void    Write(const RscPtr& value, bool omitTag = false);
    void    Write(const RscConstPtr& value, bool omitTag = false);
    void    Write(const String& value, bool omitTag = false);
    void    Write(const DateTime& value, bool omitTag = false);
    void    Write(const SecurityToken& value, bool omitTag = false);
    void    Write(RscStream stream, bool omitTag = false);
    void    Write(RscVariantBase& result, bool omitTag = false);
 
public: // generic operations used by RscGenerator
    template<RscEnumType T>         void    Write(const T& value, bool omitTag = false);
    template<RscPrimitiveType T>    void    Write(const T& value, bool omitTag = false);
    template<RscClassType T>        void    Write(const T& value, bool omitTag = false);
    template<RscSerializableType T> void    Write(const T& value, bool omitTag = false);
    template<int N>                 void    Write(const RscVariant<N>& result, bool omitTag = false);
    template<class T>               void    Write(const std::vector<T>& data, bool omitTag = false);
    template<class T>               void    Write(const std::vector<std::vector<T>>& data, bool omitTag = false);
    template<class T, size_t N>     void    Write(const std::array<T, N>& data, bool omitTag = false);
 
public: // auxiliaries operations
    void    WriteTag(RscType tag);
    void    WriteFieldCount(size_t fieldCount);
    void    WriteArrayLength(size_t arraySize);
    void    WriteStructInfo(size_t fieldCount);
    void    WriteEnumeratorTag(RscType tag);
    void    WriteConfirmation(bool flush = false);
 
private: // methods
    template<class T>
    void    WriteBeginArray(size_t arraySize, RscType& elementType, bool omitTag = false);
    void    WritePrimitive(const byte* pValue, RscType type);
    void    Write(const RscVariantBase& value, bool omitTag = false);
 
public: // internal operations
    Impl&       GetImpl(void);
    const Impl& GetImpl(void)const;
 
private: // Impl usings
    using Pimpl = PimplPtr<Impl, true>;
 
private: // Impl fields
    Pimpl   pimpl;
};
 
// inline implementations of class RscWriter
 
template<RscEnumType T>
inline void RscWriter::Write(const T& value, bool omitTag)
{
    RscType tag = RscTypeDeduction::GetFrom(value);
    if (!omitTag)
    {
        this->WriteTag(tag);
    }
    typename Enum<T>::U primitiveValue = make_enum(value).ToUnderlyingType();
    this->WritePrimitive(reinterpret_cast<const byte*>(&primitiveValue), tag);
}
 
template<RscPrimitiveType T>
inline void RscWriter::Write(const T& value, bool omitTag)
{
    RscType tag = RscTypeDeduction::GetFrom(value);
    if (!omitTag)
    {
        this->WriteTag(tag);
    }
    this->WritePrimitive(reinterpret_cast<const byte*>(&value), tag);
}
 
template<RscClassType T>
inline void RscWriter::Write(const T& value, bool omitTag)
{
    RscType tag = RscTypeDeduction::GetFrom(value);
    if (!omitTag && tag != RscType::Object) // do not write tag for RscVariant (objects), this is done by RscVariant impl itself
    {
        this->WriteTag(tag);
    }
    value.Write(*this);
}
 
template<RscSerializableType T>
inline void RscWriter::Write(const T& value, bool omitTag)
{
    if (!omitTag)
    {
        this->WriteStructInfo(StructInfo<T>().FieldCount);
    }
    value.Serialize(*this);
}
 
template<int N>
inline void RscWriter::Write(const RscVariant<N>& value, bool omitTag)
{
    this->Write(static_cast<const RscVariantBase&>(value), omitTag);
}
 
template<class T>
inline void RscWriter::Write(const std::vector<T>& data, bool omitTag)
{
    RscType elementType = RscType::None;
    size_t arraySize = data.size();
    this->WriteBeginArray<T>(arraySize, elementType, omitTag);
 
    bool omitElementTag = RscTypeInfo::IsConcreteType(elementType);
    for (size_t i = 0; i < arraySize; ++i)
    {
        this->Write(data[i], omitElementTag);
    }
}
 
template<class T>
inline void RscWriter::Write(const std::vector<std::vector<T>>& data, bool omitTag)
{
    RscType elementType = RscType::None;
    size_t arraySize = data.size();
    this->WriteTag(RscType::Array);
    this->WriteBeginArray<T>(arraySize, elementType, omitTag);
 
    bool omitElementTag = RscTypeInfo::IsConcreteType(elementType);
    for (size_t i = 0; i < arraySize; ++i)
    {
        const std::vector<T>& innerArray = data[i];
        size_t innerArraySize = innerArray.size();
        this->WriteArrayLength(innerArraySize);
 
        for (size_t j = 0; j < innerArraySize; ++j)
        {
            this->Write(innerArray[j], omitElementTag);
        }
    }
}
 
template<class T, size_t N>
inline void RscWriter::Write(const std::array<T, N>& data, bool omitTag)
{
    RscType elementType = RscType::None;
    size_t arraySize = data.size();
    this->WriteBeginArray<T>(arraySize, elementType, omitTag);
 
    bool omitElementTag = RscTypeInfo::IsConcreteType(elementType);
    for (size_t i = 0; i < arraySize; ++i)
    {
        this->Write(data[i], omitElementTag);
    }
}
 
template<class T>
inline void RscWriter::WriteBeginArray(size_t arraySize, RscType& elementType, bool omitTag)
{
    elementType = RscTypeDeduction().Get<T>();
    if (!omitTag)
    {
        this->WriteTag(RscType::Array);
        if (elementType == RscType::Struct)
        {
            this->WriteStructInfo(StructInfo<T>().FieldCount);
        }
        else
        {
            this->WriteTag(elementType);
        }
    }
    this->WriteArrayLength(arraySize);
}
 
} // end of namespace Arp::Base::Rsc::Commons::Services