#include "rotatingtree.h"

#define KEY_LOWER_THAN(key1, key2)  ((char*)(key1) < (char*)(key2))

/* The randombits() function below is a fast-and-dirty generator that

 * is probably irregular enough for our purposes.  Note that it's biased:

 * I think that ones are slightly more probable than zeroes.  It's not

 * important here, though.

 */

static unsigned int random_value = 1;

static unsigned int random_stream = 0;

static int

randombits(int bits)

{

    int result;

    if (random_stream < (1U << bits)) {

        random_value *= 1082527;

        random_stream = random_value;

    }

    result = random_stream & ((1<

    random_stream >>= bits;

    return result;

}

/* Insert a new node into the tree.

   (*root) is modified to point to the new root. */

void

RotatingTree_Add(rotating_node_t **root, rotating_node_t *node)

{

    while (*root != NULL) {

        if (KEY_LOWER_THAN(node->key, (*root)->key))

            root = &((*root)->left);

        else

            root = &((*root)->right);

    }

    node->left = NULL;

    node->right = NULL;

    *root = node;

}

/* Locate the node with the given key.  This is the most complicated

   function because it occasionally rebalances the tree to move the

   resulting node closer to the root. */

rotating_node_t *

RotatingTree_Get(rotating_node_t **root, void *key)

{

    if (randombits(3) != 4) {

        /* Fast path, no rebalancing */

        rotating_node_t *node = *root;

        while (node != NULL) {

            if (node->key == key)

                return node;

            if (KEY_LOWER_THAN(key, node->key))

                node = node->left;

            else

                node = node->right;

        }

        return NULL;

    }

    else {

        rotating_node_t **pnode = root;

        rotating_node_t *node = *pnode;

        rotating_node_t *next;

        int rotate;

        if (node == NULL)

            return NULL;

        while (1) {

            if (node->key == key)

                return node;

            rotate = !randombits(1);

            if (KEY_LOWER_THAN(key, node->key)) {

                next = node->left;

                if (next == NULL)

                    return NULL;

                if (rotate) {

                    node->left = next->right;

                    next->right = node;

                    *pnode = next;

                }

                else

                    pnode = &(node->left);

            }

            else {

                next = node->right;

                if (next == NULL)

                    return NULL;

                if (rotate) {

                    node->right = next->left;

                    next->left = node;

                    *pnode = next;

                }

                else

                    pnode = &(node->right);

            }

            node = next;

        }

    }

}

/* Enumerate all nodes in the tree.  The callback enumfn() should return

   zero to continue the enumeration, or non-zero to interrupt it.

   A non-zero value is directly returned by RotatingTree_Enum(). */

int

RotatingTree_Enum(rotating_node_t *root, rotating_tree_enum_fn enumfn,

                  void *arg)

{

    int result;

    rotating_node_t *node;

    while (root != NULL) {

        result = RotatingTree_Enum(root->left, enumfn, arg);

        if (result != 0) return result;

        node = root->right;

        result = enumfn(root, arg);

        if (result != 0) return result;

        root = node;

    }

    return 0;

}