libsheepyCSmallDouble.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 "libsheepyCSmallDouble.h"
#include "libsheepyCSmallDoubleInternal.h"

#define internal static

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

void initiateSmallDouble(smallDoublet *self);
void registerMethodsSmallDouble(smallDoubleFunctionst *f);
void initiateAllocateSmallDouble(smallDoublet **self);
void finalizeRecycleSmallDouble(void *arg UNUSED);
void finalizeSmallDouble(void);
smallDoublet* allocSmallDouble(double value);
void cleanUpSmallDoubleTerminateG(smallDoublet **val);
void cleanUpSmallDoubleFreeLocalG(smallDoublet *val);
void cleanUpSmallDoubleFreeG(smallDoublet **val);
void cleanUpSmallDoubleFinishG(smallDoublet **val);
internal void freeSmallDouble(smallDoublet *self);
internal void terminateSmallDouble(smallDoublet **self);
internal char* toStringSmallDouble(smallDoublet *self);
internal smallDoublet* duplicateSmallDouble(smallDoublet *self);
internal void  smashSmallDouble(smallDoublet **self);
#if (NFreeStackCheck)
internal void finishSmallDouble(smallDoublet **self);
#else
internal void finishSmallDouble(smallDoublet **self);
#endif
internal const char* helpSmallDouble(smallDoublet UNUSED *self);
internal double  getSmallDouble(smallDoublet *self);
internal smallDoublet*  setSmallDouble(smallDoublet *self, double value);
internal smallDoublet* setBoolSmallDouble(smallDoublet* self, bool p2);
internal smallDoublet* setInt64SmallDouble(smallDoublet* self, int64_t p2);
internal smallDoublet* setInt32SmallDouble(smallDoublet* self, int32_t p2);
internal smallDoublet* setUint32SmallDouble(smallDoublet* self, uint32_t p2);
internal smallDoublet* setUint64SmallDouble(smallDoublet* self, uint64_t p2);
internal smallDoublet* setSSmallDouble(smallDoublet* self, const char* p2);
internal smallDoublet* setSmallBoolSmallDouble(smallDoublet* self, smallBoolt* p2);
internal smallDoublet* setSmallDoubleSmallDouble(smallDoublet* self, smallDoublet* p2);
internal smallDoublet* setSmallIntSmallDouble(smallDoublet* self, smallIntt* p2);
internal smallDoublet* setSmallJsonSmallDouble(smallDoublet* self, smallJsont* p2);
internal smallDoublet* setSmallStringSmallDouble(smallDoublet* self, smallStringt* p2);
internal double* getPSmallDouble(smallDoublet *self);
internal bool equalSmallDoubleCha(smallDoublet* self, char p2);
internal bool equalSmallDoubleChar(smallDoublet* self, const char * p2);
internal bool equalSmallDoubleBase(smallDoublet* self, baset* p2);
internal bool equalSmallDoubleBool(smallDoublet* self, bool p2);
internal bool equalSmallDoubleDouble(smallDoublet* self, double p2);
internal bool equalSmallDoubleInt64(smallDoublet* self, int64_t p2);
internal bool equalSmallDoubleInt32(smallDoublet* self, int32_t p2);
internal bool equalSmallDoubleUint32(smallDoublet* self, uint32_t p2);
internal bool equalSmallDoubleUint64(smallDoublet* self, uint64_t p2);
internal bool equalSmallDoubleSmallBool(smallDoublet* self, smallBoolt* p2);
internal bool equalSmallDoubleSmallBytes(smallDoublet* self, smallBytest* p2);
internal bool equalSmallDouble(smallDoublet* self, smallDoublet* p2);
internal bool equalSmallDoubleSmallInt(smallDoublet* self, smallIntt* p2);
internal bool equalSmallDoubleSmallJson(smallDoublet* self, smallJsont* p2);
internal bool equalSmallDoubleSmallString(smallDoublet* self, smallStringt* p2);
internal smallDoublet* readFileSmallDouble(smallDoublet *self, const char *filePath);
internal smallDoublet* readFileSmallJsonSmallDouble(smallDoublet *self, smallJsont *filePath);
internal smallDoublet* readFileSmallStringSmallDouble(smallDoublet *self, smallStringt *filePath);
internal smallDoublet* readStreamSmallDouble(smallDoublet *self, FILE *fp);
internal int writeFileSmallDouble(smallDoublet *self, const char *filePath);
internal int writeFileSmallJsonSmallDouble(smallDoublet *self, smallJsont *filePath);
internal int writeFileSmallStringSmallDouble(smallDoublet *self, smallStringt *filePath);
internal int writeStreamSmallDouble(smallDoublet *self, FILE *fp);
internal int appendFileSmallDouble(smallDoublet *self, const char *filePath);
internal int appendFileSmallStringSmallDouble(smallDoublet *self, smallStringt *filePath);
smallDoublet*      duplicateSmallDoubleG          (smallDoublet *self);
double             getDoubleSmallDoubleG          (smallDoublet *self, double retType UNUSED, int64_t index UNUSED);
smallDoublet* setBoolSmallDoubleG(smallDoublet* self, bool p2);
smallDoublet* setSmallDoubleG(smallDoublet* self, double p2);
smallDoublet* setInt64SmallDoubleG(smallDoublet* self, int64_t p2);
smallDoublet* setInt32SmallDoubleG(smallDoublet* self, int32_t p2);
smallDoublet* setUint32SmallDoubleG(smallDoublet* self, uint32_t p2);
smallDoublet* setUint64SmallDoubleG(smallDoublet* self, uint64_t p2);
smallDoublet* setSSmallDoubleG(smallDoublet* self, const char* p2);
smallDoublet* setSmallBoolSmallDoubleG(smallDoublet* self, smallBoolt* p2);
smallDoublet* setSmallDoubleSmallDoubleG(smallDoublet* self, smallDoublet* p2);
smallDoublet* setSmallIntSmallDoubleG(smallDoublet* self, smallIntt* p2);
smallDoublet* setSmallJsonSmallDoubleG(smallDoublet* self, smallJsont* p2);
smallDoublet* setSmallStringSmallDoubleG(smallDoublet* self, smallStringt* p2);
double*            getDoublePSmallDoubleG         (smallDoublet *self, double* retType UNUSED, int64_t index UNUSED);
bool equalSmallDoubleChaG(smallDoublet* self, char p2);
bool equalSmallDoubleCharG(smallDoublet* self, const char * p2);
bool equalSmallDoubleBaseG(smallDoublet* self, baset* p2);
bool equalSmallDoubleBoolG(smallDoublet* self, bool p2);
bool equalSmallDoubleDoubleG(smallDoublet* self, double p2);
bool equalSmallDoubleInt64G(smallDoublet* self, int64_t p2);
bool equalSmallDoubleInt32G(smallDoublet* self, int32_t p2);
bool equalSmallDoubleUint32G(smallDoublet* self, uint32_t p2);
bool equalSmallDoubleUint64G(smallDoublet* self, uint64_t p2);
bool equalSmallDoubleSmallBoolG(smallDoublet* self, smallBoolt* p2);
bool equalSmallDoubleSmallBytesG(smallDoublet* self, smallBytest* p2);
bool equalSmallDoubleFG(smallDoublet* self, smallDoublet* p2);
bool equalSmallDoubleSmallIntG(smallDoublet* self, smallIntt* p2);
bool equalSmallDoubleSmallJsonG(smallDoublet* self, smallJsont* p2);
bool equalSmallDoubleSmallStringG(smallDoublet* self, smallStringt* p2);
smallDoublet*  readFileSmallDoubleG     (smallDoublet *self, const char *filePath);
smallDoublet* readFileSmallJsonSmallDoubleG  (smallDoublet *self, smallJsont *filePath);
smallDoublet* readFileSmallStringSmallDoubleG(smallDoublet *self, smallStringt *filePath);
smallDoublet* readStreamSmallDoubleG         (smallDoublet *self, FILE *fp);
int  writeFileSmallDoubleG    (smallDoublet *self, const char *filePath);
int writeFileSmallJsonSmallDoubleG  (smallDoublet *self, smallJsont *filePath);
int writeFileSmallStringSmallDoubleG(smallDoublet *self, smallStringt *filePath);
int writeStreamSmallDoubleG         (smallDoublet *self, FILE *fp);
int appendFileSmallDoubleFG           (smallDoublet *self, const char *filePath);
int appendFileSmallStringSmallDoubleG(smallDoublet *self, smallStringt *filePath);

