Data Packing (C Library)
A C library for packing/unpacking binary data, with no dependencies, and a memory buffer with by-ref or copy.
Works with compilers vs2022, g , clang , cl, and probably more.
Introduction
This C library aims to be easy to use.
The library works with bytes (8 bits) at a time.
The API includes classes Writer and Reader which both extend RWBase.
RWBase stores Buffer, Buffer either uses a std::vector<uint8_t> or a pointer with lengths.
Examples
#include "mxDataPacking.h"
using namespace std;
using namespace mx;
Writer bw;
bw.ui8(10);
bw.ui64(20);
bw.cstr("example", strlen("example") 1);
bw.mstr("example");
//sendOrWrite(bw.data(), bw.length());
//uint8_t* pData =
//uint64_t uiDataLen =
Reader br(pData, uiDataLen);
int a = br.ui8();
int b = br.ui64();
char *c = br.cstr(strlen("example") 1);
string d = br.mstr();Please check the examples folder for other usage examples of this library.
Constructors
To use Reader with data that is stored by reference and readonly: (Preferred for reading)
Reader::Reader(uint8_t* pData, uint64_t uiDataLen, uint64_t uiDataAllocLength = 0);To use Reader with data that is copied and expandable:
Reader::Reader(void);To use Writer with data that is stored by reference and readonly:
Writer(uint8_t* pData, uint64_t uiDataLen, uint64_t uiDataAllocLength = 0);To use Writer with data that is copied and expandable: (Preferred for writing)
Writer::Writer(void);License
This library has the MIT license.
Meaning you can use/edit your copy of this library, even commercially, but include the license file.
Please check the license file named "LICENSE" in the same directory as this Readme.md file.
API
mxDataPacking.h - #include this file in your code.
#pragma once
#include "mx.h"
#include "EEndian.h"
#include "EStorage.h"
#include "Buffer.h"
#include "RWBase.h"
#include "Reader.h"
#include "Writer.h"mx
namespace mx
{
enum EEndian;
enum EStorage;
class Buffer;
class RWBase;
class Reader;
class Writer;
}mx::EEndian
mx::EEndian::INITIAL_ENDIAN = 0;
mx::EEndian::INVERSE_ENDIAN = 1;mx::EStorage
mx::EStorage::STD_VECTOR = 0;
mx::EStorage::POINTER_READONLY = 1;mx::Writer : public mx::RWBase
mx::Writer::Writer(Buffer* pBuffer);
mx::Writer::Writer(uint8_t* pData, uint64_t uiDataLen, uint64_t uiDataAllocLength = 0);
mx::Writer::Writer(void);
void mx::Writer::ui8(uint8_t uiValue);
void mx::Writer::ui16(uint16_t uiValue);
void mx::Writer::ui24(uint32_t uiValue);
void mx::Writer::ui32(uint32_t uiValue);
void mx::Writer::ui64(uint64_t uiValue);
void mx::Writer::i8(int8_t iValue);
void mx::Writer::i16(int16_t iValue);
void mx::Writer::i24(int32_t iValue);
void mx::Writer::i32(int32_t iValue);
void mx::Writer::i64(int64_t iValue);
void mx::Writer::f32(float fValue);
void mx::Writer::f64(double fValue);
void mx::Writer::cstr(char* pData, uint64_t uiLength);
void mx::Writer::mstr(std::string& strData);
void mx::Writer::vec2(float* pFloats);
void mx::Writer::vec3(float* pFloats);
void mx::Writer::vec4(float* pFloats);
void mx::Writer::mat34(float* pFloats);
void mx::Writer::mat43(float* pFloats);
void mx::Writer::mat44(float* pFloats);
template <class T>
void mx::Writer::st(T& structure);
template <class T>
void mx::Writer::stp(T* pStructure);mx::Reader : public mx::RWBase
mx::Reader::Reader(Buffer* pBuffer);
mx::Reader::Reader(uint8_t* pData, uint64_t uiDataLen, uint64_t uiDataAllocLength = 0);
mx::Reader::Reader(void);
uint8_t mx::Reader::ui8();
uint16_t mx::Reader::ui16();
uint32_t mx::Reader::ui24();
uint32_t mx::Reader::ui32();
uint64_t mx::Reader::ui64();
int8_t mx::Reader::i8();
int16_t mx::Reader::i16();
int32_t mx::Reader::i24();
int32_t mx::Reader::i32();
int64_t mx::Reader::i64();
float mx::Reader::f32();
double mx::Reader::f64();
char* mx::Reader::cstr(uint64_t uiLength);
std::string mx::Reader::mstr();
float* mx::Reader::vec2();
float* mx::Reader::vec3();
float* mx::Reader::vec4();
float* mx::Reader::mat34();
float* mx::Reader::mat43();
float* mx::Reader::mat44();
template <class T>
T mx::Reader::st();
template <class T>
T* mx::Reader::stp();mx::RWBase
uint8_t* mx::RWBase::data(); // Returns a pointer to the start of the data.
uint64_t mx::RWBase::length(); // Returns the total length of the data.
void mx::RWBase::reset(); // Resets endian order and buffer, deallocating memory if allocated by this api.
template <class T>
T mx::RWBase::format(T value);
template <class T>
static T mx::RWBase::endian(T value);mx::Buffer
mx::Buffer::Buffer(std::vector<uint8_t>& vecData); // dynamic buffer
mx::Buffer::Buffer(uint8_t* pData, uint64_t uiDataLen, uint64_t uiDataAllocLength = 0); // readonly buffer
mx::Buffer::Buffer(); // dynamic buffer
uint8_t mx::Buffer::storage();
void mx::Buffer::seek(uint64_t uiByteIndex);
uint64_t mx::Buffer::seek();
uint64_t mx::Buffer::length();
uint64_t mx::Buffer::capacity();
uint8_t* mx::Buffer::data();
uint64_t mx::Buffer::left();
uint64_t mx::Buffer::canRW(uint64_t uiByteCount);
uint8_t* mx::Buffer::get(uint64_t uiByteCount);
uint8_t* mx::Buffer::get(uint64_t uiIndex, uint64_t uiByteCount);
void mx::Buffer::seek(uint64_t uiIndex);
void mx::Buffer::push(uint8_t* pData, uint64_t uiByteCount);
void mx::Buffer::push(std::vector<uint8_t>& vecData);
void mx::Buffer::pop(uint64_t uiByteCount);