wire.h

Go to the documentation of this file.

 
 
#pragma once
 
#include <algorithm>
#include <array>
#include <cstddef>
#include <cstdint>
#include <ranges>
#include <span>
#include <string>
#include <type_traits>
#include <vector>
namespace profinet::wire
{
 
// // NOLINTBEGIN(readability-identifier-naming)
// // @brief The number of bits in a single octet (byte), used as the base for network byte order shifts.
// static constexpr int BitsPerOctet = 8;
 
// /// @brief The bit-shift distance required to move data across a single octet.
// static constexpr int OneOctetShift = BitsPerOctet; // Automatically 8
 
// /// @brief The bit-shift distance required to move data across two octets.
// static constexpr int TwoOctetsShift = BitsPerOctet * 2; // Automatically 16
 
// /// @brief The bit-shift distance required to move data across three octets.
// static constexpr int ThreeOctetsShift = BitsPerOctet * 3; // Automatically 24
 
// /// @brief Bitmask used to isolate the lowest significant byte (8 bits) of a larger integer.
// static constexpr std::uint8_t LowByteMask = 0xFF;
// // NOLINTEND(readability-identifier-naming)
 
inline constexpr unsigned kBitsPerByte = 8U;
 
template <typename T>
  requires std::is_integral_v<T> && std::is_unsigned_v<T>
inline void PutBigEndian(std::vector<std::uint8_t>& out, T value)
{
  for (std::size_t i = sizeof(T); i > 0U; --i)
  {
    out.push_back(static_cast<std::uint8_t>(value >> ((i - 1U) * kBitsPerByte)));
  }
}
 
template <typename T>
  requires std::is_integral_v<T> && std::is_unsigned_v<T>
inline void PutLittleEndian(std::vector<std::uint8_t>& out, T value)
{
  for (std::size_t i = 0U; i < sizeof(T); ++i)
  {
    out.push_back(static_cast<std::uint8_t>(value >> (i * kBitsPerByte)));
  }
}
template <typename T>
  requires std::is_integral_v<T> && std::is_unsigned_v<T>
inline void PutLittleEndian(std::uint8_t* out, T value)
{
  for (std::size_t i = 0U; i < sizeof(T); ++i)
  {
    out[i] = static_cast<std::uint8_t>(value >> (i * kBitsPerByte));
  }
}
 
inline void PutU8(std::vector<std::uint8_t>& out, std::uint8_t value)
{
  out.push_back(value);
}
 
inline void PutU16(std::vector<std::uint8_t>& out, std::uint16_t value)
{
  PutBigEndian(out, value);
}
 
inline void PutU32(std::vector<std::uint8_t>& out, std::uint32_t value)
{
  PutBigEndian(out, value);
}
 
inline void PutBytes(std::vector<std::uint8_t>& out, const std::uint8_t* data, std::size_t len)
{
  out.insert(out.end(), data, data + len);
}
 
template <std::size_t N>
inline void PutFixed(std::vector<std::uint8_t>& out, const std::array<std::uint8_t, N>& data)
{
  out.insert(out.end(), data.begin(), data.end());
}
inline void PutFixed(std::vector<std::uint8_t>& out, const std::vector<std::uint8_t>& data)
{
  out.insert(out.end(), data.begin(), data.end());
}
 
inline void PutFixed(std::vector<std::uint8_t>& out, const std::string& data)
{
  out.insert(out.end(), data.begin(), data.end());
}
 
template <typename T>
  requires std::is_integral_v<T> && std::is_unsigned_v<T>
[[nodiscard]] constexpr T ReadBigEndian(const std::uint8_t* data)
{
  T value = 0;
 
  for (std::size_t i = 0U; i < sizeof(T); ++i)
  {
    value = static_cast<T>((value << kBitsPerByte) | static_cast<T>(data[i]));
  }
 
  return value;
}
 
template <typename T>
  requires std::is_integral_v<T> && std::is_unsigned_v<T>
[[nodiscard]] constexpr T ReadLittleEndian(const std::uint8_t* data)
{
  T value = 0;
 
  for (std::size_t i = 0U; i < sizeof(T); ++i)
  {
    value = static_cast<T>(
        value |
        (static_cast<T>(data[i]) << (i * kBitsPerByte)));
  }
 
  return value;
}
 
class Reader
{
 public:
  Reader(const std::uint8_t* data, std::size_t len)
      : data(data), len(len)
  {
  }
 
  explicit Reader(std::span<const std::uint8_t> bytes)
      : data(bytes.data()), len(bytes.size())
  {
  }
 
  explicit Reader(const std::vector<std::uint8_t>& v)
      : data(v.data()), len(v.size())
  {
  }
 
  [[nodiscard]] std::size_t Remaining() const
  {
    return len - pos;
  }
 
  [[nodiscard]] std::size_t Position() const
  {
    return pos;
  }
 
  [[nodiscard]] const std::uint8_t* Cursor() const
  {
    return data + pos;
  }
 
  void Need(std::size_t n) const
  {
    if (Remaining() < n)
    {
      throw std::out_of_range("wire::Reader: not enough data");
    }
  }
 
  std::uint8_t U8()
  {
    Need(1);
    return data[pos++];
  }
 
  std::uint16_t U16()
  {
    Need(sizeof(std::uint16_t));
    const auto value = ReadBigEndian<std::uint16_t>(&data[pos]);
    pos += sizeof(std::uint16_t);
    return value;
  }
 
  std::uint32_t U32()
  {
    Need(sizeof(std::uint32_t));
 
    const auto value = ReadBigEndian<std::uint32_t>(&data[pos]);
    pos += sizeof(std::uint32_t);
    return value;
  }
 
  std::uint16_t U16LittleEndian()
  {
    Need(sizeof(std::uint16_t));
 
    const auto value = ReadLittleEndian<std::uint16_t>(&data[pos]);
 
    pos += sizeof(std::uint16_t);
    return value;
  }
 
  std::uint32_t U32LittleEndian()
  {
    Need(sizeof(std::uint32_t));
 
    const auto value = ReadLittleEndian<std::uint32_t>(&data[pos]);
 
    pos += sizeof(std::uint32_t);
    return value;
  }
 
  std::vector<std::uint8_t> ReadBytes(std::size_t n)
  {
    Need(n);
    std::vector<std::uint8_t> v(data + pos, data + pos + n);
    pos += n;
    return v;
  }
 
  template <std::size_t N>
  std::array<std::uint8_t, N> Fixed()
  {
    Need(N);
    std::array<std::uint8_t, N> value{};
 
    std::span source{data + pos, N};
    std::ranges::copy(source, value.begin());
 
    pos += N;
    return value;
  }
 
  void Skip(std::size_t n)
  {
    Need(n);
    pos += n;
  }
  void SkipTo(std::size_t offset)
  {
    if (offset > len)
    {
      throw std::out_of_range("wire::Reader: offset is beyond the end of the buffer");
    }
 
    pos = offset;
  }
 
 private:
  const std::uint8_t* data;
 
  std::size_t len;
 
  std::size_t pos = 0;
};
 
} // namespace profinet::wire