mirror of
https://github.com/git-for-windows/git.git
synced 2026-04-11 01:39:10 -05:00
6c6c2cf4f9
The cbtree subsystem allows the user to store arbitrary data in a
prefix-free set of strings. This is used by us to store object IDs in a
way that we can easily iterate through them in lexicograph order, and so
that we can easily perform lookups with shortened object IDs.
In its current form, it is not easily possible to store arbitrary data
with the tree nodes. There are a couple of approaches such a caller
could try to use, but none of them really work:
- One may embed the `struct cb_node` in a custom structure. This does
not work though as `struct cb_node` contains a flex array, and
embedding such a struct in another struct is forbidden.
- One may use a `union` over `struct cb_node` and ones own data type,
which _is_ allowed even if the struct contains a flex array. This
does not work though, as the compiler may align members of the
struct so that the node key would not immediately start where the
flex array starts.
- One may allocate `struct cb_node` such that it has room for both its
key and the custom data. This has the downside though that if the
custom data is itself a pointer to allocated memory, then the leak
checker will not consider the pointer to be alive anymore.
Refactor the cbtree to drop the flex array and instead take in an
explicit offset for where to find the key, which allows the caller to
embed `struct cb_node` is a wrapper struct.
Note that this change has the downside that we now have a bit of padding
in our structure, which grows the size from 60 to 64 bytes on a 64 bit
system. On the other hand though, it allows us to get rid of the memory
copies that we previously had to do to ensure proper alignment. This
seems like a reasonable tradeoff.
Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
57 lines
1.7 KiB
C
57 lines
1.7 KiB
C
/*
|
|
* crit-bit tree implementation, does no allocations internally
|
|
* For more information on crit-bit trees: https://cr.yp.to/critbit.html
|
|
* Based on Adam Langley's adaptation of Dan Bernstein's public domain code
|
|
* git clone https://github.com/agl/critbit.git
|
|
*
|
|
* This is adapted to store arbitrary data (not just NUL-terminated C strings
|
|
* and allocates no memory internally. The user needs to allocate
|
|
* "struct cb_node" and fill cb_node.k[] with arbitrary match data
|
|
* for memcmp.
|
|
* If "klen" is variable, then it should be embedded into "c_node.k[]"
|
|
* Recursion is bound by the maximum value of "klen" used.
|
|
*/
|
|
#ifndef CBTREE_H
|
|
#define CBTREE_H
|
|
|
|
struct cb_node;
|
|
struct cb_node {
|
|
struct cb_node *child[2];
|
|
/*
|
|
* n.b. uint32_t for `byte' is excessive for OIDs,
|
|
* we may consider shorter variants if nothing else gets stored.
|
|
*/
|
|
uint32_t byte;
|
|
uint8_t otherbits;
|
|
};
|
|
|
|
struct cb_tree {
|
|
struct cb_node *root;
|
|
ptrdiff_t key_offset;
|
|
};
|
|
|
|
static inline void cb_init(struct cb_tree *t,
|
|
ptrdiff_t key_offset)
|
|
{
|
|
struct cb_tree blank = {
|
|
.key_offset = key_offset,
|
|
};
|
|
memcpy(t, &blank, sizeof(*t));
|
|
}
|
|
|
|
struct cb_node *cb_lookup(struct cb_tree *, const uint8_t *k, size_t klen);
|
|
struct cb_node *cb_insert(struct cb_tree *, struct cb_node *, size_t klen);
|
|
|
|
/*
|
|
* Callback invoked by `cb_each()` for each node in the critbit tree. A return
|
|
* value of 0 will cause the iteration to continue, a non-zero return code will
|
|
* cause iteration to abort. The error code will be relayed back from
|
|
* `cb_each()` in that case.
|
|
*/
|
|
typedef int (*cb_iter)(struct cb_node *, void *arg);
|
|
|
|
int cb_each(struct cb_tree *, const uint8_t *kpfx, size_t klen,
|
|
cb_iter, void *arg);
|
|
|
|
#endif /* CBTREE_H */
|