787 lines
17 KiB
C++
787 lines
17 KiB
C++
/*
|
|
AngelCode Scripting Library
|
|
Copyright (c) 2003-2013 Andreas Jonsson
|
|
|
|
This software is provided 'as-is', without any express or implied
|
|
warranty. In no event will the authors be held liable for any
|
|
damages arising from the use of this software.
|
|
|
|
Permission is granted to anyone to use this software for any
|
|
purpose, including commercial applications, and to alter it and
|
|
redistribute it freely, subject to the following restrictions:
|
|
|
|
1. The origin of this software must not be misrepresented; you
|
|
must not claim that you wrote the original software. If you use
|
|
this software in a product, an acknowledgment in the product
|
|
documentation would be appreciated but is not required.
|
|
|
|
2. Altered source versions must be plainly marked as such, and
|
|
must not be misrepresented as being the original software.
|
|
|
|
3. This notice may not be removed or altered from any source
|
|
distribution.
|
|
|
|
The original version of this library can be located at:
|
|
http://www.angelcode.com/angelscript/
|
|
|
|
Andreas Jonsson
|
|
andreas@angelcode.com
|
|
*/
|
|
|
|
|
|
//
|
|
// as_map.h
|
|
//
|
|
// This class is used for mapping a value to another
|
|
//
|
|
|
|
|
|
#ifndef AS_MAP_H
|
|
#define AS_MAP_H
|
|
|
|
template <class KEY, class VAL> struct asSMapNode;
|
|
|
|
template <class KEY, class VAL> class asCMap
|
|
{
|
|
public:
|
|
asCMap();
|
|
~asCMap();
|
|
|
|
int Insert(const KEY &key, const VAL &value);
|
|
int Insert(asSMapNode<KEY,VAL> *node);
|
|
int GetCount() const;
|
|
|
|
const KEY &GetKey(const asSMapNode<KEY,VAL> *cursor) const;
|
|
const VAL &GetValue(const asSMapNode<KEY,VAL> *cursor) const;
|
|
VAL &GetValue(asSMapNode<KEY,VAL> *cursor);
|
|
|
|
void Erase(asSMapNode<KEY,VAL> *cursor);
|
|
asSMapNode<KEY,VAL> *Remove(asSMapNode<KEY,VAL> *cursor);
|
|
void EraseAll();
|
|
|
|
void SwapWith(asCMap<KEY,VAL> &other);
|
|
|
|
// Returns true as long as cursor is valid
|
|
|
|
bool MoveTo(asSMapNode<KEY,VAL> **out, const KEY &key) const;
|
|
bool MoveFirst(asSMapNode<KEY,VAL> **out) const;
|
|
bool MoveLast(asSMapNode<KEY,VAL> **out) const;
|
|
bool MoveNext(asSMapNode<KEY,VAL> **out, asSMapNode<KEY,VAL> *cursor) const;
|
|
bool MovePrev(asSMapNode<KEY,VAL> **out, asSMapNode<KEY,VAL> *cursor) const;
|
|
|
|
// For debugging only
|
|
|
|
int CheckIntegrity(asSMapNode<KEY,VAL> *node) const;
|
|
|
|
protected:
|
|
// Don't allow value assignment
|
|
asCMap &operator=(const asCMap &) { return *this; }
|
|
|
|
void BalanceInsert(asSMapNode<KEY,VAL> *node);
|
|
void BalanceErase(asSMapNode<KEY,VAL> *child, asSMapNode<KEY,VAL> *parent);
|
|
|
|
int EraseAll(asSMapNode<KEY,VAL> *node);
|
|
int RotateLeft(asSMapNode<KEY,VAL> *node);
|
|
int RotateRight(asSMapNode<KEY,VAL> *node);
|
|
|
|
asSMapNode<KEY,VAL> *root;
|
|
asSMapNode<KEY,VAL> dummy;
|
|
|
|
int count;
|
|
};
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Implementation
|
|
|
|
// Properties of a Red-Black Tree
|
|
//
|
|
// 1. The root is always black
|
|
// 2. All single paths from the root to leafs
|
|
// contain the same amount of black nodes
|
|
// 3. No red node can have a red node as parent
|
|
|
|
#define ISRED(x) ((x != 0) && (x)->isRed)
|
|
#define ISBLACK(x) (!ISRED(x))
|
|
|
|
template <class KEY, class VAL> struct asSMapNode
|
|
{
|
|
asSMapNode() {parent = 0; left = 0; right = 0; isRed = true;}
|
|
void Init(KEY k, VAL v) {key = k; value = v; parent = 0; left = 0; right = 0; isRed = true;}
|
|
|
|
asSMapNode *parent;
|
|
asSMapNode *left;
|
|
asSMapNode *right;
|
|
bool isRed;
|
|
|
|
KEY key;
|
|
VAL value;
|
|
};
|
|
|
|
template <class KEY, class VAL>
|
|
asCMap<KEY, VAL>::asCMap()
|
|
{
|
|
root = 0;
|
|
count = 0;
|
|
}
|
|
|
|
template <class KEY, class VAL>
|
|
asCMap<KEY, VAL>::~asCMap()
|
|
{
|
|
EraseAll();
|
|
}
|
|
|
|
template <class KEY, class VAL>
|
|
void asCMap<KEY,VAL>::SwapWith(asCMap<KEY,VAL> &other)
|
|
{
|
|
asSMapNode<KEY,VAL> *tmpRoot = root;
|
|
int tmpCount = count;
|
|
|
|
root = other.root;
|
|
count = other.count;
|
|
|
|
other.root = tmpRoot;
|
|
other.count = tmpCount;
|
|
}
|
|
|
|
template <class KEY, class VAL>
|
|
void asCMap<KEY, VAL>::EraseAll()
|
|
{
|
|
EraseAll(root);
|
|
root = 0;
|
|
}
|
|
|
|
template <class KEY, class VAL>
|
|
int asCMap<KEY, VAL>::EraseAll(asSMapNode<KEY, VAL> *p)
|
|
{
|
|
if( p == 0 ) return -1;
|
|
|
|
EraseAll( p->left );
|
|
EraseAll( p->right );
|
|
|
|
typedef asSMapNode<KEY,VAL> node_t;
|
|
asDELETE(p,node_t);
|
|
|
|
count--;
|
|
|
|
return 0;
|
|
}
|
|
|
|
template <class KEY, class VAL>
|
|
int asCMap<KEY, VAL>::GetCount() const
|
|
{
|
|
return count;
|
|
}
|
|
|
|
template <class KEY, class VAL>
|
|
int asCMap<KEY, VAL>::Insert(const KEY &key, const VAL &value)
|
|
{
|
|
typedef asSMapNode<KEY,VAL> node_t;
|
|
asSMapNode<KEY,VAL> *nnode = asNEW(node_t);
|
|
if( nnode == 0 )
|
|
{
|
|
// Out of memory
|
|
return -1;
|
|
}
|
|
|
|
nnode->key = key;
|
|
nnode->value = value;
|
|
|
|
return Insert(nnode);
|
|
}
|
|
|
|
template <class KEY, class VAL>
|
|
int asCMap<KEY, VAL>::Insert(asSMapNode<KEY,VAL> *nnode)
|
|
{
|
|
// Insert the node
|
|
if( root == 0 )
|
|
root = nnode;
|
|
else
|
|
{
|
|
asSMapNode<KEY,VAL> *p = root;
|
|
for(;;)
|
|
{
|
|
if( nnode->key < p->key )
|
|
{
|
|
if( p->left == 0 )
|
|
{
|
|
nnode->parent = p;
|
|
p->left = nnode;
|
|
break;
|
|
}
|
|
else
|
|
p = p->left;
|
|
}
|
|
else
|
|
{
|
|
if( p->right == 0 )
|
|
{
|
|
nnode->parent = p;
|
|
p->right = nnode;
|
|
break;
|
|
}
|
|
else
|
|
p = p->right;
|
|
}
|
|
}
|
|
}
|
|
|
|
BalanceInsert(nnode);
|
|
|
|
count++;
|
|
|
|
return 0;
|
|
}
|
|
|
|
template <class KEY, class VAL>
|
|
void asCMap<KEY, VAL>::BalanceInsert(asSMapNode<KEY, VAL> *node)
|
|
{
|
|
// The node, that is red, can't have a red parent
|
|
while( node != root && node->parent->isRed )
|
|
{
|
|
// Check color of uncle
|
|
if( node->parent == node->parent->parent->left )
|
|
{
|
|
asSMapNode<KEY,VAL> *uncle = node->parent->parent->right;
|
|
if( ISRED(uncle) )
|
|
{
|
|
// B
|
|
// R R
|
|
// N
|
|
|
|
// Change color on parent, uncle, and grand parent
|
|
node->parent->isRed = false;
|
|
uncle->isRed = false;
|
|
node->parent->parent->isRed = true;
|
|
|
|
// Continue balancing from grand parent
|
|
node = node->parent->parent;
|
|
}
|
|
else
|
|
{
|
|
// B
|
|
// R B
|
|
// N
|
|
|
|
if( node == node->parent->right )
|
|
{
|
|
// Make the node a left child
|
|
node = node->parent;
|
|
RotateLeft(node);
|
|
}
|
|
|
|
// Change color on parent and grand parent
|
|
// Then rotate grand parent to the right
|
|
node->parent->isRed = false;
|
|
node->parent->parent->isRed = true;
|
|
RotateRight(node->parent->parent);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
asSMapNode<KEY,VAL> *uncle = node->parent->parent->left;
|
|
if( ISRED(uncle) )
|
|
{
|
|
// B
|
|
// R R
|
|
// N
|
|
|
|
// Change color on parent, uncle, and grand parent
|
|
// Continue balancing from grand parent
|
|
node->parent->isRed = false;
|
|
uncle->isRed = false;
|
|
node = node->parent->parent;
|
|
node->isRed = true;
|
|
}
|
|
else
|
|
{
|
|
// B
|
|
// B R
|
|
// N
|
|
|
|
if( node == node->parent->left )
|
|
{
|
|
// Make the node a right child
|
|
node = node->parent;
|
|
RotateRight(node);
|
|
}
|
|
|
|
// Change color on parent and grand parent
|
|
// Then rotate grand parent to the right
|
|
node->parent->isRed = false;
|
|
node->parent->parent->isRed = true;
|
|
RotateLeft(node->parent->parent);
|
|
}
|
|
}
|
|
}
|
|
|
|
root->isRed = false;
|
|
}
|
|
|
|
// For debugging purposes only
|
|
template <class KEY, class VAL>
|
|
int asCMap<KEY, VAL>::CheckIntegrity(asSMapNode<KEY, VAL> *node) const
|
|
{
|
|
if( node == 0 )
|
|
{
|
|
if( root == 0 )
|
|
return 0;
|
|
else if( ISRED(root) )
|
|
return -1;
|
|
else
|
|
node = root;
|
|
}
|
|
|
|
int left = 0, right = 0;
|
|
if( node->left )
|
|
left = CheckIntegrity(node->left);
|
|
if( node->right )
|
|
right = CheckIntegrity(node->right);
|
|
|
|
if( left != right || left == -1 )
|
|
return -1;
|
|
|
|
if( ISBLACK(node) )
|
|
return left+1;
|
|
|
|
return left;
|
|
}
|
|
|
|
// Returns true if successful
|
|
template <class KEY, class VAL>
|
|
bool asCMap<KEY, VAL>::MoveTo(asSMapNode<KEY,VAL> **out, const KEY &key) const
|
|
{
|
|
asSMapNode<KEY,VAL> *p = root;
|
|
while( p )
|
|
{
|
|
if( key < p->key )
|
|
p = p->left;
|
|
else if( key == p->key )
|
|
{
|
|
if( out ) *out = p;
|
|
return true;
|
|
}
|
|
else
|
|
p = p->right;
|
|
}
|
|
|
|
if( out ) *out = 0;
|
|
return false;
|
|
}
|
|
|
|
template <class KEY, class VAL>
|
|
void asCMap<KEY, VAL>::Erase(asSMapNode<KEY,VAL> *cursor)
|
|
{
|
|
asSMapNode<KEY,VAL> *node = Remove(cursor);
|
|
asASSERT( node == cursor );
|
|
|
|
typedef asSMapNode<KEY,VAL> node_t;
|
|
asDELETE(node,node_t);
|
|
}
|
|
|
|
template <class KEY, class VAL>
|
|
asSMapNode<KEY,VAL> *asCMap<KEY, VAL>::Remove(asSMapNode<KEY,VAL> *cursor)
|
|
{
|
|
if( cursor == 0 ) return 0;
|
|
|
|
asSMapNode<KEY,VAL> *node = cursor;
|
|
|
|
//---------------------------------------------------
|
|
// Choose the node that will replace the erased one
|
|
asSMapNode<KEY,VAL> *remove;
|
|
if( node->left == 0 || node->right == 0 )
|
|
remove = node;
|
|
else
|
|
{
|
|
remove = node->right;
|
|
while( remove->left ) remove = remove->left;
|
|
}
|
|
|
|
//--------------------------------------------------
|
|
// Remove the node
|
|
asSMapNode<KEY,VAL> *child;
|
|
if( remove->left )
|
|
child = remove->left;
|
|
else
|
|
child = remove->right;
|
|
|
|
if( child ) child->parent = remove->parent;
|
|
if( remove->parent )
|
|
{
|
|
if( remove == remove->parent->left )
|
|
remove->parent->left = child;
|
|
else
|
|
remove->parent->right = child;
|
|
}
|
|
else
|
|
root = child;
|
|
|
|
// If we remove a black node we must make sure the tree is balanced
|
|
if( ISBLACK(remove) )
|
|
BalanceErase(child, remove->parent);
|
|
|
|
//----------------------------------------
|
|
// Replace the erased node with the removed one
|
|
if( remove != node )
|
|
{
|
|
if( node->parent )
|
|
{
|
|
if( node->parent->left == node )
|
|
node->parent->left = remove;
|
|
else
|
|
node->parent->right = remove;
|
|
}
|
|
else
|
|
root = remove;
|
|
|
|
remove->isRed = node->isRed;
|
|
remove->parent = node->parent;
|
|
|
|
remove->left = node->left;
|
|
if( remove->left ) remove->left->parent = remove;
|
|
remove->right = node->right;
|
|
if( remove->right ) remove->right->parent = remove;
|
|
}
|
|
|
|
count--;
|
|
|
|
return node;
|
|
}
|
|
|
|
// Call method only if removed node was black
|
|
// child is the child of the removed node
|
|
template <class KEY, class VAL>
|
|
void asCMap<KEY, VAL>::BalanceErase(asSMapNode<KEY, VAL> *child, asSMapNode<KEY, VAL> *parent)
|
|
{
|
|
// If child is red
|
|
// Color child black
|
|
// Terminate
|
|
|
|
// These tests assume brother is to the right.
|
|
|
|
// 1. Brother is red
|
|
// Color parent red and brother black
|
|
// Rotate parent left
|
|
// Transforms to 2b
|
|
// 2a. Parent and brother is black, brother's children are black
|
|
// Color brother red
|
|
// Continue test with parent as child
|
|
// 2b. Parent is red, brother is black, brother's children are black
|
|
// Color parent black and brother red
|
|
// Terminate
|
|
// 3. Brother is black, and brother's left is red and brother's right is black
|
|
// Color brother red and brother's left black
|
|
// Rotate brother to right
|
|
// Transforms to 4.
|
|
// 4. Brother is black, brother's right is red
|
|
// Color brother's right black
|
|
// Color brother to color of parent
|
|
// Color parent black
|
|
// Rotate parent left
|
|
// Terminate
|
|
|
|
while( child != root && ISBLACK(child) )
|
|
{
|
|
if( child == parent->left )
|
|
{
|
|
asSMapNode<KEY,VAL> *brother = parent->right;
|
|
|
|
// Case 1
|
|
if( ISRED(brother) )
|
|
{
|
|
brother->isRed = false;
|
|
parent->isRed = true;
|
|
RotateLeft(parent);
|
|
brother = parent->right;
|
|
}
|
|
|
|
// Case 2
|
|
if( brother == 0 ) break;
|
|
if( ISBLACK(brother->left) && ISBLACK(brother->right) )
|
|
{
|
|
// Case 2b
|
|
if( ISRED(parent) )
|
|
{
|
|
parent->isRed = false;
|
|
brother->isRed = true;
|
|
break;
|
|
}
|
|
|
|
brother->isRed = true;
|
|
child = parent;
|
|
parent = child->parent;
|
|
}
|
|
else
|
|
{
|
|
// Case 3
|
|
if( ISBLACK(brother->right) )
|
|
{
|
|
brother->left->isRed = false;
|
|
brother->isRed = true;
|
|
RotateRight(brother);
|
|
brother = parent->right;
|
|
}
|
|
|
|
// Case 4
|
|
brother->isRed = parent->isRed;
|
|
parent->isRed = false;
|
|
brother->right->isRed = false;
|
|
RotateLeft(parent);
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
asSMapNode<KEY,VAL> *brother = parent->left;
|
|
|
|
// Case 1
|
|
if( ISRED(brother) )
|
|
{
|
|
brother->isRed = false;
|
|
parent->isRed = true;
|
|
RotateRight(parent);
|
|
brother = parent->left;
|
|
}
|
|
|
|
// Case 2
|
|
if( brother == 0 ) break;
|
|
if( ISBLACK(brother->left) && ISBLACK(brother->right) )
|
|
{
|
|
// Case 2b
|
|
if( ISRED(parent) )
|
|
{
|
|
parent->isRed = false;
|
|
brother->isRed = true;
|
|
break;
|
|
}
|
|
|
|
brother->isRed = true;
|
|
child = parent;
|
|
parent = child->parent;
|
|
}
|
|
else
|
|
{
|
|
// Case 3
|
|
if( ISBLACK(brother->left) )
|
|
{
|
|
brother->right->isRed = false;
|
|
brother->isRed = true;
|
|
RotateLeft(brother);
|
|
brother = parent->left;
|
|
}
|
|
|
|
// Case 4
|
|
brother->isRed = parent->isRed;
|
|
parent->isRed = false;
|
|
brother->left->isRed = false;
|
|
RotateRight(parent);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if( child )
|
|
child->isRed = false;
|
|
}
|
|
|
|
template <class KEY, class VAL>
|
|
int asCMap<KEY, VAL>::RotateRight(asSMapNode<KEY, VAL> *node)
|
|
{
|
|
// P L //
|
|
// / \ / \ //
|
|
// L R => Ll P //
|
|
// / \ / \ //
|
|
// Ll Lr Lr R //
|
|
|
|
if( node->left == 0 ) return -1;
|
|
|
|
asSMapNode<KEY,VAL> *left = node->left;
|
|
|
|
// Update parent
|
|
if( node->parent )
|
|
{
|
|
asSMapNode<KEY,VAL> *parent = node->parent;
|
|
if( parent->left == node )
|
|
parent->left = left;
|
|
else
|
|
parent->right = left;
|
|
|
|
left->parent = parent;
|
|
}
|
|
else
|
|
{
|
|
root = left;
|
|
left->parent = 0;
|
|
}
|
|
|
|
// Move left's right child to node's left child
|
|
node->left = left->right;
|
|
if( node->left ) node->left->parent = node;
|
|
|
|
// Put node as left's right child
|
|
left->right = node;
|
|
node->parent = left;
|
|
|
|
return 0;
|
|
}
|
|
|
|
template <class KEY, class VAL>
|
|
int asCMap<KEY, VAL>::RotateLeft(asSMapNode<KEY, VAL> *node)
|
|
{
|
|
// P R //
|
|
// / \ / \ //
|
|
// L R => P Rr //
|
|
// / \ / \ //
|
|
// Rl Rr L Rl //
|
|
|
|
if( node->right == 0 ) return -1;
|
|
|
|
asSMapNode<KEY,VAL> *right = node->right;
|
|
|
|
// Update parent
|
|
if( node->parent )
|
|
{
|
|
asSMapNode<KEY,VAL> *parent = node->parent;
|
|
if( parent->right == node )
|
|
parent->right = right;
|
|
else
|
|
parent->left = right;
|
|
|
|
right->parent = parent;
|
|
}
|
|
else
|
|
{
|
|
root = right;
|
|
right->parent = 0;
|
|
}
|
|
|
|
// Move right's left child to node's right child
|
|
node->right = right->left;
|
|
if( node->right ) node->right->parent = node;
|
|
|
|
// Put node as right's left child
|
|
right->left = node;
|
|
node->parent = right;
|
|
|
|
return 0;
|
|
}
|
|
|
|
template <class KEY, class VAL>
|
|
const VAL &asCMap<KEY, VAL>::GetValue(const asSMapNode<KEY,VAL> *cursor) const
|
|
{
|
|
if( cursor == 0 )
|
|
return dummy.value;
|
|
|
|
return cursor->value;
|
|
}
|
|
|
|
template <class KEY, class VAL>
|
|
VAL &asCMap<KEY, VAL>::GetValue(asSMapNode<KEY,VAL> *cursor)
|
|
{
|
|
if( cursor == 0 )
|
|
return dummy.value;
|
|
|
|
return cursor->value;
|
|
}
|
|
|
|
template <class KEY, class VAL>
|
|
const KEY &asCMap<KEY, VAL>::GetKey(const asSMapNode<KEY,VAL> *cursor) const
|
|
{
|
|
if( cursor == 0 )
|
|
return dummy.key;
|
|
|
|
return cursor->key;
|
|
}
|
|
|
|
template <class KEY, class VAL>
|
|
bool asCMap<KEY, VAL>::MoveFirst(asSMapNode<KEY,VAL> **out) const
|
|
{
|
|
*out = root;
|
|
if( root == 0 ) return false;
|
|
|
|
while( (*out)->left )
|
|
*out = (*out)->left;
|
|
|
|
return true;
|
|
}
|
|
|
|
template <class KEY, class VAL>
|
|
bool asCMap<KEY, VAL>::MoveLast(asSMapNode<KEY,VAL> **out) const
|
|
{
|
|
*out = root;
|
|
if( root == 0 ) return false;
|
|
|
|
while( (*out)->right )
|
|
*out = (*out)->right;
|
|
|
|
return true;
|
|
}
|
|
|
|
template <class KEY, class VAL>
|
|
bool asCMap<KEY, VAL>::MoveNext(asSMapNode<KEY,VAL> **out, asSMapNode<KEY,VAL> *cursor) const
|
|
{
|
|
if( cursor == 0 )
|
|
{
|
|
*out = 0;
|
|
return false;
|
|
}
|
|
|
|
if( cursor->right == 0 )
|
|
{
|
|
// Move upwards until we find a parent node to the right
|
|
while( cursor->parent && cursor->parent->right == cursor )
|
|
cursor = cursor->parent;
|
|
|
|
cursor = cursor->parent;
|
|
*out = cursor;
|
|
if( cursor == 0 )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
cursor = cursor->right;
|
|
while( cursor->left )
|
|
cursor = cursor->left;
|
|
|
|
*out = cursor;
|
|
return true;
|
|
}
|
|
|
|
template <class KEY, class VAL>
|
|
bool asCMap<KEY, VAL>::MovePrev(asSMapNode<KEY,VAL> **out, asSMapNode<KEY,VAL> *cursor) const
|
|
{
|
|
if( cursor == 0 )
|
|
{
|
|
*out = 0;
|
|
return false;
|
|
}
|
|
|
|
if( cursor->left == 0 )
|
|
{
|
|
// Move upwards until we find a parent node to the left
|
|
while( cursor->parent && cursor->parent->left == cursor )
|
|
cursor = cursor->parent;
|
|
|
|
cursor = cursor->parent;
|
|
|
|
*out = cursor;
|
|
if( cursor == 0 )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
cursor = cursor->left;
|
|
while( cursor->right )
|
|
cursor = cursor->right;
|
|
|
|
*out = cursor;
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
|
|
#endif
|
|
|