1630 lines
46 KiB
C++
1630 lines
46 KiB
C++
////////////////////////////////////////////////////////////////////////////////////////
|
|
// RAVEN STANDARD TEMPLATE LIBRARY
|
|
// (c) 2002 Activision
|
|
//
|
|
//
|
|
// Map
|
|
// ---
|
|
// This map is based on a red black tree, which guarentees balanced data, no mater what
|
|
// order elements are added. The map uses a memory pool for storage of node data.
|
|
//
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////////////////
|
|
#if !defined(RATL_MAP_VS_INC)
|
|
#define RATL_MAP_VS_INC
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////
|
|
// Includes
|
|
////////////////////////////////////////////////////////////////////////////////////////
|
|
#if defined(RA_DEBUG_LINKING)
|
|
#pragma message("...including map_vs.h")
|
|
#endif
|
|
#if !defined(RATL_COMMON_INC)
|
|
#include "ratl_common.h"
|
|
#endif
|
|
#if !defined(RATL_POOL_VS_INC)
|
|
#include "pool_vs.h"
|
|
#endif
|
|
namespace ratl
|
|
{
|
|
|
|
|
|
// this is private to the set, but you have no access to it, soooo..
|
|
|
|
class tree_node
|
|
{
|
|
int mParent;
|
|
int mLeft;
|
|
int mRight;
|
|
public:
|
|
enum
|
|
{
|
|
RED_BIT = 0x40000000, // to save space we are putting the red bool in a high bit
|
|
// this is in the parent only
|
|
NULL_NODE = 0x3fffffff, // this must not have the red bit set
|
|
};
|
|
void init()
|
|
{
|
|
mLeft = NULL_NODE;
|
|
mRight = NULL_NODE;
|
|
mParent = NULL_NODE | RED_BIT;
|
|
}
|
|
int left() const
|
|
{
|
|
return mLeft;
|
|
}
|
|
int right() const
|
|
{
|
|
return mRight;
|
|
}
|
|
int parent() const
|
|
{
|
|
return mParent & (~RED_BIT);
|
|
}
|
|
bool red() const
|
|
{
|
|
return !!(mParent & RED_BIT);
|
|
}
|
|
void set_left(int l)
|
|
{
|
|
mLeft = l;
|
|
}
|
|
void set_right(int r)
|
|
{
|
|
mRight = r;
|
|
}
|
|
void set_parent(int p)
|
|
{
|
|
mParent &= RED_BIT;
|
|
mParent |= p;
|
|
}
|
|
void set_red(bool isRed)
|
|
{
|
|
if (isRed)
|
|
{
|
|
mParent |= RED_BIT;
|
|
}
|
|
else
|
|
{
|
|
mParent &= ~RED_BIT;
|
|
}
|
|
}
|
|
};
|
|
|
|
//fixme void *, comparison function pointer-ize this for code bloat.
|
|
|
|
template<class T, int IS_MULTI>
|
|
class tree_base
|
|
{
|
|
public:
|
|
typedef typename T TStorageTraits;
|
|
typedef typename T::TValue TTValue;
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// Capacity Enum
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
enum
|
|
{
|
|
CAPACITY = T::CAPACITY,
|
|
};
|
|
private:
|
|
pool_base<TStorageTraits> mPool; // The Allocation Data Pool
|
|
int mRoot;
|
|
int mLastAdd;
|
|
|
|
|
|
void link_left(int node,int left)
|
|
{
|
|
T::node(mPool[node]).set_left(left);
|
|
if (left!=tree_node::NULL_NODE)
|
|
{
|
|
T::node(mPool[left]).set_parent(node);
|
|
}
|
|
}
|
|
|
|
void link_right(int node,int right)
|
|
{
|
|
T::node(mPool[node]).set_right(right);
|
|
if (right!=tree_node::NULL_NODE)
|
|
{
|
|
T::node(mPool[right]).set_parent(node);
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// This is the map internal recursive find function - do not use externally
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
int find_internal(const TTValue &key, int at) const
|
|
{
|
|
|
|
// FAIL TO FIND?
|
|
//---------------
|
|
if (at==tree_node::NULL_NODE)
|
|
{
|
|
return tree_node::NULL_NODE;
|
|
}
|
|
|
|
// Should We Search Left?
|
|
//------------------------
|
|
if (key<mPool[at])
|
|
{
|
|
return find_internal(key, T::node(mPool[at]).left());
|
|
}
|
|
|
|
// Should We Search Right?
|
|
//------------------------
|
|
else if (mPool[at]<key)
|
|
{
|
|
return find_internal(key, T::node(mPool[at]).right());
|
|
}
|
|
|
|
// FOUND!
|
|
//--------
|
|
return at;
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// This is the map internal recursive find function - do not use externally
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
int find_internal(const TTValue &key, int target, int at, int& parent) const
|
|
{
|
|
// FAIL TO FIND?
|
|
//---------------
|
|
if (at==tree_node::NULL_NODE)
|
|
{
|
|
parent = tree_node::NULL_NODE;
|
|
return tree_node::NULL_NODE;
|
|
}
|
|
|
|
// FOUND!
|
|
//--------
|
|
if (at==target)
|
|
{
|
|
if (at==mRoot)
|
|
{
|
|
parent = tree_node::NULL_NODE;
|
|
}
|
|
return at;
|
|
}
|
|
|
|
// Should We Search Left?
|
|
//------------------------
|
|
if (key<mPool[at])
|
|
{
|
|
parent = at;
|
|
return find_internal(key, target, T::node(mPool[at]).left(), parent);
|
|
}
|
|
|
|
parent = at;
|
|
return find_internal(key, target, T::node(mPool[at]).right(), parent);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// This is the map internal recursive insertion - do not use externally
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
int insert_internal(const TTValue &key, int &at)
|
|
{
|
|
// If At Is A NULL_NODE, We Have Found A Leaf.
|
|
//----------------------------------------------
|
|
if (at==tree_node::NULL_NODE)
|
|
{
|
|
if (mRoot==tree_node::NULL_NODE)
|
|
{
|
|
mRoot = mLastAdd;
|
|
}
|
|
return tree_node::NULL_NODE; // There Are No Excess Red Children (No Childeren At All, Actually)
|
|
}
|
|
|
|
|
|
int nxtChild; // The Child We Will Eventually Add Underneath
|
|
int altChild; // The "other" Child
|
|
bool nxtRotateLeft;
|
|
int excessRedChild; // If The Insert Results In An Excess Red Child, This Will Be It
|
|
|
|
|
|
// Choose Which Side To Add The New Node Under
|
|
//---------------------------------------------
|
|
if (key < mPool[at]) // The Key Classes Must Support A < Operator
|
|
{
|
|
int tmp=T::node(mPool[at]).left();
|
|
excessRedChild = insert_internal(key,tmp);
|
|
link_left(at,tmp);//T::node(mPool[at]).set_left(tmp);
|
|
|
|
if (tmp==tree_node::NULL_NODE)
|
|
{
|
|
|
|
link_left(at,mLastAdd);//T::node(mPool[at]).set_left(mLastAdd); // If mLeft Of The Current Node Is NULL, We Must Have Added DIRECTLY Below nAt
|
|
}
|
|
nxtChild = T::node(mPool[at]).left();
|
|
altChild = T::node(mPool[at]).right();
|
|
nxtRotateLeft = false;
|
|
}
|
|
else if (mPool[at] < key)
|
|
{
|
|
int tmp=T::node(mPool[at]).right();
|
|
excessRedChild = insert_internal(key,tmp);
|
|
link_right(at,tmp); // T::node(mPool[at]).set_right(tmp);
|
|
|
|
if (tmp==tree_node::NULL_NODE)
|
|
{
|
|
link_right(at,mLastAdd); // T::node(mPool[at]).set_right(mLastAdd); // If mRight Of The Current Node Is NULL, We Must Have Added DIRECTLY Below nAt
|
|
}
|
|
nxtChild = T::node(mPool[at]).right();
|
|
altChild = T::node(mPool[at]).left();
|
|
nxtRotateLeft = true;
|
|
}
|
|
|
|
// Exact Match
|
|
//-------------
|
|
else
|
|
{
|
|
// the node of interest is at
|
|
return tree_node::NULL_NODE;
|
|
}
|
|
|
|
|
|
// If The Add Resulted In An Excess Red Child, We Need To Change Colors And Rotate
|
|
//---------------------------------------------------------------------------------
|
|
if (excessRedChild!=tree_node::NULL_NODE)
|
|
{
|
|
// If Both Childeren Are Red, Just Switch And Be Done
|
|
//----------------------------------------------------
|
|
if (T::node(mPool[at]).right()!=tree_node::NULL_NODE &&
|
|
T::node(mPool[at]).left()!=tree_node::NULL_NODE &&
|
|
T::node(mPool[T::node(mPool[at]).right()]).red() &&
|
|
T::node(mPool[T::node(mPool[at]).left()]).red())
|
|
{
|
|
set_colors(T::node(mPool[at]), true, false);
|
|
}
|
|
else
|
|
{
|
|
int excessRedChildCompare =
|
|
(nxtRotateLeft)?(T::node(mPool[nxtChild]).right()):(T::node(mPool[nxtChild]).left());
|
|
if (excessRedChild==excessRedChildCompare)
|
|
{
|
|
// Single Rotation
|
|
//-----------------
|
|
rotate(at, nxtRotateLeft);
|
|
}
|
|
else
|
|
{
|
|
if (nxtRotateLeft)
|
|
{
|
|
int nxt=T::node(mPool[at]).right();
|
|
rotate(nxt, false);
|
|
link_right(at,nxt); // T::node(mPool[at]).set_right(nxt);
|
|
}
|
|
else
|
|
{
|
|
int nxt=T::node(mPool[at]).left();
|
|
rotate(nxt,true);
|
|
link_left(at,nxt); // T::node(mPool[at]).set_left(nxt);
|
|
}
|
|
rotate(at, nxtRotateLeft);
|
|
}
|
|
|
|
set_colors(T::node(mPool[at]), false, true);
|
|
}
|
|
}
|
|
|
|
if (T::node(mPool[at]).red())
|
|
{
|
|
if (T::node(mPool[at]).left()!=tree_node::NULL_NODE &&
|
|
T::node(mPool[T::node(mPool[at]).left()]).red())
|
|
{
|
|
return T::node(mPool[at]).left();
|
|
}
|
|
if (T::node(mPool[at]).right()!=tree_node::NULL_NODE &&
|
|
T::node(mPool[T::node(mPool[at]).right()]).red())
|
|
{
|
|
return T::node(mPool[at]).right();
|
|
}
|
|
}
|
|
return tree_node::NULL_NODE;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// This is the map internal recursive erase - do not use externally
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
bool erase_internal(const TTValue &key, int& at)
|
|
{
|
|
// If At Is A NULL_NODE, We Have Found A Leaf.
|
|
//---------------------------------------------
|
|
if (at==tree_node::NULL_NODE)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
//==============================================================================
|
|
// Now The Question Is, Do We Need To Continue Searching?
|
|
//==============================================================================
|
|
|
|
|
|
// Recurse To The Left?
|
|
//----------------------
|
|
if (key < mPool[at])
|
|
{
|
|
int a=T::node(mPool[at]).left();
|
|
bool r=erase_internal(key, a);
|
|
link_left(at,a); // T::node(mPool[at]).set_left(a);
|
|
if (!r) // If It Was Not Red, We Need To Rebalance
|
|
{
|
|
return rebalance(at, true);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Recurse To The Right?
|
|
//-----------------------
|
|
if (mPool[at] < key)
|
|
{
|
|
int a=T::node(mPool[at]).right();
|
|
bool r=erase_internal(key, a);
|
|
link_right(at,a); // T::node(mPool[at]).set_right(a);
|
|
if (!r) // If It Was Not Red, We Need To Rebalance
|
|
{
|
|
return rebalance(at, false);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//==============================================================================
|
|
// At This Point, We Must Have Discovered An Exact Match For Our Key
|
|
//==============================================================================
|
|
|
|
|
|
// Are There Any Open Childeren Slots?
|
|
//-------------------------------------
|
|
if (T::node(mPool[at]).left()==tree_node::NULL_NODE || T::node(mPool[at]).right()==tree_node::NULL_NODE)
|
|
{
|
|
bool atWasRed = T::node(mPool[at]).red();
|
|
int oldAt = at;
|
|
|
|
at = (T::node(mPool[at]).left()==tree_node::NULL_NODE)?(T::node(mPool[at]).right()):(T::node(mPool[at]).left()); // If Left Is Null, At Goes Right
|
|
|
|
// Actually Free It!
|
|
//-------------------
|
|
mPool.free(oldAt);
|
|
|
|
// If We Are Now At A Null Node, Just Return
|
|
//-------------------------------------------
|
|
if (at==tree_node::NULL_NODE)
|
|
{
|
|
return atWasRed;
|
|
}
|
|
|
|
// Otherwise, Mark The New Child As Red, And Return That Fact Up
|
|
//---------------------------------------------------------------
|
|
T::node(mPool[at]).set_red(false);
|
|
return true;
|
|
}
|
|
|
|
|
|
//==============================================================================
|
|
// There Are No Childeren To Link With, We Are In The Middle Of The Tree.
|
|
// We Need To Find An Open Leaf, Swap Data With That Leaf, and Then Go Find It
|
|
//==============================================================================
|
|
|
|
// Find A Successor Leaf
|
|
//-----------------------
|
|
int at_parent = T::node(mPool[at]).parent();
|
|
int successor = T::node(mPool[at]).right();
|
|
|
|
int parent_successor=-1;
|
|
while(T::node(mPool[successor]).left()!=tree_node::NULL_NODE)
|
|
{
|
|
parent_successor=successor;
|
|
successor = T::node(mPool[successor]).left();
|
|
}
|
|
|
|
int successor_right = T::node(mPool[successor]).right();
|
|
|
|
|
|
link_left(successor,T::node(mPool[at]).left());
|
|
|
|
bool red=T::node(mPool[successor]).red();
|
|
T::node(mPool[successor]).set_red(T::node(mPool[at]).red());
|
|
T::node(mPool[at]).set_red(red);
|
|
|
|
if (parent_successor!=-1)
|
|
{
|
|
|
|
link_right(successor,T::node(mPool[at]).right());
|
|
link_left(parent_successor,at);
|
|
}
|
|
else
|
|
{
|
|
link_right(successor,at);
|
|
}
|
|
|
|
if (at_parent!=tree_node::NULL_NODE)
|
|
{
|
|
if (T::node(mPool[at_parent]).left()==at)
|
|
{
|
|
//my parents left child
|
|
link_left(at_parent,successor);
|
|
}
|
|
else
|
|
{
|
|
assert(T::node(mPool[at_parent]).right()==at); // better be my parents right child then
|
|
link_right(at_parent,successor);
|
|
}
|
|
}
|
|
|
|
link_left(at,tree_node::NULL_NODE);
|
|
link_right(at,successor_right);
|
|
|
|
at=successor;
|
|
int a=T::node(mPool[at]).right();
|
|
bool r=erase_internal(key, a);
|
|
link_right(at,a); // T::node(mPool[at]).set_right(a);
|
|
// And Keep Going
|
|
//----------------
|
|
if (!r) // If It Was Not Red, We Need To Rebalance
|
|
{
|
|
return rebalance(at, false);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// HELPER: Change the color of a node and children
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
void set_colors(tree_node& at, bool red, bool childRed)
|
|
{
|
|
at.set_red(red);
|
|
if (at.left()!=tree_node::NULL_NODE)
|
|
{
|
|
T::node(mPool[at.left()]).set_red(childRed);
|
|
}
|
|
if (at.right()!=tree_node::NULL_NODE)
|
|
{
|
|
T::node(mPool[at.right()]).set_red(childRed);
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// HELPER: Rotate node located at (at) either left or right
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
void rotate(int& at, bool left)
|
|
{
|
|
int t;
|
|
if (left)
|
|
{
|
|
assert(T::node(mPool[at]).right()!=tree_node::NULL_NODE);
|
|
|
|
t = T::node(mPool[at]).right();
|
|
link_right(at,T::node(mPool[t]).left()); // T::node(mPool[at]).set_right(T::node(mPool[t]).left());
|
|
link_left(t,at); // T::node(mPool[t]).set_left(at);
|
|
at = t;
|
|
}
|
|
else
|
|
{
|
|
assert(T::node(mPool[at]).left()!=tree_node::NULL_NODE);
|
|
|
|
t = T::node(mPool[at]).left();
|
|
link_left(at,T::node(mPool[t]).right()); // T::node(mPool[at]).set_left(T::node(mPool[t]).right());
|
|
link_right(t,at); //T::node(mPool[t]).set_right(at);
|
|
at = t;
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// HELPER: Localally rebalance the tree here
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
bool rebalance(int& at, bool left)
|
|
{
|
|
// Decide Which Child, Left Or Right?
|
|
//------------------------------------
|
|
int w = (left)?(T::node(mPool[at]).right()):(T::node(mPool[at]).left()); // w is the child of at
|
|
if (w==tree_node::NULL_NODE)
|
|
{
|
|
bool atWasRed = T::node(mPool[at]).red(); // Remember what mPool[at] WAS
|
|
T::node(mPool[at]).set_red(false); // Mark mPool[at] as BLACK
|
|
return atWasRed; // Return what it used to be
|
|
}
|
|
|
|
|
|
// Get A Reference To The Child W, And Record It's Children x And y
|
|
//------------------------------------------------------------------
|
|
tree_node& wAt = T::node(mPool[w]);
|
|
int x = (left)?(wAt.left()):(wAt.right());// x and y are the grand children of at
|
|
int y = (left)?(wAt.right()):(wAt.left());
|
|
|
|
|
|
// Is The Child Black?
|
|
//---------------------
|
|
if (!wAt.red())
|
|
{
|
|
// If Both X and Y are Empty, Or Both Are Red
|
|
//--------------------------------------------
|
|
if ((x==tree_node::NULL_NODE || !T::node(mPool[x]).red()) &&
|
|
(y==tree_node::NULL_NODE || !T::node(mPool[y]).red()))
|
|
{
|
|
bool atWasRed = T::node(mPool[at]).red(); // Remember what mPool[at] WAS
|
|
T::node(mPool[at]).set_red(false); // Mark mPool[at] as BLACK
|
|
wAt.set_red(true); // Mark The Child As RED
|
|
return atWasRed; // Return what it used to be
|
|
}
|
|
|
|
// If Y Is Valid
|
|
//---------------
|
|
if (y!=tree_node::NULL_NODE && T::node(mPool[y]).red())
|
|
{
|
|
wAt.set_red(T::node(mPool[at]).red());
|
|
rotate(at, left);
|
|
T::node(mPool[T::node(mPool[at]).left()]).set_red(false);
|
|
T::node(mPool[T::node(mPool[at]).right()]).set_red(false);
|
|
return true;
|
|
}
|
|
|
|
// X Must Be Valid
|
|
//-----------------
|
|
T::node(mPool[x]).set_red(T::node(mPool[at]).red());
|
|
T::node(mPool[at]).set_red(false);
|
|
|
|
if (left)
|
|
{
|
|
int r=T::node(mPool[at]).right();
|
|
rotate(r,false);
|
|
link_right(at,r); // T::node(mPool[at]).set_right(r);
|
|
}
|
|
else
|
|
{
|
|
int r=T::node(mPool[at]).left();
|
|
rotate(r,true);
|
|
link_left(at,r); // T::node(mPool[at]).set_left(r);
|
|
}
|
|
rotate(at, left);
|
|
|
|
return true;
|
|
}
|
|
|
|
// The Child Must Have Been Red
|
|
//------------------------------
|
|
wAt.set_red(T::node(mPool[at]).red()); // Switch Child Color
|
|
T::node(mPool[at]).set_red(true);
|
|
rotate(at, left); // Rotate At
|
|
|
|
// Select The Next Rebalance Child And Recurse
|
|
//----------------------------------------------
|
|
if (left)
|
|
{
|
|
int r=T::node(mPool[at]).left();
|
|
rebalance(r,true);
|
|
link_left(at,r); // T::node(mPool[at]).set_left(r);
|
|
}
|
|
else
|
|
{
|
|
int r=T::node(mPool[at]).right();
|
|
rebalance(r,false);
|
|
link_right(at,r); //T::node(mPool[at]).set_right(r);
|
|
}
|
|
return true;
|
|
}
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// This is the map internal recursive front function - do not use externally
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
int front(int at) const
|
|
{
|
|
if (at!=tree_node::NULL_NODE &&
|
|
T::node(mPool[at]).left()!=tree_node::NULL_NODE)
|
|
{
|
|
return front(T::node(mPool[at]).left());
|
|
}
|
|
return at;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// This is the map internal recursive back function - do not use externally
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
int back(int at) const
|
|
{
|
|
if (at!=tree_node::NULL_NODE && T::node(mPool[at]).right()!=tree_node::NULL_NODE)
|
|
{
|
|
return back(T::node(mPool[at]).right());
|
|
}
|
|
return at;
|
|
}
|
|
protected:
|
|
int front() const
|
|
{
|
|
return front(mRoot);
|
|
}
|
|
|
|
int back() const
|
|
{
|
|
return back(mRoot);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// This is the map internal recursive next function - do not use externally
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
int next(int at) const
|
|
{
|
|
assert(at!=tree_node::NULL_NODE);
|
|
const TTValue& kAt = mPool[at];
|
|
const tree_node& nAt = T::node(kAt);
|
|
if (nAt.right()!=tree_node::NULL_NODE)
|
|
{
|
|
return front(nAt.right());
|
|
}
|
|
|
|
int child = at;
|
|
int parent = tree_node::NULL_NODE;
|
|
find_internal(kAt, at, mRoot, parent);
|
|
|
|
while(parent!=tree_node::NULL_NODE && (child==T::node(mPool[parent]).right()))
|
|
{
|
|
child = parent;
|
|
find_internal(mPool[parent], parent, mRoot, parent);
|
|
}
|
|
return parent;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// This is the map internal recursive previous function - do not use externally
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
int previous(int at) const
|
|
{
|
|
assert(at!=tree_node::NULL_NODE);
|
|
const TTValue& kAt = mPool[at];
|
|
const tree_node& nAt = T::node(mPool[at]);
|
|
if (kAt.left()!=tree_node::NULL_NODE)
|
|
{
|
|
return back(kAt.left());
|
|
}
|
|
|
|
int child = at;
|
|
int parent = tree_node::NULL_NODE;
|
|
find_internal(nAt, at, mRoot, parent);
|
|
|
|
while(parent!=tree_node::NULL_NODE && (child==T::node(mPool[parent]).left()))
|
|
{
|
|
child = parent;
|
|
find_internal(mPool[parent], parent, mRoot, parent);
|
|
}
|
|
return parent;
|
|
}
|
|
|
|
|
|
|
|
public:
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// Constructor
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
tree_base() : mRoot(tree_node::NULL_NODE), mLastAdd(-1)
|
|
{
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// How Many Objects Are In This Map
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
int size() const
|
|
{
|
|
return (mPool.size());
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// Are There Any Objects In This Map?
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
bool empty() const
|
|
{
|
|
return (mPool.empty());
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// Is This Map Filled?
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
bool full() const
|
|
{
|
|
return (mPool.full());
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// Clear All Data From The Map
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
void clear()
|
|
{
|
|
mRoot = tree_node::NULL_NODE;
|
|
mPool.clear();
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// Adds Element Value At Location Key - O(log n)
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
void alloc_key(const TTValue &key)
|
|
{
|
|
|
|
//fixme handle duplicates more sensibly?
|
|
assert(!full());
|
|
mLastAdd = mPool.alloc(key); // Grab A New One
|
|
T::node(mPool[mLastAdd]).init(); // Initialize Our Data And Color
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// Allocs an item, when filled, call insert_alloced
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
TTValue & alloc_key()
|
|
{
|
|
assert(!full());
|
|
mLastAdd = mPool.alloc(); // Grab A New One
|
|
T::node(mPool[mLastAdd]).init(); // Initialize Our Data And Color
|
|
return mPool[mLastAdd];
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// Allocs an item (raw), when constucted, call insert_alloced
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
TRatlNew *alloc_key_raw()
|
|
{
|
|
assert(!full());
|
|
TRatlNew *ret=mPool.alloc_raw(); // Grab A New One
|
|
mLastAdd = mPool.pointer_to_index(ret);
|
|
T::node(mPool[mLastAdd]).init(); // Initialize Our Data And Color
|
|
return ret;
|
|
}
|
|
template<class CAST_TO>
|
|
CAST_TO *verify_alloc_key(CAST_TO *p) const
|
|
{
|
|
return mPool.verify_alloc(p);
|
|
}
|
|
|
|
void insert_alloced_key()
|
|
{
|
|
assert(mLastAdd>=0&&mLastAdd<CAPACITY);
|
|
assert(!IS_MULTI || find_index(mPool[mLastAdd])!=tree_node::NULL_NODE); //fixme handle duplicates more sensibly?
|
|
|
|
insert_internal(mPool[mLastAdd],mRoot);
|
|
assert(mRoot!=tree_node::NULL_NODE);
|
|
T::node(mPool[mRoot]).set_red(false);
|
|
T::node(mPool[mRoot]).set_parent(tree_node::NULL_NODE);
|
|
}
|
|
|
|
int index_of_alloced_key() const
|
|
{
|
|
assert(mLastAdd>=0&&mLastAdd<CAPACITY);
|
|
return mLastAdd;
|
|
}
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// Removes The Element Pointed To At (it) And Decrements (it) - O((log n)^2)
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
void erase_index(int i)
|
|
{
|
|
assert(i>=0&&i<CAPACITY);
|
|
assert(mRoot!=tree_node::NULL_NODE);
|
|
|
|
//fixme this is lame to have to look by key to erase
|
|
erase_internal(mPool[i],mRoot);
|
|
if (mRoot!=tree_node::NULL_NODE)
|
|
{
|
|
T::node(mPool[mRoot]).set_red(false);
|
|
T::node(mPool[mRoot]).set_parent(tree_node::NULL_NODE);
|
|
}
|
|
}
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// Seach For A Given Key. Will Return -1 if Failed - O(log n)
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
int find_index(const TTValue &key) const
|
|
{
|
|
return find_internal(key, mRoot);
|
|
}
|
|
const TTValue &index_to_key(int i) const
|
|
{
|
|
assert(i>=0&&i<CAPACITY);
|
|
return mPool[i];
|
|
}
|
|
|
|
//fixme lower bound, upper bound, equal range
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
template<class T,int IS_MULTI>
|
|
class set_base : public tree_base<T,IS_MULTI>
|
|
{
|
|
|
|
public:
|
|
typedef typename T TStorageTraits;
|
|
typedef typename T::TValue TTValue;
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// Capacity Enum
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
enum
|
|
{
|
|
CAPACITY = T::CAPACITY
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// Adds Element Value At Location Key - O(log n)
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
void insert(const TTValue &key)
|
|
{
|
|
|
|
assert(!IS_MULTI || find_index(key)==tree_node::NULL_NODE); //fixme handle duplicates more sensibly?
|
|
|
|
alloc_key(key);
|
|
insert_alloced_key();
|
|
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// Allocs an item, when filled, call insert_alloced
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
TTValue & alloc()
|
|
{
|
|
return alloc_key();
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// Allocs an item (raw), when constucted, call insert_alloced
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
TRatlNew *alloc_raw()
|
|
{
|
|
return alloc_key_raw();
|
|
}
|
|
template<class CAST_TO>
|
|
CAST_TO *verify_alloc(CAST_TO *p) const
|
|
{
|
|
return verify_alloc_key(p);
|
|
}
|
|
|
|
void insert_alloced()
|
|
{
|
|
insert_alloced_key();
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// Removes The First Element With Key (key) - O(log n)
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
void erase(const TTValue &key)
|
|
{
|
|
//fixme this is a double search currently
|
|
int i=find_index(key);
|
|
if (i!=tree_node::NULL_NODE)
|
|
{
|
|
erase_index(i);
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// Iterator
|
|
//
|
|
// A map is sorted in ascending order on the KEY type. ++ and -- are both
|
|
// O((log n)^2) operations
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
class iterator
|
|
{
|
|
friend class set_base<TStorageTraits,IS_MULTI>;
|
|
friend class const_iterator;
|
|
|
|
int mLoc;
|
|
set_base<TStorageTraits,IS_MULTI>* mOwner;
|
|
|
|
public:
|
|
iterator(set_base<TStorageTraits,IS_MULTI> *owner=0, int loc=tree_node::NULL_NODE) :
|
|
mOwner(owner),
|
|
mLoc(loc)
|
|
{
|
|
}
|
|
iterator(const iterator &o) :
|
|
mOwner(o.mOwner),
|
|
mLoc(o.mLoc)
|
|
{
|
|
}
|
|
|
|
void operator=(const iterator &o)
|
|
{
|
|
mOwner=o.mOwner;
|
|
mLoc=o.mLoc;
|
|
}
|
|
|
|
iterator operator++() //prefix
|
|
{
|
|
assert(mOwner);
|
|
mLoc=mOwner->next(mLoc);
|
|
return *this;
|
|
}
|
|
iterator operator++(int) //postfix
|
|
{
|
|
assert(mOwner);
|
|
iterator old(*this);
|
|
mLoc=mOwner->next(mLoc);
|
|
return old;
|
|
}
|
|
|
|
iterator operator--() //prefix
|
|
{
|
|
assert(mOwner);
|
|
mLoc=mOwner->previous(mLoc);
|
|
return *this;
|
|
}
|
|
iterator operator--(int) //postfix
|
|
{
|
|
assert(mOwner);
|
|
iterator old(*this);
|
|
mLoc=mOwner->previous(mLoc);
|
|
return old;
|
|
}
|
|
|
|
bool operator!=(const iterator p) const {return (mLoc!=p.mLoc || mOwner!=p.mOwner);}
|
|
bool operator==(const iterator p) const {return (mLoc==p.mLoc && mOwner==p.mOwner);}
|
|
|
|
const TTValue & operator*() const
|
|
{
|
|
assert(mOwner);
|
|
assert(mLoc>=0&&mLoc<CAPACITY); // deferencing end()?
|
|
return mOwner->index_to_key(mLoc);
|
|
}
|
|
const TTValue * operator->() const
|
|
{
|
|
assert(mOwner);
|
|
assert(mLoc>=0&&mLoc<CAPACITY); // deferencing end()?
|
|
return &mOwner->index_to_key(mLoc);
|
|
}
|
|
};
|
|
class const_iterator
|
|
{
|
|
friend class set_base<TStorageTraits,IS_MULTI>;
|
|
|
|
int mLoc;
|
|
|
|
const set_base<TStorageTraits,IS_MULTI>* mOwner;
|
|
|
|
public:
|
|
const_iterator(const set_base<TStorageTraits,IS_MULTI> *owner=0, int loc=tree_node::NULL_NODE) :
|
|
mOwner(owner),
|
|
mLoc(loc)
|
|
{
|
|
}
|
|
const_iterator(const const_iterator &o) :
|
|
mOwner(o.mOwner),
|
|
mLoc(o.mLoc)
|
|
{
|
|
}
|
|
const_iterator(const iterator &o) :
|
|
mOwner(o.mOwner),
|
|
mLoc(o.mLoc)
|
|
{
|
|
}
|
|
void operator=(const const_iterator &o)
|
|
{
|
|
mOwner=o.mOwner;
|
|
mLoc=o.mLoc;
|
|
}
|
|
void operator=(const iterator &o)
|
|
{
|
|
mOwner=o.mOwner;
|
|
mLoc=o.mLoc;
|
|
}
|
|
|
|
|
|
const_iterator operator++() //prefix
|
|
{
|
|
assert(mOwner);
|
|
mLoc=mOwner->next(mLoc);
|
|
return *this;
|
|
}
|
|
const_iterator operator++(int) //postfix
|
|
{
|
|
assert(mOwner);
|
|
const_iterator old(*this);
|
|
mLoc=mOwner->next(mLoc);
|
|
return old;
|
|
}
|
|
|
|
const_iterator operator--() //prefix
|
|
{
|
|
assert(mOwner);
|
|
mLoc=mOwner->previous(mLoc);
|
|
return *this;
|
|
}
|
|
const_iterator operator--(int) //postfix
|
|
{
|
|
assert(mOwner);
|
|
const_iterator old(*this);
|
|
mLoc=mOwner->previous(mLoc);
|
|
return old;
|
|
}
|
|
|
|
bool operator!=(const const_iterator p) const {return (mLoc!=p.mLoc || mOwner!=p.mOwner);}
|
|
bool operator==(const const_iterator p) const {return (mLoc==p.mLoc && mOwner==p.mOwner);}
|
|
bool operator!=(const iterator p) const {return (mLoc!=p.mLoc || mOwner!=p.mOwner);}
|
|
bool operator==(const iterator p) const {return (mLoc==p.mLoc && mOwner==p.mOwner);}
|
|
|
|
const TTValue & operator*() const
|
|
{
|
|
assert(mOwner);
|
|
assert(mLoc>=0&&mLoc<CAPACITY); // deferencing end()?
|
|
return mOwner->index_to_key(mLoc);
|
|
}
|
|
const TTValue * operator->() const
|
|
{
|
|
assert(mOwner);
|
|
assert(mLoc>=0&&mLoc<CAPACITY); // deferencing end()?
|
|
return &mOwner->index_to_key(mLoc);
|
|
}
|
|
};
|
|
friend class iterator;
|
|
friend class const_iterator;
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// Seach For A Given Key. Will Return end() if Failed - O(log n)
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
iterator find(const TTValue &key)
|
|
{
|
|
return iterator(this,find_index(key));
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// Get An Iterator To The Smallest Element - O(log n)
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
iterator begin()
|
|
{
|
|
return iterator(this, front());
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// Get An Iterator To The Largest Element - O(log n)
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
iterator rbegin()
|
|
{
|
|
return iterator(this, back());
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// The Invalid Iterator, Use As A Stop Condition In Your For Loops - O(1)
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
iterator end()
|
|
{
|
|
return iterator(this);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// Seach For A Given Key. Will Return end() if Failed - O(log n)
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
const_iterator find(const TTValue &key) const
|
|
{
|
|
return const_iterator(this, find_index(key));
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// Get An const_iterator To The Smallest Element - O(log n)
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
const_iterator begin() const
|
|
{
|
|
return const_iterator(this, front());
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// Get An const_iterator To The Largest Element - O(log n)
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
const_iterator rbegin() const
|
|
{
|
|
return const_iterator(this, back());
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// The Invalid const_iterator, Use As A Stop Condition In Your For Loops - O(1)
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
const_iterator end() const
|
|
{
|
|
return const_iterator(this);
|
|
}
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// Removes The Element Pointed To At (it) And Decrements (it) - O((log n)^2)
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
void erase(const iterator &it)
|
|
{
|
|
assert(it.mOwner==this && it.mLoc>=0&&it.mLoc<CAPACITY);
|
|
erase_index(it.mLoc);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
iterator lower_bound(const TTValue &key)
|
|
{
|
|
return iterator(this, find_index(key));
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
iterator upper_bound(const TTValue &key)
|
|
{
|
|
// fixme, this don't work
|
|
iterator ubound(this, find_index(key));
|
|
ubound++;
|
|
return ubound;
|
|
}
|
|
|
|
};
|
|
|
|
|
|
template<class T, int ARG_CAPACITY>
|
|
class set_vs : public set_base<storage::value_semantics_node<T,ARG_CAPACITY,tree_node>,0 >
|
|
{
|
|
public:
|
|
typedef typename storage::value_semantics_node<T,ARG_CAPACITY,tree_node> TStorageTraits;
|
|
typedef typename TStorageTraits::TValue TTValue;
|
|
enum
|
|
{
|
|
CAPACITY = ARG_CAPACITY
|
|
};
|
|
set_vs() {}
|
|
};
|
|
|
|
template<class T, int ARG_CAPACITY>
|
|
class set_os : public set_base<storage::object_semantics_node<T,ARG_CAPACITY,tree_node>,0 >
|
|
{
|
|
public:
|
|
typedef typename storage::object_semantics_node<T,ARG_CAPACITY,tree_node> TStorageTraits;
|
|
typedef typename TStorageTraits::TValue TTValue;
|
|
enum
|
|
{
|
|
CAPACITY = ARG_CAPACITY
|
|
};
|
|
set_os() {}
|
|
};
|
|
|
|
template<class T, int ARG_CAPACITY, int ARG_MAX_CLASS_SIZE>
|
|
class set_is : public set_base<storage::virtual_semantics_node<T,ARG_CAPACITY,ARG_MAX_CLASS_SIZE,tree_node>,0 >
|
|
{
|
|
public:
|
|
typedef typename storage::virtual_semantics_node<T,ARG_CAPACITY,ARG_MAX_CLASS_SIZE,tree_node> TStorageTraits;
|
|
typedef typename TStorageTraits::TValue TTValue;
|
|
enum
|
|
{
|
|
CAPACITY = ARG_CAPACITY,
|
|
MAX_CLASS_SIZE = ARG_MAX_CLASS_SIZE
|
|
};
|
|
set_is() {}
|
|
};
|
|
|
|
|
|
template<class K,class V,int IS_MULTI>
|
|
class map_base : public tree_base<K,IS_MULTI>
|
|
{
|
|
public:
|
|
typedef typename K TKeyStorageTraits;
|
|
typedef typename K::TValue TKTValue;
|
|
typedef typename V TValueStorageTraits;
|
|
typedef typename V::TValue TVTValue;
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// Capacity Enum
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
enum
|
|
{
|
|
CAPACITY = K::CAPACITY
|
|
};
|
|
private:
|
|
array_base<TValueStorageTraits> mValues;
|
|
public:
|
|
map_base()
|
|
{
|
|
compile_assert<K::CAPACITY==V::CAPACITY>();
|
|
}
|
|
|
|
void clear()
|
|
{
|
|
tree_base<K,IS_MULTI>::clear();
|
|
mValues.clear();
|
|
}
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// Adds Element Value At Location Key - O(log n)
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
void insert(const TKTValue &key,const TVTValue &value)
|
|
{
|
|
assert(!IS_MULTI || find_index(key)==tree_node::NULL_NODE); //fixme handle duplicates more sensibly?
|
|
|
|
alloc_key(key);
|
|
insert_alloced_key();
|
|
assert(check_validity());
|
|
mValues.construct(index_of_alloced_key(),value);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// Adds Element Value At Location Key returns a reference
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
TVTValue &insert(const TKTValue &key)
|
|
{
|
|
|
|
assert(!IS_MULTI || find_index(key)==tree_node::NULL_NODE); //fixme handle duplicates more sensibly?
|
|
|
|
alloc_key(key);
|
|
insert_alloced_key();
|
|
|
|
int idx=index_of_alloced_key();
|
|
assert(check_validity());
|
|
mValues.construct(idx);
|
|
return mValues[idx];
|
|
}
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// Adds Element Value At Location Key returns a rew pointer for placement new
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
TRatlNew *insert_raw(const TKTValue &key)
|
|
{
|
|
|
|
assert(!IS_MULTI || find_index(key)==tree_node::NULL_NODE); //fixme handle duplicates more sensibly?
|
|
|
|
alloc_key(key);
|
|
insert_alloced_key();
|
|
assert(check_validity());
|
|
return mValues.alloc_raw(index_of_alloced_key());
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// After calling alloc_key*, you may call this to alloc the value
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
TVTValue &alloc_value()
|
|
{
|
|
mValues.construct(index_of_alloced_key());
|
|
return mValues[index_of_alloced_key()];
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// After calling alloc_key*, you may call this to alloc_raw the value
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
TRatlNew *alloc_value_raw()
|
|
{
|
|
return mValues.alloc_raw(index_of_alloced_key());
|
|
}
|
|
|
|
template<class CAST_TO>
|
|
CAST_TO *verify_alloc(CAST_TO *p) const
|
|
{
|
|
return mValues.verify_alloc(p);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// Removes The First Element With Key (key) - O(log n)
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
void erase(const TKTValue &key)
|
|
{
|
|
//fixme this is a double search currently
|
|
int i=find_index(key);
|
|
if (i!=tree_node::NULL_NODE)
|
|
{
|
|
erase_index(i);
|
|
mValues.destruct(i);
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// Iterator
|
|
//
|
|
// A map is sorted in ascending order on the KEY type. ++ and -- are both
|
|
// O((log n)^2) operations
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
class const_iterator;
|
|
class iterator
|
|
{
|
|
friend class map_base<K,V, IS_MULTI>;
|
|
friend class const_iterator;
|
|
|
|
int mLoc;
|
|
map_base<K,V, IS_MULTI>* mOwner;
|
|
|
|
public:
|
|
iterator(map_base<K,V, IS_MULTI> *owner=0, int loc=tree_node::NULL_NODE) :
|
|
mOwner(owner),
|
|
mLoc(loc)
|
|
{
|
|
}
|
|
iterator(const iterator &o) :
|
|
mOwner(o.mOwner),
|
|
mLoc(o.mLoc)
|
|
{
|
|
}
|
|
|
|
void operator=(const iterator &o)
|
|
{
|
|
mOwner=o.mOwner;
|
|
mLoc=o.mLoc;
|
|
}
|
|
|
|
iterator operator++() //prefix
|
|
{
|
|
assert(mOwner);
|
|
mLoc=mOwner->next(mLoc);
|
|
return *this;
|
|
}
|
|
iterator operator++(int) //postfix
|
|
{
|
|
assert(mOwner);
|
|
iterator old(*this);
|
|
mLoc=mOwner->next(mLoc);
|
|
return old;
|
|
}
|
|
|
|
iterator operator--() //prefix
|
|
{
|
|
assert(mOwner);
|
|
mLoc=mOwner->previous(mLoc);
|
|
return *this;
|
|
}
|
|
iterator operator--(int) //postfix
|
|
{
|
|
assert(mOwner);
|
|
iterator old(*this);
|
|
mLoc=mOwner->previous(mLoc);
|
|
return old;
|
|
}
|
|
|
|
bool operator!=(const iterator &p) const {return (mLoc!=p.mLoc || mOwner!=p.mOwner);}
|
|
bool operator==(const iterator &p) const {return (mLoc==p.mLoc && mOwner==p.mOwner);}
|
|
|
|
TVTValue & operator*() const
|
|
{
|
|
assert(mOwner);
|
|
assert(mLoc>=0&&mLoc<CAPACITY); // deferencing end()?
|
|
return mOwner->mValues[mLoc];
|
|
}
|
|
const TKTValue & key() const
|
|
{
|
|
assert(mOwner);
|
|
assert(mLoc>=0&&mLoc<CAPACITY); // deferencing end()?
|
|
return mOwner->index_to_key(mLoc);
|
|
}
|
|
TVTValue & value() const
|
|
{
|
|
assert(mOwner);
|
|
assert(mLoc>=0&&mLoc<CAPACITY); // deferencing end()?
|
|
return mOwner->mValues[mLoc];
|
|
}
|
|
TVTValue * operator->() const
|
|
{
|
|
assert(mOwner);
|
|
assert(mLoc>=0&&mLoc<CAPACITY); // deferencing end()?
|
|
return &mOwner->mValues[mLoc];
|
|
}
|
|
};
|
|
class const_iterator
|
|
{
|
|
friend class map_base<K,V,IS_MULTI>;
|
|
|
|
int mLoc;
|
|
const map_base<K,V,IS_MULTI>* mOwner;
|
|
|
|
public:
|
|
const_iterator(const map_base<K,V,IS_MULTI> *owner=0, int loc=tree_node::NULL_NODE) :
|
|
mOwner(owner),
|
|
mLoc(loc)
|
|
{
|
|
}
|
|
const_iterator(const const_iterator &o) :
|
|
mOwner(o.mOwner),
|
|
mLoc(o.mLoc)
|
|
{
|
|
}
|
|
const_iterator(const iterator &o) :
|
|
mOwner(o.mOwner),
|
|
mLoc(o.mLoc)
|
|
{
|
|
}
|
|
void operator=(const const_iterator &o)
|
|
{
|
|
mOwner=o.mOwner;
|
|
mLoc=o.mLoc;
|
|
}
|
|
void operator=(const iterator &o)
|
|
{
|
|
mOwner=o.mOwner;
|
|
mLoc=o.mLoc;
|
|
}
|
|
|
|
|
|
const_iterator operator++() //prefix
|
|
{
|
|
assert(mOwner);
|
|
mLoc=mOwner->next(mLoc);
|
|
return *this;
|
|
}
|
|
const_iterator operator++(int) //postfix
|
|
{
|
|
assert(mOwner);
|
|
const_iterator old(*this);
|
|
mLoc=mOwner->next(mLoc);
|
|
return old;
|
|
}
|
|
|
|
const_iterator operator--() //prefix
|
|
{
|
|
assert(mOwner);
|
|
mLoc=mOwner->previous(mLoc);
|
|
return *this;
|
|
}
|
|
const_iterator operator--(int) //postfix
|
|
{
|
|
assert(mOwner);
|
|
const_iterator old(*this);
|
|
mLoc=mOwner->previous(mLoc);
|
|
return old;
|
|
}
|
|
|
|
bool operator!=(const const_iterator &p) const {return (mLoc!=p.mLoc || mOwner!=p.mOwner);}
|
|
bool operator==(const const_iterator &p) const {return (mLoc==p.mLoc && mOwner==p.mOwner);}
|
|
bool operator!=(const iterator &p) const {return (mLoc!=p.mLoc || mOwner!=p.mOwner);}
|
|
bool operator==(const iterator &p) const {return (mLoc==p.mLoc && mOwner==p.mOwner);}
|
|
|
|
const TVTValue & operator*() const
|
|
{
|
|
assert(mOwner);
|
|
assert(mLoc>=0&&mLoc<CAPACITY); // deferencing end()?
|
|
return mOwner->mValues[mLoc];
|
|
}
|
|
const TKTValue & key() const
|
|
{
|
|
assert(mOwner);
|
|
assert(mLoc>=0&&mLoc<CAPACITY); // deferencing end()?
|
|
return mOwner->index_to_key(mLoc);
|
|
}
|
|
const TVTValue & value() const
|
|
{
|
|
assert(mOwner);
|
|
assert(mLoc>=0&&mLoc<CAPACITY); // deferencing end()?
|
|
return mOwner->mValues[mLoc];
|
|
}
|
|
const TVTValue * operator->() const
|
|
{
|
|
assert(mOwner);
|
|
assert(mLoc>=0&&mLoc<CAPACITY); // deferencing end()?
|
|
return &mOwner->mValues[mLoc];
|
|
}
|
|
};
|
|
friend class iterator;
|
|
friend class const_iterator;
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// Seach For A Given Key. Will Return end() if Failed - O(log n)
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
iterator find(const TKTValue &key)
|
|
{
|
|
return iterator(this,find_index(key));
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// Get An Iterator To The Smallest Element - O(log n)
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
iterator begin()
|
|
{
|
|
return iterator(this, front());
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// Get An Iterator To The Largest Element - O(log n)
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
iterator rbegin()
|
|
{
|
|
return iterator(this, back());
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// The Invalid Iterator, Use As A Stop Condition In Your For Loops - O(1)
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
iterator end()
|
|
{
|
|
return iterator(this);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// Seach For A Given Key. Will Return end() if Failed - O(log n)
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
const_iterator find(const TKTValue &key) const
|
|
{
|
|
return const_iterator(this, find_index(key));
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// Get An const_iterator To The Smallest Element - O(log n)
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
const_iterator begin() const
|
|
{
|
|
return const_iterator(this, front());
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// Get An const_iterator To The Largest Element - O(log n)
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
const_iterator rbegin() const
|
|
{
|
|
return const_iterator(this, back());
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// The Invalid const_iterator, Use As A Stop Condition In Your For Loops - O(1)
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
const_iterator end() const
|
|
{
|
|
return const_iterator(this);
|
|
}
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// Removes The Element Pointed To At (it) And Decrements (it) - O((log n)^2)
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
void erase(const iterator &it)
|
|
{
|
|
assert(it.mOwner==this && it.mLoc>=0&&it.mLoc<CAPACITY);
|
|
erase_index(it.mLoc);
|
|
mValues.destruct(it.mLoc);
|
|
}
|
|
private:
|
|
bool check_validity()
|
|
{
|
|
#if (0)
|
|
int cnt=0;
|
|
iterator it=begin();
|
|
for (;it!=end();it++)
|
|
{
|
|
cnt++;
|
|
}
|
|
// assert(cnt==size());
|
|
return cnt==size();
|
|
#else
|
|
return true;
|
|
#endif
|
|
}
|
|
};
|
|
|
|
template<class K,class V, int ARG_CAPACITY>
|
|
class map_vs : public map_base<
|
|
storage::value_semantics_node<K,ARG_CAPACITY,tree_node>,
|
|
storage::value_semantics<V,ARG_CAPACITY>,
|
|
0 >
|
|
{
|
|
public:
|
|
typedef typename storage::value_semantics<V,ARG_CAPACITY> VStorageTraits;
|
|
typedef typename VStorageTraits::TValue TTValue;
|
|
enum
|
|
{
|
|
CAPACITY = ARG_CAPACITY
|
|
};
|
|
map_vs() {}
|
|
};
|
|
|
|
template<class K,class V, int ARG_CAPACITY>
|
|
class map_os : public map_base<
|
|
storage::value_semantics_node<K,ARG_CAPACITY,tree_node>,
|
|
storage::object_semantics<V,ARG_CAPACITY>,
|
|
0 >
|
|
{
|
|
public:
|
|
typedef typename storage::object_semantics<V,ARG_CAPACITY> VStorageTraits;
|
|
typedef typename VStorageTraits::TValue TTValue;
|
|
enum
|
|
{
|
|
CAPACITY = ARG_CAPACITY
|
|
};
|
|
map_os() {}
|
|
};
|
|
|
|
template<class K,class V, int ARG_CAPACITY,int ARG_MAX_CLASS_SIZE>
|
|
class map_is : public map_base<
|
|
storage::value_semantics_node<K,ARG_CAPACITY,tree_node>,
|
|
storage::virtual_semantics<V,ARG_CAPACITY,ARG_MAX_CLASS_SIZE>,
|
|
0 >
|
|
{
|
|
public:
|
|
typedef typename storage::virtual_semantics<V,ARG_CAPACITY,ARG_MAX_CLASS_SIZE> VStorageTraits;
|
|
typedef typename VStorageTraits::TValue TTValue;
|
|
enum
|
|
{
|
|
CAPACITY = ARG_CAPACITY,
|
|
MAX_CLASS_SIZE = ARG_MAX_CLASS_SIZE
|
|
};
|
|
map_is() {}
|
|
};
|
|
|
|
}
|
|
|
|
#endif
|