forward_open_success.h

Go to the documentation of this file.

 
#ifndef ODVA_ETHERNETIP_FORWARD_OPEN_SUCCESS_H
#define ODVA_ETHERNETIP_FORWARD_OPEN_SUCCESS_H
 
#include <string>
#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>
 
#include "odva_ethernetip/eip_types.h"
#include "odva_ethernetip/serialization/serializable.h"
#include "odva_ethernetip/serialization/serializable_buffer.h"
#include "odva_ethernetip/serialization/reader.h"
#include "odva_ethernetip/serialization/writer.h"
 
using boost::shared_ptr;
using boost::make_shared;
 
namespace eip {
 
using serialization::Serializable;
using serialization::SerializableBuffer;
using serialization::Reader;
using serialization::Writer;
 
class ForwardOpenSuccess : public Serializable
{
public:
 
  EIP_UDINT o_to_t_connection_id;
  EIP_UDINT t_to_o_connection_id;
  EIP_UINT connection_sn;
  EIP_UINT originator_vendor_id;
  EIP_UDINT originator_sn;
  EIP_UDINT o_to_t_api;
  EIP_UDINT t_to_o_api;
 
  shared_ptr<Serializable> getResponseData() const
  {
    return response_data_;
  }
 
  virtual size_t getLength() const
  {
    size_t result = sizeof(o_to_t_connection_id)
      + sizeof(t_to_o_connection_id)
      + sizeof(connection_sn)
      + sizeof(originator_vendor_id)
      + sizeof(originator_sn)
      + sizeof(o_to_t_api)
      + sizeof(t_to_o_api)
      + 2; // reserved byte and data length
    if (response_data_)
    {
      result += response_data_->getLength();
    }
    return result;
  }
 
  virtual Writer& serialize(Writer& writer) const
  {
    throw std::logic_error("Not implemented");
  }
 
  virtual Reader& deserialize(Reader& reader, size_t length)
  {
    return deserialize(reader);
  }
 
  virtual Reader& deserialize(Reader& reader)
  {
    EIP_USINT data_length;
    reader.read(o_to_t_connection_id);
    reader.read(t_to_o_connection_id);
    reader.read(connection_sn);
    reader.read(originator_vendor_id);
    reader.read(originator_sn);
    reader.read(o_to_t_api);
    reader.read(t_to_o_api);
    reader.read(data_length);
    reader.skip(1);
    if (data_length > 0)
    {
      shared_ptr<SerializableBuffer> sb = make_shared<SerializableBuffer> ();
      sb->deserialize(reader, data_length*2);
      response_data_ = sb;
    }
    else
    {
      response_data_ = shared_ptr<Serializable>();
    }
    return reader;
  }
 
private:
  shared_ptr<Serializable> response_data_;
 
};
 
} // namespace eip
 
#endif  // ODVA_ETHERNETIP_FORWARD_OPEN_SUCCESS_H