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