libsheepySmall.c

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.

#include "libsheepySmall.h"
#include <inttypes.h>

#define internal static

#include <stdint.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <stdio.h>

bool isSTypeF(smallt *obj, char sType);
size_t sSizeTiny(smallt *obj);
sBoolt* allocSBool(bool value);
sContainert* allocSContainer(void *data);
sDictt* allocSDict(void);
sDoublet* allocSDouble(double value);
sIntt* allocSInt(int64_t value);
sStringt* allocSStringTiny(const char* data);
sArrayt* allocSArray(void);
sUndefinedt* allocSUndefined(void);
sBytest* allocSBytes(void);
void sFree(smallt *obj);
void sFreeTiny(smallt *obj);
void sDictFreeElement(sDictElemt *e);
void sDictFreeElements(sDictt *dict);
void sDictFreeTiny(sDictt *dict);
void sArrayFreeElements(sArrayt *array);
void sArrayFreeTiny(sArrayt *array);
smallt* sDuplicate(smallt *o);
smallt* sDuplicateTiny(smallt *obj);
sDictt* sDictDuplicateTiny(sDictt *dict);
sArrayt* sArrayDuplicateTiny(sArrayt *array);
char* sToStringTiny(smallt *obj);
char* sToString(smallt *obj);
char* sBoolToStringTiny(sBoolt* obj);
char* sContainerToStringTiny(sContainert* obj UNUSED);
char* sDictToStringTiny(sDictt* obj);
char* sDoubleToStringTiny(sDoublet* obj);
char* sIntToStringTiny(sIntt* obj);
char* sStringToStringTiny(sStringt* obj);
char* sArrayToStringTiny(sArrayt* obj);
char* sUndefinedToStringTiny(sUndefinedt* obj UNUSED);
char* sBytesToStringTiny(sBytest* obj);
char* sEscapeTiny(smallt *obj);
char* sEscape(smallt *obj);
char* sDictEscapeTiny(sDictt* obj);
char* sStringEscapeTiny(sStringt* obj);
char* sArrayEscapeTiny(sArrayt* obj);
char* sTypesTiny(smallt* obj);
sBytest* sTypesToBytesTiny(smallt *obj);
const char** sDictTypeStrings(sDictt* obj);
const char ** sTypesToStrings(sBytest *types);
sBytest* sDictTypes(sDictt* obj);
sBytest* sDictTypesTiny(sDictt* obj);
const char** sArrayTypeStrings(sArrayt* obj);
sBytest* sArrayTypes(sArrayt* obj);
sBytest* sArrayTypesTiny(sArrayt* obj);
smallt* sDictGet(sDictt *dict, const char *key);
smallt** sDictGetP(sDictt *dict, const char *key);
smallt* sDictGetTiny(sDictt *dict, const char *key);
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);
void sStringSetTiny(sStringt **string, const char *news);
void sArrayPushTiny(sArrayt **array, smallt* data);
void sArrayPrependTiny(sArrayt **array, smallt* data);
smallt* sArrayPopTiny(sArrayt *array);
smallt* sArrayDequeueTiny(sArrayt *array);
smallt** sArrayGetP(sArrayt *array, uint32_t index);
smallt* sArrayGetTiny(sArrayt *array, uint32_t index);
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);
void sArrayDelTiny(sArrayt *array, uint32_t index);
void sArrayDelRangeTiny(sArrayt *array, uint32_t start, uint32_t end);
void* sBytesGet(sBytest *bytes);
void* sBytesGetTiny(sBytest *bytes);
void sBytesPush(sBytest **bytes, char data);
void sBytesPushBuffer(sBytest **bytes, void* data, uint32_t size);
void sBytesPushBufferTiny(sBytest **bytes, void* data, uint32_t size);
sBytest *sSerial(smallt *obj);
sBytest *sSerialTiny(smallt *obj);
void sDictSerialElementsTiny(sBytest **r, sDictt *dict);
void sArraySerialElementsTiny(sBytest **r, sArrayt *array);
smallt* sDeserial(sBytest *obj);
smallt* sDeserialTiny(sBytest *obj);
void sDictDeserialElementsTiny(sDictt **dict, char **data);
void sArrayDeserialElementsTiny(sArrayt **array, char **data);

// min MIN_ELEMENTS is 1
#define SDICT_MIN_ELEMENTS     12
#define SDICT_REALLOC_STEPS    4
// min MIN_ELEMENTS is 1
#define SARRAY_MIN_ELEMENTS    4
#define SARRAY_REALLOC_STEPS   4

bool isSTypeF(smallt *obj, char sType) {

  if (!obj) {
    return(false);
  }
  return(isSType(obj, sType));
}

size_t sSizeTiny(smallt *obj) {
  size_t r = 0;;

  /* if !obj */
  /*   return 0 */

  switch(obj->type) {
    case UNDEFINED:
      r = sizeof(sUndefinedt);
      break;
    case BOOL:
      r = sizeof(sBoolt);
      break;
    case CONTAINER:
      r = sizeof(sContainert);
      break;
    case DICT:
      if (!((sDictt *)obj)->count) {
        r = sizeof(sDictt);
      }
      else {
        r = sizeof(sDictt) + sizeof(sDictElemt) * (((sDictt *)obj)->count - 1);
      }
      break;
    case DOUBLE:
      r = sizeof(sDoublet);
      break;
    case INT:
      r = sizeof(sIntt);
      break;
    case STRING:
      r = sizeof(sStringt) + strlen(&(((sStringt *)obj)->data));
      break;
    case ARRAY:
      if (!((sArrayt* )obj)->count) {
        r = sizeof(sArrayt);
      }
      else {
        r = sizeof(sArrayt) + sizeof(smallt *) * (((sArrayt* )obj)->count - 1);
      }
      break;
    case BYTES:
      if (!((sBytest* )obj)->count) {
        r = sizeof(sBytest);
      }
      else {
        r = sizeof(sBytest) + sizeof(char) * (((sBytest* )obj)->count - 1);
      }
      break;
    default:;
      // return 0
  }
  return(r);
}

