ReadWriteHelper.hpp

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 ------------------------------------------------

//----------------------------------------------------------------------
//----------------------------------------------------------------------

#ifndef SICK_SAFETYSCANNERS_DATA_PROCESSING_READWRITEHELPER_HPP
#define SICK_SAFETYSCANNERS_DATA_PROCESSING_READWRITEHELPER_HPP

#include <stdint.h>

namespace sick {
namespace read_write_helper {

inline void writeUint8(std::vector<uint8_t>::iterator it, const uint8_t v)
{
  *(it + 0) = v;
}

inline void writeUint8BigEndian(std::vector<uint8_t>::iterator it, const uint8_t v)
{
  writeUint8(it, v);
}

inline void writeUint8LittleEndian(std::vector<uint8_t>::iterator it, const uint8_t v)
{
  writeUint8(it, v);
}

inline void writeInt8(std::vector<uint8_t>::iterator it, const uint8_t v)
{
  writeUint8(it, v);
}

inline void writeInt8BigEndian(std::vector<uint8_t>::iterator it, const uint8_t v)
{
  writeInt8(it, v);
}

inline void writeInt8LittleEndian(std::vector<uint8_t>::iterator it, const uint8_t v)
{
  writeInt8(it, v);
}

inline void writeUint16BigEndian(std::vector<uint8_t>::iterator it, const uint16_t v)
{
  *(it + 0) = (v & 0xff00) >> 8;
  *(it + 1) = v & 0xff;
}

inline void writeUint16LittleEndian(std::vector<uint8_t>::iterator it, const uint16_t v)
{
  *(it + 0) = v & 0xff;
  *(it + 1) = (v & 0xff00) >> 8;
}


inline void writeUint32BigEndian(std::vector<uint8_t>::iterator it, const uint32_t v)
{
  *(it + 0) = (v & 0xff000000) >> 24;
  *(it + 1) = (v & 0xff0000) >> 16;
  *(it + 2) = (v & 0xff00) >> 8;
  *(it + 3) = v & 0xff;
}

inline void writeUint32LittleEndian(std::vector<uint8_t>::iterator it, const uint32_t v)
{
  *(it + 3) = (v & 0xff000000) >> 24;
  *(it + 2) = (v & 0xff0000) >> 16;
  *(it + 1) = (v & 0xff00) >> 8;
  *(it + 0) = v & 0xff;
}

inline uint8_t readUint8(std::vector<uint8_t>::const_iterator it)
{
  return *(it + 0);
}

inline uint8_t readUint8BigEndian(std::vector<uint8_t>::const_iterator it)
{
  return readUint8(it);
}

inline uint8_t readUint8LittleEndian(std::vector<uint8_t>::const_iterator it)
{
  return readUint8(it);
}

inline int8_t readInt8(std::vector<uint8_t>::const_iterator it)
{
  return readUint8(it);
}

inline int8_t readInt8BigEndian(std::vector<uint8_t>::const_iterator it)
{
  return readInt8(it);
}

inline int8_t readInt8LittleEndian(std::vector<uint8_t>::const_iterator it)
{
  return readInt8(it);
}

inline uint16_t readUint16BigEndian(std::vector<uint8_t>::const_iterator it)
{
  return (*(it + 0) << 8) + *(it + 1);
}

inline uint16_t readUint16LittleEndian(std::vector<uint8_t>::const_iterator it)
{
  return (*(it + 1) << 8) + *(it + 0);
}

inline int16_t readInt16BigEndian(std::vector<uint8_t>::const_iterator it)
{
  return readUint16BigEndian(it);
}

inline int16_t readInt16LittleEndian(std::vector<uint8_t>::const_iterator it)
{
  return readUint16LittleEndian(it);
}

inline uint32_t readUint32BigEndian(std::vector<uint8_t>::const_iterator it)
{
  return (*(it + 0) << 24) + (*(it + 1) << 16) + (*(it + 2) << 8) + *(it + 3);
}

inline uint32_t readUint32LittleEndian(std::vector<uint8_t>::const_iterator it)
{
  return (*(it + 3) << 24) + (*(it + 2) << 16) + (*(it + 1) << 8) + *(it + 0);
}

inline int32_t readInt32BigEndian(std::vector<uint8_t>::const_iterator it)
{
  return (*(it + 0) << 24) + (*(it + 1) << 16) + (*(it + 2) << 8) + *(it + 3);
}


inline int32_t readInt32LittleEndian(std::vector<uint8_t>::const_iterator it)
{
  return (*(it + 3) << 24) + (*(it + 2) << 16) + (*(it + 1) << 8) + *(it + 0);
}

} // namespace read_write_helper
} // namespace sick

#endif // SICK_SAFETYSCANNERS_DATA_PROCESSING_READWRITEHELPER_HPP