libsheepyCSmallContainer.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 smallContainer
typedef struct smallContainer smallContainert;

#define helpTextSmallContainer "TODO smallContainer help brief, class description /*, definitions,*/ methods, examples"

// for object inheriting smallContainer, cast to smallContainer to be able to use this class functions and generics
#define cCo(self) ( (smallContainert*) self )

typedef void             (*freeSmallContainerFt)                   (smallContainert *self);
typedef void             (*terminateSmallContainerFt)              (smallContainert **self);
typedef char*            (*toStringSmallContainerFt)               (smallContainert *self);
typedef smallContainert* (*duplicateSmallContainerFt)              (smallContainert *self);

typedef void             (*finishSmallContainerFt)                 (smallContainert **self);

typedef const char*      (*helpSmallContainerFt)                   (smallContainert *self);

// smallContainer functions
typedef void             (*dataFreeSmallContainerFt)               (void *data);

typedef smallContainert* (*setClassDataFreeSmallContainerFt)       (smallContainert *self, dataFreeSmallContainerFt free);

typedef smallContainert* (*setObjectDataFreeSmallContainerFt)      (smallContainert *self, dataFreeSmallContainerFt free);

typedef char*            (*dataToStringSmallContainerFt)           (void *data);

typedef smallContainert* (*setClassDataToStringSmallContainerFt)   (smallContainert *self, dataToStringSmallContainerFt toString);

typedef smallContainert* (*setObjectDataToStringSmallContainerFt)  (smallContainert *self, dataToStringSmallContainerFt toString);

typedef void*            (*dataDuplicateSmallContainerFt)          (void *data);

typedef smallContainert* (*setClassDataDuplicateSmallContainerFt)  (smallContainert *self, dataDuplicateSmallContainerFt duplicate);

typedef smallContainert* (*setObjectDataDuplicateSmallContainerFt) (smallContainert *self, dataDuplicateSmallContainerFt duplicate);

typedef void             (*smashSmallContainerFt)                  (smallContainert **self);

typedef void*            (*getSmallContainerFt)                    (smallContainert *self);

typedef smallContainert* (*setSmallContainerFt)                    (smallContainert *self, void *data);

#define SMALLCONTAINERFUNCTIONST \
  helpSmallContainerFt                   help;\
  dataFreeSmallContainerFt               dataFree;\
  setClassDataFreeSmallContainerFt       setClassDataFree;\
  setObjectDataFreeSmallContainerFt      setObjectDataFree;\
  dataToStringSmallContainerFt           dataToString;\
  setClassDataToStringSmallContainerFt   setClassDataToString;\
  setObjectDataToStringSmallContainerFt  setObjectDataToString;\
  dataDuplicateSmallContainerFt          dataDuplicate;\
  setClassDataDuplicateSmallContainerFt  setClassDataDuplicate;\
  setObjectDataDuplicateSmallContainerFt setObjectDataDuplicate;\
  getSmallContainerFt                    get;\
  setSmallContainerFt                    set

typedef struct {
  freeSmallContainerFt                   free;
  terminateSmallContainerFt              terminate;
  toStringSmallContainerFt               toString;
  duplicateSmallContainerFt              duplicate;
  smashSmallContainerFt                  smash;
  finishSmallContainerFt                 finish;
  SMALLCONTAINERFUNCTIONST;
} smallContainerFunctionst;

struct smallContainer {
  const char                    *type;
  smallContainerFunctionst      *f;

  sContainert                   *data;
  dataFreeSmallContainerFt      dataFree;
  dataToStringSmallContainerFt  dataToString;
  dataDuplicateSmallContainerFt dataDuplicate;
};

// smallContainer

#define createSmallContainer(obj) ;smallContainert obj; initiateSmallContainer(&obj)
#define createAllocateSmallContainer(obj) ;smallContainert *obj; initiateAllocateSmallContainer(&obj)

void initiateSmallContainer(smallContainert *self);
void initiateAllocateSmallContainer(smallContainert **self);
void finalizeRecycleSmallContainer(void *arg UNUSED);
void finalizeSmallContainer(void);

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

smallContainert* allocSmallContainer(void *data);

// terminate smallContainert val when it is out of scope
void cleanUpSmallContainerTerminateG(smallContainert **val);

// free smallContainert local val when it is out of scope
void cleanUpSmallContainerFreeLocalG(smallContainert *val);

// free smallContainert val when it is out of scope
void cleanUpSmallContainerFreeG(smallContainert **val);

// finish smallContainert val when it is out of scope
void cleanUpSmallContainerFinishG(smallContainert **val);

#define cleanSmallContainerP(name) smallContainert *name CLEANUP(cleanUpSmallContainerTerminateG)

#define cleanAllocateSmallContainer(obj) ;cleanSmallContainerP(obj); initiateAllocateSmallContainer(&obj)

#define cleanSmallContainer(name) smallContainert name CLEANUP(cleanUpSmallContainerFreeLocalG); initiateSmallContainer(&name)

#define cleanFreeSmallContainer(name) smallContainert *name CLEANUP(cleanUpSmallContainerFreeG)

#define cleanFinishSmallContainerP(name) smallContainert *name CLEANUP(cleanUpSmallContainerFinishG)

smallContainert* duplicateSmallContainerG              (smallContainert *self);

void  freeSmallContainerG(smallContainert *self);

void* getSmallContainerG(smallContainert *self, void* retType UNUSED, int64_t index UNUSED);

smallContainert* setSmallContainerG(smallContainert *self, void *data);

// end class smallContainer