Move everything out of src folder

cmc/hashmultiset/code.h

@@ -0,0 +1,825 @@
+/**
+ * Copyright (c) 2019 Leonardo Vencovsky
+ *
+ * This file is part of the C Macro Collections Library.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+/* Implementation Detail Functions */
+static struct CMC_DEF_ENTRY(SNAME) * CMC_(PFX, _impl_insert_and_return)(struct SNAME *_set_, V value, bool *new_node);
+static struct CMC_DEF_ENTRY(SNAME) * CMC_(PFX, _impl_get_entry)(struct SNAME *_set_, V value);
+static size_t CMC_(PFX, _impl_calculate_size)(size_t required);
+
+struct SNAME *CMC_(PFX, _new)(size_t capacity, double load, struct CMC_DEF_FVAL(SNAME) * f_val)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    return CMC_(PFX, _new_custom)(capacity, load, f_val, NULL, NULL);
+}
+
+struct SNAME *CMC_(PFX, _new_custom)(size_t capacity, double load, struct CMC_DEF_FVAL(SNAME) * f_val,
+                                     CMC_ALLOC_TYPE alloc, CMC_CALLBACK_TYPE callbacks)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    CMC_CALLBACKS_MAYBE_UNUSED(callbacks);
+
+    if (capacity == 0 || load <= 0 || load >= 1)
+        return NULL;
+
+    /* Prevent integer overflow */
+    if (capacity >= (double)UINTMAX_MAX * load)
+        return NULL;
+
+    if (!f_val)
+        return NULL;
+
+    size_t real_capacity = CMC_(PFX, _impl_calculate_size)(capacity / load);
+
+    if (!alloc)
+        alloc = &cmc_alloc_node_default;
+
+    struct SNAME *_set_ = alloc->malloc(sizeof(struct SNAME));
+
+    if (!_set_)
+        return NULL;
+
+    _set_->buffer = alloc->calloc(real_capacity, sizeof(struct CMC_DEF_ENTRY(SNAME)));
+
+    if (!_set_->buffer)
+    {
+        alloc->free(_set_);
+        return NULL;
+    }
+
+    _set_->count = 0;
+    _set_->cardinality = 0;
+    _set_->capacity = real_capacity;
+    _set_->load = load;
+    _set_->flag = CMC_FLAG_OK;
+    _set_->f_val = f_val;
+    _set_->alloc = alloc;
+    CMC_CALLBACKS_ASSIGN(_set_, callbacks);
+
+    return _set_;
+}
+
+void CMC_(PFX, _clear)(struct SNAME *_set_)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    if (_set_->f_val->free)
+    {
+        for (size_t i = 0; i < _set_->capacity; i++)
+        {
+            struct CMC_DEF_ENTRY(SNAME) *entry = &(_set_->buffer[i]);
+
+            if (entry->state == CMC_ES_FILLED)
+            {
+                _set_->f_val->free(entry->value);
+            }
+        }
+    }
+
+    memset(_set_->buffer, 0, sizeof(struct CMC_DEF_ENTRY(SNAME)) * _set_->capacity);
+
+    _set_->count = 0;
+    _set_->flag = CMC_FLAG_OK;
+}
+
+void CMC_(PFX, _free)(struct SNAME *_set_)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    if (_set_->f_val->free)
+    {
+        for (size_t i = 0; i < _set_->capacity; i++)
+        {
+            struct CMC_DEF_ENTRY(SNAME) *entry = &(_set_->buffer[i]);
+
+            if (entry->state == CMC_ES_FILLED)
+            {
+                _set_->f_val->free(entry->value);
+            }
+        }
+    }
+
+    _set_->alloc->free(_set_->buffer);
+    _set_->alloc->free(_set_);
+}
+
+void CMC_(PFX, _customize)(struct SNAME *_set_, CMC_ALLOC_TYPE alloc, CMC_CALLBACK_TYPE callbacks)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    CMC_CALLBACKS_MAYBE_UNUSED(callbacks);
+
+    if (!alloc)
+        _set_->alloc = &cmc_alloc_node_default;
+    else
+        _set_->alloc = alloc;
+
+    CMC_CALLBACKS_ASSIGN(_set_, callbacks);
+
+    _set_->flag = CMC_FLAG_OK;
+}
+
+bool CMC_(PFX, _insert)(struct SNAME *_set_, V value)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    bool new_node;
+
+    struct CMC_DEF_ENTRY(SNAME) *entry = CMC_(PFX, _impl_insert_and_return)(_set_, value, &new_node);
+
+    if (!entry)
+    {
+        _set_->flag = CMC_FLAG_ERROR;
+        return false;
+    }
+
+    if (!new_node)
+        entry->multiplicity++;
+
+    _set_->cardinality++;
+    _set_->flag = CMC_FLAG_OK;
+
+    CMC_CALLBACKS_CALL(_set_);
+
+    return true;
+}
+
+bool CMC_(PFX, _insert_many)(struct SNAME *_set_, V value, size_t count)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    if (count == 0)
+        goto success;
+
+    bool new_node;
+
+    struct CMC_DEF_ENTRY(SNAME) *entry = CMC_(PFX, _impl_insert_and_return)(_set_, value, &new_node);
+
+    if (!entry)
+    {
+        _set_->flag = CMC_FLAG_ERROR;
+        return false;
+    }
+
+    if (new_node)
+        entry->multiplicity = count;
+    else
+        entry->multiplicity += count;
+
+    _set_->cardinality += count;
+
+success:
+
+    _set_->flag = CMC_FLAG_OK;
+
+    CMC_CALLBACKS_CALL(_set_);
+
+    return true;
+}
+
+bool CMC_(PFX, _update)(struct SNAME *_set_, V value, size_t multiplicity)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    if (multiplicity == 0)
+    {
+        /* Effectively delete the entry */
+        struct CMC_DEF_ENTRY(SNAME) *result = CMC_(PFX, _impl_get_entry)(_set_, value);
+
+        if (!result)
+            /* If no entry was found then its multiplicity is already 0 */
+            goto success;
+
+        _set_->count--;
+        _set_->cardinality -= result->multiplicity;
+
+        result->value = (V){ 0 };
+        result->multiplicity = 0;
+        result->dist = 0;
+        result->state = CMC_ES_DELETED;
+
+        goto success;
+    }
+
+    bool new_node;
+
+    struct CMC_DEF_ENTRY(SNAME) *entry = CMC_(PFX, _impl_insert_and_return)(_set_, value, &new_node);
+
+    if (!entry)
+        return false;
+
+    if (new_node)
+        _set_->cardinality++;
+
+    _set_->cardinality = (_set_->cardinality - entry->multiplicity) + multiplicity;
+
+    entry->multiplicity = multiplicity;
+
+success:
+
+    _set_->flag = CMC_FLAG_OK;
+
+    CMC_CALLBACKS_CALL(_set_);
+
+    return true;
+}
+
+bool CMC_(PFX, _remove)(struct SNAME *_set_, V value)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    if (CMC_(PFX, _empty)(_set_))
+    {
+        _set_->flag = CMC_FLAG_EMPTY;
+        return false;
+    }
+
+    struct CMC_DEF_ENTRY(SNAME) *result = CMC_(PFX, _impl_get_entry)(_set_, value);
+
+    if (!result)
+    {
+        _set_->flag = CMC_FLAG_NOT_FOUND;
+        return false;
+    }
+
+    if (result->multiplicity > 1)
+        result->multiplicity--;
+    else
+    {
+        result->value = (V){ 0 };
+        result->multiplicity = 0;
+        result->dist = 0;
+        result->state = CMC_ES_DELETED;
+
+        _set_->count--;
+    }
+
+    _set_->cardinality--;
+    _set_->flag = CMC_FLAG_OK;
+
+    CMC_CALLBACKS_CALL(_set_);
+
+    return true;
+}
+
+size_t CMC_(PFX, _remove_all)(struct SNAME *_set_, V value)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    if (CMC_(PFX, _empty)(_set_))
+    {
+        _set_->flag = CMC_FLAG_EMPTY;
+        return false;
+    }
+
+    struct CMC_DEF_ENTRY(SNAME) *result = CMC_(PFX, _impl_get_entry)(_set_, value);
+
+    if (!result)
+    {
+        _set_->flag = CMC_FLAG_NOT_FOUND;
+        return 0;
+    }
+
+    size_t removed = result->multiplicity;
+
+    result->value = (V){ 0 };
+    result->multiplicity = 0;
+    result->dist = 0;
+    result->state = CMC_ES_DELETED;
+
+    _set_->count--;
+    _set_->cardinality -= removed;
+    _set_->flag = CMC_FLAG_OK;
+
+    CMC_CALLBACKS_CALL(_set_);
+
+    return removed;
+}
+
+bool CMC_(PFX, _max)(struct SNAME *_set_, V *value)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    if (CMC_(PFX, _empty)(_set_))
+    {
+        _set_->flag = CMC_FLAG_EMPTY;
+        return false;
+    }
+
+    bool first = true;
+    V max_val = (V){ 0 };
+
+    for (size_t i = 0; i < _set_->capacity; i++)
+    {
+        if (_set_->buffer[i].state == CMC_ES_FILLED)
+        {
+            if (first)
+            {
+                max_val = _set_->buffer[i].value;
+                first = false;
+            }
+            else if (_set_->f_val->cmp(_set_->buffer[i].value, max_val) > 0)
+            {
+                max_val = _set_->buffer[i].value;
+            }
+        }
+    }
+
+    if (value)
+        *value = max_val;
+
+    _set_->flag = CMC_FLAG_OK;
+
+    CMC_CALLBACKS_CALL(_set_);
+
+    return true;
+}
+
+bool CMC_(PFX, _min)(struct SNAME *_set_, V *value)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    if (CMC_(PFX, _empty)(_set_))
+    {
+        _set_->flag = CMC_FLAG_EMPTY;
+        return false;
+    }
+
+    bool first = true;
+    V min_val = (V){ 0 };
+
+    for (size_t i = 0; i < _set_->capacity; i++)
+    {
+        if (_set_->buffer[i].state == CMC_ES_FILLED)
+        {
+            if (first)
+            {
+                min_val = _set_->buffer[i].value;
+                first = false;
+            }
+            else if (_set_->f_val->cmp(_set_->buffer[i].value, min_val) < 0)
+            {
+                min_val = _set_->buffer[i].value;
+            }
+        }
+    }
+
+    if (value)
+        *value = min_val;
+
+    _set_->flag = CMC_FLAG_OK;
+
+    CMC_CALLBACKS_CALL(_set_);
+
+    return true;
+}
+
+size_t CMC_(PFX, _multiplicity_of)(struct SNAME *_set_, V value)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    struct CMC_DEF_ENTRY(SNAME) *entry = CMC_(PFX, _impl_get_entry)(_set_, value);
+
+    _set_->flag = CMC_FLAG_OK;
+
+    CMC_CALLBACKS_CALL(_set_);
+
+    if (!entry)
+        return 0;
+
+    return entry->multiplicity;
+}
+
+bool CMC_(PFX, _contains)(struct SNAME *_set_, V value)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    _set_->flag = CMC_FLAG_OK;
+
+    bool result = CMC_(PFX, _impl_get_entry)(_set_, value) != NULL;
+
+    CMC_CALLBACKS_CALL(_set_);
+
+    return result;
+}
+
+bool CMC_(PFX, _empty)(struct SNAME *_set_)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    return _set_->count == 0;
+}
+
+bool CMC_(PFX, _full)(struct SNAME *_set_)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    return (double)_set_->capacity * _set_->load <= (double)_set_->count;
+}
+
+size_t CMC_(PFX, _count)(struct SNAME *_set_)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    return _set_->count;
+}
+
+size_t CMC_(PFX, _cardinality)(struct SNAME *_set_)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    return _set_->cardinality;
+}
+
+size_t CMC_(PFX, _capacity)(struct SNAME *_set_)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    return _set_->capacity;
+}
+
+double CMC_(PFX, _load)(struct SNAME *_set_)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    return _set_->load;
+}
+
+int CMC_(PFX, _flag)(struct SNAME *_set_)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    return _set_->flag;
+}
+
+bool CMC_(PFX, _resize)(struct SNAME *_set_, size_t capacity)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    _set_->flag = CMC_FLAG_OK;
+
+    if (_set_->capacity == capacity)
+        goto success;
+
+    if (_set_->capacity > capacity / _set_->load)
+        goto success;
+
+    /* Prevent integer overflow */
+    if (capacity >= (double)UINTMAX_MAX * _set_->load)
+    {
+        _set_->flag = CMC_FLAG_ERROR;
+        return false;
+    }
+
+    /* Calculate required capacity based on the prime numbers */
+    size_t theoretical_size = CMC_(PFX, _impl_calculate_size)(capacity);
+
+    /* Not possible to shrink with current available prime numbers */
+    if (theoretical_size < _set_->count / _set_->load)
+    {
+        _set_->flag = CMC_FLAG_INVALID;
+        return false;
+    }
+
+    /* No callbacks since _new_set_ is just a temporary hashtable */
+    struct SNAME *_new_set_ = CMC_(PFX, _new_custom)(capacity, _set_->load, _set_->f_val, _set_->alloc, NULL);
+
+    if (!_new_set_)
+    {
+        _set_->flag = CMC_FLAG_ERROR;
+        return false;
+    }
+
+    for (size_t i = 0; i < _set_->capacity; i++)
+    {
+        if (_set_->buffer[i].state == CMC_ES_FILLED)
+        {
+            V value = _set_->buffer[i].value;
+            size_t multiplicity = _set_->buffer[i].multiplicity;
+
+            /* TODO check this for possible errors where entry == NULL */
+            struct CMC_DEF_ENTRY(SNAME) *entry = CMC_(PFX, _impl_insert_and_return)(_new_set_, value, NULL);
+
+            entry->multiplicity = multiplicity;
+            /* Setting cardinality not required, _new_set_ is temporary */
+        }
+    }
+
+    if (_set_->count != _new_set_->count)
+    {
+        CMC_(PFX, _free)(_new_set_);
+
+        _set_->flag = CMC_FLAG_ERROR;
+        return false;
+    }
+
+    struct CMC_DEF_ENTRY(SNAME) *tmp_b = _set_->buffer;
+    _set_->buffer = _new_set_->buffer;
+    _new_set_->buffer = tmp_b;
+
+    size_t tmp_c = _set_->capacity;
+    _set_->capacity = _new_set_->capacity;
+    _new_set_->capacity = tmp_c;
+
+    /* Prevent the set from freeing the data */
+    _new_set_->f_val = &(struct CMC_DEF_FVAL(SNAME)){ 0 };
+
+    CMC_(PFX, _free)(_new_set_);
+
+success:
+
+    CMC_CALLBACKS_CALL(_set_);
+
+    return true;
+}
+
+struct SNAME *CMC_(PFX, _copy_of)(struct SNAME *_set_)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    struct SNAME *result =
+        CMC_(PFX, _new_custom)(_set_->capacity * _set_->load, _set_->load, _set_->f_val, _set_->alloc, NULL);
+
+    if (!result)
+    {
+        _set_->flag = CMC_FLAG_ERROR;
+        return NULL;
+    }
+
+    CMC_CALLBACKS_ASSIGN(result, _set_->callbacks);
+
+    if (_set_->f_val->cpy)
+    {
+        for (size_t i = 0; i < _set_->capacity; i++)
+        {
+            struct CMC_DEF_ENTRY(SNAME) *scan = &(_set_->buffer[i]);
+
+            if (scan->state != CMC_ES_EMPTY)
+            {
+                struct CMC_DEF_ENTRY(SNAME) *target = &(result->buffer[i]);
+
+                if (scan->state == CMC_ES_DELETED)
+                    target->state = CMC_ES_DELETED;
+                else
+                {
+                    target->state = scan->state;
+                    target->dist = scan->dist;
+                    target->multiplicity = scan->multiplicity;
+
+                    target->value = _set_->f_val->cpy(scan->value);
+                }
+            }
+        }
+    }
+    else
+        memcpy(result->buffer, _set_->buffer, sizeof(struct CMC_DEF_ENTRY(SNAME)) * _set_->capacity);
+
+    result->count = _set_->count;
+    result->cardinality = _set_->cardinality;
+
+    _set_->flag = CMC_FLAG_OK;
+
+    return result;
+}
+
+bool CMC_(PFX, _equals)(struct SNAME *_set1_, struct SNAME *_set2_)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    _set1_->flag = CMC_FLAG_OK;
+    _set2_->flag = CMC_FLAG_OK;
+
+    if (_set1_->count != _set2_->count)
+        return false;
+
+    if (_set1_->cardinality != _set2_->cardinality)
+        return false;
+
+    if (_set1_->count == 0)
+        return true;
+
+    /* Optimize loop using the smallest hashtable */
+    struct SNAME *_set_a_;
+    struct SNAME *_set_b_;
+
+    _set_a_ = _set1_->capacity < _set2_->capacity ? _set1_ : _set2_;
+    _set_b_ = _set_a_ == _set1_ ? _set2_ : _set1_;
+
+    for (size_t i = 0; i < _set_a_->capacity; i++)
+    {
+        if (_set_a_->buffer[i].state == CMC_ES_FILLED)
+        {
+            struct CMC_DEF_ENTRY(SNAME) *entry_a = &(_set_a_->buffer[i]);
+            struct CMC_DEF_ENTRY(SNAME) *entry_b = CMC_(PFX, _impl_get_entry)(_set_b_, entry_a->value);
+
+            if (!entry_b)
+                return false;
+
+            if (entry_a->multiplicity != entry_b->multiplicity)
+                return false;
+        }
+    }
+
+    return true;
+}
+
+static struct CMC_DEF_ENTRY(SNAME) * CMC_(PFX, _impl_insert_and_return)(struct SNAME *_set_, V value, bool *new_node)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    /* If the entry already exists simply return it as we might do */
+    /* something with it. This function only guarantees that there is */
+    /* a valid entry for a given value */
+
+    if (new_node)
+        *new_node = false;
+
+    struct CMC_DEF_ENTRY(SNAME) *entry = CMC_(PFX, _impl_get_entry)(_set_, value);
+
+    if (entry != NULL)
+        return entry;
+
+    if (new_node)
+        *new_node = true;
+
+    if (CMC_(PFX, _full)(_set_))
+    {
+        if (!CMC_(PFX, _resize)(_set_, _set_->capacity + 1))
+            return NULL;
+    }
+
+    size_t hash = _set_->f_val->hash(value);
+    size_t original_pos = hash % _set_->capacity;
+    size_t pos = original_pos;
+    /* Current multiplicity. Might change due to robin hood hashing */
+    size_t curr_mul = 1;
+
+    struct CMC_DEF_ENTRY(SNAME) *target = &(_set_->buffer[pos]);
+    struct CMC_DEF_ENTRY(SNAME) *to_return = NULL;
+
+    if (target->state == CMC_ES_EMPTY || target->state == CMC_ES_DELETED)
+    {
+        target->value = value;
+        target->multiplicity = curr_mul;
+        target->dist = pos - original_pos;
+        target->state = CMC_ES_FILLED;
+
+        to_return = target;
+    }
+    else
+    {
+        while (true)
+        {
+            pos++;
+            target = &(_set_->buffer[pos % _set_->capacity]);
+
+            if (target->state == CMC_ES_EMPTY || target->state == CMC_ES_DELETED)
+            {
+                target->value = value;
+                target->multiplicity = curr_mul;
+                target->dist = pos - original_pos;
+                target->state = CMC_ES_FILLED;
+
+                if (!to_return)
+                    to_return = target;
+
+                break;
+            }
+            else if (target->dist < pos - original_pos)
+            {
+                /* Swap everything */
+                V tmp = target->value;
+                size_t tmp_dist = target->dist;
+                size_t tmp_mul = target->multiplicity;
+
+                target->value = value;
+                target->dist = pos - original_pos;
+                target->multiplicity = curr_mul;
+
+                value = tmp;
+                original_pos = pos - tmp_dist;
+                curr_mul = tmp_mul;
+
+                if (!to_return)
+                    to_return = target;
+            }
+        }
+    }
+
+    _set_->count++;
+
+    return to_return;
+}
+
+static struct CMC_DEF_ENTRY(SNAME) * CMC_(PFX, _impl_get_entry)(struct SNAME *_set_, V value)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    size_t hash = _set_->f_val->hash(value);
+    size_t pos = hash % _set_->capacity;
+
+    struct CMC_DEF_ENTRY(SNAME) *target = &(_set_->buffer[pos]);
+
+    while (target->state == CMC_ES_FILLED || target->state == CMC_ES_DELETED)
+    {
+        if (target->state != CMC_ES_DELETED && _set_->f_val->cmp(target->value, value) == 0)
+            return target;
+
+        pos++;
+        target = &(_set_->buffer[pos % _set_->capacity]);
+    }
+
+    return NULL;
+}
+
+static size_t CMC_(PFX, _impl_calculate_size)(size_t required)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    const size_t count = sizeof(cmc_hashtable_primes) / sizeof(cmc_hashtable_primes[0]);
+
+    if (cmc_hashtable_primes[count - 1] < required)
+        return required;
+
+    size_t i = 0;
+    while (cmc_hashtable_primes[i] < required)
+        i++;
+
+    return cmc_hashtable_primes[i];
+}

