133 lines
3.1 KiB
C++
133 lines
3.1 KiB
C++
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
//
|
|
// Copyright (C) Microsoft Corporation, 1997 - 1997
|
|
//
|
|
// File: ntree.h
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
//
|
|
// NTREE.H
|
|
//
|
|
|
|
#if !defined(_NTREE_H_)
|
|
#define _NTREE_H_
|
|
|
|
#include <functional>
|
|
#include "gelem.h"
|
|
#include "glnkenum.h"
|
|
|
|
class NTELEM;
|
|
class NTREE;
|
|
|
|
class NTELEM : public GLNKEL
|
|
{
|
|
public:
|
|
// Internal class for chains (doubly-linked lists) of tree nodes
|
|
typedef XCHN<NTELEM> CHN;
|
|
// Sort helper "less" binary function class
|
|
class SRTFNC : public binary_function<const NTELEM *, const NTELEM *, bool>
|
|
{
|
|
public:
|
|
virtual bool operator () (const NTELEM * pa, const NTELEM * pb) const
|
|
{ return pa->ICompare( pb ) < 0; }
|
|
};
|
|
static SRTFNC srtpntelem;
|
|
|
|
public:
|
|
NTELEM ();
|
|
virtual ~ NTELEM ();
|
|
|
|
// Accessor for chain of siblings
|
|
CHN & ChnSib ()
|
|
{ return (CHN &) Chn() ; }
|
|
|
|
virtual INT EType () const
|
|
{ return _pnteChild ? EGELM_BRANCH : EGELM_LEAF ; }
|
|
|
|
// Adopt (link) a child
|
|
void Adopt ( NTELEM * pnteChild, bool bSort = false ) ;
|
|
// Disown (release) a child
|
|
void Disown ( NTELEM * pnteChild ) ;
|
|
// Become an orphan
|
|
void Orphan () ;
|
|
|
|
INT ChildCount () ;
|
|
INT SiblingCount ();
|
|
NTELEM * PnteChild ( INT index ) ;
|
|
NTELEM * PnteParent ()
|
|
{ return _pnteParent; }
|
|
NTELEM * PnteChild ()
|
|
{ return _pnteChild; }
|
|
bool BIsChild ( NTELEM * pnte ) ;
|
|
|
|
// Return the sort value of *this versus another COBJ
|
|
virtual INT ICompare ( const NTELEM * pnteOther ) const = 0;
|
|
|
|
void ReorderChildren ( SRTFNC & fSortRoutine = srtpntelem ) ;
|
|
|
|
protected:
|
|
NTELEM * _pnteParent; // Pointer to single parent (or NULL)
|
|
NTELEM * _pnteChild; // Pointer to one child (or NULL)
|
|
|
|
HIDE_UNSAFE(NTELEM);
|
|
};
|
|
|
|
|
|
class NTREE : public NTELEM
|
|
{
|
|
public:
|
|
NTREE ();
|
|
virtual ~ NTREE ();
|
|
|
|
virtual INT EType () const
|
|
{ return EGELM_TREE ; }
|
|
|
|
HIDE_UNSAFE(NTREE);
|
|
};
|
|
|
|
template <class T, bool bAnchor>
|
|
class NTENUM : public GLNKENUM<T,bAnchor>
|
|
{
|
|
public:
|
|
NTENUM (const T & ntel, bool bIsAnchor = bAnchor, bool iDir = true)
|
|
: GLNKENUM<T,bAnchor>( ntel, bIsAnchor, iDir )
|
|
{}
|
|
// Position to the next pointer
|
|
T * PntelNext ()
|
|
{ return (T *) GLNKENUM<T,bAnchor>::PlnkelNext() ; }
|
|
// Return the current object pointer
|
|
T * PntelCurrent()
|
|
{ return (T *) _plnkelNext ; }
|
|
// Set the enumerator to have a new base
|
|
void Reset ( const T & ntel, int iDir = -1 )
|
|
{ GLNKENUM<T,bAnchor>::Reset( ntel, iDir ) ; }
|
|
};
|
|
|
|
// Template for generating nested tree motion accessor class
|
|
template<class T>
|
|
class TWALKER
|
|
{
|
|
public:
|
|
TWALKER ( T & t )
|
|
: _pt(&t)
|
|
{}
|
|
void Reset ( T & t )
|
|
{ _pt = &t; }
|
|
T * PlnkchnPrev ()
|
|
{ return PdynCast( _pt->Chn().PgelemPrev(), _pt ); }
|
|
T * PlnkchnNext ()
|
|
{ return PdynCast( _pt->Chn().PgelemNext(), _pt ); }
|
|
T * Pparent ()
|
|
{ return PdynCast( _pt->PnteParent(), _pt ); }
|
|
T * Pchild ()
|
|
{ return PdynCast( _pt->PnteChild(), _pt ); }
|
|
protected:
|
|
T * _pt;
|
|
};
|
|
|
|
#endif
|
|
|