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

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. /////////////////////////////////////////////////////////////////////////////
  36. // HXASVECT.H
  37. //
  38. // Class definitions for:
  39. //
  40. //        CHXAssocVectPtrToPtr
  41. //        CHXAssocVectStringToOb
  42. //        CHXAssocVectStringToString
  43. //
  44. //
  45. // The CHXAssocVectPtrToPtr - this is map class for associating "pointers" to 
  46. // "pointers". 
  47. //
  48. // The CHXAssocVectStringToOb - this is map class for associating "strings" to 
  49. // "pointers".
  50. //
  51. // The CHXAssocVectStringToString - this is map class for associating "strings" to 
  52. // "strings".
  53. //
  54. // All implementations use AssocVector imported from the public lib Loki 
  55. // written by Andrei Alexandrescu.
  56. ////////////////////
  57. #ifndef HXASVECT_H_
  58. #define HXASVECT_H_
  59. #include "hxcppflags.h"
  60. #include "hxcom.h"
  61. #ifdef HX_CPP_BASIC_TEMPLATES
  62. #include "hxtypes.h"
  63. #include "hxstring.h"
  64. #include "assocvector.h"
  65. #ifndef NDEBUG
  66. #define DEBUG_CODE(code) code
  67. #define DEBUG_COMMA ,
  68. #else
  69. #define DEBUG_CODE(code)
  70. #define DEBUG_COMMA
  71. #endif
  72. typedef void* POSITION;
  73. namespace AssocVectorHelpers
  74. {
  75. #ifndef NDEBUG
  76.     const UINT32
  77.         LengthBits = CHAR_BIT * (sizeof(POSITION) - 1),
  78.         KeepLengthMask = (1u << LengthBits) - 1;
  79.     inline UINT32 GetOffset(POSITION pos)
  80.     {
  81.         return (reinterpret_cast<UINT32>(pos) & KeepLengthMask) - 1;
  82.     }
  83.     inline unsigned char GetSerialNumber(POSITION pos)
  84.     {
  85.         UINT32& val = *reinterpret_cast<UINT32*>(&pos);
  86.         return static_cast<unsigned char>(val >> LengthBits);
  87.     }
  88.     inline void EmbedSerialNumber(POSITION& pos, unsigned char serial)
  89.     {
  90.         UINT32& val = *reinterpret_cast<UINT32*>(&pos);
  91.         HX_ASSERT((val & KeepLengthMask) == val);
  92. // HX_ASSERT(((serial << LengthBits) >> LengthBits) == serial);
  93.         HX_ASSERT(((val | (serial << LengthBits)) & KeepLengthMask) == val);
  94.         val |= serial << LengthBits;
  95.     }
  96. #else
  97.     inline UINT32 GetOffset(POSITION pos)
  98.     {
  99.         return reinterpret_cast<UINT32>(pos);
  100.     }
  101. #endif
  102.     inline POSITION MakePosition(UINT32 offset)
  103.     {
  104.         ++offset;
  105.         HX_ASSERT((offset & KeepLengthMask) == offset);
  106.         return reinterpret_cast<POSITION>(offset);
  107.     }
  108. }
  109. //////////////////////////////////////////////////////////////////////////////
  110. //
  111. //        CHXGenericAssocVect
  112. //
  113. //////////////////////////////////////////////////////////////////////////////
  114. template <class Key, class Value, class Compare = std::less<Key> >
  115. class CHXGenericAssocVect
  116. {
  117.     typedef Loki::AssocVector<Key, Value, Compare> Data;
  118. public:
  119.     class Iterator
  120.     {
  121.     public:
  122.         friend class CHXGenericAssocVect<Key, Value, Compare>;
  123.         Iterator() : value_(0)
  124.         {
  125.             DEBUG_CODE(pCont_ = 0; serial_ = 0;)
  126.         }
  127.         
  128.         Iterator& operator++()
  129.         {
  130.             HX_ASSERT(serial_ == pCont_->m_Serial);
  131.             ++value_;
  132.             return *this;
  133.         }
  134.         
  135.         Iterator& operator--()
  136.         {
  137.             HX_ASSERT(serial_ == pCont_->m_Serial);
  138.             --value_;
  139.             return *this;
  140.         }
  141.         
  142.         void operator+=( int i )
  143.         {
  144.             HX_ASSERT(serial_ == pCont_->m_Serial);
  145.             value_ += i;
  146.         }
  147.         
  148.         void operator-=( int i )
  149.         {
  150.             HX_ASSERT(serial_ == pCont_->m_Serial);
  151.             value_ -= i;
  152.         }
  153.         
  154.         BOOL operator==(const Iterator& rhs) const
  155.         {
  156.             HX_ASSERT(pCont_ == rhs.pCont_);
  157.             HX_ASSERT(serial_ == rhs.serial_);
  158.             return value_ == rhs.value_;
  159.         }
  160.         
  161.         BOOL operator!=(const Iterator& rhs) const
  162.         {
  163.             return !(*this == rhs);
  164.         }
  165.         
  166.         Value& operator*()
  167.         {
  168.             HX_ASSERT(serial_ == pCont_->m_Serial);
  169.             return value_->second;
  170.         }
  171.         
  172.         Key& get_key()
  173.         {
  174.             HX_ASSERT(serial_ == pCont_->m_Serial);
  175.             return value_->first;
  176.         }
  177.         const Key& get_key() const
  178.         {
  179.             HX_ASSERT(serial_ == pCont_->m_Serial);
  180.             return value_->first;
  181.         }
  182.     protected:
  183.         Iterator(CHXGenericAssocVect* pCont, POSITION pos)
  184.             : value_(pCont->m_Data.begin() + AssocVectorHelpers::GetOffset(pos))
  185.         {
  186.             DEBUG_CODE(pCont_ = pCont; serial_ = pCont->m_Serial;)
  187.             HX_ASSERT(serial_ == AssocVectorHelpers::GetSerialNumber(pos));
  188.         }
  189.         
  190.         Iterator(Data::iterator it DEBUG_CODE(DEBUG_COMMA CHXGenericAssocVect* pCont))
  191.             : value_(it)
  192.         {
  193.             DEBUG_CODE(pCont_ = pCont; serial_ = pCont->m_Serial;)
  194.         }
  195.         // Member variables
  196.         Data::iterator value_;
  197.         DEBUG_CODE(CHXGenericAssocVect* pCont_; unsigned char serial_;)
  198.     };
  199.     friend class Iterator;
  200. // Construction
  201.     CHXGenericAssocVect(const Compare& comp = Compare()) : m_Data(comp)
  202.     {
  203.         DEBUG_CODE(m_Serial = rand() >> (CHAR_BIT * (sizeof(short int) - 1));)
  204.     }
  205. // Attributes
  206.     // number of elements
  207.     int GetCount() const
  208.     {
  209.         return m_Data.size();
  210.     }
  211.     
  212.     BOOL IsEmpty() const
  213.     {
  214.         return m_Data.empty();
  215.     }
  216.     // Lookup
  217.     BOOL Lookup(const Key& key, Value& rValue) const
  218.     {
  219.         Data::const_iterator i = m_Data.find(key);
  220.         if (i == m_Data.end()) return FALSE;
  221.         rValue = i->second;
  222.         return TRUE;
  223.     }
  224.     
  225.     POSITION Lookup(const Key& key) const
  226.     {
  227.         Data::const_iterator i = m_Data.find(key);
  228.         if (i == m_Data.end()) return 0;
  229.         POSITION result = AssocVectorHelpers::MakePosition(i - m_Data.begin());
  230.         DEBUG_CODE(AssocVectorHelpers::EmbedSerialNumber(
  231.             result, m_Serial);)
  232.         return result;
  233.     }
  234. // Operations
  235.     // Lookup and add if not there
  236.     Value& operator[](const Key& key)
  237.     {
  238.         return m_Data[key];
  239.     }
  240.     // add a new (key, value) pair
  241.     POSITION SetAt(const Key& key, const Value& newValue)
  242.     {
  243.         std::pair<Data::iterator, bool> insResult = 
  244.             m_Data.insert(Data::value_type(key, newValue));
  245.         if (!insResult.second)
  246.         {
  247.             insResult.first->second = newValue;
  248.         }
  249.         else
  250.         {
  251.             DEBUG_CODE(++m_Serial;)
  252.         }
  253.         using namespace AssocVectorHelpers;
  254.         POSITION result = MakePosition(insResult.first - m_Data.begin());
  255.         DEBUG_CODE(EmbedSerialNumber(result, m_Serial);)
  256.         return result;
  257.     }
  258.     // removing existing (key, ?) pair
  259.     Iterator Erase(Iterator it)
  260.     {
  261.         DEBUG_CODE(++m_Serial;)
  262.         const UINT32 offset = it.value_ - m_Data.begin();
  263.         m_Data.erase(it.value_);
  264.         return Iterator(m_Data.begin() + offset DEBUG_CODE(DEBUG_COMMA this));
  265.     }
  266.     
  267.     POSITION Remove(const Key& key)
  268.     {
  269.         DEBUG_CODE(++m_Serial;)
  270.         const UINT32 offset = m_Data.find(key) - m_Data.begin();
  271.         m_Data.erase(m_Data.begin() + offset);
  272.         using namespace AssocVectorHelpers;
  273.         POSITION result = MakePosition(offset);
  274.         DEBUG_CODE(EmbedSerialNumber(result, m_Serial);)
  275.         return result;
  276.     }
  277.     
  278.     BOOL RemoveKey(const Key& key)
  279.     {
  280.         DEBUG_CODE(++m_Serial;)
  281.         UINT32 oldSize = m_Data.size();
  282.         m_Data.erase(key);
  283.         return oldSize != m_Data.size();
  284.     }
  285.     
  286.     void RemoveAll()
  287.     {
  288.         DEBUG_CODE(++m_Serial;)
  289.         m_Data.clear();
  290.     }
  291.     // iterating all (key, value) pairs
  292.     POSITION GetStartPosition() const
  293.     {
  294.         if (m_Data.empty()) return 0;
  295.         POSITION result = AssocVectorHelpers::MakePosition(0);
  296.         HX_ASSERT(result != 0);
  297.         DEBUG_CODE(AssocVectorHelpers::EmbedSerialNumber(result, m_Serial));
  298.         HX_ASSERT(result != 0);
  299.     
  300.         return result;
  301.     }
  302.     
  303.     void GetNextAssoc(POSITION& rNextPosition, Key& rKey, Value& rValue) const
  304.     {
  305.         using namespace AssocVectorHelpers;
  306.         
  307.         DEBUG_CODE(const unsigned char serial = GetSerialNumber(rNextPosition);)
  308.         HX_ASSERT(serial == m_Serial);
  309.         UINT32 offset = GetOffset(rNextPosition);
  310.         HX_ASSERT(offset < m_Data.size());
  311.         const Data::value_type& val = m_Data.begin()[offset];
  312.         rKey = val.first;
  313.         rValue = val.second;
  314.         if (++offset < m_Data.size())
  315.         {
  316.             rNextPosition = MakePosition(offset);
  317.             DEBUG_CODE(EmbedSerialNumber(rNextPosition, serial));
  318.         }
  319.         else
  320.         {
  321.             rNextPosition = 0;
  322.         }
  323.     }
  324.     
  325.     Iterator Begin()
  326.     {
  327.         return Iterator(m_Data.begin() DEBUG_CODE(DEBUG_COMMA this));
  328.     }
  329.     
  330.     Iterator End()
  331.     {
  332.         return Iterator(m_Data.end() DEBUG_CODE(DEBUG_COMMA this));
  333.     }
  334.     void Swap(CHXGenericAssocVect& rhs)
  335.     {
  336.         m_Data.swap(rhs.m_Data);
  337.         DEBUG_CODE(std::swap(m_Serial, rhs.m_Serial));
  338.     }
  339. // Implementation
  340. protected:
  341.     Data m_Data;
  342.     DEBUG_CODE(unsigned char m_Serial;)
  343. public:
  344.     ~CHXGenericAssocVect()
  345.     {
  346.     }
  347. };
  348. //////////////////////////////////////////////////////////////////////////////
  349. //
  350. //        CHXAssocVectStringToOb
  351. //
  352. //////////////////////////////////////////////////////////////////////////////
  353. struct StringCompare : public std::binary_function<CHXString, CHXString, bool>
  354. {
  355.     char m_PreserveCase;
  356.         
  357.     explicit StringCompare(char PreserveCase = TRUE) : m_PreserveCase(PreserveCase) 
  358.     {
  359.     }
  360.     bool operator()(const CHXString& p1, const CHXString& p2) const
  361.     {
  362.         return (m_PreserveCase ? strcmp(p1, p2) : strcmpi(p1, p2)) < 0;
  363.     }
  364. };
  365.     
  366. class CHXAssocVectStringToOb 
  367.     : public CHXGenericAssocVect<CHXString, void*, StringCompare>
  368. {
  369.     typedef CHXGenericAssocVect<CHXString, void*, StringCompare> Base;
  370. public:
  371.     CHXAssocVectStringToOb(const StringCompare& comp = StringCompare())
  372.         : Base(comp)
  373.     {
  374.     }
  375.     
  376.     void SetCaseSensitive(BOOL b)
  377.     {
  378.         if (!b != !m_Data.key_comp().m_PreserveCase)
  379.         {
  380.             CHXAssocVectStringToOb(StringCompare(char(!!b))).Swap(*this);
  381.         }
  382.     }
  383.     void GetNextAssoc(POSITION& rNextPosition, CHXString& rKey, void*& rValue) const
  384.     {
  385. Base::GetNextAssoc(rNextPosition, rKey, rValue);
  386.     }
  387.     // JE 12/11/01 - added a method which takes const char*& for key so that the
  388.     // key returned points to memory owned by the map (in the case of small CHXStrings)
  389.     // rather than being owned by the small string buffer of the CHXString& in the 
  390.     // above method
  391.     void GetNextAssoc(POSITION& rNextPosition, const char*& rKey, void*& rValue) const
  392.     {
  393.         using namespace AssocVectorHelpers;
  394.         
  395.         DEBUG_CODE(const unsigned char serial = GetSerialNumber(rNextPosition);)
  396.     HX_ASSERT(serial == m_Serial);
  397.         UINT32 offset = GetOffset(rNextPosition);
  398.         HX_ASSERT(offset < m_Data.size());
  399.         const Data::value_type& val = m_Data.begin()[offset];
  400.         rKey = val.first;
  401.         rValue = val.second;
  402.         if (++offset < m_Data.size())
  403.         {
  404.             rNextPosition = MakePosition(offset);
  405.             DEBUG_CODE(EmbedSerialNumber(rNextPosition, serial));
  406.         }
  407.         else
  408.         {
  409.             rNextPosition = 0;
  410.         }
  411.     }
  412. };
  413. /////////////////////////////////////////////////////////////////////////////
  414. class HXEXPORT_CLASS CHXAssocVectPtrToPtr 
  415.     : public CHXGenericAssocVect<void*, void*>
  416. {
  417. };
  418. ////////////////////////////////////////////////////////////////////////////
  419. class CHXAssocVectStringToString
  420.     : public CHXGenericAssocVect<CHXString, CHXString>
  421. {
  422. };
  423. ////////////////////////////////////////////////////////////////////////////
  424. class HXEXPORT_CLASS CHXAssocVectLongToObj
  425.     : public CHXGenericAssocVect<LONG32, void*>
  426. {
  427. };
  428. ////////////////////////////////////////////////////////////////////////////
  429. class HXEXPORT_CLASS CHXAssocVectGUIDToObj
  430.     : public CHXGenericAssocVect<GUID, void*>
  431. {
  432.     typedef CHXGenericAssocVect<GUID, void*> Base;
  433. public:
  434.     void GetNextAssoc(POSITION& rNextPosition, GUID*& rpKey, void*& rValue) const
  435.     {
  436.         using namespace AssocVectorHelpers;
  437.         
  438.         DEBUG_CODE(const unsigned char serial = GetSerialNumber(rNextPosition);)
  439.         HX_ASSERT(serial == m_Serial);
  440.         const UINT32 offset = GetOffset(rNextPosition);
  441.         HX_ASSERT(offset < m_Data.size());
  442.         const Data::value_type& val = m_Data.begin()[offset];
  443.         rpKey = const_cast<GUID*>(&val.first);
  444.         rValue = val.second;
  445.         rNextPosition = MakePosition(offset + 1);
  446.         DEBUG_CODE(EmbedSerialNumber(rNextPosition, serial));
  447.     }
  448.     typedef Base::Iterator BaseIterator;
  449.     class Iterator : public BaseIterator
  450.     {
  451.     public:
  452.         Iterator(CHXAssocVectGUIDToObj* pCont, POSITION pos)
  453.             : BaseIterator(pCont, pos)
  454.         {
  455.         }
  456.         
  457.         Iterator(Data::iterator it DEBUG_CODE(DEBUG_COMMA CHXAssocVectGUIDToObj* pCont))
  458.             : BaseIterator(it DEBUG_CODE(DEBUG_COMMA pCont))
  459.         {
  460.         }
  461. Iterator(const BaseIterator& iter)
  462.             : BaseIterator(iter)
  463.         {
  464.         }
  465.         GUID* get_key()
  466.         {
  467.             return &value_->first;
  468.         }
  469.     };
  470. };
  471. ////////////////////////////////////////////////////////////////////////////
  472. #else // HX_CPP_BASIC_TEMPLATES
  473. #include "hxmap.h"
  474. #include "hxguidmap.h"
  475. typedef CHXMapStringToString CHXAssocVectStringToString;
  476. typedef CHXMapStringToOb CHXAssocVectStringToOb;
  477. typedef CHXMapGUIDToObj CHXAssocVectGUIDToObj;
  478. typedef CHXMapLongToObj CHXAssocVectLongToObj;
  479. typedef CHXMapPtrToPtr CHXAssocVectPtrToPtr;
  480. #endif // HX_CPP_BASIC_TEMPLATES
  481. #endif // HXASVECT_H_