data.h

Go to the documentation of this file.

#ifndef EOLIB_EO_DATA_H
#define EOLIB_EO_DATA_H
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
#include "result.h"

#define EO_CHAR_MAX 253
#define EO_SHORT_MAX 64009
#define EO_THREE_MAX 16194277
#define EO_INT_MAX 4097152081
#define EO_NUMBER_PADDING 0xFE
#define EO_BREAK_BYTE 0xFF

typedef struct EoWriter
{
    uint8_t *data;                 
    size_t length;                 
    bool string_sanitization_mode; 
    size_t capacity;               
} EoWriter;

typedef struct EoReader
{
    const uint8_t *data;       
    size_t length;             
    size_t offset;             
    bool chunked_reading_mode; 
    size_t chunk_offset;       
    size_t next_chunk_offset;  
} EoReader;

EoResult eo_string_to_windows_1252(const char *value, char **out_value);

EoWriter eo_writer_init(void);

EoWriter eo_writer_init_with_capacity(size_t capacity);

void eo_writer_free(EoWriter *writer);

EoResult eo_writer_ensure_capacity(EoWriter *writer, size_t additional);

EoResult eo_encode_number(int32_t number, uint8_t out_bytes[4]);

int32_t eo_decode_number(const uint8_t *bytes, size_t length);

void eo_decode_string(uint8_t *buf, size_t length);

void eo_encode_string(uint8_t *buf, size_t length);

bool eo_writer_get_string_sanitization_mode(const EoWriter *writer);
void eo_writer_set_string_sanitization_mode(EoWriter *writer, bool enabled);

EoResult eo_writer_add_byte(EoWriter *writer, uint8_t value);

EoResult eo_writer_add_char(EoWriter *writer, int32_t value);

EoResult eo_writer_add_short(EoWriter *writer, int32_t value);

EoResult eo_writer_add_three(EoWriter *writer, int32_t value);

EoResult eo_writer_add_int(EoWriter *writer, int32_t value);

EoResult eo_writer_add_string(EoWriter *writer, const char *value);

EoResult eo_writer_add_encoded_string(EoWriter *writer, const char *value);

EoResult eo_writer_add_fixed_string(EoWriter *writer, const char *value, size_t length, bool padded);

EoResult eo_writer_add_fixed_encoded_string(EoWriter *writer, const char *value, size_t length, bool padded);

EoResult eo_writer_add_bytes(EoWriter *writer, const uint8_t *data, size_t length);

EoReader eo_reader_init(const uint8_t *data, size_t length);

bool eo_reader_get_chunked_reading_mode(const EoReader *reader);

void eo_reader_set_chunked_reading_mode(EoReader *reader, bool enabled);

size_t eo_reader_remaining(const EoReader *reader);

EoResult eo_reader_next_chunk(EoReader *reader);

EoResult eo_reader_get_byte(EoReader *reader, uint8_t *out_value);

EoResult eo_reader_get_char(EoReader *reader, int32_t *out_value);

EoResult eo_reader_get_short(EoReader *reader, int32_t *out_value);

EoResult eo_reader_get_three(EoReader *reader, int32_t *out_value);

EoResult eo_reader_get_int(EoReader *reader, int32_t *out_value);

EoResult eo_reader_get_string(EoReader *reader, char **out_value);

EoResult eo_reader_get_encoded_string(EoReader *reader, char **out_value);

EoResult eo_reader_get_fixed_string(EoReader *reader, size_t length, char **out_value);

EoResult eo_reader_get_fixed_encoded_string(EoReader *reader, size_t length, char **out_value);

EoResult eo_reader_get_bytes(EoReader *reader, size_t length, uint8_t **out_value);

typedef struct EoSerialize EoSerialize;
 
typedef struct
{
    EoResult (*deserialize)(EoSerialize *self, EoReader *reader);
    EoResult (*serialize)(const EoSerialize *self, EoWriter *writer);
    size_t (*get_size)(const EoSerialize *self);
    void (*free)(EoSerialize *self);
} EoSerializeVTable;
 
struct EoSerialize
{
    const EoSerializeVTable *vtable;
};

static inline EoResult eo_deserialize(EoSerialize *serialize, EoReader *reader)
{
    if (!serialize || !reader)
        return EO_NULL_PTR;
    return serialize->vtable->deserialize(serialize, reader);
}

static inline EoResult eo_serialize(const EoSerialize *serialize, EoWriter *writer)
{
    if (!serialize || !writer)
        return EO_NULL_PTR;
    return serialize->vtable->serialize(serialize, writer);
}

static inline size_t eo_get_size(const EoSerialize *serialize)
{
    if (!serialize)
        return 0;
    return serialize->vtable->get_size(serialize);
}

static inline void eo_free(EoSerialize *serialize)
{
    if (!serialize || !serialize->vtable || !serialize->vtable->free)
        return;
    serialize->vtable->free(serialize);
}

typedef struct EoPacket EoPacket;
typedef struct
{
    uint8_t (*get_family)(const EoPacket *self);
    uint8_t (*get_action)(const EoPacket *self);
} EoPacketVTable;
 
struct EoPacket
{
    EoSerialize base;
    const EoPacketVTable *vtable;
};

static inline uint8_t eo_packet_get_family(const EoPacket *packet)
{
    if (!packet)
        return 0;
    return packet->vtable->get_family(packet);
}

static inline uint8_t eo_packet_get_action(const EoPacket *packet)
{
    if (!packet)
        return 0;
    return packet->vtable->get_action(packet);
}
 
#endif