hxlist.h
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:20k
源码类别:

Symbian

开发平台:

C/C++

  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  35. #include "hxslist.h"
  36. #if defined(DEFINE_LIST) || defined(DEFINE_KEYED_LIST)
  37. class LIST_NAME
  38. {
  39. public:
  40. #ifdef DEFINE_KEYED_LIST
  41.     typedef VALUE_TYPE::first_type key_type;
  42.     typedef KEY_BEHAVIOUR key_behaviour;
  43.     typedef VALUE_TYPE::second_type referent_type;
  44. #endif //DEFINE_KEYED_LIST
  45.     typedef VALUE_TYPE value_type;
  46.     class _Iterator
  47.     {
  48.     public:
  49. _Iterator();
  50. _Iterator
  51. (
  52.     const CHXSimpleList* pSimpleListWrapped,
  53.     LISTPOSITION ListPosition
  54. );
  55. _Iterator(const _Iterator& rliocOther);
  56. ~_Iterator();
  57. _Iterator& operator=
  58. (
  59.     const _Iterator& rliocOther
  60. );
  61. VALUE_TYPE& operator*();
  62. _Iterator& operator=(const VALUE_TYPE& rclsNewValue);
  63. _Iterator& operator++();
  64. const _Iterator operator++(int);
  65. _Iterator& operator--();
  66. const _Iterator operator--(int);
  67.     private:
  68. CHXSimpleList* m_pSimpleListWrapped;
  69. LISTPOSITION m_ListPosition;
  70. friend class LIST_NAME;
  71. friend BOOL operator==
  72. (
  73.     const _Iterator& rliocLeft,
  74.     const _Iterator& rliocRight
  75. );
  76. friend BOOL operator!=
  77. (
  78.     const _Iterator& rliocLeft,
  79.     const _Iterator& rliocRight
  80. );
  81.     };
  82. private:
  83.     friend class _Iterator;
  84. public:
  85.     typedef _Iterator iterator;
  86.     typedef const _Iterator const_iterator;
  87.     LIST_NAME();
  88.     LIST_NAME(const LIST_NAME& rlocOther);
  89.     ~LIST_NAME();
  90.     LIST_NAME& operator=(const LIST_NAME& rlocOther);
  91.     _Iterator begin();
  92.     const _Iterator begin() const;
  93.     _Iterator end();
  94.     const _Iterator end() const;
  95.     size_t size() const;
  96.     _Iterator insert(_Iterator itBefore, const value_type&);
  97.     void insert
  98.     (
  99. _Iterator itBefore,
  100. const _Iterator itFirst,
  101. const _Iterator itLast
  102.     );
  103.     _Iterator remove(_Iterator itThis);
  104.     _Iterator remove(_Iterator itFirst, _Iterator itLast);
  105.     void empty();
  106. #ifdef DEFINE_KEYED_LIST
  107.     _Iterator insert(const value_type&);
  108.     _Iterator remove(const key_type&);
  109.     _Iterator find(const key_type&);
  110. #ifndef _UNIX
  111.     const _Iterator find(const key_type&) const;
  112. #endif
  113.     _Iterator find(const _Iterator, const key_type&);
  114. #ifndef _UNIX
  115.     const _Iterator find(const _Iterator, const key_type&) const;
  116. #endif
  117. #endif //DEFINE_KEYED_LIST
  118. protected:
  119.     CHXSimpleList m_SimpleListWrapped;
  120.     void _copy(const LIST_NAME& rlocOther);
  121. };
  122. #ifdef DEFINE_KEYED_LIST
  123. #undef DEFINE_KEYED_LIST
  124. #undef KEY_BEHAVIOUR
  125. #else //DEFINE_LIST
  126. #undef DEFINE_LIST
  127. #endif //DEFINE_KEYED_LIST
  128. #undef VALUE_TYPE
  129. #undef LIST_NAME
  130. #endif //DEFINE_LIST || DEFINE_KEYED_LIST
  131. #if defined(DEFINE_LIST_GLOBALS) || defined(DEFINE_KEYED_LIST_GLOBALS)
  132. #ifndef LIST_SCOPE
  133. #define LIST_FULL_SPEC LIST_NAME
  134. #else
  135. #define LIST_FULL_SPEC LIST_SCOPE::LIST_NAME
  136. #endif //!LIST_SCOPE
  137. BOOL operator==
  138. (
  139.     const LIST_FULL_SPEC::_Iterator& rliocLeft,
  140.     const LIST_FULL_SPEC::_Iterator& rliocRight
  141. );
  142. BOOL operator!=
  143. (
  144.     const LIST_FULL_SPEC::_Iterator& rliocLeft,
  145.     const LIST_FULL_SPEC::_Iterator& rliocRight
  146. );
  147. #undef LIST_NAME
  148. #undef DEFINE_LIST_GLOBALS
  149. #undef DEFINE_KEYED_LIST_GLOBALS
  150. #undef LIST_SCOPE
  151. #undef LIST_FULL_SPEC
  152. #endif //DEFINE_LIST_GLOBALS || DEFINE_KEYED_LIST_GLOBALS
  153. #if defined(IMPLEMENT_LIST) || defined(IMPLEMENT_KEYED_LIST)
  154. #ifndef LIST_SCOPE
  155. #define LIST_FULL_SPEC LIST_NAME
  156. #else
  157. #define LIST_FULL_SPEC LIST_SCOPE::LIST_NAME
  158. #endif //!LIST_SCOPE
  159.     LIST_FULL_SPEC::LIST_NAME()
  160.     {
  161.     }
  162.     LIST_FULL_SPEC::LIST_NAME(const LIST_NAME& rlocOther)
  163.     {
  164. _copy(rlocOther);
  165.     }
  166.     LIST_FULL_SPEC::~LIST_NAME()
  167.     {
  168. empty();
  169.     }
  170.     LIST_NAME&
  171.     LIST_FULL_SPEC::operator=(const LIST_NAME& rlocOther)
  172.     {
  173. empty();
  174. _copy(rlocOther);
  175. return *this;
  176.     }
  177.     void
  178.     LIST_FULL_SPEC::_copy(const LIST_NAME& rlocOther)
  179.     {
  180.      iterator itOther;
  181. for
  182. (
  183.     itOther = rlocOther.begin();
  184.     itOther != rlocOther.end();
  185.     ++itOther
  186. )
  187. {
  188.     insert(end(), *itOther);
  189. }
  190.     }
  191.     LIST_FULL_SPEC::iterator
  192.     LIST_FULL_SPEC::begin()
  193.     {
  194. return iterator(&m_SimpleListWrapped, m_SimpleListWrapped.GetHeadPosition());
  195.     }
  196.     const LIST_FULL_SPEC::iterator
  197.     LIST_FULL_SPEC::begin() const
  198.     {
  199. return iterator(&m_SimpleListWrapped, m_SimpleListWrapped.GetHeadPosition());
  200.     }
  201.     LIST_FULL_SPEC::iterator
  202.     LIST_FULL_SPEC::end()
  203.     {
  204. return iterator(&m_SimpleListWrapped, NULL);
  205.     }
  206.     const LIST_FULL_SPEC::iterator
  207.     LIST_FULL_SPEC::end() const
  208.     {
  209. return iterator(&m_SimpleListWrapped, NULL);
  210.     }
  211.     size_t 
  212.     LIST_FULL_SPEC::size() const
  213.     {
  214. return m_SimpleListWrapped.GetCount();
  215.     }
  216.     LIST_FULL_SPEC::iterator
  217.     LIST_FULL_SPEC::insert(LIST_FULL_SPEC::iterator itBefore, const LIST_FULL_SPEC::value_type& rclsNew)
  218.     {
  219. if ((&m_SimpleListWrapped) != itBefore.m_pSimpleListWrapped)
  220. {
  221.     return begin();
  222. }
  223. value_type* pNew = new value_type;
  224. LISTPOSITION ListPositionNew;
  225. LISTPOSITION ListPosition;
  226. HX_ASSERT(pNew);
  227. *pNew = rclsNew;
  228. if (!itBefore.m_ListPosition)
  229. {
  230.     ListPositionNew = m_SimpleListWrapped.AddTail((void*)pNew);
  231. }
  232. else
  233. {
  234.     ListPosition = itBefore.m_ListPosition;
  235.     ListPositionNew = m_SimpleListWrapped.InsertBefore(ListPosition, (void*)pNew);
  236. }
  237. return iterator(&m_SimpleListWrapped, ListPositionNew);
  238.     }
  239.     void
  240.     LIST_FULL_SPEC::insert
  241.     (
  242. LIST_FULL_SPEC::iterator itBefore,
  243. const LIST_FULL_SPEC::iterator itFirst,
  244. const LIST_FULL_SPEC::iterator itLast
  245.     )
  246.     {
  247. iterator itOther;
  248. LISTPOSITION ListPosition;
  249. if ((&m_SimpleListWrapped) != itBefore.m_pSimpleListWrapped)
  250. {
  251.     return;
  252. }
  253. for (itOther = itFirst; itOther != itLast && itOther != end(); ++itOther)
  254. {
  255.     value_type* pNew = new value_type;
  256.     HX_ASSERT(pNew);
  257.     *pNew = *((value_type*)itOther.m_pSimpleListWrapped->GetAt(itOther.m_ListPosition));
  258.     if (!itBefore.m_ListPosition)
  259.     {
  260. m_SimpleListWrapped.AddTail((void*)pNew);
  261.     }
  262.     else
  263.     {
  264. ListPosition = itBefore.m_ListPosition;
  265. m_SimpleListWrapped.InsertBefore(ListPosition, (void*)pNew);
  266.     }
  267. }
  268.     }
  269.     LIST_FULL_SPEC::iterator
  270.     LIST_FULL_SPEC::remove(LIST_FULL_SPEC::iterator itThis)
  271.     {
  272. if (!itThis.m_ListPosition || (&m_SimpleListWrapped) != itThis.m_pSimpleListWrapped)
  273. {
  274.     return end();
  275. }
  276. LISTPOSITION ListPositionOld;
  277. ListPositionOld = itThis.m_ListPosition;
  278. ++itThis;
  279. delete ((value_type*)m_SimpleListWrapped.GetAt(ListPositionOld));
  280. m_SimpleListWrapped.RemoveAt(ListPositionOld);
  281. return itThis;
  282.     }
  283.     LIST_FULL_SPEC::iterator
  284.     LIST_FULL_SPEC::remove(LIST_FULL_SPEC::iterator itFirst, LIST_FULL_SPEC::iterator itLast)
  285.     {
  286. if (!itFirst.m_ListPosition || (&m_SimpleListWrapped) != itFirst.m_pSimpleListWrapped)
  287. {
  288.     return end();
  289. }
  290. iterator itOther;
  291. LISTPOSITION ListPositionOld;
  292. for (itOther = itFirst; itOther != itLast && itOther != end();)
  293. {
  294.     ListPositionOld = itOther.m_ListPosition;
  295.     ++itOther;
  296.     delete ((value_type*)m_SimpleListWrapped.GetAt(ListPositionOld));
  297.     m_SimpleListWrapped.RemoveAt(ListPositionOld);
  298. }
  299. return itOther;
  300.     }
  301.     void
  302.     LIST_FULL_SPEC::empty()
  303.     {
  304. remove(begin(), end());
  305.     }
  306. #ifdef IMPLEMENT_KEYED_LIST
  307.     LIST_FULL_SPEC::iterator
  308.     LIST_FULL_SPEC::insert(const LIST_FULL_SPEC::value_type& rclsNew)
  309.     {
  310. return insert(begin(), rclsNew);
  311.     }
  312.     LIST_FULL_SPEC::iterator
  313.     LIST_FULL_SPEC::remove(const LIST_FULL_SPEC::key_type& key)
  314.     {
  315. iterator itNext = begin();
  316. while ((itNext = remove(find(itNext, key))) != end()) {};
  317. return itNext;
  318.     }
  319.     LIST_FULL_SPEC::iterator 
  320.     LIST_FULL_SPEC::find(const LIST_FULL_SPEC::key_type& key)
  321.     {
  322. return find(begin(), key);
  323.     }
  324. #ifndef _UNIX
  325.     LIST_FULL_SPEC::const_iterator 
  326.     LIST_FULL_SPEC::find(const LIST_FULL_SPEC::key_type& key) const
  327.     {
  328. return find(begin(), key);
  329.     }
  330. #endif
  331.     LIST_FULL_SPEC::iterator 
  332.     LIST_FULL_SPEC::find(const LIST_FULL_SPEC::iterator itBegin, const LIST_FULL_SPEC::key_type& key)
  333.     {
  334. iterator itCurrent;
  335. for (itCurrent = itBegin; itCurrent != end(); ++itCurrent)
  336. {
  337.     if (!key_behaviour::compare((*itCurrent).first, key))
  338.     {
  339. break;
  340.     }
  341. }
  342. return itCurrent;
  343.     }
  344. #ifndef _UNIX
  345.     LIST_FULL_SPEC::const_iterator 
  346.     LIST_FULL_SPEC::find(const LIST_FULL_SPEC::iterator itBegin, const LIST_FULL_SPEC::key_type& key) const
  347.     {
  348. iterator itCurrent;
  349. for (itCurrent = itBegin; itCurrent != end(); ++itCurrent)
  350. {
  351.     if (!key_behaviour::compare((*itCurrent).first, key))
  352.     {
  353. break;
  354.     }
  355. }
  356. return itCurrent;
  357.     }
  358. #endif
  359. #endif //IMPLEMENT_KEYED_LIST
  360.     LIST_FULL_SPEC::_Iterator::_Iterator()
  361. : m_pSimpleListWrapped(NULL)
  362. , m_ListPosition(NULL)
  363.     {
  364.     }
  365.     LIST_FULL_SPEC::_Iterator::_Iterator
  366.     (
  367. const CHXSimpleList* pSimpleListWrapped,
  368. LISTPOSITION ListPosition
  369.     )
  370. : m_pSimpleListWrapped((CHXSimpleList*)pSimpleListWrapped)
  371. , m_ListPosition(ListPosition)
  372.     {
  373.     }
  374.     LIST_FULL_SPEC::_Iterator::_Iterator
  375.     (
  376. const LIST_FULL_SPEC::_Iterator& rliocOther
  377.     )
  378. : m_pSimpleListWrapped(rliocOther.m_pSimpleListWrapped)
  379. , m_ListPosition(rliocOther.m_ListPosition)
  380.     {
  381.     }
  382.     LIST_FULL_SPEC::_Iterator::~_Iterator()
  383.     {
  384.     }
  385.     LIST_FULL_SPEC::_Iterator&
  386.     LIST_FULL_SPEC::_Iterator::operator=
  387.     (
  388. const LIST_FULL_SPEC::_Iterator& rliocOther
  389.     )
  390.     {
  391. m_pSimpleListWrapped = (rliocOther.m_pSimpleListWrapped);
  392. m_ListPosition = (rliocOther.m_ListPosition);
  393. return *this;
  394.     }
  395.     LIST_FULL_SPEC::value_type&
  396.     LIST_FULL_SPEC::_Iterator::operator*()
  397.     {
  398. HX_ASSERT(m_pSimpleListWrapped && m_ListPosition);
  399. return *((LIST_FULL_SPEC::value_type*)m_pSimpleListWrapped->GetAt(m_ListPosition));
  400.     }
  401.     LIST_FULL_SPEC::_Iterator&
  402.     LIST_FULL_SPEC::_Iterator::operator=(const LIST_FULL_SPEC::value_type& rclsNewValue)
  403.     {
  404. if(m_pSimpleListWrapped && m_ListPosition)
  405. {
  406.     *((LIST_FULL_SPEC::value_type*)m_pSimpleListWrapped->GetAt(m_ListPosition)) = rclsNewValue;
  407. }
  408. return *this;
  409.     }
  410.     LIST_FULL_SPEC::_Iterator&
  411.     LIST_FULL_SPEC::_Iterator::operator++()
  412.     {
  413. if(m_pSimpleListWrapped && m_ListPosition)
  414. {
  415.     m_pSimpleListWrapped->GetNext(m_ListPosition);
  416. }
  417. return *this;
  418.     }
  419.     const LIST_FULL_SPEC::_Iterator
  420.     LIST_FULL_SPEC::_Iterator::operator++(int)
  421.     {
  422. _Iterator liocRet(*this);
  423. ++(*this);
  424. return liocRet;
  425.     }
  426.     LIST_FULL_SPEC::_Iterator&
  427.     LIST_FULL_SPEC::_Iterator::operator--()
  428.     {
  429. if(m_pSimpleListWrapped)
  430. {
  431.     if (!m_ListPosition)
  432.     {
  433. m_ListPosition = m_pSimpleListWrapped->GetTailPosition();
  434.     }
  435.     else
  436.     {
  437. m_pSimpleListWrapped->GetPrev(m_ListPosition);
  438. if (!m_ListPosition)
  439. {
  440.     m_ListPosition = m_pSimpleListWrapped->GetHeadPosition();
  441. }
  442.     }
  443. }
  444. return *this;
  445.     }
  446.     const LIST_FULL_SPEC::_Iterator
  447.     LIST_FULL_SPEC::_Iterator::operator--(int)
  448.     {
  449. LIST_FULL_SPEC::_Iterator liocRet(*this);
  450. --(*this);
  451. return liocRet;
  452.     }
  453.     BOOL operator==
  454.     (
  455. const LIST_FULL_SPEC::_Iterator& rliocLeft,
  456. const LIST_FULL_SPEC::_Iterator& rliocRight
  457.     )
  458.     {
  459. return (rliocLeft.m_pSimpleListWrapped == rliocRight.m_pSimpleListWrapped && rliocLeft.m_ListPosition == rliocRight.m_ListPosition);
  460.     }
  461.     BOOL operator!=
  462.     (
  463. const LIST_FULL_SPEC::_Iterator& rliocLeft,
  464. const LIST_FULL_SPEC::_Iterator& rliocRight
  465.     )
  466.     {
  467. return (rliocLeft.m_pSimpleListWrapped != rliocRight.m_pSimpleListWrapped || rliocLeft.m_ListPosition != rliocRight.m_ListPosition);
  468.     }
  469. #undef IMPLEMENT_KEYED_LIST
  470. #undef IMPLEMENT_LIST
  471. #undef LIST_NAME
  472. #undef LIST_SCOPE
  473. #undef LIST_FULL_SPEC
  474. #endif //IMPLEMENT_LIST
  475. #ifdef DEFINE_UNIQUELY_KEYED_LIST
  476. //#define KEYED_LIST
  477. //#define LOOKUP_MAP
  478. //#define LIST_NAME
  479. class LIST_NAME : public KEYED_LIST
  480. {
  481. public:
  482.     typedef KEYED_LIST::key_type key_type;
  483.     typedef KEYED_LIST::key_behaviour key_behaviour;
  484.     typedef KEYED_LIST::referent_type referent_type;
  485.     typedef KEYED_LIST::value_type value_type;
  486.     typedef KEYED_LIST::iterator iterator;
  487.     typedef KEYED_LIST::const_iterator const_iterator;
  488.     typedef KEYED_LIST base_list;
  489.     typedef LOOKUP_MAP lookup_map;
  490. public:
  491.     LIST_NAME();
  492.     LIST_NAME(const LIST_NAME& rlocOther);
  493.     ~LIST_NAME();
  494.     LIST_NAME& operator=(const LIST_NAME& rlocOther);
  495.     iterator insert(iterator itBefore, const value_type&);
  496.     void insert
  497.     (
  498. iterator itBefore,
  499. const iterator itFirst,
  500. const iterator itLast
  501.     );
  502.     iterator insert(const value_type&);
  503.     iterator remove(iterator itThis);
  504.     iterator remove(iterator itFirst, iterator itLast);
  505.     iterator remove(const key_type&);
  506.     void empty();
  507.     KEYED_LIST::_Iterator find(const key_type&);
  508. #ifndef _UNIX
  509.     const KEYED_LIST::_Iterator find(const key_type&) const;
  510. #endif
  511. private:
  512.     KEYED_LIST::_Iterator find(const KEYED_LIST::_Iterator, const key_type&);
  513. #ifndef _UNIX
  514.     const KEYED_LIST::_Iterator find(const KEYED_LIST::_Iterator, const key_type&) const;
  515. #endif
  516. private:
  517.     LOOKUP_MAP m_LookupMap;
  518.     void _copy(const LIST_NAME& rlocOther);
  519. };
  520. #undef KEYED_LIST
  521. #undef LIST_NAME
  522. #undef LOOKUP_MAP
  523. #undef DEFINE_UNIQUELY_KEYED_LIST
  524. #endif //DEFINE_UNIQUELY_KEYED_LIST
  525. #ifdef DEFINE_UNIQUELY_KEYED_LIST_GLOBALS
  526. #ifndef LIST_SCOPE
  527. #define LIST_FULL_SPEC LIST_NAME
  528. #else
  529. #define LIST_FULL_SPEC LIST_SCOPE::LIST_NAME
  530. #endif //!LIST_SCOPE
  531. #undef LIST_NAME
  532. #undef DEFINE_UNIQUELY_KEYED_LIST_GLOBALS
  533. #undef LIST_SCOPE
  534. #undef LIST_FULL_SPEC
  535. #endif //DEFINE_UNIQUELY_KEYED_LIST_GLOBALS
  536. #ifdef IMPLEMENT_UNIQUELY_KEYED_LIST
  537. #ifndef LIST_SCOPE
  538. #define LIST_FULL_SPEC LIST_NAME
  539. #else
  540. #define LIST_FULL_SPEC LIST_SCOPE::LIST_NAME
  541. #endif //!LIST_SCOPE
  542.     LIST_FULL_SPEC::LIST_NAME()
  543.     {
  544.     }
  545.     LIST_FULL_SPEC::LIST_NAME(const LIST_FULL_SPEC& rlocOther)
  546.     {
  547. _copy(rlocOther);
  548.     }
  549.     LIST_FULL_SPEC::~LIST_NAME()
  550.     {
  551. empty();
  552.     }
  553.     LIST_FULL_SPEC&
  554.     LIST_FULL_SPEC::operator=(const LIST_FULL_SPEC& rlocOther)
  555.     {
  556. empty();
  557. _copy(rlocOther);
  558. return *this;
  559.     }
  560.     void
  561.     LIST_FULL_SPEC::_copy(const LIST_FULL_SPEC& rlocOther)
  562.     {
  563.      iterator itOther;
  564. for
  565. (
  566.     itOther = rlocOther.begin();
  567.     itOther != rlocOther.end();
  568.     ++itOther
  569. )
  570. {
  571.     insert(end(), *itOther);
  572. }
  573.     }
  574.     LIST_FULL_SPEC::iterator
  575.     LIST_FULL_SPEC::insert(LIST_FULL_SPEC::iterator itBefore, const LIST_FULL_SPEC::value_type& rvalue)
  576.     {
  577. lookup_map::iterator itValue;
  578. iterator itNew;
  579. itValue = m_LookupMap.find(rvalue.first);
  580. if (itValue == m_LookupMap.end())
  581. {
  582.     //New insert
  583.     // insert into ordered list
  584.     itNew = base_list::insert(itBefore, rvalue);
  585.     // insert into map
  586.     m_LookupMap.insert(lookup_map::value_type(rvalue.first, itNew));
  587. }
  588. else
  589. {
  590.     // dup insert, replace previous with this.
  591.     // remove existing from ordered list
  592.     base_list::remove((*itValue).second);
  593.     // insert new into ordered list
  594.     itNew = base_list::insert(itBefore, rvalue);
  595.     // replace old iterator in the map
  596.     itValue = lookup_map::value_type(rvalue.first, itNew);
  597. }
  598. return itNew;
  599.     }
  600.     void
  601.     LIST_FULL_SPEC::insert
  602.     (
  603. LIST_FULL_SPEC::iterator itBefore,
  604. const LIST_FULL_SPEC::iterator itFirst,
  605. const LIST_FULL_SPEC::iterator itLast
  606.     )
  607.     {
  608. iterator itOther;
  609. for (itOther = itFirst; itOther != itLast && itOther != end(); ++itOther)
  610. {
  611.     insert(itBefore, *itOther);
  612. }
  613.     }
  614.     LIST_FULL_SPEC::iterator
  615.     LIST_FULL_SPEC::insert(const LIST_FULL_SPEC::value_type& rclsNew)
  616.     {
  617. return insert(begin(), rclsNew);
  618.     }
  619.     LIST_FULL_SPEC::iterator
  620.     LIST_FULL_SPEC::remove(LIST_FULL_SPEC::iterator itThis)
  621.     {
  622. // remove from map
  623. m_LookupMap.remove((*itThis).first);
  624. // remove from ordered list
  625. return base_list::remove(itThis);
  626.     }
  627.     LIST_FULL_SPEC::iterator
  628.     LIST_FULL_SPEC::remove(LIST_FULL_SPEC::iterator itFirst, LIST_FULL_SPEC::iterator itLast)
  629.     {
  630. iterator itOther;
  631. for (itOther = itFirst; itOther != itLast && itOther != end();)
  632. {
  633.     itOther = remove(itOther);
  634. }
  635. return itOther;
  636.     }
  637.     LIST_FULL_SPEC::iterator
  638.     LIST_FULL_SPEC::remove(const LIST_FULL_SPEC::key_type& key)
  639.     {
  640. iterator itNext;
  641. lookup_map::iterator itValue;
  642. itValue = m_LookupMap.find(key);
  643. if (itValue != m_LookupMap.end())
  644. {
  645.     // Save iterator
  646.     itNext = (*itValue).second;
  647.     // remove from map
  648.     m_LookupMap.remove((*itValue).first);
  649.     // remove from ordered list
  650.     itNext = remove(itNext);
  651. }
  652. else
  653. {
  654.     itNext = end();
  655. }
  656. return itNext;
  657.     }
  658.     void
  659.     LIST_FULL_SPEC::empty()
  660.     {
  661. remove(begin(), end());
  662.     }
  663.     LIST_FULL_SPEC::iterator 
  664.     LIST_FULL_SPEC::find(const LIST_FULL_SPEC::key_type& key)
  665.     {
  666. iterator itFound;
  667. lookup_map::iterator itValue;
  668. itValue = m_LookupMap.find(key);
  669. if (itValue != m_LookupMap.end())
  670. {
  671.     itFound = (*itValue).second;
  672. }
  673. else
  674. {
  675.     itFound = end();
  676. }
  677. return itFound;
  678.     }
  679. #ifndef _UNIX
  680.     LIST_FULL_SPEC::const_iterator 
  681.     LIST_FULL_SPEC::find(const LIST_FULL_SPEC::key_type& key) const
  682.     {
  683. iterator itFound;
  684. lookup_map::iterator itValue;
  685. itValue = m_LookupMap.find(key);
  686. if (itValue != m_LookupMap.end())
  687. {
  688.     itFound = (*itValue).second;
  689. }
  690. else
  691. {
  692.     itFound = end();
  693. }
  694. return itFound;
  695.     }
  696. #endif
  697.     LIST_FULL_SPEC::iterator 
  698.     LIST_FULL_SPEC::find(const LIST_FULL_SPEC::iterator , const LIST_FULL_SPEC::key_type& )
  699.     {
  700. return end();
  701.     }
  702. #ifndef _UNIX
  703.     LIST_FULL_SPEC::const_iterator 
  704.     LIST_FULL_SPEC::find(const LIST_FULL_SPEC::iterator , const LIST_FULL_SPEC::key_type& ) const
  705.     {
  706. return end();
  707.     }
  708. #endif
  709. #undef LIST_NAME
  710. #undef IMPLEMENT_UNIQUELY_KEYED_LIST
  711. #undef LIST_SCOPE
  712. #undef LIST_FULL_SPEC
  713. #endif //IMPLEMENT_UNIQUELY_KEYED_LIST