274 lines
7.0 KiB
C
274 lines
7.0 KiB
C
// SONIC ROBO BLAST 2
|
|
//-----------------------------------------------------------------------------
|
|
// Copyright (C) 1993-1996 by id Software, Inc.
|
|
// Copyright (C) 1998-2000 by DooM Legacy Team.
|
|
// Copyright (C) 1999-2018 by Sonic Team Junior.
|
|
//
|
|
// This program is free software distributed under the
|
|
// terms of the GNU General Public License, version 2.
|
|
// See the 'LICENSE' file for more details.
|
|
//-----------------------------------------------------------------------------
|
|
/// \file m_aatree.h
|
|
/// \brief AA trees code
|
|
|
|
#include "m_aatree.h"
|
|
#include "z_zone.h"
|
|
#include "m_misc.h"
|
|
|
|
// A partial implementation of AA trees,
|
|
// according to the algorithms given on Wikipedia.
|
|
// http://en.wikipedia.org/wiki/AA_tree
|
|
|
|
typedef struct aatree_node_s
|
|
{
|
|
INT32 key;
|
|
INT32 depth;
|
|
void *value;
|
|
|
|
struct aatree_node_s *left, *right;
|
|
} aatree_node_t;
|
|
|
|
typedef struct aatree_entry_s
|
|
{
|
|
struct aatree_entry_s *next;
|
|
char *key;
|
|
void *value;
|
|
} aatree_entry_t;
|
|
|
|
struct aatree_s
|
|
{
|
|
aatree_node_t *root;
|
|
UINT32 flags;
|
|
};
|
|
|
|
aatree_t *M_AATreeAlloc(UINT32 flags)
|
|
{
|
|
aatree_t *aatree = Z_Malloc(sizeof (aatree_t), PU_STATIC, NULL);
|
|
aatree->root = NULL;
|
|
aatree->flags = flags;
|
|
return aatree;
|
|
}
|
|
|
|
static void M_AATreeFree_Node(aatree_node_t *node, bool is_string)
|
|
{
|
|
if (node->left) M_AATreeFree_Node(node->left, is_string);
|
|
if (node->right) M_AATreeFree_Node(node->right, is_string);
|
|
if (is_string)
|
|
Z_Free(node->value);
|
|
Z_Free(node);
|
|
}
|
|
|
|
void M_AATreeFree(aatree_t *aatree)
|
|
{
|
|
if (aatree->root)
|
|
M_AATreeFree_Node(aatree->root, (aatree->flags & AATREE_STRING) == AATREE_STRING);
|
|
|
|
Z_Free(aatree);
|
|
}
|
|
|
|
static aatree_node_t *M_AATreeRotateRight(aatree_node_t *node)
|
|
{
|
|
I_Assert(node->left != NULL);
|
|
aatree_node_t *newnode = node->left;
|
|
aatree_node_t *tmp = newnode->right;
|
|
newnode->right = node;
|
|
node->left = tmp;
|
|
return newnode;
|
|
}
|
|
|
|
static aatree_node_t *M_AATreeRotateLeft(aatree_node_t *node)
|
|
{
|
|
I_Assert(node->right != NULL);
|
|
aatree_node_t *newnode = node->right;
|
|
aatree_node_t *tmp = newnode->left;
|
|
newnode->left = node;
|
|
node->right = tmp;
|
|
return newnode;
|
|
}
|
|
|
|
static aatree_node_t *M_AATreeRebalance(aatree_node_t *node)
|
|
{
|
|
INT32 balance;
|
|
if (node->left == NULL && node->right == NULL)
|
|
return node;
|
|
if (node->left == NULL)
|
|
balance = -node->right->depth;
|
|
else if (node->right == NULL)
|
|
balance = node->left->depth;
|
|
else
|
|
{
|
|
I_Assert(node->left->key < node->right->key);
|
|
balance = node->left->depth - node->right->depth;
|
|
}
|
|
|
|
if (balance > 1)
|
|
{
|
|
return M_AATreeRotateRight(node);
|
|
}
|
|
else if (balance < -1)
|
|
{
|
|
return M_AATreeRotateLeft(node);
|
|
}
|
|
|
|
return node;
|
|
}
|
|
|
|
static aatree_node_t *M_AATreeSet_Node(aatree_node_t *node, UINT32 flags, INT32 key, void* value)
|
|
{
|
|
if (!node)
|
|
{
|
|
// Nothing here, so just add where we are
|
|
node = Z_Malloc(sizeof (aatree_node_t), PU_STATIC, NULL);
|
|
node->key = key;
|
|
if (value && (flags & AATREE_ZUSER)) Z_SetUser(value, &node->value);
|
|
else node->value = value;
|
|
node->left = node->right = NULL;
|
|
node->depth = 1;
|
|
}
|
|
else
|
|
{
|
|
if (key < node->key)
|
|
node->left = M_AATreeSet_Node(node->left, flags, key, value);
|
|
else if (key > node->key)
|
|
node->right = M_AATreeSet_Node(node->right, flags, key, value);
|
|
else
|
|
{
|
|
if (value && (flags & AATREE_ZUSER)) Z_SetUser(value, &node->value);
|
|
else node->value = value;
|
|
}
|
|
|
|
node = M_AATreeRebalance(node);
|
|
if (node->left == NULL && node->right == NULL)
|
|
node->depth = 1;
|
|
else if (node->left == NULL)
|
|
node->depth = node->right->depth + 1;
|
|
else if (node->right == NULL)
|
|
node->depth = node->left->depth + 1;
|
|
else if (node->left->depth > node->right->depth)
|
|
node->depth = node->left->depth + 1;
|
|
else
|
|
node->depth = node->right->depth + 1;
|
|
}
|
|
|
|
return node;
|
|
}
|
|
|
|
void M_AATreeSet(aatree_t *aatree, INT32 key, void* value)
|
|
{
|
|
I_Assert((aatree->flags & AATREE_STRING) == 0);
|
|
aatree->root = M_AATreeSet_Node(aatree->root, aatree->flags, key, value);
|
|
}
|
|
|
|
static aatree_node_t *M_AATreeSetString_Node(aatree_node_t *node, UINT32 flags, INT32 hash, const char *key, void* value)
|
|
{
|
|
if (!node)
|
|
{
|
|
// Nothing here, so just add where we are
|
|
aatree_entry_t *entry = Z_Malloc(sizeof(aatree_entry_t), PU_STATIC, NULL);
|
|
entry->next = NULL;
|
|
entry->key = Z_StrDup(key);
|
|
if (value && (flags & AATREE_ZUSER)) Z_SetUser(value, &entry->value);
|
|
else entry->value = value;
|
|
|
|
node = Z_Malloc(sizeof (aatree_node_t), PU_STATIC, NULL);
|
|
node->key = hash;
|
|
node->value = entry;
|
|
node->left = node->right = NULL;
|
|
node->depth = 1;
|
|
}
|
|
else
|
|
{
|
|
if (hash < node->key)
|
|
node->left = M_AATreeSetString_Node(node->left, flags, hash, key, value);
|
|
else if (hash > node->key)
|
|
node->right = M_AATreeSetString_Node(node->right, flags, hash, key, value);
|
|
else
|
|
{
|
|
aatree_entry_t *entry = node->value;
|
|
if (entry != NULL && !fastcmp(entry->key, key))
|
|
entry = entry->next;
|
|
if (entry != NULL)
|
|
{
|
|
if (value && (flags & AATREE_ZUSER)) Z_SetUser(value, &entry->value);
|
|
else entry->value = value;
|
|
}
|
|
else
|
|
{
|
|
entry = Z_Malloc(sizeof(aatree_entry_t), PU_STATIC, NULL);
|
|
entry->next = node->value;
|
|
entry->key = Z_StrDup(key);
|
|
if (value && (flags & AATREE_ZUSER)) Z_SetUser(value, &entry->value);
|
|
else entry->value = value;
|
|
node->value = entry;
|
|
}
|
|
}
|
|
|
|
node = M_AATreeRebalance(node);
|
|
if (node->left == NULL && node->right == NULL)
|
|
node->depth = 1;
|
|
else if (node->left == NULL)
|
|
node->depth = node->right->depth + 1;
|
|
else if (node->right == NULL)
|
|
node->depth = node->left->depth + 1;
|
|
else if (node->left->depth > node->right->depth)
|
|
node->depth = node->left->depth + 1;
|
|
else
|
|
node->depth = node->right->depth + 1;
|
|
}
|
|
|
|
return node;
|
|
}
|
|
|
|
void M_AATreeSetString(aatree_t *aatree, const char *key, void *value)
|
|
{
|
|
I_Assert((aatree->flags & AATREE_STRING) == AATREE_STRING);
|
|
UINT32 hash = FNV1a_HashString(key);
|
|
aatree->root = M_AATreeSetString_Node(aatree->root, aatree->flags, hash, key, value);
|
|
}
|
|
|
|
// Caveat: we don't distinguish between nodes that don't exists
|
|
// and nodes with value == NULL.
|
|
static void *M_AATreeGet_Node(aatree_node_t *node, INT32 key)
|
|
{
|
|
if (LIKELY(node))
|
|
{
|
|
if (UNLIKELY(node->key == key))
|
|
return node->value;
|
|
else if (node->key < key)
|
|
return M_AATreeGet_Node(node->right, key);
|
|
else
|
|
return M_AATreeGet_Node(node->left, key);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void *M_AATreeGet(aatree_t *aatree, INT32 key)
|
|
{
|
|
I_Assert((aatree->flags & AATREE_STRING) == 0);
|
|
return M_AATreeGet_Node(aatree->root, key);
|
|
}
|
|
|
|
void *M_AATreeGetString(aatree_t *aatree, const char *key)
|
|
{
|
|
I_Assert((aatree->flags & AATREE_STRING) == AATREE_STRING);
|
|
UINT32 hash = FNV1a_HashString(key);
|
|
aatree_entry_t *entry = M_AATreeGet_Node(aatree->root, hash);
|
|
while (entry != NULL && !fastcmp(entry->key, key))
|
|
entry = entry->next;
|
|
return entry != NULL ? entry->value : NULL;
|
|
}
|
|
|
|
static void M_AATreeIterate_Node(aatree_node_t *node, aatree_iter_t callback)
|
|
{
|
|
if (node->left) M_AATreeIterate_Node(node->left, callback);
|
|
callback(node->key, node->value);
|
|
if (node->right) M_AATreeIterate_Node(node->right, callback);
|
|
}
|
|
|
|
void M_AATreeIterate(aatree_t *aatree, aatree_iter_t callback)
|
|
{
|
|
if (aatree->root)
|
|
M_AATreeIterate_Node(aatree->root, callback);
|
|
}
|