strarray.c

/*
 *  Copyright (C) 2023 Swansea University
 *
 *  This file is part of the SELKIELogger suite of tools.
 *
 *  SELKIELogger is free software: you can redistribute it and/or modify it
 *  under the terms of the GNU General Public License as published by the Free
 *  Software Foundation, either version 3 of the License, or (at your option)
 *  any later version.
 *
 *  SELKIELogger is distributed in the hope that it will be useful, but WITHOUT
 *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 *  more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this SELKIELogger product.
 *  If not, see <http://www.gnu.org/licenses/>.
*/
 
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
 
#include "strarray.h"
 
strarray *sa_new(int entries) {
    strarray *newarray = calloc(1, sizeof(strarray));
    if (newarray == NULL) { return NULL; }
    if (!sa_init(newarray, entries)) {
        //LCOV_EXCL_START
        free(newarray);
        return NULL;
        //LCOV_EXCL_STOP
    }
    return newarray;
}
 
bool sa_init(strarray *dst, const int entries) {
    if (dst->entries) { sa_destroy(dst); }
    dst->entries = entries;
    dst->strings = calloc(entries, sizeof(string));
    if (dst->strings == NULL) { return false; }
    return true;
}
 
bool sa_copy(strarray *dst, const strarray *src) {
    if (dst == NULL || src == NULL) { return false; }
    sa_destroy(dst);
    dst->entries = src->entries;
    dst->strings = calloc(dst->entries, sizeof(string));
    if (dst->strings == NULL) {
        //LCOV_EXCL_START
        dst->entries = 0;
        return false;
        //LCOV_EXCL_STOP
    }
    bool success = true;
    for (int ix = 0; ix < dst->entries; ix++) {
        success &= str_copy(&(dst->strings[ix]), &(src->strings[ix]));
    }
    if (!success) {
        //LCOV_EXCL_START
        sa_destroy(dst);
        return false;
        //LCOV_EXCL_STOP
    }
    return true;
}
 
bool sa_move(strarray *dst, strarray *src) {
    if (dst == NULL || src == NULL) { return false; }
    sa_destroy(dst);
    dst->entries = src->entries;
    dst->strings = src->strings;
    src->strings = NULL;
    src->entries = 0;
    return true;
}
 
bool sa_set_entry(strarray *array, const int index, string *str) {
    if (array == NULL) { return false; }
 
    if (index >= array->entries) { return false; }
 
    return str_copy(&(array->strings[index]), str);
}
 
bool sa_create_entry(strarray *array, const int index, const size_t len, const char *src) {
    if (array == NULL) { return false; }
    if (index >= array->entries) { return false; }
 
    return str_update(&(array->strings[index]), len, src);
}
 
void sa_clear_entry(strarray *array, const int index) {
    if (array == NULL) { return; }
    if (index >= array->entries) { return; }
 
    str_destroy(&(array->strings[index]));
}
 
void sa_destroy(strarray *sa) {
    if (sa == NULL) { return; }
    if (sa->entries == 0) {
        // Why did we allocate a zero length array?
        if (sa->strings) {
            free(sa->strings);
            sa->strings = NULL;
        }
        return;
    }
    if (sa->strings == NULL) {
        // Bonus - we don't have an array here at all
        sa->entries = 0;
        return;
    }
 
    for (int ix = 0; ix < sa->entries; ix++) {
        str_destroy(&(sa->strings[ix]));
    }
    free(sa->strings);
    sa->strings = NULL;
    sa->entries = 0;
}
 
string *str_new(const size_t len, const char *ca) {
    string *ns = calloc(1, sizeof(string));
    if (ns == NULL) { return NULL; }
 
    if (len == 0) {
        ns->length = 0;
        ns->data = NULL;
        return ns;
    }
 
    ns->length = len;
    int alen = len;
    if (ca[len - 1] != 0) { alen++; }
    ns->data = malloc(alen);
    if (ns->data == NULL) {
        //LCOV_EXCL_START
        free(ns);
        return NULL;
        //LCOV_EXCL_STOP
    }
 
    strncpy(ns->data, ca, len);
    ns->data[alen - 1] = 0; // Force last byte to zero
    return ns;
}
 
bool str_copy(string *dst, const string *src) {
    str_destroy(dst);
    dst->length = src->length;
    dst->data = malloc(dst->length + 1);
    if (dst->data == NULL) {
        //LCOV_EXCL_START
        dst->length = 0;
        return false;
        //LCOV_EXCL_STOP
    }
    if (src->data == NULL) {
        dst->length = 0;
        free(dst->data);
        dst->data = NULL;
        return true; // Odd scenario, but still a valid string
    }
    strncpy(dst->data, src->data, dst->length);
    dst->data[dst->length] = 0;
    return true;
}
 
string *str_duplicate(const string *src) {
    return str_new(src->length, src->data);
}
 
bool str_update(string *str, const size_t len, const char *src) {
    str_destroy(str);
    if (len == 0 || src == NULL) {
        str->data = NULL;
        str->length = 0;
        return true;
    }
    size_t checklen = strnlen(src, len);
    str->length = checklen + 1;
    str->data = malloc(str->length);
    if (str->data == NULL) {
        //LCOV_EXCL_START
        str->length = 0;
        return false;
        //LCOV_EXCL_STOP
    }
    strncpy(str->data, src, checklen);
    str->data[str->length - 1] = 0;
    str->length = strlen(str->data);
    return true;
}
 
void str_destroy(string *str) {
    if (str == NULL) { return; }
    str->length = 0;
    if (str->data) { free(str->data); }
    str->data = NULL;
}