///

template <class T>
class Tree 
	: protected Array<T>
{
protected:
	typedef Array<T> B;
	T * parent;

public:
	T       *GetPtr()                   { return (T *) this; }
	const T *GetPtr() const             { return (const T *) this; }
	T       *GetParent()                { return parent; }
	const T *GetParent() const          { return parent; }

// Array interface

	T&       Add()                      { T & t = B::Add(); t.parent = (T *)this; return t; }
	void     Add(const T& x)            { T & t = B::Add(DeepCopyNew(x)); t.parent = (T *)this; }// return t;  }
	void     AddPick(pick_ T& x)        { T & t = B::Add(new T(x)); t.parent = (T *)this; }// return t; }
	T&       Add(T *newt)               { ASSERT(newt->parent == NULL); T & t = B::Add(newt); t.parent = (T *)this; return t; }

	using B::operator[];
	using B::GetCount;
	using B::IsEmpty;

	using B::Trim;
	void     SetCount(int n)            { B::SetCount(n); for(int i = 0; i < B::GetCount(); i++) B::operator[](i).parent = (T *)this; }
	void     SetCountR(int n)           { B::SetCountR(n); for(int i = 0; i < B::GetCount(); i++) B::operator[](i).parent = (T *)this; }
	using B::Clear;

	using B::Remove;
	T&       Insert(int i)              { T & t = B::Insert(i); t.parent = (T *)this; return t; }
	void     InsertPick(int i, pick_ T& x) { x.parent = (T *)this; B::InsertPick(i, x); }

	using B::GetIndex;
	using B::Swap;
	using B::Move;

	T       *Detach(int i)              { T *t = B::Detach(i); t->parent = NULL; return t; }
	T&       Set(int i, T *newt)        { ASSERT(newt->parent == NULL); T & t = B::Set(i, newt); parent = (T *)this; return t; }
	void     Insert(int i, T *newt)     { ASSERT(newt->parent == NULL); B::Insert(i, newt); newt->parent = (T *)this; }

	using B::Drop;
	using B::Top;
	
	T       *PopDetach()                { T * t = B::PopDetach(); t->parent = NULL; return t; }

	void     Swap(Tree& b)              { B::Swap(b); for(int i = 0; i < b.GetCount(); i++) b[i].parent = (T *)this; for(int i = 0; i < B::GetCount(); i++) B::operator[](i).parent = &b; }

	Tree& operator<<(const T& x)        { Add(x); return *this; }
	Tree& operator<<(T *newt)           { Add(newt); return *this; }
	Tree& operator|(pick_ T& x)         { AddPick(x); return *this; }

// Array Interface end

	Tree()
		: parent(NULL)
	{}

private:
	Tree(const Tree&);
	void operator=(const Tree&);

public:
#ifdef _DEBUG
	void Dump() {
		for(int i = 0; i < GetCount(); i++)
			LOG((*this)[i]);
		LOG("-------------------------------------");
	}
#endif
};

//

template <class T>
class Tree : public One<T>, public Moveable<Tree<T> >
{
private:
	Tree<T> *		parent;
	Vector<Tree<T> > 	children;
public:
	Tree<T>       *GetParent()          		{ return parent; }
	const Tree<T> *GetParent() const   		{ return parent; }
	Tree<T>       *GetRoot()            		{ return Tree<T> *p = this; while (p->GetParent()) p = GetParent(); return p; }
	const Tree<T> *GetRoot() const      		{ return const Tree<T> *p = this; while (p->GetParent()) p = GetParent(); return p; }

	// All the necessary add/insert stuff goes here        
	
	Tree<T>&	operator[](int i)		{ return children[i]; }
	const Tree<T>&	operator[](int i) const		{ return children[i]; }
};

class Node
	: public Tree<Node>
{
public:
	typedef Node CLASSNAME;
	///.... your data, maybe this
	String name;
	Value value;
};

	root.name = "/";
	root.SetCount(3);
	Node & child = root[2];
	child.name = "any child";
	rood.Add().name = "another child";
	RLOG(child.GetParent()->name);
	RLOG(root.GetCount());