libsheepyCSmallBytes.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 smallBytes
typedef struct smallBytes smallBytest;

#define helpTextSmallBytes "TODO smallBytes help brief, class description /*, definitions,*/ methods, examples"

// for object inheriting smallBytes, cast to smallBytes to be able to use this class functions and generics
#define cBy(self) ( (smallBytest*) self )

typedef void            (*freeSmallBytesFt)      (smallBytest *self);
typedef void            (*terminateSmallBytesFt) (smallBytest **self);
typedef char*           (*toStringSmallBytesFt)  (smallBytest *self);
typedef smallBytest*    (*duplicateSmallBytesFt) (smallBytest *self);

typedef void            (*finishSmallBytesFt)(smallBytest **self);

typedef const char*     (*helpSmallBytesFt)   (smallBytest *self);

typedef void*           (*getSmallBytesFt) (smallBytest *self);

typedef smallBytest*    (*setSmallBytesFt) (smallBytest *self, void *data, uint32_t size);

typedef smallBytest*    (*pushSmallBytesFt) (smallBytest *self, char data);

typedef smallBytest*    (*pushBufferSmallBytesFt) (smallBytest *self, void *data, uint32_t size);

typedef char            (*getAtSmallBytesFt) (smallBytest *self, int64_t index);

typedef size_t          (*lenSmallBytesFt) (smallBytest *self);

typedef bool            (*isEmptySmallBytesFt)(smallBytest *self);

typedef smallBytest* (*readFileSmallBytesFt)(smallBytest *self, const char *filePath);
typedef smallBytest* (*readFileSmallJsonSmallBytesFt)(smallBytest *self, smallJsont *filePath);
typedef smallBytest* (*readFileSmallStringSmallBytesFt)(smallBytest *self, smallStringt *filePath);
typedef smallBytest* (*readStreamSmallBytesFt)(smallBytest *self, FILE *fp);

typedef int (*writeFileSmallBytesFt)(smallBytest *self, const char *filePath);
typedef int (*writeFileSmallJsonSmallBytesFt)(smallBytest *self, smallJsont *filePath);
typedef int (*writeFileSmallStringSmallBytesFt)(smallBytest *self, smallStringt *filePath);
typedef int (*writeStreamSmallBytesFt)(smallBytest *self, FILE *fp);

typedef int (*appendFileSmallBytesFt)(smallBytest *self, const char *filePath);
typedef int (*appendFileSmallStringSmallBytesFt)(smallBytest *self, smallStringt *filePath);

typedef bool (*equalSmallBytesFt)(smallBytest *self, smallBytest *value);
typedef bool (*equalSmallBytesBoolFt)(smallBytest *self, bool value);
typedef bool (*equalSmallBytesDoubleFt)(smallBytest *self, double value);
typedef bool (*equalSmallBytesInt64Ft)(smallBytest *self, int64_t value);
typedef bool (*equalSmallBytesInt32Ft)(smallBytest *self, int32_t value);
typedef bool (*equalSmallBytesUint32Ft)(smallBytest *self, uint32_t value);
typedef bool (*equalSmallBytesUint64Ft)(smallBytest *self, uint64_t value);
typedef bool (*equalSmallBytesSmallBoolFt)(smallBytest *self, smallBoolt *value);
typedef bool (*equalSmallBytesSmallDoubleFt)(smallBytest *self, smallDoublet *value);
typedef bool (*equalSmallBytesSmallIntFt)(smallBytest *self, smallIntt *value);
typedef bool (*equalSmallBytesCharFt)(smallBytest *self, const char *value);
typedef bool (*equalSmallBytesSmallStringFt)(smallBytest *self, smallStringt *value);
typedef bool (*equalSmallBytesBaseFt)(smallBytest *self, baset *value);

/* *
 * class functions
 * allocated once for all objects
 *
 * freed with finalizeSmallBytes or finalizeLibsheepy
 */

#define SMALLBYTESFUNCTIONST \
  helpSmallBytesFt       help;\
  getSmallBytesFt        get;\
  setSmallBytesFt        set;\
  pushSmallBytesFt       push;\
  pushBufferSmallBytesFt pushBuffer;\
  getAtSmallBytesFt      getAt;\
  /*setAt*/\
  lenSmallBytesFt        len;\
  isEmptySmallBytesFt    isEmpty;\
  readFileSmallBytesFt   readFile;\
  readFileSmallJsonSmallBytesFt   readFileSmallJson;\
  readFileSmallStringSmallBytesFt readFileSmallString;\
  readStreamSmallBytesFt readStream;\
  writeFileSmallBytesFt  writeFile;\
  writeFileSmallJsonSmallBytesFt writeFileSmallJson;\
  writeFileSmallStringSmallBytesFt writeFileSmallString;\
  writeStreamSmallBytesFt writeStream;\
  appendFileSmallBytesFt  appendFile;\
  appendFileSmallStringSmallBytesFt appendFileSmallString;\
  equalSmallBytesFt            equal;\
  equalSmallBytesBoolFt        equalBool;\
  equalSmallBytesDoubleFt      equalDouble;\
  equalSmallBytesInt64Ft       equalInt64;\
  equalSmallBytesInt32Ft       equalInt32;\
  equalSmallBytesUint32Ft      equalUint32;\
  equalSmallBytesUint64Ft      equalUint64;\
  equalSmallBytesSmallBoolFt   equalSmallBool;\
  equalSmallBytesSmallDoubleFt equalSmallDouble;\
  equalSmallBytesSmallIntFt    equalSmallInt;\
  equalSmallBytesCharFt        equalS;\
  equalSmallBytesSmallStringFt equalSmallString;\
  equalSmallBytesBaseFt  equalBase

 typedef struct {
  freeSmallBytesFt       free;
  terminateSmallBytesFt  terminate;
  toStringSmallBytesFt   toString;
  duplicateSmallBytesFt  duplicate;
  finishSmallBytesFt     smash;
  finishSmallBytesFt     finish;
  SMALLBYTESFUNCTIONST;
} smallBytesFunctionst;

