void releaseBase(OppBase *base)
{
if (NULL != base) {
releaseNode(base->nonDealerRoot);
releaseNode(base->dealerRoot);
}
}
void releaseNode(struct Node *node)
{
if (NULL == node) return;
releaseNode(node->leftChild);
releaseNode(node->midChild);
releaseNode(node->rightChild);
releaseNode(node);
}
/**
* Releases the old node and then references the next node.
*
* Note: Make sure to call this until it returns NULL (so the last node is released properly) or
* remember to release the node yourself if you don't iterate to the end.
*
* @return NULL if oldNode was the last node
*/
Node* NodeStoreServers::referenceNextNodeAndReleaseOld(Node* oldNode)
{
uint16_t oldNodeID = oldNode->getNumID();
releaseNode(&oldNode);
return referenceNextNode(oldNodeID);
}
void releaseNode(struct Node *node)
{
if (NULL == node) return;
int i;
for(i=0; i<3; i++)
releaseNode(node->child[i]);
free(node);
}
/* =============================================================================
* freeNode
* =============================================================================
*/
static void
freeNode (node_t* n)
{
if (n) {
freeNode(n->l);
freeNode(n->r);
releaseNode(n);
}
}
ifun(void, releaseNode, TrieNode* node)
{
if (node) {
for (int i=0; i<MCTrieWidth; i++)
if (node->childs[i])
releaseNode(0, node->childs[i]);
free(node);
}
}
void QuadTree::release()
{
if (mRoot)
{
releaseNode(mRoot);
delete mRoot;
mRoot = NULL;
}
}
void GPUOctree::releaseNode(GPUTreeNode *node)
{
if(!node) return;
for(int i=0; i < 8; i++) releaseNode( node->child[i] );
delete[] node->child;
delete node;
}
/* =============================================================================
* rbtree_insert
* -- Returns TRUE on success
* =============================================================================
*/
bool_t
rbtree_insert (rbtree_t* r, void* key, void* val)
{
node_t* node = getNode();
node_t* ex = INSERT(r, key, val, node);
if (ex != NULL) {
releaseNode(node);
}
return ((ex == NULL) ? TRUE : FALSE);
}
//shutdown-- cleans up memory for the terrain quad tree
void TerrainQuadTree::shutdown()
{
//recusivly release the quad tree data
if (m_parentNode)
{
releaseNode(m_parentNode);
delete m_parentNode;
m_parentNode = NULL;
}
}
/* =============================================================================
* rbtree_update
* -- Return FALSE if had to insert node first
* =============================================================================
*/
bool_t
rbtree_update (rbtree_t* r, void* key, void* val)
{
node_t* nn = getNode();
node_t* ex = INSERT(r, key, val, nn);
if (ex != NULL) {
STF(ex, v, val);
releaseNode(nn);
return TRUE;
}
return FALSE;
}
bool NodeStoreServers::updateLastHeartbeatT(uint16_t id)
{
Node* node = referenceNode(id);
if(!node)
return false;
node->updateLastHeartbeatT();
releaseNode(&node);
return true;
}
/* =============================================================================
* rbtree_delete
* -- Returns TRUE if key exists
* =============================================================================
*/
bool_t
rbtree_delete (rbtree_t* r, void* key)
{
node_t* node = NULL;
node = LOOKUP(r, key);
if (node != NULL) {
node = DELETE(r, node);
}
if (node != NULL) {
releaseNode(node);
}
return ((node != NULL) ? TRUE : FALSE);
}
//releaseNode-- releases the passed in node
//node- the node to be released
void TerrainQuadTree::releaseNode(Node* node)
{
int i;
// Recursively go down the tree and release the bottom nodes first.
for (i = 0; i<4; i++)
{
if (node->nodes[i] != 0)
{
releaseNode(node->nodes[i]);
}
}
// Release the vertex buffer for this node.
if (node->vertexBuffer)
{
node->vertexBuffer->Release();
node->vertexBuffer = 0;
}
// Release the index buffer for this node.
if (node->indexBuffer)
{
node->indexBuffer->Release();
node->indexBuffer = 0;
}
//Release the vertex array for this node
if (node->vertexArray)
{
delete[] node->vertexArray;
node->vertexArray = NULL;
}
// Release the four child nodes.
for (i = 0; i<4; i++)
{
if (node->nodes[i])
{
delete node->nodes[i];
node->nodes[i] = 0;
}
}
return;
}
void QuadTree::releaseNode(TreeNode* node)
{
if (node->hasChild)
{
for (int i = 0; i < 4; ++i)
{
releaseNode(node->nodes[i]);
}
}
else
{
// Release node mesh
if (node->mmesh)
{
node->mmesh->Release();
node->mmesh = NULL;
}
// Delete node
delete node;
node = NULL;
}
}
NBBST<T, Threads>::~NBBST(){
//Remove the three nodes created in the constructor
releaseNode(root->left);
releaseNode(root->right);
releaseNode(root);
}
fun(MCTrie, void, bye, voida)
{
releaseNode(obj, obj->root);
superbye(MCObject);
}
void GPUOctree::release()
{
if(m_root) releaseNode(m_root);
if(m_dt) delete[] m_dt;
if(m_idr) delete[] m_idr;
}