ParseDatagramHeader.cpp

Go to the documentation of this file.

// this is for emacs file handling -*- mode: c++; indent-tabs-mode: nil -*-
 
// -- BEGIN LICENSE BLOCK ----------------------------------------------
 
// -- END LICENSE BLOCK ------------------------------------------------
 
//----------------------------------------------------------------------
//----------------------------------------------------------------------
 
#include <sick_safetyscanners/data_processing/ParseDatagramHeader.h>
 
namespace sick {
namespace data_processing {
 
ParseDatagramHeader::ParseDatagramHeader() {}
 
bool ParseDatagramHeader::parseUDPSequence(const datastructure::PacketBuffer& buffer,
                                           datastructure::DatagramHeader& header) const
{
  // Keep our own copy of the shared_ptr to keep the iterators valid
  const std::shared_ptr<std::vector<uint8_t> const> vec_ptr = buffer.getBuffer();
  std::vector<uint8_t>::const_iterator data_ptr             = vec_ptr->begin();
  setDataInHeader(data_ptr, header);
  return true;
}
 
void ParseDatagramHeader::setDataInHeader(std::vector<uint8_t>::const_iterator data_ptr,
                                          datastructure::DatagramHeader& header) const
{
  setDatagramMarkerInHeader(data_ptr, header);
  setProtocolInHeader(data_ptr, header);
  setMajorVersionInHeader(data_ptr, header);
  setMinorVersionInHeader(data_ptr, header);
  setTotalLengthInHeader(data_ptr, header);
  setIdentificationInHeader(data_ptr, header);
  setFragmentOffsetInHeader(data_ptr, header);
}
 
void ParseDatagramHeader::setDatagramMarkerInHeader(std::vector<uint8_t>::const_iterator data_ptr,
                                                    datastructure::DatagramHeader& header) const
{
  header.setDatagramMarker(read_write_helper::readUint32BigEndian(data_ptr + 0));
}
 
void ParseDatagramHeader::setProtocolInHeader(std::vector<uint8_t>::const_iterator data_ptr,
                                              datastructure::DatagramHeader& header) const
{
  header.setProtocol(read_write_helper::readUint16BigEndian(data_ptr + 4));
}
 
void ParseDatagramHeader::setMajorVersionInHeader(std::vector<uint8_t>::const_iterator data_ptr,
                                                  datastructure::DatagramHeader& header) const
{
  header.setMajorVersion(read_write_helper::readUint8LittleEndian(data_ptr + 6));
}
 
void ParseDatagramHeader::setMinorVersionInHeader(std::vector<uint8_t>::const_iterator data_ptr,
                                                  datastructure::DatagramHeader& header) const
{
  header.setMinorVersion(read_write_helper::readUint8LittleEndian(data_ptr + 7));
}
 
void ParseDatagramHeader::setTotalLengthInHeader(std::vector<uint8_t>::const_iterator data_ptr,
                                                 datastructure::DatagramHeader& header) const
{
  header.setTotalLength(read_write_helper::readUint32LittleEndian(data_ptr + 8));
}
 
void ParseDatagramHeader::setIdentificationInHeader(std::vector<uint8_t>::const_iterator data_ptr,
                                                    datastructure::DatagramHeader& header) const
{
  header.setIdentification(read_write_helper::readUint32LittleEndian(data_ptr + 12));
}
 
void ParseDatagramHeader::setFragmentOffsetInHeader(std::vector<uint8_t>::const_iterator data_ptr,
                                                    datastructure::DatagramHeader& header) const
{
  header.setFragmentOffset(read_write_helper::readUint32LittleEndian(data_ptr + 16));
}
 
} // namespace data_processing
} // namespace sick