libsheepyCSmallDouble.h

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.
#pragma once

// Class smallDouble
typedef struct smallDouble smallDoublet;

#define helpTextSmallDouble "TODO smallDouble help brief, class description /*, definitions,*/ methods, examples"

// for object inheriting smallDouble, cast to smallDouble to be able to use this class functions and generics
#define cDo(self) ( (smallDoublet*) self )

typedef void      (*freeSmallDoubleFt)      (smallDoublet *self);
typedef void      (*terminateSmallDoubleFt) (smallDoublet **self);
typedef char*     (*toStringSmallDoubleFt)  (smallDoublet *self);
typedef smallDoublet* (*duplicateSmallDoubleFt) (smallDoublet *self);

// smallDouble functions
typedef void     (*smashSmallDoubleFt)     (smallDoublet **self);

typedef void     (*finishSmallDoubleFt)    (smallDoublet **self);

typedef const char* (*helpSmallDoubleFt)   (smallDoublet *self);

typedef double   (*getSmallDoubleFt)       (smallDoublet *self);

typedef smallDoublet*     (*setSmallDoubleFt)       (smallDoublet *self, double value);

typedef smallDoublet* (*setBoolSmallDoubleFt)(smallDoublet* self, bool p2);
typedef smallDoublet* (*setSmallDoubleFt)(smallDoublet* self, double p2);
typedef smallDoublet* (*setInt64SmallDoubleFt)(smallDoublet* self, int64_t p2);
typedef smallDoublet* (*setInt32SmallDoubleFt)(smallDoublet* self, int32_t p2);
typedef smallDoublet* (*setUint32SmallDoubleFt)(smallDoublet* self, uint32_t p2);
typedef smallDoublet* (*setUint64SmallDoubleFt)(smallDoublet* self, uint64_t p2);
typedef smallDoublet* (*setSSmallDoubleFt)(smallDoublet* self, const char* p2);
typedef smallDoublet* (*setSmallBoolSmallDoubleFt)(smallDoublet* self, smallBoolt* p2);
typedef smallDoublet* (*setSmallDoubleSmallDoubleFt)(smallDoublet* self, smallDoublet* p2);
typedef smallDoublet* (*setSmallIntSmallDoubleFt)(smallDoublet* self, smallIntt* p2);
typedef smallDoublet* (*setSmallJsonSmallDoubleFt)(smallDoublet* self, smallJsont* p2);
typedef smallDoublet* (*setSmallStringSmallDoubleFt)(smallDoublet* self, smallStringt* p2);

typedef double*    (*getPSmallDoubleFt)       (smallDoublet *self);

typedef bool (*equalSmallDoubleChaFt)(smallDoublet* self, char p2);
typedef bool (*equalSmallDoubleCharFt)(smallDoublet* self, const char * p2);
typedef bool (*equalSmallDoubleBaseFt)(smallDoublet* self, baset* p2);
typedef bool (*equalSmallDoubleBoolFt)(smallDoublet* self, bool p2);
typedef bool (*equalSmallDoubleDoubleFt)(smallDoublet* self, double p2);
typedef bool (*equalSmallDoubleInt64Ft)(smallDoublet* self, int64_t p2);
typedef bool (*equalSmallDoubleInt32Ft)(smallDoublet* self, int32_t p2);
typedef bool (*equalSmallDoubleUint32Ft)(smallDoublet* self, uint32_t p2);
typedef bool (*equalSmallDoubleUint64Ft)(smallDoublet* self, uint64_t p2);
typedef bool (*equalSmallDoubleSmallBoolFt)(smallDoublet* self, smallBoolt* p2);
typedef bool (*equalSmallDoubleSmallBytesFt)(smallDoublet* self, smallBytest* p2);
typedef bool (*equalSmallDoubleFt)(smallDoublet* self, smallDoublet* p2);
typedef bool (*equalSmallDoubleSmallIntFt)(smallDoublet* self, smallIntt* p2);
typedef bool (*equalSmallDoubleSmallJsonFt)(smallDoublet* self, smallJsont* p2);
typedef bool (*equalSmallDoubleSmallStringFt)(smallDoublet* self, smallStringt* p2);

typedef smallDoublet* (*readFileSmallDoubleFt)(smallDoublet *self, const char *filePath);
typedef smallDoublet* (*readFileSmallJsonSmallDoubleFt)(smallDoublet *self, smallJsont *filePath);
typedef smallDoublet* (*readFileSmallStringSmallDoubleFt)(smallDoublet *self, smallStringt *filePath);
typedef smallDoublet* (*readStreamSmallDoubleFt)(smallDoublet *self, FILE *fp);

typedef int (*writeFileSmallDoubleFt)           (smallDoublet *self, const char *filePath);
typedef int (*writeFileSmallJsonSmallDoubleFt)  (smallDoublet *self, smallJsont *filePath);
typedef int (*writeFileSmallStringSmallDoubleFt)(smallDoublet *self, smallStringt *filePath);
typedef int (*writeStreamSmallDoubleFt)         (smallDoublet *self, FILE *fp);

typedef int (*appendFileSmallDoubleFt)(smallDoublet *self, const char *filePath);
typedef int (*appendFileSmallStringSmallDoubleFt)(smallDoublet *self, smallStringt *filePath);

