RscReader.hpp

//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Rsc/Services/Rsc.h"
#include "Arp/System/Core/ByteConverter.hpp"
#include "Arp/System/Rsc/Services/RscValueAdapter.hxx"
#include "Arp/System/Rsc/Services/RscStream.hpp"
#include "Arp/System/Rsc/Services/RemotingReader.hpp"
#include "Arp/System/Rsc/Services/RscException.hpp"
#include <vector>
 
namespace Arp { namespace System { namespace Rsc { namespace Services
{
 
// forwards
class RscClientContext;
class RscStreamAdapter;
 
class RscReader
{
public: // construction/destruction
    RscReader(BinaryReader2& binaryReader, RscClientContext* pClientContext = nullptr);
    RscReader(const RscReader& arg) = default;
    RscReader& operator=(const RscReader& arg) = default;
    ~RscReader(void) = default;
 
public: // setter/getter operations
    RscStream GetStream(void);
 
    RemotingReader& GetRemotingReader(void);
 
public: // read operations
    void    ReadStream(RscStreamAdapter& stream);
 
public: // generic read operations
    template<class T>   T       Read(void);
 
    template<class T>   void    Read(T& result);
 
    template<class T>   void    Read(T& result, bool readTag);
 
    template<int N>     void    ReadString(String& result);
 
    template<int N>     void    ReadString(char(&value)[N]);
 
    template<int N>     void    ReadObjectString(char(&value)[N]);
 
    template<class T>   void    ReadArray(std::vector<T>& result);
 
    template<class T>   void    ReadArray(std::vector<std::vector<T>>& result);
 
    template<class T, size_t N> void ReadArray(std::array<T, N>& result);
 
private: // methods
    template<class T> size_t BeginArray(void);
 
private: // fields
    RemotingReader remotingReader;
};
 
// inline methods of class RscReader
inline RscReader::RscReader(BinaryReader2& binaryReader, RscClientContext* pClientContext)
    : remotingReader(binaryReader, *this, pClientContext)
{
}
 
inline RscStream RscReader::GetStream(void)
{
    return RscStream(this->remotingReader);
}
 
inline RemotingReader& RscReader::GetRemotingReader(void)
{
    return this->remotingReader;
}
 
template<class T>
inline void RscReader::Read(T& result)
{
    RscValueAdapter<T> valueAdapter(result);
    valueAdapter.Read(this->remotingReader);
}
 
template<class T>
inline void RscReader::Read(T& result, bool readTag)
{
    RscValueAdapter<T> valueAdapter(result);
    valueAdapter.Read(this->remotingReader, readTag);
}
 
template<class T>
inline T RscReader::Read()
{
    T value;
    this->Read(value);
    return value;
}
 
template<int N>
inline void RscReader::ReadString(String& result)
{
    char buffer[N] = "";
    this->ReadString<N>(buffer);
    result = buffer;
}
 
template<int N>
inline void RscReader::ReadString(char(&result)[N])
{
    this->remotingReader.ReadStringInternal(result, N, RscStringEncoding::Utf8);
}
 
template<class T>
inline void RscReader::ReadArray(std::vector<T>& result)
{
    size_t length = this->BeginArray<T>();
    result.reserve(length);
 
    for (size_t i = 0; i < length; ++i)
    {
        T value;
        RscValueAdapter<T> valueAdapter(value);
        valueAdapter.Read(this->remotingReader, false); // Tag has already been verified
        result.push_back(value);
    }
}
 
template<class T>
inline void RscReader::ReadArray(std::vector<std::vector<T>>& result)
{
    this->remotingReader.ReadTag(RscType::Array);
    size_t outerArraySize = this->BeginArray<T>();
    result.reserve(outerArraySize);
    for(size_t i = 0; i < outerArraySize; ++i)
    {
        size_t innerArraySize = this->remotingReader.ReadArrayLength();
        std::vector<T> innerArray;
        innerArray.reserve(innerArraySize);
 
        for(size_t j = 0; j < innerArraySize; ++j)
        {
            T value;
            RscValueAdapter<T> valueAdapter(value);
            valueAdapter.Read(this->remotingReader, false); // Tag has already been verified
            innerArray.push_back(value);
        }
        result.push_back(std::move(innerArray));
    }
}
 
template<class T, size_t N>
inline void RscReader::ReadArray(std::array<T, N>& result)
{
    size_t length = this->BeginArray<T>();
    if(length != N)
    {
        throw RscException((int)RscErrors::InvalidData, "Received Array doesn't contain {0} elements", N);
    }
 
    for(size_t i = 0; i < N; ++i)
    {
        RscValueAdapter<T> valueAdapter(result[i]);
        valueAdapter.Read(this->remotingReader, false); // Tag has already been verified
    }
}
 
template<class T>
inline size_t RscReader::BeginArray(void)
{
    RscType elementType = GetRscTypeFrom(T());
    this->remotingReader.ReadTag(RscType::Array);
    if(elementType == RscType::Struct)
    {
        this->remotingReader.ReadBeginStruct(StructInfo<T>().FieldCount);
    }
    else
    {
        this->remotingReader.ReadTag(elementType);
    }
    return this->remotingReader.ReadArrayLength();
}
 
template<int N>
inline void RscReader::ReadObjectString(char(&result)[N])
{
    RscType type = static_cast<RscType>(this->remotingReader.ReadObjectType());
 
    // determine encoding
    RscStringEncoding encoding = RscStringEncoding::None;
    if(type == RscType::Utf8String )
    {
        encoding = RscStringEncoding::Utf8;
    }
    else if (type == RscType::Utf16String)
    {
        encoding = RscStringEncoding::Utf16;
    }
    else
    {
        throw InvalidOperationException("Requested string type does not match read object type '{0}'", type);
    }
 
    if(encoding == RscStringEncoding::Utf16)
    {
        throw NotImplementedException("String encoding UTF16 not implemented yet");
    }
 
    // else
    this->remotingReader.ReadStringInternal(result, N, encoding);
}
 
}}}} // end of namespace Arp::System::Rsc::Services