cmc/hashmultiset/ext/code.h

@@ -0,0 +1,742 @@
+/**
+ * Copyright (c) 2019 Leonardo Vencovsky
+ *
+ * This file is part of the C Macro Collections Library.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+/**
+ * INIT
+ *
+ * The part 'INIT' gives a new way of initializing a collection. The collection
+ * struct is not heap allocated, only its internal structure (nodes, buffers).
+ */
+#ifdef CMC_EXT_INIT
+
+#endif /* CMC_EXT_INIT */
+
+/**
+ * ITER
+ *
+ * List bi-directional iterator.
+ */
+#ifdef CMC_EXT_ITER
+
+struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_start)(struct SNAME *target)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    struct CMC_DEF_ITER(SNAME) iter;
+
+    iter.target = target;
+    iter.cursor = 0;
+    iter.index = 0;
+    iter.first = 0;
+    iter.last = 0;
+    iter.start = true;
+    iter.end = CMC_(PFX, _empty)(target);
+
+    if (!CMC_(PFX, _empty)(target))
+    {
+        for (size_t i = 0; i < target->capacity; i++)
+        {
+            if (target->buffer[i].state == CMC_ES_FILLED)
+            {
+                iter.first = i;
+                break;
+            }
+        }
+
+        iter.cursor = iter.first;
+
+        for (size_t i = target->capacity; i > 0; i--)
+        {
+            if (target->buffer[i - 1].state == CMC_ES_FILLED)
+            {
+                iter.last = i - 1;
+                break;
+            }
+        }
+    }
+
+    return iter;
+}
+
+struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_end)(struct SNAME *target)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    struct CMC_DEF_ITER(SNAME) iter;
+
+    iter.target = target;
+    iter.cursor = 0;
+    iter.index = 0;
+    iter.first = 0;
+    iter.last = 0;
+    iter.start = CMC_(PFX, _empty)(target);
+    iter.end = true;
+
+    if (!CMC_(PFX, _empty)(target))
+    {
+        for (size_t i = 0; i < target->capacity; i++)
+        {
+            if (target->buffer[i].state == CMC_ES_FILLED)
+            {
+                iter.first = i;
+                break;
+            }
+        }
+
+        for (size_t i = target->capacity; i > 0; i--)
+        {
+            if (target->buffer[i - 1].state == CMC_ES_FILLED)
+            {
+                iter.last = i - 1;
+                break;
+            }
+        }
+
+        iter.cursor = iter.last;
+        iter.index = target->count - 1;
+    }
+
+    return iter;
+}
+
+bool CMC_(PFX, _iter_at_start)(struct CMC_DEF_ITER(SNAME) * iter)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    return CMC_(PFX, _empty)(iter->target) || iter->start;
+}
+
+bool CMC_(PFX, _iter_at_end)(struct CMC_DEF_ITER(SNAME) * iter)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    return CMC_(PFX, _empty)(iter->target) || iter->end;
+}
+
+bool CMC_(PFX, _iter_to_start)(struct CMC_DEF_ITER(SNAME) * iter)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    if (!CMC_(PFX, _empty)(iter->target))
+    {
+        iter->cursor = iter->first;
+        iter->index = 0;
+        iter->start = true;
+        iter->end = CMC_(PFX, _empty)(iter->target);
+
+        return true;
+    }
+
+    return false;
+}
+
+bool CMC_(PFX, _iter_to_end)(struct CMC_DEF_ITER(SNAME) * iter)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    if (!CMC_(PFX, _empty)(iter->target))
+    {
+        iter->cursor = iter->last;
+        iter->index = iter->target->count - 1;
+        iter->start = CMC_(PFX, _empty)(iter->target);
+        iter->end = true;
+
+        return true;
+    }
+
+    return false;
+}
+
+bool CMC_(PFX, _iter_next)(struct CMC_DEF_ITER(SNAME) * iter)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    if (iter->end)
+        return false;
+
+    if (iter->index + 1 == iter->target->count)
+    {
+        iter->end = true;
+        return false;
+    }
+
+    iter->start = CMC_(PFX, _empty)(iter->target);
+
+    struct CMC_DEF_ENTRY(SNAME) *scan = &(iter->target->buffer[iter->cursor]);
+
+    iter->index++;
+
+    while (1)
+    {
+        iter->cursor++;
+        scan = &(iter->target->buffer[iter->cursor]);
+
+        if (scan->state == CMC_ES_FILLED)
+            break;
+    }
+
+    return true;
+}
+
+bool CMC_(PFX, _iter_prev)(struct CMC_DEF_ITER(SNAME) * iter)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    if (iter->start)
+        return false;
+
+    if (iter->index == 0)
+    {
+        iter->start = true;
+        return false;
+    }
+
+    iter->end = CMC_(PFX, _empty)(iter->target);
+
+    struct CMC_DEF_ENTRY(SNAME) *scan = &(iter->target->buffer[iter->cursor]);
+
+    iter->index--;
+
+    while (1)
+    {
+        iter->cursor--;
+        scan = &(iter->target->buffer[iter->cursor]);
+
+        if (scan->state == CMC_ES_FILLED)
+            break;
+    }
+
+    return true;
+}
+
+/* Returns true only if the iterator moved */
+bool CMC_(PFX, _iter_advance)(struct CMC_DEF_ITER(SNAME) * iter, size_t steps)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    if (iter->end)
+        return false;
+
+    if (iter->index + 1 == iter->target->count)
+    {
+        iter->end = true;
+        return false;
+    }
+
+    if (steps == 0 || iter->index + steps >= iter->target->count)
+        return false;
+
+    for (size_t i = 0; i < steps; i++)
+        CMC_(PFX, _iter_next)(iter);
+
+    return true;
+}
+
+/* Returns true only if the iterator moved */
+bool CMC_(PFX, _iter_rewind)(struct CMC_DEF_ITER(SNAME) * iter, size_t steps)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    if (iter->start)
+        return false;
+
+    if (iter->index == 0)
+    {
+        iter->start = true;
+        return false;
+    }
+
+    if (steps == 0 || iter->index < steps)
+        return false;
+
+    for (size_t i = 0; i < steps; i++)
+        CMC_(PFX, _iter_prev)(iter);
+
+    return true;
+}
+
+/* Returns true only if the iterator was able to be positioned at the */
+/* given index */
+bool CMC_(PFX, _iter_go_to)(struct CMC_DEF_ITER(SNAME) * iter, size_t index)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    if (index >= iter->target->count)
+        return false;
+
+    if (iter->index > index)
+        return CMC_(PFX, _iter_rewind)(iter, iter->index - index);
+    else if (iter->index < index)
+        return CMC_(PFX, _iter_advance)(iter, index - iter->index);
+
+    return true;
+}
+
+V CMC_(PFX, _iter_value)(struct CMC_DEF_ITER(SNAME) * iter)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    if (CMC_(PFX, _empty)(iter->target))
+        return (V){ 0 };
+
+    return iter->target->buffer[iter->cursor].value;
+}
+
+size_t CMC_(PFX, _iter_multiplicity)(struct CMC_DEF_ITER(SNAME) * iter)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    if (CMC_(PFX, _empty)(iter->target))
+        return 0;
+
+    return iter->target->buffer[iter->cursor].multiplicity;
+}
+
+size_t CMC_(PFX, _iter_index)(struct CMC_DEF_ITER(SNAME) * iter)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    return iter->index;
+}
+
+#endif /* CMC_EXT_ITER */
+
+/**
+ * SETF
+ *
+ * Set functions
+ */
+#ifdef CMC_EXT_SETF
+
+/* Implementation detail function */
+static size_t CMC_(PFX, _impl_multiplicity_of)(struct SNAME *_set_, V value);
+
+struct SNAME *CMC_(PFX, _union)(struct SNAME *_set1_, struct SNAME *_set2_)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    /* Callbacks are added later */
+    struct SNAME *_set_r_ = CMC_(PFX, _new_custom)(_set1_->capacity, _set1_->load, _set1_->f_val, _set1_->alloc, NULL);
+
+    if (!_set_r_)
+        return NULL;
+
+    struct CMC_DEF_ITER(SNAME) iter1 = CMC_(PFX, _iter_start)(_set1_);
+    struct CMC_DEF_ITER(SNAME) iter2 = CMC_(PFX, _iter_start)(_set2_);
+
+    for (; !CMC_(PFX, _iter_at_end)(&iter1); CMC_(PFX, _iter_next)(&iter1))
+    {
+        V value = CMC_(PFX, _iter_value)(&iter1);
+
+        size_t m1 = CMC_(PFX, _iter_multiplicity)(&iter1);
+        size_t m2 = CMC_(PFX, _impl_multiplicity_of)(_set2_, value);
+        size_t max_ = m1 > m2 ? m1 : m2;
+
+        CMC_(PFX, _update)(_set_r_, value, max_);
+    }
+
+    for (; !CMC_(PFX, _iter_at_end)(&iter2); CMC_(PFX, _iter_next)(&iter2))
+    {
+        V value = CMC_(PFX, _iter_value)(&iter2);
+
+        size_t m1 = CMC_(PFX, _impl_multiplicity_of)(_set1_, value);
+        size_t m2 = CMC_(PFX, _iter_multiplicity)(&iter2);
+        size_t max_ = m1 > m2 ? m1 : m2;
+
+        CMC_(PFX, _update)(_set_r_, value, max_);
+    }
+
+    CMC_CALLBACKS_ASSIGN(_set_r_, _set1_->callbacks);
+
+    return _set_r_;
+}
+
+struct SNAME *CMC_(PFX, _intersection)(struct SNAME *_set1_, struct SNAME *_set2_)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    /* Callbacks are added later */
+    struct SNAME *_set_r_ = CMC_(PFX, _new_custom)(_set1_->capacity, _set1_->load, _set1_->f_val, _set1_->alloc, NULL);
+
+    if (!_set_r_)
+        return NULL;
+
+    struct SNAME *_set_A_ = _set1_->count < _set2_->count ? _set1_ : _set2_;
+    struct SNAME *_set_B_ = _set_A_ == _set1_ ? _set2_ : _set1_;
+
+    struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_set_A_);
+
+    for (; !CMC_(PFX, _iter_at_end)(&iter); CMC_(PFX, _iter_next)(&iter))
+    {
+        V value = CMC_(PFX, _iter_value)(&iter);
+
+        size_t m1 = CMC_(PFX, _iter_multiplicity)(&iter);
+        size_t m2 = CMC_(PFX, _impl_multiplicity_of)(_set_B_, value);
+        size_t max_ = m1 < m2 ? m1 : m2;
+
+        CMC_(PFX, _update)(_set_r_, value, max_);
+    }
+
+    CMC_CALLBACKS_ASSIGN(_set_r_, _set1_->callbacks);
+
+    return _set_r_;
+}
+
+struct SNAME *CMC_(PFX, _difference)(struct SNAME *_set1_, struct SNAME *_set2_)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    /* Callbacks are added later */
+    struct SNAME *_set_r_ = CMC_(PFX, _new_custom)(_set1_->capacity, _set1_->load, _set1_->f_val, _set1_->alloc, NULL);
+
+    if (!_set_r_)
+        return NULL;
+
+    struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_set1_);
+
+    for (; !CMC_(PFX, _iter_at_end)(&iter); CMC_(PFX, _iter_next)(&iter))
+    {
+        V value = CMC_(PFX, _iter_value)(&iter);
+
+        size_t m1 = CMC_(PFX, _iter_multiplicity)(&iter);
+        size_t m2 = CMC_(PFX, _impl_multiplicity_of)(_set2_, value);
+
+        if (m1 > m2)
+            CMC_(PFX, _update)(_set_r_, value, m1 - m2);
+    }
+
+    CMC_CALLBACKS_ASSIGN(_set_r_, _set1_->callbacks);
+
+    return _set_r_;
+}
+
+struct SNAME *CMC_(PFX, _summation)(struct SNAME *_set1_, struct SNAME *_set2_)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    /* Callbacks are added later */
+    struct SNAME *_set_r_ = CMC_(PFX, _new_custom)(_set1_->capacity, _set1_->load, _set1_->f_val, _set1_->alloc, NULL);
+
+    if (!_set_r_)
+        return NULL;
+
+    struct CMC_DEF_ITER(SNAME) iter1 = CMC_(PFX, _iter_start)(_set1_);
+    struct CMC_DEF_ITER(SNAME) iter2 = CMC_(PFX, _iter_start)(_set2_);
+
+    for (; !CMC_(PFX, _iter_at_end)(&iter1); CMC_(PFX, _iter_next)(&iter1))
+    {
+        CMC_(PFX, _insert_many)
+        (_set_r_, CMC_(PFX, _iter_value)(&iter1), CMC_(PFX, _iter_multiplicity)(&iter1));
+    }
+
+    for (; !CMC_(PFX, _iter_at_end)(&iter2); CMC_(PFX, _iter_next)(&iter2))
+    {
+        CMC_(PFX, _insert_many)
+        (_set_r_, CMC_(PFX, _iter_value)(&iter2), CMC_(PFX, _iter_multiplicity)(&iter2));
+    }
+
+    CMC_CALLBACKS_ASSIGN(_set_r_, _set1_->callbacks);
+
+    return _set_r_;
+}
+
+struct SNAME *CMC_(PFX, _symmetric_difference)(struct SNAME *_set1_, struct SNAME *_set2_)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    /* Callbacks are added later */
+    struct SNAME *_set_r_ = CMC_(PFX, _new_custom)(_set1_->capacity, _set1_->load, _set1_->f_val, _set1_->alloc, NULL);
+
+    if (!_set_r_)
+        return NULL;
+    struct CMC_DEF_ITER(SNAME) iter1 = CMC_(PFX, _iter_start)(_set1_);
+    struct CMC_DEF_ITER(SNAME) iter2 = CMC_(PFX, _iter_start)(_set2_);
+
+    for (; !CMC_(PFX, _iter_at_end)(&iter1); CMC_(PFX, _iter_next)(&iter1))
+    {
+        V value = CMC_(PFX, _iter_value)(&iter1);
+
+        size_t m1 = CMC_(PFX, _iter_multiplicity)(&iter1);
+        size_t m2 = CMC_(PFX, _impl_multiplicity_of)(_set2_, value);
+
+        if (m1 != m2)
+        {
+            if (m1 > m2)
+                CMC_(PFX, _update)(_set_r_, value, m1 - m2);
+            else
+                CMC_(PFX, _update)(_set_r_, value, m2 - m1);
+        }
+    }
+
+    for (; !CMC_(PFX, _iter_at_end)(&iter2); CMC_(PFX, _iter_next)(&iter2))
+    {
+        V value = CMC_(PFX, _iter_value)(&iter2);
+
+        size_t m1 = CMC_(PFX, _impl_multiplicity_of)(_set1_, value);
+        size_t m2 = CMC_(PFX, _iter_multiplicity)(&iter2);
+
+        if (m1 != m2)
+        {
+            if (m1 > m2)
+                CMC_(PFX, _update)(_set_r_, value, m1 - m2);
+            else
+                CMC_(PFX, _update)(_set_r_, value, m2 - m1);
+        }
+    }
+
+    CMC_CALLBACKS_ASSIGN(_set_r_, _set1_->callbacks);
+
+    return _set_r_;
+}
+
+bool CMC_(PFX, _is_subset)(struct SNAME *_set1_, struct SNAME *_set2_)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    if (_set1_->count > _set2_->count)
+        return false;
+
+    if (CMC_(PFX, _empty)(_set1_))
+        return true;
+
+    struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_set1_);
+
+    for (; !CMC_(PFX, _iter_at_end)(&iter); CMC_(PFX, _iter_next)(&iter))
+    {
+        V value = CMC_(PFX, _iter_value)(&iter);
+
+        size_t m1 = CMC_(PFX, _iter_multiplicity)(&iter);
+        size_t m2 = CMC_(PFX, _impl_multiplicity_of)(_set2_, value);
+
+        if (m1 > m2)
+            return false;
+    }
+
+    return true;
+}
+
+bool CMC_(PFX, _is_superset)(struct SNAME *_set1_, struct SNAME *_set2_)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    return CMC_(PFX, _is_subset)(_set2_, _set1_);
+}
+
+bool CMC_(PFX, _is_proper_subset)(struct SNAME *_set1_, struct SNAME *_set2_)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    if (_set1_->count >= _set2_->count)
+        return false;
+
+    if (CMC_(PFX, _empty)(_set1_))
+    {
+        if (!CMC_(PFX, _empty)(_set2_))
+            return true;
+        else
+            return false;
+    }
+
+    struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_set1_);
+
+    for (; !CMC_(PFX, _iter_at_end)(&iter); CMC_(PFX, _iter_next)(&iter))
+    {
+        V value = CMC_(PFX, _iter_value)(&iter);
+
+        size_t m1 = CMC_(PFX, _iter_multiplicity)(&iter);
+        size_t m2 = CMC_(PFX, _impl_multiplicity_of)(_set2_, value);
+
+        if (m1 >= m2)
+            return false;
+    }
+
+    return true;
+}
+
+bool CMC_(PFX, _is_proper_superset)(struct SNAME *_set1_, struct SNAME *_set2_)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    return CMC_(PFX, _is_proper_subset)(_set2_, _set1_);
+}
+
+bool CMC_(PFX, _is_disjointset)(struct SNAME *_set1_, struct SNAME *_set2_)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    if (CMC_(PFX, _empty)(_set1_))
+        return true;
+
+    struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_set1_);
+
+    for (; !CMC_(PFX, _iter_at_end)(&iter); CMC_(PFX, _iter_next)(&iter))
+    {
+        V value = CMC_(PFX, _iter_value)(&iter);
+
+        if (CMC_(PFX, _impl_get_entry)(_set2_, value) != NULL)
+            return false;
+    }
+
+    return true;
+}
+
+static size_t CMC_(PFX, _impl_multiplicity_of)(struct SNAME *_set_, V value)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    struct CMC_DEF_ENTRY(SNAME) *entry = CMC_(PFX, _impl_get_entry)(_set_, value);
+
+    if (!entry)
+        return 0;
+
+    return entry->multiplicity;
+}
+
+#endif /* CMC_EXT_SETF */
+
+/**
+ * STR
+ *
+ * Print helper functions.
+ */
+#ifdef CMC_EXT_STR
+
+bool CMC_(PFX, _to_string)(struct SNAME *_set_, FILE *fptr)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    struct SNAME *s_ = _set_;
+
+    return 0 <= fprintf(fptr,
+                        "struct %s<%s> "
+                        "at %p { "
+                        "buffer:%p, "
+                        "capacity:%" PRIuMAX ", "
+                        "count:%" PRIuMAX ", "
+                        "cardinality:%" PRIuMAX ", "
+                        "load:%lf, "
+                        "flag:%d, "
+                        "f_val:%p, "
+                        "alloc:%p, "
+                        "callbacks:%p }",
+                        CMC_TO_STRING(SNAME), CMC_TO_STRING(V), s_, s_->buffer, s_->capacity, s_->count,
+                        s_->cardinality, s_->load, s_->flag, s_->f_val, s_->alloc, CMC_CALLBACKS_GET(s_));
+}
+
+bool CMC_(PFX, _print)(struct SNAME *_set_, FILE *fptr, const char *start, const char *separator, const char *end,
+                       const char *val_mul_sep)
+{
+#ifdef CMC_DEV
+    CMC_DEV_FCALL;
+#endif
+
+    fprintf(fptr, "%s", start);
+
+    size_t last = 0;
+    for (size_t i = _set_->capacity; i > 0; i--)
+    {
+        if ((_set_->buffer[i - 1]).state == CMC_ES_FILLED)
+        {
+            last = i - 1;
+            break;
+        }
+    }
+
+    for (size_t i = 0; i < _set_->capacity; i++)
+    {
+        struct CMC_DEF_ENTRY(SNAME) *entry = &(_set_->buffer[i]);
+
+        if (entry->state == CMC_ES_FILLED)
+        {
+            if (!_set_->f_val->str(fptr, entry->value))
+                return false;
+
+            fprintf(fptr, "%s", val_mul_sep);
+
+            if (fprintf(fptr, "%" PRIuMAX "", entry->multiplicity) < 0)
+                return false;
+
+            if (i + 1 < last)
+                fprintf(fptr, "%s", separator);
+        }
+    }
+
+    fprintf(fptr, "%s", end);
+
+    return true;
+}
+
+#endif /* CMC_EXT_STR */

