libsheepyCSmallBool.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 "libsheepyCSmallBool.h"
#include "libsheepyCSmallBoolInternal.h"

#define internal static

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

void initiateSmallBool(smallBoolt *self);
void registerMethodsSmallBool(smallBoolFunctionst *f);
void initiateAllocateSmallBool(smallBoolt **self);
void finalizeRecycleSmallBool(void *arg UNUSED);
void finalizeSmallBool(void);
smallBoolt* allocSmallBool(bool value);
void cleanUpSmallBoolTerminateG(smallBoolt **val);
void cleanUpSmallBoolFreeLocalG(smallBoolt *val);
void cleanUpSmallBoolFreeG(smallBoolt **val);
void cleanUpSmallBoolFinishG(smallBoolt **val);
internal void freeSmallBool(smallBoolt *self);
internal void terminateSmallBool(smallBoolt **self);
internal char* toStringSmallBool(smallBoolt *self);
internal smallBoolt* duplicateSmallBool(smallBoolt *self);
internal void  smashSmallBool(smallBoolt **self);
#if (NFreeStackCheck)
internal void finishSmallBool(smallBoolt **self);
#else
internal void finishSmallBool(smallBoolt **self);
#endif
internal const char* helpSmallBool(smallBoolt UNUSED *self);
internal bool  getSmallBool(smallBoolt *self);
internal smallBoolt*  setSmallBool(smallBoolt *self, bool value);
internal smallBoolt* setDoubleSmallBool(smallBoolt* self, double p2);
internal smallBoolt* setInt64SmallBool(smallBoolt* self, int64_t p2);
internal smallBoolt* setInt32SmallBool(smallBoolt* self, int32_t p2);
internal smallBoolt* setUint32SmallBool(smallBoolt* self, uint32_t p2);
internal smallBoolt* setUint64SmallBool(smallBoolt* self, uint64_t p2);
internal smallBoolt* setSSmallBool(smallBoolt* self, const char* p2);
internal smallBoolt* setSmallBoolSmallBool(smallBoolt* self, smallBoolt* p2);
internal smallBoolt* setSmallDoubleSmallBool(smallBoolt* self, smallDoublet* p2);
internal smallBoolt* setSmallIntSmallBool(smallBoolt* self, smallIntt* p2);
internal smallBoolt* setSmallJsonSmallBool(smallBoolt* self, smallJsont* p2);
internal smallBoolt* setSmallStringSmallBool(smallBoolt* self, smallStringt* p2);
internal bool* getPSmallBool(smallBoolt *self);
internal bool equalSmallBoolChar(smallBoolt* self, const char * p2);
internal bool equalSmallBoolBase(smallBoolt* self, baset* p2);
internal bool equalSmallBoolBool(smallBoolt* self, bool p2);
internal bool equalSmallBoolDouble(smallBoolt* self, double p2);
internal bool equalSmallBoolInt64(smallBoolt* self, int64_t p2);
internal bool equalSmallBoolInt32(smallBoolt* self, int32_t p2);
internal bool equalSmallBoolUint32(smallBoolt* self, uint32_t p2);
internal bool equalSmallBoolUint64(smallBoolt* self, uint64_t p2);
internal bool equalSmallBool(smallBoolt* self, smallBoolt* p2);
internal bool equalSmallBoolSmallBytes(smallBoolt* self, smallBytest* p2);
internal bool equalSmallBoolSmallDouble(smallBoolt* self, smallDoublet* p2);
internal bool equalSmallBoolSmallInt(smallBoolt* self, smallIntt* p2);
internal bool equalSmallBoolSmallJson(smallBoolt* self, smallJsont* p2);
internal bool equalSmallBoolSmallString(smallBoolt* self, smallStringt* p2);
internal smallBoolt* readFileSmallBool(smallBoolt *self, const char *filePath);
internal smallBoolt* readFileSmallJsonSmallBool(smallBoolt *self, smallJsont *filePath);
internal smallBoolt* readFileSmallStringSmallBool(smallBoolt *self, smallStringt *filePath);
internal smallBoolt* readStreamSmallBool(smallBoolt *self, FILE *fp);
internal int writeFileSmallBool(smallBoolt *self, const char *filePath);
internal int writeFileSmallJsonSmallBool(smallBoolt *self, smallJsont *filePath);
internal int writeFileSmallStringSmallBool(smallBoolt *self, smallStringt *filePath);
internal int writeStreamSmallBool(smallBoolt *self, FILE *fp);
internal int appendFileSmallBool(smallBoolt *self, const char *filePath);
internal int appendFileSmallStringSmallBool(smallBoolt *self, smallStringt *filePath);
smallBoolt* duplicateSmallBoolG (smallBoolt *self);
bool             getBoolSmallBoolG          (smallBoolt *self, bool retType UNUSED, int64_t index UNUSED);
bool*            getBoolPSmallBoolG         (smallBoolt *self, bool* retType UNUSED, int64_t index UNUSED);
smallBoolt* setSmallBoolG(smallBoolt* self, bool p2);
smallBoolt* setDoubleSmallBoolG(smallBoolt* self, double p2);
smallBoolt* setInt64SmallBoolG(smallBoolt* self, int64_t p2);
smallBoolt* setInt32SmallBoolG(smallBoolt* self, int32_t p2);
smallBoolt* setUint32SmallBoolG(smallBoolt* self, uint32_t p2);
smallBoolt* setUint64SmallBoolG(smallBoolt* self, uint64_t p2);
smallBoolt* setSSmallBoolG(smallBoolt* self, const char* p2);
smallBoolt* setSmallBoolSmallBoolG(smallBoolt* self, smallBoolt* p2);
smallBoolt* setSmallDoubleSmallBoolG(smallBoolt* self, smallDoublet* p2);
smallBoolt* setSmallIntSmallBoolG(smallBoolt* self, smallIntt* p2);
smallBoolt* setSmallJsonSmallBoolG(smallBoolt* self, smallJsont* p2);
smallBoolt* setSmallStringSmallBoolG(smallBoolt* self, smallStringt* p2);
bool equalSmallBoolCharG(smallBoolt* self, const char * p2);
bool equalSmallBoolBaseG(smallBoolt* self, baset* p2);
bool equalSmallBoolBoolG(smallBoolt* self, bool p2);
bool equalSmallBoolDoubleG(smallBoolt* self, double p2);
bool equalSmallBoolInt64G(smallBoolt* self, int64_t p2);
bool equalSmallBoolInt32G(smallBoolt* self, int32_t p2);
bool equalSmallBoolUint32G(smallBoolt* self, uint32_t p2);
bool equalSmallBoolUint64G(smallBoolt* self, uint64_t p2);
bool equalSmallBoolFG(smallBoolt* self, smallBoolt* p2);
bool equalSmallBoolSmallBytesG(smallBoolt* self, smallBytest* p2);
bool equalSmallBoolSmallDoubleG(smallBoolt* self, smallDoublet* p2);
bool equalSmallBoolSmallIntG(smallBoolt* self, smallIntt* p2);
bool equalSmallBoolSmallJsonG(smallBoolt* self, smallJsont* p2);
bool equalSmallBoolSmallStringG(smallBoolt* self, smallStringt* p2);
smallBoolt*  readFileSmallBoolG     (smallBoolt *self, const char *filePath);
smallBoolt* readFileSmallJsonSmallBoolG(smallBoolt *self, smallJsont *filePath);
smallBoolt* readFileSmallStringSmallBoolG(smallBoolt *self, smallStringt *filePath);
smallBoolt* readStreamSmallBoolG         (smallBoolt *self, FILE *fp);
int  writeFileSmallBoolG    (smallBoolt *self, const char *filePath);
int writeFileSmallJsonSmallBoolG  (smallBoolt *self, smallJsont *filePath);
int writeFileSmallStringSmallBoolG(smallBoolt *self, smallStringt *filePath);
int writeStreamSmallBoolG         (smallBoolt *self, FILE *fp);
int appendFileSmallBoolFG           (smallBoolt *self, const char *filePath);
int appendFileSmallStringSmallBoolG(smallBoolt *self, smallStringt *filePath);

