126 lines
2.6 KiB
C++
126 lines
2.6 KiB
C++
#pragma once
|
|
#include <tuple>
|
|
#include <cstring>
|
|
#include <print>
|
|
#include <type_traits>
|
|
#include "buffer.h"
|
|
#define read_comp(size, ptr, t, sizes) const_for_<size>([&](auto i){std::get<i.value>(t) = read_var<std::tuple_element_t<i.value, std::remove_cvref_t<decltype(t)>>>::call(&ptr, sizes[i.value]);});
|
|
#ifdef __APPLE__
|
|
#include <libkern/OSByteOrder.h>
|
|
|
|
|
|
|
|
#define htobe16(x) OSSwapHostToBigInt16(x)
|
|
#define htole16(x) OSSwapHostToLittleInt16(x)
|
|
#define be16toh(x) OSSwapBigToHostInt16(x)
|
|
#define le16toh(x) OSSwapLittleToHostInt16(x)
|
|
|
|
#define htobe32(x) OSSwapHostToBigInt32(x)
|
|
#define htole32(x) OSSwapHostToLittleInt32(x)
|
|
#define be32toh(x) OSSwapBigToHostInt32(x)
|
|
#define le32toh(x) OSSwapLittleToHostInt32(x)
|
|
|
|
#define htobe64(x) OSSwapHostToBigInt64(x)
|
|
#define htole64(x) OSSwapHostToLittleInt64(x)
|
|
#define be64toh(x) OSSwapBigToHostInt64(x)
|
|
#define le64toh(x) OSSwapLittleToHostInt64(x)
|
|
#endif
|
|
|
|
struct parsing_buffer
|
|
{
|
|
parsing_buffer(buffer &b)
|
|
:buf(b)
|
|
{}
|
|
buffer &buf;
|
|
char *point;
|
|
int consumed_size;
|
|
};
|
|
|
|
template <typename T>
|
|
static T read_type(char *data, size_t size)
|
|
{
|
|
T a;
|
|
|
|
std::memcpy(&a, data, size);
|
|
|
|
switch (size)
|
|
{
|
|
case 1:
|
|
break;
|
|
case 2:
|
|
a = be16toh(a);
|
|
break;
|
|
case 4:
|
|
a = be32toh(a);
|
|
break;
|
|
case 8:
|
|
a = be64toh(a);
|
|
break;
|
|
default:
|
|
std::println("This integer is not supported!");
|
|
}
|
|
return a;
|
|
}
|
|
|
|
template <>
|
|
float read_type<float>(char *data, size_t size)
|
|
{
|
|
uint32_t num_as_uint32;
|
|
float num;
|
|
|
|
memcpy(&num_as_uint32, data, size);
|
|
num_as_uint32 = be32toh(num_as_uint32);
|
|
memcpy(&num, &num_as_uint32, size);
|
|
|
|
return num;
|
|
}
|
|
|
|
template <>
|
|
double read_type<double>(char *data, size_t size)
|
|
{
|
|
uint64_t num_as_uint64;
|
|
double num;
|
|
|
|
memcpy(&num_as_uint64, data, size);
|
|
num_as_uint64 = be64toh(num_as_uint64);
|
|
memcpy(&num, &num_as_uint64, size);
|
|
|
|
return num;
|
|
}
|
|
|
|
template<>
|
|
buffer read_type<buffer>(char *data, size_t size)
|
|
{
|
|
buffer ret;
|
|
ret.allocated = size + 1;
|
|
ret.size = size;
|
|
ret.data = (char *)malloc(size * sizeof(char) + 1);
|
|
|
|
return ret;
|
|
}
|
|
|
|
template<typename T>
|
|
struct read_var
|
|
{
|
|
static T call(parsing_buffer* v, size_t size)
|
|
{
|
|
if (size + v->consumed_size > v->buf.size)
|
|
return T{};
|
|
T ret = read_type<T>(v->point, size);
|
|
v->point += sizeof(T);
|
|
v->consumed_size += sizeof(T);
|
|
return ret;
|
|
}
|
|
};
|
|
|
|
|
|
template <typename Integer, Integer ...I, typename F> constexpr void const_for_each_(std::integer_sequence<Integer, I...>, F&& func)
|
|
{
|
|
(func(std::integral_constant<Integer, I>{}), ...);
|
|
}
|
|
|
|
template <auto N, typename F> constexpr void const_for_(F&& func)
|
|
{
|
|
if constexpr (N > 0)
|
|
const_for_each_(std::make_integer_sequence<decltype(N), N>{}, std::forward<F>(func));
|
|
}
|