cmc/hashmultiset/ext/header.h

@@ -0,0 +1,95 @@
+/**
+ * Copyright (c) 2019 Leonardo Vencovsky
+ *
+ * This file is part of the C Macro Collections Library.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+/**
+ * INIT
+ *
+ * The part 'INIT' gives a new way of initializing a collection. The collection
+ * struct is not heap allocated, only its internal structure (nodes, buffers).
+ */
+#ifdef CMC_EXT_INIT
+
+#endif /* CMC_EXT_INIT */
+
+/**
+ * ITER
+ *
+ * List bi-directional iterator.
+ */
+#ifdef CMC_EXT_ITER
+
+/* Iterator Initialization */
+struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_start)(struct SNAME *target);
+struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_end)(struct SNAME *target);
+/* Iterator State */
+bool CMC_(PFX, _iter_at_start)(struct CMC_DEF_ITER(SNAME) * iter);
+bool CMC_(PFX, _iter_at_end)(struct CMC_DEF_ITER(SNAME) * iter);
+/* Iterator Movement */
+bool CMC_(PFX, _iter_to_start)(struct CMC_DEF_ITER(SNAME) * iter);
+bool CMC_(PFX, _iter_to_end)(struct CMC_DEF_ITER(SNAME) * iter);
+bool CMC_(PFX, _iter_next)(struct CMC_DEF_ITER(SNAME) * iter);
+bool CMC_(PFX, _iter_prev)(struct CMC_DEF_ITER(SNAME) * iter);
+bool CMC_(PFX, _iter_advance)(struct CMC_DEF_ITER(SNAME) * iter, size_t steps);
+bool CMC_(PFX, _iter_rewind)(struct CMC_DEF_ITER(SNAME) * iter, size_t steps);
+bool CMC_(PFX, _iter_go_to)(struct CMC_DEF_ITER(SNAME) * iter, size_t index);
+/* Iterator Access */
+V CMC_(PFX, _iter_value)(struct CMC_DEF_ITER(SNAME) * iter);
+size_t CMC_(PFX, _iter_multiplicity)(struct CMC_DEF_ITER(SNAME) * iter);
+size_t CMC_(PFX, _iter_index)(struct CMC_DEF_ITER(SNAME) * iter);
+
+#endif /* CMC_EXT_ITER */
+
+/**
+ * SETF
+ *
+ * Set functions
+ */
+#ifdef CMC_EXT_SETF
+
+/* Set Operations */
+struct SNAME *CMC_(PFX, _union)(struct SNAME *_set1_, struct SNAME *_set2_);
+struct SNAME *CMC_(PFX, _intersection)(struct SNAME *_set1_, struct SNAME *_set2_);
+struct SNAME *CMC_(PFX, _difference)(struct SNAME *_set1_, struct SNAME *_set2_);
+struct SNAME *CMC_(PFX, _summation)(struct SNAME *_set1_, struct SNAME *_set2_);
+struct SNAME *CMC_(PFX, _symmetric_difference)(struct SNAME *_set1_, struct SNAME *_set2_);
+bool CMC_(PFX, _is_subset)(struct SNAME *_set1_, struct SNAME *_set2_);
+bool CMC_(PFX, _is_superset)(struct SNAME *_set1_, struct SNAME *_set2_);
+bool CMC_(PFX, _is_proper_subset)(struct SNAME *_set1_, struct SNAME *_set2_);
+bool CMC_(PFX, _is_proper_superset)(struct SNAME *_set1_, struct SNAME *_set2_);
+bool CMC_(PFX, _is_disjointset)(struct SNAME *_set1_, struct SNAME *_set2_);
+
+#endif /* CMC_EXT_SETF */
+
+/**
+ * STR
+ *
+ * Print helper functions.
+ */
+#ifdef CMC_EXT_STR
+
+bool CMC_(PFX, _to_string)(struct SNAME *_set_, FILE *fptr);
+bool CMC_(PFX, _print)(struct SNAME *_set_, FILE *fptr, const char *start, const char *separator, const char *end,
+                       const char *key_val_sep);
+
+#endif /* CMC_EXT_STR */

