libsheepyCSmallBytes.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 "../libsheepyObject.h"
#include "libsheepyCSmallBytes.h"
#include "libsheepyCSmallBytesInternal.h"

#define internal static

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

void initiateSmallBytes(smallBytest *self);
void registerMethodsSmallBytes(smallBytesFunctionst *f);
void initiateAllocateSmallBytes(smallBytest **self);
void finalizeRecycleSmallBytes(void *arg UNUSED);
void finalizeSmallBytes(void);
smallBytest* allocSmallBytes(void *data, uint32_t size);
void cleanUpSmallBytesTerminateG(smallBytest **val);
void cleanUpSmallBytesFreeLocalG(smallBytest *val);
void cleanUpSmallBytesFreeG(smallBytest **val);
void cleanUpSmallBytesFinishG(smallBytest **val);
internal void freeSmallBytes(smallBytest *self);
internal void terminateSmallBytes(smallBytest **self);
#if (NFreeStackCheck)
internal void finishSmallBytes(smallBytest **self);
#else
internal void finishSmallBytes(smallBytest **self);
#endif
internal const char* helpSmallBytes(smallBytest UNUSED *self);
internal char* toStringSmallBytes(smallBytest *self);
internal smallBytest* duplicateSmallBytes(smallBytest *self);
internal void* getSmallBytes(smallBytest *self);
internal smallBytest* setSmallBytes(smallBytest *self, void *data, uint32_t size);
internal smallBytest* pushSmallBytes(smallBytest *self, char data);
internal smallBytest* pushBufferSmallBytes(smallBytest *self, void *data, uint32_t size);
internal char getAtSmallBytes(smallBytest *self, int64_t index);
internal size_t lenSmallBytes(smallBytest *self);
internal bool isEmptySmallBytes(smallBytest *self);
internal smallBytest* readFileSmallBytes(smallBytest *self, const char *filePath);
internal smallBytest* readFileSmallJsonSmallBytes(smallBytest *self, smallJsont *filePath);
internal smallBytest* readFileSmallStringSmallBytes(smallBytest *self, smallStringt *filePath);
internal smallBytest* readStreamSmallBytes(smallBytest *self, FILE *fp);
internal int writeFileSmallBytes(smallBytest *self, const char *filePath);
internal int writeFileSmallJsonSmallBytes(smallBytest *self, smallJsont *filePath);
internal int writeFileSmallStringSmallBytes(smallBytest *self, smallStringt *filePath);
internal int writeStreamSmallBytes(smallBytest *self, FILE *fp);
internal int appendFileSmallBytes(smallBytest *self, const char *filePath);
internal int appendFileSmallStringSmallBytes(smallBytest *self, smallStringt *filePath);
internal bool equalSmallBytes(smallBytest *self, smallBytest *value);
internal bool equalSmallBytesBool(smallBytest *self, bool value);
internal bool equalSmallBytesDouble(smallBytest *self, double value);
internal bool equalSmallBytesInt64(smallBytest *self, int64_t value);
internal bool equalSmallBytesInt32(smallBytest *self, int32_t value);
internal bool equalSmallBytesUint32(smallBytest *self, uint32_t value);
internal bool equalSmallBytesUint64(smallBytest *self, uint64_t value);
internal bool equalSmallBytesSmallBool(smallBytest *self, smallBoolt *value);
internal bool equalSmallBytesSmallDouble(smallBytest *self, smallDoublet *value);
internal bool equalSmallBytesSmallInt(smallBytest *self, smallIntt *value);
internal bool equalSmallBytesChar(smallBytest *self, const char *value);
internal bool equalSmallBytesSmallString(smallBytest *self, smallStringt *value);
internal bool equalSmallBytesBase(smallBytest *self, baset *value);
smallBytest* duplicateSmallBytesG (smallBytest *self);
smallBytest* setSmallBytesG(smallBytest *self, void *data, uint32_t size);
char getAtSmallBytesG(smallBytest *self, char retType UNUSED, int64_t index);
smallBytest* pushSmallBytesG (smallBytest *self, char data);
size_t lenSmallBytesG(smallBytest *self);
bool isEmptySmallBytesG(smallBytest *self);
smallBytest* readFileSmallBytesG(smallBytest *self, const char *filePath);
smallBytest* readFileSmallJsonSmallBytesG(smallBytest *self, smallJsont *filePath);
smallBytest* readFileSmallStringSmallBytesG(smallBytest *self, smallStringt *filePath);
smallBytest* readStreamSmallBytesG(smallBytest *self, FILE *fp);
int writeFileSmallBytesG(smallBytest *self, const char *filePath);
int writeFileSmallJsonSmallBytesG(smallBytest *self, smallJsont *filePath);
int writeFileSmallStringSmallBytesG(smallBytest *self, smallStringt *filePath);
int writeStreamSmallBytesG(smallBytest *self, FILE *fp);
int appendFileSmallBytesG(smallBytest *self, const char *filePath);
int appendFileSmallStringSmallBytesG(smallBytest *self, smallStringt *filePath);
bool equalSmallBytesG(smallBytest *self, smallBytest *value);
bool equalSmallBytesBoolG(smallBytest *self, bool value);
bool equalSmallBytesDoubleG(smallBytest *self, double value);
bool equalSmallBytesInt64G(smallBytest *self, int64_t value);
bool equalSmallBytesInt32G(smallBytest *self, int32_t value);
bool equalSmallBytesUint32G(smallBytest *self, uint32_t value);
bool equalSmallBytesUint64G(smallBytest *self, uint64_t value);
bool equalSmallBytesSmallBoolG(smallBytest *self, smallBoolt *value);
bool equalSmallBytesSmallDoubleG(smallBytest *self, smallDoublet *value);
bool equalSmallBytesSmallIntG(smallBytest *self, smallIntt *value);
bool equalSmallBytesCharG(smallBytest *self, const char *value);
bool equalSmallBytesSmallStringG(smallBytest *self, smallStringt *value);
bool equalSmallBytesBaseG(smallBytest *self, baset *value);

