RscStructWriter.hxx

 
//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Rsc/Services/RscVariant.hxx"
#include "Arp/System/Rsc/Services/RscValue.hpp"
namespace Arp { namespace System { namespace Rsc { namespace Services
{
 
template<int MaxStringSize>
class RscStructWriter
{
public: // typedefs
    using WriteElementFunction = RscVariant<>::WriteElementFunction;
 
public: // construction/destruction
    RscStructWriter(const RscVariant<MaxStringSize>& structVariant);
    RscStructWriter(const RscStructWriter& arg) = default;
    RscStructWriter& operator=(const RscStructWriter& arg) = default;
    ~RscStructWriter(void) = default;
 
public: // operations
    template<class T> void WriteNextField(const T& currentField);
 
    void WriteNextField(const RscVariant<MaxStringSize>& currentField);
 
    void WriteNextField(const RscString<MaxStringSize>& currentField);
 
protected: // operations
 
private: // static methods
 
private: // methods
    void WriteRemotingValue(RscType valueType, const byte* pValue);
 
private: // fields
    RscStructInformation structInformation;
    WriteElementFunction writeFieldFunction;
    RemotingWriter* pWriter = nullptr;;
private: // static fields
 
};
 
// inline methods of class RscStructWriter
 
template<int MaxStringSize>
inline RscStructWriter<MaxStringSize>::RscStructWriter(const RscVariant<MaxStringSize>& structVariant)
    : structInformation(structVariant.GetStructInformation())
{
    if(structVariant.typeInfo.pWriteElementFunction != nullptr)
    {
        this->writeFieldFunction = *structVariant.typeInfo.pWriteElementFunction;
    }
    else
    {
        this->writeFieldFunction = [&](RscType valueType, const byte * pValue)
        {
            this->WriteRemotingValue(valueType, pValue);
        };
        if(structVariant.typeInfo.pWriter == nullptr)
        {
            throw ArgumentException("No remoting writer set in argument 'structVariant'");
        }
        this->pWriter = structVariant.typeInfo.pWriter;
    }
}
 
template<int MaxStringSize>
inline void RscStructWriter<MaxStringSize>::WriteNextField(const RscVariant<MaxStringSize>& currentField)
{
    if(currentField.GetType() == RscType::Array)
    {
        const RscArrayInformation& arrayInformation = currentField.GetArrayInformation();
        this->writeFieldFunction(RscType::Array, reinterpret_cast<const byte*>(&arrayInformation));
        currentField.typeInfo.pWriter = this->pWriter;
        if(this->pWriter == nullptr)
        {
            currentField.typeInfo.pWriteElementFunction = &this->writeFieldFunction;
        }
    }
    else if (currentField.GetType() == RscType::Struct)
    {
        const RscStructInformation& currenttructInformation = currentField.GetStructInformation();
        this->writeFieldFunction(RscType::Struct, reinterpret_cast<const byte*>(&currenttructInformation));
        currentField.typeInfo.pWriter = this->pWriter;
        if (this->pWriter == nullptr)
        {
            currentField.typeInfo.pWriteElementFunction = &this->writeFieldFunction;
        }
    }
    else
    {
        this->writeFieldFunction(currentField.GetType(), currentField.GetDataAddress());
    }
}
 
template<int MaxStringSize>
inline void RscStructWriter<MaxStringSize>::WriteNextField(const RscString<MaxStringSize>& currentField)
{
    this->writeFieldFunction(RscType::Utf8String, reinterpret_cast<const byte*>(currentField.CStr()));
}
 
template<int MaxStringSize>
template<class T>
inline void RscStructWriter<MaxStringSize>::WriteNextField(const T& currentField)
{
    RscType type = GetRscTypeFrom(currentField);
    if(!IsPrimitiveRscType(type))
    {
        throw InvalidOperationException("{}: This method is only for primtive types", __FUNCTION__);
    }
    this->writeFieldFunction(type, reinterpret_cast<const byte*>(&currentField));
}
 
template<int MaxStringSize>
inline void RscStructWriter<MaxStringSize>::WriteRemotingValue(RscType valueType, const byte* pValue)
{
    if(valueType == RscType::Array)
    {
        this->pWriter->WriteArrayInformation(*reinterpret_cast<const RscArrayInformation*>(pValue));
        return;
    }
    this->pWriter->WriteObjectType(valueType);
    RscValue::Write(*this->pWriter, valueType, pValue, MaxStringSize);
}
 
}}}} // end of namespace Arp::System::Rsc::Services