void initiateSmallDouble(smallDoublet *self) {

  self->type = "smallDouble";
  if (!smallDoubleF) {
    isError(smallDoubleF, malloc(sizeof(smallDoubleFunctionst))) {
      self->f = NULL;
      return;
    }
    registerMethodsSmallDouble(smallDoubleF);
  }
  self->f     = smallDoubleF;;

  self->value = NULL;
}

void registerMethodsSmallDouble(smallDoubleFunctionst *f) {

  f->free                  = freeSmallDouble;
  f->terminate             = terminateSmallDouble;
  f->toString              = toStringSmallDouble;
  f->duplicate             = duplicateSmallDouble;
  f->smash                 = smashSmallDouble;
  f->finish                = finishSmallDouble;
  f->help                  = helpSmallDouble;
  f->get                   = getSmallDouble;
  f->set                   = setSmallDouble;
  f->setBool               = setBoolSmallDouble;
  f->setInt64              = setInt64SmallDouble;
  f->setInt32              = setInt32SmallDouble;
  f->setUint32             = setUint32SmallDouble;
  f->setUint64             = setUint64SmallDouble;
  f->setS                  = setSSmallDouble;
  f->setSmallBool          = setSmallBoolSmallDouble;
  f->setSmallDouble        = setSmallDoubleSmallDouble;
  f->setSmallInt           = setSmallIntSmallDouble;
  f->setSmallJson          = setSmallJsonSmallDouble;
  f->setSmallString        = setSmallStringSmallDouble;
  f->getP                  = getPSmallDouble;
  f->equalCha              = equalSmallDoubleCha;
  f->equalChar             = equalSmallDoubleChar;
  f->equalBase             = equalSmallDoubleBase;
  f->equalBool             = equalSmallDoubleBool;
  f->equalDouble           = equalSmallDoubleDouble;
  f->equalInt64            = equalSmallDoubleInt64;
  f->equalInt32            = equalSmallDoubleInt32;
  f->equalUint32           = equalSmallDoubleUint32;
  f->equalUint64           = equalSmallDoubleUint64;
  f->equalSmallBool        = equalSmallDoubleSmallBool;
  f->equalSmallBytes       = equalSmallDoubleSmallBytes;
  f->equal                 = equalSmallDouble;
  f->equalSmallInt         = equalSmallDoubleSmallInt;
  f->equalSmallJson        = equalSmallDoubleSmallJson;
  f->equalSmallString      = equalSmallDoubleSmallString;
  f->readFile              = readFileSmallDouble;
  f->readFileSmallJson     = readFileSmallJsonSmallDouble;
  f->readFileSmallString   = readFileSmallStringSmallDouble;
  f->readStream            = readStreamSmallDouble;
  f->writeFile             = writeFileSmallDouble;
  f->writeFileSmallJson    = writeFileSmallJsonSmallDouble;
  f->writeFileSmallString  = writeFileSmallStringSmallDouble;
  f->writeStream           = writeStreamSmallDouble;
  f->appendFile            = appendFileSmallDouble;
  f->appendFileSmallString = appendFileSmallStringSmallDouble;
}