sBoolt* allocSBool(bool value) {
  sBoolt *r = NULL;

  isError(r, malloc(sizeof(sBoolt))) return(NULL);
  r->type  = BOOL;
  r->value = value;
  return(r);
}

sContainert* allocSContainer(void *data) {
  sContainert *r = NULL;

  isError(r, malloc(sizeof(sContainert))) return(NULL);
  r->type     = CONTAINER;
  r->dataType = SH_DT_UNKNOWN;
  r->data     = data;
  r->free     = NULL;
  return(r);
}

sDictt* allocSDict(void) {
  sDictt *r = NULL;

  isError(r, malloc(sizeof(sDictt) + sizeof(sDictElemt) * (SDICT_MIN_ELEMENTS-1))) return(NULL);
  r->type     = DICT;
  r->count    = 0;
  r->maxCount = SDICT_MIN_ELEMENTS;
  return(r);
}

sDoublet* allocSDouble(double value) {
  sDoublet *r = NULL;

  isError(r, malloc(sizeof(sDoublet))) return(NULL);
  r->type  = DOUBLE;
  r->value = value;
  return(r);
}

sIntt* allocSInt(int64_t value) {
  sIntt *r = NULL;

  isError(r, malloc(sizeof(sIntt))) return(NULL);
  r->type  = INT;
  r->value = value;
  return(r);
}

sStringt* allocSStringTiny(const char* data) {
  sStringt *r = NULL;
  size_t len;
  char *T = NULL;

  len      = strlen(data);
  isError(r, malloc(sizeof(sStringt) + len)) return(NULL);
  r->type  = STRING;
  // should be: strcpy(&(r->data), data); but it fails (Abort trap 6) with clang / macOS
  T = &(r->data);;
  strcpy(T, data);
  return(r);
}

// keep data uninitialized (count)
sArrayt* allocSArray(void) {
  sArrayt *r = NULL;

  isError(r, malloc(sizeof(sArrayt) + sizeof(smallt *) * SARRAY_MIN_ELEMENTS)) return(NULL);
  r->type     = ARRAY;
  r->count    = 0;
  r->maxCount = SARRAY_MIN_ELEMENTS;
  return(r);
}

sUndefinedt* allocSUndefined(void) {
  sUndefinedt *r = NULL;

  isError(r, malloc(sizeof(sUndefinedt))) return(NULL);
  r->type = UNDEFINED;
  return(r);
}

sBytest* allocSBytes(void) {
  sBytest *r = NULL;

  isError(r, malloc(sizeof(sBytest))) return(NULL);
  r->type     = BYTES;
  r->count    = 0;
  return(r);
}

void sFree(smallt *obj) {

  if (obj) {
    sFreeTiny(obj);
}
  }

void sFreeTiny(smallt *obj) {
  sContainert *c = NULL;

  switch(obj->type) {
    case DICT:
      sDictFreeTiny((sDictt *) obj);
      break;
    case ARRAY:
      sArrayFreeTiny((sArrayt *) obj);
      break;
    case CONTAINER:
      c = (sContainert*)obj;
      if (c->free) {
        c->free(c->data);
        c->data = NULL;
      }
      free(obj);
      break;
    default:
      free(obj);
  }
}

void sDictFreeElement(sDictElemt *e) {

  if (e->key) {
    free(e->key);
    sFreeTiny(e->data);
    e->key = NULL;
}
  }

void sDictFreeElements(sDictt *dict) {

  forEachSDict(dict, e) {
      sDictFreeElement(e);
}
  }

void sDictFreeTiny(sDictt *dict) {

  sDictFreeElements(dict);
  free(dict);
}

void sArrayFreeElements(sArrayt *array) {

  forEachSArray(array, e) {
    sFree(e);
}
  }

void sArrayFreeTiny(sArrayt *array) {

  sArrayFreeElements(array);
  free(array);
}

smallt* sDuplicate(smallt *o) {

  if (!o) {
    return(NULL);
  }

  return(sDuplicateTiny(o));
}

smallt* sDuplicateTiny(smallt *obj) {
  smallt *r = NULL;
  sBytest *B = NULL;
  sContainert *c = NULL;

  switch(obj->type) {
    case UNDEFINED:
      r = (smallt *)allocSUndefined();
      break;
    case BOOL:
      r = (smallt *)allocSBool(((sBoolt *)obj)->value);
      break;
    case CONTAINER:
      // data is not copied, same data pointer is used
      isError(c, allocSContainer(((sContainert *)obj)->data)) return(NULL);
      c->dataType = ((sContainert *)obj)->dataType;
      c->free     = ((sContainert *)obj)->free;
      r           = (smallt *)c;
      break;
    case DICT:
      r = (smallt *)sDictDuplicateTiny((sDictt *)obj);
      break;
    case DOUBLE:
      r = (smallt *)allocSDouble(((sDoublet *)obj)->value);
      break;
    case INT:
      r = (smallt *)allocSInt(((sIntt *)obj)->value);
      break;
    case STRING:
      r = (smallt *) strdup((char *) obj);;
      break;
    case ARRAY:
      r = (smallt *)sArrayDuplicateTiny((sArrayt *)obj);
      break;
    case BYTES:
      isError(B, allocSBytes()) return(NULL);
      if (((sBytest *)obj)->count) {
        sBytesPushBuffer(&B, sBytesGetTiny((sBytest *)obj), ((sBytest *)obj)->count);
      }
      r = (smallt *) B;
      break;
    default:
      logME(libsheepyErrorMask, "Unsupported object type.");
  }
  return(r);
}

