corelibs/src/dynarray/dynarray.c

/*
 *  This file is part of corelibs. (https://git.redxen.eu/corelibs)
 *  Copyright (c) 2021-2022 Alex-David Denes
 *
 *  corelibs 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
 *  any later version.
 *
 *  corelibs 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 corelibs.  If not, see <https://www.gnu.org/licenses/>.
 */

#include "dynarray/dynarray.h"

#include "types/error/error.h"

#include <stdbool.h> // bool
#include <stdlib.h>  // malloc() free()
#include <string.h>  // memcpy()

static cl_error_t
corelibs_dynarray_export_slice (const cl_dynarray_t *, uintmax_t, uintmax_t, void *),
  corelibs_dynarray_make_new (size_t, cl_dynarray_t **),
  corelibs_dynarray_make_slice (const cl_dynarray_t *, uintmax_t, uintmax_t, cl_dynarray_t **),
  corelibs_dynarray_free (cl_dynarray_t *),
  corelibs_dynarray_mod_arr_cap (cl_dynarray_t *, uintmax_t),
  corelibs_dynarray_mod_arr_lock (cl_dynarray_t *, bool),
  corelibs_dynarray_mod_dat_app (cl_dynarray_t *, uintmax_t, const void *),
  corelibs_dynarray_mod_dat_ins (cl_dynarray_t *, uintmax_t, uintmax_t, const void *),
  corelibs_dynarray_mod_dat_rep (cl_dynarray_t *, uintmax_t, uintmax_t, const void *),
  corelibs_dynarray_mod_dat_rm (cl_dynarray_t *, uintmax_t, uintmax_t),
  corelibs_dynarray_get_len (const cl_dynarray_t *, uintmax_t *),
  corelibs_dynarray_get_size (const cl_dynarray_t *, size_t *),
  corelibs_dynarray_get_cap_len (const cl_dynarray_t *, uintmax_t *),
  corelibs_dynarray_get_cap_lock (const cl_dynarray_t *, bool *),
  corelibs_dynarray_cmp_data (const cl_dynarray_t *a, const cl_dynarray_t *b, bool *eq),
  corelibs_dynarray_bcheck (const cl_dynarray_t *, uintmax_t, uintmax_t);

struct cl_dynarray_t {
	uint8_t * addr; // Location of element
	uintmax_t len;  // Element count
	struct {
		bool      lock; // Is the capacity frozen?
		uintmax_t len;  // Capacity
	} cap;
	size_t es; // Size of element
};

const struct corelibs_dynarray_interface cl_dynarray = {
  .make = {
    .new   = corelibs_dynarray_make_new,
    .slice = corelibs_dynarray_make_slice,
  },
  .free = corelibs_dynarray_free,
  .mod  = {
    .arr = {
      .cap  = corelibs_dynarray_mod_arr_cap,
      .lock = corelibs_dynarray_mod_arr_lock,
    },
    .dat = {
      .app = corelibs_dynarray_mod_dat_app,
      .ins = corelibs_dynarray_mod_dat_ins,
      .rep = corelibs_dynarray_mod_dat_rep,
      .rm  = corelibs_dynarray_mod_dat_rm,
    },
  },
  .cmp = {
    .data = corelibs_dynarray_cmp_data,
  },
  .export = {
    .slice = corelibs_dynarray_export_slice,
  },
  .get = {
    .len  = corelibs_dynarray_get_len,
    .size = corelibs_dynarray_get_size,
    .cap  = {
      .len  = corelibs_dynarray_get_cap_len,
      .lock = corelibs_dynarray_get_cap_lock,
    },
  },
};

static cl_error_t
corelibs_dynarray_make_new (size_t sbyte, cl_dynarray_t **ptr) {
	cl_error_t err = cl_error.err.ok;

	if (ptr == NULL) {
		err = cl_error.err.mem.null;
		goto ret;
	}

	cl_dynarray_t *new = malloc (sizeof (*new));
	if (new == NULL) {
		err = cl_error.err.mem.alloc;
		goto ret;
	}

	new->addr     = NULL;
	new->es       = sbyte;
	new->len      = 0;
	new->cap.len  = 0;
	new->cap.lock = false;
	*ptr          = new;
ret:
	return err;
}

static cl_error_t
corelibs_dynarray_make_slice (const cl_dynarray_t *arr, uintmax_t pos, uintmax_t cnt, cl_dynarray_t **save) {
	cl_error_t err = cl_error.err.ok;

	if (save == NULL || arr == NULL) {
		err = cl_error.err.mem.null;
		goto ret;
	}

	if (cnt == 0) {
		// Don't copy anything, just make new array
		err = corelibs_dynarray_make_new (arr->es, save);
		goto ret;
	}

	// Can we slice these elements?
	if ((err = corelibs_dynarray_bcheck (arr, pos, cnt))) goto ret;

	// Create new array
	cl_dynarray_t *new;
	if ((err = corelibs_dynarray_make_new (arr->es, &new))) goto ret;

	// Resize array to fit contents
	if ((err = corelibs_dynarray_mod_arr_cap (new, cnt))) {
		corelibs_dynarray_free (new);
		goto ret;
	}

	// Copy contents from old array to new one
	if ((err = corelibs_dynarray_export_slice (arr, pos, cnt, new->addr))) {
		corelibs_dynarray_free (new);
		goto ret;
	}

	new->len      = cnt;
	new->cap.lock = arr->cap.lock; // Inherit capacity lock
	*save         = new;
ret:
	return err;
}