cmc/hashmultiset/ext/struct.h

@@ -0,0 +1,57 @@
+/**
+ * Copyright (c) 2019 Leonardo Vencovsky
+ *
+ * This file is part of the C Macro Collections Library.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+/**
+ * ITER
+ *
+ * Hashmultiset bi-directional iterator.
+ */
+#ifdef CMC_EXT_ITER
+
+/* HashMultiSet Iterator */
+struct CMC_DEF_ITER(SNAME)
+{
+    /* Target HashMultiset */
+    struct SNAME *target;
+
+    /* Cursor's position (index) */
+    size_t cursor;
+
+    /* Keeps track of relative index to the iteration of elements */
+    size_t index;
+
+    /* The index of the first element */
+    size_t first;
+
+    /* The index of the last element */
+    size_t last;
+
+    /* If the iterator has reached the start of the iteration */
+    bool start;
+
+    /* If the iterator has reached the end of the iteration */
+    bool end;
+};
+
+#endif /* CMC_EXT_ITER */

cmc/hashmultiset/header.h

@@ -0,0 +1,72 @@
+/**
+ * Copyright (c) 2019 Leonardo Vencovsky
+ *
+ * This file is part of the C Macro Collections Library.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+/* Value struct function table */
+struct CMC_DEF_FVAL(SNAME)
+{
+    /* Comparator function */
+    CMC_DEF_FTAB_CMP(V);
+    /* Copy function */
+    CMC_DEF_FTAB_CPY(V);
+    /* To string function */
+    CMC_DEF_FTAB_STR(V);
+    /* Free from memory function */
+    CMC_DEF_FTAB_FREE(V);
+    /* Hash function */
+    CMC_DEF_FTAB_HASH(V);
+    /* Priority function */
+    CMC_DEF_FTAB_PRI(V);
+};
+
+/* Collection Allocation and Deallocation */
+struct SNAME *CMC_(PFX, _new)(size_t capacity, double load, struct CMC_DEF_FVAL(SNAME) * f_val);
+struct SNAME *CMC_(PFX, _new_custom)(size_t capacity, double load, struct CMC_DEF_FVAL(SNAME) * f_val,
+                                     CMC_ALLOC_TYPE alloc, CMC_CALLBACK_TYPE callbacks);
+void CMC_(PFX, _clear)(struct SNAME *_set_);
+void CMC_(PFX, _free)(struct SNAME *_set_);
+/* Customization of Allocation and Callbacks */
+void CMC_(PFX, _customize)(struct SNAME *_set_, CMC_ALLOC_TYPE alloc, CMC_CALLBACK_TYPE callbacks);
+/* Collection Input and Output */
+bool CMC_(PFX, _insert)(struct SNAME *_set_, V value);
+bool CMC_(PFX, _insert_many)(struct SNAME *_set_, V value, size_t count);
+bool CMC_(PFX, _update)(struct SNAME *_set_, V value, size_t multiplicity);
+bool CMC_(PFX, _remove)(struct SNAME *_set_, V value);
+size_t CMC_(PFX, _remove_all)(struct SNAME *_set_, V value);
+/* Element Access */
+bool CMC_(PFX, _max)(struct SNAME *_set_, V *value);
+bool CMC_(PFX, _min)(struct SNAME *_set_, V *value);
+size_t CMC_(PFX, _multiplicity_of)(struct SNAME *_set_, V value);
+/* Collection State */
+bool CMC_(PFX, _contains)(struct SNAME *_set_, V value);
+bool CMC_(PFX, _empty)(struct SNAME *_set_);
+bool CMC_(PFX, _full)(struct SNAME *_set_);
+size_t CMC_(PFX, _count)(struct SNAME *_set_);
+size_t CMC_(PFX, _cardinality)(struct SNAME *_set_);
+size_t CMC_(PFX, _capacity)(struct SNAME *_set_);
+double CMC_(PFX, _load)(struct SNAME *_set_);
+int CMC_(PFX, _flag)(struct SNAME *_set_);
+/* Collection Utility */
+bool CMC_(PFX, _resize)(struct SNAME *_set_, size_t capacity);
+struct SNAME *CMC_(PFX, _copy_of)(struct SNAME *_set_);
+bool CMC_(PFX, _equals)(struct SNAME *_set1_, struct SNAME *_set2_);

