RscStructReader.hxx

//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Rsc/Services/Rsc.h"
#include "Arp/System/Rsc/Services/RscVariant.hxx"
#include "Arp/System/Rsc/Services/RscString.hxx"
#include "Arp/System/Rsc/Services/RscValue.hpp"
#include "Arp/System/Rsc/Services/RscException.hpp"
#include <functional>
namespace Arp { namespace System { namespace Rsc { namespace Services
{
 
class RscArrayReader;
 
template<int MaxStringSize>
class RscStructReader
{
public: // typedefs
    using ReadElementFunction = RscVariant<>::ReadElementFunction;
 
public: // construction/destruction
    RscStructReader(const RscVariant<MaxStringSize>& structVariant); // Variant with struct information
    RscStructReader(const RscStructReader& arg) = default;
    RscStructReader& operator=(const RscStructReader& arg) = default;
    ~RscStructReader(void) = default;
 
public: // operators
 
public: // static operations
    size_t GetFieldCount(void) const;
 
public: // setter/getter operations
 
public: // operations
 
    template<class T>
    void ReadNextField(T& currentField);
 
    void ReadNextField(RscString<MaxStringSize>& currentField);
 
    void ReadNextField(RscVariant<MaxStringSize>& value);
 
private: // methods
    RscType ReadRemotingValue(RscType expectedType, byte* pValue);
 
private: // fields
    RscStructInformation structInformation;
    RemotingReader* pReader = nullptr;
    ReadElementFunction  readFieldFunction;
 
private: // static fields
 
};
 
// inline methods of class RscStructReader
 
template<int MaxStringSize>
inline RscStructReader<MaxStringSize>::RscStructReader(const RscVariant<MaxStringSize>& structVariant)
    : structInformation(structVariant.GetStructInformation())
{
    if(structVariant.typeInfo.pReader == nullptr)
    {
        this->readFieldFunction = *structVariant.typeInfo.pReadElementFunction;
    }
    else
    {
        this->readFieldFunction = [&](RscType expectedType, byte * pValue)
        {
            return this->ReadRemotingValue(expectedType, pValue);
        };
        if(structVariant.typeInfo.pReader == nullptr)
        {
            throw ArgumentException("No remoting reader set in argument 'structVariant'");
        }
        this->pReader = structVariant.typeInfo.pReader;
    }
}
 
template<int MaxStringSize>
inline size_t RscStructReader<MaxStringSize>::GetFieldCount(void) const
{
    return this->structInformation.FieldCount;
}
 
template<int MaxStringSize>
inline void RscStructReader<MaxStringSize>::ReadNextField(RscVariant<MaxStringSize>& value)
{
    RscType readType = this->readFieldFunction(RscType::Object, value.GetDataAddress());
    value.SetType(readType);
    if(value.ContainsTypeInformation())
    {
        value.InitComplexTypeInfo();
        value.typeInfo.pReader = this->pReader;
        if(this->pReader == nullptr)
        {
            value.typeInfo.pReadElementFunction = &this->readFieldFunction;
        }
    }
}
 
template<int MaxStringSize>
template<class T>
inline void RscStructReader<MaxStringSize>::ReadNextField(T& currentField)
{
    RscType expectedType = GetRscTypeFrom(currentField);
    if(!IsPrimitiveRscType(expectedType))
    {
        throw InvalidOperationException("{}: This method works only for primitive types", __FUNCTION__);
    }
    (void)this->readFieldFunction(expectedType, reinterpret_cast<byte*>(&currentField));
}
 
template<int MaxStringSize>
inline void RscStructReader<MaxStringSize>::ReadNextField(RscString<MaxStringSize>& currentField)
{
    (void)this->readFieldFunction(RscType::Utf8String, reinterpret_cast<byte*>(currentField.CStr()));
}
 
template<int MaxStringSize>
inline RscType RscStructReader<MaxStringSize>::ReadRemotingValue(RscType expectedType, byte* pValue)
{
    RscType valueType = this->pReader->ReadObjectType();
    if(expectedType != RscType::Object && expectedType != valueType)
    {
        throw RscException((int)RscErrors::InvalidData, "{}: Expected data type '{}', but got '{}'", __FUNCTION__, expectedType, valueType);
    }
    if(valueType == RscType::Array)
    {
        RscArrayInformation& arrayInformation = *reinterpret_cast<RscArrayInformation*>(pValue);
        arrayInformation = this->pReader->ReadArrayInformation();
        return RscType::Array;
    }
    else if(valueType == RscType::Struct)
    {
        RscStructInformation& nestedStructInformation = *reinterpret_cast<RscStructInformation*>(pValue);
        nestedStructInformation.FieldCount = this->pReader->ReadFieldCount();
        return RscType::Struct;
    }
    RscValue::Read(*this->pReader, valueType, pValue, MaxStringSize);
    return valueType;
}
 
}}}} // end of namespace Arp::System::Rsc::Services