153 lines
3.5 KiB
C++
153 lines
3.5 KiB
C++
#pragma once
|
|
|
|
#include "buffer.h"
|
|
#include "error.h"
|
|
|
|
#include <cstdint>
|
|
#include <cstring>
|
|
|
|
#include <iostream>
|
|
|
|
namespace saw {
|
|
/**
|
|
* Helper class to encode/decode any primtive type into/from litte endian.
|
|
* The shift class does this by shifting bytes. This type of procedure is
|
|
* platform independent. So it does not matter if the memory layout is
|
|
* little endian or big endian
|
|
*/
|
|
template <typename T, size_t size = sizeof(T)> class shift_stream_value;
|
|
|
|
template <typename T> class shift_stream_value<T, 1> {
|
|
public:
|
|
inline static error decode(T &val, buffer &buffer) {
|
|
uint8_t &raw = reinterpret_cast<uint8_t &>(val);
|
|
return buffer.pop(raw, sizeof(T));
|
|
}
|
|
|
|
inline static error encode(const T &val, buffer &buffer) {
|
|
const uint8_t &raw = reinterpret_cast<const uint8_t &>(val);
|
|
return buffer.push(raw, sizeof(T));
|
|
}
|
|
|
|
inline static size_t size() { return sizeof(T); }
|
|
};
|
|
|
|
template <typename T> class shift_stream_value<T, 2> {
|
|
public:
|
|
inline static error decode(T &val, buffer &buffer) {
|
|
if (buffer.read_composite_length() < sizeof(T)) {
|
|
return recoverable_error("Buffer too small");
|
|
}
|
|
|
|
uint16_t raw = 0;
|
|
|
|
for (size_t i = 0; i < sizeof(T); ++i) {
|
|
raw |= (static_cast<uint16_t>(buffer.read(i)) << (i * 8));
|
|
}
|
|
memcpy(&val, &raw, sizeof(T));
|
|
buffer.read_advance(sizeof(T));
|
|
|
|
return no_error();
|
|
}
|
|
|
|
inline static error encode(const T &val, buffer &buffer) {
|
|
error error = buffer.write_require_length(sizeof(T));
|
|
if (error.failed()) {
|
|
return error;
|
|
}
|
|
|
|
uint16_t raw;
|
|
memcpy(&raw, &val, sizeof(T));
|
|
|
|
for (size_t i = 0; i < sizeof(T); ++i) {
|
|
buffer.write(i) = raw >> (i * 8);
|
|
}
|
|
|
|
buffer.write_advance(sizeof(T));
|
|
return no_error();
|
|
}
|
|
|
|
inline static size_t size() { return sizeof(T); }
|
|
};
|
|
|
|
template <typename T> class shift_stream_value<T, 4> {
|
|
public:
|
|
inline static error decode(T &val, buffer &buffer) {
|
|
if (buffer.read_composite_length() < sizeof(T)) {
|
|
return recoverable_error("Buffer too small");
|
|
}
|
|
|
|
uint32_t raw = 0;
|
|
|
|
for (size_t i = 0; i < sizeof(T); ++i) {
|
|
raw |= (static_cast<uint32_t>(buffer.read(i)) << (i * 8));
|
|
}
|
|
memcpy(&val, &raw, sizeof(T));
|
|
buffer.read_advance(sizeof(T));
|
|
|
|
return no_error();
|
|
}
|
|
|
|
inline static error encode(const T &val, buffer &buffer) {
|
|
error error = buffer.write_require_length(sizeof(T));
|
|
if (error.failed()) {
|
|
return error;
|
|
}
|
|
|
|
uint32_t raw;
|
|
memcpy(&raw, &val, sizeof(T));
|
|
|
|
for (size_t i = 0; i < sizeof(T); ++i) {
|
|
buffer.write(i) = raw >> (i * 8);
|
|
}
|
|
|
|
buffer.write_advance(sizeof(T));
|
|
return no_error();
|
|
}
|
|
|
|
inline static size_t size() { return sizeof(T); }
|
|
};
|
|
|
|
template <typename T> class shift_stream_value<T, 8> {
|
|
public:
|
|
inline static error decode(T &val, buffer &buffer) {
|
|
if (buffer.read_composite_length() < sizeof(T)) {
|
|
return recoverable_error("Buffer too small");
|
|
}
|
|
|
|
uint64_t raw = 0;
|
|
|
|
for (size_t i = 0; i < sizeof(T); ++i) {
|
|
raw |= (static_cast<uint64_t>(buffer.read(i)) << (i * 8));
|
|
}
|
|
|
|
memcpy(&val, &raw, sizeof(T));
|
|
buffer.read_advance(sizeof(T));
|
|
|
|
return no_error();
|
|
}
|
|
|
|
inline static error encode(const T &val, buffer &buffer) {
|
|
error error = buffer.write_require_length(sizeof(T));
|
|
if (error.failed()) {
|
|
return error;
|
|
}
|
|
|
|
uint64_t raw;
|
|
memcpy(&raw, &val, sizeof(T));
|
|
|
|
for (size_t i = 0; i < sizeof(T); ++i) {
|
|
buffer.write(i) = raw >> (i * 8);
|
|
}
|
|
|
|
buffer.write_advance(sizeof(T));
|
|
return no_error();
|
|
}
|
|
|
|
inline static size_t size() { return sizeof(T); }
|
|
};
|
|
|
|
template <typename T> using stream_value = shift_stream_value<T>;
|
|
|
|
} // namespace saw
|