RscStream.hpp

//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Rsc/Services/Rsc.h"
#include "Arp/System/Rsc/Services/RemotingReader.hpp"
#include "Arp/System/Rsc/Services/RemotingWriter.hpp"
#include "Arp/System/Commons/Io/Stream.hpp"

namespace Arp { namespace System { namespace Rsc { namespace Services
{


class RscStream
{
public: // usings
    using Stream = Arp::System::Commons::Io::Stream;

public: // construction/destruction
    RscStream(void) = default;

    RscStream(RemotingWriter& writer);

    RscStream(RemotingReader& reader);

    RscStream(const RscStream& rscStream) = default;

    ~RscStream(void) = default;

public: // setter/getter
    void SetWriter(RemotingWriter* pValue);

    void SetReader(RemotingReader* pValue);

public: // Read operations (only allowed with RemotingReader set)
    void    BeginRead(void);

    size_t  Read(byte* pBuffer, size_t bufferSize);

    void    Skip(void);

    void    DeserializeTo(Stream& stream);

public: // Write operations (only allowed if RemotingWriter is set)
    void    BeginWrite(void);

    void    Write(const byte* pBuffer, size_t bufferCount);

    void    Flush(void);

    void    SerializeFrom(Stream& stream);

private: // fields
    RemotingWriter*  pWriter = nullptr;
    RemotingReader*  pReader = nullptr;
    bool             initialized = false;
    int              count = 0;
    int              remaining = 0;

private: // static fields
    static constexpr int MaxPacketSize = std::numeric_limits<int>::max();
    static constexpr size_t BufferSize = 4096;
};

// inline methods of class RscStream
inline RscStream::RscStream(RemotingWriter& writer)
    : pWriter(&writer)
{
}

inline RscStream::RscStream(RemotingReader& reader)
    : pReader(&reader)
{
}

inline void RscStream::SetWriter(RemotingWriter * value)
{
    this->pWriter = value;
}

inline void RscStream::SetReader(RemotingReader* value)
{
    this->pReader = value;
}
}}}} // end of namespace Arp::System::Rsc::Services