libsheepyCSmallContainer.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 "libsheepyCSmallContainer.h"
#include "libsheepyCSmallContainerInternal.h"

#define internal static

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

void initiateSmallContainer(smallContainert *self);
void registerMethodsSmallContainer(smallContainerFunctionst *f);
void initiateAllocateSmallContainer(smallContainert **self);
void finalizeRecycleSmallContainer(void *arg UNUSED);
void finalizeSmallContainer(void);
smallContainert* allocSmallContainer(void *data);
void cleanUpSmallContainerTerminateG(smallContainert **val);
void cleanUpSmallContainerFreeLocalG(smallContainert *val);
void cleanUpSmallContainerFreeG(smallContainert **val);
void cleanUpSmallContainerFinishG(smallContainert **val);
internal void freeSmallContainer(smallContainert *self);
internal void terminateSmallContainer(smallContainert **self);
#if (NFreeStackCheck)
internal void finishSmallContainer(smallContainert **self);
#else
internal void finishSmallContainer(smallContainert **self);
#endif
internal const char* helpSmallContainer(smallContainert UNUSED *self);
internal char* toStringSmallContainer(smallContainert *self);
internal smallContainert* duplicateSmallContainer(smallContainert *self);
internal smallContainert* setClassDataFreeSmallContainer(smallContainert *self, dataFreeSmallContainerFt free);
internal smallContainert* setObjectDataFreeSmallContainer(smallContainert *self, dataFreeSmallContainerFt free);
internal smallContainert* setClassDataToStringSmallContainer(smallContainert *self, dataToStringSmallContainerFt toString);
internal smallContainert* setObjectDataToStringSmallContainer(smallContainert *self, dataToStringSmallContainerFt toString);
internal smallContainert* setClassDataDuplicateSmallContainer(smallContainert *self, dataDuplicateSmallContainerFt duplicate);
internal smallContainert* setObjectDataDuplicateSmallContainer(smallContainert *self, dataDuplicateSmallContainerFt duplicate);
internal void smashSmallContainer(smallContainert **self);
internal void* getSmallContainer(smallContainert *self);
internal smallContainert* setSmallContainer(smallContainert *self, void *data);
smallContainert* duplicateSmallContainerG              (smallContainert *self);
void* getSmallContainerG(smallContainert *self, void* retType UNUSED, int64_t index UNUSED);
smallContainert* setSmallContainerG(smallContainert *self, void *data);

void initiateSmallContainer(smallContainert *self) {

  self->type = "smallContainer";
  if (!smallContainerF) {
    isError(smallContainerF, malloc(sizeof(smallContainerFunctionst))) {
      self->f = NULL;
      return;
    }
    registerMethodsSmallContainer(smallContainerF);
  }
  self->f             = smallContainerF;;

  self->data          = NULL;
  self->dataFree      = NULL;
  self->dataToString  = NULL;
  self->dataDuplicate = NULL;
}

void registerMethodsSmallContainer(smallContainerFunctionst *f) {

  f->free                   = freeSmallContainer;
  f->terminate              = terminateSmallContainer;
  f->finish                 = finishSmallContainer;
  f->toString               = toStringSmallContainer;
  f->duplicate              = duplicateSmallContainer;
  f->help                   = helpSmallContainer;
  f->dataFree               = NULL;
  f->setClassDataFree       = setClassDataFreeSmallContainer;
  f->setObjectDataFree      = setObjectDataFreeSmallContainer;
  f->dataToString           = NULL;
  f->setClassDataToString   = setClassDataToStringSmallContainer;
  f->setObjectDataToString  = setObjectDataToStringSmallContainer;
  f->dataDuplicate          = NULL;
  f->setClassDataDuplicate  = setClassDataDuplicateSmallContainer;
  f->setObjectDataDuplicate = setObjectDataDuplicateSmallContainer;
  f->smash                  = smashSmallContainer;
  f->get                    = getSmallContainer;
  f->set                    = setSmallContainer;
}

void initiateAllocateSmallContainer(smallContainert **self) {

  if (self) {
    #if (recycleContainers)
    initAllocateRecycle(smallContainert);
    #else
    isError(*self, malloc(sizeof(smallContainert)))
      return;
    #endif
    if (*self) {
      initiateSmallContainer(*self);
      if (!(*self)->f) {
        finishSmallContainer(self);
}
  }
    }
      }

