path: root/hw4/l4basic/l4strv.c

/* vim: set sw=4 ts=4 sts=4 et: */

#include "l4strv.h"

#include <stdarg.h>
#include <stdlib.h>
#include <string.h>

LbsStrv* lbs_strv_new_with_max (size_t max) {
    LbsStrv* strv = xmalloc (sizeof (LbsStrv));
    if (strv == NULL) {
        return NULL;
    }

    if (lbs_array_init_with_max (&strv->array, sizeof (LbsArray), max) < 0) {
        free (strv);
        return NULL;
    }

    strv->ref_count = 1;
    strv->is_alloc = true;
    return strv;
}

int lbs_strv_init_with_max (LbsStrv* strv, size_t max) {
    if (lbs_array_init_with_max (&strv->array, sizeof (LbsArray), max) < 0) {
        return -1;
    }

    strv->ref_count = 1;
    strv->is_alloc = false;
    return 0;
}

void* lbs_strv_ref_generic (void* strv_generic) {
    LbsStrv* strv = LBS_STRV (strv_generic);
    strv->ref_count++;
    return strv;
}

void lbs_strv_unref_generic (void* strv_generic) {
    if (strv_generic == NULL) {
        return;
    }
    LbsStrv* strv = LBS_STRV (strv_generic);
    strv->ref_count--;
    if (strv->ref_count <= 0) {
        lbs_strv_free (strv);
    }
}

void lbs_strv_free_generic (void* strv_generic) {
    if (strv_generic == NULL) {
        return;
    }
    LbsStrv* strv = LBS_STRV (strv_generic);
    size_t i = 0;
    for (; i < lbs_strv_get_len (strv); i++) {
        LbsArray* str_wrapper = lbs_strv_get_str_wrapper (strv, i);
        lbs_array_unref (str_wrapper);
    }
    lbs_array_unref (&strv->array);
    if (strv->is_alloc) {
        free (strv);
    }
}

char* lbs_strv_dup_str (LbsStrv* strv, size_t stri) {
    LbsArray* str_wrapper = lbs_strv_get_str_wrapper (strv, stri);
    size_t len = lbs_array_get_len (str_wrapper);
    char* str = lbs_array_get_data (str_wrapper);

    char* str_new = xmalloc (len + sizeof (char));
    strncpy (str_new, str, len);
    str_new[len] = '\0';

    return str_new;
}

int lbs_strv_append_char (LbsStrv* strv, size_t stri, char chr) {
    if (chr == '\0') {
        return -1;
    }

    if (stri >= lbs_strv_get_len (strv)) {
        stri = lbs_strv_get_len (strv);
        LbsArray str_struct;
        LbsArray* str = &str_struct;
        if (lbs_array_init (str, sizeof (char)) < 0) {
            return -1;
        }
        if (lbs_array_append_data (&strv->array, str) < 0) {
            lbs_array_unref (str);
            return -1;
        }
    }
    LbsArray* str = lbs_strv_get_str_wrapper (strv, stri);
    return lbs_array_append_data (str, &chr);
}

int lbs_strv_append_str_empty (LbsStrv* strv) {
    LbsArray str_struct, *str = &str_struct;
    if (lbs_array_init (str, sizeof (char)) < 0) {
        return -1;
    }
    if (lbs_array_append_data (&strv->array, &str_struct) < 0) {
        lbs_array_unref (str);
        return -1;
    }
    return 0;
}

int lbs_strv_append_str (LbsStrv* strv, const char* bstr) {
    if (bstr == NULL) {
        return -1;
    }

    size_t len = strlen (bstr);
    char* str_copy = xmalloc (sizeof (char) * len);
    if (str_copy == NULL) {
        return -1;
    }
    strncpy (str_copy, bstr, len);

    LbsArray str_struct, *str = &str_struct;
    if (lbs_array_make_struct (str, sizeof (char), len, len, str_copy) == NULL)
    {
        free (str_copy);
        return -1;
    }

    if (lbs_array_append_data (&strv->array, &str_struct) < 0) {
        lbs_array_unref (str);
        free (str_copy);
        return -1;
    }

    return 0;
}