void initiateSmallBytes(smallBytest *self) {

  self->type = "smallBytes";
  if (!smallBytesF) {
    isError(smallBytesF, malloc(sizeof(smallBytesFunctionst))) {
      self->f = NULL;
      return;
    }
    registerMethodsSmallBytes(smallBytesF);
  }
  self->f = smallBytesF;
  self->B = NULL;
}

void registerMethodsSmallBytes(smallBytesFunctionst *f) {

  f->free                  = freeSmallBytes;
  f->terminate             = terminateSmallBytes;
  f->toString              = toStringSmallBytes;
  f->duplicate             = duplicateSmallBytes;
  f->smash                 = finishSmallBytes;
  f->finish                = finishSmallBytes;
  f->help                  = helpSmallBytes;
  f->get                   = getSmallBytes;
  f->set                   = setSmallBytes;
  f->push                  = pushSmallBytes;
  f->pushBuffer            = pushBufferSmallBytes;
  f->getAt                 = getAtSmallBytes;
  f->len                   = lenSmallBytes;
  f->isEmpty               = isEmptySmallBytes;
  f->readFile              = readFileSmallBytes;
  f->readFileSmallJson     = readFileSmallJsonSmallBytes;
  f->readFileSmallString   = readFileSmallStringSmallBytes;
  f->readStream            = readStreamSmallBytes;
  f->writeFile             = writeFileSmallBytes;
  f->writeFileSmallJson    = writeFileSmallJsonSmallBytes;
  f->writeFileSmallString  = writeFileSmallStringSmallBytes;
  f->writeStream           = writeStreamSmallBytes;
  f->appendFile            = appendFileSmallBytes;
  f->appendFileSmallString = appendFileSmallStringSmallBytes;
  f->equal                 = equalSmallBytes;
  f->equalBool             = equalSmallBytesBool;
  f->equalDouble           = equalSmallBytesDouble;
  f->equalInt64            = equalSmallBytesInt64;
  f->equalInt32            = equalSmallBytesInt32;
  f->equalUint32           = equalSmallBytesUint32;
  f->equalUint64           = equalSmallBytesUint64;
  f->equalSmallBool        = equalSmallBytesSmallBool;
  f->equalSmallDouble      = equalSmallBytesSmallDouble;
  f->equalSmallInt         = equalSmallBytesSmallInt;
  f->equalS                = equalSmallBytesChar;
  f->equalSmallString      = equalSmallBytesSmallString;
  f->equalBase             = equalSmallBytesBase;
}

