llmap.h
上传用户:king477883
上传日期:2021-03-01
资源大小:9553k
文件大小:6k
源码类别:

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file llmap.h
  3.  * @brief LLMap class header file
  4.  *
  5.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2001-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  32. #ifndef LL_LLMAP_H
  33. #define LL_LLMAP_H
  34. // llmap uses the fast stl library code in a manner consistant with LLSkipMap, et. al. 
  35. template<class INDEX_TYPE, class MAPPED_TYPE> class LLMap
  36. {
  37. private:
  38. typedef typename std::map<INDEX_TYPE, MAPPED_TYPE> stl_map_t;
  39. typedef typename stl_map_t::iterator stl_iter_t;
  40. typedef typename stl_map_t::value_type stl_value_t;
  41. stl_map_t mStlMap;
  42. stl_iter_t mCurIter; // *iterator = pair<const INDEX_TYPE, MAPPED_TYPE>
  43. MAPPED_TYPE dummy_data;
  44. INDEX_TYPE dummy_index;
  45. public:
  46. LLMap() : mStlMap()
  47. {
  48. memset((void*)(&dummy_data),  0x0, sizeof(MAPPED_TYPE));
  49. memset((void*)(&dummy_index), 0x0, sizeof(INDEX_TYPE));
  50. mCurIter = mStlMap.begin();
  51. }
  52. ~LLMap()
  53. {
  54. mStlMap.clear();
  55. }
  56. // use these functions to itterate through a list
  57. void resetMap()
  58. {
  59. mCurIter = mStlMap.begin();
  60. }
  61. // get the current data and bump mCurrentp
  62. // This is kind of screwy since it returns a reference;
  63. //   We have to have a dummy value for when we reach the end
  64. //   or in case we have an empty list. Presumably, this value
  65. //   will initialize to some NULL value that will end the iterator.
  66. // We really shouldn't be using getNextData() or getNextKey() anyway...
  67. MAPPED_TYPE &getNextData()
  68. {
  69. if (mCurIter == mStlMap.end())
  70. {
  71. return dummy_data;
  72. }
  73. else
  74. {
  75. return (*mCurIter++).second;
  76. }
  77. }
  78. const INDEX_TYPE &getNextKey()
  79. {
  80. if (mCurIter == mStlMap.end())
  81. {
  82. return dummy_index;
  83. }
  84. else
  85. {
  86. return (*mCurIter++).first;
  87. }
  88. }
  89. MAPPED_TYPE &getFirstData()
  90. {
  91. resetMap();
  92. return getNextData();
  93. }
  94. const INDEX_TYPE &getFirstKey()
  95. {
  96. resetMap();
  97. return getNextKey();
  98. }
  99. S32 getLength()
  100. {
  101. return mStlMap.size();
  102. }
  103. void addData(const INDEX_TYPE &index, MAPPED_TYPE pointed_to)
  104. {
  105. mStlMap.insert(stl_value_t(index, pointed_to));
  106. }
  107. void addData(const INDEX_TYPE &index)
  108. {
  109. mStlMap.insert(stl_value_t(index, dummy_data));
  110. }
  111. // if index doesn't exist, then insert a new node and return it
  112. MAPPED_TYPE &getData(const INDEX_TYPE &index)
  113. {
  114. std::pair<stl_iter_t, bool> res;
  115. res = mStlMap.insert(stl_value_t(index, dummy_data));
  116. return res.first->second;
  117. }
  118. // if index doesn't exist, then insert a new node, return it, and set b_new_entry to true
  119. MAPPED_TYPE &getData(const INDEX_TYPE &index, BOOL &b_new_entry)
  120. {
  121. std::pair<stl_iter_t, bool> res;
  122. res = mStlMap.insert(stl_value_t(index, dummy_data));
  123. b_new_entry = res.second;
  124. return res.first->second;
  125. }
  126. // If there, returns the data.
  127. // If not, returns NULL.
  128. // Never adds entries to the map.
  129. MAPPED_TYPE getIfThere(const INDEX_TYPE &index)
  130. {
  131. stl_iter_t iter;
  132. iter = mStlMap.find(index);
  133. if (iter == mStlMap.end())
  134. {
  135. return (MAPPED_TYPE)0;
  136. }
  137. else
  138. {
  139. return (*iter).second;
  140. }
  141. }
  142. // if index doesn't exist, then make a new node and return it
  143. MAPPED_TYPE &operator[](const INDEX_TYPE &index)
  144. {
  145. return getData(index);
  146. }
  147. // do a reverse look-up, return NULL if failed
  148. INDEX_TYPE reverseLookup(const MAPPED_TYPE data)
  149. {
  150. stl_iter_t iter;
  151. stl_iter_t end_iter;
  152. iter = mStlMap.begin();
  153. end_iter = mStlMap.end();
  154. while (iter != end_iter)
  155. {
  156. if ((*iter).second == data)
  157. return (*iter).first;
  158. iter++;
  159. }
  160. return (INDEX_TYPE)0;
  161. }
  162. BOOL removeData(const INDEX_TYPE &index)
  163. {
  164. mCurIter = mStlMap.find(index);
  165. if (mCurIter == mStlMap.end())
  166. {
  167. return FALSE;
  168. }
  169. else
  170. {
  171. stl_iter_t iter = mCurIter++; // incrament mCurIter to the next element
  172. mStlMap.erase(iter);
  173. return TRUE;
  174. }
  175. }
  176. // does this index exist?
  177. BOOL checkData(const INDEX_TYPE &index)
  178. {
  179. stl_iter_t iter;
  180. iter = mStlMap.find(index);
  181. if (iter == mStlMap.end())
  182. {
  183. return FALSE;
  184. }
  185. else
  186. {
  187. mCurIter = iter;
  188. return TRUE;
  189. }
  190. }
  191. BOOL deleteData(const INDEX_TYPE &index)
  192. {
  193. mCurIter = mStlMap.find(index);
  194. if (mCurIter == mStlMap.end())
  195. {
  196. return FALSE;
  197. }
  198. else
  199. {
  200. stl_iter_t iter = mCurIter++; // incrament mCurIter to the next element
  201. delete (*iter).second;
  202. mStlMap.erase(iter);
  203. return TRUE;
  204. }
  205. }
  206. void deleteAllData()
  207. {
  208. stl_iter_t iter;
  209. stl_iter_t end_iter;
  210. iter = mStlMap.begin();
  211. end_iter = mStlMap.end();
  212. while (iter != end_iter)
  213. {
  214. delete (*iter).second;
  215. iter++;
  216. }
  217. mStlMap.clear();
  218. mCurIter = mStlMap.end();
  219. }
  220. void removeAllData()
  221. {
  222. mStlMap.clear();
  223. }
  224. };
  225. #endif