struct smallBytes {
  const char           *type;
  smallBytesFunctionst *f;

  // internal
  sBytest *B;
};

// smallBytes

#define createSmallBytes(obj) ;smallBytest obj; initiateSmallBytes(&obj)
#define createAllocateSmallBytes(obj) ;smallBytest *obj; initiateAllocateSmallBytes(&obj)

void initiateSmallBytes(smallBytest *self);
void initiateAllocateSmallBytes(smallBytest **self);
void finalizeRecycleSmallBytes(void *arg UNUSED);
void finalizeSmallBytes(void);

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

smallBytest* allocSmallBytes(void *data, uint32_t size);

// terminate smallBytest val when it is out of scope
void cleanUpSmallBytesTerminateG(smallBytest **val);

// free smallBytest val declared locally in a code block when it is out of scope
void cleanUpSmallBytesFreeLocalG(smallBytest *val);

// free smallBytest val when it is out of scope
void cleanUpSmallBytesFreeG(smallBytest **val);

// finish smallBytest val when it is out of scope
void cleanUpSmallBytesFinishG(smallBytest **val);

#define cleanSmallBytesP(name) smallBytest *name CLEANUP(cleanUpSmallBytesTerminateG)

#define cleanAllocateSmallBytes(obj) ;cleanSmallBytesP(obj); initiateAllocateSmallBytes(&obj)

#define cleanSmallBytes(name) smallBytest name CLEANUP(cleanUpSmallBytesFreeLocalG); initiateSmallBytes(&name)

#define cleanFreeSmallBytes(name) smallBytest *name CLEANUP(cleanUpSmallBytesFreeG)

#define cleanFinishSmallBytesP(name) smallBytest *name CLEANUP(cleanUpSmallBytesFinishG)

smallBytest* duplicateSmallBytesG (smallBytest *self);

void            freeSmallBytesG      (smallBytest *self);

smallBytest* setSmallBytesG(smallBytest *self, void *data, uint32_t size);
char getAtSmallBytesG(smallBytest *self, char retType UNUSED, int64_t index);
smallBytest* pushSmallBytesG (smallBytest *self, char data);
size_t lenSmallBytesG(smallBytest *self);
bool isEmptySmallBytesG(smallBytest *self);
smallBytest* readFileSmallJsonSmallBytesG(smallBytest *self, smallJsont *filePath);
smallBytest* readFileSmallStringSmallBytesG(smallBytest *self, smallStringt *filePath);
smallBytest* readFileSmallBytesG(smallBytest *self, const char *filePath);
smallBytest* readStreamSmallBytesG(smallBytest *self, FILE *fp);
int writeFileSmallBytesG(smallBytest *self, const char *filePath);
int writeFileSmallJsonSmallBytesG(smallBytest *self, smallJsont *filePath);
int writeFileSmallStringSmallBytesG(smallBytest *self, smallStringt *filePath);
int writeStreamSmallBytesG(smallBytest *self, FILE *fp);
int appendFileSmallBytesG(smallBytest *self, const char *filePath);
int appendFileSmallStringSmallBytesG(smallBytest *self, smallStringt *filePath);
bool equalSmallBytesG(smallBytest *self, smallBytest *value);
bool equalSmallBytesBoolG(smallBytest *self, bool value);
bool equalSmallBytesDoubleG(smallBytest *self, double value);
bool equalSmallBytesInt64G(smallBytest *self, int64_t value);
bool equalSmallBytesInt32G(smallBytest *self, int32_t value);
bool equalSmallBytesUint32G(smallBytest *self, uint32_t value);
bool equalSmallBytesUint64G(smallBytest *self, uint64_t value);
bool equalSmallBytesSmallBoolG(smallBytest *self, smallBoolt *value);
bool equalSmallBytesSmallDoubleG(smallBytest *self, smallDoublet *value);
bool equalSmallBytesSmallIntG(smallBytest *self, smallIntt *value);
bool equalSmallBytesCharG(smallBytest *self, const char *value);
bool equalSmallBytesSmallStringG(smallBytest *self, smallStringt *value);
bool equalSmallBytesBaseG(smallBytest *self, baset *value);

// end class smallBytes