cmhi
/
vcpe
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
vcpe/srcs/libs/misc/zvector.c

3426 lines
93 KiB
C
Raw Blame History

/*
* Name: ZVector
* Purpose: Library to use Dynamic Arrays (Vectors) in C Language
* Author: Paolo Fabio Zaino
* Domain: General
* License: Copyright by Paolo Fabio Zaino, all rights reserved.
* Distributed under MIT license
*
* Credits: This Library was inspired by the work of quite few,
* apologies if I forgot to mention them all!
*
* Gnome Team (GArray demo)
* Dimitros Michail (Dynamic Array in C presentation)
*
*/
/*
* Few code standard notes:
*
* p_ <- indicate a PRIVATE method or variable. Not reachable outside this
* module.
*
*/
/* Include standard C libs headers */
#include <assert.h>
#include <stddef.h>
#include <stdio.h>
#include <string.h>
/* Include vector.h header */
#include "zvector/zvector.h"
#include "common.h"
#if (OS_TYPE == 1)
#if (!defined(macOS))
/* Improve PThreads on Linux.
* macOS seems to be handling pthreads
* in a slightly different way than
* Linux, so, avoid using the same trick
* on macOS.
*/
#ifndef _POSIX_C_SOURCE
#define _POSIX_C_SOURCE 200112L
#endif // _POSIX_C_SOURCE
#define __USE_UNIX98
#endif // macOS
#endif // OS_TYPE
// Include non-ANSI Libraries
// only if the user has requested
// special extensions:
#if (OS_TYPE == 1)
#if (!defined(macOS))
#include <malloc.h>
#endif
#if (CPU_TYPE == x86_64)
// # include <xmmintrin.h>
#endif
#endif // OS_TYPE
#if (ZVECT_THREAD_SAFE == 1)
#if MUTEX_TYPE == 1
#if (!defined(macOS))
#include <semaphore.h>
#else
#include <dispatch/dispatch.h>
#endif
#include <pthread.h>
#elif MUTEX_TYPE == 2
#include <windows.h>
#include <psapi.h>
#endif // MUTEX_TYPE
#endif // ZVECT_THREAD_SAFE
// Local Defines/Macros:
// Declare Vector status flags:
enum {
ZVS_NONE = 0, // - Set or Reset vector's status
// register.
ZVS_CUST_WIPE_ON = 1 << 0, // - Set the bit to indicate a custom
// secure wipe
// function has been set.
ZVS_USR1_FLAG = 1 << 1, // - This is a "user" available flag,
// a user code can set it to 1 or
// 0 for its own need.
// Can be useful when signaling
// between threads.
ZVS_USR2_FLAG = 1 << 2
};
#ifndef ZVECT_MEMX_METHOD
#define ZVECT_MEMX_METHOD 1
#endif
#if defined(Arch32)
#define ADDR_TYPE1 uint32_t
#define ADDR_TYPE2 uint32_t
#define ADDR_TYPE3 uint16_t
#else
#define ADDR_TYPE1 uint64_t
#define ADDR_TYPE2 uint64_t
#define ADDR_TYPE3 uint32_t
#endif // Arch32
/*---------------------------------------------------------------------------*/
// Useful macros
// # define min(x, y) (((x) < (y)) ? (x) : (y))
#define max(x, y) (((x) > (y)) ? (x) : (y))
#ifndef UNUSED
#define UNUSED(x) (void)x
#endif
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/* Define the vector data structure:
*
* This is ZVector core data structure, it is the structure of a ZVector
* vector :)
* Please note: fields order is based on "most used fields" to help a bit
* with cache
*/
struct ZVECT_PACKING p_vector {
zvect_index cap_left; // - Max capacity allocated on the
// left.
zvect_index cap_right; // - Max capacity allocated on the
// right.
zvect_index begin; // - First vector's Element Pointer
zvect_index end; // - Current Array size. size - 1 gives
// us the pointer to the last element
// in the vector.
uint32_t flags; // - This flag set is used to store all
// Vector's properties.
// It contains bits that set Secure
// Wipe, Auto Shrink, Pass Items By
// Ref etc.
size_t data_size; // - User DataType size.
// This should be 2 bytes size on a
// 16-bit system, 4 bytes on a 32
// bit, 8 bytes on a 64 bit. But
// check your compiler for the
// actual size, it's implementation
// dependent.
#if (ZVECT_THREAD_SAFE == 1)
#if MUTEX_TYPE == 0
void *lock ZVECT_DATAALIGN; // - Vector's mutex for thread safe
// micro-transactions or user locks.
// This should be 2 bytes size on a
// 16 bit machine, 4 bytes on a 32
// bit 4 bytes on a 64 bit.
void *cond; // - Vector's mutex condition variable
#elif MUTEX_TYPE == 1
pthread_mutex_t lock ZVECT_DATAALIGN;
// - Vector's mutex for thread safe
// micro-transactions or user locks.
// This should be 24 bytes on a 32bit
// machine and 40 bytes on a 64bit.
pthread_cond_t cond; // - Vector's mutex condition variable
#elif MUTEX_TYPE == 2
CRITICAL_SECTION lock ZVECT_DATAALIGN;
// - Vector's mutex for thread safe
// micro-transactions or user locks.
// Check your WINNT.H to calculate
// the size of this one.
CONDITION_VARIABLE cond; // - Vector's mutex condition variable
#endif // MUTEX_TYPE
#endif // ZVECT_THREAD_SAFE
void **data ZVECT_DATAALIGN; // - Vector's storage.
zvect_index init_capacity; // - Initial Capacity (this is set at
// creation time).
// For the size of zvect_index check
// zvector_config.h.
void (*SfWpFunc)(const void *item, size_t size);
// - Pointer to a CUSTOM Safe Wipe
// function (optional) needed only
// for Secure Wiping special
// structures.
#ifdef ZVECT_DMF_EXTENSIONS
zvect_index balance; // - Used by the Adaptive Binary Search
// to improve performance.
zvect_index bottom; // - Used to optimise Adaptive Binary
// Search.
#endif // ZVECT_DMF_EXTENSIONS
volatile uint32_t status; // - Internal vector Status Flags
#if (ZVECT_THREAD_SAFE == 1)
#if (!defined(macOS))
sem_t semaphore; // - Vector semaphore
#else
dispatch_semaphore_t semaphore; // - Vector semaphore
#endif
volatile int32_t lock_type; // - This field contains the lock type
// used for this Vector.
#endif // ZVECT_THREAD_SAFE
} ZVECT_DATAALIGN;
// Internal representation of a vector
typedef struct p_vector *const ivector;
// Initialisation state:
static uint32_t p_init_state = 0;
/*---------------------------------------------------------------------------*/
/*****************************************************************************
** ZVector Support Functions **
*****************************************************************************/
/*---------------------------------------------------------------------------*/
// Errors and messages handling:
enum ZVECT_LOGPRIORITY {
ZVLP_NONE = 0, // No priority
ZVLP_INFO = 1 << 0, // This is an informational priority
// message.
ZVLP_LOW = 1 << 1, // " low "
ZVLP_MEDIUM = 1 << 2, // " medium "
ZVLP_HIGH = 1 << 3, // " high "
ZVLP_ERROR = 1 << 4 // This is an error message.
};
// Set the message priority at which we log it:
#ifdef DEBUG
unsigned int LOG_PRIORITY = (ZVLP_ERROR | ZVLP_HIGH | ZVLP_MEDIUM | ZVLP_LOW | ZVLP_INFO);
#endif
#ifndef DEBUG
unsigned int LOG_PRIORITY = (ZVLP_ERROR | ZVLP_HIGH | ZVLP_MEDIUM);
#endif
// Local declaration of private functions
void p_init_zvect(void);
zvect_retval p_vect_clear(ivector v);
// This is a vprintf wrapper nothing special:
static void log_msg(int const priority, const char *const format, ...) {
va_list args;
va_start(args, format);
if (priority & LOG_PRIORITY) {
vprintf(format, args);
}
#ifdef DEBUG
fflush(stdout);
#endif
#ifndef DEBUG
if (priority & (ZVLP_ERROR | ZVLP_HIGH)) {
fflush(stdout);
}
#endif
va_end(args);
}
static size_t safe_strlen(const char *str, size_t max_len) {
const char *end = (const char *)memchr(str, '\0', max_len);
if (end == NULL) {
return max_len;
} else {
return end - str;
}
}
static void *safe_strncpy(const char *const str_src, size_t max_len) {
void *str_dst = NULL;
char tmp_dst[max_len];
tmp_dst[sizeof(tmp_dst) - 1] = 0;
strncpy(tmp_dst, str_src, sizeof(tmp_dst));
if (tmp_dst[sizeof(tmp_dst) - 1] != 0) {
tmp_dst[sizeof(tmp_dst) - 1] = 0;
}
str_dst = (void *)malloc(sizeof(char *) * (sizeof(tmp_dst) + 1));
if (str_dst == NULL) {
log_msg(ZVLP_ERROR, "Error: %*i, %s\n", 8, -1000, "Out of memory!");
} else {
strncpy((char *)str_dst, tmp_dst, max_len);
}
return str_dst;
}
#if (ZVECT_COMPTYPE == 1) || (ZVECT_COMPTYPE == 3)
__attribute__((noreturn))
#endif
static void
p_throw_error(const zvect_retval error_code, const char *error_message) {
int32_t locally_allocated = 0;
char *message = NULL;
size_t msg_len = 0;
if (error_message == NULL) {
msg_len = sizeof(char *) * 255;
locally_allocated = -1;
} else {
msg_len = safe_strlen(error_message, 255);
}
if (locally_allocated) {
switch (error_code) {
case ZVERR_VECTUNDEF:
message = (char *)safe_strncpy("Undefined or uninitialized vector.\n\0", msg_len);
break;
case ZVERR_IDXOUTOFBOUND:
message = (char *)safe_strncpy("Index out of bound.\n\0", msg_len);
break;
case ZVERR_OUTOFMEM:
message = (char *)safe_strncpy("Not enough memory to allocate space for the vector.\n\0", msg_len);
break;
case ZVERR_VECTCORRUPTED:
message = (char *)safe_strncpy("Vector corrupted.\n\0", msg_len);
break;
case ZVERR_RACECOND:
message = (char *)safe_strncpy("Race condition detected, cannot continue.\n\0", msg_len);
break;
case ZVERR_VECTTOOSMALL:
message = (char *)safe_strncpy("Destination vector is smaller than source.\n\0", msg_len);
break;
case ZVERR_VECTDATASIZE:
message = (char *)safe_strncpy(
"This operation requires two (or more "
"vectors) with the same data size.\n\0",
msg_len);
break;
case ZVERR_VECTEMPTY:
message = (char *)safe_strncpy("Vector is empty.\n\0", msg_len);
break;
case ZVERR_OPNOTALLOWED:
message = (char *)safe_strncpy("Operation not allowed.\n\0", msg_len);
break;
default:
message = (char *)safe_strncpy("Unknown error.\n\0", msg_len);
break;
}
} else {
message = (char *)safe_strncpy(error_message, msg_len);
}
log_msg(ZVLP_ERROR, "Error: %*i, %s\n", 8, error_code, message);
if (locally_allocated) {
free((void *)message);
}
exit(error_code);
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
// Memory management:
#if (ZVECT_MEMX_METHOD == 0)
ZVECT_ALWAYSINLINE
static inline
#endif // ZVECT_MEMX_METHOD
void *
p_vect_memcpy(const void *__restrict dst, const void *__restrict src, size_t size) {
#if (ZVECT_MEMX_METHOD == 0)
// Using regular memcpy
// If you are using ZVector on Linux/macOS/BSD/Windows
// you should stick to this one!
return memcpy((void *)dst, src, size);
#elif (ZVECT_MEMX_METHOD == 1)
// Using improved memcpy (where improved means for
// embedded systems only!):
if (size > 0) {
if (((uintptr_t)dst % sizeof(ADDR_TYPE1) == 0) && ((uintptr_t)src % sizeof(ADDR_TYPE1) == 0) &&
(size % sizeof(ADDR_TYPE1) == 0)) {
ADDR_TYPE1 *pExDst = (ADDR_TYPE1 *)dst;
ADDR_TYPE1 const *pExSrc = (ADDR_TYPE1 const *)src;
size_t end = size / sizeof(ADDR_TYPE1);
for (register size_t i = 0; i < end; i++) {
// The following should be compiled as: (-O2 on x86_64)
// mov rdi, QWORD PTR [rsi+rcx]
// mov QWORD PTR [rax+rcx], rdi
*pExDst++ = *pExSrc++;
}
} else {
return memcpy(dst, src, size);
}
}
return dst;
#endif // ZVECT_MEMX_METHOD
}
ZVECT_ALWAYSINLINE
static inline void *p_vect_memmove(const void *__restrict dst, const void *__restrict src, size_t size) {
#ifdef DEBUG
log_msg(ZVLP_INFO, "p_vect_memmove: dst %*p\n", 14, dst);
log_msg(ZVLP_INFO, "p_vect_memmove: src %*p\n", 14, src);
log_msg(ZVLP_INFO, "p_vect_memmove: size %*u\n", 14, size);
#endif
return memmove((void *)dst, src, size);
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
// Thread Safe functions:
#if (ZVECT_THREAD_SAFE == 1)
static volatile bool locking_disabled = false;
#if MUTEX_TYPE == 0
#define ZVECT_THREAD_SAFE 0
#elif MUTEX_TYPE == 1
ZVECT_ALWAYSINLINE
static inline int mutex_lock(pthread_mutex_t *lock) {
return pthread_mutex_lock(lock);
}
ZVECT_ALWAYSINLINE
static inline int mutex_trylock(pthread_mutex_t *lock) {
return pthread_mutex_trylock(lock);
}
ZVECT_ALWAYSINLINE
static inline int mutex_unlock(pthread_mutex_t *lock) {
return pthread_mutex_unlock(lock);
}
static inline void mutex_init(pthread_mutex_t *lock) {
#if (!defined(macOS))
pthread_mutexattr_t Attr;
pthread_mutexattr_init(&Attr);
pthread_mutexattr_settype(&Attr, PTHREAD_MUTEX_RECURSIVE_NP);
pthread_mutexattr_setpshared(&Attr, PTHREAD_PROCESS_PRIVATE);
pthread_mutexattr_setprotocol(&Attr, PTHREAD_PRIO_INHERIT);
pthread_mutex_init(lock, &Attr);
#else
pthread_mutex_init(lock, NULL);
#endif // macOS
}
static inline void mutex_cond_init(pthread_cond_t *cond) {
#if (!defined(macOS))
pthread_condattr_t Attr;
pthread_condattr_init(&Attr);
pthread_condattr_setpshared(&Attr, PTHREAD_PROCESS_PRIVATE);
pthread_cond_init(cond, &Attr);
#else
pthread_cond_init(cond, NULL);
#endif // macOS
}
static inline void mutex_destroy(pthread_mutex_t *lock) {
pthread_mutex_destroy(lock);
}
static inline int semaphore_init
#if !defined(macOS)
(sem_t *sem, int value)
#else
(dispatch_semaphore_t *sem, int value)
#endif
{
#if !defined(macOS)
return sem_init(sem, 0, value);
#else
*sem = dispatch_semaphore_create(value);
return 0;
#endif
}
static inline int semaphore_destroy
#if !defined(macOS)
(sem_t *sem)
#else
(dispatch_semaphore_t *sem)
#endif
{
#if !defined(macOS)
return sem_destroy(sem);
#else
return 0; // dispatch_semaphore_destroy(sem);
(void)sem;
#endif
}
#elif MUTEX_TYPE == 2
static inline void mutex_lock(CRITICAL_SECTION *lock) {
EnterCriticalSection(lock);
}
static inline void mutex_unlock(CRITICAL_SECTION *lock) {
LeaveCriticalSection(lock);
}
static inline void mutex_alloc(CRITICAL_SECTION *lock) {
// InitializeCriticalSection(lock);
InitializeCriticalSectionAndSpinCount(lock, 32);
}
static inline void mutex_destroy(CRITICAL_SECTION *lock) {
DeleteCriticalSection(lock);
}
#endif // MUTEX_TYPE
#endif // ZVECT_THREAD_SAFE
#if (ZVECT_THREAD_SAFE == 1)
// The following two functions are generic locking functions
/*
* ZVector uses the concept of Priorities for locking.
* A user lock has the higher priority while ZVector itself
* uses two different levels of priorities (both lower than
* the user lock priority).
* level 1 is the lower priority, and it's used just by the
* primitives in ZVector.
* level 2 is the priority used by the ZVector functions that
* uses ZVector primitives.
* level 3 is the priority of the User's locks.
*/
static inline zvect_retval get_mutex_lock(const c_vector v, const int32_t lock_type) {
if (lock_type >= v->lock_type) {
mutex_lock(&(v->lock));
v->lock_type = lock_type;
return 1;
}
return 0;
}
static inline zvect_retval check_mutex_trylock(const c_vector v, const int32_t lock_type) {
if ((lock_type >= v->lock_type) && (!mutex_trylock(&(v->lock)))) {
v->lock_type = lock_type;
return 1;
}
return 0;
}
static inline zvect_retval lock_after_signal(const c_vector v, const int32_t lock_type) {
if (lock_type >= v->lock_type) {
// if (!mutex_trylock(&(v->lock))) {
while (!pthread_cond_wait(&(v->cond), &(v->lock))) {
// wait until we get a signal
}
// mutex_lock(&(v->lock));
v->lock_type = lock_type;
return 1;
//}
}
return 0;
}
/*
* TODO: Write a generic function to allow user to use signals:
static inline zvect_retval wait_for_signal(const c_vector v, const int32_t
lock_type, bool (*f1)(const c_vector v), ) { if (lock_type >= v->lock_type) {
//if (!mutex_trylock(&(v->lock))) {
while(!(*f1)(v)) {
// wait until we get a signal
pthread_cond_wait(&(v->cond), &(v->lock))
}
return 1;
//}
}
return 0;
}
*/
static inline zvect_retval send_signal(const c_vector v, const int32_t lock_type) {
return (lock_type >= v->lock_type) ? pthread_cond_signal(&(v->cond)) : 0;
}
static inline zvect_retval broadcast_signal(const c_vector v, const int32_t lock_type) {
return (lock_type >= v->lock_type) ? pthread_cond_broadcast(&(v->cond)) : 0;
}
static inline zvect_retval get_mutex_unlock(const c_vector v, const int32_t lock_type) {
if (lock_type == v->lock_type) {
v->lock_type = 0;
mutex_unlock(&(v->lock));
return 1;
}
return 0;
}
#endif // ZVECT_THREAD_SAFE
/*---------------------------------------------------------------------------*/
/*****************************************************************************
** ZVector Primitives **
*****************************************************************************/
/*---------------------------------------------------------------------------*/
// Library Initialisation:
void p_init_zvect(void) {
#if (OS_TYPE == 1)
#if (!defined(macOS))
// mallopt(M_MXFAST, 196*sizeof(size_t)/4);
#endif
#endif // OS_TYPE == 1
// We are done initialising ZVector so set the following
// to one, so this function will no longer be called:
p_init_state = 1;
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
// Vector's Utilities:
ZVECT_ALWAYSINLINE
static inline zvect_retval p_vect_check(const c_vector x) {
return (x == NULL) ? ZVERR_VECTUNDEF : 0;
}
ZVECT_ALWAYSINLINE
static inline zvect_index p_vect_capacity(const c_vector v) {
return (v->cap_left + v->cap_right);
}
ZVECT_ALWAYSINLINE
static inline zvect_index p_vect_size(const c_vector v) {
return (v->end > v->begin) ? (v->end - v->begin) : (v->begin - v->end);
}
static inline void p_item_safewipe(ivector v, void *const item) {
if (item != NULL) {
if (!(v->status & ZVS_CUST_WIPE_ON)) {
memset(item, 0, v->data_size);
} else {
(*(v->SfWpFunc))(item, v->data_size);
}
}
}
ZVECT_ALWAYSINLINE
static inline zvect_retval p_usr_status(zvect_index flag_id) {
switch (flag_id) {
case 1:
return 0;
break;
default:
return 1;
}
}
bool vect_check_status(const c_vector v, zvect_index flag_id) {
return (v->status >> flag_id) & 1U;
}
bool vect_set_status(const c_vector v, zvect_index flag_id) {
zvect_retval rval = p_usr_status(flag_id);
if (!rval) {
v->status |= 1 << flag_id;
}
return (bool)rval;
}
bool vect_clear_status(const c_vector v, zvect_index flag_id) {
zvect_retval rval = p_usr_status(flag_id);
if (!rval) {
v->status &= ~(1 << flag_id);
}
return (bool)rval;
}
bool vect_toggle_status(const c_vector v, zvect_index flag_id) {
zvect_retval rval = p_usr_status(flag_id);
if (!rval) {
v->status ^= (1 << flag_id);
}
return rval;
}
static void p_free_items(ivector v, zvect_index first, zvect_index offset) {
if (p_vect_size(v) == 0) {
return;
}
for (register zvect_index j = (first + offset); j >= first; j--) {
if (v->data[v->begin + j] != NULL) {
if (v->flags & ZV_SEC_WIPE) {
p_item_safewipe(v, v->data[v->begin + j]);
}
if (!(v->flags & ZV_BYREF)) {
free(v->data[v->begin + j]);
}
}
if (j == first) {
break; // this is required if we are using
// uint and the first element is element
// 0, because on GCC an uint will fail
// then check in the for loop if j >= first
// in this particular case!
}
}
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
// Vector Size and Capacity management functions:
/*
* Set vector capacity to a specific new_capacity value
*/
static zvect_retval p_vect_set_capacity(ivector v, const zvect_index direction, const zvect_index new_capacity_) {
zvect_index new_capacity = new_capacity_;
if (new_capacity <= v->init_capacity) {
new_capacity = v->init_capacity;
}
void **new_data = NULL;
if (!direction) {
// Set capacity on the left side of the vector to new_capacity:
new_data = (void **)malloc(sizeof(void *) * (new_capacity + v->cap_right));
if (new_data == NULL) {
return ZVERR_OUTOFMEM;
}
memset(new_data, 0, sizeof(void *) * (new_capacity + v->cap_right));
zvect_index nb;
zvect_index ne;
nb = v->cap_left;
ne = (nb + (v->end - v->begin));
if (v->end != v->begin) {
p_vect_memcpy(new_data + nb, v->data + v->begin, sizeof(void *) * (v->end - v->begin));
}
// Reconfigure vector:
v->cap_left = new_capacity;
v->end = ne;
v->begin = nb;
free(v->data);
} else {
// Set capacity on the right side of the vector to new_capacity:
new_data = (void **)realloc(v->data, sizeof(void *) * (v->cap_left + new_capacity));
if (new_data == NULL) {
return ZVERR_OUTOFMEM;
}
// Reconfigure Vector:
v->cap_right = new_capacity;
}
// Apply changes
v->data = new_data;
// done
return 0;
}
/*
* This function increase the CAPACITY of a vector.
*/
static zvect_retval p_vect_increase_capacity(ivector v, const zvect_index direction) {
zvect_index new_capacity;
if (!direction) {
// Increase capacity on the left side of the vector:
// Get actual left capacity and double it
// Note: "<< 1" is the same as "* 2"
// this is an optimisation for old
// compilers.
new_capacity = v->cap_left << 1;
} else {
// Increase capacity on the right side of the vector:
// Get actual left capacity and double it
// Note: "<< 1" is the same as "* 2"
// this is an optimisation for old
// compilers.
new_capacity = v->cap_right << 1;
}
zvect_retval rval = p_vect_set_capacity(v, direction, new_capacity);
// done
return rval;
}
/*
* This function decrease the CAPACITY of a vector.
*/
static zvect_retval p_vect_decrease_capacity(ivector v, const zvect_index direction) {
// Check if new capacity is smaller than initial capacity
if (p_vect_capacity(v) <= v->init_capacity) {
return 0;
}
zvect_index new_capacity;
void **new_data = NULL;
if (!direction) {
// Decreasing on the left:
// Note: ">> 1" is the same as "/ 2"
// this is an optimisation for old
// compilers.
new_capacity = v->cap_left >> 1;
if (new_capacity < (v->init_capacity >> 1)) {
new_capacity = v->init_capacity >> 1;
}
new_capacity = max((p_vect_size(v) >> 1), new_capacity);
new_data = (void **)malloc(sizeof(void *) * (new_capacity + v->cap_right));
if (new_data == NULL) {
return ZVERR_OUTOFMEM;
}
zvect_index nb;
zvect_index ne;
nb = (new_capacity >> 1);
ne = (nb + (v->end - v->begin));
p_vect_memcpy(new_data + nb, v->data + v->begin, sizeof(void *) * (v->end - v->begin));
// Reconfigure Vector:
v->cap_left = new_capacity;
v->end = ne;
v->begin = nb;
free(v->data);
} else {
// Decreasing on the right:
// Note: ">> 1" is the same as "/ 2"
// this is an optimisation for old
// compilers.
new_capacity = v->cap_right >> 1;
if (new_capacity < (v->init_capacity >> 1)) {
new_capacity = v->init_capacity >> 1;
}
new_capacity = max((p_vect_size(v) >> 1), new_capacity);
new_data = (void **)realloc(v->data, sizeof(void *) * (v->cap_left + new_capacity));
if (new_data == NULL) {
return ZVERR_OUTOFMEM;
}
// Reconfigure vector:
v->cap_right = new_capacity;
}
// Apply changes
v->data = new_data;
// done:
return 0;
}
/*
* This function shrinks the CAPACITY of a vector
* not its size. To reduce the size of a vector we
* need to remove items from it.
*/
static zvect_retval p_vect_shrink(ivector v) {
if (v->init_capacity < 2) {
v->init_capacity = 2;
}
if (p_vect_capacity(v) == v->init_capacity || p_vect_capacity(v) <= p_vect_size(v)) {
return 0;
}
// Determine the correct shrunk size:
zvect_index new_capacity;
if (p_vect_size(v) < v->init_capacity) {
new_capacity = v->init_capacity;
} else {
new_capacity = p_vect_size(v) + 2;
}
// shrink the vector:
// Given that zvector supports vectors that can grow on the left and on the
// right I cannot use realloc here.
void **new_data = (void **)malloc(sizeof(void *) * new_capacity);
if (new_data == NULL) {
return ZVERR_OUTOFMEM;
}
zvect_index ne;
zvect_index nb;
// Note: ">> 1" is the same as "/ 2"
// this is an optimisation for old
// compilers.
nb = (new_capacity >> 1);
ne = (nb + (v->end - v->begin));
p_vect_memcpy(new_data + nb, v->data + v->begin, sizeof(void *) * (v->end - v->begin));
// Apply changes:
free(v->data);
v->data = new_data;
v->end = ne;
v->begin = nb;
v->cap_left = new_capacity >> 1;
v->cap_right = new_capacity >> 1;
// done:
return 0;
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
// Creation and destruction primitives:
zvect_retval p_vect_clear(ivector v) {
// Clear the vector:
if (!vect_is_empty(v)) {
p_free_items(v, 0, (p_vect_size(v) - 1));
}
// Reset interested descriptors:
v->begin = v->end = 0;
// Shrink Vector's capacity:
// p_vect_shrink(v); // commented this out to make vect_clear behave more like
// the clear method in C++
return 0;
}
static zvect_retval p_vect_destroy(c_vector v, uint32_t flags) {
// p_destroy is an exception to the rule of handling
// locking from the public methods. This because
// p_destroy has to destroy the vector mutex too and
// so it needs to control the lock as well!
#if (ZVECT_THREAD_SAFE == 1)
zvect_retval lock_owner = (locking_disabled || (v->flags & ZV_NOLOCKING)) ? 0 : get_mutex_lock(v, 1);
if (!lock_owner && (!locking_disabled) && !(v->flags & ZV_NOLOCKING)) {
return ZVERR_RACECOND;
}
#endif
// Clear the vector (if LSB of flags is set to 1):
if ((p_vect_size(v) > 0) && (flags & 1)) {
// Clean the vector:
p_vect_clear(v);
// Reset interested descriptors:
v->end = 0;
}
// Destroy the vector:
v->init_capacity = v->cap_left = v->cap_right = 0;
// Destroy it:
if (v->status & ZVS_CUST_WIPE_ON) {
v->SfWpFunc = NULL;
}
if (v->data != NULL) {
free(v->data);
v->data = NULL;
}
// Clear vector status flags:
v->status = v->flags = v->begin = v->end = v->data_size = v->balance = v->bottom = 0;
#if (ZVECT_THREAD_SAFE == 1)
if (lock_owner) {
get_mutex_unlock(v, v->lock_type);
}
mutex_destroy(&(v->lock));
semaphore_destroy(&(v->semaphore));
#endif
// All done and freed, so we can safely
// free the vector itself:
free(v);
return 0;
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
// Vector data storage primitives:
// inline implementation for all put:
static zvect_retval p_vect_put_at(ivector v, const void *value, const zvect_index i) {
// Check if the index passed is out of bounds:
zvect_index idx = i;
if (!(v->flags & ZV_CIRCULAR)) {
if (idx >= p_vect_size(v)) {
return ZVERR_IDXOUTOFBOUND;
}
} else {
if (idx >= p_vect_size(v)) {
idx = i % v->init_capacity;
}
}
// Add value at the specified index, considering
// if the vector has ZV_BYREF property enabled:
if (v->flags & ZV_BYREF) {
void *temp = v->data[v->begin + idx];
v->data[v->begin + idx] = (void *)value;
if (v->flags & ZV_SEC_WIPE) {
memset((void *)temp, 0, v->data_size);
}
} else {
p_vect_memcpy(v->data[v->begin + idx], value, v->data_size);
}
// done
return 0;
}
// inline implementation for all add(s):
static inline zvect_retval p_vect_add_at(ivector v, const void *value, const zvect_index i) {
zvect_index idx = i;
// Get vector size:
zvect_index vsize = p_vect_size(v);
#if (ZVECT_FULL_REENTRANT == 1)
// If we are in FULL_REENTRANT MODE prepare for potential
// array copy:
void **new_data = NULL;
if (idx < vsize) {
new_data = (void **)malloc(sizeof(void *) * p_vect_capacity(v));
if (new_data == NULL) {
return ZVERR_OUTOFMEM;
}
}
#endif
// Allocate memory for the new item:
zvect_index base = v->begin;
if (!idx) {
// Prepare left side of the vector:
if (base) {
base--;
}
if (!(v->flags & ZV_BYREF)) {
v->data[base] = (void *)malloc(v->data_size);
if (v->data[base] == NULL) {
return ZVERR_OUTOFMEM;
}
}
} else if (idx == vsize && !(v->flags & ZV_BYREF)) {
// Prepare right side of the vector:
v->data[base + vsize] = (void *)malloc(v->data_size);
if (v->data[base + vsize] == NULL) {
return ZVERR_OUTOFMEM;
}
}
// "Shift" right the array of one position to make space for the new item:
int16_t array_changed = 0;
if ((idx < vsize) && (idx != 0)) {
array_changed = 1;
#if (ZVECT_FULL_REENTRANT == 1)
// Algorithm to try to copy an array of pointers as fast as possible:
if (idx > 0) {
p_vect_memcpy(new_data + base, v->data + base, sizeof(void *) * idx);
}
p_vect_memcpy(new_data + base + (idx + 1), v->data + base + idx, sizeof(void *) * (vsize - idx));
#else
// We can't use the vect_memcpy when not in full reentrant code
// because it's not safe to use it on the same src and dst.
p_vect_memmove(v->data + base + (idx + 1), v->data + base + idx, sizeof(void *) * (vsize - idx));
#endif // (ZVECT_FULL_REENTRANT == 1)
}
// Add new value in (at the index i):
#if (ZVECT_FULL_REENTRANT == 1)
if (array_changed) {
if (v->flags & ZV_BYREF) {
new_data[base + idx] = (void *)value;
} else {
new_data[base + idx] = (void *)malloc(v->data_size);
if (new_data[base + idx] == NULL) {
return ZVERR_OUTOFMEM;
}
p_vect_memcpy(new_data[base + idx], value, v->data_size);
}
} else {
if (v->flags & ZV_BYREF) {
v->data[base + idx] = (void *)value;
} else {
p_vect_memcpy(v->data[base + idx], value, v->data_size);
}
}
#else
if (array_changed && !(v->flags & ZV_BYREF)) {
// We moved chunks of memory, so we need to
// allocate new memory for the item at position i:
v->data[base + idx] = malloc(v->data_size);
if (v->data[base + idx] == NULL) {
return ZVERR_OUTOFMEM;
}
}
if (v->flags & ZV_BYREF) {
v->data[base + idx] = (void *)value;
} else {
p_vect_memcpy(v->data[base + idx], value, v->data_size);
}
#endif // (ZVECT_FULL_REENTRANT == 1)
// Apply changes:
#if (ZVECT_FULL_REENTRANT == 1)
if (array_changed) {
free(v->data);
v->data = new_data;
}
#endif
// Increment vector size
if (!idx) {
if (v->begin == base) {
v->end++;
} else {
v->begin = base;
}
} else {
v->end++;
}
// done
return 0;
#if (ZVECT_FULL_REENTRANT == 1)
UNUSED(new_data);
#endif
}
// This is the inline implementation for all the remove and pop
static inline zvect_retval p_vect_remove_at(ivector v, const zvect_index i, void **item) {
zvect_index idx = i;
// Get the vector size:
zvect_index vsize = p_vect_size(v);
// Check if the index is out of bounds:
if (idx >= vsize) {
if (!(v->flags & ZV_CIRCULAR)) {
return ZVERR_IDXOUTOFBOUND;
} else {
idx = idx % vsize;
}
}
// Check if the vector got corrupted
if ((v->end != 0) && (v->begin > v->end)) {
return ZVERR_VECTCORRUPTED;
}
// Start processing the vector:
#if (ZVECT_FULL_REENTRANT == 1)
// Allocate memory for support Data Structure:
void **new_data = (void **)malloc(sizeof(void *) * p_vect_capacity(v));
if (new_data == NULL) {
return ZVERR_OUTOFMEM;
}
#endif
// Get the value we are about to remove:
// If the vector is set as ZV_BYREF, then just copy the pointer to the item
// If the vector is set as regular, then copy the item
zvect_index base = v->begin;
if (v->flags & ZV_BYREF) {
*item = v->data[base + idx];
} else {
*item = (void **)malloc(v->data_size);
if (v->data[base + idx] != NULL) {
p_vect_memcpy(*item, v->data[base + idx], v->data_size);
// If the vector is set for secure wipe, and we copied the item
// then we need to wipe the old copy:
if (v->flags & ZV_SEC_WIPE) {
p_item_safewipe(v, v->data[base + idx]);
}
} /* else {
memset(item, 0, v->data_size - 1);
} */
}
// "shift" left the array of one position:
uint16_t array_changed;
array_changed = 0;
if (idx != 0) {
if ((idx < (vsize - 1)) && (vsize > 0)) {
array_changed = 1;
free(v->data[base + idx]);
#if (ZVECT_FULL_REENTRANT == 1)
p_vect_memcpy(new_data + base, v->data + base, sizeof(void *) * idx);
p_vect_memcpy(new_data + base + idx, v->data + base + (idx + 1), sizeof(void *) * (vsize - idx));
#else
// We can't use the vect_memcpy when not in full reentrant code
// because it's not safe to use it on the same src and dst.
p_vect_memmove(v->data + (base + idx), v->data + (base + (idx + 1)), sizeof(void *) * (vsize - idx));
// Clear leftover item pointers:
memset(v->data[(v->begin + vsize) - 1], 0, 1);
#endif
}
} else {
if (base < v->end) {
array_changed = 1;
if (v->data[base] != NULL) {
free(v->data[base]);
}
}
}
// Reduce vector size:
#if (ZVECT_FULL_REENTRANT == 0)
if (!(v->flags & ZV_BYREF) && !array_changed) {
p_free_items(v, vsize - 1, 0);
}
#else
// Apply changes
if (array_changed) {
free(v->data);
v->data = new_data;
}
#endif
if (!(v->flags & ZV_CIRCULAR)) {
if (idx != 0) {
if (v->end > v->begin) {
v->end--;
} else {
v->end = v->begin;
}
} else {
if (v->begin < v->end) {
v->begin++;
} else {
v->begin = v->end;
}
}
// Check if we need to shrink vector's capacity:
if ((4 * vsize) < p_vect_capacity(v)) {
p_vect_decrease_capacity(v, idx);
}
}
// All done, return control:
return 0;
}
// This is the inline implementation for all the "delete" methods
static inline zvect_retval p_vect_delete_at(ivector v,
const zvect_index start,
const zvect_index offset,
uint32_t flags) {
zvect_index vsize = p_vect_size(v);
// If the vector is empty just return
if (vsize == 0) {
return ZVERR_VECTEMPTY;
}
// Check if the index is out of bounds:
if ((start + offset) > vsize) {
return ZVERR_IDXOUTOFBOUND;
}
uint16_t array_changed = 0;
// "shift" left the data of one position:
zvect_index tot_items = start + offset;
#ifdef DEBUG
/*
log_msg(ZVLP_INFO, "p_vect_delete_at: start %*u\n", 14, start);
log_msg(ZVLP_INFO, "p_vect_delete_at: offset %*u\n", 14, offset);
log_msg(ZVLP_INFO, "p_vect_delete_at: tot_items %*u\n", 14, tot_items);
log_msg(ZVLP_INFO, "p_vect_delete_at: v->begin %*u\n", 14, v->begin);
log_msg(ZVLP_INFO, "p_vect_delete_at: v->end %*u\n", 14, v->end);
log_msg(ZVLP_INFO, "p_vect_delete_at: vsize %*u\n", 14, vsize);
log_msg(ZVLP_INFO, "p_vect_delete_at: data %*p\n", 14, v->data);
*/
#endif
if ((vsize > 1) && (start < (vsize - 1)) && (tot_items < vsize) && (v->data != NULL)) {
array_changed = 1;
#ifdef DEBUG
/* for (zvect_index ptrID = start; ptrID < start + offset; ptrID++)
{
log_msg(ZVLP_INFO, "p_vect_delete_at: data ptr %*p\n", 14,
v->data + (v->begin + ptrID));
}*/
#endif
// Safe erase items?
if (flags & 1) {
p_free_items(v, start, offset);
}
// Move remaining items pointers up:
if (tot_items) {
p_vect_memmove(v->data + (v->begin + start),
v->data + (v->begin + tot_items + 1),
sizeof(void *) * ((vsize - start) - offset));
}
// Clear leftover item pointers:
if (offset && !(flags & 1)) {
memset(v->data + ((v->begin + vsize) - (offset + 1)), 0, offset);
}
}
// Reduce vector size:
if (!(v->flags & ZV_BYREF) && (flags & 1) && !array_changed) {
p_free_items(v, ((vsize - 1) - offset), offset);
}
// Check if we need to increment begin or decrement end
// depending on the direction of the "delete" (left or right)
if (start != 0 || array_changed) {
if ((v->end - (offset + 1)) > v->begin) {
v->end -= (offset + 1);
} else {
v->end = v->begin;
}
} else {
if ((v->begin + (offset + 1)) < v->end) {
v->begin += (offset + 1);
} else {
v->begin = v->end;
}
}
if (v->begin == v->end) {
v->begin = 0;
v->end = 0;
}
// Check if we need to shrink the vector:
if ((4 * vsize) < p_vect_capacity(v)) {
p_vect_decrease_capacity(v, start);
}
// All done, return control:
return 0;
}
/*---------------------------------------------------------------------------*/
/*****************************************************************************
** ZVector API **
*****************************************************************************/
/*---------------------------------------------------------------------------*/
// Vector Size and Capacity management functions:
/*
* Public method to request ZVector to
* shrink a vector.
*/
void vect_shrink(ivector v) {
#if (ZVECT_THREAD_SAFE == 1)
zvect_retval lock_owner = get_mutex_lock(v, 1);
#endif
zvect_retval rval = p_vect_shrink(v);
#if (ZVECT_THREAD_SAFE == 1)
if (lock_owner) {
get_mutex_unlock(v, 1);
}
#endif
if (rval) {
p_throw_error(rval, NULL);
}
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
// Vector Structural Information report:
int vect_is_empty(ivector v) {
return !p_vect_check(v) ? ((p_vect_size(v) == 0) ? TRUE : FALSE) : FALSE;
//return !p_vect_check(v) ? (p_vect_size(v) == 0) : (bool)ZVERR_VECTUNDEF;
}
zvect_index vect_size(ivector v) {
return !p_vect_check(v) ? p_vect_size(v) : 0;
}
zvect_index vect_max_size(ivector v) {
return (!p_vect_check(v) ? zvect_index_max : 0);
}
void *vect_begin(ivector v) {
return !p_vect_check(v) ? v->data[v->begin] : NULL;
}
void *vect_end(ivector v) {
return !p_vect_check(v) ? v->data[v->end] : NULL;
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
// Vector Creation and Destruction:
c_vector vect_create(const zvect_index init_capacity, const size_t item_size, const uint32_t properties) {
// If ZVector has not been initialised yet, then initialise it
// when creating the first vector:
if (p_init_state == 0) {
p_init_zvect();
}
// Create the vector first:
c_vector v = (c_vector)malloc(sizeof(struct p_vector));
if (v == NULL) {
p_throw_error(ZVERR_OUTOFMEM, NULL);
}
// Initialize the vector:
v->end = 0;
if (item_size == 0) {
v->data_size = ZVECT_DEFAULT_DATA_SIZE;
} else {
v->data_size = item_size;
}
zvect_index capacity = init_capacity;
if (init_capacity == 0) {
v->cap_left = ZVECT_INITIAL_CAPACITY / 2;
v->cap_right = ZVECT_INITIAL_CAPACITY / 2;
} else {
if (init_capacity <= 4) {
capacity = 4;
}
v->cap_left = capacity / 2;
v->cap_right = capacity / 2;
}
v->begin = v->end = 0;
v->init_capacity = v->cap_left + v->cap_right;
v->flags = properties;
v->SfWpFunc = NULL;
v->status = 0;
if (v->flags & ZV_CIRCULAR) {
// If the vector is circular then
// we need to pre-allocate all the elements
// the vector will not grow:
v->end = v->cap_right - 1;
v->begin = v->cap_left - 1;
}
#ifdef ZVECT_DMF_EXTENSIONS
v->balance = v->bottom = 0;
#endif // ZVECT_DMF_EXTENSIONS
v->data = NULL;
#if (ZVECT_THREAD_SAFE == 1)
v->lock_type = 0;
mutex_init(&(v->lock));
mutex_cond_init(&(v->cond));
semaphore_init(&(v->semaphore), 0);
#endif
// Allocate memory for the vector storage area
v->data = (void **)calloc(p_vect_capacity(v), sizeof(void *));
if (v->data == NULL) {
p_throw_error(ZVERR_OUTOFMEM, NULL);
}
// Return the vector to the user:
return v;
}
void vect_destroy(c_vector v) {
// Call p_vect_destroy with flags set to 1
// to destroy data according to the vector
// properties:
zvect_retval rval = p_vect_check(v);
if (rval) {
goto JOB_DONE;
}
rval = p_vect_destroy(v, 1);
JOB_DONE:
if (rval) {
p_throw_error(rval, NULL);
}
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
// Vector Thread Safe user functions:
#if (ZVECT_THREAD_SAFE == 1)
void vect_lock_enable(void) {
locking_disabled = false;
}
void vect_lock_disable(void) {
locking_disabled = true;
}
static inline zvect_retval p_vect_lock(ivector v) {
return (locking_disabled || (v->flags & ZV_NOLOCKING)) ? 0 : get_mutex_lock(v, 3);
}
zvect_retval vect_lock(ivector v) {
return p_vect_lock(v);
}
static inline zvect_retval p_vect_unlock(ivector v) {
return (locking_disabled || (v->flags & ZV_NOLOCKING)) ? 0 : get_mutex_unlock(v, 3);
}
zvect_retval vect_unlock(ivector v) {
return p_vect_unlock(v);
}
static inline zvect_retval p_vect_trylock(ivector v) {
return (locking_disabled || (v->flags & ZV_NOLOCKING)) ? 0 : check_mutex_trylock(v, 3);
}
zvect_retval vect_trylock(ivector v) {
return p_vect_trylock(v);
}
zvect_retval vect_sem_wait(const c_vector v) {
#if !defined(macOS)
return sem_wait(&(v->semaphore));
#else
return dispatch_semaphore_wait(v->semaphore, DISPATCH_TIME_FOREVER);
#endif
}
zvect_retval vect_sem_post(const c_vector v) {
#if !defined(macOS)
return sem_post(&(v->semaphore));
#else
return dispatch_semaphore_signal(v->semaphore);
#endif
}
/*
static inline zvect_retval p_vect_wait_for_signal(const c_vector v) {
return (locking_disabled || (v->flags & ZV_NOLOCKING)) ? 1 :
wait_for_signal(v, 3);
}
inline zvect_retval vect_wait_for_signal(const c_vector v) {
return p_vect_wait_for_signal(v);
}
*/
static inline zvect_retval p_vect_lock_after_signal(const c_vector v) {
return (locking_disabled || (v->flags & ZV_NOLOCKING)) ? 1 : lock_after_signal(v, 3);
}
zvect_retval vect_lock_after_signal(const c_vector v) {
return p_vect_lock_after_signal(v);
}
zvect_retval vect_send_signal(const c_vector v) {
return send_signal(v, 3);
}
zvect_retval vect_broadcast_signal(const c_vector v) {
return broadcast_signal(v, 3);
}
#endif
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
// Vector Data Storage functions:
void vect_clear(ivector v) {
// check if the vector exists:
zvect_retval rval = p_vect_check(v);
if (rval) {
goto JOB_DONE;
}
#if (ZVECT_THREAD_SAFE == 1)
zvect_retval lock_owner = (locking_disabled || (v->flags & ZV_NOLOCKING)) ? 0 : get_mutex_lock(v, 1);
#endif
rval = p_vect_clear(v);
// DONE_PROCESSING:
#if (ZVECT_THREAD_SAFE == 1)
if (lock_owner) {
get_mutex_unlock(v, 1);
}
#endif
JOB_DONE:
if (rval) {
p_throw_error(rval, NULL);
}
}
void vect_set_wipefunct(const c_vector v, void (*f1)(const void *, size_t)) {
// v->SfWpFunc = (void *)malloc(sizeof(void *));
// if (v->SfWpFunc == NULL)
// p_throw_error(ZVERR_OUTOFMEM, NULL);
// Set custom Safe Wipe function:
v->SfWpFunc = f1;
// p_vect_memcpy(v->SfWpFunc, f1, sizeof(void *));
v->status |= ZVS_CUST_WIPE_ON;
}
// Add an item at the END (top) of the vector
void vect_push(const c_vector v, const void *value) {
zvect_index vsize = 0;
zvect_retval rval = p_vect_check(v);
if (rval) {
goto JOB_DONE;
}
// If the vector is circular then use vect_put_at
// instead:
if (v->flags & ZV_CIRCULAR) {
rval = p_vect_put_at(v, value, p_vect_size(v));
goto JOB_DONE;
}
#if (ZVECT_THREAD_SAFE == 1)
zvect_retval lock_owner = (locking_disabled || (v->flags & ZV_NOLOCKING)) ? 0 : get_mutex_lock(v, 1);
#endif
// The very first time we do a push, if the vector is
// declared very small, we may need to expand its
// capacity on the left. This because the very first
// push will use index 0 and the rule in ZVector is
// when we use index 0 we may need to expand on the
// left. So let's check if we do for this vector:
vsize = p_vect_size(v);
// Check if we need to expand on thr right side:
if ((v->end >= v->cap_right) && ((rval = p_vect_increase_capacity(v, 1)) != 0)) {
goto DONE_PROCESSING;
}
rval = p_vect_add_at(v, value, vsize);
DONE_PROCESSING:
#if (ZVECT_THREAD_SAFE == 1)
if (lock_owner) {
get_mutex_unlock(v, 1);
}
#endif
JOB_DONE:
if (rval) {
p_throw_error(rval, NULL);
}
}
// Add an item at the END of the vector
void vect_add(const c_vector v, const void *value) {
vect_push(v, value);
}
// Add an item at position "i" of the vector
void vect_add_at(const c_vector v, const void *value, const zvect_index i) {
zvect_retval rval = p_vect_check(v);
if (rval) {
goto JOB_DONE;
}
// If the vector is circular then use vect_put_at
// instead:
if (v->flags & ZV_CIRCULAR) {
rval = p_vect_put_at(v, value, i);
goto JOB_DONE;
}
#if (ZVECT_THREAD_SAFE == 1)
zvect_retval lock_owner = (locking_disabled || (v->flags & ZV_NOLOCKING)) ? 0 : get_mutex_lock(v, 1);
#endif
// Check if the provided index is out of bounds:
if (i > p_vect_size(v)) {
rval = ZVERR_IDXOUTOFBOUND;
goto DONE_PROCESSING;
}
if (!i) {
// Check if we need to expand on the left side:
if ((v->begin == 0 || v->cap_left <= 1) && ((rval = p_vect_increase_capacity(v, 0)) != 0)) {
goto DONE_PROCESSING;
}
} else {
// Check if we need to expand on thr right side:
if ((v->end >= v->cap_right) && ((rval = p_vect_increase_capacity(v, 1)) != 0)) {
goto DONE_PROCESSING;
}
}
rval = p_vect_add_at(v, value, i);
DONE_PROCESSING:
#if (ZVECT_THREAD_SAFE == 1)
if (lock_owner) {
get_mutex_unlock(v, 1);
}
#endif
JOB_DONE:
if (rval) {
p_throw_error(rval, NULL);
}
}
// Add an item at the FRONT of the vector
void vect_add_front(ivector v, const void *value) {
zvect_retval rval = p_vect_check(v);
if (rval) {
goto JOB_DONE;
}
// If the vector is circular then use vect_put_at
// instead:
if (v->flags & ZV_CIRCULAR) {
rval = p_vect_put_at(v, value, 0);
goto JOB_DONE;
}
#if (ZVECT_THREAD_SAFE == 1)
zvect_retval lock_owner = (locking_disabled || (v->flags & ZV_NOLOCKING)) ? 0 : get_mutex_lock(v, 1);
#endif
// Check if we need to expand on the left side:
if ((v->begin == 0 || v->cap_left <= 1) && ((rval = p_vect_increase_capacity(v, 0)) != 0)) {
goto DONE_PROCESSING;
}
rval = p_vect_add_at(v, value, 0);
DONE_PROCESSING:
#if (ZVECT_THREAD_SAFE == 1)
if (lock_owner) {
get_mutex_unlock(v, 1);
}
#endif
JOB_DONE:
if (rval) {
p_throw_error(rval, NULL);
}
}
// inline implementation for all get(s):
static inline void *p_vect_get_at(ivector v, const zvect_index i) {
// Check if passed index is out of bounds:
if (i >= p_vect_size(v)) {
p_throw_error(ZVERR_IDXOUTOFBOUND, NULL);
}
// Return found element:
return v->data[v->begin + i];
}
void *vect_get(ivector v) {
// check if the vector exists:
zvect_retval rval = p_vect_check(v);
if (!rval) {
return p_vect_get_at(v, p_vect_size(v) - 1);
} else {
p_throw_error(rval, NULL);
}
return NULL;
}
void *vect_get_at(ivector v, const zvect_index i) {
// check if the vector exists:
zvect_retval rval = p_vect_check(v);
if (!rval) {
return p_vect_get_at(v, i);
} else {
p_throw_error(rval, NULL);
}
return NULL;
}
void *vect_get_front(ivector v) {
// check if the vector exists:
zvect_retval rval = p_vect_check(v);
if (!rval) {
return p_vect_get_at(v, 0);
} else {
p_throw_error(rval, NULL);
}
return NULL;
}
void vect_put(ivector v, const void *value) {
zvect_retval rval = p_vect_check(v);
if (rval) {
goto JOB_DONE;
}
#if (ZVECT_THREAD_SAFE == 1)
zvect_retval lock_owner = (locking_disabled || (v->flags & ZV_NOLOCKING)) ? 0 : get_mutex_lock(v, 1);
#endif
rval = p_vect_put_at(v, value, p_vect_size(v) - 1);
#if (ZVECT_THREAD_SAFE == 1)
if (lock_owner) {
get_mutex_unlock(v, 1);
}
#endif
JOB_DONE:
if (rval) {
p_throw_error(rval, NULL);
}
}
void vect_put_at(ivector v, const void *value, const zvect_index i) {
zvect_retval rval = p_vect_check(v);
if (rval) {
goto JOB_DONE;
}
#if (ZVECT_THREAD_SAFE == 1)
zvect_retval lock_owner = (locking_disabled || (v->flags & ZV_NOLOCKING)) ? 0 : get_mutex_lock(v, 1);
#endif
rval = p_vect_put_at(v, value, i);
#if (ZVECT_THREAD_SAFE == 1)
if (lock_owner) {
get_mutex_unlock(v, 1);
}
#endif
JOB_DONE:
if (rval) {
p_throw_error(rval, NULL);
}
}
void vect_put_front(ivector v, const void *value) {
zvect_retval rval = p_vect_check(v);
if (rval) {
goto JOB_DONE;
}
#if (ZVECT_THREAD_SAFE == 1)
zvect_retval lock_owner = (locking_disabled || (v->flags & ZV_NOLOCKING)) ? 0 : get_mutex_lock(v, 1);
#endif
rval = p_vect_put_at(v, value, 0);
#if (ZVECT_THREAD_SAFE == 1)
if (lock_owner) {
get_mutex_unlock(v, 1);
}
#endif
JOB_DONE:
if (rval) {
p_throw_error(rval, NULL);
}
}
void *vect_pop(ivector v) {
void *item = NULL;
zvect_retval rval = p_vect_check(v);
if (rval) {
goto JOB_DONE;
}
#if (ZVECT_THREAD_SAFE == 1)
zvect_retval lock_owner = (locking_disabled || (v->flags & ZV_NOLOCKING)) ? 0 : get_mutex_lock(v, 1);
#endif
zvect_index vsize = p_vect_size(v);
if (vsize != 0) {
rval = p_vect_remove_at(v, vsize - 1, &item);
}
#if (ZVECT_THREAD_SAFE == 1)
if (lock_owner) {
get_mutex_unlock(v, 1);
}
#endif
JOB_DONE:
if (rval) {
p_throw_error(rval, NULL);
}
return item;
}
void *vect_remove(ivector v) {
void *item = NULL;
zvect_retval rval = p_vect_check(v);
if (rval) {
goto JOB_DONE;
}
#if (ZVECT_THREAD_SAFE == 1)
zvect_retval lock_owner = (locking_disabled || (v->flags & ZV_NOLOCKING)) ? 0 : get_mutex_lock(v, 1);
#endif
zvect_index vsize = p_vect_size(v);
if (vsize != 0) {
rval = p_vect_remove_at(v, vsize - 1, &item);
}
#if (ZVECT_THREAD_SAFE == 1)
if (lock_owner) {
get_mutex_unlock(v, 1);
}
#endif
JOB_DONE:
if (rval) {
p_throw_error(rval, NULL);
}
return item;
}
void *vect_remove_at(ivector v, const zvect_index i) {
void *item = NULL;
zvect_retval rval = p_vect_check(v);
if (rval) {
goto JOB_DONE;
}
#if (ZVECT_THREAD_SAFE == 1)
zvect_retval lock_owner = (locking_disabled || (v->flags & ZV_NOLOCKING)) ? 0 : get_mutex_lock(v, 1);
#endif
if (p_vect_size(v) != 0) {
rval = p_vect_remove_at(v, i, &item);
}
#if (ZVECT_THREAD_SAFE == 1)
if (lock_owner) {
get_mutex_unlock(v, 1);
}
#endif
JOB_DONE:
if (rval) {
p_throw_error(rval, NULL);
}
return item;
}
void *vect_remove_front(ivector v) {
void *item = NULL;
zvect_retval rval = p_vect_check(v);
if (rval) {
goto JOB_DONE;
}
#if (ZVECT_THREAD_SAFE == 1)
zvect_retval lock_owner = (locking_disabled || (v->flags & ZV_NOLOCKING)) ? 0 : get_mutex_lock(v, 1);
#endif
if (p_vect_size(v) != 0) {
rval = p_vect_remove_at(v, 0, &item);
}
#if (ZVECT_THREAD_SAFE == 1)
if (lock_owner) {
get_mutex_unlock(v, 1);
}
#endif
JOB_DONE:
if (rval) {
p_throw_error(rval, NULL);
}
return item;
}
// Delete an item at the END of the vector
void vect_delete(ivector v) {
zvect_retval rval = p_vect_check(v);
if (rval) {
goto JOB_DONE;
}
#if (ZVECT_THREAD_SAFE == 1)
zvect_retval lock_owner = (locking_disabled || (v->flags & ZV_NOLOCKING)) ? 0 : get_mutex_lock(v, 1);
#endif
rval = p_vect_delete_at(v, p_vect_size(v) - 1, 0, 1);
#if (ZVECT_THREAD_SAFE == 1)
if (lock_owner) {
get_mutex_unlock(v, 1);
}
#endif
JOB_DONE:
if (rval) {
p_throw_error(rval, NULL);
}
}
// Delete an item at position "i" on the vector
void vect_delete_at(const c_vector v, const zvect_index i) {
zvect_retval rval = p_vect_check(v);
if (rval) {
goto JOB_DONE;
}
#if (ZVECT_THREAD_SAFE == 1)
zvect_retval lock_owner = (locking_disabled || (v->flags & ZV_NOLOCKING)) ? 0 : get_mutex_lock(v, 1);
#endif
rval = p_vect_delete_at(v, i, 0, 1);
#if (ZVECT_THREAD_SAFE == 1)
if (lock_owner) {
get_mutex_unlock(v, 1);
}
#endif
JOB_DONE:
if (rval) {
p_throw_error(rval, NULL);
}
}
// Delete a range of items from "first_element" to "last_element" on the vector
// v
void vect_delete_range(ivector v, const zvect_index first_element, const zvect_index last_element) {
zvect_retval rval = p_vect_check(v);
if (rval) {
goto JOB_DONE;
}
#if (ZVECT_THREAD_SAFE == 1)
zvect_retval lock_owner = (locking_disabled || (v->flags & ZV_NOLOCKING)) ? 0 : get_mutex_lock(v, 1);
#endif
zvect_index end = (last_element - first_element);
rval = p_vect_delete_at(v, first_element, end, 1);
#if (ZVECT_THREAD_SAFE == 1)
if (lock_owner) {
get_mutex_unlock(v, 1);
}
#endif
JOB_DONE:
if (rval) {
p_throw_error(rval, NULL);
}
}
// Delete an item at the BEGINNING of a vector v
void vect_delete_front(ivector v) {
zvect_retval rval = p_vect_check(v);
if (rval) {
goto JOB_DONE;
}
#if (ZVECT_THREAD_SAFE == 1)
zvect_retval lock_owner = (locking_disabled || (v->flags & ZV_NOLOCKING)) ? 0 : get_mutex_lock(v, 1);
#endif
rval = p_vect_delete_at(v, 0, 0, 1);
#if (ZVECT_THREAD_SAFE == 1)
if (lock_owner) {
get_mutex_unlock(v, 1);
}
#endif
JOB_DONE:
if (rval) {
p_throw_error(rval, NULL);
}
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
// Vector Data Manipulation functions
#ifdef ZVECT_DMF_EXTENSIONS
void vect_swap(ivector v, const zvect_index i1, const zvect_index i2) {
// Check parameters:
if (i1 == i2) {
return;
}
// check if the vector exists:
zvect_retval rval = p_vect_check(v);
if (rval) {
goto JOB_DONE;
}
#if (ZVECT_THREAD_SAFE == 1)
zvect_retval lock_owner = (locking_disabled || (v->flags & ZV_NOLOCKING)) ? 0 : get_mutex_lock(v, 1);
#endif
// Check parameters:
zvect_index vsize = p_vect_size(v);
if (i1 > vsize || i2 > vsize) {
rval = ZVERR_IDXOUTOFBOUND;
goto DONE_PROCESSING;
}
// Let's swap items:
void *temp = v->data[v->begin + i2];
v->data[v->begin + i2] = v->data[v->begin + i1];
v->data[v->begin + i1] = temp;
DONE_PROCESSING:
#if (ZVECT_THREAD_SAFE == 1)
if (lock_owner) {
get_mutex_unlock(v, 1);
}
#endif
JOB_DONE:
if (rval) {
p_throw_error(rval, NULL);
}
}
void vect_swap_range(ivector v, const zvect_index s1, const zvect_index e1, const zvect_index s2) {
// Check parameters:
if (s1 == s2) {
return;
}
zvect_index end = e1;
if (e1 != 0) {
end = e1 - s1;
}
// check if the vector exists:
zvect_retval rval = p_vect_check(v);
if (rval) {
goto JOB_DONE;
}
#if (ZVECT_THREAD_SAFE == 1)
zvect_retval lock_owner = (locking_disabled || (v->flags & ZV_NOLOCKING)) ? 0 : get_mutex_lock(v, 1);
#endif
zvect_index vsize = p_vect_size(v);
if ((s1 + end) > vsize || (s2 + end) > vsize || s2 < (s1 + end)) {
rval = ZVERR_IDXOUTOFBOUND;
goto DONE_PROCESSING;
}
// Let's swap items:
register zvect_index i;
for (register zvect_index j = s1; j <= (s1 + end); j++) {
i = j - s1;
void *temp = v->data[v->begin + j];
v->data[v->begin + j] = v->data[v->begin + (s2 + i)];
v->data[v->begin + (s2 + i)] = temp;
}
DONE_PROCESSING:
#if (ZVECT_THREAD_SAFE == 1)
if (lock_owner) {
get_mutex_unlock(v, 1);
}
#endif
JOB_DONE:
if (rval) {
p_throw_error(rval, NULL);
}
}
void vect_rotate_left(ivector v, const zvect_index i) {
// check if the vector exists:
zvect_retval rval = p_vect_check(v);
if (rval) {
goto JOB_DONE;
}
#if (ZVECT_THREAD_SAFE == 1)
zvect_retval lock_owner = (locking_disabled || (v->flags & ZV_NOLOCKING)) ? 0 : get_mutex_lock(v, 1);
#endif
// Check parameters:
zvect_index vsize = p_vect_size(v);
if (i == 0 || i == vsize) {
goto DONE_PROCESSING;
}
if (i > vsize) {
rval = ZVERR_IDXOUTOFBOUND;
goto DONE_PROCESSING;
}
// Process the vector
if (i == 1) {
// Rotate left the vector of 1 position:
void *temp = v->data[0];
p_vect_memmove(v->data, v->data + 1, sizeof(void *) * (vsize - 1));
v->data[vsize - 1] = temp;
} else {
void **new_data = (void **)malloc(sizeof(void *) * p_vect_capacity(v));
if (new_data == NULL) {
rval = ZVERR_OUTOFMEM;
goto DONE_PROCESSING;
}
// Rotate left the vector of "i" positions:
p_vect_memcpy(new_data + v->begin, v->data + v->begin, sizeof(void *) * i);
p_vect_memmove(v->data + v->begin, v->data + v->begin + i, sizeof(void *) * (vsize - i));
p_vect_memcpy(v->data + v->begin + (vsize - i), new_data + v->begin, sizeof(void *) * i);
free(new_data);
}
DONE_PROCESSING:
#if (ZVECT_THREAD_SAFE == 1)
if (lock_owner) {
get_mutex_unlock(v, 1);
}
#endif
JOB_DONE:
if (rval) {
p_throw_error(rval, NULL);
}
}
void vect_rotate_right(ivector v, const zvect_index i) {
// check if the vector exists:
zvect_retval rval = p_vect_check(v);
if (rval) {
goto JOB_DONE;
}
#if (ZVECT_THREAD_SAFE == 1)
zvect_retval lock_owner = (locking_disabled || (v->flags & ZV_NOLOCKING)) ? 0 : get_mutex_lock(v, 1);
#endif
// Check parameters:
zvect_index vsize = p_vect_size(v);
if (i == 0 || i == vsize) {
goto DONE_PROCESSING;
}
if (i > vsize) {
rval = ZVERR_IDXOUTOFBOUND;
goto DONE_PROCESSING;
}
// Process the vector
if (i == 1) {
// Rotate right the vector of 1 position:
void *temp = v->data[v->begin + p_vect_size(v) - 1];
p_vect_memmove(v->data + v->begin + 1, v->data + v->begin, sizeof(void *) * (vsize - 1));
v->data[v->begin] = temp;
} else {
void **new_data = (void **)malloc(sizeof(void *) * p_vect_capacity(v));
if (new_data == NULL) {
rval = ZVERR_OUTOFMEM;
goto DONE_PROCESSING;
}
// Rotate right the vector of "i" positions:
p_vect_memcpy(new_data + v->begin, v->data + v->begin + (p_vect_size(v) - i), sizeof(void *) * i);
p_vect_memmove(v->data + v->begin + i, v->data + v->begin, sizeof(void *) * (vsize - i));
p_vect_memcpy(v->data + v->begin, new_data + v->begin, sizeof(void *) * i);
free(new_data);
}
DONE_PROCESSING:
#if (ZVECT_THREAD_SAFE == 1)
if (lock_owner) {
get_mutex_unlock(v, 1);
}
#endif
JOB_DONE:
if (rval) {
p_throw_error(rval, NULL);
}
}
#ifdef TRADITIONAL_QSORT
static inline zvect_index p_partition(c_vector v,
zvect_index low,
zvect_index high,
int (*compare_func)(const void *, const void *)) {
if (high >= p_vect_size(v)) {
high = p_vect_size(v) - 1;
}
void *pivot = v->data[v->begin + high];
zvect_index i = (low - 1);
for (register zvect_index j = low; j <= (high - 1); j++) {
// v->data[j] <= pivot
if ((*compare_func)(v->data[v->begin + j], pivot) <= 0) {
vect_swap(v, ++i, j);
}
}
vect_swap(v, i + 1, high);
return (i + 1);
}
static void p_vect_qsort(c_vector v,
zvect_index low,
zvect_index high,
int (*compare_func)(const void *, const void *)) {
if (low < high) {
zvect_index pi = p_partition(v, low, high, compare_func);
p_vect_qsort(v, low, pi - 1, compare_func);
p_vect_qsort(v, pi + 1, high, compare_func);
}
}
#endif // TRADITIONAL_QSORT
#ifndef TRADITIONAL_QSORT
// This is my much faster implementation of a quicksort algorithm
// it fundamentally uses the 3 ways partitioning adapted and improved
// to deal with arrays of pointers together with having a custom
// compare function:
static void p_vect_qsort(const c_vector v,
zvect_index l,
zvect_index r,
int (*compare_func)(const void *, const void *)) {
if (r <= l) {
return;
}
zvect_index i;
zvect_index p;
zvect_index j;
zvect_index q;
void *ref_val = NULL;
// l = left (also low)
if (l > 0) {
i = l - 1;
} else {
i = l;
}
// r = right (also high)
j = r;
p = i;
q = r;
ref_val = v->data[v->begin + r];
for (;;) {
while ((*compare_func)(v->data[v->begin + i], ref_val) < 0) {
i++;
}
while ((*compare_func)(ref_val, v->data[(--j) + v->begin]) < 0) {
if (j == l) {
break;
}
}
if (i >= j) {
break;
}
vect_swap(v, i, j);
if ((*compare_func)(v->data[v->begin + i], ref_val) == 0) {
p++;
vect_swap(v, p, i);
}
if ((*compare_func)(ref_val, v->data[v->begin + j]) == 0) {
q--;
vect_swap(v, q, j);
}
}
vect_swap(v, i, r);
j = i - 1;
i = i + 1;
register zvect_index k;
for (k = l; k < p; k++, j--) {
vect_swap(v, k, j);
}
for (k = r - 1; k > q; k--, i++) {
vect_swap(v, k, i);
}
p_vect_qsort(v, l, j, compare_func);
p_vect_qsort(v, i, r, compare_func);
}
#endif // ! TRADITIONAL_QSORT
void vect_qsort(const c_vector v, int (*compare_func)(const void *, const void *)) {
// Check parameters:
if (compare_func == NULL) {
return;
}
zvect_retval rval = p_vect_check(v);
if (rval) {
goto JOB_DONE;
}
#if (ZVECT_THREAD_SAFE == 1)
zvect_retval lock_owner = (locking_disabled || (v->flags & ZV_NOLOCKING)) ? 0 : get_mutex_lock(v, 1);
#endif
zvect_index vsize = p_vect_size(v);
if (vsize <= 1) {
goto DONE_PROCESSING;
}
// Process the vector:
p_vect_qsort(v, 0, vsize - 1, compare_func);
DONE_PROCESSING:
#if (ZVECT_THREAD_SAFE == 1)
if (lock_owner) {
get_mutex_unlock(v, 1);
}
#endif
JOB_DONE:
if (rval) {
p_throw_error(rval, NULL);
}
}
#ifdef TRADITIONAL_BINARY_SEARCH
static bool p_standard_binary_search(c_vector v,
const void *key,
zvect_index *item_index,
int (*f1)(const void *, const void *)) {
zvect_index bot, top;
bot = 0;
top = p_vect_size(v) - 1;
while (bot < top) {
zvect_index mid // mid-point
mid = top - (top - bot) / 2;
// key < array[mid]
if ((*f1)(key, v->data[v->begin + mid]) < 0) {
top = mid - 1;
} else {
bot = mid;
}
}
// key == array[top]
if ((*f1)(key, v->data[v->begin + top]) == 0) {
*item_index = top;
return true;
}
*item_index = top;
return false;
}
#endif // TRADITIONAL_BINARY_SEARCH
#ifndef TRADITIONAL_BINARY_SEARCH
// This is my re-implementation of Igor van den Hoven's Adaptive
// Binary Search algorithm. It has few improvements over the
// original design, most notably the use of custom compare
// function that makes it suitable also to search through strings
// and other types of vectors.
static bool p_adaptive_binary_search(ivector v,
const void *key,
zvect_index *item_index,
int (*f1)(const void *, const void *)) {
zvect_index bot;
zvect_index top;
zvect_index mid;
if ((v->balance >= 32) || (p_vect_size(v) <= 64)) {
bot = 0;
top = p_vect_size(v);
goto MONOBOUND;
}
bot = v->bottom;
top = 32;
// key >= array[bot]
if ((*f1)(key, v->data[v->begin + bot]) >= 0) {
while (1) {
if ((bot + top) >= p_vect_size(v)) {
top = p_vect_size(v) - bot;
break;
}
bot += top;
// key < array[bot]
if ((*f1)(key, v->data[v->begin + bot]) < 0) {
bot -= top;
break;
}
top *= 2;
}
} else {
while (1) {
if (bot < top) {
top = bot;
bot = 0;
break;
}
bot -= top;
// key >= array[bot]
if ((*f1)(key, v->data[v->begin + bot]) >= 0) {
break;
}
top *= 2;
}
}
MONOBOUND:
while (top > 3) {
mid = top / 2;
// key >= array[bot + mid]
if ((*f1)(key, v->data[v->begin + (bot + mid)]) >= 0) {
bot += mid;
}
top -= mid;
}
v->balance = v->bottom > bot ? v->bottom - bot : bot - v->bottom;
v->bottom = bot;
while (top) {
// key == array[bot + --top]
int test = (*f1)(key, v->data[v->begin + (bot + (--top))]);
if (test == 0) {
*item_index = bot + top;
return true;
} else if (test > 0) {
*item_index = bot + (top + 1);
return false;
}
}
*item_index = bot + top;
return false;
}
#endif // ! TRADITIONAL_BINARY_SEARCH
bool vect_bsearch(ivector v, const void *key, int (*f1)(const void *, const void *), zvect_index *item_index) {
// Check parameters:
if ((key == NULL) || (f1 == NULL) || (p_vect_size(v) == 0)) {
return false;
}
*item_index = 0;
// check if the vector exists:
zvect_retval rval = p_vect_check(v);
if (rval) {
goto JOB_DONE;
}
// TODO: Add mutex locking
#ifdef TRADITIONAL_BINARY_SEARCH
if (p_standard_binary_search(v, key, item_index, f1)) {
return true;
} else {
*item_index = 0;
return false;
}
#endif // TRADITIONAL_BINARY_SEARCH
#ifndef TRADITIONAL_BINARY_SEARCH
if (p_adaptive_binary_search(v, key, item_index, f1)) {
return true;
} else {
*item_index = 0;
return false;
}
#endif // ! TRADITIONAL_BINARY_SEARCH
// DONE_PROCESSING:
// TODO: Add mutex unlock
JOB_DONE:
if (rval) {
p_throw_error(rval, NULL);
}
return false;
}
/*
* Although if the vect_add_* doesn't belong to this group of
* functions, the vect_add_ordered is an exception because it
* requires vect_bserach and vect_qsort to be available.
*/
void vect_add_ordered(ivector v, const void *value, int (*f1)(const void *, const void *)) {
// Check parameters:
if (value == NULL) {
return;
}
// check if the vector exists:
zvect_retval rval = p_vect_check(v);
if (rval) {
goto JOB_DONE;
}
#if (ZVECT_THREAD_SAFE == 1)
zvect_retval lock_owner = (locking_disabled || (v->flags & ZV_NOLOCKING)) ? 0 : get_mutex_lock(v, 2);
#endif
// Few tricks to make it faster:
zvect_index vsize = p_vect_size(v);
if (vsize == 0) {
// If the vector is empty clearly we can just
// use vect_add and add the value normally!
vect_add(v, value);
goto DONE_PROCESSING;
}
if ((*f1)(value, v->data[v->begin + (vsize - 1)]) > 0) {
// If the compare function returns that
// the value passed should go after the
// last value in the vector, just do so!
vect_add(v, value);
goto DONE_PROCESSING;
}
// Ok previous checks didn't help us, so we need
// to get "heavy weapons" out and find where in
// the vector we should add "value":
zvect_index item_index = 0;
// Here is another trick:
// I improved adaptive binary search to ALWAYS
// return an index (even when it doesn't find a
// searched item), this works for both: regular
// searches which will also use the bool to
// know if we actually found the item in that
// item_index or not and the vect_add_ordered
// which will use item_index (which will be the
// place where value should have been) to insert
// value as an ordered item :)
p_adaptive_binary_search(v, value, &item_index, f1);
vect_add_at(v, value, item_index);
DONE_PROCESSING:
#if (ZVECT_THREAD_SAFE == 1)
if (lock_owner) {
get_mutex_unlock(v, 2);
}
#endif
JOB_DONE:
if (rval) {
p_throw_error(rval, NULL);
}
}
#endif // ZVECT_DMF_EXTENSIONS
#ifdef ZVECT_SFMD_EXTENSIONS
// Single Function Call Multiple Data operations extensions:
void vect_apply(ivector v, void (*f)(void *)) {
// Check Parameters:
if (f == NULL) {
return;
}
zvect_retval rval = p_vect_check(v);
if (rval) {
goto JOB_DONE;
}
#if (ZVECT_THREAD_SAFE == 1)
zvect_retval lock_owner = (locking_disabled || (v->flags & ZV_NOLOCKING)) ? 0 : get_mutex_lock(v, 1);
#endif
// Process the vector:
for (register zvect_index i = p_vect_size(v); i--;) {
(*f)(v->data[v->begin + i]);
}
// DONE_PROCESSING:
#if (ZVECT_THREAD_SAFE == 1)
if (lock_owner) {
get_mutex_unlock(v, 1);
}
#endif
JOB_DONE:
if (rval) {
p_throw_error(rval, NULL);
}
}
void vect_apply_range(ivector v, void (*f)(void *), const zvect_index x, const zvect_index y) {
// Check parameters:
if (f == NULL) {
return;
}
// check if the vector exists:
zvect_retval rval = p_vect_check(v);
if (rval) {
goto JOB_DONE;
}
#if (ZVECT_THREAD_SAFE == 1)
zvect_retval lock_owner = (locking_disabled || (v->flags & ZV_NOLOCKING)) ? 0 : get_mutex_lock(v, 1);
#endif
if (x > p_vect_size(v) || y > p_vect_size(v)) {
rval = ZVERR_IDXOUTOFBOUND;
goto DONE_PROCESSING;
}
zvect_index start;
zvect_index end;
if (x > y) {
start = x;
end = y;
} else {
start = y;
end = x;
}
// Process the vector:
for (register zvect_index i = start; i <= end; i++) {
(*f)(v->data[v->begin + i]);
}
DONE_PROCESSING:
#if (ZVECT_THREAD_SAFE == 1)
if (lock_owner) {
get_mutex_unlock(v, 1);
}
#endif
JOB_DONE:
if (rval) {
p_throw_error(rval, NULL);
}
}
void vect_apply_if(ivector v1, ivector v2, void (*f1)(void *), bool (*f2)(void *, void *)) {
// Check parameters:
if (f1 == NULL || f2 == NULL) {
return;
}
// check if the vector exists:
zvect_retval rval = p_vect_check(v1) | p_vect_check(v2);
if (rval) {
goto JOB_DONE;
}
#if (ZVECT_THREAD_SAFE == 1)
zvect_retval lock_owner = (locking_disabled || (v1->flags & ZV_NOLOCKING)) ? 0 : get_mutex_lock(v1, 1);
#endif
// Check parameters:
if (p_vect_size(v1) > p_vect_size(v2)) {
rval = ZVERR_VECTTOOSMALL;
goto DONE_PROCESSING;
}
// Process vectors:
for (register zvect_index i = p_vect_size(v1); i--;) {
if ((*f2)(v1->data[v1->begin + i], v2->data[v2->begin + i])) {
(*f1)(v1->data[v1->begin + i]);
}
}
DONE_PROCESSING:
#if (ZVECT_THREAD_SAFE == 1)
if (lock_owner) {
get_mutex_unlock(v1, 1);
}
#endif
JOB_DONE:
if (rval) {
p_throw_error(rval, NULL);
}
}
void vect_copy(ivector v1, ivector v2, const zvect_index s2, const zvect_index e2) {
// check if the vectors v1 and v2 exist:
zvect_retval rval = p_vect_check(v1) | p_vect_check(v2);
if (rval) {
goto JOB_DONE;
}
#if (ZVECT_THREAD_SAFE == 1)
zvect_retval lock_owner = (locking_disabled || (v1->flags & ZV_NOLOCKING)) ? 0 : get_mutex_lock(v1, 2);
#endif
// We can only copy vectors with the same data_size!
if (v1->data_size != v2->data_size) {
rval = ZVERR_VECTDATASIZE;
goto DONE_PROCESSING;
}
// Let's check if the indexes provided are correct for
// v2:
if (e2 > p_vect_size(v2) || s2 > p_vect_size(v2)) {
rval = ZVERR_IDXOUTOFBOUND;
goto DONE_PROCESSING;
}
// If the user specified 0 max_elements then
// copy the entire vector from start position
// till the last item in the vector 2:
zvect_index ee2;
if (e2 == 0) {
ee2 = (p_vect_size(v2) - 1) - s2;
} else {
ee2 = e2;
}
// Set the correct capacity for v1 to get the whole v2:
while (p_vect_capacity(v1) <= (p_vect_size(v1) + ee2)) {
p_vect_increase_capacity(v1, 1);
}
// Copy v2 (from s2) in v1 at the end of v1:
p_vect_memcpy(v1->data + v1->begin + p_vect_size(v1), v2->data + v2->begin + s2, sizeof(void *) * ee2);
// Update v1 size:
v1->end += ee2;
DONE_PROCESSING:
#if (ZVECT_THREAD_SAFE == 1)
if (lock_owner) {
get_mutex_unlock(v1, 2);
}
#endif
JOB_DONE:
if (rval) {
p_throw_error(rval, NULL);
}
}
/*
* vect_insert inserts the specified number of elements
* from vector v2 (from position s2) in vector v1 (from
* position s1).
*
*/
void vect_insert(ivector v1, ivector v2, const zvect_index s2, const zvect_index e2, const zvect_index s1) {
// check if the vectors v1 and v2 exist:
zvect_retval rval = p_vect_check(v1) | p_vect_check(v2);
if (rval) {
goto JOB_DONE;
}
#if (ZVECT_THREAD_SAFE == 1)
zvect_retval lock_owner = (locking_disabled || (v1->flags & ZV_NOLOCKING)) ? 0 : get_mutex_lock(v1, 2);
#endif
// We can only copy vectors with the same data_size!
if (v1->data_size != v2->data_size) {
rval = ZVERR_VECTDATASIZE;
goto DONE_PROCESSING;
}
// Let's check if the indexes provided are correct for
// v2:
if ((e2 > p_vect_size(v2)) || (s2 > p_vect_size(v2))) {
rval = ZVERR_IDXOUTOFBOUND;
goto DONE_PROCESSING;
}
// If the user specified 0 max_elements then
// copy the entire vector from start position
// till the last item in the vector 2:
zvect_index ee2;
if (e2 == 0) {
ee2 = (p_vect_size(v2) - 1) - s2;
} else {
ee2 = e2;
}
// Process vectors:
if (ee2 > 1) {
// Number of rows to insert is large, so let's use
// memmove:
// Set the correct capacity for v1 to get data from v2:
if (p_vect_capacity(v1) <= (p_vect_size(v1) + ee2)) {
p_vect_set_capacity(v1, 1, p_vect_capacity(v1) + ee2);
}
const void *rptr = NULL;
// Reserve appropriate space in the destination vector
rptr = p_vect_memmove(v1->data + (v1->begin + s1 + ee2),
v1->data + (v1->begin + s1),
sizeof(void *) * (p_vect_size(v1) - s1));
if (rptr == NULL) {
rval = ZVERR_VECTCORRUPTED;
goto DONE_PROCESSING;
}
// Copy items from v2 to v1 at location s1:
rptr = p_vect_memcpy(v1->data + (v1->begin + s1), v2->data + (v2->begin + s2), sizeof(void *) * ee2);
if (rptr == NULL) {
rval = ZVERR_VECTCORRUPTED;
goto DONE_PROCESSING;
}
// Update v1 size:
v1->end += ee2;
} else {
// Number of rows to insert is small
// so let's use vect_Add_at:
register zvect_index j = 0;
// Copy v2 items (from s2) in v1 (from s1):
for (register zvect_index i = s2; i <= s2 + ee2; i++, j++) {
vect_add_at(v1, v2->data[v2->begin + i], s1 + j);
}
goto DONE_PROCESSING;
}
rval = p_vect_delete_at(v2, s2, ee2 - 1, 0);
DONE_PROCESSING:
#if (ZVECT_THREAD_SAFE == 1)
if (lock_owner) {
get_mutex_unlock(v1, 2);
}
#endif
JOB_DONE:
if (rval) {
p_throw_error(rval, NULL);
}
}
/*
* vect_move moves the specified number of elements
* from vector v2 (from position s2) in vector v1 (at
* the end of it).
*
*/
static inline zvect_retval p_vect_move(ivector v1, c_vector v2, const zvect_index s2, const zvect_index e2) {
zvect_retval rval = 0;
#ifdef DEBUG
log_msg(ZVLP_INFO, "p_vect_move: move pointers set from v2 to v1\n");
#endif
// We can only copy vectors with the same data_size!
if (v1->data_size != v2->data_size) {
return ZVERR_VECTDATASIZE;
}
// Let's check if the indexes provided are correct for
// v2:
if ((e2 > p_vect_size(v2)) || (s2 > p_vect_size(v2))) {
return ZVERR_IDXOUTOFBOUND;
}
// If the user specified 0 max_elements then
// move the entire vector from start position
// till the last item in the vector 2:
zvect_index ee2;
if (e2 == 0) {
ee2 = (p_vect_size(v2) - 1) - s2;
} else {
ee2 = e2;
}
#ifdef DEBUG
log_msg(ZVLP_INFO,
"p_vect_move: v2 capacity = %*u, begin = %*u, end = %*u, size = %*u, "
"s2 = %*u, ee2 = %*u\n",
10,
p_vect_capacity(v2),
10,
v2->begin,
10,
v2->end,
10,
p_vect_size(v2),
10,
s2,
10,
ee2);
log_msg(ZVLP_INFO,
"p_vect_move: v1 capacity = %*u, begin = %*u, end = %*u, size = %*u\n",
10,
p_vect_capacity(v1),
10,
v1->begin,
10,
v1->end,
10,
p_vect_size(v1));
#endif
// Set the correct capacity for v1 to get the whole v2:
if (p_vect_capacity(v1) <= (p_vect_size(v1) + ee2)) {
p_vect_set_capacity(v1, 1, p_vect_capacity(v1) + ee2);
}
#ifdef DEBUG
log_msg(ZVLP_INFO,
"p_vect_move: v1 capacity = %*u, begin = %*u, end = %*u, size = %*u\n",
10,
p_vect_capacity(v1),
10,
v1->begin,
10,
v1->end,
10,
p_vect_size(v1));
log_msg(ZVLP_INFO, "p_vect_move: ready to copy pointers set\n");
#endif
// Move v2 (from s2) in v1 at the end of v1:
const void *rptr = NULL;
if (v1 != v2) {
rptr = p_vect_memcpy(v1->data + (v1->begin + p_vect_size(v1)),
v2->data + (v2->begin + s2),
sizeof(void *) * ee2);
} else {
rptr = p_vect_memmove(v1->data + (v1->begin + p_vect_size(v1)),
v2->data + (v2->begin + s2),
sizeof(void *) * ee2);
}
if (rptr == NULL) {
rval = ZVERR_VECTCORRUPTED;
goto DONE_PROCESSING;
}
// Update v1 size:
v1->end += ee2;
#ifdef DEBUG
log_msg(ZVLP_INFO, "p_vect_move: done copy pointers set\n");
#endif
// Clean up v2 memory slots that no longer belong to v2:
// rval = p_vect_delete_at(v2, s2, ee2 - 1, 0);
DONE_PROCESSING:
#ifdef DEBUG
log_msg(ZVLP_INFO,
"p_vect_move: v1 capacity = %*u, begin = %*u, end = %*u, size = %*u\n",
10,
p_vect_capacity(v1),
10,
v1->begin,
10,
v1->end,
10,
p_vect_size(v1));
log_msg(ZVLP_INFO,
"p_vect_move: v2 capacity = %*u, begin = %*u, end = %*u, size = %*u\n",
10,
p_vect_capacity(v2),
10,
v2->begin,
10,
v2->end,
10,
p_vect_size(v2));
#endif
return rval;
}
// END of p_vect_move
//////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////
// vect_move moves a portion of a vector (v2) into another (v1):
void vect_move(ivector v1, c_vector v2, const zvect_index s2, const zvect_index e2) {
// check if the vectors v1 and v2 exist:
zvect_retval rval = p_vect_check(v1) | p_vect_check(v2);
if (rval) {
goto JOB_DONE;
}
#if (ZVECT_THREAD_SAFE == 1)
// vect_move modifies both vectors, so has to lock them both (if needed)
zvect_retval lock_owner2 = (locking_disabled || (v2->flags & ZV_NOLOCKING)) ? 0 : get_mutex_lock(v2, 1);
zvect_retval lock_owner1 = (locking_disabled || (v1->flags & ZV_NOLOCKING)) ? 0 : get_mutex_lock(v1, 1);
#endif
#ifdef DEBUG
log_msg(ZVLP_INFO, "vect_move: --- begin ---\n");
#if (ZVECT_THREAD_SAFE == 1)
log_msg(ZVLP_INFO, "vect_move: lock_owner1 for vector v1: %*u\n", 10, lock_owner1);
log_msg(ZVLP_INFO, "vect_move: lock_owner2 for vector v2: %*u\n", 10, lock_owner2);
#endif // ZVECT_THREAD_SAFE
#endif
// We can only copy vectors with the same data_size!
if (v1->data_size != v2->data_size) {
rval = ZVERR_VECTDATASIZE;
goto DONE_PROCESSING;
}
rval = p_vect_move(v1, v2, s2, e2);
DONE_PROCESSING:
#if (ZVECT_THREAD_SAFE == 1)
if (lock_owner1) {
get_mutex_unlock(v1, 1);
}
rval = p_vect_delete_at(v2, s2, e2 - 1, 0);
if (lock_owner2) {
get_mutex_unlock(v2, 1);
}
#endif
#ifdef DEBUG
log_msg(ZVLP_INFO, "vect_move: --- end ---\n");
#endif
JOB_DONE:
if (rval) {
p_throw_error(rval, NULL);
}
}
/////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////
// vect_move_if moves a portion of a vector (v2) into another (v1) if f2 is
// true:
zvect_retval vect_move_if(ivector v1,
c_vector v2,
const zvect_index s2,
const zvect_index e2,
zvect_retval (*f2)(void *, void *)) {
// check if the vectors v1 and v2 exist:
zvect_retval rval = p_vect_check(v1) | p_vect_check(v2);
if (rval) {
goto JOB_DONE;
}
#if (ZVECT_THREAD_SAFE == 1)
// vect_move modifies both vectors, so has to lock them both (if needed)
zvect_retval lock_owner2 = (locking_disabled || (v2->flags & ZV_NOLOCKING)) ? 0 : get_mutex_lock(v2, 1);
zvect_retval lock_owner1 = (locking_disabled || (v1->flags & ZV_NOLOCKING)) ? 0 : get_mutex_lock(v1, 1);
#endif
#ifdef DEBUG
log_msg(ZVLP_INFO, "vect_move_if: --- begin ---\n");
#if (ZVECT_THREAD_SAFE == 1)
log_msg(ZVLP_INFO, "vect_move_if: lock_owner1 for vector v1: %*u\n", 10, lock_owner1);
log_msg(ZVLP_INFO, "vect_move_if: lock_owner2 for vector v2: %*u\n", 10, lock_owner2);
#endif // ZVECT_THREAD_SAFE
#endif
// We can only move vectors with the same data_size!
if (v1->data_size != v2->data_size) {
rval = ZVERR_VECTDATASIZE;
goto DONE_PROCESSING;
}
rval = (*f2)(v1, v2) ? p_vect_move(v1, v2, s2, e2) : 1;
DONE_PROCESSING:
#if (ZVECT_THREAD_SAFE == 1)
if (lock_owner1) {
get_mutex_unlock(v1, 1);
}
rval = p_vect_delete_at(v2, s2, e2 - 1, 0);
if (lock_owner2) {
get_mutex_unlock(v2, 1);
}
#endif
#ifdef DEBUG
log_msg(ZVLP_INFO, "vect_move_if: --- end ---\n");
#endif
JOB_DONE:
if (rval && (rval != 1)) {
p_throw_error(rval, NULL);
}
return rval;
}
/////////////////////////////////////////////////////////////////
#if (ZVECT_THREAD_SAFE == 1)
/////////////////////////////////////////////////////////////////
// vect_move_on_signal
zvect_retval vect_move_on_signal(ivector v1,
c_vector v2,
const zvect_index s2,
const zvect_index e2,
zvect_retval (*f2)(void *, void *)) {
// check if the vectors v1 and v2 exist:
zvect_retval rval = p_vect_check(v1) | p_vect_check(v2);
if (rval) {
goto JOB_DONE;
}
// vect_move modifies both vectors, so has to lock them both (if needed)
zvect_retval lock_owner2 = (locking_disabled || (v2->flags & ZV_NOLOCKING)) ? 0 : get_mutex_lock(v2, 1);
zvect_retval lock_owner1 = (locking_disabled || (v1->flags & ZV_NOLOCKING)) ? 0 : get_mutex_lock(v1, 1);
#ifdef DEBUG
log_msg(ZVLP_MEDIUM, "vect_move_on_signal: --- start waiting ---\n");
#endif
// wait until we get a signal
while (!(*f2)(v1, v2) && !(v2->status)) {
pthread_cond_wait(&(v2->cond), &(v2->lock));
}
v2->status &= ~(ZVS_USR1_FLAG);
// v2->status |= ZVS_USR_FLAG;
#ifdef DEBUG
log_msg(ZVLP_MEDIUM, "Set status flag: %*i\n", 10, vect_check_status(v2, 1));
log_msg(ZVLP_MEDIUM, "vect_move_on_signal: --- received signal ---\n");
log_msg(ZVLP_MEDIUM, "vect_move_on_signal: --- begin ---\n");
#endif
// Proceed with move items:
rval = p_vect_move(v1, v2, s2, e2);
#ifdef DEBUG
log_msg(ZVLP_MEDIUM, "vect_move_on_signal: --- end ---\n");
#endif
v2->status &= ~(ZVS_USR1_FLAG);
#ifdef DEBUG
log_msg(ZVLP_MEDIUM, "Reset status flag: %*i\n", 10, vect_check_status(v2, 1));
#endif
// DONE_PROCESSING:
#ifdef DEBUG
log_msg(ZVLP_MEDIUM, "v1 owner? %*i\n", 10, lock_owner1);
#endif
if (lock_owner1) {
get_mutex_unlock(v1, 1);
}
#ifdef DEBUG
log_msg(ZVLP_MEDIUM, "v2 owner? %*i\n", 10, lock_owner2);
#endif
rval = p_vect_delete_at(v2, s2, e2 - 1, 0);
if (lock_owner2) {
get_mutex_unlock(v2, 1);
}
JOB_DONE:
if (rval && (rval != 1)) {
p_throw_error(rval, NULL);
}
return rval;
}
#endif // (ZVECT_THREAD_SAFE == 1)
/////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
// vect_merge merges a vector (v2) into another (v1)
void vect_merge(ivector v1, c_vector v2) {
// check if the vector v1 exists:
zvect_retval rval = p_vect_check(v1) | p_vect_check(v2);
if (rval) {
goto JOB_DONE;
}
#if (ZVECT_THREAD_SAFE == 1)
zvect_retval lock_owner1 = (locking_disabled || (v1->flags & ZV_NOLOCKING)) ? 0 : get_mutex_lock(v1, 1);
zvect_retval lock_owner2 = (locking_disabled || (v2->flags & ZV_NOLOCKING)) ? 0 : get_mutex_lock(v2, 1);
#endif
#ifdef DEBUG
log_msg(ZVLP_INFO, "vect_merge: --- begin ---\n");
#if (ZVECT_THREAD_SAFE == 1)
log_msg(ZVLP_INFO, "vect_merge: lock_owner1 for vector v1: %*u\n", 10, lock_owner1);
log_msg(ZVLP_INFO, "vect_merge: lock_owner2 for vector v2: %*u\n", 10, lock_owner2);
#endif // ZVECT_THREAD_SAFE
#endif // DEBUG
// We can only copy vectors with the same data_size!
if (v1->data_size != v2->data_size) {
rval = ZVERR_VECTDATASIZE;
goto DONE_PROCESSING;
}
// Check if the user is trying to merge a vector to itself:
if (v1 == v2) {
rval = ZVERR_OPNOTALLOWED;
goto DONE_PROCESSING;
}
#ifdef DEBUG
log_msg(ZVLP_INFO,
"vect_merge: v2 capacity = %*u, begin = %*u, end: %*u, size = %*u\n",
10,
p_vect_capacity(v2),
10,
v2->begin,
10,
v2->end,
10,
p_vect_size(v2));
log_msg(ZVLP_INFO,
"vect_merge: v1 capacity = %*u, begin = %*u, end: %*u, size = %*u\n",
10,
p_vect_capacity(v1),
10,
v1->begin,
10,
v1->end,
10,
p_vect_size(v1));
#endif
// Set the correct capacity for v1 to get the whole v2:
if (p_vect_capacity(v1) <= (p_vect_size(v1) + p_vect_size(v2))) {
p_vect_set_capacity(v1, 1, p_vect_capacity(v1) + p_vect_size(v2));
}
#ifdef DEBUG
log_msg(ZVLP_INFO,
"vect_merge: v1 capacity = %*u, begin = %*u, end: %*u, size = %*u\n",
10,
p_vect_capacity(v1),
10,
v1->begin,
10,
v1->end,
10,
p_vect_size(v1));
#endif
// Copy the whole v2 in v1 at the end of v1:
p_vect_memcpy(v1->data + (v1->begin + p_vect_size(v1)), v2->data + v2->begin, sizeof(void *) * p_vect_size(v2));
// Update v1 size:
v1->end += p_vect_size(v2);
#ifdef DEBUG
log_msg(ZVLP_INFO,
"vect_merge: v1 capacity = %*u, begin = %*u, end: %*u, size = %*u\n",
10,
p_vect_capacity(v1),
10,
v1->begin,
10,
v1->end,
10,
p_vect_size(v1));
#endif
DONE_PROCESSING:
#if (ZVECT_THREAD_SAFE == 1)
if (lock_owner2) {
get_mutex_unlock(v2, 1);
}
if (!rval) {
rval = p_vect_destroy(v2, 0);
}
if (lock_owner1) {
get_mutex_unlock(v1, 1);
}
#else
rval = p_vect_destroy(v2, 0);
// ^ Because we are merging two vectors in one
// after merged v2 to v1 there is no need for
// v2 to still exists, so let's destroy it to
// free memory correctly.
#endif
#ifdef DEBUG
log_msg(ZVLP_INFO, "vect_merge: --- end ---\n");
#endif
JOB_DONE:
if (rval) {
p_throw_error(rval, NULL);
}
}
// END of vect_merge
#endif
/*---------------------------------------------------------------------------*/
Reference in New Issue View Git Blame Copy Permalink