stream.h

Go to the documentation of this file.

#ifndef __OPC_UA_MAPPING_SERIALIZE_H__
#define __OPC_UA_MAPPING_SERIALIZE_H__

#include <opc/ua/protocol/channel.h>
#include <opc/ua/protocol/binary/common.h>

#include <memory>
#include <vector>

#define OPCUA_DEFAULT_BUFFER_SIZE 4096

namespace OpcUa
{
namespace Binary
{

class DataSerializer
{
public:
  explicit DataSerializer(std::size_t defBufferSize = OPCUA_DEFAULT_BUFFER_SIZE)
  {
    Buffer.reserve(defBufferSize);
  }

  template <typename T>
  DataSerializer & operator<<(const T & value)
  {
    Serialize<T>(value);
    return *this;
  }

  template <typename Acceptor>
  void Flush(Acceptor & aceptor)
  {
    aceptor.Send(&Buffer[0], Buffer.size());
    Buffer.clear();
  }

  template<typename T>
  void Serialize(const T & value);

private:
  std::vector<char> Buffer;
};

class DataSupplier
{
public:
  virtual size_t Read(char * buffer, size_t size) = 0;
};

class DataDeserializer
{
public:
  DataDeserializer(DataSupplier & supplier)
    : In(supplier)
  {
  }

  virtual ~DataDeserializer()
  {
  }

  template <typename T>
  DataDeserializer & operator>>(T & value)
  {
    Deserialize<T>(value);
    return *this;
  }

  template <typename T>
  void Deserialize(T &);

private:
  DataSupplier & In;
};


struct RawMessage
{
  const char * Data;
  std::size_t Size;

  RawMessage(const char * data, std::size_t size)
    : Data(data)
    , Size(size)
  {
  }
};


template <typename OutputChannelType>
class OStream
{
public:
  explicit OStream(std::shared_ptr<OutputChannelType> channel)
    : Out(*channel)
    , Holder(channel)
  {
  }

  explicit OStream(OutputChannelType & channel)
    : Out(channel)
  {
  }

  virtual ~OStream()
  {
  }

  template <typename T>
  OStream & operator<<(const T & value)
  {
    Serializer << value;
    return *this;
  }

  OStream & operator<< (OStream & (*pf)(OStream & out))
  {
    return pf(*this);
  }

  void Flush()
  {
    Serializer.Flush(Out);
  }

private:
  OutputChannelType & Out;
  std::shared_ptr<OutputChannelType> Holder;
  DataSerializer Serializer;
};

template <typename ChannelType>
inline OStream<ChannelType> & flush(OStream<ChannelType> & os)
{
  os.Flush();
  return os;
}

struct RawBuffer
{
  char * Data;
  std::size_t Size;

  RawBuffer(char * data, std::size_t size)
    : Data(data)
    , Size(size)
  {
  }
};


template <typename InputChannelType>
class IStream : private DataSupplier
{
public:
  explicit IStream(std::shared_ptr<InputChannelType> channel)
    : In(*channel)
    , Holder(channel)
    , Deserializer(*this)
  {
  }

  explicit IStream(InputChannelType & channel)
    : In(channel)
    , Deserializer(*this)
  {
  }

  virtual ~IStream()
  {
  }

  template <typename T>
  IStream & operator>>(T & value)
  {
    Deserializer >> value;
    return *this;
  }

private:
  virtual size_t Read(char * buffer, size_t size)
  {
    return In.Receive(buffer, size);
  }

private:
  InputChannelType & In;
  std::shared_ptr<InputChannelType> Holder;
  DataDeserializer Deserializer;
};


template <typename IOChannelType>
class IOStream : public IStream<IOChannelType>, public OStream<IOChannelType>
{
public:
  IOStream(std::shared_ptr<IOChannelType> channel)
    : IStream<IOChannelType>(channel)
    , OStream<IOChannelType>(channel)
  {
  }
};

template <typename InputChannelType, typename OutputChannelType>
class InputOutputStream : public IStream<InputChannelType>, public OStream<OutputChannelType>
{
public:
  InputOutputStream(std::shared_ptr<InputChannelType> input, std::shared_ptr<OutputChannelType> output)
    : IStream<InputChannelType>(input)
    , OStream<OutputChannelType>(output)
  {
  }
};

typedef OpcUa::Binary::IOStream<OpcUa::IOChannel> IOStreamBinary;
typedef OpcUa::Binary::IStream<OpcUa::InputChannel> IStreamBinary;
typedef OpcUa::Binary::OStream<OpcUa::OutputChannel> OStreamBinary;

} // namespace Binary
} // namespace OpcUa

#endif // __OPC_UA_MAPPING_SERIALIZE_H__