Overwriting insert. Just a wrapper for raxGenericInsert() that will * update the element if there is already one for the same key. */

Get the node auxiliary data. */

Free a whole radix tree. */

Allocate a new rax and return its pointer. On out of memory the function * returns NULL. */

Append characters at the current key string of the iterator 'it'. This * is a low level function used to implement the iterator, not callable by * t

Return the UNIX time in microseconds */

Perform a fuzz test, returns 0 on success, 1 on error. */

Seek an iterator at the specified element. * Return 0 if the seek failed for syntax error or out of memory. Otherwise * 1 is returned. When 0 is ret

Find a key in the rax, returns raxNotFound special void pointer value * if the item was not found, otherwise the value associated with the * item is

Initialize a Rax iterator. This call should be performed a single time * to initialize the iterator, and must be followed by a raxSeek() call, * oth

Free the iterator. */

Set the node auxiliary data to the specified pointer. */

Go to the next element in the scope of the iterator 'it'. * If EOF (or out of memory) is reached, 0 is returned, otherwise 1 is * returned. In case

Push an item into the stack, returns 1 on success, 0 on out of memory. */

Pop an item from the stack, the function returns NULL if there are no * items to pop. */

Do an iteration step towards the next element. At the end of the step the * iterator key will represent the (new) current key. If it is not possible

Remove the specified item. Returns 1 if the item was found and * deleted, 0 otherwise. */

Like raxIteratorNextStep() but implements an iteration step moving * to the lexicographically previous element. The 'noup' option has a similar * ef

Low level function that walks the tree looking for the string * 's' of 'len' bytes. The function returns the number of characters * of the key that

Allocate a new non compressed node with the specified number of children. * If datafiled is true, the allocation is made large enough to hold the *

Return the number of elements inside the radix tree. */

Free the stack in case we used heap allocation. */

Low level hash table lookup function. */

Remove the specified number of chars from the right of the current * iterator key. */

Go to the previous element in the scope of the iterator 'it'. * If EOF (or out of memory) is reached, 0 is returned, otherwise 1 is * returned. In c

Seek the greatest key in the subtree at the current node. Return 0 on * out of memory, otherwise 1. This is an helper function for different * itera

Show a tree, as outlined in the comment above. */

Utility functions used with qsort() in order to sort the array of strings * in the same way Rax sorts keys (which is, lexicographically considering

djb2 hash function. */

Return the memory address where the 'parent' node stores the specified * 'child' pointer, so that the caller can update the pointer with another * o

Insert the element 's' of size 'len', setting as auxiliary data * the pointer 'data'. If the element is already present, the associated * data is up

realloc the node to make room for auxiliary data in order * to store an item in that node. On out of memory NULL is returned. */

Initialize the stack. */

Seek an element in the array, returning the seek index (the index inside the * array). If the seek is not possible (== operator and key not found or

Redis Cluster alike fuzz testing. * * This test simulates the radix tree usage made by Redis Cluster in order * to maintain the hash slot -> keys m

Add an elmenet to the hash table, return 1 if the element is new, * 0 if it existed and the value was updated to the new one. */

Find an element inside the hash table. Returns htNotFound if the * element is not there, otherwise returns the associated value. */

Free the whole hash table including all the linked nodes. */

Create a new hash table. */

Remove the specified element, returns 1 on success, 0 if the element * was not there already. */

Turn an uint32_t integer into an alphanumerical key and return its * length. This function is used in order to generate keys that have * a large cha

This is a simple Feistel network in order to turn every possible * uint32_t input into another "randomly" looking uint32_t. It is a * one to one map

Test the random walk function. */

Add a new child to the node 'n' representing the character 'c' and return * its new pointer, as well as the child pointer by reference. Additionally

Turn the node 'n', that must be a node without any children, into a * compressed node representing a set of nodes linked one after the other * and h

Free a whole radix tree, calling the specified callback in order to * free the auxiliary data. */

Perform a random walk starting in the current position of the iterator. * Return 0 if the tree is empty or on out of memory. Otherwise 1 is returned

This is the core of raxFree(): performs a depth-first scan of the * tree and releases all the nodes found. */

The actual implementation of raxShow(). */

Low level child removal from node. The new node pointer (after the child * removal) is returned. Note that this function does not fix the pointer *

Return the stack item at the top of the stack without actually consuming * it. */

Non overwriting insert function: this if an element with the same key * exists, the value is not updated and the function returns 0. * This is a jus

Regression test #1: Iterator wrong element returned after seek. */

Regression test #2: Crash when mixing NULL and not NULL values. */

Regression test #3: Wrong access at node value in raxRemoveChild() * when iskey == 1 and isnull == 1: the memmove() was performed including * the va

Regression test #4: Github issue #8, iterator does not populate the * data field after seek in case of exact match. The test case is looks odd * bec

Less than seek bug when stopping in the middle of a compressed node. */

Seek may not populate iterator data. See issue #25. */

Compressed nodes can only hold (2^29)-1 characters, so it is important * to test for keys bigger than this amount, in order to make sure that * the

Test that raxInsert() / raxTryInsert() overwrite semantic * works as expected. */

Compare the key currently pointed by the iterator to the specified * key according to the specified operator. Returns 1 if the comparison is * true,

Used by debugnode() macro to show info about a given node. */

Return if the iterator is in an EOF state. This happens when raxSeek() * failed to seek an appropriate element, so that raxNext() or raxPrev() * wil

When debug messages are enabled, turn them on/off dynamically. By * default they are enabled. Set the state to 0 to disable, and 1 to * re-enable. *

Touch all the nodes of a tree returning a check sum. This is useful * in order to make Valgrind detect if there is something wrong while * reading t