ew_list.h

基于Windml2.0的窗口系统原代码 , 以及和MFC CDC兼容的CDC

            if (! m_pNode)
                m_pNode = m_pFirst;
            if ((m_pNode->m_pNext && m_pNode->m_pNext->m_pItem == m_pStart) ||
                (! m_pNode->m_pNext && m_pFirst->m_pItem == m_pStart))
                m_IsDone = true;
        }
        return tmp;
    }

    //##ModelId=3FD88508016B
    /*! \brief 重载==运算符函数
     *
     *  比较两个循环迭代器是否指向同一个对象
     *  \return true    指向同一个对象
     *          false   指向不同的对象
     */
    bool operator==(const EW_LoopIterator & i) const { return m_pNode == i.m_pNode; }

    //##ModelId=3FD88508017F
    /*! \brief 重载!=运算符函数
     *
     *  比较两个循环迭代器是否指向不同的对象
     *  \return true    指向不同的对象
     *          false   指向同一个对象
     */
    bool operator!=(const EW_LoopIterator & i) const { return m_pNode != i.m_pNode; }

    //##ModelId=3FD885080193
    /*! \brief 重载==运算符函数
     *
     *  比较循环迭代器是否指向某个特定的对象
     *  \return true    指向该对象
     *          false   不是指向该对象
     */
    bool operator==(ITEM * const p) const { return m_pNode->m_pItem == p; }

    //##ModelId=3FD8850801A7
    /*! \brief 重载!=运算符函数
     *
     *  比较循环迭代器是否不指向某个特定的对象
     *  \return true    不是指向该对象
     *          false   指向该对象
     */
    bool operator!=(ITEM * const p) const { return m_pNode->m_pItem != p; }

protected:
    //##ModelId=409265B703D8
    EW_BList_Node<ITEM> * m_pFirst;     /*!< \brief 指向遍历的容器中的第一个对象的指针 */
    
    //##ModelId=409265B80069
    EW_BList_Node<ITEM> * m_pNode;      /*!< \brief 循环迭代器当前指向的节点 */
    
    //##ModelId=3FD885080072
    ITEM                * m_pStart;     /*!< \brief 指向开始循环遍历的第一个对象的指针 */
    
    //##ModelId=3FD885080085
    /*!< \brief 是否已经遍历结束的标志
     * 
     * true     结束
     * false    未结束
     */
    bool                  m_IsDone;
};

//##ModelId=3FD885070015
/*! \brief 单向链表容器类
 *
 *  \param ITEM 其中保存的对象类型，容器中保存指向ITEM对象的指针，并且不负责对象的释放
 */
template <class ITEM>
class EW_SList
{
public:
    //##ModelId=3FD885070047
    /*! \brief 单向链表容器类中的节点类型 */
    typedef EW_SList_Node<ITEM>                     node;
    
    //##ModelId=3FD88507005B
    /*! \brief 单向链表容器类中的节点中保存的对象的类型 */
    typedef ITEM                                    item;
    
    //##ModelId=3FD88507006F
    /*! \brief 单向链表容器类中使用的正向迭代器类型 */
    typedef EW_ForwardIterator<EW_SList_Node<ITEM>, ITEM> iterator;

    //##ModelId=3FD885080265
    /*! \brief 单向链表容器类的缺省构造函数 */
    EW_SList() : m_First(NULL) {}
    
    //##ModelId=3FD88508026F
    /*! \brief 单向链表容器类的析构函数
     * 
     *  删除所有的节点对象，但是不负责删除节点中保存的ITEM对象
     */
    virtual ~EW_SList()
    {
        RemoveAll();
    }

    //##ModelId=3FD885080271
    /*! \brief 返回指向第一个对象的正向迭代器
     * 
     *  \return 指向第一个对象的正向迭代器
     */
    iterator First() const { return m_First.m_pNext; }

    //##ModelId=3FD885080279
    /*! \brief 删除一个对象
     * 
     *  \param i 指向要删除的对象的迭代器
     *  \return 删除操作是否成功\n
     *          true    成功\n
     *          false   失败
     */
    bool Remove(const iterator i) { return Remove((item *)i); }
    
    //##ModelId=3FD88508028D
    /*! \brief 添加一个对象
     * 
     *  \param pItem 指向要添加的对象
     *  \return 添加操作是否成功\n
     *          true    成功\n
     *          false   失败
     */
    bool Add(item * const pItem)
    {
        node * pNode = & m_First;
        while (pNode->m_pNext) pNode = pNode->m_pNext;

        pNode->m_pNext = new node(pItem);
        return true;
    }
    