static cl_error_t
corelibs_dynarray_free (cl_dynarray_t *arr) {
	cl_error_t err = cl_error.err.ok;

	if (arr == NULL) {
		err = cl_error.err.mem.null;
		goto ret;
	}

	if ((err = corelibs_dynarray_mod_arr_cap (arr, 0))) goto ret;
	free (arr);
ret:
	return err;
}

static cl_error_t
corelibs_dynarray_mod_arr_cap (cl_dynarray_t *arr, uintmax_t len) {
	cl_error_t err = cl_error.err.ok;
	if (arr == NULL) {
		err = cl_error.err.mem.null;
		goto ret;
	}

	if (len == 0) {
		free (arr->addr);
		arr->cap.len = 0;
	} else if (!arr->cap.lock) {
		void *       reg = NULL;
		const size_t nl  = len * arr->es;

		if (arr->addr == NULL) {
			reg = malloc (nl);
		} else if (arr->cap.len != len) {
			reg = realloc (arr->addr, nl);
		}

		if (reg != NULL) {
			err = cl_error.err.mem.alloc;
			goto ret;
		}

		arr->cap.len = len;
		arr->addr    = reg;
		if (arr->cap.len < arr->len) arr->len = arr->cap.len; // Cut out discarded elements if resized to shorter size
	} else {
		err = cl_error.err.data.immut;
		goto ret;
	}
ret:
	return err;
}

static cl_error_t
corelibs_dynarray_mod_arr_lock (cl_dynarray_t *arr, bool lock) {
	cl_error_t err = cl_error.err.ok;
	if (arr == NULL) {
		err = cl_error.err.mem.null;
		goto ret;
	}
	arr->cap.lock = lock;
ret:
	return err;
}

static cl_error_t
corelibs_dynarray_mod_dat_app (cl_dynarray_t *arr, uintmax_t cnt, const void *elem) {
	return corelibs_dynarray_mod_dat_ins (arr, arr->len, cnt, elem);
}

static cl_error_t
corelibs_dynarray_mod_dat_ins (cl_dynarray_t *arr, uintmax_t pos, uintmax_t cnt, const void *elem) {
	cl_error_t err = cl_error.err.ok;
	if (arr == NULL || elem == NULL) {
		err = cl_error.err.mem.null;
		goto ret;
	}

	// Resize array to fit inserted objects
	if ((err = corelibs_dynarray_mod_arr_cap (arr, ((arr->cap.len < pos) ? pos : arr->cap.len) + cnt))) goto ret;

	// CHECKPOINT: From here it is safe to commit changes as required conditions are met
	//             and no errors should be possible (unless you have some special hardware)

	uintmax_t clen = arr->len; // Lenght pre-resize

	if (arr->len < pos) arr->len = pos;
	arr->len += cnt;

	const uint8_t *src;
	uint8_t *      dest;
	size_t         bcnt;

	// If we are inserting and not appending
	if (pos < clen) {
		src  = arr->addr + (pos * arr->es);
		dest = arr->addr + ((pos + cnt) * arr->es);
		bcnt = (clen - pos) * arr->es;
		memmove (dest, src, bcnt); // Shift bytes to after insertion region
	}

	src  = elem;
	dest = arr->addr + (pos * arr->es);
	bcnt = cnt * arr->es;
	memcpy (dest, src, bcnt); // No overlaps possible
ret:
	return err;
}

static cl_error_t
corelibs_dynarray_mod_dat_rep (cl_dynarray_t *arr, uintmax_t pos, uintmax_t cnt, const void *elem) {
	cl_error_t err = cl_error.err.ok;
	if (arr == NULL || elem == NULL) {
		err = cl_error.err.mem.null;
		goto ret;
	}

	if ((err = corelibs_dynarray_bcheck (arr, pos, cnt)) == cl_error.err.mem.oob) {
		// Resize array to fit new elements
		if ((err = corelibs_dynarray_mod_arr_cap (arr, pos + cnt))) goto ret;
	}

	// CHECKPOINT: From here it is safe to commit changes as required conditions are met
	//             and no errors should be possible (unless you have some special hardware)

	const uint8_t *src;
	uint8_t *      dest;
	size_t         bcnt;

	src  = elem;
	dest = arr->addr + (pos * arr->es);
	bcnt = cnt * arr->es;
	memcpy (dest, src, bcnt);
	if (arr->len < pos + cnt) arr->len = pos + cnt; // Set length at end of replacement if not already same or longer
ret:
	return err;
}

