00001
00002
00003
00004
00005 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00006
00007 template <class T> ACE_INLINE int
00008 ACE_Noop_Key_Generator<T>::operator() (T &)
00009 {
00010 return -1;
00011 }
00012
00013 template <class T> ACE_INLINE
00014 ACE_Incremental_Key_Generator<T>::ACE_Incremental_Key_Generator (void)
00015 : t_ (0)
00016 {
00017 }
00018
00019 template <class T> ACE_INLINE int
00020 ACE_Incremental_Key_Generator<T>::operator() (T &t)
00021 {
00022 t = ++this->t_;
00023 return 0;
00024 }
00025
00026 template <class T> ACE_INLINE const T &
00027 ACE_Incremental_Key_Generator<T>::current_value (void) const
00028 {
00029 return this->t_;
00030 }
00031
00032 template <class T> ACE_INLINE
00033 ACE_Iterator<T>::ACE_Iterator (ACE_Iterator_Impl<T> *impl)
00034 : implementation_ (impl)
00035 {
00036 }
00037
00038 template <class T> ACE_INLINE
00039 ACE_Iterator<T>::ACE_Iterator (const ACE_Iterator<T> &rhs)
00040 : implementation_ (rhs.implementation_->clone ())
00041 {
00042 }
00043
00044 template <class T> ACE_INLINE
00045 ACE_Iterator<T>::~ACE_Iterator (void)
00046 {
00047 delete this->implementation_;
00048 }
00049
00050 template <class T> ACE_INLINE ACE_Iterator<T> &
00051 ACE_Iterator<T>::operator= (const ACE_Iterator<T> &rhs)
00052 {
00053 delete this->implementation_;
00054 this->implementation_ = rhs.implementation_->clone ();
00055 return *this;
00056 }
00057
00058 template <class T> ACE_INLINE bool
00059 ACE_Iterator<T>::operator== (const ACE_Iterator<T> &rhs) const
00060 {
00061 return this->implementation_->compare (*rhs.implementation_);
00062 }
00063
00064 template <class T> ACE_INLINE bool
00065 ACE_Iterator<T>::operator!= (const ACE_Iterator<T> &rhs) const
00066 {
00067 return !this->operator== (rhs);
00068 }
00069
00070 template <class T> ACE_INLINE T
00071 ACE_Iterator<T>::operator* (void) const
00072 {
00073 return this->implementation_->dereference ();
00074 }
00075
00076 template <class T> ACE_INLINE ACE_Iterator<T> &
00077 ACE_Iterator<T>::operator++ (void)
00078 {
00079 this->implementation_->plus_plus ();
00080 return *this;
00081 }
00082
00083 template <class T> ACE_INLINE ACE_Iterator<T>
00084 ACE_Iterator<T>::operator++ (int)
00085 {
00086 ACE_Iterator<T> tmp = *this;
00087 this->implementation_->plus_plus ();
00088 return tmp;
00089 }
00090
00091 template <class T> ACE_INLINE ACE_Iterator<T> &
00092 ACE_Iterator<T>::operator-- (void)
00093 {
00094 this->implementation_->minus_minus ();
00095 return *this;
00096 }
00097
00098 template <class T> ACE_INLINE ACE_Iterator<T>
00099 ACE_Iterator<T>::operator-- (int)
00100 {
00101 ACE_Iterator<T> tmp = *this;
00102 this->implementation_->minus_minus ();
00103 return tmp;
00104 }
00105
00106 template <class T> ACE_INLINE ACE_Iterator_Impl<T> &
00107 ACE_Iterator<T>::impl (void)
00108 {
00109 return *this->implementation_;
00110 }
00111
00112 template <class T> ACE_INLINE
00113 ACE_Reverse_Iterator<T>::ACE_Reverse_Iterator (ACE_Reverse_Iterator_Impl<T> *impl)
00114 : implementation_ (impl)
00115 {
00116 }
00117
00118 template <class T> ACE_INLINE
00119 ACE_Reverse_Iterator<T>::ACE_Reverse_Iterator (const ACE_Reverse_Iterator<T> &rhs)
00120 : implementation_ (rhs.implementation_->clone ())
00121 {
00122 }
00123
00124 template <class T> ACE_INLINE
00125 ACE_Reverse_Iterator<T>::~ACE_Reverse_Iterator (void)
00126 {
00127 delete this->implementation_;
00128 }
00129
00130 template <class T> ACE_INLINE ACE_Reverse_Iterator<T> &
00131 ACE_Reverse_Iterator<T>::operator= (const ACE_Reverse_Iterator<T> &rhs)
00132 {
00133 delete this->implementation_;
00134 this->implementation_ = rhs.implementation_->clone ();
00135 return *this;
00136 }
00137
00138 template <class T> ACE_INLINE bool
00139 ACE_Reverse_Iterator<T>::operator== (const ACE_Reverse_Iterator<T> &rhs) const
00140 {
00141 return this->implementation_->compare (*rhs.implementation_);
00142 }
00143
00144 template <class T> ACE_INLINE bool
00145 ACE_Reverse_Iterator<T>::operator!= (const ACE_Reverse_Iterator<T> &rhs) const
00146 {
00147 return !this->operator== (rhs);
00148 }
00149
00150 template <class T> ACE_INLINE T
00151 ACE_Reverse_Iterator<T>::operator* (void) const
00152 {
00153 return this->implementation_->dereference ();
00154 }
00155
00156 template <class T> ACE_INLINE ACE_Reverse_Iterator<T> &
00157 ACE_Reverse_Iterator<T>::operator++ (void)
00158 {
00159 this->implementation_->plus_plus ();
00160 return *this;
00161 }
00162
00163 template <class T> ACE_INLINE ACE_Reverse_Iterator<T>
00164 ACE_Reverse_Iterator<T>::operator++ (int)
00165 {
00166 ACE_Reverse_Iterator<T> tmp = *this;
00167 this->implementation_->plus_plus ();
00168 return tmp;
00169 }
00170
00171 template <class T> ACE_INLINE ACE_Reverse_Iterator<T> &
00172 ACE_Reverse_Iterator<T>::operator-- (void)
00173 {
00174 this->implementation_->minus_minus ();
00175 return *this;
00176 }
00177
00178 template <class T> ACE_INLINE ACE_Reverse_Iterator<T>
00179 ACE_Reverse_Iterator<T>::operator-- (int)
00180 {
00181 ACE_Reverse_Iterator<T> tmp = *this;
00182 this->implementation_->minus_minus ();
00183 return tmp;
00184 }
00185
00186 template <class T> ACE_INLINE ACE_Reverse_Iterator_Impl<T> &
00187 ACE_Reverse_Iterator<T>::impl (void)
00188 {
00189 return *this->implementation_;
00190 }
00191
00192 template <class KEY, class VALUE> ACE_INLINE
00193 ACE_Map<KEY, VALUE>::ACE_Map (void)
00194 {
00195 }
00196
00197 template <class KEY, class VALUE> ACE_INLINE ACE_Iterator<ACE_Reference_Pair<const KEY, VALUE> >
00198 ACE_Map<KEY, VALUE>::begin (void)
00199 {
00200 return iterator (this->begin_impl ());
00201 }
00202
00203 template <class KEY, class VALUE> ACE_INLINE ACE_Iterator<ACE_Reference_Pair<const KEY, VALUE> >
00204 ACE_Map<KEY, VALUE>::end (void)
00205 {
00206 return iterator (this->end_impl ());
00207 }
00208
00209 template <class KEY, class VALUE> ACE_INLINE ACE_Reverse_Iterator<ACE_Reference_Pair<const KEY, VALUE> >
00210 ACE_Map<KEY, VALUE>::rbegin (void)
00211 {
00212 return reverse_iterator (this->rbegin_impl ());
00213 }
00214
00215 template <class KEY, class VALUE> ACE_INLINE ACE_Reverse_Iterator<ACE_Reference_Pair<const KEY, VALUE> >
00216 ACE_Map<KEY, VALUE>::rend (void)
00217 {
00218 return reverse_iterator (this->rend_impl ());
00219 }
00220
00221 template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE
00222 ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::ACE_Map_Impl_Iterator_Adapter (const IMPLEMENTATION &impl)
00223 : implementation_ (impl)
00224 {
00225 }
00226
00227 template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE IMPLEMENTATION &
00228 ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::impl (void)
00229 {
00230 return this->implementation_;
00231 }
00232
00233 template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE
00234 ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::ACE_Map_Impl_Reverse_Iterator_Adapter (const IMPLEMENTATION &impl)
00235 : implementation_ (impl)
00236 {
00237 }
00238
00239 template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE IMPLEMENTATION &
00240 ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::impl (void)
00241 {
00242 return this->implementation_;
00243 }
00244
00245 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE
00246 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::ACE_Map_Impl (ACE_Allocator *alloc)
00247 : implementation_ (alloc)
00248 {
00249 }
00250
00251 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE
00252 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::ACE_Map_Impl (size_t size,
00253 ACE_Allocator *alloc)
00254 : implementation_ (size,
00255 alloc)
00256 {
00257 }
00258
00259 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE IMPLEMENTATION &
00260 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::impl (void)
00261 {
00262 return this->implementation_;
00263 }
00264
00265 template <class T, class VALUE> ACE_INLINE
00266 ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::ACE_Active_Map_Manager_Iterator_Adapter (const ACE_Map_Iterator<ACE_Active_Map_Manager_Key, VALUE, ACE_Null_Mutex> &impl)
00267 : implementation_ (impl)
00268 {
00269 }
00270
00271 template <class T, class VALUE> ACE_INLINE ACE_Map_Iterator<ACE_Active_Map_Manager_Key, VALUE, ACE_Null_Mutex> &
00272 ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::impl (void)
00273 {
00274 return this->implementation_;
00275 }
00276
00277 template <class T, class VALUE> ACE_INLINE
00278 ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::ACE_Active_Map_Manager_Reverse_Iterator_Adapter (const ACE_Map_Reverse_Iterator<ACE_Active_Map_Manager_Key, VALUE, ACE_Null_Mutex> &impl)
00279 : implementation_ (impl)
00280 {
00281 }
00282
00283 template <class T, class VALUE> ACE_INLINE ACE_Map_Reverse_Iterator<ACE_Active_Map_Manager_Key, VALUE, ACE_Null_Mutex> &
00284 ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::impl (void)
00285 {
00286 return this->implementation_;
00287 }
00288
00289 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE
00290 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::ACE_Active_Map_Manager_Adapter (ACE_Allocator *alloc)
00291 : implementation_ (alloc)
00292 {
00293 }
00294
00295 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE
00296 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::ACE_Active_Map_Manager_Adapter (size_t size,
00297 ACE_Allocator *alloc)
00298 : implementation_ (size,
00299 alloc)
00300 {
00301 }
00302
00303 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE ACE_Active_Map_Manager<ACE_Pair<KEY, VALUE> > &
00304 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::impl (void)
00305 {
00306 return this->implementation_;
00307 }
00308
00309 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE KEY_ADAPTER &
00310 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::key_adapter (void)
00311 {
00312 return this->key_adapter_;
00313 }
00314
00315 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_INLINE
00316 ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::ACE_Hash_Map_Manager_Ex_Iterator_Adapter (const ACE_Hash_Map_Iterator_Ex<KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex> &impl)
00317 : implementation_ (impl)
00318 {
00319 }
00320
00321 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_INLINE ACE_Hash_Map_Iterator_Ex<KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex> &
00322 ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::impl (void)
00323 {
00324 return this->implementation_;
00325 }
00326
00327 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_INLINE
00328 ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter (const ACE_Hash_Map_Reverse_Iterator_Ex<KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex> &impl)
00329 : implementation_ (impl)
00330 {
00331 }
00332
00333 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_INLINE ACE_Hash_Map_Reverse_Iterator_Ex<KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex> &
00334 ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::impl (void)
00335 {
00336 return this->implementation_;
00337 }
00338
00339 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE
00340 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::ACE_Hash_Map_Manager_Ex_Adapter (ACE_Allocator *alloc)
00341 : implementation_ (alloc)
00342 {
00343 }
00344
00345 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE
00346 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::ACE_Hash_Map_Manager_Ex_Adapter (size_t size,
00347 ACE_Allocator *alloc)
00348 : implementation_ (size,
00349 alloc)
00350 {
00351 }
00352
00353 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE ACE_Hash_Map_Manager_Ex<KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex> &
00354 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::impl (void)
00355 {
00356 return this->implementation_;
00357 }
00358
00359 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE KEY_GENERATOR &
00360 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::key_generator (void)
00361 {
00362 return this->key_generator_;
00363 }
00364
00365 template <class T, class KEY, class VALUE> ACE_INLINE
00366 ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::ACE_Map_Manager_Iterator_Adapter (const ACE_Map_Iterator<KEY, VALUE, ACE_Null_Mutex> &impl)
00367 : implementation_ (impl)
00368 {
00369 }
00370
00371 template <class T, class KEY, class VALUE> ACE_INLINE ACE_Map_Iterator<KEY, VALUE, ACE_Null_Mutex> &
00372 ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::impl (void)
00373 {
00374 return this->implementation_;
00375 }
00376
00377 template <class T, class KEY, class VALUE> ACE_INLINE
00378 ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::ACE_Map_Manager_Reverse_Iterator_Adapter (const ACE_Map_Reverse_Iterator<KEY, VALUE, ACE_Null_Mutex> &impl)
00379 : implementation_ (impl)
00380 {
00381 }
00382
00383 template <class T, class KEY, class VALUE> ACE_INLINE ACE_Map_Reverse_Iterator<KEY, VALUE, ACE_Null_Mutex> &
00384 ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::impl (void)
00385 {
00386 return this->implementation_;
00387 }
00388
00389 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE
00390 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::ACE_Map_Manager_Adapter (ACE_Allocator *alloc)
00391 : implementation_ (alloc)
00392 {
00393 }
00394
00395 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE
00396 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::ACE_Map_Manager_Adapter (size_t size,
00397 ACE_Allocator *alloc)
00398 : implementation_ (size,
00399 alloc)
00400 {
00401 }
00402
00403 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE ACE_Map_Manager<KEY, VALUE, ACE_Null_Mutex> &
00404 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::impl (void)
00405 {
00406 return this->implementation_;
00407 }
00408
00409 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE KEY_GENERATOR &
00410 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::key_generator (void)
00411 {
00412 return this->key_generator_;
00413 }
00414
00415 ACE_END_VERSIONED_NAMESPACE_DECL