void initiateAllocateSmallBytes(smallBytest **self) {

  if (self) {
    #if (recycleContainers)
    initAllocateRecycle(smallBytest);
    #else
    isError(*self, malloc(sizeof(smallBytest)))
      return;
    #endif
    if (*self) {
      initiateSmallBytes(*self);
      if (!(*self)->f) {
        finishSmallBytes(self);
}
  }
    }
      }

void finalizeRecycleSmallBytes(void *arg UNUSED) {

  #if (recycleContainers)
  finalizeRecycle
  #endif
  // recycleContainers
}

void finalizeSmallBytes(void) {

  if (smallBytesF) {
    free(smallBytesF);
    smallBytesF = NULL;
  }
  finalizeRecycleSmallBytes(NULL);
}

smallBytest* allocSmallBytes(void *data, uint32_t size) {
  smallBytest *r = NULL;

  initiateAllocateSmallBytes(&r);
  if (!r) {
    return(NULL);
  }
  r->f->pushBuffer(r, data, size);
  return(r);
}

void cleanUpSmallBytesTerminateG(smallBytest **val) {

  terminateO(*val);
}

void cleanUpSmallBytesFreeLocalG(smallBytest *val) {

  freeO(val);
}

void cleanUpSmallBytesFreeG(smallBytest **val) {

  freeO(*val);
}

void cleanUpSmallBytesFinishG(smallBytest **val) {

  finishO(*val);
}



internal void freeSmallBytes(smallBytest *self) {

  sFree((smallt *)self->B);
  self->B = NULL;
  return;
}

internal void terminateSmallBytes(smallBytest **self) {

  freeSmallBytes(*self);
  finishSmallBytes(self);
}

#if (NFreeStackCheck)
internal void finishSmallBytes(smallBytest **self) {

  register u64 rsp asm("rsp");
  if ((u64)*self > rsp) {
    logW("Probably trying to free a smallBytes on stack: "BLD PRIx64 RST" sp: "BLD PRIx64 RST, *self, rsp);
    logBtrace;
  }
  else {
    #if (recycleContainers)
    finishRecycle
    #else
    free(*self);
    #endif
    // recycleContainers
    *self = NULL;
}
  }

#else
// #if NFreeStackCheck
internal void finishSmallBytes(smallBytest **self) {

  #if (recycleContainers)
  finishRecycle
  #else
  free(*self);
  #endif
  // recycleContainers
  *self = NULL;
}

#endif
// #if NFreeStackCheck

internal const char* helpSmallBytes(smallBytest UNUSED *self) {

  return(helpTextSmallBytes);
}


internal char* toStringSmallBytes(smallBytest *self) {

  if (!self->B) {
    return(strdup("[]"));
  }

  return(sToString((smallt *)self->B));
}

internal smallBytest* duplicateSmallBytes(smallBytest *self) {

  createAllocateSmallBytes(dup);
  if (!dup) {
    return(NULL);
  }
  dup->B = (sBytest *)sDuplicate((smallt *)self->B);;
  return(dup);
}

