libsheepyCSmallBool.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

#include <stdbool.h>

// Class smallBool
typedef struct smallBool smallBoolt;

#define helpTextSmallBool "TODO smallBool help brief, class description /*, definitions,*/ methods, examples"

// for object inheriting smallBool, cast to smallBool to be able to use this class functions and generics
#define cBo(self) ( (smallBoolt*) self )

typedef void    (*freeSmallBoolFt)      (smallBoolt *self);
typedef void    (*terminateSmallBoolFt) (smallBoolt **self);
typedef char*   (*toStringSmallBoolFt)  (smallBoolt *self);
typedef smallBoolt* (*duplicateSmallBoolFt) (smallBoolt *self);

// smallBool functions
typedef void     (*smashSmallBoolFt)     (smallBoolt **self);

typedef void     (*finishSmallBoolFt)    (smallBoolt **self);

typedef const char* (*helpSmallBoolFt)   (smallBoolt *self);

typedef bool     (*getSmallBoolFt)       (smallBoolt *self);

typedef smallBoolt*     (*setSmallBoolFt)       (smallBoolt *self, bool value);

typedef smallBoolt*     (*setDoubleSmallBoolFt)     (smallBoolt* self, double p2);
typedef smallBoolt*     (*setInt64SmallBoolFt)      (smallBoolt* self, int64_t p2);
typedef smallBoolt*     (*setInt32SmallBoolFt)      (smallBoolt* self, int32_t p2);
typedef smallBoolt*     (*setUint32SmallBoolFt)     (smallBoolt* self, uint32_t p2);
typedef smallBoolt*     (*setUint64SmallBoolFt)     (smallBoolt* self, uint64_t p2);
typedef smallBoolt*     (*setSSmallBoolFt)          (smallBoolt* self, const char* p2);
typedef smallBoolt*     (*setSmallBoolSmallBoolFt)  (smallBoolt* self, smallBoolt* p2);
typedef smallBoolt*     (*setSmallDoubleSmallBoolFt)(smallBoolt* self, smallDoublet* p2);
typedef smallBoolt*     (*setSmallIntSmallBoolFt)   (smallBoolt* self, smallIntt* p2);
typedef smallBoolt*     (*setSmallJsonSmallBoolFt)  (smallBoolt* self, smallJsont* p2);
typedef smallBoolt*     (*setSmallStringSmallBoolFt)(smallBoolt* self, smallStringt* p2);

typedef bool*    (*getPSmallBoolFt)       (smallBoolt *self);

typedef bool (*equalSmallBoolCharFt)(smallBoolt* self, const char * p2);
typedef bool (*equalSmallBoolBaseFt)(smallBoolt* self, baset* p2);
typedef bool (*equalSmallBoolBoolFt)(smallBoolt* self, bool p2);
typedef bool (*equalSmallBoolDoubleFt)(smallBoolt* self, double p2);
typedef bool (*equalSmallBoolInt64Ft)(smallBoolt* self, int64_t p2);
typedef bool (*equalSmallBoolInt32Ft)(smallBoolt* self, int32_t p2);
typedef bool (*equalSmallBoolUint32Ft)(smallBoolt* self, uint32_t p2);
typedef bool (*equalSmallBoolUint64Ft)(smallBoolt* self, uint64_t p2);
typedef bool (*equalSmallBoolFt)(smallBoolt* self, smallBoolt* p2);
typedef bool (*equalSmallBoolSmallDoubleFt)(smallBoolt* self, smallDoublet* p2);
typedef bool (*equalSmallBoolSmallIntFt)(smallBoolt* self, smallIntt* p2);
typedef bool (*equalSmallBoolSmallJsonFt)(smallBoolt* self, smallJsont* p2);
typedef bool (*equalSmallBoolSmallStringFt)(smallBoolt* self, smallStringt* p2);
typedef bool (*equalSmallBoolSmallBytesFt)(smallBoolt* self, smallBytest* p2);

typedef smallBoolt* (*readFileSmallBoolFt)(smallBoolt *self, const char *filePath);
typedef smallBoolt* (*readFileSmallJsonSmallBoolFt)(smallBoolt *self, smallJsont *filePath);
typedef smallBoolt* (*readFileSmallStringSmallBoolFt)(smallBoolt *self, smallStringt *filePath);
typedef smallBoolt* (*readStreamSmallBoolFt)(smallBoolt *self, FILE *fp);

typedef int (*writeFileSmallBoolFt)           (smallBoolt *self, const char *filePath);
typedef int (*writeFileSmallJsonSmallBoolFt)  (smallBoolt *self, smallJsont *filePath);
typedef int (*writeFileSmallStringSmallBoolFt)(smallBoolt *self, smallStringt *filePath);
typedef int (*writeStreamSmallBoolFt)         (smallBoolt *self, FILE *fp);

typedef int (*appendFileSmallBoolFt)(smallBoolt *self, const char *filePath);
typedef int (*appendFileSmallStringSmallBoolFt)(smallBoolt *self, smallStringt *filePath);

