RscReader.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/RscStreamReader.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 RscReader
{
public: // Impl forward declaration
    class Impl;
 
public: // construction
    explicit RscReader(Stream& remoteStream);
 
    // canonical construction/destruction/assignment
    RscReader(const RscReader& arg);
    RscReader(RscReader&& arg)noexcept;
    RscReader& operator=(const RscReader& arg);
    RscReader& operator=(RscReader&& arg)noexcept;
    ~RscReader(void);
 
public: // setter/getter operations
    RscStream       GetStream(void);
    RscStreamReader GetStreamReader(void);
 
public: // concrete operations used by RscGenerator
    void    Read(RscPtr& result, bool omitTag = false);
    void    Read(RscConstPtr& result, bool omitTag = false);
    void    Read(String& result, bool omitTag = false);
    void    Read(DateTime& result, bool omitTag = false);
    void    Read(RscStream& stream, bool omitTag = false);
    void    Read(SecurityToken& result, bool omitTag = false);
    void    Read(RscVariantBase& result, bool omitTag = false);
 
public: // template operations used by RscGenerator
    template<RscEnumType T>         void    Read(T& result, bool omitTag = false);
    template<RscPrimitiveType T>    void    Read(T& result, bool omitTag = false);
    template<RscClassType T>        void    Read(T& result, bool omitTag = false);
    template<RscSerializableType T> void    Read(T& result, bool omitTag = false);
    template<int N>                 void    Read(RscVariant<N>& result, bool omitTag = false);
    template<class T>               void    Read(std::vector<T>& result, bool omitTag = false);
    template<class T>               void    Read(std::vector<std::vector<T>>& result, bool omitTag = false);
    template<class T, size_t N>     void    Read(std::array<T, N>& result, bool omitTag = false  );
 
public: // auxiliaries operations
    RscType ReadTag(void);
    void    ReadTag(RscType expectedTag);
    size_t  ReadFieldCount(void);
    size_t  ReadArrayLength(void);
    void    ReadBeginStruct(size_t fieldCount);
    void    ReadEnumeratorTag(RscType expectedTag, bool& isEndTag);
 
private: // methods
    template<class T>
    size_t  ReadBeginArray(RscType& elementType, bool omitTag);
    void    ReadPrimitive(byte* pValue, RscType type);
 
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 RscReader
 
template<RscEnumType T>
inline void RscReader::Read(T& result, bool omitTag)
{
    RscType type = RscTypeDeduction::GetFrom(result);
    if (!omitTag)
    {
        this->ReadTag(type);
    }
    typename Enum<T>::U value;
    this->ReadPrimitive(reinterpret_cast<byte*>(&value), type);
    result = static_cast<T>(value);
}
 
template<RscPrimitiveType T>
inline void RscReader::Read(T& result, bool omitTag)
{
    RscType type = RscTypeDeduction::GetFrom(result);
    if (!omitTag)
    {
        this->ReadTag(type);
    }
    this->ReadPrimitive(reinterpret_cast<byte*>(&result), type);
}
 
template<RscClassType T>
inline void RscReader::Read(T& result, bool omitTag)
{
    RscType type = RscTypeDeduction::GetFrom(result);
    if (!omitTag)
    {
        this->ReadTag(type);
    }
    result.Read(*this);
}
 
template<RscSerializableType T>
inline void RscReader::Read(T& result, bool omitTag)
{
    if (!omitTag)
    {
        this->ReadBeginStruct(StructInfo<T>().FieldCount);
    }
    result.Deserialize(*this);
}
 
template<int N>
inline void RscReader::Read(RscVariant<N>& result, bool omitTag)
{
    this->Read(static_cast<RscVariantBase&>(result), omitTag);
}
 
template<class T>
inline void RscReader::Read(std::vector<T>& result, bool omitTag)
{
    RscType elementType = RscType::None;
    size_t arraySize = this->ReadBeginArray<T>(elementType, omitTag);
    result.reserve(arraySize);
    bool omitElementTag = RscTypeInfo::IsConcreteType(elementType);
    for (size_t i = 0; i < arraySize; ++i)
    {
        T value;
        this->Read(value, omitElementTag);
        result.push_back(value);
    }
}
 
template<class T>
inline void RscReader::Read(std::vector<std::vector<T>>& result, bool omitTag)
{
    RscType elementType = RscType::None;
    this->ReadTag(RscType::Array);
    size_t outerArraySize = this->ReadBeginArray<T>(elementType, omitTag);
    result.reserve(outerArraySize);
 
    bool omitElementTag = RscTypeInfo::IsConcreteType(elementType);
    for (size_t i = 0; i < outerArraySize; ++i)
    {
        std::vector<T> innerArray;
        size_t innerArraySize = this->ReadArrayLength();
        innerArray.reserve(innerArraySize);
 
        for (size_t j = 0; j < innerArraySize; ++j)
        {
            T value;
            this->Read(value, omitElementTag);
            innerArray.push_back(value);
        }
        result.emplace_back(std::move(innerArray));
    }
}
 
template<class T, size_t N>
inline void RscReader::Read(std::array<T, N>& result, bool omitTag)
{
    RscType elementType = RscType::None;
    size_t arraySize = this->ReadBeginArray<T>(elementType, omitTag);
    if (arraySize != N)
    {
        throw RscException(RscError::InvalidServiceData, "Received array does not contain {} elements", N);
    }
 
    bool omitTagElementTag = RscTypeInfo::IsConcreteType(elementType);
    for (size_t i = 0; i < N; ++i)
    {
        T value;
        this->Read(value, omitTagElementTag);
        result[i] = value;
    }
}
 
template<class T>
inline size_t RscReader::ReadBeginArray(RscType& elementType, bool omitTag)
{
    elementType = RscTypeDeduction().Get<T>();
    if (!omitTag)
    {
        this->ReadTag(RscType::Array);
        if (elementType == RscType::Struct)
        {
            this->ReadBeginStruct(StructInfo<T>().FieldCount);
        }
        else
        {
            this->ReadTag(elementType);
        }
    }
    return this->ReadArrayLength();
}
 
} // end of namespace Arp::Base::Rsc::Commons::Services