internal void* getSmallBytes(smallBytest *self) {

  return(sBytesGet(self->B));
}

internal smallBytest* setSmallBytes(smallBytest *self, void *data, uint32_t size) {

  freeSmallBytes(self);
  sBytesPushBuffer(&(self->B), data, size);
  return(self);
}

internal smallBytest* pushSmallBytes(smallBytest *self, char data) {

  sBytesPush(&(self->B), data);
  return(self);
}

internal smallBytest* pushBufferSmallBytes(smallBytest *self, void *data, uint32_t size) {

  sBytesPushBuffer(&(self->B), data, size);
  return(self);
}

internal char getAtSmallBytes(smallBytest *self, int64_t index) {

  if (!self->B) {
    return(0);
  }

  if (index >= self->B->count) {
    return(0);
  }
  if (index < -(int64_t)self->B->count) {
    return(0);
  }
  if (index < 0) {
    index = (int64_t)self->B->count + index;
  }

  return((&(self->B->data))[index]);
}

internal size_t lenSmallBytes(smallBytest *self) {

  if (!self->B) {
    return(0);
  }

  return(self->B->count);
}

internal bool isEmptySmallBytes(smallBytest *self) {

  return(!lenSmallBytes(self));
}

internal smallBytest* readFileSmallBytes(smallBytest *self, const char *filePath) {
  FILE *f = NULL;
  ssize_t len;
  size_t readStatus;

  // sanity checks
  if (!filePath || isBlankS(filePath)) {
    return(NULL);
  }

  len = fileSize(filePath);;
  // TODO check that len is less than 4GB because sBytes can hold 4GB at most
  if (len == -1) {
    return(NULL);
  }

  freeSmallBytes(self);

  void *buffer = malloc((size_t)len);
  if (!buffer) {
    return(NULL);
  }

  f = fopen(filePath, "r");
  readStatus = fread(buffer, 1, (size_t)len , f);
  fclose(f);

  // readStatus == len when ok
  pushBufferSmallBytes(self, buffer, (uint32_t)readStatus);

  // pushBuffer copies the buffer, buffer is not used anymore, free it
  free(buffer);

  if (readStatus != (size_t)len) {
    pFuncError
    shEPrintfS("The path was: \"%s\"\n", filePath);
    return(NULL);
  }

  return(self);
}

internal smallBytest* readFileSmallJsonSmallBytes(smallBytest *self, smallJsont *filePath) {

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

  if (checkObjectTypes && !isOSmallJson(filePath)) {
    return(NULL);
  }

  const char *type = getTopTypeO(filePath);

  if (!eqS(type,"string")) {
    return(NULL);
  }

  return(readFileSmallBytes(self, getTopSO(filePath)));
}

internal smallBytest* readFileSmallStringSmallBytes(smallBytest *self, smallStringt *filePath) {

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

  if (checkObjectTypes && !isOSmallString(filePath)) {
    return(NULL);
  }

  return(readFileSmallBytes(self, ssGet(filePath)));
}

internal smallBytest* readStreamSmallBytes(smallBytest *self, FILE *fp) {
  ssize_t len;
  size_t readStatus;

  // sanity checks
  if (!fp) {
    return(NULL);
  }

  len = fileSizeFP(fp);
  // TODO check that len is less than 4GB because sBytes can hold 4GB at most
  if (len == -1) {
    return(NULL);
  }

  freeSmallBytes(self);

  void *buffer = malloc((size_t)len);
  if (!buffer) {
    return(NULL);
  }

  readStatus = fread(buffer, 1, (size_t)len , fp);

  // readStatus == len when ok
  pushBufferSmallBytes(self, buffer, (uint32_t)readStatus);

  // pushBuffer copies the buffer, buffer is not used anymore, free it
  free(buffer);

  if (readStatus != (size_t)len) {
    pFuncError
    return(NULL);
  }

  return(self);
}

