Nugget
fixed_set.h
1 // Copyright (c) Electronic Arts Inc. All rights reserved.
4 
6 // This file implements a set and multiset which use a fixed size memory
7 // pool for their nodes.
9 
10 
11 #ifndef EASTL_FIXED_SET_H
12 #define EASTL_FIXED_SET_H
13 
14 
15 #include <EASTL/set.h>
16 #include <EASTL/internal/fixed_pool.h>
17 
18 #if defined(EA_PRAGMA_ONCE_SUPPORTED)
19  #pragma once // Some compilers (e.g. VC++) benefit significantly from using this. We've measured 3-4% build speed improvements in apps as a result.
20 #endif
21 
22 
23 
24 namespace eastl
25 {
32  #ifndef EASTL_FIXED_SET_DEFAULT_NAME
33  #define EASTL_FIXED_SET_DEFAULT_NAME EASTL_DEFAULT_NAME_PREFIX " fixed_set" // Unless the user overrides something, this is "EASTL fixed_set".
34  #endif
35 
36  #ifndef EASTL_FIXED_MULTISET_DEFAULT_NAME
37  #define EASTL_FIXED_MULTISET_DEFAULT_NAME EASTL_DEFAULT_NAME_PREFIX " fixed_multiset" // Unless the user overrides something, this is "EASTL fixed_multiset".
38  #endif
39 
40 
44  #ifndef EASTL_FIXED_SET_DEFAULT_ALLOCATOR
45  #define EASTL_FIXED_SET_DEFAULT_ALLOCATOR overflow_allocator_type(EASTL_FIXED_SET_DEFAULT_NAME)
46  #endif
47 
48  #ifndef EASTL_FIXED_MULTISET_DEFAULT_ALLOCATOR
49  #define EASTL_FIXED_MULTISET_DEFAULT_ALLOCATOR overflow_allocator_type(EASTL_FIXED_MULTISET_DEFAULT_NAME)
50  #endif
51 
52 
53 
66  template <typename Key, size_t nodeCount, bool bEnableOverflow = true, typename Compare = eastl::less<Key>, typename OverflowAllocator = EASTLAllocatorType>
67  class fixed_set : public set<Key, Compare, fixed_node_allocator<sizeof(typename set<Key>::node_type),
68  nodeCount, EASTL_ALIGN_OF(Key), 0, bEnableOverflow, OverflowAllocator> >
69  {
70  public:
71  typedef fixed_node_allocator<sizeof(typename set<Key>::node_type), nodeCount,
72  EASTL_ALIGN_OF(Key), 0, bEnableOverflow, OverflowAllocator> fixed_allocator_type;
73  typedef typename fixed_allocator_type::overflow_allocator_type overflow_allocator_type;
74  typedef set<Key, Compare, fixed_allocator_type> base_type;
75  typedef fixed_set<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator> this_type;
76  typedef typename base_type::value_type value_type;
77  typedef typename base_type::node_type node_type;
78  typedef typename base_type::size_type size_type;
79 
80  enum { kMaxSize = nodeCount };
81 
82  using base_type::insert;
83 
84  protected:
85  char mBuffer[fixed_allocator_type::kBufferSize]; // kBufferSize will take into account alignment requirements.
86 
87  using base_type::mAllocator;
88  using base_type::get_compare;
89 
90  public:
91  fixed_set();
92  fixed_set(const overflow_allocator_type& overflowAllocator);
93  explicit fixed_set(const Compare& compare);
94  fixed_set(const this_type& x);
95  fixed_set(this_type&& x);
96  fixed_set(this_type&& x, const overflow_allocator_type& overflowAllocator);
97  fixed_set(std::initializer_list<value_type> ilist, const overflow_allocator_type& overflowAllocator = EASTL_FIXED_SET_DEFAULT_ALLOCATOR);
98 
99  template <typename InputIterator>
100  fixed_set(InputIterator first, InputIterator last);
101 
102  this_type& operator=(const this_type& x);
103  this_type& operator=(std::initializer_list<value_type> ilist);
104  this_type& operator=(this_type&& x);
105 
106  void swap(this_type& x);
107 
108  void reset_lose_memory(); // This is a unilateral reset to an initially empty state. No destructors are called, no deallocation occurs.
109 
110  size_type max_size() const;
111 
112  const overflow_allocator_type& get_overflow_allocator() const EA_NOEXCEPT;
113  overflow_allocator_type& get_overflow_allocator() EA_NOEXCEPT;
114  void set_overflow_allocator(const overflow_allocator_type& allocator);
115  }; // fixed_set
116 
117 
118 
119 
120 
121 
133  template <typename Key, size_t nodeCount, bool bEnableOverflow = true, typename Compare = eastl::less<Key>, typename OverflowAllocator = EASTLAllocatorType>
134  class fixed_multiset : public multiset<Key, Compare, fixed_node_allocator<sizeof(typename multiset<Key>::node_type),
135  nodeCount, EASTL_ALIGN_OF(Key), 0, bEnableOverflow, OverflowAllocator> >
136  {
137  public:
138  typedef fixed_node_allocator<sizeof(typename multiset<Key>::node_type), nodeCount,
139  EASTL_ALIGN_OF(Key), 0, bEnableOverflow, OverflowAllocator> fixed_allocator_type;
140  typedef typename fixed_allocator_type::overflow_allocator_type overflow_allocator_type;
141  typedef multiset<Key, Compare, fixed_allocator_type> base_type;
142  typedef fixed_multiset<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator> this_type;
143  typedef typename base_type::value_type value_type;
144  typedef typename base_type::node_type node_type;
145  typedef typename base_type::size_type size_type;
146 
147  enum { kMaxSize = nodeCount };
148 
149  using base_type::insert;
150 
151  protected:
152  char mBuffer[fixed_allocator_type::kBufferSize]; // kBufferSize will take into account alignment requirements.
153 
154  using base_type::mAllocator;
155 
156  public:
157  fixed_multiset();
158  fixed_multiset(const overflow_allocator_type& overflowAllocator);
159  explicit fixed_multiset(const Compare& compare);
160  fixed_multiset(const this_type& x);
161  fixed_multiset(this_type&& x);
162  fixed_multiset(this_type&& x, const overflow_allocator_type& overflowAllocator);
163  fixed_multiset(std::initializer_list<value_type> ilist, const overflow_allocator_type& overflowAllocator = EASTL_FIXED_MULTISET_DEFAULT_ALLOCATOR);
164 
165  template <typename InputIterator>
166  fixed_multiset(InputIterator first, InputIterator last);
167 
168  this_type& operator=(const this_type& x);
169  this_type& operator=(std::initializer_list<value_type> ilist);
170  this_type& operator=(this_type&& x);
171 
172  void swap(this_type& x);
173 
174  void reset_lose_memory(); // This is a unilateral reset to an initially empty state. No destructors are called, no deallocation occurs.
175 
176  size_type max_size() const;
177 
178  const overflow_allocator_type& get_overflow_allocator() const EA_NOEXCEPT;
179  overflow_allocator_type& get_overflow_allocator() EA_NOEXCEPT;
180  void set_overflow_allocator(const overflow_allocator_type& allocator);
181  }; // fixed_multiset
182 
183 
184 
185 
187  // fixed_set
189 
190  template <typename Key, size_t nodeCount, bool bEnableOverflow, typename Compare, typename OverflowAllocator>
191  inline fixed_set<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::fixed_set()
192  : base_type(fixed_allocator_type(mBuffer))
193  {
194  #if EASTL_NAME_ENABLED
195  mAllocator.set_name(EASTL_FIXED_SET_DEFAULT_NAME);
196  #endif
197  }
198 
199 
200  template <typename Key, size_t nodeCount, bool bEnableOverflow, typename Compare, typename OverflowAllocator>
201  inline fixed_set<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::fixed_set(const overflow_allocator_type& overflowAllocator)
202  : base_type(fixed_allocator_type(mBuffer, overflowAllocator))
203  {
204  #if EASTL_NAME_ENABLED
205  mAllocator.set_name(EASTL_FIXED_SET_DEFAULT_NAME);
206  #endif
207  }
208 
209 
210  template <typename Key, size_t nodeCount, bool bEnableOverflow, typename Compare, typename OverflowAllocator>
211  inline fixed_set<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::fixed_set(const Compare& compare)
212  : base_type(compare, fixed_allocator_type(mBuffer))
213  {
214  #if EASTL_NAME_ENABLED
215  mAllocator.set_name(EASTL_FIXED_SET_DEFAULT_NAME);
216  #endif
217  }
218 
219 
220  template <typename Key, size_t nodeCount, bool bEnableOverflow, typename Compare, typename OverflowAllocator>
221  inline fixed_set<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::fixed_set(const this_type& x)
222  : base_type(x.get_compare(), fixed_allocator_type(mBuffer))
223  {
224  mAllocator.copy_overflow_allocator(x.mAllocator);
225 
226  #if EASTL_NAME_ENABLED
227  mAllocator.set_name(x.mAllocator.get_name());
228  #endif
229 
230  base_type::operator=(x);
231  }
232 
233 
234  template <typename Key, size_t nodeCount, bool bEnableOverflow, typename Compare, typename OverflowAllocator>
235  inline fixed_set<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::fixed_set(this_type&& x)
236  : base_type(x.get_compare(), fixed_allocator_type(mBuffer))
237  {
238  mAllocator.copy_overflow_allocator(x.mAllocator);
239 
240  #if EASTL_NAME_ENABLED
241  mAllocator.set_name(x.mAllocator.get_name());
242  #endif
243 
244  base_type::operator=(x);
245  }
246 
247 
248  template <typename Key, size_t nodeCount, bool bEnableOverflow, typename Compare, typename OverflowAllocator>
249  inline fixed_set<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::fixed_set(this_type&& x, const overflow_allocator_type& overflowAllocator)
250  : base_type(x.get_compare(), fixed_allocator_type(mBuffer, overflowAllocator))
251  {
252  mAllocator.copy_overflow_allocator(x.mAllocator);
253 
254  #if EASTL_NAME_ENABLED
255  mAllocator.set_name(x.mAllocator.get_name());
256  #endif
257 
258  base_type::operator=(x);
259  }
260 
261 
262  template <typename Key, size_t nodeCount, bool bEnableOverflow, typename Compare, typename OverflowAllocator>
263  fixed_set<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::fixed_set(std::initializer_list<value_type> ilist, const overflow_allocator_type& overflowAllocator)
264  : base_type(fixed_allocator_type(mBuffer, overflowAllocator))
265  {
266  #if EASTL_NAME_ENABLED
267  mAllocator.set_name(EASTL_FIXED_SET_DEFAULT_NAME);
268  #endif
269 
270  insert(ilist.begin(), ilist.end());
271  }
272 
273 
274  template <typename Key, size_t nodeCount, bool bEnableOverflow, typename Compare, typename OverflowAllocator>
275  template <typename InputIterator>
276  fixed_set<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::fixed_set(InputIterator first, InputIterator last)
277  : base_type(fixed_allocator_type(mBuffer))
278  {
279  #if EASTL_NAME_ENABLED
280  mAllocator.set_name(EASTL_FIXED_SET_DEFAULT_NAME);
281  #endif
282 
283  insert(first, last);
284  }
285 
286 
287  template <typename Key, size_t nodeCount, bool bEnableOverflow, typename Compare, typename OverflowAllocator>
288  inline typename fixed_set<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::this_type&
289  fixed_set<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::operator=(const this_type& x)
290  {
291  base_type::operator=(x);
292  return *this;
293  }
294 
295 
296  template <typename Key, size_t nodeCount, bool bEnableOverflow, typename Compare, typename OverflowAllocator>
297  inline typename fixed_set<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::this_type&
298  fixed_set<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::operator=(std::initializer_list<value_type> ilist)
299  {
300  base_type::clear();
301  insert(ilist.begin(), ilist.end());
302  return *this;
303  }
304 
305 
306  template <typename Key, size_t nodeCount, bool bEnableOverflow, typename Compare, typename OverflowAllocator>
307  inline typename fixed_set<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::this_type&
308  fixed_set<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::operator=(this_type&& x)
309  {
310  base_type::operator=(x);
311  return *this;
312  }
313 
314 
315  template <typename Key, size_t nodeCount, bool bEnableOverflow, typename Compare, typename OverflowAllocator>
316  inline void fixed_set<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::swap(this_type& x)
317  {
318  // Fixed containers use a special swap that can deal with excessively large buffers.
319  eastl::fixed_swap(*this, x);
320  }
321 
322 
323  template <typename Key, size_t nodeCount, bool bEnableOverflow, typename Compare, typename OverflowAllocator>
324  inline void fixed_set<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::reset_lose_memory()
325  {
326  base_type::reset_lose_memory();
327  base_type::get_allocator().reset(mBuffer);
328  }
329 
330 
331  template <typename Key, size_t nodeCount, bool bEnableOverflow, typename Compare, typename OverflowAllocator>
332  inline typename fixed_set<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::size_type
333  fixed_set<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::max_size() const
334  {
335  return kMaxSize;
336  }
337 
338 
339  template <typename Key, size_t nodeCount, bool bEnableOverflow, typename Compare, typename OverflowAllocator>
340  inline const typename fixed_set<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::overflow_allocator_type&
341  fixed_set<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::get_overflow_allocator() const EA_NOEXCEPT
342  {
343  return mAllocator.get_overflow_allocator();
344  }
345 
346 
347  template <typename Key, size_t nodeCount, bool bEnableOverflow, typename Compare, typename OverflowAllocator>
348  inline typename fixed_set<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::overflow_allocator_type&
349  fixed_set<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::get_overflow_allocator() EA_NOEXCEPT
350  {
351  return mAllocator.get_overflow_allocator();
352  }
353 
354 
355  template <typename Key, size_t nodeCount, bool bEnableOverflow, typename Compare, typename OverflowAllocator>
356  inline void fixed_set<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::set_overflow_allocator(const overflow_allocator_type& allocator)
357  {
358  mAllocator.set_overflow_allocator(allocator);
359  }
360 
361 
363  // global operators
365 
366  template <typename Key, size_t nodeCount, bool bEnableOverflow, typename Compare, typename OverflowAllocator>
367  inline void swap(fixed_set<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>& a,
368  fixed_set<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>& b)
369  {
370  // Fixed containers use a special swap that can deal with excessively large buffers.
371  eastl::fixed_swap(a, b);
372  }
373 
374 
375 
377  // fixed_multiset
379 
380  template <typename Key, size_t nodeCount, bool bEnableOverflow, typename Compare, typename OverflowAllocator>
381  inline fixed_multiset<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::fixed_multiset()
382  : base_type(fixed_allocator_type(mBuffer))
383  {
384  #if EASTL_NAME_ENABLED
385  mAllocator.set_name(EASTL_FIXED_MULTISET_DEFAULT_NAME);
386  #endif
387  }
388 
389 
390  template <typename Key, size_t nodeCount, bool bEnableOverflow, typename Compare, typename OverflowAllocator>
391  inline fixed_multiset<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::fixed_multiset(const overflow_allocator_type& overflowAllocator)
392  : base_type(fixed_allocator_type(mBuffer, overflowAllocator))
393  {
394  #if EASTL_NAME_ENABLED
395  mAllocator.set_name(EASTL_FIXED_MULTISET_DEFAULT_NAME);
396  #endif
397  }
398 
399 
400  template <typename Key, size_t nodeCount, bool bEnableOverflow, typename Compare, typename OverflowAllocator>
401  inline fixed_multiset<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::fixed_multiset(const Compare& compare)
402  : base_type(compare, fixed_allocator_type(mBuffer))
403  {
404  #if EASTL_NAME_ENABLED
405  mAllocator.set_name(EASTL_FIXED_MULTISET_DEFAULT_NAME);
406  #endif
407  }
408 
409 
410  template <typename Key, size_t nodeCount, bool bEnableOverflow, typename Compare, typename OverflowAllocator>
411  inline fixed_multiset<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::fixed_multiset(const this_type& x)
412  : base_type(x.get_compare(), fixed_allocator_type(mBuffer))
413  {
414  mAllocator.copy_overflow_allocator(x.mAllocator);
415 
416  #if EASTL_NAME_ENABLED
417  mAllocator.set_name(x.mAllocator.get_name());
418  #endif
419 
420  base_type::operator=(x);
421  }
422 
423 
424  template <typename Key, size_t nodeCount, bool bEnableOverflow, typename Compare, typename OverflowAllocator>
425  inline fixed_multiset<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::fixed_multiset(this_type&& x)
426  : base_type(x.get_compare(), fixed_allocator_type(mBuffer))
427  {
428  mAllocator.copy_overflow_allocator(x.mAllocator);
429 
430  #if EASTL_NAME_ENABLED
431  mAllocator.set_name(x.mAllocator.get_name());
432  #endif
433 
434  base_type::operator=(x);
435  }
436 
437 
438  template <typename Key, size_t nodeCount, bool bEnableOverflow, typename Compare, typename OverflowAllocator>
439  inline fixed_multiset<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::fixed_multiset(this_type&& x, const overflow_allocator_type& overflowAllocator)
440  : base_type(x.get_compare(), fixed_allocator_type(mBuffer, overflowAllocator))
441  {
442  mAllocator.copy_overflow_allocator(x.mAllocator);
443 
444  #if EASTL_NAME_ENABLED
445  mAllocator.set_name(x.mAllocator.get_name());
446  #endif
447 
448  base_type::operator=(x);
449  }
450 
451 
452  template <typename Key, size_t nodeCount, bool bEnableOverflow, typename Compare, typename OverflowAllocator>
453  fixed_multiset<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::fixed_multiset(std::initializer_list<value_type> ilist, const overflow_allocator_type& overflowAllocator)
454  : base_type(fixed_allocator_type(mBuffer, overflowAllocator))
455  {
456  #if EASTL_NAME_ENABLED
457  mAllocator.set_name(EASTL_FIXED_MULTISET_DEFAULT_NAME);
458  #endif
459 
460  insert(ilist.begin(), ilist.end());
461  }
462 
463 
464  template <typename Key, size_t nodeCount, bool bEnableOverflow, typename Compare, typename OverflowAllocator>
465  template <typename InputIterator>
466  fixed_multiset<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::fixed_multiset(InputIterator first, InputIterator last)
467  : base_type(fixed_allocator_type(mBuffer))
468  {
469  #if EASTL_NAME_ENABLED
470  mAllocator.set_name(EASTL_FIXED_MULTISET_DEFAULT_NAME);
471  #endif
472 
473  insert(first, last);
474  }
475 
476 
477  template <typename Key, size_t nodeCount, bool bEnableOverflow, typename Compare, typename OverflowAllocator>
478  inline typename fixed_multiset<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::this_type&
479  fixed_multiset<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::operator=(const this_type& x)
480  {
481  base_type::operator=(x);
482  return *this;
483  }
484 
485 
486  template <typename Key, size_t nodeCount, bool bEnableOverflow, typename Compare, typename OverflowAllocator>
487  inline typename fixed_multiset<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::this_type&
488  fixed_multiset<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::operator=(std::initializer_list<value_type> ilist)
489  {
490  base_type::clear();
491  insert(ilist.begin(), ilist.end());
492  return *this;
493  }
494 
495 
496  template <typename Key, size_t nodeCount, bool bEnableOverflow, typename Compare, typename OverflowAllocator>
497  inline typename fixed_multiset<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::this_type&
498  fixed_multiset<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::operator=(this_type&& x)
499  {
500  base_type::operator=(x);
501  return *this;
502  }
503 
504 
505  template <typename Key, size_t nodeCount, bool bEnableOverflow, typename Compare, typename OverflowAllocator>
506  inline void fixed_multiset<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::swap(this_type& x)
507  {
508  // Fixed containers use a special swap that can deal with excessively large buffers.
509  eastl::fixed_swap(*this, x);
510  }
511 
512 
513  template <typename Key, size_t nodeCount, bool bEnableOverflow, typename Compare, typename OverflowAllocator>
514  inline void fixed_multiset<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::reset_lose_memory()
515  {
516  base_type::reset_lose_memory();
517  base_type::get_allocator().reset(mBuffer);
518  }
519 
520 
521  template <typename Key, size_t nodeCount, bool bEnableOverflow, typename Compare, typename OverflowAllocator>
522  inline typename fixed_multiset<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::size_type
523  fixed_multiset<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::max_size() const
524  {
525  return kMaxSize;
526  }
527 
528 
529  template <typename Key, size_t nodeCount, bool bEnableOverflow, typename Compare, typename OverflowAllocator>
530  inline const typename fixed_multiset<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::overflow_allocator_type&
531  fixed_multiset<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::get_overflow_allocator() const EA_NOEXCEPT
532  {
533  return mAllocator.get_overflow_allocator();
534  }
535 
536 
537  template <typename Key, size_t nodeCount, bool bEnableOverflow, typename Compare, typename OverflowAllocator>
538  inline typename fixed_multiset<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::overflow_allocator_type&
539  fixed_multiset<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::get_overflow_allocator() EA_NOEXCEPT
540  {
541  return mAllocator.get_overflow_allocator();
542  }
543 
544 
545  template <typename Key, size_t nodeCount, bool bEnableOverflow, typename Compare, typename OverflowAllocator>
546  inline void fixed_multiset<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>::set_overflow_allocator(const overflow_allocator_type& allocator)
547  {
548  mAllocator.set_overflow_allocator(allocator);
549  }
550 
551 
553  // global operators
555 
556  template <typename Key, size_t nodeCount, bool bEnableOverflow, typename Compare, typename OverflowAllocator>
557  inline void swap(fixed_multiset<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>& a,
558  fixed_multiset<Key, nodeCount, bEnableOverflow, Compare, OverflowAllocator>& b)
559  {
560  // Fixed containers use a special swap that can deal with excessively large buffers.
561  eastl::fixed_swap(a, b);
562  }
563 
564 
565 
566 } // namespace eastl
567 
568 
569 #endif // Header include guard
570 
571 
572 
573 
574 
575 
576 
577 
578 
eastl::allocator
Definition: allocator.h:52
eastl::fixed_multiset
Definition: fixed_set.h:136
eastl::fixed_node_allocator
Definition: fixed_pool.h:607
eastl::fixed_set
Definition: fixed_set.h:69
eastl::multiset
Definition: set.h:168
eastl::rbtree< Key, Key, eastl::less< Key >, EASTLAllocatorType, eastl::use_self< Key >, false, true >::mAllocator
allocator_type mAllocator
Stores the count of nodes in the tree (not counting the anchor node).
Definition: red_black_tree.h:422
eastl::set
Definition: set.h:85
std::initializer_list
Definition: initializer_list.h:38
eastl
EA Standard Template Library.
Definition: algorithm.h:288
eastl::rbtree_node
Definition: red_black_tree.h:108
Generated by doxygen 1.9.1