packet_reader.hpp

Go to the documentation of this file.

#ifndef CODEX_PACKET_READER_PACKET_READER_HPP
#define CODEX_PACKET_READER_PACKET_READER_HPP
 
#include <array>
#include <cassert>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <span>
 
namespace codex {
 
enum class Type : uint8_t { INVALID, INT, FLOAT };
 
template<typename T> constexpr Type type_to_enum = Type::INVALID;
template<> constexpr Type type_to_enum<int> = Type::INT;
template<> constexpr Type type_to_enum<float> = Type::FLOAT;
 
template<typename T> concept Readable = type_to_enum<T> != Type::INVALID;
 
using ReadResult = bool;
 
class Packet {
public:
    static constexpr std::size_t N = 32;
    std::span<char, N> data() { return this->buf; }
    auto get(Readable auto *...ps) { return (this->read(ps) && ...); }
private:
    template<typename T> void advance();
    template<typename T> T read();
    template<typename T> ReadResult read(T *p);
    std::array<char, N> buf = {};
    size_t i = {};
};
 
template<typename T>
void Packet::advance() {
    const auto ni = this->i + sizeof(T);
    assert(ni < this->buf.size());
    this->i = ni;
}
 
template<typename T>
T Packet::read() {
    assert(this->i + sizeof(T) <= this->buf.size());
    T ret = {};
    std::memcpy(&ret, this->buf.data() + this->i, sizeof(T));
    return ret;
}
 
template<typename T>
ReadResult Packet::read(T *p) {
    if(this->read<Type>() != type_to_enum<T>)
        return false;
    this->advance<Type>();
    *p = this->read<T>();
    this->advance<T>();
    return true;
}
 
}
 
#endif