164 lines
4.5 KiB
C
164 lines
4.5 KiB
C
/* This software is licensed by the MIT License, see LICENSE file */
|
|
/* Copyright © 2022 Gregory Lirent */
|
|
|
|
#include "include.h"
|
|
|
|
/*#####################################################################################################################*/
|
|
|
|
static inline int mnode_compare(const mnode_t* s0, const mnode_t* s1, vtype t) {
|
|
int c = vnode_compare_eq(&s0->key, &s1->key, t);
|
|
|
|
return !c ? vnode_compare(&s0->value, s0->type, &s1->value, s1->type) : c;
|
|
}
|
|
|
|
static inline hash_t mnode_hash(const mnode_t* s, vtype t) {
|
|
return vnode_hash(&s->key, t) + vnode_hash(&s->value, s->type) + t;
|
|
}
|
|
|
|
/*#####################################################################################################################*/
|
|
|
|
hash_t map_hash(const map_t* s) {
|
|
|
|
stack_t z;
|
|
mnode_t *c0, *c1;
|
|
hash_t hash, v;
|
|
|
|
if (mnode_is_empty(s->root))
|
|
return 0;
|
|
|
|
stack_init(&z);
|
|
stack_push(&z, s->root->left);
|
|
|
|
hash = 1;
|
|
|
|
if (!mnode_is_empty(c0 = stack_pop(&z))) {
|
|
do {
|
|
++hash;
|
|
if (!mnode_is_empty(c0->right)) stack_push(&z, c0->right);
|
|
if (!mnode_is_empty(c0->left)) stack_push(&z, c1 = c0->left);
|
|
} while (!is_null(c0 = stack_pop(&z)));
|
|
}
|
|
|
|
v = mnode_hash(c1, s->type);
|
|
stack_push(&z, s->root->right);
|
|
|
|
if (!mnode_is_empty(c0 = stack_pop(&z))) {
|
|
do {
|
|
++hash;
|
|
if (!mnode_is_empty(c0->right)) stack_push(&z, c1 = c0->right);
|
|
if (!mnode_is_empty(c0->left)) stack_push(&z, c0->left);
|
|
} while (!is_null(c0 = stack_pop(&z)));
|
|
}
|
|
|
|
v += mnode_hash(c1, s->type);
|
|
|
|
return (hash ^ v) + VTYPE_MAP;
|
|
}
|
|
|
|
/*#####################################################################################################################*/
|
|
|
|
void map_init(map_t* x, vtype t) {
|
|
x->root = mnode_empty;
|
|
x->type = t;
|
|
}
|
|
|
|
void map_free(map_t* x) {
|
|
mnode_t *t, *c;
|
|
|
|
c = x->root;
|
|
|
|
while (!mnode_is_empty(x->root)) {
|
|
if (!mnode_is_empty(c->left)) {
|
|
c = c->left;
|
|
} else if (!mnode_is_empty(c->right)) {
|
|
c = c->right;
|
|
} else if (!mnode_is_root(c)) {
|
|
vnode_free(&c->key, x->type);
|
|
vnode_free(&c->value, c->type);
|
|
|
|
t = c;
|
|
c = c->parent;
|
|
|
|
if (t == c->left) c->left = mnode_empty;
|
|
else c->right = mnode_empty;
|
|
|
|
free(t);
|
|
} else {
|
|
vnode_free(&c->key, x->type);
|
|
vnode_free(&c->value, c->type);
|
|
x->root = mnode_empty;
|
|
}
|
|
}
|
|
|
|
x->type = 0;
|
|
}
|
|
|
|
/*#####################################################################################################################*/
|
|
|
|
size_t map_size(const map_t* x) {
|
|
stack_t z;
|
|
size_t n;
|
|
rbnode_t* c;
|
|
|
|
stack_init(&z);
|
|
stack_push(&z, x->root);
|
|
|
|
n = 0;
|
|
|
|
if (!mnode_is_empty(x->root)) {
|
|
while ((c = stack_pop(&z))) {
|
|
++n;
|
|
if (!rbnode_is_empty(c->right)) stack_push(&z, c->right);
|
|
if (!rbnode_is_empty(c->left)) stack_push(&z, c->left);
|
|
}
|
|
}
|
|
|
|
return n;
|
|
}
|
|
|
|
/*#####################################################################################################################*/
|
|
|
|
int map_compare(const map_t* s0, const map_t* s1) {
|
|
stack_t z;
|
|
mnode_t *c0, *c1;
|
|
int cmp;
|
|
|
|
if (s0 == s1 || s0->root == s1->root)
|
|
return 0;
|
|
if (s0->type != s1->type)
|
|
return s0->type - s1->type;
|
|
|
|
stack_init(&z);
|
|
stack_push_many(&z, 2, (void*)s1, (void*)s0);
|
|
|
|
cmp = 0;
|
|
|
|
do {
|
|
c0 = stack_pop(&z);
|
|
c1 = stack_pop(&z);
|
|
|
|
if (mnode_is_empty(c0) || mnode_is_empty(c1)) {
|
|
if (c0 != c1) {
|
|
stack_flush(&z);
|
|
return mnode_is_empty(c0) ? -1 : 1;
|
|
}
|
|
} else if ((cmp = mnode_compare(c0, c1, s0->type))) {
|
|
if (c0->left == c1->right) { // == mnode_empty
|
|
cmp = mnode_compare(c0->right, c1, s0->type);
|
|
if (!cmp) cmp = mnode_compare(c0, c1->left, s0->type);
|
|
} else if (c0->right == c1->left) { // == mnode_empty
|
|
cmp = mnode_compare(c0, c1->right, s0->type);
|
|
if (!cmp) cmp = mnode_compare(c0->left, c1, s0->type);
|
|
}
|
|
|
|
if (cmp) {
|
|
stack_flush(&z);
|
|
return cmp;
|
|
}
|
|
} else stack_push_many(&z, 4, c1->right, c0->right, c1->left, c0->left);
|
|
|
|
} while (!is_null(z.value));
|
|
|
|
return 0;
|
|
}
|