#define SMALLDOUBLEFUNCTIONST \
  helpSmallDoubleFt             help;\
  getSmallDoubleFt              get;\
  setSmallDoubleFt              set;\
  setBoolSmallDoubleFt          setBool;\
  setInt64SmallDoubleFt         setInt64;\
  setInt32SmallDoubleFt         setInt32;\
  setUint32SmallDoubleFt        setUint32;\
  setUint64SmallDoubleFt        setUint64;\
  setSSmallDoubleFt             setS;\
  setSmallBoolSmallDoubleFt     setSmallBool;\
  setSmallDoubleSmallDoubleFt   setSmallDouble;\
  setSmallIntSmallDoubleFt      setSmallInt;\
  setSmallJsonSmallDoubleFt     setSmallJson;\
  setSmallStringSmallDoubleFt   setSmallString;\
  getPSmallDoubleFt             getP;\
  equalSmallDoubleChaFt         equalCha;\
  equalSmallDoubleCharFt        equalChar;\
  equalSmallDoubleBaseFt        equalBase;\
  equalSmallDoubleBoolFt        equalBool;\
  equalSmallDoubleDoubleFt      equalDouble;\
  equalSmallDoubleInt64Ft       equalInt64;\
  equalSmallDoubleInt32Ft       equalInt32;\
  equalSmallDoubleUint32Ft      equalUint32;\
  equalSmallDoubleUint64Ft      equalUint64;\
  equalSmallDoubleSmallBoolFt   equalSmallBool;\
  equalSmallDoubleSmallBytesFt  equalSmallBytes;\
  equalSmallDoubleFt            equal;\
  equalSmallDoubleSmallIntFt    equalSmallInt;\
  equalSmallDoubleSmallJsonFt   equalSmallJson;\
  equalSmallDoubleSmallStringFt equalSmallString;\
  readFileSmallDoubleFt              readFile;\
  readFileSmallJsonSmallDoubleFt     readFileSmallJson;\
  readFileSmallStringSmallDoubleFt   readFileSmallString;\
  readStreamSmallDoubleFt            readStream;\
  writeFileSmallDoubleFt             writeFile;\
  writeFileSmallJsonSmallDoubleFt    writeFileSmallJson;\
  writeFileSmallStringSmallDoubleFt  writeFileSmallString;\
  writeStreamSmallDoubleFt           writeStream;\
  appendFileSmallDoubleFt            appendFile;\
  appendFileSmallStringSmallDoubleFt appendFileSmallString

typedef struct {
  freeSmallDoubleFt             free;
  terminateSmallDoubleFt        terminate;
  toStringSmallDoubleFt         toString;
  duplicateSmallDoubleFt        duplicate;
  smashSmallDoubleFt            smash;
  finishSmallDoubleFt           finish;
  SMALLDOUBLEFUNCTIONST;
} smallDoubleFunctionst;

struct smallDouble {
  const char *type;
  smallDoubleFunctionst *f;

  sDoublet   *value;
};

// smallDouble

#define createSmallDouble(obj) ;smallDoublet obj; initiateSmallDouble(&obj)
#define createAllocateSmallDouble(obj) ;smallDoublet *obj; initiateAllocateSmallDouble(&obj)

void initiateSmallDouble(smallDoublet *self);
void initiateAllocateSmallDouble(smallDoublet **self);
void finalizeRecycleSmallDouble(void *arg UNUSED);
void finalizeSmallDouble(void);

// initialize class methods, call registerMethodsSmallDouble from classes inheriting this class
void registerMethodsSmallDouble(smallDoubleFunctionst *f);

smallDoublet* allocSmallDouble(double value);

// terminate smallDoublet val when it is out of scope
void cleanUpSmallDoubleTerminateG(smallDoublet **val);

// free smallDoublet local val when it is out of scope
void cleanUpSmallDoubleFreeLocalG(smallDoublet *val);

// free smallDoublet val when it is out of scope
void cleanUpSmallDoubleFreeG(smallDoublet **val);

// finish smallDoublet val when it is out of scope
void cleanUpSmallDoubleFinishG(smallDoublet **val);

#define cleanSmallDoubleP(name) smallDoublet *name CLEANUP(cleanUpSmallDoubleTerminateG)

#define cleanAllocateSmallDouble(obj) ;cleanSmallDoubleP(obj); initiateAllocateSmallDouble(&obj)

#define cleanSmallDouble(name) smallDoublet name CLEANUP(cleanUpSmallDoubleFreeLocalG); initiateSmallDouble(&name)

#define cleanFreeSmallDouble(name) smallDoublet *name CLEANUP(cleanUpSmallDoubleFreeG)

#define cleanFinishSmallDoubleP(name) smallDoublet *name CLEANUP(cleanUpSmallDoubleFinishG)

smallDoublet*      duplicateSmallDoubleG          (smallDoublet *self);

void               freeSmallDoubleG               (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); //TODO remove F - oGMacros generates a macro making the compilation fail
int appendFileSmallStringSmallDoubleG(smallDoublet *self, smallStringt *filePath);
// end class smallDouble