    //##ModelId=3FD885080298
    /*! \brief 删除一个对象
     * 
     *  要在容器中寻找该对象
     *  \param pItem 指向要删除的对象
     *  \return 删除操作是否成功\n
     *          true    成功\n
     *          false   失败
     */
    bool Remove(item * const pItem)
    {
        node * pNode = & m_First;
        while (pNode->m_pNext)
        {
            if (pNode->m_pNext->m_pItem == pItem)
            {
                node * pRemove = pNode->m_pNext;
                pNode->m_pNext = pRemove->m_pNext;
                delete pRemove;
                return true;
            }
            pNode = pNode->m_pNext;
        }
        return false;
    }

    //##ModelId=3FD8850802AB
    /*! \brief 删除容器中的所有对象
     * 
     *  \return 删除操作是否成功\n
     *          true    成功\n
     *          false   失败
     */
    bool RemoveAll()
    {
        node * pNode = m_First.m_pNext;
        while (pNode)
        {
            node * pRemove = pNode;
            pNode = pRemove->m_pNext;
            delete pRemove;
        }
        m_First.m_pNext = NULL;
        return true;
    }

protected:
    //##ModelId=3FD885080252
    /*! \brief 指向单向链表中的第一个对象
     *
     *  \ref EW_SList_Node::m_pNext指向单向链表中的第一个对象，不用node *可以简化添加和删除操作
     */
    node m_First;
};

//##ModelId=3FD8850601C2
/*! \brief 双向链表容器类
 *
 *  \param ITEM 其中保存的对象类型，容器中保存指向ITEM对象的指针，并且不负责对象的释放
 */
template <class ITEM>
class EW_BList
{
public:
    //##ModelId=3FD8850601EB
    /*! \brief 双向链表容器类中的节点类型 */
    typedef EW_BList_Node<ITEM>                             node;

    //##ModelId=3FD8850601FF
    /*! \brief 双向链表容器类中的节点中保存的对象的类型 */
    typedef ITEM                                            item;

    //##ModelId=3FD885060213
    /*! \brief 双向链表容器类中使用的正向迭代器类型 */
    typedef EW_ForwardIterator<EW_BList_Node<ITEM>, ITEM>   forward_iterator;

    //##ModelId=3FD885060227
    /*! \brief 双向链表容器类中使用的反向迭代器类型 */
    typedef EW_BackIterator<ITEM>                           back_iterator;

    //##ModelId=3FD88506023A
    /*! \brief 双向链表容器类中使用的循环迭代器类型 */
    typedef EW_LoopIterator<ITEM>                           loop_iterator;

    //##ModelId=3FD885070123
    /*! \brief 双向链表容器类的缺省构造函数
     * 
     *  初始化前驱和后继指针
     */
    EW_BList() : m_pFirst(NULL), m_pLast(NULL) {}

    //##ModelId=3FD885070124
    /*! \brief 双向链表容器类的析构函数
     * 
     *  删除所有的节点对象，但是不负责删除节点中保存的ITEM对象
     */
    virtual ~EW_BList()
    {
        RemoveAll();
    }

    //##ModelId=3FD88507012D
    /*! \brief 返回循环迭代器
     * 
     *  循环迭代器从起始对象指针开始遍历，直到容器中的最后一个对象，
     *  然后再从容器中的第一个元素开始遍历，直到起始对象（包括起始对象）
     *  \param pItem 指向循环遍历的起始对象的指针
     *  \return 循环迭代器
     */
    loop_iterator Loop(item * const pItem) const
    {
        return loop_iterator(m_pFirst, pItem);
    }

    //##ModelId=3FD885070141
    /*! \brief 返回指向第一个对象的正向迭代器
     * 
     *  \return 指向第一个对象的正向迭代器
     */
    forward_iterator First() const { return m_pFirst; }
    
    //##ModelId=3FD885070142
    /*! \brief 返回指向最后一个对象的反向迭代器
     * 
     *  \return 指向最后一个对象的反向迭代器
     */
    back_iterator Last()     const { return m_pLast; }

    /*! \brief 删除一个对象
     * 
     *  \param i 指向要删除的对象的迭代器
     *  \return 删除操作是否成功\n
     *          true    成功\n
     *          false   失败
     */
    template <class ITERATOR>
    bool Remove(const ITERATOR i) { return Remove((item *)i); }

