C Organized Plain Structures

This library implement macro of collections, import once, use anywhere.

Integrated and interchangable collection are:

• Slice (variadic lenght array)
• Vec (dinamyc array)
• List (double linked list)
• Hset (robin hood hash set)
• Tset (red-black tree set)

To mantain usability, clone "cops.h", create you own centered header (like this example "collection.h")

#ifndef COLLETION_H
#define COLLETION_H

// use only in dev, will enable assert instead of handling error
#define COPS_ASSERT_ENABLE
#include "cops.h"

init_slice(int, int_slice);
init_vec(int, int_vec, int_slice);
init_set(int, int_set, int_slice);
init_oset(int, int_oset, int_slice);
#endif /* end guard #define COLLETION_H */

In the main file you should use COPS_IMPLEMENTATION to enable implementation (classic stb-pattern).

#define COPS_IMPLEMENTATION
#include "collection.h"

int main(int argc, char *argv[]) {
//...

This macro shall be used before the #include:

Note: If you declare COPS_ALLOC you should define all three, if not you would encounted undefined behavior

Coherent implementations exist in the library to simplify usage and navigability.

Collection can manage memory. Each collection (except slice) contain two optional function pointer.

• T (*dup)(T): if set, collection return clone.
• void (*free)(T): if set, collection take ownership of input.

COPS relay on consistent API pattern.
int collection_func(NAME *self, [args..], [T *res]);

• Error as result: Posix behavior to communicate status with int return value
• Output parameter: Secondary output could be optionally obtained by T *res who is ignored when NULL

Slice work as intermidiate representation between collections (vec, list, hset, tset).

• collection_export: Create a slice containing all elements (return a borrowed value, if dup is declared return copies)
• collection_import: Bulk-inserts from slice

• pool: memory pool (list of slab allocator), non interoperable
• tset: implement interoperability
• pqueue: priority queue (heap) implementation, interoperable
• mgraph: matric graph (matrix bitmap + node vec) implementation, non interoperable
• lgraph: light graph (node and edge vec) implementation, non interoperable

struct slice {
    uint64_t len;
    T data[];
};

struct vec {
    uint64_t len;
    uint64_t cap;
    T *data;
    void (*free)(T);
    T (*dup)(T);
};

Sorting is not implemented but can be performed in this manner:

#include <stdlib.h>
qsort(self->data, sizeof(*self->data), self->len, my_cmp_func);

struct ll_node {
    ll_node *next;
    ll_node *prev;
    T val;
};
struct list {
    uint64_t len;
    ll_node *head;
    ll_node *tail;
    void (*free)(T);
    T (*dup)(T);
};

struct rh_node {
    uint8_t free: 1;
    uint8_t tomb: 1;
    uint8_t jumps: 6;
    T val;
};
struct list {
    uint64_t len;
    uint64_t cap;
    rh_node *data;
    uint64_t (*hash)(T);
    int (*cmp)(T, T);
    void (*free)(T);
    T (*dup)(T);
};

struct rb_node {
    rb_node *parent;
    rb_node *left;
    rb_node *right;
    uint8_t isred;
    T val;
};

struct list {
    uint64_t len;
    rb_node *root;
    int (*cmp)(T, T);
    void (*free)(T);
    T (*dup)(T);
};