void initiateSmallBool(smallBoolt *self) {

  self->type = "smallBool";

  if (!smallBoolF) {
    isError(smallBoolF, malloc(sizeof(smallBoolFunctionst))) {
      self->f = NULL;
      return;
    }
    registerMethodsSmallBool(smallBoolF);
  }
  self->f = smallBoolF;

  self->value = NULL;
}

void registerMethodsSmallBool(smallBoolFunctionst *f) {

  f->free                  = freeSmallBool;
  f->terminate             = terminateSmallBool;
  f->toString              = toStringSmallBool;
  f->duplicate             = duplicateSmallBool;
  f->smash                 = smashSmallBool;
  f->finish                = finishSmallBool;
  f->help                  = helpSmallBool;
  f->get                   = getSmallBool;
  f->set                   = setSmallBool;
  f->setDouble             = setDoubleSmallBool;
  f->setInt64              = setInt64SmallBool;
  f->setInt32              = setInt32SmallBool;
  f->setUint32             = setUint32SmallBool;
  f->setUint64             = setUint64SmallBool;
  f->setS                  = setSSmallBool;
  f->setSmallBool          = setSmallBoolSmallBool;
  f->setSmallDouble        = setSmallDoubleSmallBool;
  f->setSmallInt           = setSmallIntSmallBool;
  f->setSmallJson          = setSmallJsonSmallBool;
  f->setSmallString        = setSmallStringSmallBool;
  f->getP                  = getPSmallBool;
  f->equalChar             = equalSmallBoolChar;
  f->equalBase             = equalSmallBoolBase;
  f->equalBool             = equalSmallBoolBool;
  f->equalDouble           = equalSmallBoolDouble;
  f->equalInt64            = equalSmallBoolInt64;
  f->equalInt32            = equalSmallBoolInt32;
  f->equalUint32           = equalSmallBoolUint32;
  f->equalUint64           = equalSmallBoolUint64;
  f->equal                 = equalSmallBool;
  f->equalSmallBytes       = equalSmallBoolSmallBytes;
  f->equalSmallDouble      = equalSmallBoolSmallDouble;
  f->equalSmallInt         = equalSmallBoolSmallInt;
  f->equalSmallJson        = equalSmallBoolSmallJson;
  f->equalSmallString      = equalSmallBoolSmallString;
  f->readFile              = readFileSmallBool;
  f->readFileSmallJson     = readFileSmallJsonSmallBool;
  f->readFileSmallString   = readFileSmallStringSmallBool;
  f->readStream            = readStreamSmallBool;
  f->writeFile             = writeFileSmallBool;
  f->writeFileSmallJson    = writeFileSmallJsonSmallBool;
  f->writeFileSmallString  = writeFileSmallStringSmallBool;
  f->writeStream           = writeStreamSmallBool;
  f->appendFile            = appendFileSmallBool;
  f->appendFileSmallString = appendFileSmallStringSmallBool;
}