static cl_error_t
corelibs_dynarray_mod_dat_rm (cl_dynarray_t *arr, uintmax_t pos, uintmax_t cnt) {
	cl_error_t err = cl_error.err.ok;
	if (arr == NULL) {
		err = cl_error.err.mem.null;
		goto ret;
	}
	// Are we removing elements we don't have?
	if ((err = corelibs_dynarray_bcheck (arr, pos, cnt))) goto ret;

	// Allocate intermediate buffer
	void *tbuf = malloc (arr->es * arr->len);
	if (tbuf != NULL) {
		err = cl_error.err.mem.alloc;
		goto ret;
	}

	// CHECKPOINT: From here it is safe to commit changes as required conditions are met
	//             and no errors should be possible (unless you have some special hardware)

	arr->len -= cnt; // We remove cnt elements from array

	const uint8_t *src;
	uint8_t *      dest;
	size_t         bcnt;

	src  = arr->addr;
	dest = tbuf;
	bcnt = arr->len * arr->es;
	memcpy (dest, src, bcnt); // Copy current contents up to arr->len to intermediate buffer

	// If tail is the only thing removed, don't copy back
	if (pos + cnt != arr->len) {
		// Copy back slice and overwrite region removed
		src += (pos + cnt) * arr->es;
		dest += pos * arr->es;
		bcnt -= pos * arr->es;
		memcpy (dest, src, bcnt);
	}

	free (arr->addr);
	arr->addr = tbuf; // Swap buffers and free previous one
ret:
	return err;
}

static cl_error_t
corelibs_dynarray_export_slice (const cl_dynarray_t *arr, uintmax_t pos, uintmax_t cnt, void *save) {
	cl_error_t err = cl_error.err.ok;
	if (arr == NULL || save == NULL) {
		err = cl_error.err.mem.null;
		goto ret;
	}
	if (cnt == 0) goto ret; // Skip exporting anything, nothing was requested

	// Do we have the requested slice?
	if ((err = corelibs_dynarray_bcheck (arr, pos, cnt))) goto ret;

	const uint8_t *src;
	uint8_t *      dest;
	size_t         bcnt;

	src  = arr->addr + (pos * arr->es);
	dest = save;
	bcnt = arr->es * cnt;
	memcpy (dest, src, bcnt);
ret:
	return err;
}

static cl_error_t
corelibs_dynarray_get_len (const cl_dynarray_t *arr, uintmax_t *save) {
	cl_error_t err = cl_error.err.ok;

	if (arr == NULL || save == NULL) {
		err = cl_error.err.mem.null;
		goto ret;
	}
	*save = arr->len;
ret:
	return err;
}

static cl_error_t
corelibs_dynarray_get_cap_len (const cl_dynarray_t *arr, uintmax_t *save) {
	cl_error_t err = cl_error.err.ok;

	if (arr == NULL || save == NULL) {
		err = cl_error.err.mem.null;
		goto ret;
	}
	*save = arr->cap.len;
ret:
	return err;
}

static cl_error_t
corelibs_dynarray_get_cap_lock (const cl_dynarray_t *arr, bool *save) {
	cl_error_t err = cl_error.err.ok;

	if (arr == NULL || save == NULL) {
		err = cl_error.err.mem.null;
		goto ret;
	}
	*save = arr->cap.lock;
ret:
	return err;
}

static cl_error_t
corelibs_dynarray_get_size (const cl_dynarray_t *arr, size_t *save) {
	cl_error_t err = cl_error.err.ok;

	if (arr == NULL || save == NULL) {
		err = cl_error.err.mem.null;
		goto ret;
	}
	*save = arr->es;
ret:
	return err;
}

static cl_error_t
corelibs_dynarray_cmp_data (const cl_dynarray_t *a, const cl_dynarray_t *b, bool *eq) {
	cl_error_t err = cl_error.err.ok;

	if (a == NULL || b == NULL) {
		err = cl_error.err.mem.null;
		goto ret;
	}
	if (a->es != b->es) {
		err = cl_error.err.data.incompat;
		goto ret;
	}

	if (a->len != b->len) {
		*eq = false;
	} else {
		*eq = (memcmp (a->addr, b->addr, a->len) != 0) ? false : true;
	}
ret:
	return err;
}

// Private functions
static cl_error_t
corelibs_dynarray_bcheck (const cl_dynarray_t *arr, uintmax_t pos, uintmax_t len) {
	cl_error_t err = cl_error.err.ok;
	if (arr == NULL) {
		err = cl_error.err.mem.null;
		goto ret;
	}
	if (arr->cap.len < pos + len) {
		err = cl_error.err.mem.oob;
		goto ret;
	}
ret:
	return err;
}