RscArrayWriter.hpp

 
//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Rsc/Services/Rsc.h"
#include "Arp/System/Commons/Exceptions/Exceptions.h"
#include "Arp/System/Rsc/Services/RemotingWriter.hpp"
#include "Arp/System/Rsc/Services/RscVariant.hxx"
#include <functional>
 
namespace Arp { namespace System { namespace Rsc { namespace Services
{
 
class RscArrayWriter
{
public: // typedefs
    using WriteElementFunction = RscVariant<>::WriteElementFunction;
 
public: // construction/destruction
    template<int N>
    RscArrayWriter(const RscVariant<N>& value);
    RscArrayWriter(size_t size, RscType elementType, WriteElementFunction writeFunction);
    RscArrayWriter(size_t size, RscType elementType, RemotingWriter& writer, size_t dimensions = 1);
    RscArrayWriter(const RscArrayWriter& arg) = default;
    RscArrayWriter& operator=(const RscArrayWriter& arg) = default;
    ~RscArrayWriter(void) = default;
 
public: // setter/getter operations
    size_t  GetSize(void)const;
 
    RscType GetElementType(void)const;
 
    size_t  GetPosition(void)const;
 
public: // operations
    template<class T>
    void WriteNext(const T& current);
 
    template<int N>
    void WriteNext(const RscString<N>& current);
 
    template<int N>
    void WriteNext(const RscVariant<N>& current);
 
    void WriteNext(const byte* pCurrent);
 
    RscArrayWriter WriteNextArray(size_t size);
 
    template<int MaxStringSize> RscVariant<MaxStringSize> WriteNextStruct();
 
 
private: // methods
    void    WriteRemotingValue(RscType type, const byte* pValue);
 
private: // fields
    RscArrayInformation     arrayInformation;
    size_t                  position = 0;
    RemotingWriter*         pWriter = nullptr;
    WriteElementFunction    writeElementFunction;
    size_t                  maxStringSize = 0;
};
 
// inline methods of class RscArrayWriter<T>
 
template<int N>
inline RscArrayWriter::RscArrayWriter(const RscVariant<N>& value)
    : arrayInformation(value.GetArrayInformation())
    , pWriter(value.typeInfo.pWriter)
    , maxStringSize(N)
{
    if (this->GetElementType() == RscType::None)
    {
        throw ArgumentException::Create("arrayElementType", this->GetElementType());
    }
 
    if(this->arrayInformation.Dimensions == 0)
    {
        throw ArgumentException("{0}: dimension size has to be >= 0", __FUNCTION__);
    }
 
    if (value.typeInfo.pWriteElementFunction != nullptr)
    {
        this->writeElementFunction = *value.typeInfo.pWriteElementFunction;
    }
    else if(this->pWriter != nullptr)
    {
        this->writeElementFunction = [&](RscType type, const byte * pValue)
        {
            WriteRemotingValue(type, pValue);
        };
    }
    else
    {
        throw ArgumentException("WriteElementFunction in RscVariant has to be defined");
    }
}
 
 
inline size_t RscArrayWriter::GetSize()const
{
    return this->arrayInformation.Size;
}
 
inline RscType RscArrayWriter::GetElementType()const
{
    return this->arrayInformation.ElementType;
}
 
inline size_t RscArrayWriter::GetPosition()const
{
    return this->position;
}
 
template<class T>
inline void RscArrayWriter::WriteNext(const T& current)
{
    if(!IsPrimitiveRscType(this->GetElementType()))
    {
        throw InvalidOperationException("This method can only be used with primitve Types");
    }
    this->WriteNext(reinterpret_cast<const byte*>(&current));
}
 
template<>
inline void RscArrayWriter::WriteNext(const DateTime& current)
{
    if(this->GetElementType() != RscType::DateTime)
    {
        throw InvalidOperationException("This method can only be used for array of DateTime");
    }
    this->WriteNext(reinterpret_cast<const byte*>(&current));
}
 
template<int N>
inline void RscArrayWriter::WriteNext(const RscString<N>& current)
{
    if(this->GetElementType() != RscType::Utf8String)
    {
        throw InvalidOperationException("This instance of RscArrayWriter is not initialized for string operations");
    }
    if(N != this->maxStringSize)
    {
        throw InvalidOperationException("Size of current doesn't fit to maxStringSize");
    }
    this->writeElementFunction(this->GetElementType(), reinterpret_cast<const byte*>(current.CStr()));
    ++this->position;
}
 
template<int MaxStringSize>
inline RscVariant<MaxStringSize> RscArrayWriter::WriteNextStruct()
{
 
    if(this->arrayInformation.ElementType != RscType::Struct)
    {
        throw InvalidOperationException("This method is only valid with struct element types");
    }
 
    RscVariant<MaxStringSize> structVariant;
 
    if(this->pWriter == nullptr)
    {
        structVariant = RscVariant<MaxStringSize>::CreateStructVariant(this->arrayInformation.FieldCount);
        structVariant.SetWriteElementFunction(&this->writeElementFunction);
        this->writeElementFunction(RscType::Struct, structVariant.GetDataAddress());
    }
    else
    {
        structVariant = RscVariant<MaxStringSize>::CreateStructVariant(this->arrayInformation.FieldCount, *this->pWriter);
    }
 
    ++this->position;
    return structVariant;
}
 
template<int N>
inline void RscArrayWriter::WriteNext(const RscVariant<N>& current)
{
    if(this->GetElementType() != RscType::Object)
    {
        throw InvalidOperationException("This instance of RscArrayWriter is not initialized to contain objects");
    }
    if(N != this->maxStringSize)
    {
        throw InvalidOperationException("Size of current doesn't fit to maxStringSize");
    }
    this->writeElementFunction(current.GetType(), current.GetDataAddress());
    if(current.ContainsTypeInformation())
    {
        current.typeInfo.pWriter = this->pWriter;
    }
    ++this->position;
}
 
}}}} // end of namespace Arp::System::Rsc::Services