winamp/Src/Wasabi/bfc/node.h
2024-09-24 14:54:57 +02:00

119 lines
2.4 KiB
C++

#ifndef _NODE_H
#define _NODE_H
#include "ptrlist.h"
//
// node.h
//
// Some node classes.
//
// ==========================================================================
//
// class Node
//
// A generic "node" object from which one may subclass and create a set of
// disparate objects that may be assembled into a hierarchical tree.
//
class Node {
private:
PtrList<Node> childlist;
Node * parent;
protected:
#ifdef _DEBUG
static int count;
#endif//_DEBUG
public:
Node(Node * myParent = NULL) : childlist(), parent(myParent) {
#ifdef _DEBUG
count++;
#endif//_DEBUG
}
Node(const Node & a) : childlist(a.childlist), parent(a.parent) {
#ifdef _DEBUG
count++;
#endif//_DEBUG
}
virtual ~Node() {
#ifdef _DEBUG
count--;
#endif//_DEBUG
};
int nodeCount() {
#ifdef _DEBUG
return count;
#else //_DEBUG
return -1;
#endif//_DEBUG
}
//
// Const Data Accessor Methods
int getNumChildren() const {
return childlist.getNumItems();
}
Node * enumChild(int index) const {
return childlist[index];
}
Node * getParent() const {
return parent;
}
//
// Nonconst Data Manipulator Methods
Node * addChild(Node * child) {
child->setParent(this);
return childlist.addItem(child);
}
Node * setParent(Node * myParent) {
return parent = myParent;
}
PtrList< Node > & ChildList() {
return childlist;
}
};
// ==========================================================================
//
// class NodeC< TPayload >
//
// If you would rather use Node as a container class than as a base class,
// this object will allow you to contain a payload instance and be accessed
// as if it were the payload instance using a reference operator and an
// implicit cast operator.
//
template < class TPayload >
class NodeC : public Node {
protected:
TPayload payload;
public:
NodeC( const TPayload & myPayload, NodeC * myParent = NULL ) : Node( myParent ), payload( myPayload ) {}
NodeC( const NodeC & a ) : Node( a ), payload( a.payload ) {}
//
// In addition to being able to call all of the Node methods, you can also
// simply treat the node objects themselves as if they were the payload
// instantiation through these simple methods:
// Explicit reference operator - for lvalues and force rvalues.
TPayload & operator () ( void ) { return payload; }
// Implicit cast operator - for rvalues that can accept a TPayload &
operator TPayload & ( void ) { return payload; }
};
#endif//_NODE_H