void initiateAllocateSmallBool(smallBoolt **self) {

  if (self) {
    #if (recycleContainers)
    initAllocateRecycle(smallBoolt);
    #else
    isError(*self, malloc(sizeof(smallBoolt)))
      return;
    #endif
    // recycleContainers
    if (*self) {
      initiateSmallBool(*self);
      if (!(*self)->f) {
        finishSmallBool(self);
}
  }
    }
      }

void finalizeRecycleSmallBool(void *arg UNUSED) {

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

void finalizeSmallBool(void) {

  if (smallBoolF) {
    free(smallBoolF);
    smallBoolF = NULL;
  }
  finalizeRecycleSmallBool(NULL);
}

smallBoolt* allocSmallBool(bool value) {
  smallBoolt *r = NULL;

  initiateAllocateSmallBool(&r);
  if (!r) {
    return(NULL);
  }

  r->value        = allocSBool(value);
  return(r);
}

void cleanUpSmallBoolTerminateG(smallBoolt **val) {

  terminateO(*val);
}

void cleanUpSmallBoolFreeLocalG(smallBoolt *val) {

  freeO(val);
}

void cleanUpSmallBoolFreeG(smallBoolt **val) {

  freeO(*val);
}

void cleanUpSmallBoolFinishG(smallBoolt **val) {

  finishO(*val);
}

internal void freeSmallBool(smallBoolt *self) {

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

internal void terminateSmallBool(smallBoolt **self) {

  freeSmallBool(*self);
  finishSmallBool(self);
}


internal char* toStringSmallBool(smallBoolt *self) {

  if (!self->value) {
    return(NULL);
  }
  if (self->value->value) {
    return(strdup("true"));
  }
  else {
    return(strdup("false"));
}
  }

internal smallBoolt* duplicateSmallBool(smallBoolt *self) {

  createAllocateSmallBool(dup);
  if (!dup) {
    return(NULL);
  }
  if (self->value) {
    dup->value = allocSBool(self->value->value);
  }
  return(dup);
}

internal void  smashSmallBool(smallBoolt **self) {

  finishSmallBool(self);
}

#if (NFreeStackCheck)
internal void finishSmallBool(smallBoolt **self) {

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

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

#endif
// #if NFreeStackCheck

internal const char* helpSmallBool(smallBoolt UNUSED *self) {

  return(helpTextSmallBool);
}

internal bool  getSmallBool(smallBoolt *self) {

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

internal smallBoolt*  setSmallBool(smallBoolt *self, bool value) {

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

internal smallBoolt* setDoubleSmallBool(smallBoolt* self, double p2) {
  bool value = false;;

  if (p2) {
    value = true;
  }

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

internal smallBoolt* setInt64SmallBool(smallBoolt* self, int64_t p2) {
  bool value = false;;

  if (p2) {
    value = true;
  }

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

internal smallBoolt* setInt32SmallBool(smallBoolt* self, int32_t p2) {
  bool value = false;;

  if (p2) {
    value = true;
  }

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

internal smallBoolt* setUint32SmallBool(smallBoolt* self, uint32_t p2) {
  bool value = false;;

  if (p2) {
    value = true;
  }

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

internal smallBoolt* setUint64SmallBool(smallBoolt* self, uint64_t p2) {
  bool value = false;;

  if (p2) {
    value = true;
  }

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

internal smallBoolt* setSSmallBool(smallBoolt* self, const char* p2) {
  bool value = false;;

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

  if (strEq(p2, "true") || strEq(p2, "TRUE")) {
    value = true;
  }

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

internal smallBoolt* setSmallBoolSmallBool(smallBoolt* self, smallBoolt* p2) {
  bool value = false;;

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

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

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

internal smallBoolt* setSmallDoubleSmallBool(smallBoolt* self, smallDoublet* p2) {
  bool value = false;;

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

  double r = p2->f->get(p2);
  if (r) {
    value = true;
  }

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

internal smallBoolt* setSmallIntSmallBool(smallBoolt* self, smallIntt* p2) {
  bool value = false;;

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

  int64_t r = p2->f->get(p2);
  if (r) {
    value = true;
  }

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

internal smallBoolt* setSmallJsonSmallBool(smallBoolt* 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(setSmallBool(self, getTopBoolO(p2)));
  }
  else if (eqS(type, "double")) {
    return(setDoubleSmallBool(self, getTopDoubleO(p2)));
  }
  else if (eqS(type, "int")) {
    return(setInt64SmallBool(self, getTopIntO(p2)));
  }
  else if (eqS(type, "string")) {
    return(setSSmallBool(self, getTopSO(p2)));
  }

  return(self);
}

internal smallBoolt* setSmallStringSmallBool(smallBoolt* self, smallStringt* p2) {
  bool value = false;;

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

  if (equalSO(p2, "true") || equalSO(p2, "TRUE")) {
    value = true;
  }

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

internal bool* getPSmallBool(smallBoolt *self) {

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

internal bool equalSmallBoolChar(smallBoolt* self, const char * p2) {

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

  if (strEq(p2, "true") || strEq(p2, "TRUE")) {
    return(self->value->value);
  }
  else if (strEq(p2, "false") || strEq(p2, "FALSE")) {
    return(!self->value->value);
  }
  return(false);
}

internal bool equalSmallBoolBase(smallBoolt* self, baset* p2) {

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

  char *s = toStringO(p2);

  if (strEq(s, "true") || strEq(s, "TRUE")) {
    free(s);
    return(self->value->value);
  }
  else if (strEq(s, "false") || strEq(s, "FALSE")) {
    free(s);
    return(!self->value->value);
  }
  free(s);
  return(false);
}

internal bool equalSmallBoolBool(smallBoolt* self, bool p2) {

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

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

internal bool equalSmallBoolDouble(smallBoolt* self, double p2) {

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

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

internal bool equalSmallBoolInt64(smallBoolt* self, int64_t p2) {

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

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

internal bool equalSmallBoolInt32(smallBoolt* self, int32_t p2) {

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

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

internal bool equalSmallBoolUint32(smallBoolt* self, uint32_t p2) {

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

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

internal bool equalSmallBoolUint64(smallBoolt* self, uint64_t p2) {

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

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

internal bool equalSmallBool(smallBoolt* self, smallBoolt* p2) {

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

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

internal bool equalSmallBoolSmallBytes(smallBoolt* self, smallBytest* p2) {

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

  if (equalSO(p2, "true") || equalSO(p2, "TRUE")) {
    return(self->value->value);
  }
  else if (equalSO(p2, "false") || equalSO(p2, "FALSE")) {
    return(!self->value->value);
  }
  return(false);
}

internal bool equalSmallBoolSmallDouble(smallBoolt* self, smallDoublet* p2) {

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

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

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

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

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

internal bool equalSmallBoolSmallJson(smallBoolt* self, smallJsont* p2) {

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

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

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

internal bool equalSmallBoolSmallString(smallBoolt* self, smallStringt* p2) {

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

  char *s = sStringGetTiny(p2->data);
  if (strEq(s, "true") || strEq(s, "TRUE")) {
    return(self->value->value);
  }
  else if (strEq(s, "false") || strEq(s, "FALSE")) {
    return(!self->value->value);
  }
  return(false);
}

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

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

  if (!self->value) {
    isError(self->value, allocSBool(false)) 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(bool) , f);
  fclose(f);

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

  return(self);
}

internal smallBoolt* readFileSmallJsonSmallBool(smallBoolt *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(readFileSmallBool(self, getTopSO(filePath)));
}

internal smallBoolt* readFileSmallStringSmallBool(smallBoolt *self, smallStringt *filePath) {

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

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

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

internal smallBoolt* readStreamSmallBool(smallBoolt *self, FILE *fp) {
  size_t readStatus;

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

  if (!self->value) {
    isError(self->value, allocSBool(false)) return(NULL);
  }

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

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

  return(self);
}

internal int writeFileSmallBool(smallBoolt *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(bool) , f);
  fclose(f);

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

  return(1);
}

internal int writeFileSmallJsonSmallBool(smallBoolt *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(writeFileSmallBool(self, getTopSO(filePath)));
}

internal int writeFileSmallStringSmallBool(smallBoolt *self, smallStringt *filePath) {

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

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

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

internal int writeStreamSmallBool(smallBoolt *self, FILE *fp) {
  size_t writeStatus;

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

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

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

  return(1);
}

internal int appendFileSmallBool(smallBoolt *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(bool) , f);
  fclose(f);

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

  return(1);
}

internal int appendFileSmallStringSmallBool(smallBoolt *self, smallStringt *filePath) {

  if (!filePath) {
    return(0);
  }
  // TODO check if filePath is really a smallString
  return(appendFileSmallBool(self, ssGet(filePath)));
}



smallBoolt* duplicateSmallBoolG (smallBoolt *self) {

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

void             freeSmallBoolG             (smallBoolt *self) {self->f->free(self);}

bool             getBoolSmallBoolG          (smallBoolt *self, bool retType UNUSED, int64_t index UNUSED) {

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

bool*            getBoolPSmallBoolG         (smallBoolt *self, bool* retType UNUSED, int64_t index UNUSED) {

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

smallBoolt* setSmallBoolG(smallBoolt* self, bool p2) {

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

smallBoolt* setDoubleSmallBoolG(smallBoolt* self, double p2) {

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

smallBoolt* setInt64SmallBoolG(smallBoolt* self, int64_t p2) {

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

smallBoolt* setInt32SmallBoolG(smallBoolt* self, int32_t p2) {

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

smallBoolt* setUint32SmallBoolG(smallBoolt* self, uint32_t p2) {

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

smallBoolt* setUint64SmallBoolG(smallBoolt* self, uint64_t p2) {

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

smallBoolt* setSSmallBoolG(smallBoolt* self, const char* p2) {

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

smallBoolt* setSmallBoolSmallBoolG(smallBoolt* self, smallBoolt* p2) {

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

smallBoolt* setSmallDoubleSmallBoolG(smallBoolt* self, smallDoublet* p2) {

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

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

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

smallBoolt* setSmallJsonSmallBoolG(smallBoolt* self, smallJsont* p2) {

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

smallBoolt* setSmallStringSmallBoolG(smallBoolt* self, smallStringt* p2) {

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


bool equalSmallBoolCharG(smallBoolt* self, const char * p2) {

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

bool equalSmallBoolBaseG(smallBoolt* self, baset* p2) {

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

bool equalSmallBoolBoolG(smallBoolt* self, bool p2) {

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

bool equalSmallBoolDoubleG(smallBoolt* self, double p2) {

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

bool equalSmallBoolInt64G(smallBoolt* self, int64_t p2) {

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

bool equalSmallBoolInt32G(smallBoolt* self, int32_t p2) {

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

bool equalSmallBoolUint32G(smallBoolt* self, uint32_t p2) {

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

bool equalSmallBoolUint64G(smallBoolt* self, uint64_t p2) {

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

bool equalSmallBoolFG(smallBoolt* self, smallBoolt* p2) {

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

bool equalSmallBoolSmallBytesG(smallBoolt* self, smallBytest* p2) {

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

bool equalSmallBoolSmallDoubleG(smallBoolt* self, smallDoublet* p2) {

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

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

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

bool equalSmallBoolSmallJsonG(smallBoolt* self, smallJsont* p2) {

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

bool equalSmallBoolSmallStringG(smallBoolt* self, smallStringt* p2) {

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

smallBoolt*  readFileSmallBoolG     (smallBoolt *self, const char *filePath) {

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

smallBoolt* readFileSmallJsonSmallBoolG(smallBoolt *self, smallJsont *filePath) {

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

smallBoolt* readFileSmallStringSmallBoolG(smallBoolt *self, smallStringt *filePath) {

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

smallBoolt* readStreamSmallBoolG         (smallBoolt *self, FILE *fp) {

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

int  writeFileSmallBoolG    (smallBoolt *self, const char *filePath) {

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

int writeFileSmallJsonSmallBoolG  (smallBoolt *self, smallJsont *filePath) {

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

int writeFileSmallStringSmallBoolG(smallBoolt *self, smallStringt *filePath) {

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

int writeStreamSmallBoolG         (smallBoolt *self, FILE *fp) {

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

int appendFileSmallBoolFG           (smallBoolt *self, const char *filePath) {

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

int appendFileSmallStringSmallBoolG(smallBoolt *self, smallStringt *filePath) {

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