#define SMALLBOOLFUNCTIONST \
  helpSmallBoolFt             help;\
  getSmallBoolFt              get;\
  setSmallBoolFt              set;\
  setDoubleSmallBoolFt        setDouble;\
  setInt64SmallBoolFt         setInt64;\
  setInt32SmallBoolFt         setInt32;\
  setUint32SmallBoolFt        setUint32;\
  setUint64SmallBoolFt        setUint64;\
  setSSmallBoolFt             setS;\
  setSmallBoolSmallBoolFt     setSmallBool;\
  setSmallDoubleSmallBoolFt   setSmallDouble;\
  setSmallIntSmallBoolFt      setSmallInt;\
  setSmallJsonSmallBoolFt     setSmallJson;\
  setSmallStringSmallBoolFt   setSmallString;\
  getPSmallBoolFt             getP;\
  equalSmallBoolCharFt        equalChar;\
  equalSmallBoolBaseFt        equalBase;\
  equalSmallBoolBoolFt        equalBool;\
  equalSmallBoolDoubleFt      equalDouble;\
  equalSmallBoolInt64Ft       equalInt64;\
  equalSmallBoolInt32Ft       equalInt32;\
  equalSmallBoolUint32Ft      equalUint32;\
  equalSmallBoolUint64Ft      equalUint64;\
  equalSmallBoolFt            equal;\
  equalSmallBoolSmallBytesFt  equalSmallBytes;\
  equalSmallBoolSmallDoubleFt equalSmallDouble;\
  equalSmallBoolSmallIntFt    equalSmallInt;\
  equalSmallBoolSmallJsonFt   equalSmallJson;\
  equalSmallBoolSmallStringFt equalSmallString;\
  readFileSmallBoolFt              readFile;\
  readFileSmallJsonSmallBoolFt     readFileSmallJson;\
  readFileSmallStringSmallBoolFt   readFileSmallString;\
  readStreamSmallBoolFt            readStream;\
  writeFileSmallBoolFt             writeFile;\
  writeFileSmallJsonSmallBoolFt    writeFileSmallJson;\
  writeFileSmallStringSmallBoolFt  writeFileSmallString;\
  writeStreamSmallBoolFt           writeStream;\
  appendFileSmallBoolFt            appendFile;\
  appendFileSmallStringSmallBoolFt appendFileSmallString

typedef struct {
  freeSmallBoolFt             free;
  terminateSmallBoolFt        terminate;
  toStringSmallBoolFt         toString;
  duplicateSmallBoolFt        duplicate;
  smashSmallBoolFt            smash;
  finishSmallBoolFt           finish;
  SMALLBOOLFUNCTIONST;
} smallBoolFunctionst;

struct smallBool {
  const char      *type;
  smallBoolFunctionst *f;

  sBoolt          *value;
};

// smallBool

#define createSmallBool(obj) ;smallBoolt obj; initiateSmallBool(&obj)
#define createAllocateSmallBool(obj) ;smallBoolt *obj; initiateAllocateSmallBool(&obj)

void initiateSmallBool(smallBoolt *self);
void initiateAllocateSmallBool(smallBoolt **self);
void finalizeRecycleSmallBool(void *arg UNUSED);
void finalizeSmallBool(void);

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

smallBoolt* allocSmallBool(bool value);

// terminate smallBoolt val when it is out of scope
void cleanUpSmallBoolTerminateG(smallBoolt **val);

// free smallBoolt local val when it is out of scope
void cleanUpSmallBoolFreeLocalG(smallBoolt *val);

// free smallBoolt val when it is out of scope
void cleanUpSmallBoolFreeG(smallBoolt **val);

// finish smallBoolt val when it is out of scope
void cleanUpSmallBoolFinishG(smallBoolt **val);

#define cleanSmallBoolP(name) smallBoolt *name CLEANUP(cleanUpSmallBoolTerminateG)

#define cleanAllocateSmallBool(obj) ;cleanSmallBoolP(obj); initiateAllocateSmallBool(&obj)

#define cleanSmallBool(name) smallBoolt name CLEANUP(cleanUpSmallBoolFreeLocalG); initiateSmallBool(&name)

#define cleanFreeSmallBool(name) smallBoolt *name CLEANUP(cleanUpSmallBoolFreeG)

#define cleanFinishSmallBoolP(name) smallBoolt *name CLEANUP(cleanUpSmallBoolFinishG)

smallBoolt* duplicateSmallBoolG (smallBoolt *self);

void    freeSmallBoolG      (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 equalSmallBoolSmallDoubleG(smallBoolt* self, smallDoublet* p2);
bool equalSmallBoolSmallIntG(smallBoolt* self, smallIntt* p2);
bool equalSmallBoolSmallJsonG(smallBoolt* self, smallJsont* p2);
bool equalSmallBoolSmallStringG(smallBoolt* self, smallStringt* p2);
bool equalSmallBoolSmallBytesG(smallBoolt* self, smallBytest* 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); //TODO remove F - oGMacros generates a macro making the compilation fail
int appendFileSmallStringSmallBoolG(smallBoolt *self, smallStringt *filePath);
// end class smallBool