serializable_buffer.h

Go to the documentation of this file.

 
#ifndef ODVA_ETHERNETIP_SERIALIZATION_SERIALIZABLE_BUFFER_H
#define ODVA_ETHERNETIP_SERIALIZATION_SERIALIZABLE_BUFFER_H
 
#include <boost/asio.hpp>
 
#include "odva_ethernetip/serialization/serializable.h"
#include "odva_ethernetip/serialization/writer.h"
#include "odva_ethernetip/serialization/reader.h"
#include "odva_ethernetip/serialization/buffer_reader.h"
 
using boost::asio::mutable_buffer;
using boost::asio::buffer_size;
 
namespace eip {
namespace serialization {
 
class SerializableBuffer : public Serializable
{
public:
 
  SerializableBuffer() : data_(NULL, 0), allocated_buffer_(NULL) { }
 
  SerializableBuffer(mutable_buffer data) : data_(data), allocated_buffer_(NULL) { }
 
  virtual ~SerializableBuffer()
  {
    deleteAllocatedBuffer();
    data_ = mutable_buffer(NULL, 0);
  }
 
  virtual size_t getLength() const
  {
    return buffer_size(data_);
  }
 
  virtual mutable_buffer getData() const
  {
    return data_;
  }
 
  virtual void setData(mutable_buffer data)
  {
    // TODO: It's possible that the user could pass in the same buffer again,
    // or a subset of it. That would be absurd, but possible.
    deleteAllocatedBuffer();
    data_ = data;
  }
 
  virtual Writer& serialize(Writer& writer) const
  {
    writer.writeBuffer(data_);
    return writer;
  }
 
  virtual Reader& deserialize(Reader& reader, size_t length)
  {
    // with a BufferReader, we can read without copying
    BufferReader* br = dynamic_cast<BufferReader*>(&reader);
    if (br)
    {
      deleteAllocatedBuffer();
      data_ = br->readBuffer(length);
    }
    else
    {
      if (length != buffer_size(data_))
      {
        // must allocate a new buffer
        deleteAllocatedBuffer();
        allocated_buffer_ = new char[length];
        data_ = buffer(allocated_buffer_, length);
      }
      reader.readBuffer(data_);
    }
    return reader;
  }
 
  virtual Reader& deserialize(Reader& reader)
  {
    reader.readBuffer(data_);
    return reader;
  }
 
  void operator=(mutable_buffer b)
  {
    data_ = b;
  }
 
private:
  mutable_buffer data_;
  char* allocated_buffer_;
 
  void deleteAllocatedBuffer()
  {
    if (allocated_buffer_)
    {
      delete[] allocated_buffer_;
      allocated_buffer_ = NULL;
    }
  }
};
 
} // namespace serialization
} // namespace eip
#endif  // ODVA_ETHERNETIP_SERIALIZATION_SERIALIZABLE_BUFFER_H