sDictt* sDictDuplicateTiny(sDictt *dict) {

  sDictt *d = allocSDict();
  if (!d) {
    return(NULL);
  }

  forEachSDict(dict, e) {
    if (e->key) {
      smallt *eDup = sDuplicateTiny(e->data);
      sDictPushTiny(&d, e->key, eDup);
  }
    }
  return(d);
}

sArrayt* sArrayDuplicateTiny(sArrayt *array) {

  sArrayt *a = allocSArray();
  if (!a) {
    return(NULL);
  }

  forEachSArray(array, e) {
    sArrayPushTiny(&a, sDuplicate(e));
  }
  return(a);
}

char* sToStringTiny(smallt *obj) {
  char *r = NULL;

  switch(obj->type) {
    case UNDEFINED:
      r = sUndefinedToStringTiny((sUndefinedt *)obj);
      break;
    case BOOL:
      r = sBoolToStringTiny((sBoolt *)obj);
      break;
    case CONTAINER:
      r = sContainerToStringTiny((sContainert *)obj);
      break;
    case DICT:
      r = sDictToStringTiny((sDictt *)obj);
      break;
    case DOUBLE:
      r = sDoubleToStringTiny((sDoublet *)obj);
      break;
    case INT:
      r = sIntToStringTiny((sIntt *)obj);
      break;
    case STRING:
      r = sStringToStringTiny((sStringt *)obj);
      break;
    case ARRAY:
      r = sArrayToStringTiny((sArrayt* )obj);
      break;
    case BYTES:
      r = sBytesToStringTiny((sBytest* )obj);
      break;
    default:
      logME(libsheepyErrorMask, "Unsupported object type.");
  }
  return(r);
}

char* sToString(smallt *obj) {

  if (obj) {
    return(sToStringTiny(obj));
  }
  return(NULL);
}

char* sBoolToStringTiny(sBoolt* obj) {

  if (obj->value) {
    return(strdup("true"));
  }
  else {
    return(strdup("false"));
}
  }

char* sContainerToStringTiny(sContainert* obj UNUSED) {

  return(strdup("<data container>"));
}

char* sDictToStringTiny(sDictt* obj) {
  char *s = NULL;

  if (!obj->count) {
    return(strdup("{}"));
  }

  char *r = strdup("{");

  bool hasAtLeastOneElement = no;

  forEachSDict(obj, e) {
    if (e->key) {
      hasAtLeastOneElement = yes;
      pErrorNULL(iAppendS(&r, "\""));
      pErrorNULL(iAppendS(&r, e->key));
      pErrorNULL(iAppendS(&r, "\""));
      if (isSType(e->data, STRING) || isSType(e->data, CONTAINER)) {
        // add quotes for strings
        pErrorNULL(iAppendS(&r, ":\""));
        s = sToStringTiny(e->data);
        pErrorNULL(iAppendS(&r, s));
        free(s);
        pErrorNULL(iAppendS(&r, "\","));
      }
      else {
        pErrorNULL(iAppendS(&r, ":"));
        s = sToStringTiny(e->data);
        pErrorNULL(iAppendS(&r, s));
        free(s);
        pErrorNULL(iAppendS(&r, ","));
  }
    }
      }

  if (hasAtLeastOneElement) {
    pErrorNULL(setS(r, -1, '}'));
  }
  else {
    pErrorNULL(iAppendS(&r, "}"));
  }
  return(r);
}

char* sDoubleToStringTiny(sDoublet* obj) {
  char *s = NULL;

  isError(s, malloc(256*sizeof(char))) return(NULL);
  snprintf(s,256, "%e", obj->value);

  return(s);
}

char* sIntToStringTiny(sIntt* obj) {
  char *s = NULL;

  isError(s, malloc(256*sizeof(char))) return(NULL);
  snprintf(s,256, "%" PRIi64, obj->value);

  return(s);
}

char* sStringToStringTiny(sStringt* obj) {

  return(strdup(sStringGetTiny(obj)));
}

char* sArrayToStringTiny(sArrayt* obj) {
  char *s = NULL;

  if (!obj->count) {
    return(strdup("[]"));
  }

  char *r      = strdup("[");
  uint32_t cnt   = 0;;
  bool emptySlot = false;;
  forEachSArray(obj, o) {
    if (!o) {
      // empty slot
      emptySlot = true;;
      continue;
    }
    emptySlot = false;;
    cnt++;
    if (isSType(o, STRING) || isSType(o, CONTAINER)) {
      // add quotes for strings
      pErrorNULL(iAppendS(&r, "\""));
      s = sToStringTiny(o);
      pErrorNULL(iAppendS(&r, s));
      free(s);
      pErrorNULL(iAppendS(&r, "\""));
    }
    else {
      s = sToStringTiny(o);
      pErrorNULL(iAppendS(&r, s));
      free(s);
    }
    pErrorNULL(iAppendS(&r, ","));
  }
  if (!cnt && emptySlot) {
    pErrorNULL(iAppendS(&r, "]"));
  }
  else {
    pErrorNULL(setS(r, -1, ']'));
  }
  return(r);
}

char* sUndefinedToStringTiny(sUndefinedt* obj UNUSED) {

  return(strdup("null"));
}

char* sBytesToStringTiny(sBytest* obj) {

  if (!obj->count) {
    return(strdup("[]"));
  }

  char *r = toHexSepS(&(obj->data), obj->count, ",");
  pErrorNULL(iPrependS(&r, "["));
  pErrorNULL(iAppendS(&r, "]"));
  return(r);
}

