C++源码分享(三):层次结构泛型基类

      层次结构泛型基类用于支持层次结构类型数据,如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

你可能感兴趣的:(C++源码分享(三):层次结构泛型基类)