libsheepySmall.h

Go to the documentation of this file.

// MIT License
//
// Copyright (c) 2023 Remy Noulin
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
#pragma once

#include <stdbool.h>
#include <stdint.h>
#include "libsheepy.h"

typedef enum {
  NOT_AN_OBJECT, UNDEFINED, BOOL, CONTAINER, DICT, DICT_ELEM, DOUBLE, INT, STRING, FASTSTRING, ARRAY, BYTES
} smallTypet;

static const char *SMALL_TYPE_NAMES[] UNUSED = {
    "not a sheepy object",
    "undefined",
    "bool",
    "container",
    "dict",
    "element",
    "double",
    "int",
    "string",
    "faststring",
    "array",
    "bytes"
};

typedef struct {
  char type;
} smallt;

typedef struct {
  char type;
  bool value;
} sBoolt;

typedef void (*freeSContainerFt)(void *data);
typedef struct {
  char type;
  char dataType;
  // data is an array of size size
  void *data;
  freeSContainerFt free;
} sContainert;

// libsheepy dataTypes in sContainert (SH for libsheepy, DT for dataType)
enum { SH_DT_UNKNOWN, SH_DT_BASET};

typedef struct {
  char *key;
  smallt *data;
} sDictElemt;

typedef struct {
  char type;
  uint32_t count;
  uint32_t maxCount;
  // data is an array of sDictElemt
  sDictElemt elements;
} sDictt;

typedef struct {
  char type;
  double value;
} sDoublet;

typedef struct {
  char type;
  int64_t value;
} sIntt;

typedef struct {
  char type;
  // data is the start of the string
  char data;
} sStringt;

// TODO
typedef struct {
  char type;
  uint32_t count;
  uint32_t maxCount;
  // data is the start of the string
  char data;
} sFastStringt;

typedef struct {
  char type;
  uint32_t count;
  uint32_t maxCount;
  // data is an array of pointers
  smallt *data;
} sArrayt;

typedef struct {
  char type;
} sUndefinedt;

typedef struct {
  char type;
  uint32_t count;
  // data is a byte array
  char data;
} sBytest;

#define isSType(obj, sType) (((smallt *) (obj))->type == sType)
bool isSTypeF(smallt *obj, char sType);

#define getSType(obj) obj ? ((smallt *) (obj))->type : -1

#define getSTypeS(obj) obj ? SMALL_TYPE_NAMES[(unsigned char)((smallt *) (obj))->type] : NULL

size_t sSizeTiny(smallt *obj);

sBoolt* allocSBool(bool value) MUST_CHECK;
sContainert* allocSContainer(void *data) MUST_CHECK;
sDictt* allocSDict(void) MUST_CHECK;
sDoublet* allocSDouble(double value) MUST_CHECK;
sIntt* allocSInt(int64_t value) MUST_CHECK;
sStringt* allocSStringTiny(const char* data) MUST_CHECK;
sArrayt* allocSArray(void) MUST_CHECK;
sUndefinedt* allocSUndefined(void) MUST_CHECK;
sBytest* allocSBytes(void) MUST_CHECK;

void sFree(smallt *obj);
void sFreeTiny(smallt *obj);
void sDictFreeTiny(sDictt *dict);
void sArrayFreeTiny(sArrayt *array);

smallt* sDuplicate(smallt *o) MUST_CHECK;
smallt* sDuplicateTiny(smallt *obj) MUST_CHECK;
sDictt* sDictDuplicateTiny(sDictt *dict) MUST_CHECK;
sArrayt* sArrayDuplicateTiny(sArrayt *obj) MUST_CHECK;

char* sToStringTiny(smallt *obj) MUST_CHECK;
char* sToString(smallt *obj) MUST_CHECK;
char* sBoolToStringTiny(sBoolt* obj) MUST_CHECK;
char* sContainerToStringTiny(sContainert* obj) MUST_CHECK;
char* sDictToStringTiny(sDictt* obj) MUST_CHECK;
char* sDoubleToStringTiny(sDoublet* obj) MUST_CHECK;
char* sIntToStringTiny(sIntt* obj) MUST_CHECK;
char* sStringToStringTiny(sStringt* obj) MUST_CHECK;
char* sArrayToStringTiny(sArrayt* obj) MUST_CHECK;
char* sUndefinedToStringTiny(sUndefinedt* obj) MUST_CHECK;
char* sBytesToStringTiny(sBytest* obj) MUST_CHECK;

char* sEscapeTiny(smallt *obj) MUST_CHECK;
char* sEscape(smallt *obj) MUST_CHECK;
char* sDictEscapeTiny(sDictt* obj) MUST_CHECK;
char* sStringEscapeTiny(sStringt* obj) MUST_CHECK;
char* sArrayEscapeTiny(sArrayt* obj) MUST_CHECK;