char* sEscapeTiny(smallt *obj) {
  char *r = NULL;

  switch(obj->type) {
    case UNDEFINED:
      r = sUndefinedToStringTiny((sUndefinedt *)obj);
      break;
    case BOOL:
      r = sBoolToStringTiny((sBoolt *)obj);
      break;
    case CONTAINER:
      r = sContainerToStringTiny((sContainert *)obj);
      break;
    case DICT:
      r = sDictEscapeTiny((sDictt *)obj);
      break;
    case DOUBLE:
      r = sDoubleToStringTiny((sDoublet *)obj);
      break;
    case INT:
      r = sIntToStringTiny((sIntt *)obj);
      break;
    case STRING:
      r = sStringEscapeTiny((sStringt *)obj);
      break;
    case ARRAY:
      r = sArrayEscapeTiny((sArrayt* )obj);
      break;
    case BYTES:
      r = sBytesToStringTiny((sBytest* )obj);
      break;
    default:
      logME(libsheepyErrorMask, "Unsupported object type.");
  }
  return(r);
}

char* sEscape(smallt *obj) {

  if (obj) {
    return(sEscapeTiny(obj));
  }
  return(NULL);
}

char* sDictEscapeTiny(sDictt* obj) {
  char *s = NULL;

  if (!obj->count) {
    return(strdup("{}"));
  }

  char *r = strdup("{");

  bool hasAtLeastOneElement = no;

  forEachSDict(obj, e) {
    if (e->key) {
      hasAtLeastOneElement = yes;
      pErrorNULL(iAppendS(&r, "\""));
      pErrorNULL(iAppendNFreeS(&r, escapeS(e->key, '\"')));
      pErrorNULL(iAppendS(&r, "\""));
      if (isSType(e->data, STRING)) {
        // add quotes for strings
        pErrorNULL(iAppendS(&r, ":\""));
        s = sEscapeTiny(e->data);
        pErrorNULL(iAppendS(&r, s));
        free(s);
        pErrorNULL(iAppendS(&r, "\","));
      }
      else if (isSType(e->data, CONTAINER)) {
        // add quotes for strings
        pErrorNULL(iAppendS(&r, ":\""));
        s = sToStringTiny(e->data);
        pErrorNULL(iAppendS(&r, s));
        free(s);
        pErrorNULL(iAppendS(&r, "\","));
      }
      else {
        pErrorNULL(iAppendS(&r, ":"));
        s = sEscapeTiny(e->data);
        pErrorNULL(iAppendS(&r, s));
        free(s);
        pErrorNULL(iAppendS(&r, ","));
  }
    }
      }

  if (hasAtLeastOneElement) {
    pErrorNULL(setS(r, -1, '}'));
  }
  else {
    pErrorNULL(iAppendS(&r, "}"));
  }
  return(r);
}

char* sStringEscapeTiny(sStringt* obj) {

  return(escapeS(sStringGetTiny(obj), '\"'));
}

char* sArrayEscapeTiny(sArrayt* obj) {
  char *s = NULL;

  if (!obj->count) {
    return(strdup("[]"));
  }

  char *r      = strdup("[");
  uint32_t cnt   = 0;;
  bool emptySlot = false;;
  forEachSArray(obj, o) {
    if (!o) {
      // empty slot
      emptySlot = true;;
      continue;
    }
    emptySlot = false;;
    cnt++;
    if (isSType(o, STRING)) {
      // add quotes for strings
      pErrorNULL(iAppendS(&r, "\""));
      s = sEscapeTiny(o);
      pErrorNULL(iAppendS(&r, s));
      free(s);
      pErrorNULL(iAppendS(&r, "\""));
    }
    else if (isSType(o, CONTAINER)) {
      // add quotes for strings
      pErrorNULL(iAppendS(&r, "\""));
      s = sToStringTiny(o);
      pErrorNULL(iAppendS(&r, s));
      free(s);
      pErrorNULL(iAppendS(&r, "\""));
    }
    else {
      s = sEscapeTiny(o);
      pErrorNULL(iAppendS(&r, s));
      free(s);
    }
    pErrorNULL(iAppendS(&r, ","));
  }
  if (!cnt && emptySlot) {
    pErrorNULL(iAppendS(&r, "]"));
  }
  else {
    pErrorNULL(setS(r, -1, ']'));
  }
  return(r);
}

char* sTypesTiny(smallt* obj) {
  char *r = NULL;
  sArrayt *a = NULL;
  sBytest *types = NULL;

  isError(types, sTypesToBytesTiny(obj)) return(NULL);

  for (uint32_t i = 0; i < types->count;i++) {
    char b = (&(types->data))[i];
    if ((size_t)b >= ARRAY_SIZE(SMALL_TYPE_NAMES)) {
      free(types);
      if (a) {
        sArrayFreeTiny(a);
      }
      return(NULL);
    }
    sStringt *s = allocSStringTiny(SMALL_TYPE_NAMES[(size_t) b]);
    if (!s) {
      free(types);
      if (a) {
        sArrayFreeTiny(a);
      }
      return(NULL);
    }
    sArrayPushTiny(&a, (smallt *) s);
  }

  r = sArrayToStringTiny(a);
  free(types);
  sArrayFreeTiny(a);
  return(r);
}

sBytest* sTypesToBytesTiny(smallt *obj) {
  sBytest *r = NULL;

  switch(obj->type) {
    case DICT:
      r = sDictTypesTiny((sDictt *) obj);;
      break;
    case ARRAY:
      r = sArrayTypesTiny((sArrayt *) obj);;
      break;
    default:;
  }
  return(r);
}

const char** sDictTypeStrings(sDictt* obj) {

  sBytest *types  = sDictTypes(obj);

  return(sTypesToStrings(types));
}

const char ** sTypesToStrings(sBytest *types) {
  const char **r = NULL;

  if (!types) {
    return(NULL);
  }

  isError(r, malloc((types->count+1) * sizeof(char *))) return(NULL);
  r[types->count] = NULL;

  for (uint32_t i = 0 ; i < types->count ; i++) {
    char b = (&(types->data))[i];
    if ((size_t)b >= ARRAY_SIZE(SMALL_TYPE_NAMES)) {
      free(r);
      return(NULL);
    }
    r[i]   = SMALL_TYPE_NAMES[(size_t) b];
  }

  free(types);
  return(r);
}