internal int writeFileSmallBytes(smallBytest *self, const char *filePath) {
  FILE *f = NULL;
  size_t len;
  size_t writeStatus;

  // sanity checks
  if (!filePath || isBlankS(filePath) || !self->B) {
    return(0);
  }

  len = self->B->count;

  f = fopen(filePath, "w");
  if (!f) {
    pFuncError
    shEPrintfS("The path was: \"%s\"\n", filePath);
    return(0);
  }
  writeStatus = fwrite(sBytesGet(self->B), 1, len , f);
  fclose(f);

  if (writeStatus != len) {
    pFuncError
    shEPrintfS("The path was: \"%s\"\n", filePath);
    return(0);
  }

  return(1);
}

internal int writeFileSmallJsonSmallBytes(smallBytest *self, smallJsont *filePath) {

  if (!filePath) {
    return(0);
  }

  if (checkObjectTypes && !isOSmallJson(filePath)) {
    return(0);
  }

  const char *type = getTopTypeO(filePath);

  if (!eqS(type,"string")) {
    return(0);
  }

  return(writeFileSmallBytes(self, getTopSO(filePath)));
}

internal int writeFileSmallStringSmallBytes(smallBytest *self, smallStringt *filePath) {

  if (!filePath) {
    return(0);
  }

  if (checkObjectTypes && !isOSmallString(filePath)) {
    return(0);
  }

  return(writeFileSmallBytes(self, ssGet(filePath)));
}

internal int writeStreamSmallBytes(smallBytest *self, FILE *fp) {
  size_t len;
  size_t writeStatus;

  // sanity checks
  if (!fp || !self->B) {
    return(0);
  }

  len = self->B->count;

  writeStatus = fwrite(sBytesGet(self->B), 1, len , fp);

  if (writeStatus != len) {
    pFuncError
    return(0);
  }

  return(1);
}

internal int appendFileSmallBytes(smallBytest *self, const char *filePath) {
  FILE *f = NULL;
  size_t len;
  size_t writeStatus;

  // sanity checks
  if (!filePath || isBlankS(filePath) || !self->B) {
    return(0);
  }

  len = self->B->count;

  f = fopen(filePath, "a");
  if (!f) {
    pFuncError
    shEPrintfS("The path was: \"%s\"\n", filePath);
    return(0);
  }
  writeStatus = fwrite(sBytesGet(self->B), 1, len , f);
  fclose(f);

  if (writeStatus != len) {
    pFuncError
    shEPrintfS("The path was: \"%s\"\n", filePath);
    return(0);
  }

  return(1);
}

internal int appendFileSmallStringSmallBytes(smallBytest *self, smallStringt *filePath) {

  if (!filePath) {
    return(0);
  }
  return(appendFileSmallBytes(self, ssGet(filePath)));
}

internal bool equalSmallBytes(smallBytest *self, smallBytest *value) {

  if (!self->B || !value || !value->B) {
    return(false);
  }

  if (self->B->count != value->B->count) {
    return(false);
  }

  return(memcmp(sBytesGet(self->B),sBytesGet(value->B), self->B->count) == 0);;
}

internal bool equalSmallBytesBool(smallBytest *self, bool value) {

  if (!self->B) {
    return(false);
  }

  if (equalSmallBytesChar(self, "true") || equalSmallBytesChar(self, "TRUE")) {
    return(value);
  }
  else if (equalSmallBytesChar(self, "false") || equalSmallBytesChar(self, "FALSE")) {
    return(!value);
  }
  return(false);
}

internal bool equalSmallBytesDouble(smallBytest *self, double value) {

  if (!self->B) {
    return(false);
  }

  char *s = sBytesGet(self->B);

  bool has0 = false;
  rangeDown(i, self->B->count) {
    if (s[i] == 0) {
      has0 = true;
      break;
    }
  }

  if (!has0) {
    return(false);
  }

  if (isInt(s) || !isNumber(s)) {
    return(false);
  }

  double val = parseDouble(s);

  return(val == value);;
}

