RscWriter.hpp

//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Rsc/Services/Rsc.h"
#include "Arp/System/Rsc/Services/RscValueAdapter.hxx"
#include "Arp/System/Rsc/Services/RscStream.hpp"
#include "Arp/System/Rsc/Services/RemotingWriter.hpp"
#include <vector>
#include <type_traits>
 
// forwards
namespace CommonRemoting
{
class BinaryWriter2;
}
 
namespace Arp { namespace System { namespace Rsc { namespace Services
{
 
// forwards
class RscClientContext;
class RscStreamAdapter;
 
class RscWriter
{
public: // construction/destruction
    RscWriter(BinaryWriter2& remotingWriter, RscClientContext* pClientContext = nullptr);
    RscWriter(const RscWriter& arg) = default;
    RscWriter& operator=(const RscWriter& arg) = default;
    ~RscWriter(void) = default;
 
public: // setter/getter operations
    RscStream GetStream();
 
    RemotingWriter& GetRemotingWriter(void);
 
public: // write operations
    void    WriteConfirmation(bool flush = false);
 
    void    WriteStream(RscStreamAdapter& stream);
 
public: // generic write operations
    template<class T>   void    Write(const T& value);
 
    template<class T>   void    Write(const T& value, bool writeTag);
 
    template<int N>     void    WriteString(const String& value);
 
    template<int N>     void    WriteString(const char(&value)[N]);
 
    template<class T>   void    WriteObject(const T& value);
 
    template<int N>     void    WriteObjectString(const String& value);
 
    template<int N>     void    WriteObjectString(const char(&value)[N]);
 
    template<class T>   void    WriteArray(const std::vector<T>& values);
 
    template<class T>   void    WriteArray(const std::vector<std::vector<T>>& values);
 
    template<class T, size_t N> void WriteArray(const std::array<T, N>& values);
 
private: // methods
    template<class T> void BeginArray(size_t size);
 
private: // fields
    RemotingWriter remotingWriter;
};
 
// inline methods of class RscWriter
 
inline RscWriter::RscWriter(BinaryWriter2& remotingWriter, RscClientContext* pClientContextArg)
    : remotingWriter(remotingWriter, *this, pClientContextArg)
{
}
 
inline RemotingWriter& RscWriter::GetRemotingWriter(void)
{
    return this->remotingWriter;
}
 
inline void RscWriter::WriteConfirmation(bool flush)
{
    this->remotingWriter.WriteConfirmation(flush);
}
 
inline RscStream RscWriter::GetStream()
{
    return RscStream(this->remotingWriter);
}
 
template<class T>
inline void RscWriter::Write(const T& value)
{
    RscValueAdapter<T> valueAdapter(value);
    valueAdapter.Write(this->remotingWriter);
}
 
template<class T>
inline void RscWriter::Write(const T& value, bool writetTag)
{
    RscValueAdapter<T> valueAdapter(value);
    valueAdapter.Write(this->remotingWriter, writetTag);
}
 
template<int N>
inline void RscWriter::WriteString(const String& value)
{
    this->remotingWriter.WriteStringInternal(value, N);
}
 
template<int N>
inline void RscWriter::WriteString(const char(&value)[N])
{
    this->remotingWriter.WriteStringInternal(value, N);
}
 
template<class T>
inline void RscWriter::WriteArray(const std::vector<T>& values)
{
    size_t length = values.size();
    this->BeginArray<T>(length);
    for (size_t i = 0; i < length; ++i)
    {
        const T& value = values[i];
        RscValueAdapter<T> valueAdapter(value);
        valueAdapter.Write(this->remotingWriter, false); // Tag has already been written
    }
}
 
template<class T>
inline void RscWriter::WriteArray(const std::vector<std::vector<T>>& values)
{
    this->remotingWriter.WriteTag(RscType::Array);
    this->BeginArray<T>(values.size());
    for(const std::vector<T>& innerArray : values)
    {
        this->remotingWriter.WriteArrayLength(innerArray.size());
 
        for(const T& value : innerArray)
        {
            RscValueAdapter<T> valueAdapter(value);
            valueAdapter.Write(this->remotingWriter, false); // Tag has already been written
        }
    }
}
 
template<class T, size_t N>
inline void RscWriter::WriteArray(const std::array<T, N>& values)
{
    this->BeginArray<T>(N);
    for(size_t i = 0; i < N; ++i)
    {
        const T& value = values[i];
        RscValueAdapter<T> valueAdapter(value);
        valueAdapter.Write(this->remotingWriter, false); // Tag has already been written
    }
}
 
template<class T>
inline void RscWriter::BeginArray(size_t size)
{
    RscType elementType = GetRscTypeFrom(T());
    this->remotingWriter.WriteTag(RscType::Array);
    if(elementType == RscType::Struct)
    {
        this->remotingWriter.WriteBeginStruct(StructInfo<T>().FieldCount);
    }
    else
    {
        this->remotingWriter.WriteTag(elementType);
    }
    this->remotingWriter.WriteArrayLength(size);
}
 
 
template<class T>
inline void RscWriter::WriteObject(const T& value)
{
    this->remotingWriter.WriteObjectType(GetRscTypeFrom(value));
    this->Write(value);
}
 
template<int N>
inline void RscWriter::WriteObjectString(const String& value)
{
    this->remotingWriter.WriteObjectString(RscStringEncoding::Utf8, value);
}
 
template<int N>
inline void RscWriter::WriteObjectString(const char(&value)[N])
{
    this->remotingWriter.WriteObjectString(RscStringEncoding::Utf8, value);
}
 
}}}} // end of namespace Arp::System::Rsc::Services