glist.h
上传用户:dangjiwu
上传日期:2013-07-19
资源大小:42019k
文件大小:9k
源码类别:

Symbian

开发平台:

Visual C++

  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: glist.h,v 1.1.26.1 2004/07/09 01:54:36 hubbe Exp $
  3.  * 
  4.  * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
  5.  * 
  6.  * The contents of this file, and the files included with this file,
  7.  * are subject to the current version of the RealNetworks Public
  8.  * Source License (the "RPSL") available at
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed
  10.  * the file under the current version of the RealNetworks Community
  11.  * Source License (the "RCSL") available at
  12.  * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
  13.  * will apply. You may also obtain the license terms directly from
  14.  * RealNetworks.  You may not use this file except in compliance with
  15.  * the RPSL or, if you have a valid RCSL with RealNetworks applicable
  16.  * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
  17.  * the rights, obligations and limitations governing use of the
  18.  * contents of the file.
  19.  * 
  20.  * Alternatively, the contents of this file may be used under the
  21.  * terms of the GNU General Public License Version 2 or later (the
  22.  * "GPL") in which case the provisions of the GPL are applicable
  23.  * instead of those above. If you wish to allow use of your version of
  24.  * this file only under the terms of the GPL, and not to allow others
  25.  * to use your version of this file under the terms of either the RPSL
  26.  * or RCSL, indicate your decision by deleting the provisions above
  27.  * and replace them with the notice and other provisions required by
  28.  * the GPL. If you do not delete the provisions above, a recipient may
  29.  * use your version of this file under the terms of any one of the
  30.  * RPSL, the RCSL or the GPL.
  31.  * 
  32.  * This file is part of the Helix DNA Technology. RealNetworks is the
  33.  * developer of the Original Code and owns the copyrights in the
  34.  * portions it created.
  35.  * 
  36.  * This file, and the files included with this file, is distributed
  37.  * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
  38.  * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
  39.  * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
  40.  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
  41.  * ENJOYMENT OR NON-INFRINGEMENT.
  42.  * 
  43.  * Technology Compatibility Kit Test Suite(s) Location:
  44.  *    http://www.helixcommunity.org/content/tck
  45.  * 
  46.  * Contributor(s):
  47.  * 
  48.  * ***** END LICENSE BLOCK ***** */
  49. #ifndef _GLIST_H
  50. #define _GLIST_H
  51. #include "hxtypes.h"
  52. class GListIterator;
  53. class GList;
  54. class GListNode
  55. {
  56.     friend class GListIterator;
  57.     friend class GList;
  58. private:
  59.     void      *m_pElement;
  60.     GListNode *m_pNext;
  61.     GListNode *m_pPrev;
  62.     GListNode(void *pElement = 0L, GListNode *pNext = 0L, GListNode *pPrev = 0L)
  63.     {
  64.         m_pElement = pElement;
  65.         m_pNext    = pNext;
  66.         m_pPrev    = pPrev;
  67.     };
  68.     ~GListNode() {};
  69.     void      *GetElement() { return m_pElement; }
  70.     GListNode *GetNext()    { return m_pNext;    }
  71.     GListNode *GetPrev()    { return m_pPrev;    }
  72.     void       SetElement(void *pElement) { m_pElement = pElement; }
  73.     void       SetNext(GListNode *pNext)  { m_pNext    = pNext;    }
  74.     void       SetPrev(GListNode *pPrev)  { m_pPrev    = pPrev;    }
  75. };
  76. class GListIterator
  77. {
  78.     friend class GList;
  79. protected:
  80.     GListNode *m_pNode;
  81.     GListIterator(GListNode * const pNode) : m_pNode(pNode) {};
  82. public:
  83.     GListIterator() {};
  84.     GListIterator(const GListIterator & rIterator) : m_pNode(rIterator.m_pNode) {};
  85.     ~GListIterator() {};
  86.     GListIterator & operator = (const GListIterator & rIterator )
  87.     {
  88.         m_pNode = rIterator.m_pNode;
  89.         return *this;
  90.     };
  91.     BOOL operator == (const GListIterator & rIterator) const
  92.     {
  93.         return (m_pNode == rIterator.m_pNode ? TRUE : FALSE);
  94.     };
  95.     BOOL operator != (const GListIterator & rIterator) const
  96.     {
  97.         return (m_pNode != rIterator.m_pNode ? TRUE : FALSE);
  98.     };
  99.     GListIterator & operator ++ ()
  100.     {
  101.         m_pNode = m_pNode->m_pNext;
  102.         return *this;
  103.     }
  104.     GListIterator operator ++ (int)
  105.     {
  106.         GListIterator cIterator = *this;
  107.         ++*this;
  108.         return cIterator;
  109.     };
  110.     GListIterator & operator -- ()
  111.     {
  112.         m_pNode = m_pNode->m_pPrev;
  113.         return *this;
  114.     };
  115.     GListIterator operator -- (int)
  116.     {
  117.         GListIterator cIterator = *this;
  118.         --*this;
  119.         return cIterator;
  120.     };
  121.     GListIterator operator + (int n) const
  122.     {
  123.         GListIterator cIterator = *this;
  124.         if (n > 0)
  125.         {
  126.             while (n--)
  127.             {
  128.                 ++cIterator;
  129.             }
  130.         }
  131.         else
  132.         {
  133.             while (n++)
  134.             {
  135.                 --cIterator;
  136.             }
  137.         }
  138.         return cIterator;
  139.     };
  140.     GListIterator operator += (int n)
  141.     {
  142.         return *this = *this + n;
  143.     };
  144.     GListIterator operator - (int n) const
  145.     {
  146.         GListIterator cIterator = *this;
  147.         if (n > 0)
  148.         {
  149.             while (n--)
  150.             {
  151.                 --cIterator;
  152.             }
  153.         }
  154.         else
  155.         {
  156.             while (n++)
  157.             {
  158.                 ++cIterator;
  159.             }
  160.         }
  161.         return cIterator;
  162.     };
  163.     GListIterator operator -= (int n)
  164.     {
  165.         return *this = *this - n;
  166.     };
  167.     void * operator * () const           { return m_pNode->m_pElement; };
  168.     void * operator [] (int index) const { return *(*this + index); };
  169. };
  170. class GList
  171. {
  172. protected:
  173.     GListNode m_cHead;
  174.     ULONG32   m_ulSize;
  175. public:
  176.     GList() : m_cHead(), m_ulSize(0)
  177.     {
  178.         m_cHead.SetNext(&m_cHead);
  179.         m_cHead.SetPrev(&m_cHead);
  180.     };
  181.    ~GList()
  182.    {
  183.        Erase(Begin(), End());
  184.    }
  185.     BOOL    Empty()   { return (m_ulSize ? FALSE : TRUE); }
  186.     ULONG32 Size()    { return m_ulSize; }
  187. ULONG32 GetCount(){ return m_ulSize; }
  188.     GListIterator Begin() { return GListIterator(m_cHead.m_pNext); }
  189.     GListIterator End()   { return GListIterator(&m_cHead); }
  190.     void * First()                 { return *Begin(); }
  191.     void * Last()                  { return *(--End()); }
  192.     void * operator [] (int index) { return *(Begin() + index); }
  193.     BOOL operator == (GList & rList)
  194.     {
  195.         if (m_ulSize != rList.m_ulSize)
  196.         {
  197.             return FALSE;
  198.         }
  199.         GListIterator start1 = Begin();
  200.         GListIterator end1   = End();
  201.         GListIterator start2 = rList.Begin();
  202.         while (start1 != end1)
  203.         {
  204.             if (*start1++ != *start2++)
  205.             {
  206.                 return FALSE;
  207.             }
  208.         }
  209.         return TRUE;
  210.     }
  211.     BOOL operator != (GList & rList)
  212.     {
  213.         return (*this == rList ? FALSE : TRUE);
  214.     }
  215.     GListIterator Insert(GListIterator cPos, void *pElement)
  216.     {
  217.         GListNode *pNode               = new GListNode(pElement);
  218.         pNode->m_pNext                 = cPos.m_pNode;
  219.         pNode->m_pPrev                 = cPos.m_pNode->m_pPrev;
  220.         cPos.m_pNode->m_pPrev->m_pNext = pNode;
  221.         cPos.m_pNode->m_pPrev          = pNode;
  222.         m_ulSize++;
  223.         return GListIterator(pNode);
  224.     }
  225.     GListIterator PushFront(void *pElement)
  226.     {
  227.         return Insert(Begin(), pElement);
  228.     }
  229.     GListIterator PushBack(void *pElement)
  230.     {
  231.         return Insert(End(), pElement);
  232.     }
  233.     void Erase(GListIterator cPos)
  234.     {
  235.         if (cPos == End())
  236.         {
  237.             return;
  238.         }
  239.         cPos.m_pNode->m_pPrev->m_pNext = cPos.m_pNode->m_pNext;
  240.         cPos.m_pNode->m_pNext->m_pPrev = cPos.m_pNode->m_pPrev;
  241.         delete cPos.m_pNode;
  242.         --m_ulSize;
  243.         return;
  244.     }
  245.     void Erase(GListIterator cStart, GListIterator cEnd)
  246.     {
  247.         while (cStart != cEnd && cStart != End())
  248.         {
  249.             Erase(cStart++);
  250.         }
  251.         return;
  252.     }
  253.     void PopFront()
  254.     {
  255.         Erase(Begin());
  256.     }
  257.     void PopBack()
  258.     {
  259.         Erase(--End());
  260.     }
  261.     void EraseAll()
  262.     {
  263.         Erase(Begin(), End());
  264.     }
  265.     void ResetAll()
  266.     {
  267.         GListNode *pCurrent = m_cHead.m_pNext;
  268.         GListNode *pNext    = pCurrent->m_pNext;
  269.         while (pCurrent != pNext)
  270.         {
  271.             pCurrent->m_pPrev->m_pNext = pCurrent->m_pNext;
  272.             pCurrent->m_pNext->m_pPrev = pCurrent->m_pPrev;
  273.             delete pCurrent;
  274.             --m_ulSize;
  275.         }
  276.         m_cHead.m_pNext = m_cHead.m_pPrev = &m_cHead;
  277.     }
  278.     void Remove(void *pElement)
  279.     {
  280.         GListIterator cStart = Begin();
  281.         GListIterator cEnd   = End();
  282.         while (cStart != cEnd)
  283.         {
  284.             GListIterator cNext = cStart;
  285.             ++cNext;
  286.             if (*cStart == pElement)
  287.             {
  288.                 Erase(cStart);
  289.             }
  290.             cStart = cNext;
  291.         }
  292. #if 0
  293.         GListIterator itr;
  294.         while (Size() > 0)
  295.         {
  296.             itr = Begin();
  297.             if (*itr == pElement)
  298.             {
  299.                 Erase(itr);
  300.             }
  301.         }
  302. #endif
  303.     }
  304. };
  305. #endif