forward_close_request.h

Go to the documentation of this file.

 
#ifndef ODVA_ETHERNETIP_FORWARD_CLOSE_REQUEST_H
#define ODVA_ETHERNETIP_FORWARD_CLOSE_REQUEST_H
 
#include <string>
#include <boost/shared_ptr.hpp>
 
#include "odva_ethernetip/eip_types.h"
#include "odva_ethernetip/serialization/serializable.h"
#include "odva_ethernetip/serialization/reader.h"
#include "odva_ethernetip/serialization/writer.h"
#include "odva_ethernetip/path.h"
 
using boost::shared_ptr;
 
namespace eip {
 
using serialization::Serializable;
using serialization::Reader;
using serialization::Writer;
 
class ForwardCloseRequest : public Serializable
{
public:
 
  EIP_BYTE timeout_tick_size;
  EIP_USINT timeout_ticks;
  EIP_UINT connection_sn;
  EIP_UINT originator_vendor_id;
  EIP_UDINT originator_sn;
 
  Path& getPath()
  {
    return path_;
  }
 
  virtual size_t getLength() const
  {
    return sizeof(timeout_tick_size)
          + sizeof(timeout_ticks)
          + sizeof(connection_sn)
          + sizeof(originator_vendor_id)
          + sizeof(originator_sn)
          + 1 // reserved byte
          + path_.getLength();
  }
 
  virtual Writer& serialize(Writer& writer) const
  {
    writer.write(timeout_tick_size);
    writer.write(timeout_ticks);
    writer.write(connection_sn);
    writer.write(originator_vendor_id);
    writer.write(originator_sn);
    // add reserved byte should be after the path size.
    // seriously. Who thought this out? Dumbest standard ever.
    path_.serialize(writer, true);
    return writer;
  }
 
  virtual Reader& deserialize(Reader& reader, size_t length)
  {
    throw std::logic_error("Not implemented");
  }
 
  virtual Reader& deserialize(Reader& reader)
  {
    throw std::logic_error("Not implemented");
  }
 
private:
  Path path_;
};
 
} // namespace eip
 
#endif  // ODVA_ETHERNETIP_FORWARD_CLOSE_REQUEST_H