void initiateAllocateSmallDouble(smallDoublet **self) {

  if (self) {
    #if (recycleContainers)
    initAllocateRecycle(smallDoublet);
    #else
    isError(*self, malloc(sizeof(smallDoublet)))
      return;
    #endif
    if (*self) {
      initiateSmallDouble(*self);
      if (!(*self)->f) {
        finishSmallDouble(self);
}
  }
    }
      }

void finalizeRecycleSmallDouble(void *arg UNUSED) {

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

void finalizeSmallDouble(void) {

  if (smallDoubleF) {
    free(smallDoubleF);
    smallDoubleF = NULL;
  }
  finalizeRecycleSmallDouble(NULL);
}

smallDoublet* allocSmallDouble(double value) {
  smallDoublet *r = NULL;

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

void cleanUpSmallDoubleTerminateG(smallDoublet **val) {

  terminateO(*val);
}

void cleanUpSmallDoubleFreeLocalG(smallDoublet *val) {

  freeO(val);
}

void cleanUpSmallDoubleFreeG(smallDoublet **val) {

  freeO(*val);
}

void cleanUpSmallDoubleFinishG(smallDoublet **val) {

  finishO(*val);
}

internal void freeSmallDouble(smallDoublet *self) {

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

internal void terminateSmallDouble(smallDoublet **self) {

  freeSmallDouble(*self);
  finishSmallDouble(self);
}


internal char* toStringSmallDouble(smallDoublet *self) {
  char *s = NULL;

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

  return(s);
}

internal smallDoublet* duplicateSmallDouble(smallDoublet *self) {

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

internal void  smashSmallDouble(smallDoublet **self) {

  finishSmallDouble(self);
}

#if (NFreeStackCheck)
internal void finishSmallDouble(smallDoublet **self) {

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

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

#endif
// #if NFreeStackCheck

internal const char* helpSmallDouble(smallDoublet UNUSED *self) {

  return(helpTextSmallDouble);
}

internal double  getSmallDouble(smallDoublet *self) {

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

internal smallDoublet*  setSmallDouble(smallDoublet *self, double value) {

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

internal smallDoublet* setBoolSmallDouble(smallDoublet* self, bool p2) {

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

internal smallDoublet* setInt64SmallDouble(smallDoublet* self, int64_t p2) {

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

internal smallDoublet* setInt32SmallDouble(smallDoublet* self, int32_t p2) {

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

internal smallDoublet* setUint32SmallDouble(smallDoublet* self, uint32_t p2) {

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

internal smallDoublet* setUint64SmallDouble(smallDoublet* self, uint64_t p2) {

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

internal smallDoublet* setSSmallDouble(smallDoublet* self, const char* p2) {

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

internal smallDoublet* setSmallBoolSmallDouble(smallDoublet* self, smallBoolt* p2) {
  bool value;

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

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

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

internal smallDoublet* setSmallDoubleSmallDouble(smallDoublet* self, smallDoublet* p2) {

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

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

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

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

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

internal smallDoublet* setSmallJsonSmallDouble(smallDoublet* 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(setBoolSmallDouble(self, getTopBoolO(p2)));
  }
  else if (eqS(type, "double")) {
    return(setSmallDouble(self, getTopDoubleO(p2)));
  }
  else if (eqS(type, "int")) {
    return(setInt64SmallDouble(self, getTopIntO(p2)));
  }
  else if (eqS(type, "string")) {
    return(setSSmallDouble(self, getTopSO(p2)));
  }
  return(NULL);
}


internal smallDoublet* setSmallStringSmallDouble(smallDoublet* self, smallStringt* p2) {

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

internal double* getPSmallDouble(smallDoublet *self) {

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

internal bool equalSmallDoubleCha(smallDoublet* self, char p2) {

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

  charToS(s, p2);

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

  double value = parseDouble(s);

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

internal bool equalSmallDoubleChar(smallDoublet* self, const char * p2) {

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

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

  double value = parseDouble(p2);

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

internal bool equalSmallDoubleBase(smallDoublet* self, baset* p2) {

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

  char *s = toStringO(p2);

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

  double value = parseDouble(s);

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

  free(s);
  return(r);
}

internal bool equalSmallDoubleBool(smallDoublet* self, bool p2) {

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

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

internal bool equalSmallDoubleDouble(smallDoublet* self, double p2) {

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

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

internal bool equalSmallDoubleInt64(smallDoublet* self, int64_t p2) {

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

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

internal bool equalSmallDoubleInt32(smallDoublet* self, int32_t p2) {

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

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

internal bool equalSmallDoubleUint32(smallDoublet* self, uint32_t p2) {

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

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

internal bool equalSmallDoubleUint64(smallDoublet* self, uint64_t p2) {

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

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

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

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

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

internal bool equalSmallDoubleSmallBytes(smallDoublet* 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) || !isNumber(s)) {
    return(false);
  }

  double p2Value = parseDouble(s);

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


internal bool equalSmallDouble(smallDoublet* self, smallDoublet* p2) {

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

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

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

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

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

internal bool equalSmallDoubleSmallJson(smallDoublet* self, smallJsont* p2) {

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

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

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

internal bool equalSmallDoubleSmallString(smallDoublet* self, smallStringt* p2) {

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

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

  double value = parseDoubleO(p2);

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

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

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

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

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

  return(self);
}

internal smallDoublet* readFileSmallJsonSmallDouble(smallDoublet *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(readFileSmallDouble(self, getTopSO(filePath)));
}

internal smallDoublet* readFileSmallStringSmallDouble(smallDoublet *self, smallStringt *filePath) {

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

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

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

internal smallDoublet* readStreamSmallDouble(smallDoublet *self, FILE *fp) {
  size_t readStatus;

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

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

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

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

  return(self);
}

internal int writeFileSmallDouble(smallDoublet *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(double) , f);
  fclose(f);

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

  return(1);
}

internal int writeFileSmallJsonSmallDouble(smallDoublet *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(writeFileSmallDouble(self, getTopSO(filePath)));
}

internal int writeFileSmallStringSmallDouble(smallDoublet *self, smallStringt *filePath) {

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

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

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

internal int writeStreamSmallDouble(smallDoublet *self, FILE *fp) {
  size_t writeStatus;

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

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

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

  return(1);
}

internal int appendFileSmallDouble(smallDoublet *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(double) , f);
  fclose(f);

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

  return(1);
}

internal int appendFileSmallStringSmallDouble(smallDoublet *self, smallStringt *filePath) {

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



smallDoublet*      duplicateSmallDoubleG          (smallDoublet *self) {

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

void               freeSmallDoubleG               (smallDoublet *self) {self->f->free(self);}

double             getDoubleSmallDoubleG          (smallDoublet *self, double retType UNUSED, int64_t index UNUSED) {

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

smallDoublet* setBoolSmallDoubleG(smallDoublet* self, bool p2) {

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

smallDoublet* setSmallDoubleG(smallDoublet* self, double p2) {

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

smallDoublet* setInt64SmallDoubleG(smallDoublet* self, int64_t p2) {

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

smallDoublet* setInt32SmallDoubleG(smallDoublet* self, int32_t p2) {

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

smallDoublet* setUint32SmallDoubleG(smallDoublet* self, uint32_t p2) {

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

smallDoublet* setUint64SmallDoubleG(smallDoublet* self, uint64_t p2) {

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

smallDoublet* setSSmallDoubleG(smallDoublet* self, const char* p2) {

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

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

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

smallDoublet* setSmallDoubleSmallDoubleG(smallDoublet* self, smallDoublet* p2) {

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

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

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

smallDoublet* setSmallJsonSmallDoubleG(smallDoublet* self, smallJsont* p2) {

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

smallDoublet* setSmallStringSmallDoubleG(smallDoublet* self, smallStringt* p2) {

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


double*            getDoublePSmallDoubleG         (smallDoublet *self, double* retType UNUSED, int64_t index UNUSED) {

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

bool equalSmallDoubleChaG(smallDoublet* self, char p2) {

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

bool equalSmallDoubleCharG(smallDoublet* self, const char * p2) {

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

bool equalSmallDoubleBaseG(smallDoublet* self, baset* p2) {

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

bool equalSmallDoubleBoolG(smallDoublet* self, bool p2) {

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

bool equalSmallDoubleDoubleG(smallDoublet* self, double p2) {

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

bool equalSmallDoubleInt64G(smallDoublet* self, int64_t p2) {

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

bool equalSmallDoubleInt32G(smallDoublet* self, int32_t p2) {

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

bool equalSmallDoubleUint32G(smallDoublet* self, uint32_t p2) {

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

bool equalSmallDoubleUint64G(smallDoublet* self, uint64_t p2) {

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

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

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

bool equalSmallDoubleSmallBytesG(smallDoublet* self, smallBytest* p2) {

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

bool equalSmallDoubleFG(smallDoublet* self, smallDoublet* p2) {

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

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

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

bool equalSmallDoubleSmallJsonG(smallDoublet* self, smallJsont* p2) {

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

bool equalSmallDoubleSmallStringG(smallDoublet* self, smallStringt* p2) {

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

smallDoublet*  readFileSmallDoubleG     (smallDoublet *self, const char *filePath) {

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

smallDoublet* readFileSmallJsonSmallDoubleG  (smallDoublet *self, smallJsont *filePath) {

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

smallDoublet* readFileSmallStringSmallDoubleG(smallDoublet *self, smallStringt *filePath) {

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

smallDoublet* readStreamSmallDoubleG         (smallDoublet *self, FILE *fp) {

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

int  writeFileSmallDoubleG    (smallDoublet *self, const char *filePath) {

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

int writeFileSmallJsonSmallDoubleG  (smallDoublet *self, smallJsont *filePath) {

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

int writeFileSmallStringSmallDoubleG(smallDoublet *self, smallStringt *filePath) {

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

int writeStreamSmallDoubleG         (smallDoublet *self, FILE *fp) {

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

int appendFileSmallDoubleFG           (smallDoublet *self, const char *filePath) {

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

int appendFileSmallStringSmallDoubleG(smallDoublet *self, smallStringt *filePath) {

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