internal bool equalSmallBytesInt64(smallBytest *self, int64_t value) {

  if (!self->B) {
    return(false);
  }

  char *s = sBytesGet(self->B);

  bool has0 = false;
  rangeDown(i, self->B->count) {
    if (s[i] == 0) {
      has0 = true;
      break;
    }
  }

  if (!has0) {
    return(false);
  }

  if (!isInt(s)) {
    return(false);
  }

  int64_t val = parseInt(s);

  return(val == value);;
}

internal bool equalSmallBytesInt32(smallBytest *self, int32_t value) {

  if (!self->B) {
    return(false);
  }

  char *s = sBytesGet(self->B);

  bool has0 = false;
  rangeDown(i, self->B->count) {
    if (s[i] == 0) {
      has0 = true;
      break;
    }
  }

  if (!has0) {
    return(false);
  }

  if (!isInt(s)) {
    return(false);
  }

  int32_t val = (int32_t)parseInt(s);

  return(val == value);;
}

internal bool equalSmallBytesUint32(smallBytest *self, uint32_t value) {

  if (!self->B) {
    return(false);
  }

  char *s = sBytesGet(self->B);

  bool has0 = false;
  rangeDown(i, self->B->count) {
    if (s[i] == 0) {
      has0 = true;
      break;
    }
  }

  if (!has0) {
    return(false);
  }

  if (!isInt(s)) {
    return(false);
  }

  uint32_t val = (uint32_t)parseInt(s);

  return(val == value);;
}

internal bool equalSmallBytesUint64(smallBytest *self, uint64_t value) {

  if (!self->B) {
    return(false);
  }

  char *s = sBytesGet(self->B);

  bool has0 = false;
  rangeDown(i, self->B->count) {
    if (s[i] == 0) {
      has0 = true;
      break;
    }
  }

  if (!has0) {
    return(false);
  }

  if (!isInt(s)) {
    return(false);
  }

  uint64_t val = (uint64_t)parseInt(s);

  return(val == value);;
}

internal bool equalSmallBytesSmallBool(smallBytest *self, smallBoolt *value) {

  if (!self->B || !value || !value->value) {
    return(false);
  }

  return(equalSmallBytesBool(self, value->value->value));
}

internal bool equalSmallBytesSmallDouble(smallBytest *self, smallDoublet *value) {

  if (!self->B || !value || !value->value) {
    return(false);
  }

  return(equalSmallBytesDouble(self, value->value->value));
}

internal bool equalSmallBytesSmallInt(smallBytest *self, smallIntt *value) {

  if (!self->B || !value || !value->value) {
    return(false);
  }

  return(equalSmallBytesInt64(self, value->value->value));
}


internal bool equalSmallBytesChar(smallBytest *self, const char *value) {

  if (!self->B || !value) {
    return(false);
  }

  size_t size = strlen(value) + 1;
  if (self->B->count != size) {
    return(false);
  }

  return(memcmp(sBytesGet(self->B), value, size) == 0);;
}

internal bool equalSmallBytesSmallString(smallBytest *self, smallStringt *value) {

  if (!self->B || !value || !value->data) {
    return(false);
  }

  if (self->B->count != (value->_len + 1)) {
    return(false);
  }

  return(memcmp(sBytesGet(self->B), sStringGetTiny(value->data), self->B->count) == 0);;
}

internal bool equalSmallBytesBase(smallBytest *self, baset *value) {

  if (!self->B || !value) {
    return(false);
  }

  if (isOSmallBytes(value)) {
    return(equalSmallBytes(self, (smallBytest*)value));
  }
  else if (isOSmallString(value)) {
    return(equalSmallBytesSmallString(self, (smallStringt*)value));
  }
  else {
    return(false);
}
  }

smallBytest* duplicateSmallBytesG (smallBytest *self) {

  return(self->f->duplicate(self));
}