sBytest* sDictTypes(sDictt* obj) {

  if (!obj || !isSType(obj, DICT)) {
    return(NULL);
  }

  return(sDictTypesTiny(obj));
}

sBytest* sDictTypesTiny(sDictt* obj) {
  sBytest *r = NULL;

  forEachSDict(obj, e) {
    if (e->key) {
      sBytesPush(&r, e->data->type);
  }
    }

  return(r);
}

const char** sArrayTypeStrings(sArrayt* obj) {

  sBytest *types  = sArrayTypes(obj);

  return(sTypesToStrings(types));
}

sBytest* sArrayTypes(sArrayt* obj) {

  if (!obj || !isSType(obj, ARRAY)) {
    return(NULL);
  }

  return(sArrayTypesTiny(obj));
}

sBytest* sArrayTypesTiny(sArrayt* obj) {
  sBytest *r = NULL;

  forEachSArray(obj, e) {
    if (e) {
      sBytesPush(&r, e->type);
  }
    }

  return(r);
}

smallt* sDictGet(sDictt *dict, const char *key) {

  if (!dict || !key) {
    return(NULL);
  }

  return(sDictGetTiny(dict, key));
}

smallt** sDictGetP(sDictt *dict, const char *key) {

  if (!dict || !key) {
    return(NULL);
  }

  forEachSDict(dict, e) {
    if (e->key && eqS(key, e->key)) {
        return(&(e->data));
  }
    }

  return(NULL);
}

smallt* sDictGetTiny(sDictt *dict, const char *key) {

  forEachSDict(dict, e) {
    if (e->key && strEq(key, e->key)) {
        return(e->data);
  }
    }

  return(NULL);
}

// TODO create SetShort - create element and add - no alloc
void sDictSetP(sDictt **dict, const char *key, smallt *data) {

  if (!(*dict)) {
    sDictPushTiny(dict, key, data);
    return;
  }

  if (!data) {
    // NULL not inserted in dictionary
    return;
  }

  forEachSDict(*dict, e) {
    if (e->key && strEq(key, e->key)) {
      e->data = data;
      return;
  }
    }

  // create new element
  sDictPushTiny(dict, key, data);
}

void sDictSetTiny(sDictt **dict, const char *key, smallt *data) {

  if (!(*dict)) {
    sDictPushTiny(dict, key, data);
    return;
  }

  if (!data) {
    // NULL not inserted in dictionary
    return;
  }

  forEachSDict(*dict, e) {
    if (e->key && strEq(key, e->key)) {
      sFree(e->data);
      e->data = data;
      return;
  }
    }

  // create new element
  sDictPushTiny(dict, key, data);
}

// TODO create PushShort - create element and add - no alloc
void sDictPushTiny(sDictt **dict, const char *key, smallt *data) {

  /* // sanity checks */
  /* if !dict */
  /*   return */

  if (!(*dict)) {
    // create dict
    isError(*dict, allocSDict()) {
      return;
    }
  }

  if (!data) {
    // NULL not inserted in dictionary
    return;
  }

  if ((*dict)->count == 0) {
    (*dict)->elements.key  = strdup(key);
    (*dict)->elements.data = data;
  }
  else {
    if ((*dict)->count >= (*dict)->maxCount) {
      // realloc
      sDictt *tmp = realloc(*dict, sizeof(sDictt) + sizeof(sDictElemt) * ((*dict)->count + SDICT_REALLOC_STEPS-1));
      if (!tmp) {
        return;
      }
      else {
        *dict = tmp;
        (*dict)->maxCount = 1 + (*dict)->count + SDICT_REALLOC_STEPS-1;
    }
      }
    sDictElemt *di = &((*dict)->elements);
    di[(*dict)->count].key  = strdup(key);
    di[(*dict)->count].data = data;
  }

  (*dict)->count++;
  return;
}

void sDictDelTiny(sDictt *dict, const char *key) {

  forEachSDict(dict, e) {
    if (e->key && strEq(key, e->key)) {
      sDictFreeElement(e);
      return;
}
  }
    }

char* sStringGetTiny(sStringt *string) {

  return(&(string->data));
}

void sStringSetTiny(sStringt **string, const char *news) {

  free(*string);
  *string = allocSStringTiny(news);
}

// TODO create PushShort - create element and add - no alloc
void sArrayPushTiny(sArrayt **array, smallt* data) {

  /* // sanity checks */
  /* if !array */
  /*   return */

  if (!(*array)) {
    // create array
    isError(*array, allocSArray())
      return;
  }

  if ((*array)->count == 0) {
    (*array)->data = data;;
  }
  else {
    if ((*array)->count >= (*array)->maxCount) {
      // realloc
      //print 'ARRAY REALLOC'
      sArrayt *tmp = realloc(*array, sizeof(sArrayt) + sizeof(smallt *) * ((*array)->count + SARRAY_REALLOC_STEPS));
      if (!tmp) {
        return;
      }
      else {
        *array = tmp;
        (*array)->maxCount = 1 + (*array)->count + SARRAY_REALLOC_STEPS-1;
    }
      }
    smallt **arr = &((*array)->data);
    arr[(*array)->count] = data;
  }

  (*array)->count++;
  return;
}

void sArrayPrependTiny(sArrayt **array, smallt* data) {

  /* // sanity checks */
  /* if !array */
  /*   return */

  if (!(*array)) {
    // create array
    isError(*array, allocSArray())
      return;
  }

  if ((*array)->count == 0) {
    (*array)->data = data;;
  }
  else {
    if ((*array)->count >= (*array)->maxCount) {
      // realloc
      //print 'ARRAY REALLOC'
      sArrayt *tmp = realloc(*array, sizeof(sArrayt) + sizeof(smallt *) * ((*array)->count + SARRAY_REALLOC_STEPS));
      if (!tmp) {
        return;
      }
      else {
        *array = tmp;
        (*array)->maxCount = 1 + (*array)->count + SARRAY_REALLOC_STEPS-1;
    }
      }
    smallt **arr = &((*array)->data);
    // shift list
    for (uint32_t i = (*array)->count; i > 0; i--) {
      arr[i] = arr[i-1];
    }
    arr[0] = data;
  }

  (*array)->count++;
  return;
}

