libsheepyCSmallInt.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 "libsheepyCSmallInt.h"
#include "libsheepyCSmallIntInternal.h"
#include <inttypes.h>

#define internal static

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

void initiateSmallInt(smallIntt *self);
void registerMethodsSmallInt(smallIntFunctionst *f);
void initiateAllocateSmallInt(smallIntt **self);
void finalizeRecycleSmallInt(void *arg UNUSED);
void finalizeSmallInt(void);
smallIntt* allocSmallInt(int64_t value);
void cleanUpSmallIntTerminateG(smallIntt **val);
void cleanUpSmallIntFreeLocalG(smallIntt *val);
void cleanUpSmallIntFreeG(smallIntt **val);
void cleanUpSmallIntFinishG(smallIntt **val);
internal void freeSmallInt(smallIntt *self);
internal void terminateSmallInt(smallIntt **self);
internal char* toStringSmallInt(smallIntt *self);
internal smallIntt* duplicateSmallInt(smallIntt *self);
internal void  smashSmallInt(smallIntt **self);
#if (NFreeStackCheck)
internal void finishSmallInt(smallIntt **self);
#else
internal void finishSmallInt(smallIntt **self);
#endif
internal const char* helpSmallInt(smallIntt UNUSED *self);
internal int64_t  getSmallInt(smallIntt *self);
internal smallIntt*  setSmallInt(smallIntt *self, int64_t value);
internal smallIntt* setBoolSmallInt(smallIntt* self, bool p2);
internal smallIntt* setDoubleSmallInt(smallIntt* self, double p2);
internal smallIntt* setInt32SmallInt(smallIntt* self, int32_t p2);
internal smallIntt* setUint32SmallInt(smallIntt* self, uint32_t p2);
internal smallIntt* setUint64SmallInt(smallIntt* self, uint64_t p2);
internal smallIntt* setSSmallInt(smallIntt* self, const char* p2);
internal smallIntt* setSmallBoolSmallInt(smallIntt* self, smallBoolt* p2);
internal smallIntt* setSmallDoubleSmallInt(smallIntt* self, smallDoublet* p2);
internal smallIntt* setSmallIntSmallInt(smallIntt* self, smallIntt* p2);
internal smallIntt* setSmallJsonSmallInt(smallIntt* self, smallJsont* p2);
internal smallIntt* setSmallStringSmallInt(smallIntt* self, smallStringt* p2);
internal int64_t* getPSmallInt(smallIntt *self);
internal bool equalSmallIntCha(smallIntt* self, char p2);
internal bool equalSmallIntChar(smallIntt* self, const char * p2);
internal bool equalSmallIntBase(smallIntt* self, baset* p2);
internal bool equalSmallIntBool(smallIntt* self, bool p2);
internal bool equalSmallIntDouble(smallIntt* self, double p2);
internal bool equalSmallIntInt64(smallIntt* self, int64_t p2);
internal bool equalSmallIntInt32(smallIntt* self, int32_t p2);
internal bool equalSmallIntUint32(smallIntt* self, uint32_t p2);
internal bool equalSmallIntUint64(smallIntt* self, uint64_t p2);
internal bool equalSmallIntSmallBool(smallIntt* self, smallBoolt* p2);
internal bool equalSmallIntSmallBytes(smallIntt* self, smallBytest* p2);
internal bool equalSmallIntSmallDouble(smallIntt* self, smallDoublet* p2);
internal bool equalSmallInt(smallIntt* self, smallIntt* p2);
internal bool equalSmallIntSmallJson(smallIntt* self, smallJsont* p2);
internal bool equalSmallIntSmallString(smallIntt* self, smallStringt* p2);
internal smallIntt* readFileSmallInt(smallIntt *self, const char *filePath);
internal smallIntt* readFileSmallJsonSmallInt(smallIntt *self, smallJsont *filePath);
internal smallIntt* readFileSmallStringSmallInt(smallIntt *self, smallStringt *filePath);
internal smallIntt* readStreamSmallInt(smallIntt *self, FILE *fp);
internal int writeFileSmallInt(smallIntt *self, const char *filePath);
internal int writeFileSmallJsonSmallInt(smallIntt *self, smallJsont *filePath);
internal int writeFileSmallStringSmallInt(smallIntt *self, smallStringt *filePath);
internal int writeStreamSmallInt(smallIntt *self, FILE *fp);
internal int appendFileSmallInt(smallIntt *self, const char *filePath);
internal int appendFileSmallStringSmallInt(smallIntt *self, smallStringt *filePath);
smallIntt*          duplicateSmallIntG       (smallIntt *self);
int64_t             getIntSmallIntG          (smallIntt *self, int64_t retType UNUSED, int64_t index UNUSED);
int64_t*            getIntPSmallIntG         (smallIntt *self, int64_t* retType UNUSED, int64_t index UNUSED);
int32_t             getInt32SmallIntG        (smallIntt *self, int32_t retType UNUSED, int64_t index UNUSED);
int32_t*            getInt32PSmallIntG       (smallIntt *self, int32_t* retType UNUSED, int64_t index UNUSED);
uint64_t            getUintSmallIntG          (smallIntt *self, uint64_t retType UNUSED, int64_t index UNUSED);
uint64_t*           getUintPSmallIntG         (smallIntt *self, uint64_t* retType UNUSED, int64_t index UNUSED);
uint32_t            getUint32SmallIntG        (smallIntt *self, uint32_t retType UNUSED, int64_t index UNUSED);
uint32_t*           getUint32PSmallIntG       (smallIntt *self, uint32_t* retType UNUSED, int64_t index UNUSED);
smallIntt* setBoolSmallIntG(smallIntt* self, bool p2);
smallIntt* setDoubleSmallIntG(smallIntt* self, double p2);
smallIntt* setInt32SmallIntG(smallIntt* self, int32_t p2);
smallIntt* setUint32SmallIntG(smallIntt* self, uint32_t p2);
smallIntt* setUint64SmallIntG(smallIntt* self, uint64_t p2);
smallIntt* setSSmallIntG(smallIntt* self, const char* p2);
smallIntt* setSmallBoolSmallIntG(smallIntt* self, smallBoolt* p2);
smallIntt* setSmallDoubleSmallIntG(smallIntt* self, smallDoublet* p2);
smallIntt* setSmallIntSmallIntG(smallIntt* self, smallIntt* p2);
smallIntt* setSmallJsonSmallIntG(smallIntt* self, smallJsont* p2);
smallIntt* setSmallStringSmallIntG(smallIntt* self, smallStringt* p2);
bool equalSmallIntChaG(smallIntt* self, char p2);
bool equalSmallIntCharG(smallIntt* self, const char * p2);
bool equalSmallIntBaseG(smallIntt* self, baset* p2);
bool equalSmallIntBoolG(smallIntt* self, bool p2);
bool equalSmallIntDoubleG(smallIntt* self, double p2);
bool equalSmallIntInt64G(smallIntt* self, int64_t p2);
bool equalSmallIntInt32G(smallIntt* self, int32_t p2);
bool equalSmallIntUint32G(smallIntt* self, uint32_t p2);
bool equalSmallIntUint64G(smallIntt* self, uint64_t p2);
bool equalSmallIntSmallBoolG(smallIntt* self, smallBoolt* p2);
bool equalSmallIntSmallBytesG(smallIntt* self, smallBytest* p2);
bool equalSmallIntSmallDoubleG(smallIntt* self, smallDoublet* p2);
bool equalSmallIntFG(smallIntt* self, smallIntt* p2);
bool equalSmallIntSmallJsonG(smallIntt* self, smallJsont* p2);
bool equalSmallIntSmallStringG(smallIntt* self, smallStringt* p2);
smallIntt*  readFileSmallIntG     (smallIntt *self, const char *filePath);
smallIntt* readFileSmallJsonSmallIntG  (smallIntt *self, smallJsont *filePath);
smallIntt* readFileSmallStringSmallIntG(smallIntt *self, smallStringt *filePath);
smallIntt* readStreamSmallIntG         (smallIntt *self, FILE *fp);
int  writeFileSmallIntG    (smallIntt *self, const char *filePath);
int writeFileSmallJsonSmallIntG  (smallIntt *self, smallJsont *filePath);
int writeFileSmallStringSmallIntG(smallIntt *self, smallStringt *filePath);
int writeStreamSmallIntG         (smallIntt *self, FILE *fp);
int appendFileSmallIntFG           (smallIntt *self, const char *filePath);
int appendFileSmallStringSmallIntG(smallIntt *self, smallStringt *filePath);