void freeSmallBytesG (smallBytest *self) {self->f->free(self);}

smallBytest* setSmallBytesG(smallBytest *self, void *data, uint32_t size) {

  return(self->f->set(self, data, size));
}

char getAtSmallBytesG(smallBytest *self, char retType UNUSED, int64_t index) {

  return(self->f->getAt(self,index));
}

smallBytest* pushSmallBytesG (smallBytest *self, char data) {

  return(self->f->push(self, data));
}

size_t lenSmallBytesG(smallBytest *self) {

  return(self->f->len(self));
}

bool isEmptySmallBytesG(smallBytest *self) {

  return(self->f->isEmpty(self));
}

smallBytest* readFileSmallBytesG(smallBytest *self, const char *filePath) {

  return(self->f->readFile(self, filePath));
}

smallBytest* readFileSmallJsonSmallBytesG(smallBytest *self, smallJsont *filePath) {

  return(self->f->readFileSmallJson(self,filePath));
}

smallBytest* readFileSmallStringSmallBytesG(smallBytest *self, smallStringt *filePath) {

  return(self->f->readFileSmallString(self,filePath));
}

smallBytest* readStreamSmallBytesG(smallBytest *self, FILE *fp) {

  return(self->f->readStream(self, fp));
}


int writeFileSmallBytesG(smallBytest *self, const char *filePath) {

  return(self->f->writeFile(self, filePath));
}

int writeFileSmallJsonSmallBytesG(smallBytest *self, smallJsont *filePath) {

  return(self->f->writeFileSmallJson(self, filePath));
}

int writeFileSmallStringSmallBytesG(smallBytest *self, smallStringt *filePath) {

  return(self->f->writeFileSmallString(self, filePath));
}

int writeStreamSmallBytesG(smallBytest *self, FILE *fp) {

  return(self->f->writeStream(self, fp));
}

int appendFileSmallBytesG(smallBytest *self, const char *filePath) {

  return(self->f->appendFile(self, filePath));
}

int appendFileSmallStringSmallBytesG(smallBytest *self, smallStringt *filePath) {

  return(self->f->appendFileSmallString(self, filePath));
}

bool equalSmallBytesG(smallBytest *self, smallBytest *value) {

  return(self->f->equal(self, value));
}

bool equalSmallBytesBoolG(smallBytest *self, bool value) {

  return(self->f->equalBool(self, value));
}

bool equalSmallBytesDoubleG(smallBytest *self, double value) {

  return(self->f->equalDouble(self, value));
}

bool equalSmallBytesInt64G(smallBytest *self, int64_t value) {

  return(self->f->equalInt64(self, value));
}

bool equalSmallBytesInt32G(smallBytest *self, int32_t value) {

  return(self->f->equalInt32(self, value));
}

bool equalSmallBytesUint32G(smallBytest *self, uint32_t value) {

  return(self->f->equalUint32(self, value));
}

bool equalSmallBytesUint64G(smallBytest *self, uint64_t value) {

  return(self->f->equalUint64(self, value));
}

bool equalSmallBytesSmallBoolG(smallBytest *self, smallBoolt *value) {

  return(self->f->equalSmallBool(self, value));
}

bool equalSmallBytesSmallDoubleG(smallBytest *self, smallDoublet *value) {

  return(self->f->equalSmallDouble(self, value));
}

bool equalSmallBytesSmallIntG(smallBytest *self, smallIntt *value) {

  return(self->f->equalSmallInt(self, value));
}

bool equalSmallBytesCharG(smallBytest *self, const char *value) {

  return(self->f->equalS(self, value));
}

bool equalSmallBytesSmallStringG(smallBytest *self, smallStringt *value) {

  return(self->f->equalSmallString(self, value));
}

bool equalSmallBytesBaseG(smallBytest *self, baset *value) {

  return(self->f->equalBase(self, value));
}