smallt* sArrayPopTiny(sArrayt *array) {
  smallt *r = NULL;

  /* if !array->count */
  /*   return NULL */

  r = sArrayGetTiny(array, array->count -1);
  array->count--;
  return(r);
}

smallt* sArrayDequeueTiny(sArrayt *array) {
  smallt *r = NULL;

  /* if !array->count */
  /*   return NULL */

  smallt **arr = &(array->data);
  r            = arr[0];
  // shift list
  for (uint32_t i = 1 ; i < array->count ; i++) {
    arr[i-1] = arr[i];
  }
  array->count--;
  return(r);
}

smallt** sArrayGetP(sArrayt *array, uint32_t index) {

  return(&(((smallt **) &(array->data))[index]));
}

smallt* sArrayGetTiny(sArrayt *array, uint32_t index) {

  return(((smallt **) &(array->data))[index]);
}

void sArraySetShortTiny(sArrayt *array, uint32_t index, smallt *value) {

  ((smallt **) &(array->data))[index] = value;
}

void sArraySetP(sArrayt *array, uint32_t index, smallt *value) {

  sArraySetShortTiny(array, index, value);
}

void sArraySetTiny(sArrayt *array, uint32_t index, smallt *value) {

  if (value == (((smallt **) &(array->data))[index])) {
    // value is same element as the element already in the array
    return;
  }
  sFree(((smallt **) &(array->data))[index]);
  sArraySetShortTiny(array, index, value);
}

int sArrayReverseTiny(sArrayt *array) {

  /* if !array->count */
  /*   return -1 */

  smallt **arr = &(array->data);
  for (uint32_t i = 0 ; i < array->count/2 ; i++) {
    smallt *a              = arr[i];
    arr[i]                 = arr[array->count-1 -i];
    arr[array->count-1 -i] = a;
  }
  return(1);
}

void sArrayDelTiny(sArrayt *array, uint32_t index) {

  sArraySetTiny(array, index, NULL);
}

void sArrayDelRangeTiny(sArrayt *array, uint32_t start, uint32_t end) {

  smallt **arr = &(array->data);

  // free elements in range start, end
  for (uint32_t i = start ; i < end ; i++) {
    sFree(arr[i]);
  }

  // copy pointers from range end, array->count to start
  for (uint32_t i = 0 ; i < (array->count - end) ; i ++) {
    arr[start+i] = arr[end + i];;
  }

  array->count -= end - start;
}

void* sBytesGet(sBytest *bytes) {

  if (!bytes || !isSType(bytes, BYTES)) {
    return(NULL);
  }

  return(sBytesGetTiny(bytes));
}

void* sBytesGetTiny(sBytest *bytes) {

  return(&(bytes->data));
}

void sBytesPush(sBytest **bytes, char data) {

  if (!(*bytes)) {
    // create bytes
    isError(*bytes, allocSBytes())
      return;
  }

  if ((*bytes)->count == 0) {
    (*bytes)->data = data;;
  }
  else {
    sBytest *tmp = realloc(*bytes, sizeof(sBytest) + sizeof(char) * ((*bytes)->count));
    if (!tmp) {
      return;
    }
    else {
      *bytes = tmp;
      (&((*bytes)->data))[(*bytes)->count] = data;
  }
    }

  (*bytes)->count++;
  return;
}

void sBytesPushBuffer(sBytest **bytes, void* data, uint32_t size) {

  if (!(*bytes)) {
    // create bytes
    *bytes          = allocSBytes();
  }

  if (!data || !size) {
    return;
  }

  sBytesPushBufferTiny(bytes, data, size);
}


void sBytesPushBufferTiny(sBytest **bytes, void* data, uint32_t size) {

  if ((*bytes)->count == 0) {
    sBytest *tmp = realloc(*bytes, sizeof(sBytest) + sizeof(char) * (size-1));
    if (!tmp) {
      return;
    }
    else {
      *bytes = tmp;
      memcpy(&((*bytes)->data), data, size);
      (*bytes)->count = size;;
  }
    }
  else {
    sBytest *tmp = realloc(*bytes, sizeof(sBytest) + sizeof(char) * ((*bytes)->count + size-1));
    if (!tmp) {
      return;
    }
    else {
      *bytes = tmp;
      memcpy((&((*bytes)->data))+(*bytes)->count, data, size);
      (*bytes)->count += size;;
  }
    }
  return;
}

sBytest *sSerial(smallt *obj) {

  if (!obj) {
    return(NULL);
  }

  return(sSerialTiny(obj));
}

// TODO reimplement using loops
// TODO serialize simple types
sBytest *sSerialTiny(smallt *obj) {
  sBytest *r = NULL;
  sBytest *B = NULL;

  switch(obj->type) {
    case UNDEFINED:
      sBytesPush(&r, obj->type);
      break;
    case BOOL:
      sBytesPush(&r, obj->type);
      sBytesPushBuffer(&r, &((sBoolt *)&(obj->type))->value, sizeof(bool));
      break;
    case CONTAINER:
      sBytesPush(&r, obj->type);
      break;
    case DICT:
      sDictSerialElementsTiny(&r, (sDictt *)&(obj->type));
      break;
    case DOUBLE:
      sBytesPush(&r, obj->type);
      sBytesPushBuffer(&r, &((sDoublet *)&(obj->type))->value, sizeof(double));
      break;
    case INT:
      sBytesPush(&r, obj->type);
      sBytesPushBuffer(&r, &((sIntt *)&(obj->type))->value, sizeof(int64_t));
      break;
    case STRING:
      sBytesPush(&r, obj->type);
      sBytesPushBuffer(&r, &((sStringt *)&(obj->type))->data, (uint32_t)sizeof(sStringt) + (uint32_t)strlen(&(((sStringt *)&(obj->type))->data)) -1);
      break;
    case ARRAY:
      sArraySerialElementsTiny(&r, (sArrayt *)&(obj->type));
      break;
    case BYTES:
      sBytesPush(&r, obj->type);
      B = (sBytest *)&(obj->type);
      sBytesPushBuffer(&r, &(B->count), sizeof(uint32_t));
      sBytesPushBuffer(&r, &(B->data), B->count);
      break;
    default:
      logME(libsheepyErrorMask, "Unsupported object type.");
  }
  return(r);
}

