CLucene - a full-featured, c++ search engine
API Documentation
00001 /*------------------------------------------------------------------------------ 00002 * Copyright (C) 2003-2006 Ben van Klinken and the CLucene Team 00003 * 00004 * Distributable under the terms of either the Apache License (Version 2.0) or 00005 * the GNU Lesser General Public License, as specified in the COPYING file. 00006 ------------------------------------------------------------------------------*/ 00007 #ifndef _lucene_util_VoidMap_ 00008 #define _lucene_util_VoidMap_ 00009 00010 #if defined(_LUCENE_PRAGMA_ONCE) 00011 # pragma once 00012 #endif 00013 00014 00015 CL_NS_DEF(util) 00016 00017 00021 template<typename _kt, typename _vt, 00022 typename _base, 00023 typename _KeyDeletor=CL_NS(util)::Deletor::Dummy, 00024 typename _ValueDeletor=CL_NS(util)::Deletor::Dummy> 00025 class __CLMap:public _base,LUCENE_BASE { 00026 private: 00027 bool dk; 00028 bool dv; 00029 typedef _base base; 00030 public: 00031 DEFINE_MUTEX(THIS_LOCK) 00032 00033 typedef typename _base::iterator iterator; 00034 typedef typename _base::const_iterator const_iterator; 00035 typedef CL_NS_STD(pair)<_kt, _vt> _pair; 00036 00038 __CLMap (): 00039 dk(true), 00040 dv(true) 00041 { 00042 } 00043 00045 ~__CLMap (){ 00046 clear(); 00047 } 00048 00049 void setDeleteKey(bool val){ dk = val; } 00050 void setDeleteValue(bool val){ dv = val; } 00051 00057 /*__CLMap ( const bool deleteKey, const bool deleteValue ): 00058 dk(deleteKey), 00059 dv(deleteValue) 00060 { 00061 }*/ 00062 00066 bool exists(_kt k)const{ 00067 const_iterator itr = base::find(k); 00068 bool ret = itr!=base::end(); 00069 return ret; 00070 } 00071 00075 void put(_kt k,_vt v){ 00076 //todo: check if this is always right! 00077 //must should look through code, for 00078 //cases where map is not unique!!! 00079 if ( dk || dv ) 00080 remove(k); 00081 00082 //todo: replacing the old item might be quicker... 00083 00084 base::insert(_pair(k,v)); 00085 } 00086 00087 00089 _vt get( _kt k) const { 00090 const_iterator itr = base::find(k); 00091 if ( itr==base::end() ) 00092 return NULL; 00093 else 00094 return itr->second; 00095 } 00097 _kt getKey( _kt k) const { 00098 const_iterator itr = base::find(k); 00099 if ( itr==base::end() ) 00100 return NULL; 00101 else 00102 return itr->first; 00103 } 00104 00105 void removeitr (iterator itr, const bool dontDeleteKey = false, const bool dontDeleteValue = false){ 00106 //delete key&val first. This prevents potential loops (deleting object removes itself) 00107 _kt key = itr->first; 00108 _vt val = itr->second; 00109 base::erase(itr); 00110 00111 //keys & vals need to be deleted after erase, because the hashvalue is still needed 00112 if ( dk && !dontDeleteKey ) 00113 _KeyDeletor::doDelete(key); 00114 if ( dv && !dontDeleteValue ) 00115 _ValueDeletor::doDelete(val); 00116 } 00118 void remove(_kt key, const bool dontDeleteKey = false, const bool dontDeleteValue = false){ 00119 iterator itr = base::find(key); 00120 if ( itr!=base::end() ) 00121 removeitr(itr,dontDeleteKey,dontDeleteValue); 00122 } 00123 00125 void clear(){ 00126 if ( dk || dv ){ 00127 iterator itr = base::begin(); 00128 while ( itr!=base::end() ){ 00129 #ifdef _CL_HAVE_EXT_HASH_MAP 00130 removeitr(itr); 00131 itr = base::begin(); 00132 00133 #else 00134 if ( dk ) 00135 _KeyDeletor::doDelete(itr->first); 00136 if ( dv ) 00137 _ValueDeletor::doDelete(itr->second); 00138 ++itr; 00139 00140 #endif 00141 } 00142 } 00143 base::clear(); 00144 } 00145 }; 00146 00147 // makes no guarantees as to the order of the map 00148 // cannot contain duplicate keys; each key can map to at most one value 00149 #define CLHashtable CLHashMap 00150 00151 #if defined(_CL_HAVE_GOOGLE_DENSE_HASH_MAP) 00152 //do nothing, implementations is done later... 00153 #elif defined(LUCENE_DISABLE_HASHING) 00154 00155 //a CLSet with CLHashMap traits 00156 template<typename _kt, typename _vt, 00157 typename _Compare, 00158 typename _EqualDummy, 00159 typename _KeyDeletor=CL_NS(util)::Deletor::Dummy, 00160 typename _ValueDeletor=CL_NS(util)::Deletor::Dummy> 00161 class CLHashMap:public __CLMap<_kt,_vt, 00162 CL_NS_STD(map)<_kt,_vt, _Compare>, 00163 _KeyDeletor,_ValueDeletor> 00164 { 00165 typedef typename CL_NS_STD(map)<_kt,_vt,_Compare> _base; 00166 typedef __CLMap<_kt, _vt, CL_NS_STD(map)<_kt,_vt, _Compare>, 00167 _KeyDeletor,_ValueDeletor> _this; 00168 public: 00169 CLHashMap ( const bool deleteKey=false, const bool deleteValue=false ) 00170 { 00171 _this::setDeleteKey(deleteKey); 00172 _this::setDeleteValue(deleteValue); 00173 } 00174 }; 00175 #elif defined(_CL_HAVE_EXT_HASH_MAP) 00176 //ext/hash_map syntax 00177 //HashMap class is roughly equivalent to Hashtable, except that it is unsynchronized 00178 template<typename _kt, typename _vt, 00179 typename _Hasher, 00180 typename _Equals, 00181 typename _KeyDeletor=CL_NS(util)::Deletor::Dummy, 00182 typename _ValueDeletor=CL_NS(util)::Deletor::Dummy> 00183 class CLHashMap:public __CLMap<_kt,_vt, 00184 CL_NS_HASHING(hash_map)<_kt,_vt, _Hasher,_Equals>, 00185 _KeyDeletor,_ValueDeletor> 00186 { 00187 typedef __CLMap<_kt,_vt, CL_NS_HASHING(hash_map)<_kt,_vt, _Hasher,_Equals>, 00188 _KeyDeletor,_ValueDeletor> _this; 00189 public: 00190 CLHashMap ( const bool deleteKey=false, const bool deleteValue=false ) 00191 { 00192 _this::setDeleteKey(deleteKey); 00193 _this::setDeleteValue(deleteValue); 00194 } 00195 }; 00196 00197 #else 00198 //HashMap class is roughly equivalent to Hashtable, except that it is unsynchronized 00199 template<typename _kt, typename _vt, 00200 typename _Hasher, 00201 typename _Equals, 00202 typename _KeyDeletor=CL_NS(util)::Deletor::Dummy, 00203 typename _ValueDeletor=CL_NS(util)::Deletor::Dummy> 00204 class CLHashMap:public __CLMap<_kt,_vt, 00205 CL_NS_HASHING(hash_map)<_kt,_vt, _Hasher>, 00206 _KeyDeletor,_ValueDeletor> 00207 { 00208 typedef __CLMap<_kt,_vt, CL_NS_HASHING(hash_map)<_kt,_vt, _Hasher>, 00209 _KeyDeletor,_ValueDeletor> _this; 00210 public: 00211 CLHashMap ( const bool deleteKey=false, const bool deleteValue=false ) 00212 { 00213 _this::setDeleteKey(deleteKey); 00214 _this::setDeleteValue(deleteValue); 00215 } 00216 }; 00217 #endif 00218 00219 //A collection that contains no duplicates 00220 //does not guarantee that the order will remain constant over time 00221 template<typename _kt, typename _vt, 00222 typename _Compare, 00223 typename _KeyDeletor=CL_NS(util)::Deletor::Dummy, 00224 typename _ValueDeletor=CL_NS(util)::Deletor::Dummy> 00225 class CLSet:public __CLMap<_kt,_vt, 00226 CL_NS_STD(map)<_kt,_vt, _Compare>, 00227 _KeyDeletor,_ValueDeletor> 00228 { 00229 typedef typename CL_NS_STD(map)<_kt,_vt,_Compare> _base; 00230 typedef __CLMap<_kt, _vt, CL_NS_STD(map)<_kt,_vt, _Compare>, 00231 _KeyDeletor,_ValueDeletor> _this; 00232 public: 00233 CLSet ( const bool deleteKey=false, const bool deleteValue=false ) 00234 { 00235 _this::setDeleteKey(deleteKey); 00236 _this::setDeleteValue(deleteValue); 00237 } 00238 }; 00239 00240 00241 //A collection that can contains duplicates 00242 template<typename _kt, typename _vt, 00243 typename _Compare, 00244 typename _KeyDeletor=CL_NS(util)::Deletor::Dummy, 00245 typename _ValueDeletor=CL_NS(util)::Deletor::Dummy> 00246 class CLMultiMap:public __CLMap<_kt,_vt, 00247 CL_NS_STD(multimap)<_kt,_vt>, 00248 _KeyDeletor,_ValueDeletor> 00249 { 00250 typedef typename CL_NS_STD(multimap)<_kt,_vt> _base; 00251 typedef __CLMap<_kt, _vt, CL_NS_STD(multimap)<_kt,_vt>, 00252 _KeyDeletor,_ValueDeletor> _this; 00253 public: 00254 CLMultiMap ( const bool deleteKey=false, const bool deleteValue=false ) 00255 { 00256 _this::setDeleteKey(deleteKey); 00257 _this::setDeleteValue(deleteValue); 00258 } 00259 }; 00260 00261 00262 //*** need to create a class that allows duplicates - use <set> 00263 //#define CLSet __CLMap 00264 CL_NS_END 00265 00266 #ifdef _CL_HAVE_GOOGLE_DENSE_HASH_MAP 00267 #include "GoogleSparseMap.h" 00268 #endif 00269 00270 #endif