Pool.c

Go to the documentation of this file.

/*
 * Copyright (c) All Rights Reserved
 * 2025 Oliver Dixon <od641@york.ac.uk>
 */
 
#include <assert.h>
#include <errno.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include "Pool.h"
#include "Product.h"
 
struct Pool
{
    unsigned int capacity; 
    unsigned int index; 
    float growth_factor; 
    struct Product **products; 
};
 
static void print_dashed_header(FILE *const buffer)
{
    static const unsigned int line_length = 4 + 3 + MAX_NAME_LENGTH + 3 + 11;
    for (unsigned int counter = 0; counter < line_length; ++counter)
        fputc('-', buffer);
 
    fputc('\n', buffer);
}
 
struct Pool *pool_create(const unsigned int initial_capacity, const float growth_factor)
{
    assert(growth_factor > 1.0f);
 
    struct Pool *pool = malloc(sizeof(struct Pool));
    if (pool == NULL)
        return NULL;
 
    pool->products = malloc(sizeof(struct Product *) * initial_capacity);
    if (pool->products == NULL) {
        pool_delete(&pool);
        return NULL;
    }
 
    pool->capacity = initial_capacity;
    pool->index = 0;
    pool->growth_factor = growth_factor;
 
    return pool;
}
 
void pool_delete(struct Pool **const this)
{
    const unsigned int product_count = (*this)->index;
    for (unsigned int product_idx = 0; product_idx < product_count; ++product_idx)
        product_delete(&(*this)->products[product_idx]);
 
    free((*this)->products);
    free(*this);
    *this = NULL;
}
 
bool pool_insert_element(struct Pool *const this, struct Product *const product)
{
    errno = 0;
 
    if (this->index >= this->capacity) {
        /*
         * The pool does not have sufficient capacity of accommodate another element. Try to increase it by the stated
         * growth factor. If the re-allocation fails, errno will be set. The responsibility for verification is on the
         * caller.
         */
        const unsigned int new_capacity = (unsigned int) ceilf(this->capacity * this->growth_factor);
 
        struct Product **new_products = realloc(this->products, sizeof(struct Product *) * new_capacity);
        if (new_products == NULL)
            return false;
 
        this->products = new_products;
        this->capacity = new_capacity;
    }
 
    this->products[this->index++] = product;
    return true;
}
 
int pool_serialise_report(const struct Pool *const this, FILE *const buffer)
{
    const unsigned int count = this->index;
    struct Product *sorted[count];
    int retcode = 0;
 
    // Create a new temporary array to store the sorted product pool elements.
    memcpy(sorted, this->products, sizeof(struct Product *) * count);
    qsort(sorted, count, sizeof(struct Product *), &product_ptr_compare);
 
    print_dashed_header(buffer);
    fprintf(buffer, "%-4s | %-" XSTR(MAX_NAME_LENGTH) "s | Stock Level\n", "ID", "Name");
    print_dashed_header(buffer);
 
    // Print the sorted elements.
    for (unsigned int product_idx = 0; product_idx < count; ++product_idx)
        if ((retcode = product_report_serialise(sorted[product_idx], buffer)) < 0)
            break;
 
    if (count > 0)
        print_dashed_header(buffer);
 
    fputc('\n', buffer);
    return retcode;
}
 
int pool_serialise_stock_file(const struct Pool *const this, FILE *const buffer)
{
    const unsigned int product_count = this->index;
    int retcode = 0;
 
    for (unsigned int product_idx = 0; product_idx < product_count; ++product_idx)
        if ((retcode = product_file_serialise(this->products[product_idx], buffer)) < 0)
            break;
 
    return retcode;
}
 
struct Product *pool_get_product_by_index(const struct Pool *const this, const unsigned int index)
{
    return index < this->index ? this->products[index] : NULL;
}