    //##ModelId=3FD88507014B
    /*! \brief 添加一个对象
     * 
     *  \param pItem 指向要添加的对象
     *  \return 添加操作是否成功\n
     *          true    成功\n
     *          false   失败
     */
    bool Add(item * const pItem)
    {
        if (! m_pFirst && ! m_pLast)
        {
            // 容器为空
            m_pFirst = m_pLast = new node(pItem);
        }
        else if (m_pFirst && m_pLast)
        {
            // 容器不为空，调整链表指针
            node * pNode = new node(pItem);
            pNode->m_pPrev = m_pLast;
            m_pLast->m_pNext = pNode;
            m_pLast = pNode;
        }
        else
        {
            // 不可能发生的情况
            return false;
        }
        return true;
    }

    //##ModelId=3FD885070160
    /*! \brief 删除一个对象
     * 
     *  要在容器中寻找该对象
     *  \param pItem 指向要删除的对象
     *  \return 删除操作是否成功\n
     *          true    成功\n
     *          false   失败
     */
    bool Remove(item * const pItem)
    {
        node * pNode = m_pLast;

        while (pNode)
        {
            if (pNode->m_pItem == pItem)
            {
                // 调整链表指针
                node * pPrev = pNode->m_pPrev;
                node * pNext = pNode->m_pNext;

                if (pPrev)
                    pPrev->m_pNext = pNext;
                else
                    m_pFirst = pNext;

                if (pNext)
                    pNext->m_pPrev = pPrev;
                else
                    m_pLast = pPrev;

                delete pNode;
                return true;
            }
            else
            {
                pNode = pNode->m_pPrev;
            }
        }
        return false;
    }

    //##ModelId=3FD885070174
    /*! \brief 删除容器中的所有对象
     * 
     *  \return 删除操作是否成功\n
     *          true    成功\n
     *          false   失败
     */
    bool RemoveAll()
    {
        node * pNext, * pNode = m_pFirst;

        while (pNode)
        {
            pNext = pNode->m_pNext;
            delete pNode;
            pNode = pNext;
        }
        m_pFirst = m_pLast = NULL;
        return true;
    }


private:
    //##ModelId=3FD8850700F2
    node * m_pFirst;    /*!< \brief 指向双向链表中的第一个节点的指针 */
    //##ModelId=3FD885070106
    node * m_pLast;     /*!< \brief 指向双向链表中的最后一个节点的指针 */
};

/*! \brief 在容器中搜寻符合要求的对象的算法
 *
 *  \param i 迭代器，用该迭代器进行搜寻
 *  \param pItem 要搜寻的对象指针
 *  \return 是否找到该对象\n
 *          true    找到该对象，迭代器i指向了搜寻到的对象\n
 *          false   该对象不存在
 */
template <class ITERATOR, class ITEM>
bool EW_ListFind(ITERATOR & i, const ITEM * pItem)
{
    for (; ! i.IsDone(); ++ i)
    {
        if (i == pItem)
            return true;
    }
    return false;
}

//##ModelId=3FD88506033F
/*! \brief 用于\ref EW_ListFind_If算法的检查接口类
 *
 *  根据对象指针搜寻对象
 *  该类的派生类实现\ref EW_ListCheck::FindIt函数，具体的检查操作由派生类决定，类似C语言中的回调函数
 *  \param ITEM 容器保存的对象类型
 */
template <class ITEM>
class EW_ListCheck
{
public:
    //##ModelId=3FD885070372
    /*! \brief 检查对象是否满足条件
     *
     *  纯虚函数，由\ref EW_ListFind_If算法调用，必须由派生类实现具体的检查操作
     *  \param pItem 要检查的对象指针
     *  \return 是否满足条件\n
     *          true    满足条件\n
     *          false   不满足条件
     */
    virtual bool FindIt(const ITEM * pItem) = 0;
};

/*! \brief 在容器中搜寻符合要求的对象的算法
 *
 *  调用check对象的CheckIt函数来决定对象是否满足条件
 *  \param i 迭代器，用该迭代器进行搜寻
 *  \param check 具体的检查类对象
 *  \return 是否找到该对象\n
 *          true    找到该对象，迭代器i指向了搜寻到的对象\n
 *          false   该对象不存在
 */
template <class ITERATOR, class ITEM>
bool EW_ListFind_If(ITERATOR & i, EW_ListCheck<ITEM> & check)
{
    for (; ! i.IsDone(); ++ i)
    {
        if (check.FindIt(i))
            return true;
    }
    return false;
}

#endif  /* _EW_LIST_H_ */

/*! @} */