ACE/ace/Map_T.inl

   1 // -*- C++ -*-
   2 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
   3
   4 template <class T> ACE_INLINE int
   5 ACE_Noop_Key_Generator<T>::operator() (T &)
   6 {
   7   return -1;
   8 }
   9
  10 template <class T> ACE_INLINE int
  11 ACE_Incremental_Key_Generator<T>::operator() (T &t)
  12 {
  13   t = ++this->t_;
  14   return 0;
  15 }
  16
  17 template <class T> ACE_INLINE const T &
  18 ACE_Incremental_Key_Generator<T>::current_value () const
  19 {
  20   return this->t_;
  21 }
  22
  23 template <class T> ACE_INLINE
  24 ACE_Iterator<T>::ACE_Iterator (ACE_Iterator_Impl<T> *impl)
  25   : implementation_ (impl)
  26 {
  27 }
  28
  29 template <class T> ACE_INLINE
  30 ACE_Iterator<T>::ACE_Iterator (const ACE_Iterator<T> &rhs)
  31   : implementation_ (rhs.implementation_->clone ())
  32 {
  33 }
  34
  35 template <class T> ACE_INLINE
  36 ACE_Iterator<T>::~ACE_Iterator ()
  37 {
  38   delete this->implementation_;
  39 }
  40
  41 template <class T> ACE_INLINE ACE_Iterator<T> &
  42 ACE_Iterator<T>::operator= (const ACE_Iterator<T> &rhs)
  43 {
  44   delete this->implementation_;
  45   this->implementation_ = rhs.implementation_->clone ();
  46   return *this;
  47 }
  48
  49 template <class T> ACE_INLINE bool
  50 ACE_Iterator<T>::operator== (const ACE_Iterator<T> &rhs) const
  51 {
  52   return this->implementation_->compare (*rhs.implementation_);
  53 }
  54
  55 template <class T> ACE_INLINE bool
  56 ACE_Iterator<T>::operator!= (const ACE_Iterator<T> &rhs) const
  57 {
  58   return !this->operator== (rhs);
  59 }
  60
  61 template <class T> ACE_INLINE T
  62 ACE_Iterator<T>::operator* () const
  63 {
  64   return this->implementation_->dereference ();
  65 }
  66
  67 template <class T> ACE_INLINE ACE_Iterator<T> &
  68 ACE_Iterator<T>::operator++ ()
  69 {
  70   this->implementation_->plus_plus ();
  71   return *this;
  72 }
  73
  74 template <class T> ACE_INLINE ACE_Iterator<T>
  75 ACE_Iterator<T>::operator++ (int)
  76 {
  77   ACE_Iterator<T> tmp = *this;
  78   this->implementation_->plus_plus ();
  79   return tmp;
  80 }
  81
  82 template <class T> ACE_INLINE ACE_Iterator<T> &
  83 ACE_Iterator<T>::operator-- ()
  84 {
  85   this->implementation_->minus_minus ();
  86   return *this;
  87 }
  88
  89 template <class T> ACE_INLINE ACE_Iterator<T>
  90 ACE_Iterator<T>::operator-- (int)
  91 {
  92   ACE_Iterator<T> tmp = *this;
  93   this->implementation_->minus_minus ();
  94   return tmp;
  95 }
  96
  97 template <class T> ACE_INLINE ACE_Iterator_Impl<T> &
  98 ACE_Iterator<T>::impl ()
  99 {
 100   return *this->implementation_;
 101 }
 102
 103 template <class T> ACE_INLINE
 104 ACE_Reverse_Iterator<T>::ACE_Reverse_Iterator (ACE_Reverse_Iterator_Impl<T> *impl)
 105   : implementation_ (impl)
 106 {
 107 }
 108
 109 template <class T> ACE_INLINE
 110 ACE_Reverse_Iterator<T>::ACE_Reverse_Iterator (const ACE_Reverse_Iterator<T> &rhs)
 111   : implementation_ (rhs.implementation_->clone ())
 112 {
 113 }
 114
 115 template <class T> ACE_INLINE
 116 ACE_Reverse_Iterator<T>::~ACE_Reverse_Iterator ()
 117 {
 118   delete this->implementation_;
 119 }
 120
 121 template <class T> ACE_INLINE ACE_Reverse_Iterator<T> &
 122 ACE_Reverse_Iterator<T>::operator= (const ACE_Reverse_Iterator<T> &rhs)
 123 {
 124   delete this->implementation_;
 125   this->implementation_ = rhs.implementation_->clone ();
 126   return *this;
 127 }
 128
 129 template <class T> ACE_INLINE bool
 130 ACE_Reverse_Iterator<T>::operator== (const ACE_Reverse_Iterator<T> &rhs) const
 131 {
 132   return this->implementation_->compare (*rhs.implementation_);
 133 }
 134
 135 template <class T> ACE_INLINE bool
 136 ACE_Reverse_Iterator<T>::operator!= (const ACE_Reverse_Iterator<T> &rhs) const
 137 {
 138   return !this->operator== (rhs);
 139 }
 140
 141 template <class T> ACE_INLINE T
 142 ACE_Reverse_Iterator<T>::operator* () const
 143 {
 144   return this->implementation_->dereference ();
 145 }
 146
 147 template <class T> ACE_INLINE ACE_Reverse_Iterator<T> &
 148 ACE_Reverse_Iterator<T>::operator++ ()
 149 {
 150   this->implementation_->plus_plus ();
 151   return *this;
 152 }
 153
 154 template <class T> ACE_INLINE ACE_Reverse_Iterator<T>
 155 ACE_Reverse_Iterator<T>::operator++ (int)
 156 {
 157   ACE_Reverse_Iterator<T> tmp = *this;
 158   this->implementation_->plus_plus ();
 159   return tmp;
 160 }
 161
 162 template <class T> ACE_INLINE ACE_Reverse_Iterator<T> &
 163 ACE_Reverse_Iterator<T>::operator-- ()
 164 {
 165   this->implementation_->minus_minus ();
 166   return *this;
 167 }
 168
 169 template <class T> ACE_INLINE ACE_Reverse_Iterator<T>
 170 ACE_Reverse_Iterator<T>::operator-- (int)
 171 {
 172   ACE_Reverse_Iterator<T> tmp = *this;
 173   this->implementation_->minus_minus ();
 174   return tmp;
 175 }
 176
 177 template <class T> ACE_INLINE ACE_Reverse_Iterator_Impl<T> &
 178 ACE_Reverse_Iterator<T>::impl ()
 179 {
 180   return *this->implementation_;
 181 }
 182
 183 template <class KEY, class VALUE> ACE_INLINE ACE_Iterator<ACE_Reference_Pair<const KEY, VALUE> >
 184 ACE_Map<KEY, VALUE>::begin ()
 185 {
 186   return iterator (this->begin_impl ());
 187 }
 188
 189 template <class KEY, class VALUE> ACE_INLINE ACE_Iterator<ACE_Reference_Pair<const KEY, VALUE> >
 190 ACE_Map<KEY, VALUE>::end ()
 191 {
 192   return iterator (this->end_impl ());
 193 }
 194
 195 template <class KEY, class VALUE> ACE_INLINE ACE_Reverse_Iterator<ACE_Reference_Pair<const KEY, VALUE> >
 196 ACE_Map<KEY, VALUE>::rbegin ()
 197 {
 198   return reverse_iterator (this->rbegin_impl ());
 199 }
 200
 201 template <class KEY, class VALUE> ACE_INLINE ACE_Reverse_Iterator<ACE_Reference_Pair<const KEY, VALUE> >
 202 ACE_Map<KEY, VALUE>::rend ()
 203 {
 204   return reverse_iterator (this->rend_impl ());
 205 }
 206
 207 template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE
 208 ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::ACE_Map_Impl_Iterator_Adapter (const IMPLEMENTATION &impl)
 209   : implementation_ (impl)
 210 {
 211 }
 212
 213 template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE IMPLEMENTATION &
 214 ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::impl ()
 215 {
 216   return this->implementation_;
 217 }
 218
 219 template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE
 220 ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::ACE_Map_Impl_Reverse_Iterator_Adapter (const IMPLEMENTATION &impl)
 221   : implementation_ (impl)
 222 {
 223 }
 224
 225 template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE IMPLEMENTATION &
 226 ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::impl ()
 227 {
 228   return this->implementation_;
 229 }
 230
 231 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE
 232 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::ACE_Map_Impl (ACE_Allocator *alloc)
 233   : implementation_ (alloc)
 234 {
 235 }
 236
 237 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE
 238 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::ACE_Map_Impl (size_t size,
 239                                                                                            ACE_Allocator *alloc)
 240   : implementation_ (size,
 241                      alloc)
 242 {
 243 }
 244
 245 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE IMPLEMENTATION &
 246 ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::impl ()
 247 {
 248   return this->implementation_;
 249 }
 250
 251 template <class T, class VALUE> ACE_INLINE
 252 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)
 253   : implementation_ (impl)
 254 {
 255 }
 256
 257 template <class T, class VALUE> ACE_INLINE ACE_Map_Iterator<ACE_Active_Map_Manager_Key, VALUE, ACE_Null_Mutex> &
 258 ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::impl ()
 259 {
 260   return this->implementation_;
 261 }
 262
 263 template <class T, class VALUE> ACE_INLINE
 264 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)
 265   : implementation_ (impl)
 266 {
 267 }
 268
 269 template <class T, class VALUE> ACE_INLINE ACE_Map_Reverse_Iterator<ACE_Active_Map_Manager_Key, VALUE, ACE_Null_Mutex> &
 270 ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::impl ()
 271 {
 272   return this->implementation_;
 273 }
 274
 275 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE
 276 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::ACE_Active_Map_Manager_Adapter (ACE_Allocator *alloc)
 277   : implementation_ (alloc)
 278 {
 279 }
 280
 281 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE
 282 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::ACE_Active_Map_Manager_Adapter (size_t size,
 283                                                                                          ACE_Allocator *alloc)
 284   : implementation_ (size,
 285                      alloc)
 286 {
 287 }
 288
 289 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE ACE_Active_Map_Manager<std::pair<KEY, VALUE> > &
 290 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::impl ()
 291 {
 292   return this->implementation_;
 293 }
 294
 295 template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE KEY_ADAPTER &
 296 ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::key_adapter ()
 297 {
 298   return this->key_adapter_;
 299 }
 300
 301 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_INLINE
 302 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)
 303   : implementation_ (impl)
 304 {
 305 }
 306
 307 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> &
 308 ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::impl ()
 309 {
 310   return this->implementation_;
 311 }
 312
 313 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_INLINE
 314 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)
 315   : implementation_ (impl)
 316 {
 317 }
 318
 319 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> &
 320 ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::impl ()
 321 {
 322   return this->implementation_;
 323 }
 324
 325 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE
 326 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::ACE_Hash_Map_Manager_Ex_Adapter (ACE_Allocator *alloc)
 327   : implementation_ (alloc)
 328 {
 329 }
 330
 331 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE
 332 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::ACE_Hash_Map_Manager_Ex_Adapter (size_t size,
 333                                                                                                                      ACE_Allocator *alloc)
 334   : implementation_ (size,
 335                      alloc)
 336 {
 337 }
 338
 339 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> &
 340 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::impl ()
 341 {
 342   return this->implementation_;
 343 }
 344
 345 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE KEY_GENERATOR &
 346 ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::key_generator ()
 347 {
 348   return this->key_generator_;
 349 }
 350
 351 template <class T, class KEY, class VALUE> ACE_INLINE
 352 ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::ACE_Map_Manager_Iterator_Adapter (const ACE_Map_Iterator<KEY, VALUE, ACE_Null_Mutex> &impl)
 353   : implementation_ (impl)
 354 {
 355 }
 356
 357 template <class T, class KEY, class VALUE> ACE_INLINE ACE_Map_Iterator<KEY, VALUE, ACE_Null_Mutex> &
 358 ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::impl ()
 359 {
 360   return this->implementation_;
 361 }
 362
 363 template <class T, class KEY, class VALUE> ACE_INLINE
 364 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)
 365   : implementation_ (impl)
 366 {
 367 }
 368
 369 template <class T, class KEY, class VALUE> ACE_INLINE ACE_Map_Reverse_Iterator<KEY, VALUE, ACE_Null_Mutex> &
 370 ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::impl ()
 371 {
 372   return this->implementation_;
 373 }
 374
 375 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE
 376 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::ACE_Map_Manager_Adapter (ACE_Allocator *alloc)
 377   : implementation_ (alloc)
 378 {
 379 }
 380
 381 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE
 382 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::ACE_Map_Manager_Adapter (size_t size,
 383                                                                              ACE_Allocator *alloc)
 384   : implementation_ (size,
 385                      alloc)
 386 {
 387 }
 388
 389 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE ACE_Map_Manager<KEY, VALUE, ACE_Null_Mutex> &
 390 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::impl ()
 391 {
 392   return this->implementation_;
 393 }
 394
 395 template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE KEY_GENERATOR &
 396 ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::key_generator ()
 397 {
 398   return this->key_generator_;
 399 }
 400
 401 ACE_END_VERSIONED_NAMESPACE_DECL