mirror of
https://github.com/open62541/open62541.git
synced 2025-06-03 04:00:21 +00:00
Deps: Add ziptree.h
This commit is contained in:
Julius Pfrommer
Julius Pfrommer
parent
9441890da9
commit
835b83b2f9
239
deps/ziptree.h
vendored
Normal file
239
deps/ziptree.h
vendored
Normal file
@ -0,0 +1,239 @@
|
||||
/* This Source Code Form is subject to the terms of the Mozilla Public
|
||||
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
||||
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
||||
*
|
||||
* Copyright 2018 (c) Julius Pfrommer
|
||||
*/
|
||||
|
||||
#ifndef ZIPTREE_H_
|
||||
#define ZIPTREE_H_
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* Reusable zip tree implementation. The style is inspired by the BSD
|
||||
* sys/queue.h linked list definition.
|
||||
*
|
||||
* Zip trees were developed in: Tarjan, R. E., Levy, C. C., and Timmel, S. "Zip
|
||||
* Trees." arXiv preprint arXiv:1806.06726 (2018).
|
||||
*
|
||||
* The ZIP_ENTRY definitions are to be contained in the tree entries themselves.
|
||||
* Use ZIP_PROTTYPE to define the signature of the zip tree and ZIP_IMPL (in a
|
||||
* .c compilation unit) for the method implementations.
|
||||
*
|
||||
* Zip trees are a probabilistic data structure. Entries are assigned a
|
||||
* (nonzero) rank k with probability 1/2^{k+1}. This header file does not assume
|
||||
* a specific random number generator. So the rank must be given when an entry
|
||||
* is inserted. A fast way (with a single call to a pseudo random generator) to
|
||||
* compute the rank is with ZIP_FFS32(random()). The ZIP_FFS32 returns the least
|
||||
* significant nonzero bit of a 32bit number. */
|
||||
|
||||
#define ZIP_HEAD(name, type) \
|
||||
struct name { \
|
||||
struct type *zip_root; \
|
||||
}
|
||||
|
||||
#define ZIP_INIT(head) do { (head)->zip_root = NULL; } while (0)
|
||||
#define ZIP_ROOT(head) (head)->zip_root
|
||||
#define ZIP_EMPTY(head) (ZIP_ROOT(head) == NULL)
|
||||
|
||||
#define ZIP_ENTRY(type) \
|
||||
struct { \
|
||||
struct type *zip_left; \
|
||||
struct type *zip_right; \
|
||||
unsigned char rank; \
|
||||
}
|
||||
|
||||
#define ZIP_LEFT(elm, field) (elm)->field.zip_left
|
||||
#define ZIP_RIGHT(elm, field) (elm)->field.zip_right
|
||||
#define ZIP_RANK(elm, field) (elm)->field.rank
|
||||
|
||||
/* Shortcuts */
|
||||
#define ZIP_INSERT(name, head, elm, rank) name##_ZIP_INSERT(head, elm, rank)
|
||||
#define ZIP_REMOVE(name, head, elm) name##_ZIP_REMOVE(head, elm)
|
||||
#define ZIP_FIND(name, head, key) name##_ZIP_FIND(head, key)
|
||||
#define ZIP_MIN(name, head) name##_ZIP_MIN(head)
|
||||
#define ZIP_MAX(name, head) name##_ZIP_MAX(head)
|
||||
#define ZIP_ITER(name, head, cb, d) name##_ZIP_ITER(head, cb, d)
|
||||
|
||||
/* Zip tree method prototypes */
|
||||
#define ZIP_PROTTYPE(name, type, keytype) \
|
||||
void name##_ZIP_INSERT(struct name *head, struct type *elm, unsigned char rank); \
|
||||
void name##_ZIP_REMOVE(struct name *head, struct type *elm); \
|
||||
struct type *name##_ZIP_FIND(struct name *head, const keytype *key); \
|
||||
struct type *name##_ZIP_MIN(struct name *head); \
|
||||
struct type *name##_ZIP_MAX(struct name *head); \
|
||||
typedef void (*name##_cb)(struct type *elm, void *data); \
|
||||
void name##_ZIP_ITER(struct name *head, name##_cb cb, void *data); \
|
||||
|
||||
/* The comparison method "cmp" defined for every zip tree has the signature
|
||||
*
|
||||
* enum ZIP_CMP cmpDateTime(const keytype *a, const keytype *b);
|
||||
*
|
||||
* The entries need an absolute ordering. So ZIP_CMP_EQ must only be returned if
|
||||
* a and b point to the same memory. (E.g. assured by unique identifiers.) */
|
||||
enum ZIP_CMP {
|
||||
ZIP_CMP_LESS = -1,
|
||||
ZIP_CMP_EQ = 0,
|
||||
ZIP_CMP_MORE = 1
|
||||
};
|
||||
|
||||
/* Find the position of the first bit in an unsigned 32bit integer */
|
||||
#ifdef _MSC_VER
|
||||
static __inline
|
||||
#else
|
||||
static inline
|
||||
#endif
|
||||
unsigned char
|
||||
ZIP_FFS32(unsigned int v) {
|
||||
unsigned int t = 1;
|
||||
unsigned char r = 1;
|
||||
if(v == 0) return 0;
|
||||
while((v & t) == 0) {
|
||||
t = t << 1; r++;
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
/* Zip tree method implementations */
|
||||
#define ZIP_IMPL(name, type, field, keytype, keyfield, cmp) \
|
||||
static struct type * \
|
||||
__##name##_ZIP_INSERT(struct type *root, struct type *elm) { \
|
||||
if(!root) { \
|
||||
ZIP_LEFT(elm, field) = NULL; \
|
||||
ZIP_RIGHT(elm, field) = NULL; \
|
||||
return elm; \
|
||||
} \
|
||||
if((cmp)(&(elm)->keyfield, &(root)->keyfield) == ZIP_CMP_LESS) { \
|
||||
if(__##name##_ZIP_INSERT(ZIP_LEFT(root, field), elm) == elm) { \
|
||||
if(ZIP_RANK(elm, field) < ZIP_RANK(root, field)) { \
|
||||
ZIP_LEFT(root, field) = elm; \
|
||||
} else { \
|
||||
ZIP_LEFT(root, field) = ZIP_RIGHT(elm, field); \
|
||||
ZIP_RIGHT(elm, field) = root; \
|
||||
return elm; \
|
||||
} \
|
||||
} \
|
||||
} else { \
|
||||
if(__##name##_ZIP_INSERT(ZIP_RIGHT(root, field), elm) == elm) { \
|
||||
if(ZIP_RANK(elm, field) <= ZIP_RANK(root, field)) { \
|
||||
ZIP_RIGHT(root, field) = elm; \
|
||||
} else { \
|
||||
ZIP_RIGHT(root, field) = ZIP_LEFT(elm, field); \
|
||||
ZIP_LEFT(elm, field) = root; \
|
||||
return elm; \
|
||||
} \
|
||||
} \
|
||||
} \
|
||||
return root; \
|
||||
} \
|
||||
\
|
||||
void \
|
||||
name##_ZIP_INSERT(struct name *head, struct type *elm, \
|
||||
unsigned char rank) { \
|
||||
ZIP_RANK(elm, field) = rank; \
|
||||
ZIP_ROOT(head) = __##name##_ZIP_INSERT(ZIP_ROOT(head), elm); \
|
||||
} \
|
||||
\
|
||||
static struct type * \
|
||||
__##name##ZIP(struct type *x, struct type *y) { \
|
||||
if(!x) return y; \
|
||||
if(!y) return x; \
|
||||
if(ZIP_RANK(x, field) < ZIP_RANK(y, field)) { \
|
||||
ZIP_LEFT(y, field) = __##name##ZIP(x, ZIP_LEFT(y, field)); \
|
||||
return y; \
|
||||
} \
|
||||
ZIP_RIGHT(x, field) = __##name##ZIP(ZIP_RIGHT(x, field), y); \
|
||||
return x; \
|
||||
} \
|
||||
\
|
||||
static struct type * \
|
||||
__##name##_ZIP_REMOVE(struct type *root, struct type *elm) { \
|
||||
if(root == elm) \
|
||||
return __##name##ZIP(ZIP_LEFT(root, field), \
|
||||
ZIP_RIGHT(root, field)); \
|
||||
enum ZIP_CMP eq = (cmp)(&(elm)->keyfield, &(root)->keyfield); \
|
||||
if(eq == ZIP_CMP_LESS) { \
|
||||
struct type *left = ZIP_LEFT(root, field); \
|
||||
if(elm == left) \
|
||||
ZIP_LEFT(root, field) = \
|
||||
__##name##ZIP(ZIP_LEFT(left, field), \
|
||||
ZIP_RIGHT(left, field)); \
|
||||
else \
|
||||
__##name##_ZIP_REMOVE(left, elm); \
|
||||
} else { \
|
||||
struct type *right = ZIP_RIGHT(root, field); \
|
||||
if(elm == right) \
|
||||
ZIP_RIGHT(root, field) = \
|
||||
__##name##ZIP(ZIP_LEFT(right, field), \
|
||||
ZIP_RIGHT(right, field)); \
|
||||
else \
|
||||
__##name##_ZIP_REMOVE(right, elm); \
|
||||
} \
|
||||
return root; \
|
||||
} \
|
||||
\
|
||||
void \
|
||||
name##_ZIP_REMOVE(struct name *head, struct type *elm) { \
|
||||
ZIP_ROOT(head) = __##name##_ZIP_REMOVE(ZIP_ROOT(head), elm); \
|
||||
} \
|
||||
\
|
||||
static struct type * \
|
||||
__##name##_ZIP_FIND(struct type *root, const keytype *key) { \
|
||||
if(!root) \
|
||||
return NULL; \
|
||||
enum ZIP_CMP eq = (cmp)(key, &(root)->keyfield); \
|
||||
if(eq == ZIP_CMP_EQ) { \
|
||||
return root; \
|
||||
} else if(eq == ZIP_CMP_LESS) { \
|
||||
return __##name##_ZIP_FIND(ZIP_LEFT(root, field), key); \
|
||||
} else { \
|
||||
return __##name##_ZIP_FIND(ZIP_RIGHT(root, field), key); \
|
||||
} \
|
||||
} \
|
||||
\
|
||||
struct type * \
|
||||
name##_ZIP_FIND(struct name *head, const keytype *key) { \
|
||||
return __##name##_ZIP_FIND(ZIP_ROOT(head), key); \
|
||||
} \
|
||||
\
|
||||
struct type * \
|
||||
name##_ZIP_MIN(struct name *head) { \
|
||||
struct type *cur = ZIP_ROOT(head); \
|
||||
if(!cur) return NULL; \
|
||||
while(ZIP_LEFT(cur, field)) { \
|
||||
cur = ZIP_LEFT(cur, field); \
|
||||
} \
|
||||
return cur; \
|
||||
} \
|
||||
\
|
||||
struct type * \
|
||||
name##_ZIP_MAX(struct name *head) { \
|
||||
struct type *cur = ZIP_ROOT(head); \
|
||||
if(!cur) return NULL; \
|
||||
while(ZIP_RIGHT(cur, field)) { \
|
||||
cur = ZIP_RIGHT(cur, field); \
|
||||
} \
|
||||
return cur; \
|
||||
} \
|
||||
\
|
||||
static void \
|
||||
__##name##_ZIP_ITER(struct type *elm, name##_cb cb, void *data) { \
|
||||
if(!elm) \
|
||||
return; \
|
||||
__##name##_ZIP_ITER(ZIP_LEFT(elm, field), cb, data); \
|
||||
__##name##_ZIP_ITER(ZIP_RIGHT(elm, field), cb, data); \
|
||||
cb(elm, data); \
|
||||
} \
|
||||
\
|
||||
void \
|
||||
name##_ZIP_ITER(struct name *head, name##_cb cb, void *data) { \
|
||||
__##name##_ZIP_ITER(ZIP_ROOT(head), cb, data); \
|
||||
}
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
|
||||
#endif /* ZIPTREE_H_ */
|
||||
Loading…
Reference in New Issue
Block a user