encap_packet.h

Go to the documentation of this file.

 
#ifndef ODVA_ETHERNETIP_ENCAP_PACKET_H
#define ODVA_ETHERNETIP_ENCAP_PACKET_H
 
#include <boost/shared_ptr.hpp>
 
#include "odva_ethernetip/eip_types.h"
 
#include "odva_ethernetip/encap_header.h"
#include "odva_ethernetip/serialization/reader.h"
#include "odva_ethernetip/serialization/writer.h"
#include "odva_ethernetip/serialization/serializable.h"
 
 
using boost::shared_ptr;
 
namespace eip {
 
using serialization::Serializable;
using serialization::Reader;
using serialization::Writer;
 
class EncapPacket : public Serializable
{
public:
 
  EncapPacket(EIP_UINT command = 0, EIP_UDINT session_handle = 0)
    : header_(command, session_handle) { }
 
  EncapPacket(EIP_UINT command, EIP_UDINT session_handle,
    shared_ptr<Serializable> payload)
    : header_(command, session_handle), payload_(payload)
    {
      updateLength();
    }
 
 
  EncapHeader& getHeader()
  {
    return header_;
  }
 
  shared_ptr<Serializable> getPayload() const
  {
    return payload_;
  }
 
  void setPayload(shared_ptr<Serializable> payload)
  {
    payload_ = payload;
    updateLength();
  }
 
  void getPayloadAs(Serializable& result);
 
  size_t getLength() const
  {
    size_t l = header_.getLength();
    if (NULL != payload_)
    {
      l += payload_->getLength();
    }
    return l;
  }
 
  void updateLength()
  {
    header_.length = payload_ ? payload_->getLength() : 0;
  }
 
  Writer& serialize(Writer& writer) const;
 
  Reader& deserialize(Reader& reader, size_t length);
 
  Reader& deserialize(Reader& reader);
 
private:
  EncapHeader header_;
  shared_ptr<Serializable> payload_;
};
 
} // namespace eip
 
#endif  // ODVA_ETHERNETIP_ENCAP_PACKET_H