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
    bool HasWriter(void)const;
 
    bool HasReader(void)const;
 
    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);
 
    void    DeserializeTo(RscStream 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);
 
    void    SerializeFrom(RscStream 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 bool RscStream::HasWriter()const
{
    return this->pWriter != nullptr;
}
 
inline bool RscStream::HasReader()const
{
    return this->pReader != nullptr;
}
 
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