void initiateSmallInt(smallIntt *self) {

  self->type = "smallInt";
  if (!smallIntF) {
    isError(smallIntF, malloc(sizeof(smallIntFunctionst))) {
      self->f = NULL;
      return;
    }
    registerMethodsSmallInt(smallIntF);
  }
  self->f = smallIntF;

  self->value = NULL;
}

void registerMethodsSmallInt(smallIntFunctionst *f) {

  f->free                  = freeSmallInt;
  f->terminate             = terminateSmallInt;
  f->toString              = toStringSmallInt;
  f->duplicate             = duplicateSmallInt;
  f->smash                 = smashSmallInt;
  f->finish                = finishSmallInt;
  f->help                  = helpSmallInt;
  f->get                   = getSmallInt;
  f->set                   = setSmallInt;
  f->setBool               = setBoolSmallInt;
  f->setDouble             = setDoubleSmallInt;
  f->setInt32              = setInt32SmallInt;
  f->setUint32             = setUint32SmallInt;
  f->setUint64             = setUint64SmallInt;
  f->setS                  = setSSmallInt;
  f->setSmallBool          = setSmallBoolSmallInt;
  f->setSmallDouble        = setSmallDoubleSmallInt;
  f->setSmallInt           = setSmallIntSmallInt;
  f->setSmallJson          = setSmallJsonSmallInt;
  f->setSmallString        = setSmallStringSmallInt;
  f->getP                  = getPSmallInt;
  f->equalCha              = equalSmallIntCha;
  f->equalChar             = equalSmallIntChar;
  f->equalBase             = equalSmallIntBase;
  f->equalBool             = equalSmallIntBool;
  f->equalDouble           = equalSmallIntDouble;
  f->equalInt64            = equalSmallIntInt64;
  f->equalInt32            = equalSmallIntInt32;
  f->equalUint32           = equalSmallIntUint32;
  f->equalUint64           = equalSmallIntUint64;
  f->equalSmallBool        = equalSmallIntSmallBool;
  f->equalSmallBytes       = equalSmallIntSmallBytes;
  f->equalSmallDouble      = equalSmallIntSmallDouble;
  f->equal                 = equalSmallInt;
  f->equalSmallJson        = equalSmallIntSmallJson;
  f->equalSmallString      = equalSmallIntSmallString;
  f->readFile              = readFileSmallInt;
  f->readFileSmallJson     = readFileSmallJsonSmallInt;
  f->readFileSmallString   = readFileSmallStringSmallInt;
  f->readStream            = readStreamSmallInt;
  f->writeFile             = writeFileSmallInt;
  f->writeFileSmallJson    = writeFileSmallJsonSmallInt;
  f->writeFileSmallString  = writeFileSmallStringSmallInt;
  f->writeStream           = writeStreamSmallInt;
  f->appendFile            = appendFileSmallInt;
  f->appendFileSmallString = appendFileSmallStringSmallInt;
}

