10#ifndef ENDIAN_BUFFER_HPP
11#define ENDIAN_BUFFER_HPP
14#include "../core/bitmath_func.hpp"
15#include "../core/overflowsafe_type.hpp"
25template <
typename Tcont =
typename std::vector<u
int8_t>,
typename Titer =
typename std::back_insert_iterator<Tcont>>
34 EndianBufferWriter &operator <<(
const std::string &data) {
return *
this << std::string_view{ data }; }
35 EndianBufferWriter &operator <<(
const char *data) {
return *
this << std::string_view{ data }; }
37 EndianBufferWriter &operator <<(
bool data) {
return *this << static_cast<uint8_t>(data ? 1 : 0); }
42 template <
typename... Targs>
45 this->
WriteTuple(data, std::index_sequence_for<Targs...>{});
49 template <
class T, std::enable_if_t<std::disjunction_v<std::negation<std::is_
class<T>>, std::is_base_of<StrongTypedefBase, T>>,
int> = 0>
52 if constexpr (std::is_enum_v<T>) {
54 }
else if constexpr (std::is_base_of_v<StrongTypedefBase, T>) {
55 this->
Write(data.base());
62 template <
typename Tvalue,
typename Tbuf = std::vector<u
int8_t>>
63 static Tbuf FromValue(
const Tvalue &data)
73 template<
class Ttuple,
size_t... Tindices>
74 void WriteTuple(
const Ttuple &values, std::index_sequence<Tindices...>)
76 ((*this << std::get<Tindices>(values)), ...);
80 void Write(std::string_view value)
82 for (
auto c : value) {
85 this->buffer++ =
'\0';
92 static_assert(
sizeof(T) <= 8,
"Value can't be larger than 8 bytes");
94 if constexpr (
sizeof(T) > 1) {
95 this->buffer++ =
GB(value, 0, 8);
96 this->buffer++ =
GB(value, 8, 8);
97 if constexpr (
sizeof(T) > 2) {
98 this->buffer++ =
GB(value, 16, 8);
99 this->buffer++ =
GB(value, 24, 8);
101 if constexpr (
sizeof(T) > 4) {
102 this->buffer++ =
GB(value, 32, 8);
103 this->buffer++ =
GB(value, 40, 8);
104 this->buffer++ =
GB(value, 48, 8);
105 this->buffer++ =
GB(value, 56, 8);
108 this->buffer++ = value;
128 void rewind() { this->read_pos = 0; }
131 EndianBufferReader &operator >>(
bool &data) { data = this->Read<uint8_t>() != 0;
return *
this; }
133 template <
typename T>
136 template <
typename... Targs>
139 this->
ReadTuple(data, std::index_sequence_for<Targs...>{});
143 template <
class T, std::enable_if_t<std::disjunction_v<std::negation<std::is_
class<T>>, std::is_base_of<StrongTypedefBase, T>>,
int> = 0>
146 if constexpr (std::is_enum_v<T>) {
147 data =
static_cast<T
>(this->Read<std::underlying_type_t<T>>());
148 }
else if constexpr (std::is_base_of_v<StrongTypedefBase, T>) {
149 data = this->Read<typename T::BaseType>();
151 data = this->Read<T>();
156 template <
typename Tvalue>
157 static Tvalue ToValue(std::span<const uint8_t>
buffer)
167 template<
class Ttuple,
size_t... Tindices>
168 void ReadTuple(Ttuple &values, std::index_sequence<Tindices...>)
170 ((*
this >> std::get<Tindices>(values)), ...);
177 while (this->read_pos < this->
buffer.size()) {
178 char ch = this->Read<char>();
179 if (ch ==
'\0')
break;
189 static_assert(!std::is_const_v<T>,
"Can't read into const variables");
190 static_assert(
sizeof(T) <= 8,
"Value can't be larger than 8 bytes");
192 if (
read_pos +
sizeof(T) > this->buffer.size())
return {};
194 T value =
static_cast<T
>(this->buffer[this->read_pos++]);
195 if constexpr (
sizeof(T) > 1) {
196 value +=
static_cast<T
>(this->buffer[this->read_pos++]) << 8;
198 if constexpr (
sizeof(T) > 2) {
199 value +=
static_cast<T
>(this->buffer[this->read_pos++]) << 16;
200 value +=
static_cast<T
>(this->buffer[this->read_pos++]) << 24;
202 if constexpr (
sizeof(T) > 4) {
203 value +=
static_cast<T
>(this->buffer[this->read_pos++]) << 32;
204 value +=
static_cast<T
>(this->buffer[this->read_pos++]) << 40;
205 value +=
static_cast<T
>(this->buffer[this->read_pos++]) << 48;
206 value +=
static_cast<T
>(this->buffer[this->read_pos++]) << 56;
debug_inline static constexpr uint GB(const T x, const uint8_t s, const uint8_t n)
Fetch n bits from x, started at bit s.
Endian-aware buffer adapter that always reads values in little endian order.
size_t read_pos
Current read position.
std::span< const uint8_t > buffer
Reference to storage buffer.
void ReadTuple(Ttuple &values, std::index_sequence< Tindices... >)
Helper function to read a tuple from the buffer.
T Read()
Fundamental read function.
std::string ReadStr()
Read overload for string data.
Endian-aware buffer adapter that always writes values in little endian order.
void WriteTuple(const Ttuple &values, std::index_sequence< Tindices... >)
Helper function to write a tuple to the buffer.
Titer buffer
Output iterator for the destination buffer.
void Write(T value)
Fundamental write function.
void Write(std::string_view value)
Write overload for string values.
Overflow safe template for integers, i.e.
constexpr std::underlying_type_t< enum_type > to_underlying(enum_type e)
Implementation of std::to_underlying (from C++23)
Non-templated base for StrongType::Typedef for use with type trait queries.