void sDictSerialElementsTiny(sBytest **r, sDictt *dict) {
  sBytest *B = NULL;

  sBytesPush(r, dict->type);
  sBytesPushBuffer(r, &(dict->count), sizeof(uint32_t));

  forEachSDict(dict, e) {
    if (e->key) {
      sBytesPushBuffer(r, e->key, (uint32_t)strlen(e->key) + 1);
      sBytesPush(r, e->data->type);

      switch(e->data->type) {
        case UNDEFINED:
          break;
        case BOOL:
          sBytesPushBuffer(r, &((sBoolt *)(e->data))->value, sizeof(bool));
          break;
        case CONTAINER:
          break;
        case DICT:
          // decrease to overwrite the e->type since sDictSerialElementsTiny stores the type
          // again
          (*r)->count--;
          sDictSerialElementsTiny(r, (sDictt *)(e->data));
          break;
        case DOUBLE:
          sBytesPushBuffer(r, &((sDoublet *)(e->data))->value, sizeof(double));
          break;
        case INT:
          sBytesPushBuffer(r, &((sIntt *)(e->data))->value, sizeof(int64_t));
          break;
        case STRING:
          sBytesPushBuffer(r, &((sStringt *)(e->data))->data, (uint32_t)sizeof(sStringt) + (uint32_t)strlen(&(((sStringt *)(e->data))->data)) -1);
          break;
        case ARRAY:
          // decrease to overwrite the e->type since sDictSerialElementsTiny stores the type
          // again
          (*r)->count--;
          sArraySerialElementsTiny(r, (sArrayt *)(e->data));
          break;
        case BYTES:
          B = (sBytest *)(e->data);
          sBytesPushBuffer(r, &(B->count), sizeof(uint32_t));
          sBytesPushBuffer(r, &(B->data), B->count);
          break;
        default:
          logME(libsheepyErrorMask, "Unsupported object type.");
      }
  }
    }
  return;
}

void sArraySerialElementsTiny(sBytest **r, sArrayt *array) {
  sBytest *B = NULL;

  sBytesPush(r, array->type);
  sBytesPushBuffer(r, &(array->count), sizeof(uint32_t));

  forEachSArray(array, e) {
    if (!e) {
      // empty slots are represented as undefined elements
      sBytesPush(r, UNDEFINED);
    }
    else {
      sBytesPush(r, e->type);

      switch(e->type) {
        case UNDEFINED:
          break;
        case BOOL:
          sBytesPushBuffer(r, &((sBoolt *)e)->value, sizeof(bool));
          break;
        case CONTAINER:
          break;
        case DICT:
          // decrease to overwrite the e->type since sDictSerialElementsTiny stores the type
          // again
          (*r)->count--;
          sDictSerialElementsTiny(r, (sDictt *)e);
          break;
        case DOUBLE:
          sBytesPushBuffer(r, &((sDoublet *)e)->value, sizeof(double));
          break;
        case INT:
          sBytesPushBuffer(r, &((sIntt *)e)->value, sizeof(int64_t));
          break;
        case STRING:
          sBytesPushBuffer(r, &((sStringt *)e)->data, (uint32_t)sizeof(sStringt) + (uint32_t)strlen(&(((sStringt *)e)->data)) -1);
          break;
        case ARRAY:
          // decrease to overwrite the e->type since sDictSerialElementsTiny stores the type
          // again
          (*r)->count--;
          sArraySerialElementsTiny(r, (sArrayt *)e);
          break;
        case BYTES:
          B = (sBytest *)e;
          sBytesPushBuffer(r, &(B->count), sizeof(uint32_t));
          sBytesPushBuffer(r, &(B->data), B->count);
          break;
        default:
          logME(libsheepyErrorMask, "Unsupported object type.");
      }
  }
    }
  return;
}

smallt* sDeserial(sBytest *obj) {

  if (!obj || !obj->count) {
    return(NULL);
  }

  return(sDeserialTiny(obj));
}

// TODO reimplement using loops
smallt* sDeserialTiny(sBytest *obj) {
  smallt   *r = NULL;
  bool *b = NULL;
  double *D = NULL;
  int64_t *i = NULL;
  char *s = NULL;
  sBytest *B = NULL;
  uint32_t *count = NULL;
  char *data = NULL;

  switch(obj->data) {
    case UNDEFINED:
      r = (smallt *) allocSUndefined();
      break;
    case BOOL:
      data = &(obj->data)+1;
      b = (bool *)data;
      r = (smallt *) allocSBool(*b);
      break;
    case CONTAINER:
      r = (smallt *) allocSContainer(NULL);
      break;
    case DICT:
      data = (char *)&(obj->data)+1;
      sDictDeserialElementsTiny((sDictt **)&r, &data);
      break;
    case DOUBLE:
      data = &(obj->data)+1;
      D = (double *)data;
      r = (smallt *) allocSDouble(*D);
      break;
    case INT:
      data = &(obj->data)+1;
      i = (int64_t *)data;
      r = (smallt *) allocSInt(*i);
      break;
    case STRING:
      s = (char *)&(obj->data)+1;
      r = (smallt *) allocSStringTiny(s);
      break;
    case ARRAY:
      data = (char *)&(obj->data)+1;
      sArrayDeserialElementsTiny((sArrayt **)&r, &data);
      break;
    case BYTES:
      isError(B, allocSBytes()) return(NULL);
      data  = &(obj->data)+1;
      count = (uint32_t *)data;
      s     = (char *)data + sizeof(uint32_t);
      sBytesPushBuffer(&B, s, *count);
      r = (smallt *)B;
      break;
    default:
      logME(libsheepyErrorMask, "Unsupported object type.");
  }

  return(r);
}

