/*
===========================================================================
Doom 3 BFG Edition GPL Source Code
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company.
This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").
Doom 3 BFG Edition Source Code is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Doom 3 BFG Edition Source Code is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Doom 3 BFG Edition Source Code. If not, see .
In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code. If not, please request a copy in writing from id Software at the address below.
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
===========================================================================
*/
#ifndef __HIERARCHY_H__
#define __HIERARCHY_H__
/*
==============================================================================
idHierarchy
==============================================================================
*/
template< class type >
class idHierarchy {
public:
idHierarchy();
~idHierarchy();
void SetOwner( type *object );
type * Owner() const;
void ParentTo( idHierarchy &node );
void MakeSiblingAfter( idHierarchy &node );
bool ParentedBy( const idHierarchy &node ) const;
void RemoveFromParent();
void RemoveFromHierarchy();
type * GetParent() const; // parent of this node
type * GetChild() const; // first child of this node
type * GetSibling() const; // next node with the same parent
type * GetPriorSibling() const; // previous node with the same parent
type * GetNext() const; // goes through all nodes of the hierarchy
type * GetNextLeaf() const; // goes through all leaf nodes of the hierarchy
private:
idHierarchy * parent;
idHierarchy * sibling;
idHierarchy * child;
type * owner;
idHierarchy *GetPriorSiblingNode() const; // previous node with the same parent
};
/*
================
idHierarchy::idHierarchy
================
*/
template< class type >
idHierarchy::idHierarchy() {
owner = NULL;
parent = NULL;
sibling = NULL;
child = NULL;
}
/*
================
idHierarchy::~idHierarchy
================
*/
template< class type >
idHierarchy::~idHierarchy() {
RemoveFromHierarchy();
}
/*
================
idHierarchy::Owner
Gets the object that is associated with this node.
================
*/
template< class type >
type *idHierarchy::Owner() const {
return owner;
}
/*
================
idHierarchy::SetOwner
Sets the object that this node is associated with.
================
*/
template< class type >
void idHierarchy::SetOwner( type *object ) {
owner = object;
}
/*
================
idHierarchy::ParentedBy
================
*/
template< class type >
bool idHierarchy::ParentedBy( const idHierarchy &node ) const {
if ( parent == &node ) {
return true;
} else if ( parent ) {
return parent->ParentedBy( node );
}
return false;
}
/*
================
idHierarchy::ParentTo
Makes the given node the parent.
================
*/
template< class type >
void idHierarchy::ParentTo( idHierarchy &node ) {
RemoveFromParent();
parent = &node;
sibling = node.child;
node.child = this;
}
/*
================
idHierarchy::MakeSiblingAfter
Makes the given node a sibling after the passed in node.
================
*/
template< class type >
void idHierarchy::MakeSiblingAfter( idHierarchy &node ) {
RemoveFromParent();
parent = node.parent;
sibling = node.sibling;
node.sibling = this;
}
/*
================
idHierarchy::RemoveFromParent
================
*/
template< class type >
void idHierarchy::RemoveFromParent() {
idHierarchy *prev;
if ( parent ) {
prev = GetPriorSiblingNode();
if ( prev ) {
prev->sibling = sibling;
} else {
parent->child = sibling;
}
}
parent = NULL;
sibling = NULL;
}
/*
================
idHierarchy::RemoveFromHierarchy
Removes the node from the hierarchy and adds it's children to the parent.
================
*/
template< class type >
void idHierarchy::RemoveFromHierarchy() {
idHierarchy *parentNode;
idHierarchy *node;
parentNode = parent;
RemoveFromParent();
if ( parentNode ) {
while( child ) {
node = child;
node->RemoveFromParent();
node->ParentTo( *parentNode );
}
} else {
while( child ) {
child->RemoveFromParent();
}
}
}
/*
================
idHierarchy::GetParent
================
*/
template< class type >
type *idHierarchy::GetParent() const {
if ( parent ) {
return parent->owner;
}
return NULL;
}
/*
================
idHierarchy::GetChild
================
*/
template< class type >
type *idHierarchy::GetChild() const {
if ( child ) {
return child->owner;
}
return NULL;
}
/*
================
idHierarchy::GetSibling
================
*/
template< class type >
type *idHierarchy::GetSibling() const {
if ( sibling ) {
return sibling->owner;
}
return NULL;
}
/*
================
idHierarchy::GetPriorSiblingNode
Returns NULL if no parent, or if it is the first child.
================
*/
template< class type >
idHierarchy *idHierarchy::GetPriorSiblingNode() const {
if ( !parent || ( parent->child == this ) ) {
return NULL;
}
idHierarchy *prev;
idHierarchy *node;
node = parent->child;
prev = NULL;
while( ( node != this ) && ( node != NULL ) ) {
prev = node;
node = node->sibling;
}
if ( node != this ) {
idLib::Error( "idHierarchy::GetPriorSibling: could not find node in parent's list of children" );
}
return prev;
}
/*
================
idHierarchy::GetPriorSibling
Returns NULL if no parent, or if it is the first child.
================
*/
template< class type >
type *idHierarchy::GetPriorSibling() const {
idHierarchy *prior;
prior = GetPriorSiblingNode();
if ( prior ) {
return prior->owner;
}
return NULL;
}
/*
================
idHierarchy::GetNext
Goes through all nodes of the hierarchy.
================
*/
template< class type >
type *idHierarchy::GetNext() const {
const idHierarchy *node;
if ( child ) {
return child->owner;
} else {
node = this;
while( node && node->sibling == NULL ) {
node = node->parent;
}
if ( node ) {
return node->sibling->owner;
} else {
return NULL;
}
}
}
/*
================
idHierarchy::GetNextLeaf
Goes through all leaf nodes of the hierarchy.
================
*/
template< class type >
type *idHierarchy::GetNextLeaf() const {
const idHierarchy *node;
if ( child ) {
node = child;
while ( node->child ) {
node = node->child;
}
return node->owner;
} else {
node = this;
while( node && node->sibling == NULL ) {
node = node->parent;
}
if ( node ) {
node = node->sibling;
while ( node->child ) {
node = node->child;
}
return node->owner;
} else {
return NULL;
}
}
}
#endif /* !__HIERARCHY_H__ */