wire.h

Go to the documentation of this file.

 
 
#pragma once
 
#include <cstdint>
#include <cstring>
#include <span>
#include <stdexcept>
#include <vector>
 
namespace profinet::wire
{
 
inline void PutU8(std::vector<std::uint8_t>& out, std::uint8_t v)
{
  out.push_back(v);
}
 
inline void PutU16(std::vector<std::uint8_t>& out, std::uint16_t v)
{
  out.push_back(static_cast<std::uint8_t>(v >> OneOctetShift));
  out.push_back(static_cast<std::uint8_t>(v & LowByteMask));
}
 
inline void PutU32(std::vector<std::uint8_t>& out, std::uint32_t v)
{
  out.push_back(static_cast<std::uint8_t>(v >> ThreeOctetsShift));
  out.push_back(static_cast<std::uint8_t>((v >> TwoOctetsShift) & LowByteMask));
  out.push_back(static_cast<std::uint8_t>((v >> OneOctetShift) & LowByteMask));
  out.push_back(static_cast<std::uint8_t>(v & LowByteMask));
}
 
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());
}
 
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(2);
    auto v = static_cast<std::uint16_t>(data[pos] << OneOctetShift | data[pos + 1]);
    pos += 2;
    return v;
  }
 
  std::uint32_t U32()
  {
    Need(4);
    std::uint32_t v = static_cast<std::uint32_t>(data[pos]) << ThreeOctetsShift |
                      static_cast<std::uint32_t>(data[pos + 1]) << TwoOctetsShift |
                      static_cast<std::uint32_t>(data[pos + 2]) << OneOctetShift |
                      static_cast<std::uint32_t>(data[pos + 3]);
    pos += 4;
    return v;
  }
 
  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> v{};
    std::memcpy(v.data(), data + pos, N);
    pos += N;
    return v;
  }
 
  void Skip(std::size_t n)
  {
    Need(n);
    pos += n;
  }
 
 private:
  const std::uint8_t* data;
 
  std::size_t len;
 
  std::size_t pos = 0;
};
 
} // namespace profinet::wire