cmc/hashmultiset/struct.h

@@ -0,0 +1,58 @@
+/**
+ * Copyright (c) 2019 Leonardo Vencovsky
+ *
+ * This file is part of the C Macro Collections Library.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+struct SNAME
+{
+    /* Array of Entries */
+    struct CMC_DEF_ENTRY(SNAME) * buffer;
+    /* Current Array Capcity */
+    size_t capacity;
+    /* Current amount of unique elements */
+    size_t count;
+    /* Total amount of elements taking into account their multiplicity */
+    size_t cardinality;
+    /* Load factor in range (0.0, 1.0) */
+    double load;
+    /* Flags indicating errors or success */
+    int flag;
+    /* Key function table */
+    struct CMC_DEF_FVAL(SNAME) * f_val;
+    /* Custom allocation functions */
+    CMC_ALLOC_TYPE alloc;
+    /* Custom callback functions */
+    CMC_CALLBACKS_DECL;
+};
+
+struct CMC_DEF_ENTRY(SNAME)
+{
+    /* Entry element */
+    V value;
+    /* The element's multiplicity */
+    size_t multiplicity;
+    /* The distance of this node to its original position, used by */
+    /* robin-hood hashing */
+    size_t dist;
+    /* The sate of this node (DELETED, EMPTY, FILLED) */
+    enum cmc_entry_state state;
+};