int lbs_strv_append_strv (LbsStrv* strv, const char* const* bstrv) {
    if (bstrv == NULL) {
        return -1;
    }

    int i;
    for (i = 0; bstrv[i] != NULL; i++) {
        if (lbs_strv_append_str (strv, bstrv[i]) < 0) {
            return -1;
        }
    }
    return 0;
}

int lbs_strv_remove_str (LbsStrv* strv) {
    size_t len = lbs_strv_get_len (strv);
    if (len <= 0) {
        return -1;
    }

    lbs_array_unref (lbs_strv_get_str_wrapper (strv, len - 1));
    return lbs_array_remove (&strv->array);
}

int lbs_strv_minimize (LbsStrv* strv) {
    if (lbs_array_minimize (&strv->array) < 0) {
        return -1;
    }

    size_t i;
    size_t len = lbs_strv_get_len (strv);
    for (i = 0; i < len; i++) {
        LbsArray* str = lbs_strv_get_str_wrapper (strv, i);
        if (lbs_array_minimize (str) < 0) {
            return -1;
        }
    }

    return 0;
}

char** lbs_strv_copy_strv (LbsStrv* strv) {
    size_t len = lbs_strv_get_len (strv);
    char** bstrv = xmalloc (sizeof (char*) * (len + 1));
    if (bstrv == NULL) {
        return NULL;
    }

    size_t i;
    for (i = 0; i < len; i++) {
        LbsArray* str = lbs_strv_get_str_wrapper (strv, i);
        size_t str_len = lbs_array_get_len (str);
        char* bstr = xmalloc (sizeof (char) * (str_len + 1));

        strncpy (bstr, lbs_array_get_data (str), str_len);
        bstr[str_len] = '\0';
        bstrv[i] = bstr;
    }
    bstrv[len] = NULL;
    return bstrv;
}

char** lbs_strv_drop_struct (LbsStrv* strv) {
    char** bstrv = lbs_strv_copy_strv (strv);
    if (bstrv == NULL) {
        return NULL;
    }

    lbs_strv_free (strv);
    return bstrv;
}

char** lbs_strv_generic_build (const char* str_first, ...) {
    LbsArray bstrv_w_struct, *bstrv_w = &bstrv_w_struct;
    va_list ap;
    char* str;
    char* str_copy;
    size_t str_len;

    if (lbs_array_init (bstrv_w, sizeof (void*)) < 0) {
        return NULL;
    }

    va_start (ap, str_first);

    str_len = strlen (str_first);
    str_copy = xmalloc (sizeof (char) * (str_len + 1));
    if (str_copy == NULL) {
        lbs_array_unref (bstrv_w);
        va_end (ap);
        return NULL;
    }
    strcpy (str_copy, str_first);

    if (lbs_array_append_ptr (bstrv_w, str_copy) < 0) {
        free (str_copy);
        lbs_array_unref (bstrv_w);
        va_end (ap);
        return NULL;
    }


    while ((str = va_arg (ap, char*)) != NULL) {
        str_len = strlen (str);
        str_copy = xmalloc (sizeof (char) * (str_len + 1));
        if (str_copy == NULL) {
            lbs_array_unref (bstrv_w);
            va_end (ap);
            return NULL;
        }
        strcpy (str_copy, str);

        if (lbs_array_append_ptr (bstrv_w, str_copy) < 0) {
            free (str_copy);
            lbs_array_unref (bstrv_w);
            va_end (ap);
            return NULL;
        }
    }
    if (lbs_array_append_ptr (bstrv_w, NULL) < 0) {
        lbs_array_unref (bstrv_w);
        va_end (ap);
        return NULL;
    }

    va_end (ap);

    return lbs_array_drop_struct (bstrv_w);
}

int lbs_strv_generic_cmp (
    const char* const* bstrv1, const char* const* bstrv2) {
    int i;
    for (i = 0; bstrv1[i] != NULL && bstrv2[i] != NULL; i++) {
        int r = strcmp (bstrv1[i], bstrv2[i]);
        if (r != 0) {
            return r;
        }
    }

    if (bstrv1[i] != NULL) {
        return 1;
    }
    if (bstrv2[i] != NULL) {
        return -1;
    }

    return 0;
}

void lbs_strv_generic_free (char** bstrv) {
    int i;
    for (i = 0; bstrv[i] != NULL; i++) {
        free (bstrv[i]);
    }
    free (bstrv);
}