void finalizeRecycleSmallContainer(void *arg UNUSED) {

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

void finalizeSmallContainer(void) {

  if (smallContainerF) {
    free(smallContainerF);
    smallContainerF = NULL;
  }
  finalizeRecycleSmallContainer(NULL);
}

smallContainert* allocSmallContainer(void *data) {
  smallContainert *r = NULL;

  initiateAllocateSmallContainer(&r);
  if (!r) {
    return(NULL);
  }
  r->data       = allocSContainer(data);
  return(r);
}

void cleanUpSmallContainerTerminateG(smallContainert **val) {

  terminateO(*val);
}

void cleanUpSmallContainerFreeLocalG(smallContainert *val) {

  freeO(val);
}

void cleanUpSmallContainerFreeG(smallContainert **val) {

  freeO(*val);
}

void cleanUpSmallContainerFinishG(smallContainert **val) {

  finishO(*val);
}

internal void freeSmallContainer(smallContainert *self) {

  if (self->data) {
    // free with sContainert free function
    if (self->data->free) {
      self->data->free(self->data->data);
    }
    else if (self->dataFree) {
      self->dataFree(self->data->data);
    }
    else if (self->f->dataFree) {
      self->f->dataFree(self->data->data);
    }
    free(self->data);
    self->data = NULL;
  }
  return;
}

internal void terminateSmallContainer(smallContainert **self) {

  freeSmallContainer(*self);
  finishSmallContainer(self);
}

#if (NFreeStackCheck)
internal void finishSmallContainer(smallContainert **self) {

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

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

#endif
// #if NFreeStackCheck

internal const char* helpSmallContainer(smallContainert UNUSED *self) {

  return(helpTextSmallContainer);
}


internal char* toStringSmallContainer(smallContainert *self) {

  if (!self->data) {
    return(NULL);
  }
  if (self->dataToString) {
    return(self->dataToString(self->data->data));
  }
  if (self->f->dataToString) {
    return(self->f->dataToString(self->data->data));
  }
  return(strdup("<data smallContainer>"));
}

internal smallContainert* duplicateSmallContainer(smallContainert *self) {

  createAllocateSmallContainer(dup);
  if (!dup) {
    return(NULL);
  }
  if (self->data) {
    isError(dup->data, allocSContainer(NULL)) return(NULL);
    if (self->dataDuplicate) {
      dup->data->data = self->dataDuplicate(self->data->data);
    }
    else if (self->f->dataDuplicate) {
      dup->data->data = self->f->dataDuplicate(self->data->data);
    }
    dup->data->free = self->data->free;
  }
  dup->dataFree      = self->dataFree;
  dup->dataToString  = self->dataToString;
  dup->dataDuplicate = self->dataDuplicate;
  return(dup);
}

internal smallContainert* setClassDataFreeSmallContainer(smallContainert *self, dataFreeSmallContainerFt free) {

  self->f->dataFree = free;
  if (self->data) {
    self->data->free = (freeSContainerFt)free;;
  }
  return(self);
}

internal smallContainert* setObjectDataFreeSmallContainer(smallContainert *self, dataFreeSmallContainerFt free) {

  self->dataFree = free;
  if (self->data) {
    self->data->free = (freeSContainerFt)free;;
  }
  return(self);
}

internal smallContainert* setClassDataToStringSmallContainer(smallContainert *self, dataToStringSmallContainerFt toString) {

  self->f->dataToString = toString;
  return(self);
}

internal smallContainert* setObjectDataToStringSmallContainer(smallContainert *self, dataToStringSmallContainerFt toString) {

  self->dataToString = toString;
  return(self);
}

internal smallContainert* setClassDataDuplicateSmallContainer(smallContainert *self, dataDuplicateSmallContainerFt duplicate) {

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

internal smallContainert* setObjectDataDuplicateSmallContainer(smallContainert *self, dataDuplicateSmallContainerFt duplicate) {

  self->dataDuplicate = duplicate;
  return(self);
}

internal void smashSmallContainer(smallContainert **self) {

  if ((*self)->data) {
    free((*self)->data);
  }
  finishSmallContainer(self);
}

internal void* getSmallContainer(smallContainert *self) {

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

internal smallContainert* setSmallContainer(smallContainert *self, void *data) {

  if (!self->data) {
    isError(self->data, allocSContainer(data)) return(NULL);
    if (self->f->dataFree) {
      // set free function from class
      self->data->free = (freeSContainerFt)self->f->dataFree;
  }
    }
  else {
    self->data->data = data;
  }
  return(self);
}

smallContainert* duplicateSmallContainerG              (smallContainert *self) {

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

void  freeSmallContainerG(smallContainert *self) {self->f->free(self);}

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

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

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

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