char* sTypesTiny(smallt* obj) MUST_CHECK;
sBytest* sTypesToBytesTiny(smallt *obj) MUST_CHECK;
const char** sDictTypeStrings(sDictt* obj) MUST_CHECK;
sBytest* sDictTypes(sDictt* obj) MUST_CHECK;
sBytest* sDictTypesTiny(sDictt* obj) MUST_CHECK;
const char** sArrayTypeStrings(sArrayt* obj) MUST_CHECK;
sBytest* sArrayTypes(sArrayt* obj) MUST_CHECK;
sBytest* sArrayTypesTiny(sArrayt* obj) MUST_CHECK;

// forEach - loop macro on elements
#define forEachSDict(dict, element) \
  sDictElemt *element = &((dict)->elements); \
  for (size_t UNIQVAR(libsheepyInternalIndex) = 0; UNIQVAR(libsheepyInternalIndex) < (dict)->count ; UNIQVAR(libsheepyInternalIndex)++, element = UNIQVAR(libsheepyInternalIndex) < (dict)->count ? &((dict)->elements) + UNIQVAR(libsheepyInternalIndex) : NULL)

#define enumerateSDict(dict, element, index) \
  sDictElemt *element = &((dict)->elements); \
  for (size_t index = 0; index < (dict)->count ; index++, index < (dict)->count ? element = &((dict)->elements) + index : NULL)

#define forEachSArray(array, element) \
  smallt *element = ((smallt **) &((array)->data))[0]; \
  for (size_t UNIQVAR(libsheepyInternalIndex) = 0; UNIQVAR(libsheepyInternalIndex) < (array)->count ; UNIQVAR(libsheepyInternalIndex)++, element = UNIQVAR(libsheepyInternalIndex) < (array)->count ? ((smallt **) &((array)->data))[UNIQVAR(libsheepyInternalIndex)] : NULL)

#define enumerateSArray(array, element, index) \
  smallt *element = ((smallt **) &((array)->data))[0]; \
  for (size_t index = 0; index < (array)->count ; index++, element = index < (array)->count ? ((smallt **) &((array)->data))[index] : NULL)

// TODO forEachSBytes

smallt* sDictGet(sDictt *dict, const char *key) MUST_CHECK;
smallt** sDictGetP(sDictt *dict, const char *key) MUST_CHECK;
smallt* sDictGetTiny(sDictt *dict, const char *key) MUST_CHECK;
smallt* sDictElemGet(sDictElemt *dictElement) MUST_CHECK;
void sDictSetP(sDictt **dict, const char *key, smallt *data);
void sDictSetTiny(sDictt **dict, const char *key, smallt *data);
void sDictPushTiny(sDictt **dict, const char *key, smallt *data);
void sDictDelTiny(sDictt *dict, const char *key);

char* sStringGetTiny(sStringt *string) MUST_CHECK;
void sStringSetTiny(sStringt **string, const char *news);

void sArrayPushTiny(sArrayt **array, smallt* data);
void sArrayPrependTiny(sArrayt **array, smallt* data);
smallt* sArrayPopTiny(sArrayt *array) MUST_CHECK;
smallt* sArrayDequeueTiny(sArrayt *array) MUST_CHECK;
smallt** sArrayGetP(sArrayt *array, uint32_t index) MUST_CHECK;
smallt* sArrayGetTiny(sArrayt *array, uint32_t index) MUST_CHECK;
void sArraySetShortTiny(sArrayt *array, uint32_t index, smallt *value);
void sArraySetP(sArrayt *array, uint32_t index, smallt *value);
void sArraySetTiny(sArrayt *array, uint32_t index, smallt *value);
int sArrayReverseTiny(sArrayt *array) MUST_CHECK;
void sArrayDelTiny(sArrayt *array, uint32_t index);
void sArrayDelRangeTiny(sArrayt *array, uint32_t start, uint32_t end);

// get void* from sBytes
void* sBytesGet(sBytest *bytes) MUST_CHECK;
void* sBytesGetTiny(sBytest *bytes) MUST_CHECK;
void sBytesPush(sBytest **bytes, char data);
// function to copy data from void* to sBytes
void sBytesPushBuffer(sBytest **bytes, void* data, uint32_t size);
void sBytesPushBufferTiny(sBytest **bytes, void* data, uint32_t size);

// serialyzer/deserialyzer
sBytest *sSerial(smallt *obj) MUST_CHECK;
sBytest *sSerialTiny(smallt *obj) MUST_CHECK;
void sDictSerialElementsTiny(sBytest **r, sDictt *dict);
void sArraySerialElementsTiny(sBytest **r, sArrayt *array);
smallt* sDeserial(sBytest *obj) MUST_CHECK;
smallt* sDeserialTiny(sBytest *obj) MUST_CHECK;
void sDictDeserialElementsTiny(sDictt **dict, char **data);
void sArrayDeserialElementsTiny(sArrayt **array, char **data);