void initiateAllocateSmallInt(smallIntt **self) {

  if (self) {
    #if (recycleContainers)
    initAllocateRecycle(smallIntt);
    #else
    isError(*self, malloc(sizeof(smallIntt)))
      return;
    #endif
    if (*self) {
      initiateSmallInt(*self);
      if (!(*self)->f) {
        finishSmallInt(self);
}
  }
    }
      }

void finalizeRecycleSmallInt(void *arg UNUSED) {

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

void finalizeSmallInt(void) {

  if (smallIntF) {
    free(smallIntF);
    smallIntF = NULL;
  }
  finalizeRecycleSmallInt(NULL);
}

smallIntt* allocSmallInt(int64_t value) {
  smallIntt *r = NULL;

  initiateAllocateSmallInt(&r);
  if (!r) {
    return(NULL);
  }
  isError(r->value, allocSInt(value)) {
    terminateO(r);
    return(NULL);
  }
  return(r);
}

void cleanUpSmallIntTerminateG(smallIntt **val) {

  terminateO(*val);
}

void cleanUpSmallIntFreeLocalG(smallIntt *val) {

  freeO(val);
}

void cleanUpSmallIntFreeG(smallIntt **val) {

  freeO(*val);
}

void cleanUpSmallIntFinishG(smallIntt **val) {

  finishO(*val);
}

internal void freeSmallInt(smallIntt *self) {

  if (self->value) {
    free(self->value);
    self->value = NULL;
  }
  return;
}

internal void terminateSmallInt(smallIntt **self) {

  freeSmallInt(*self);
  finishSmallInt(self);
}


internal char* toStringSmallInt(smallIntt *self) {
  char *s = NULL;

  if (!self->value) {
    return(NULL);
  }
  s = malloc(256*sizeof(char));
  if (!s) {
    return(NULL);
  }
  snprintf(s,256, "%" PRIi64, self->value->value);

  return(s);
}

internal smallIntt* duplicateSmallInt(smallIntt *self) {

  createAllocateSmallInt(dup);
  if (!dup) {
    return(NULL);
  }
  if (self->value) {
    isError(dup->value, allocSInt(self->value->value)) {
      terminateO(dup);
      return(NULL);
    }
  }
  return(dup);
}

internal void  smashSmallInt(smallIntt **self) {

  finishSmallInt(self);
}

#if (NFreeStackCheck)
internal void finishSmallInt(smallIntt **self) {

  register u64 rsp asm("rsp");
  if ((u64)*self > rsp) {
    logW("Probably trying to free a smallInt 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 finishSmallInt(smallIntt **self) {

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

#endif
// #if NFreeStackCheck

internal const char* helpSmallInt(smallIntt UNUSED *self) {

  return(helpTextSmallInt);
}

internal int64_t  getSmallInt(smallIntt *self) {

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

internal smallIntt*  setSmallInt(smallIntt *self, int64_t value) {

  if (!self->value) {
    isError(self->value, allocSInt(value)) return(NULL);
  }
  else {
    self->value->value = value;
  }
  return(self);
}

internal smallIntt* setBoolSmallInt(smallIntt* self, bool p2) {

  if (!self->value) {
    isError(self->value, allocSInt((int64_t)p2)) return(NULL);
  }
  else {
    self->value->value = (int64_t)p2;
  }
  return(self);
}

internal smallIntt* setDoubleSmallInt(smallIntt* self, double p2) {

  if (!self->value) {
    isError(self->value, allocSInt((int64_t)p2)) return(NULL);
  }
  else {
    self->value->value = (int64_t)p2;
  }
  return(self);
}

internal smallIntt* setInt32SmallInt(smallIntt* self, int32_t p2) {

  if (!self->value) {
    isError(self->value, allocSInt((int64_t)p2)) return(NULL);
  }
  else {
    self->value->value = (int64_t)p2;
  }
  return(self);
}

internal smallIntt* setUint32SmallInt(smallIntt* self, uint32_t p2) {

  if (!self->value) {
    isError(self->value, allocSInt((int64_t)p2)) return(NULL);
  }
  else {
    self->value->value = (int64_t)p2;
  }
  return(self);
}

internal smallIntt* setUint64SmallInt(smallIntt* self, uint64_t p2) {

  if (!self->value) {
    isError(self->value, allocSInt((int64_t)p2)) return(NULL);
  }
  else {
    self->value->value = (int64_t)p2;
  }
  return(self);
}

internal smallIntt* setSSmallInt(smallIntt* self, const char* p2) {

  if (!p2 || !isNumber(p2)) {
    return(NULL);
  }
  if (!self->value) {
    isError(self->value, allocSInt(parseInt(p2))) return(NULL);
  }
  else {
    self->value->value = parseInt(p2);
  }
  return(self);
}

internal smallIntt* setSmallBoolSmallInt(smallIntt* self, smallBoolt* p2) {
  bool value;

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

  value = p2->f->get(p2);

  if (!self->value) {
    isError(self->value, allocSInt((int64_t)value)) return(NULL);
  }
  else {
    self->value->value = (int64_t)value;
  }
  return(self);
}

internal smallIntt* setSmallDoubleSmallInt(smallIntt* self, smallDoublet* p2) {

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

  if (!self->value) {
    isError(self->value, allocSInt((int64_t)p2->f->get(p2))) return(NULL);
  }
  else {
    self->value->value = (int64_t)p2->f->get(p2);
  }
  return(self);
}

internal smallIntt* setSmallIntSmallInt(smallIntt* self, smallIntt* p2) {

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

  if (!self->value) {
    isError(self->value, allocSInt(p2->f->get(p2))) return(NULL);
  }
  else {
    self->value->value = p2->f->get(p2);
  }
  return(self);
}

internal smallIntt* setSmallJsonSmallInt(smallIntt* self, smallJsont* p2) {

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

  const char *type = getTopTypeO(p2);

  if (!type || eqS(type, "undefined") || eqS(type, "dict") || eqS(type, "array")) {
    return(NULL);
  }

  if (eqS(type, "bool")) {
    return(setBoolSmallInt(self, getTopBoolO(p2)));
  }
  else if (eqS(type, "double")) {
    return(setDoubleSmallInt(self, getTopDoubleO(p2)));
  }
  else if (eqS(type, "int")) {
    return(setSmallInt(self, getTopIntO(p2)));
  }
  else if (eqS(type, "string")) {
    return(setSSmallInt(self, getTopSO(p2)));
  }

  return(NULL);
}

internal smallIntt* setSmallStringSmallInt(smallIntt* self, smallStringt* p2) {

  if (!p2 || !isNumberO(p2)) {
    return(NULL);
  }
  if (!self->value) {
    isError(self->value, allocSInt(parseIntO(p2))) return(NULL);
  }
  else {
    self->value->value = parseIntO(p2);
  }
  return(self);
}

internal int64_t* getPSmallInt(smallIntt *self) {

  if (!self->value) {
    return(NULL);
  }
  return(&(self->value->value));
}

internal bool equalSmallIntCha(smallIntt* self, char p2) {

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

  charToS(s, p2);

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

  int64_t value = parseInt(s);

  return(self->value->value == value);;
}

internal bool equalSmallIntChar(smallIntt* self, const char * p2) {

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

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

  int64_t value = parseInt(p2);

  return(self->value->value == value);;
}

internal bool equalSmallIntBase(smallIntt* self, baset* p2) {

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

  char *s = toStringO(p2);

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

  int64_t value = parseInt(s);

  bool r;
  if (self->value->value == value) {
    r = true;
  }
  else {
    r = false;
  }
  free(s);
  return(r);
}

internal bool equalSmallIntBool(smallIntt* self, bool p2) {

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

  return(self->value->value == p2);;
}

internal bool equalSmallIntDouble(smallIntt* self, double p2) {

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

  return(self->value->value == p2);;
}

internal bool equalSmallIntInt64(smallIntt* self, int64_t p2) {

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

  return(self->value->value == p2);;
}

internal bool equalSmallIntInt32(smallIntt* self, int32_t p2) {

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

  return(self->value->value == p2);;
}

internal bool equalSmallIntUint32(smallIntt* self, uint32_t p2) {

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

  return(self->value->value == p2);;
}

internal bool equalSmallIntUint64(smallIntt* self, uint64_t p2) {

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

  return((uint64_t)self->value->value == p2);;
}

internal bool equalSmallIntSmallBool(smallIntt* self, smallBoolt* p2) {

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

  return(self->value->value == p2->value->value);;
}

internal bool equalSmallIntSmallBytes(smallIntt* self, smallBytest* p2) {

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

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

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

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

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

  int64_t p2Value = parseInt(s);

  return(p2Value == self->value->value);;
}

internal bool equalSmallIntSmallDouble(smallIntt* self, smallDoublet* p2) {

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

  return(self->value->value == p2->value->value);;
}

internal bool equalSmallInt(smallIntt* self, smallIntt* p2) {

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

  return(self->value->value == p2->value->value);;
}

internal bool equalSmallIntSmallJson(smallIntt* self, smallJsont* p2) {

  // sanity checks
  if (!p2) {
    return(false);
  }

  if (checkObjectTypes && !isOSmallJson(p2)) {
    return(false);
  }

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

internal bool equalSmallIntSmallString(smallIntt* self, smallStringt* p2) {

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

  if (!isIntO(p2)) {
    return(false);
  }

  int64_t value = parseIntO(p2);

  return(self->value->value == value);;
}

internal smallIntt* readFileSmallInt(smallIntt *self, const char *filePath) {
  FILE *f = NULL;
  size_t readStatus;

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

  if (!self->value) {
    isError(self->value, allocSInt(0)) return(NULL);
  }

  f = fopen(filePath, "r");
  if (!f) {
    pFuncError
    shEPrintfS("The path was: \"%s\"\n", filePath);
    return(NULL);
  }
  readStatus = fread(&self->value->value, 1, sizeof(int64_t) , f);
  fclose(f);

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

  return(self);
}

internal smallIntt* readFileSmallJsonSmallInt(smallIntt *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(readFileSmallInt(self, getTopSO(filePath)));
}

internal smallIntt* readFileSmallStringSmallInt(smallIntt *self, smallStringt *filePath) {

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

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

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

internal smallIntt* readStreamSmallInt(smallIntt *self, FILE *fp) {
  size_t readStatus;

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

  if (!self->value) {
    isError(self->value, allocSInt(0)) return(NULL);
  }

  readStatus = fread(&self->value->value, 1, sizeof(int64_t) , fp);

  if (readStatus != sizeof(int64_t)) {
    pFuncError
    return(NULL);
  }

  return(self);
}

internal int writeFileSmallInt(smallIntt *self, const char *filePath) {
  FILE *f = NULL;
  size_t writeStatus;

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

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

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

  return(1);
}

internal int writeFileSmallJsonSmallInt(smallIntt *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(writeFileSmallInt(self, getTopSO(filePath)));
}

internal int writeFileSmallStringSmallInt(smallIntt *self, smallStringt *filePath) {

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

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

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

internal int writeStreamSmallInt(smallIntt *self, FILE *fp) {
  size_t writeStatus;

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

  writeStatus = fwrite(&self->value->value, 1, sizeof(int64_t) , fp);

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

  return(1);
}

internal int appendFileSmallInt(smallIntt *self, const char *filePath) {
  FILE *f = NULL;
  size_t writeStatus;

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

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

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

  return(1);
}

internal int appendFileSmallStringSmallInt(smallIntt *self, smallStringt *filePath) {

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

smallIntt*          duplicateSmallIntG       (smallIntt *self) {

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

void                freeSmallIntG            (smallIntt *self) {self->f->free(self);}

int64_t             getIntSmallIntG          (smallIntt *self, int64_t retType UNUSED, int64_t index UNUSED) {

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

int64_t*            getIntPSmallIntG         (smallIntt *self, int64_t* retType UNUSED, int64_t index UNUSED) {

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

int32_t             getInt32SmallIntG        (smallIntt *self, int32_t retType UNUSED, int64_t index UNUSED) {

  return((int32_t)self->f->get(self));
}

int32_t*            getInt32PSmallIntG       (smallIntt *self, int32_t* retType UNUSED, int64_t index UNUSED) {

  return((int32_t*)self->f->getP(self));
}

uint64_t            getUintSmallIntG          (smallIntt *self, uint64_t retType UNUSED, int64_t index UNUSED) {

  return((uint64_t)self->f->get(self));
}

uint64_t*           getUintPSmallIntG         (smallIntt *self, uint64_t* retType UNUSED, int64_t index UNUSED) {

  return((uint64_t*)self->f->getP(self));
}

uint32_t            getUint32SmallIntG        (smallIntt *self, uint32_t retType UNUSED, int64_t index UNUSED) {

  return((uint32_t)self->f->get(self));
}

uint32_t*           getUint32PSmallIntG       (smallIntt *self, uint32_t* retType UNUSED, int64_t index UNUSED) {

  return((uint32_t*)self->f->getP(self));
}

smallIntt* setBoolSmallIntG(smallIntt* self, bool p2) {

  return(self->f->setBool(self, p2));
}

smallIntt* setDoubleSmallIntG(smallIntt* self, double p2) {

  return(self->f->setDouble(self, p2));
}

smallIntt* setInt32SmallIntG(smallIntt* self, int32_t p2) {

  return(self->f->setInt32(self, p2));
}

smallIntt* setUint32SmallIntG(smallIntt* self, uint32_t p2) {

  return(self->f->setUint32(self, p2));
}

smallIntt* setUint64SmallIntG(smallIntt* self, uint64_t p2) {

  return(self->f->setUint64(self, p2));
}

smallIntt* setSSmallIntG(smallIntt* self, const char* p2) {

  return(self->f->setS(self, p2));
}

smallIntt* setSmallBoolSmallIntG(smallIntt* self, smallBoolt* p2) {

  return(self->f->setSmallBool(self, p2));
}

smallIntt* setSmallDoubleSmallIntG(smallIntt* self, smallDoublet* p2) {

  return(self->f->setSmallDouble(self, p2));
}

smallIntt* setSmallIntSmallIntG(smallIntt* self, smallIntt* p2) {

  return(self->f->setSmallInt(self, p2));
}

smallIntt* setSmallJsonSmallIntG(smallIntt* self, smallJsont* p2) {

  return(self->f->setSmallJson(self, p2));
}

smallIntt* setSmallStringSmallIntG(smallIntt* self, smallStringt* p2) {

  return(self->f->setSmallString(self, p2));
}


bool equalSmallIntChaG(smallIntt* self, char p2) {

  return(self->f->equalCha(self, p2));
}

bool equalSmallIntCharG(smallIntt* self, const char * p2) {

  return(self->f->equalChar(self, p2));
}

bool equalSmallIntBaseG(smallIntt* self, baset* p2) {

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

bool equalSmallIntBoolG(smallIntt* self, bool p2) {

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

bool equalSmallIntDoubleG(smallIntt* self, double p2) {

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

bool equalSmallIntInt64G(smallIntt* self, int64_t p2) {

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

bool equalSmallIntInt32G(smallIntt* self, int32_t p2) {

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

bool equalSmallIntUint32G(smallIntt* self, uint32_t p2) {

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

bool equalSmallIntUint64G(smallIntt* self, uint64_t p2) {

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

bool equalSmallIntSmallBoolG(smallIntt* self, smallBoolt* p2) {

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

bool equalSmallIntSmallBytesG(smallIntt* self, smallBytest* p2) {

  return(self->f->equalSmallBytes(self, p2));
}

bool equalSmallIntSmallDoubleG(smallIntt* self, smallDoublet* p2) {

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

bool equalSmallIntFG(smallIntt* self, smallIntt* p2) {

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

bool equalSmallIntSmallJsonG(smallIntt* self, smallJsont* p2) {

  return(self->f->equalSmallJson(self, p2));
}

bool equalSmallIntSmallStringG(smallIntt* self, smallStringt* p2) {

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

smallIntt*  readFileSmallIntG     (smallIntt *self, const char *filePath) {

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

smallIntt* readFileSmallJsonSmallIntG  (smallIntt *self, smallJsont *filePath) {

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

smallIntt* readFileSmallStringSmallIntG(smallIntt *self, smallStringt *filePath) {

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

smallIntt* readStreamSmallIntG         (smallIntt *self, FILE *fp) {

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

int  writeFileSmallIntG    (smallIntt *self, const char *filePath) {

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

int writeFileSmallJsonSmallIntG  (smallIntt *self, smallJsont *filePath) {

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

int writeFileSmallStringSmallIntG(smallIntt *self, smallStringt *filePath) {

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

int writeStreamSmallIntG         (smallIntt *self, FILE *fp) {

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

int appendFileSmallIntFG           (smallIntt *self, const char *filePath) {

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

int appendFileSmallStringSmallIntG(smallIntt *self, smallStringt *filePath) {

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