AtomicMap.hpp
Go to the documentation of this file.
00001 /***************************************************************************** 00002 * Copyright (C) 2011 by Benjamin Hadorn (b_hadorn@bluewin.ch) 00003 ***************************************************************************** 00004 * Project : Zeus Base Library 00005 * Module : AtomicMap 00006 * Package : Zeus.ZeusBase.System 00007 * Author : Benjamin Hadorn 00008 * Date : 27.12.2011 00009 * System : Zeus-Framework 00010 ***************************************************************************** 00011 * Licence: * 00012 * This library is free software; you can redistribute it and/or modify * 00013 * it under the terms of the GNU Lesser General Public License as * 00014 * published by the Free Software Foundation; either version * 00015 * 2.1 of the License, or (at your option) any later version. * 00016 * * 00017 * This library is distributed in the hope that it will be useful, * 00018 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 00019 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * 00020 * GNU Lesser General Public License for more details. * 00021 * * 00022 * You should have received a copy of the GNU Lesser General Public * 00023 * License along with this library; if not, write to the Free Software * 00024 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA * 00025 *****************************************************************************/ 00026 00027 /***************************************************************************** 00028 * Changes: 00029 * 27.12.2011 bha: created zeus 2.0 00030 *****************************************************************************/ 00031 00032 #ifndef AtomicMapHPP 00033 #define AtomicMapHPP 00034 00035 #include <zeusbase/System/CriticalSection.h> 00036 #include <zeusbase/System/CriticalScopeLock.hpp> 00037 #include <zeusbase/System/Map.hpp> 00038 00039 BEGIN_NAMESPACE_Zeus 00040 00041 /******************************************************************************/ 00044 /******************************************************************************/ 00045 template <class TKeyType, class T> class TAtomicMap : public IMap<TKeyType,T> 00046 { 00047 public: 00048 /************************************************************************/ 00051 /************************************************************************/ 00052 inline TAtomicMap() 00053 : m_rLock(*new TCriticalSection(TCriticalSection::etRecursive)) 00054 {} 00055 00056 /************************************************************************/ 00060 /************************************************************************/ 00061 inline TAtomicMap(const T& rEmptyItem) 00062 : m_rLock(*new TCriticalSection(TCriticalSection::etRecursive)), 00063 m_mapData(rEmptyItem) 00064 {} 00065 00066 #ifdef USE_STL_BINDINGS 00067 /*********************************************************************/ 00071 /*********************************************************************/ 00072 inline TAtomicMap(const std::map<TKeyType, T>& rMap) 00073 : m_rLock(*new TCriticalSection(TCriticalSection::etRecursive)), 00074 m_mapData(rMap) 00075 {} 00076 #endif 00077 00078 /*********************************************************************/ 00082 /*********************************************************************/ 00083 inline TAtomicMap(const TMap<TKeyType, T>& rMap) 00084 : m_rLock(*new TCriticalSection(TCriticalSection::etRecursive)), 00085 m_mapData(rMap) 00086 {} 00087 00088 /*********************************************************************/ 00092 /*********************************************************************/ 00093 inline TAtomicMap(const TAtomicMap<TKeyType, T>& rMap) 00094 : m_rLock(*new TCriticalSection(TCriticalSection::etRecursive)) 00095 { 00096 *this = rMap; 00097 } 00098 00099 /************************************************************************/ 00102 /************************************************************************/ 00103 inline virtual ~TAtomicMap() 00104 { 00105 m_rLock.release(); 00106 } 00107 00108 /************************************************************************/ 00111 /************************************************************************/ 00112 inline virtual void MQUALIFIER copyToMap(IMap<TKeyType, T>& rMap) const 00113 { 00115 // LOCK 00116 TCriticalScopeLock Lock(m_rLock); 00117 m_mapData.copyToMap(rMap); 00119 } 00120 00121 /************************************************************************/ 00124 /************************************************************************/ 00125 inline virtual T& MQUALIFIER getItem(const TKeyType& rKey) 00126 { 00128 // LOCK 00129 TCriticalScopeLock Lock(m_rLock); 00130 return m_mapData.getItem(rKey); 00132 } 00133 00134 /************************************************************************/ 00137 /************************************************************************/ 00138 inline virtual const T& MQUALIFIER getItemConst(const TKeyType& rKey) const 00139 { 00141 // LOCK 00142 TCriticalScopeLock Lock(m_rLock); 00143 return m_mapData.getItemConst(rKey); 00145 } 00146 00147 /************************************************************************/ 00150 /************************************************************************/ 00151 inline virtual void MQUALIFIER setItem(const TKeyType& rKey, const T& rData) 00152 { 00154 // LOCK 00155 TCriticalScopeLock Lock(m_rLock); 00156 m_mapData.setItem(rKey, rData); 00158 } 00159 00160 /************************************************************************/ 00163 /************************************************************************/ 00164 inline virtual bool MQUALIFIER isEmpty() const 00165 { 00167 // LOCK 00168 TCriticalScopeLock Lock(m_rLock); 00169 return m_mapData.isEmpty(); 00171 } 00172 00173 /************************************************************************/ 00176 /************************************************************************/ 00177 inline virtual Int MQUALIFIER getCount() const 00178 { 00180 // LOCK 00181 TCriticalScopeLock Lock(m_rLock); 00182 return m_mapData.getCount(); 00184 } 00185 00186 /************************************************************************/ 00189 /************************************************************************/ 00190 inline virtual bool MQUALIFIER deleteItem(const TKeyType& rKey) 00191 { 00193 // LOCK 00194 TCriticalScopeLock Lock(m_rLock); 00195 return m_mapData.deleteItem(rKey); 00197 } 00198 00199 /************************************************************************/ 00202 /************************************************************************/ 00203 inline virtual bool MQUALIFIER hasItem(const TKeyType& rKey) const 00204 { 00206 // LOCK 00207 TCriticalScopeLock Lock(m_rLock); 00208 return m_mapData.hasItem(rKey); 00210 } 00211 00212 /************************************************************************/ 00215 /************************************************************************/ 00216 inline virtual void MQUALIFIER clear() 00217 { 00219 // LOCK 00220 TCriticalScopeLock Lock(m_rLock); 00221 m_mapData.clear(); 00223 } 00224 00225 /************************************************************************/ 00228 /************************************************************************/ 00229 inline virtual IMapIterator<TKeyType, T>* MQUALIFIER getIterator() 00230 { 00232 // LOCK 00233 TCriticalScopeLock Lock(m_rLock); 00234 return m_mapData.getIterator(); 00236 } 00237 00238 /************************************************************************/ 00241 /************************************************************************/ 00242 inline virtual const IMapIterator<TKeyType, T>* MQUALIFIER getConstIterator() const 00243 { 00245 // LOCK 00246 TCriticalScopeLock Lock(m_rLock); 00247 return m_mapData.getConstIterator(); 00249 } 00250 00251 00252 /************************************************************************/ 00255 /************************************************************************/ 00256 inline virtual void MQUALIFIER releaseIterator(const IListIterator<T>* pIterator) const 00257 { 00259 // LOCK 00260 TCriticalScopeLock Lock(m_rLock); 00261 m_mapData.releaseIterator(pIterator); 00263 } 00264 00265 /************************************************************************/ 00268 /************************************************************************/ 00269 inline virtual bool MQUALIFIER equals(const IMap<TKeyType, T>& rMap) const 00270 { 00272 // LOCK 00273 TCriticalScopeLock Lock(m_rLock); 00274 return m_mapData.equals(rMap); 00276 } 00277 00278 /************************************************************************/ 00281 /************************************************************************/ 00282 inline virtual bool equals(const TMap<TKeyType, T>& rMap) const 00283 { 00285 // LOCK 00286 TCriticalScopeLock Lock(m_rLock); 00287 return m_mapData.equals(rMap); 00289 } 00290 00291 /*********************************************************************/ 00296 /*********************************************************************/ 00297 inline TAtomicMap<TKeyType, T>& operator= (const TMap<TKeyType, T>& rInPar) 00298 { 00300 // LOCK 00301 TCriticalScopeLock Lock(m_rLock); 00302 m_mapData = rInPar; 00303 return *this; 00305 } 00306 00307 /*********************************************************************/ 00312 /*********************************************************************/ 00313 inline TAtomicMap<TKeyType, T>& operator= (const TAtomicMap<TKeyType, T>& rInPar) 00314 { 00316 // LOCK 00317 m_rLock.enter(); 00318 rInPar.m_rLock.enter(); 00319 00320 m_mapData = rInPar.m_mapData; 00321 00322 rInPar.m_rLock.leave(); 00323 m_rLock.leave(); 00325 00326 return *this; 00327 } 00328 00329 #ifdef USE_STL_BINDINGS 00330 /*********************************************************************/ 00335 /*********************************************************************/ 00336 inline TMap<TKeyType, T>& operator= (const std::map<TKeyType, T>& rInPar) 00337 { 00339 // LOCK 00340 TCriticalScopeLock Lock(m_rLock); 00341 m_mapData = rInPar; 00342 return *this; 00344 } 00345 #endif 00346 00347 /*********************************************************************/ 00353 /*********************************************************************/ 00354 inline bool operator== (const TAtomicMap<TKeyType, T>& rMap) const 00355 { 00357 // LOCK 00358 m_rLock.enter(); 00359 rMap.m_rLock.enter(); 00360 00361 bool bRetval = (m_mapData == rInPar.m_setData); 00362 00363 rMap.m_rLock.leave(); 00364 m_rLock.leave(); 00366 00367 return bRetval; 00368 } 00369 00370 /*********************************************************************/ 00376 /*********************************************************************/ 00377 inline bool operator== (const TMap<TKeyType, T>& rMap) const 00378 { 00380 // LOCK 00381 TCriticalScopeLock Lock(m_rLock); 00382 return (m_mapData == rMap); 00384 } 00385 00386 /*********************************************************************/ 00392 /*********************************************************************/ 00393 inline bool operator== (const IMap<TKeyType, T>& rMap) const 00394 { 00396 // LOCK 00397 TCriticalScopeLock Lock(m_rLock); 00398 return (m_mapData == rMap); 00400 } 00401 00402 /*********************************************************************/ 00405 /*********************************************************************/ 00406 inline bool operator!= (const TAtomicMap<TKeyType, T>& rMap) const 00407 { 00409 // LOCK 00410 m_rLock.enter(); 00411 rMap.m_rLock.enter(); 00412 00413 bool bRetval = (m_mapData != rInPar.m_setData); 00414 00415 rMap.m_rLock.leave(); 00416 m_rLock.leave(); 00418 00419 return bRetval; 00420 } 00421 00422 /*********************************************************************/ 00425 /*********************************************************************/ 00426 inline bool operator!= (const TMap<TKeyType, T>& rMap) const 00427 { 00429 // LOCK 00430 TCriticalScopeLock Lock(m_rLock); 00431 return (m_mapData != rMap); 00433 } 00434 00435 /*********************************************************************/ 00438 /*********************************************************************/ 00439 inline bool operator!= (const IMap<TKeyType, T>& rMap) const 00440 { 00442 // LOCK 00443 TCriticalScopeLock Lock(m_rLock); 00444 return (m_mapData != rMap); 00446 } 00447 00448 private: 00450 TMap<TKeyType, T> m_mapData; 00452 TCriticalSection& m_rLock; 00453 }; 00454 00455 00456 END_NAMESPACE_Zeus 00457 00458 #endif