void sDictDeserialElementsTiny(sDictt **dict, char **data) {
  sUndefinedt *u = NULL;
  bool *b = NULL;
  sBoolt *bo = NULL;
  sContainert *c = NULL;
  double *D = NULL;
  sDoublet *Do = NULL;
  sDictt *d = NULL;
  int64_t *i = NULL;
  sIntt *io = NULL;
  char *s = NULL;
  sStringt *so = NULL;
  sArrayt *a = NULL;
  sBytest *B = NULL;
  uint32_t *count = NULL;
  uint32_t dictCount;

  dictCount  = *((uint32_t *)(*data));
  *data     += sizeof(uint32_t);

  if (!dictCount) {
    *dict = allocSDict();
    return;
  }

  for (uint32_t counter = 0 ; counter < dictCount ; counter++) {
    char type;
    char *key;
    key    = *data;
    *data += strlen(key)+1;
    type   = *((*data)++);

    switch(type) {
      case UNDEFINED:
        u = allocSUndefined();
        sDictPushTiny(dict, key, (smallt *) u);
        break;
      case BOOL:
        b      = (bool *)(*data);
        *data += sizeof(bool);
        bo     = allocSBool(*b);
        sDictPushTiny(dict, key, (smallt *) bo);
        break;
      case CONTAINER:
        c = allocSContainer(NULL);
        sDictPushTiny(dict, key, (smallt *) c);
        break;
      case DICT:
        d = NULL;
        sDictDeserialElementsTiny(&d, data);
        sDictPushTiny(dict, key, (smallt *) d);
        break;
      case DOUBLE:
        D      = (double *)(*data);
        *data += sizeof(double);
        Do     = allocSDouble(*D);
        sDictPushTiny(dict, key, (smallt *) Do);
        break;
      case INT:
        i      = (int64_t *)(*data);
        *data += sizeof(int64_t);
        io     = allocSInt(*i);
        sDictPushTiny(dict, key, (smallt *) io);
        break;
      case STRING:
        s      = (char *)(*data);
        *data += strlen(s)+1;
        so     = allocSStringTiny(s);
        sDictPushTiny(dict, key, (smallt *) so);
        break;
      case ARRAY:
        a = NULL;
        sArrayDeserialElementsTiny(&a, data);
        sDictPushTiny(dict, key, (smallt *) a);
        break;
      case BYTES:
        isError(B, allocSBytes()) {
          return;
        }
        count  = (uint32_t *)(*data);
        *data += sizeof(uint32_t);
        s      = *data;
        *data += *count;
        sBytesPushBuffer(&B, s, *count);
        sDictPushTiny(dict, key, (smallt *) B);
        break;
      default:
        logME(libsheepyErrorMask, "Unsupported object type.");
    }
}
  }

void sArrayDeserialElementsTiny(sArrayt **array, char **data) {
  sUndefinedt *u = NULL;
  bool *b = NULL;
  sBoolt *bo = NULL;
  sContainert *c = NULL;
  double *D = NULL;
  sDoublet *Do = NULL;
  sDictt *d = NULL;
  int64_t *i = NULL;
  sIntt *io = NULL;
  char *s = NULL;
  sStringt *so = NULL;
  sArrayt *a = NULL;
  sBytest *B = NULL;
  uint32_t *count = NULL;
  uint32_t arrayCount;

  arrayCount  = *((uint32_t *)(*data));
  *data     += sizeof(uint32_t);

  if (!arrayCount) {
    *array = allocSArray();
    return;
  }

  for (uint32_t counter = 0 ; counter < arrayCount ; counter++) {
    char type;
    type  = *((*data)++);

    switch(type) {
      case UNDEFINED:
        u = allocSUndefined();
        sArrayPushTiny(array, (smallt *) u);
        break;
      case BOOL:
        b      = (bool *)(*data);
        *data += sizeof(bool);
        bo     = allocSBool(*b);
        sArrayPushTiny(array, (smallt *) bo);
        break;
      case CONTAINER:
        c = allocSContainer(NULL);
        sArrayPushTiny(array, (smallt *) c);
        break;
      case DICT:
        d = NULL;
        sDictDeserialElementsTiny(&d, data);
        sArrayPushTiny(array, (smallt *) d);
        break;
      case DOUBLE:
        D      = (double *)(*data);
        *data += sizeof(double);
        Do     = allocSDouble(*D);
        sArrayPushTiny(array, (smallt *) Do);
        break;
      case INT:
        i      = (int64_t *)(*data);
        *data += sizeof(int64_t);
        io     = allocSInt(*i);
        sArrayPushTiny(array, (smallt *) io);
        break;
      case STRING:
        s      = (char *)(*data);
        *data += strlen(s)+1;
        so     = allocSStringTiny(s);
        sArrayPushTiny(array, (smallt *) so);
        break;
      case ARRAY:
        a = NULL;
        sArrayDeserialElementsTiny(&a, data);
        sArrayPushTiny(array, (smallt *) a);
        break;
      case BYTES:
        isError(B, allocSBytes()) {
          return;
        }
        count  = (uint32_t *)(*data);
        *data += sizeof(uint32_t);
        s      = *data;
        *data += *count;
        sBytesPushBuffer(&B, s, *count);
        sArrayPushTiny(array, (smallt *) B);
        break;
      default:
        logME(libsheepyErrorMask, "Unsupported object type.");
    }
}
  }