层次结构泛型基类用于支持层次结构类型数据,如DOM、或者View(Chromumn),提供父子关系管理、迭代器、访问者
使用方法如下:
class CView : public Base::CHiberarchyBaseT<CView)
{
...
};
//**********************************************************************
// Copyright (c) 2010
// 迪斯特软件开发小组.
// 文件: Hiberarchy.hpp
// 内容:
// 历史:
// 序号 修改时间 修改人 修改内容
// 1 2010-8-1 hlq 首次生成
//*********************************************************************
//声明本头文件宏
#ifndef _HIBERARCHY_HPP
#define _HIBERARCHY_HPP
//包含头文件
#include <cassert>
#include <xutility>
#include <iostream>
//Base名字空间开始
namespace Base
{
//**********************************************************************
// 类名: CHiberarchyBaseT
// 目的: 层次结构基类
//*********************************************************************
template<typename T>
class CHiberarchyBaseT
{
////类型声明
public:
typedef CHiberarchyBaseT<T> my_type;
typedef T node_type;
template<class t, class ref, class ptr>
struct CHiberarchyIterator
{
////类型声明
public:
typedef CHiberarchyIterator<t, t&, t*> iterator;
typedef CHiberarchyIterator<t, const t&, const t*> const_iterator;
typedef CHiberarchyIterator<t, ref, ptr> my_type;
typedef std::bidirectional_iterator_tag iterator_category; // 迭代器类型属于bidirectional iterator
typedef t value_type; // 值类型
typedef ptr pointer; // 指针类型
typedef ref reference; // 引用类型
typedef std::size_t size_type;
typedef std::ptrdiff_t difference_type;
// 三种构造函数
CHiberarchyIterator(pointer pSource) : m_pSource(pSource) {}
CHiberarchyIterator(void) : m_pSource(0) {}
CHiberarchyIterator(const iterator& rhs) : m_pSource(rhs.GetSource()) {}
// ==和!=操作符重载
bool operator==(const my_type& rhs) const { return m_pSource == rhs.m_pSource; }
bool operator!=(const my_type& rhs) const { return m_pSource != rhs.m_pSource; }
// *操作符,汲取所指节点中的数据
reference operator*() const { return *m_pSource; }
// ->操作符,汲取所指节点中数据的地址
pointer operator->() const { return &(operator*());}
// 前置++操作符,指向下一个节点
my_type& operator++() { if(m_pSource) m_pSource = m_pSource->GetNextSibling();return *this;}
// 后置++操作符,指向下一个节点
my_type operator++(int) { my_type tmp = *this;++*this; return tmp;}
// 前置--操作符,指向前一个节点
my_type& operator--() { if(m_pSource) m_pSource = m_pSource->GetPrevSibling();return *this;}
// 后置--操作符,指向前一个节点
my_type operator--(int) { my_type tmp = *this;--*this;return tmp;}
//得到源对象
pointer GetSource(void) const {return m_pSource;}
////数据成员
private:
pointer m_pSource;
};
typedef CHiberarchyIterator<T,T&,T*> iterator;
typedef CHiberarchyIterator<T,const T&,const T*> const_iterator;
////基本查询
public:
//得到父对象(常量)
const node_type* GetParent(void) const {return reinterpret_cast<const node_type*>(m_pParentNode);}
//得到父对象
node_type* GetParent(void) {return reinterpret_cast<node_type*>(m_pParentNode);}
//得到根对象(常量)
const node_type* GetRoot(void) const { return m_pParentNode ? m_pParentNode->GetRoot() : reinterpret_cast<const node_type*>(this);}
//得到根对象
node_type* GetRoot(void) { return m_pParentNode ? m_pParentNode->GetRoot() : reinterpret_cast<node_type*>(this);}
//得到第一个子对象(常量)
const node_type* GetFirstChild(void) const {return reinterpret_cast<const node_type*>(m_pFirstChild);}
//得到第一个子对象
node_type* GetFirstChild(void) {return reinterpret_cast<node_type*>(m_pFirstChild);}
//得到最后一个子对象(常量)
const node_type* GetLastChild(void) const {return reinterpret_cast<const node_type*>(m_pLastChild);}
//得到最后一个子对象
node_type* GetLastChild(void) {return reinterpret_cast<node_type*>(m_pLastChild);}
//得到前一个兄弟对象(常量)
const node_type* GetPrevSibling(void) const {return reinterpret_cast<const node_type*>(m_pPrevSibling);}
//得到前一个兄弟对象
node_type* GetPrevSibling(void) {return reinterpret_cast<node_type*>(m_pPrevSibling);}
//得到后一个兄弟对象(常量)
const node_type* GetNextSibling(void) const {return reinterpret_cast<const node_type*>(m_pNextSibling);}
//得到后一个兄弟对象
node_type* GetNextSibling(void) {return reinterpret_cast<node_type*>(m_pNextSibling);}
////命令
public:
//设置父对象
void SetParent(my_type* pParentNode) {m_pParentNode = pParentNode;}
//插入子对象(pWhere = 0表示追加)
void InsertChild(my_type* pWhere,my_type* pChild);
//追加子对象
void AppendChild(my_type* pChild){InsertChild(0,pChild);}
//删除子对象
void RemoveChild(my_type* pChild);
//删除所有子对象
void RemoveChildren(void);
////执行函数
private:
//连接兄弟对象
static void ConnectSibling(my_type* pFirst,my_type* pSecond);
////构造、析构函数
public:
//默认构造函数
CHiberarchyBaseT(void) : m_pParentNode(0),m_pFirstChild(0),m_pLastChild(0),m_pPrevSibling(0),m_pNextSibling(0){}
protected:
//保护析构函数
~CHiberarchyBaseT(void) {}
////迭代器实现
public:
iterator child_begin(void) { return reinterpret_cast<node_type*>(m_pFirstChild);}
const_iterator child_begin(void) const { return reinterpret_cast<const node_type*>(m_pFirstChild);}
iterator child_end(void) { return reinterpret_cast<node_type*>(0);}
const_iterator child_end(void) const { return reinterpret_cast<const node_type*>(0);}
////扩展查询
public:
template <typename VisitorType> bool AcceptVisitor(VisitorType& aVisitor,bool bReverse = false) const;
template <typename VisitorType> bool AcceptVisitor(VisitorType& aVisitor,bool bReverse = false);
////数据成员
private:
my_type* m_pParentNode; //父对象指针,不存在时为0,总是有效
my_type* m_pFirstChild; //第一个子对象指针,不存在时为0,总是有效
my_type* m_pLastChild; //最后一个子对象指针,不存在时为0,只有在第一个字对象不为0时才有效
my_type* m_pPrevSibling; //前一个兄弟对象指针,不存在时为0,只有在父对象为不为0的情况下有效
my_type* m_pNextSibling; //后一个兄弟对象指针,不存在时为0,只有在父对象为不为0的情况下有效
};
//**********************************************************************
// 函数: InsertChild
// 功能: 插入子对象(pWhere = 0表示追加)
//*********************************************************************
template<typename T>
inline void CHiberarchyBaseT<T>::InsertChild(my_type* pWhere,my_type* pChild)
{
assert((!pWhere) || (pWhere->GetParent() == this));
pChild->m_pParentNode = this;
if(pWhere) //表示插入
{
if(pWhere->m_pPrevSibling) //表示中间插入
ConnectSibling(pWhere->m_pPrevSibling,pChild);
else //表示前置插入
{
pChild->m_pPrevSibling = 0;
m_pFirstChild = pChild;
}
ConnectSibling(pChild,pWhere);
}
else //表示追加
{
if(m_pLastChild)
{
ConnectSibling(m_pLastChild,pChild);
m_pLastChild = pChild;
}
else
{
pChild->m_pPrevSibling = 0;
m_pFirstChild = m_pLastChild = pChild;
}
pChild->m_pNextSibling = 0;
}
}
//**********************************************************************
// 函数: RemoveChild
// 功能: 删除子对象
//*********************************************************************
template<typename T>
inline void CHiberarchyBaseT<T>::RemoveChild(my_type* pChild)
{
assert(pChild && pChild->GetParent() == this);
if(pChild->m_pPrevSibling && pChild->m_pNextSibling) //中间节点
{
ConnectSibling(pChild->m_pPrevSibling,pChild->m_pNextSibling);
pChild->m_pPrevSibling = pChild->m_pNextSibling = 0;
}
else if(pChild->m_pPrevSibling) //最后一个节点
{
m_pLastChild = pChild->m_pPrevSibling;
ConnectSibling(pChild->m_pPrevSibling,0);
}
else //第一个节点
{
m_pFirstChild = pChild->m_pNextSibling;
ConnectSibling(0,pChild->m_pNextSibling);
}
//删除对象
pChild->m_pParentNode = 0;
delete reinterpret_cast<node_type*>(pChild);
}
//**********************************************************************
// 函数: RemoveChildren
// 功能: 删除所有子对象
//*********************************************************************
template<typename T>
inline void CHiberarchyBaseT<T>::RemoveChildren(void)
{
for(my_type* pChild = GetFirstChild(); pChild; )
{
my_type* pThis = pChild;
pChild = pChild->m_pNextSibling;
pThis->m_pParentNode = 0;
pThis->m_pPrevSibling = 0;
pThis->m_pNextSibling = 0;
delete pThis;
}
m_pFirstChild = m_pLastChild = 0;
}
//**********************************************************************
// 函数: ConnectSibling
// 功能: 连接兄弟对象
//*********************************************************************
template<typename T>
inline void CHiberarchyBaseT<T>::ConnectSibling(my_type* pFirst,my_type* pSecond)
{
if(pFirst)
pFirst->m_pNextSibling = pSecond;
if(pSecond)
pSecond->m_pPrevSibling = pFirst;
}
//**********************************************************************
// 函数: AcceptVisitor
// 功能: 接受访问(常量)
//*********************************************************************
template<typename T>
template<typename VisitorType>
inline bool CHiberarchyBaseT<T>::AcceptVisitor(VisitorType& aVisitor,bool bReverse) const
{
//前访问自身
if(!bReverse)
{
bool bTerminate = false;
aVisitor(*reinterpret_cast<const node_type*>(this),bTerminate);
if(bTerminate)
return bTerminate;
}
//访问子对象
for(const node_type* pNode = GetFirstChild();pNode;pNode = pNode->GetNextSibling())
{
if(pNode->AcceptVisitor(aVisitor,bReverse))
return true;
}
//后访问自身
if(bReverse)
{
bool bTerminate = false;
aVisitor(*reinterpret_cast<const node_type*>(this),bTerminate);
if(bTerminate)
return bTerminate;
}
//返回
return false;
}
//**********************************************************************
// 函数: AcceptVisitor
// 功能: 接受访问
//*********************************************************************
template<typename T>
template<typename VisitorType>
inline bool CHiberarchyBaseT<T>::AcceptVisitor(VisitorType& aVisitor,bool bReverse)
{
//前访问自身
if(!bReverse)
{
bool bTerminate = false;
aVisitor(*reinterpret_cast<node_type*>(this),bTerminate);
if(bTerminate)
return bTerminate;
}
//访问子对象
for(node_type* pNode = GetFirstChild();pNode;pNode = pNode->GetNextSibling())
{
if(pNode->AcceptVisitor(aVisitor,bReverse))
return true;
}
//后访问自身
if(bReverse)
{
bool bTerminate = false;
aVisitor(*reinterpret_cast<node_type*>(this),bTerminate);
if(bTerminate)
return bTerminate;
}
//返回
return false;
}
//**********************************************************************
// 函数: PrintHiberarchyVisitor
// 功能: 打印节点访问者
//*********************************************************************
template <typename NodeType,bool bPretty>
inline void PrintHiberarchyVisitor(const NodeType& aNode,bool& bTernminate)
{
if(bPretty)
{
const NodeType* pNode = &aNode;
while(pNode = pNode->GetParent())
std::cout << " ";
}
std::cout << aNode << std::endl;
}
//**********************************************************************
// 函数: PrintHiberarchy
// 功能: 打印层次树
//*********************************************************************
template <typename NodeType>
inline void PrintHiberarchy(const NodeType& aNode,bool bPretty = true)
{
if(bPretty)
aNode.AcceptVisitor(PrintHiberarchyVisitor<NodeType,true>);
else
aNode.AcceptVisitor(PrintHiberarchyVisitor<NodeType,false>);
}
//---------------------------------------------- 测试 -------------------------------------
//**********************************************************************
// 类名: CTestNode
// 目的: 测试对象类
//*********************************************************************
class CTestNode : public CHiberarchyBaseT<CTestNode>
{
////构造、析构函数
public:
//构造函数
CTestNode(const char* szName) : m_szName(szName){}
//得到名称
const char* GetName(void) const { return m_szName;}
////数据成员
private:
const char* m_szName;
};
//**********************************************************************
// 函数: <<
// 功能: 输出操作符重载
//*********************************************************************
inline std::ostream& operator <<(std::ostream& os,const CTestNode& aNode)
{
os << aNode.GetName();
return os;
}
//**********************************************************************
// 函数: HiberarchyT_Test
// 功能: 执行测试
//*********************************************************************
template <typename T>
inline void HiberarchyT_Test(void)
{
//类型声明
typedef CTestNode node_type;
typedef typename node_type::const_iterator const_iterator;
typedef typename node_type::iterator iterator;
//声明变量
node_type aRootNode("Root");
node_type* pRootNode = aRootNode.GetRoot();
node_type* pChild1 = new node_type("First");
node_type* pChild2 = new node_type("Second");
node_type* pChild3 = new node_type("Third");
node_type* pChild4 = new node_type("Fourth");
node_type* pChild5 = new node_type("Five");
node_type* pChildren[] = {pChild1,pChild2,pChild3,pChild4,pChild5};
//测试用例1: 插入测试
pRootNode->AppendChild(pChild4);
pRootNode->AppendChild(pChild5);
pRootNode->InsertChild(pChild4,pChild2);
pRootNode->InsertChild(pChild4,pChild3);
pRootNode->InsertChild(pChild2,pChild1);
unsigned int nIndex = 0;
for(node_type* pNode = pRootNode->GetFirstChild();pNode;pNode = pNode->GetNextSibling(),++nIndex)
assert(pNode == pChildren[nIndex]);
nIndex = 0;
const_iterator pEnd = pRootNode->child_end();
for(const_iterator p = pRootNode->child_begin();p != pEnd;++p,++nIndex)
assert(&(*p) == pChildren[nIndex]);
// 打印节点名称
PrintHiberarchy(*pRootNode);
//测试用例2: 删除测试
pRootNode->RemoveChild(pChild2);
node_type* pChildren1[] = {pChild1,pChild3,pChild4,pChild5};
nIndex = 0;
pEnd = pRootNode->child_end();
for(const_iterator p = pRootNode->child_begin();p != pEnd;++p,++nIndex)
assert(&(*p) == pChildren1[nIndex]);
nIndex = 0;
for(node_type* pNode = pRootNode->GetFirstChild();pNode;pNode = pNode->GetNextSibling(),++nIndex)
assert(pNode == pChildren1[nIndex]);
pRootNode->RemoveChild(pChild5);
node_type* pChildren2[] = {pChild1,pChild3,pChild4};
nIndex = 0;
pEnd = pRootNode->child_end();
for(const_iterator p = pRootNode->child_begin();p != pEnd;++p,++nIndex)
assert(&(*p) == pChildren2[nIndex]);
pRootNode->RemoveChild(pChild1);
node_type* pChildren3[] = {pChild3,pChild4};
nIndex = 0;
pEnd = pRootNode->child_end();
for(const_iterator p = pRootNode->child_begin();p != pEnd;++p,++nIndex)
assert(&(*p) == pChildren3[nIndex]);
pRootNode->RemoveChild(pChild3);
assert(pRootNode->GetFirstChild() == pRootNode->GetLastChild());
assert(pRootNode->GetFirstChild() == pChild4);
pRootNode->RemoveChildren();
assert(pRootNode->GetFirstChild() == 0);
}
} // Base名字空间结束
#endif //假如未定义_HIBERARCHY_HPP宏
胡乐秋
2010/8/3
http://blog.csdn.net/hlqyq