bvector_cc.h
Go to the documentation of this file.
1 /*--------------------------------------------------------------------------------------+
2 |
3 | Supplied under applicable software license agreement.
4 |
5 | Copyright (c) 2018 Bentley Systems, Incorporated. All rights reserved.
6 |
7 +---------------------------------------------------------------------------------------*/
8 #pragma once
9 
11 /***************************************************************************
12  *
13  * bvector.cc - Non-inline definitions for the Standard Library bvector class
14  *
15  * $Id: bvector.cc 804291 2009-08-14 16:44:37Z faridz $
16  *
17  ***************************************************************************
18  *
19  * Copyright (c) 1994
20  * Hewlett-Packard Company
21  *
22  * Permission to use, copy, modify, distribute and sell this software
23  * and its documentation for any purpose is hereby granted without fee,
24  * provided that the above copyright notice appear in all copies and
25  * that both that copyright notice and this permission notice appear
26  * in supporting documentation. Hewlett-Packard Company makes no
27  * representations about the suitability of this software for any
28  * purpose. It is provided "as is" without express or implied warranty.
29  *
30  ***************************************************************************
31  *
32  * Licensed to the Apache Software Foundation (ASF) under one or more
33  * contributor license agreements. See the NOTICE file distributed
34  * with this work for additional information regarding copyright
35  * ownership. The ASF licenses this file to you under the Apache
36  * License, Version 2.0 (the "License"); you may not use this file
37  * except in compliance with the License. You may obtain a copy of
38  * the License at
39  *
40  * http://www.apache.org/licenses/LICENSE-2.0
41  *
42  * Unless required by applicable law or agreed to in writing, software
43  * distributed under the License is distributed on an "AS IS" BASIS,
44  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
45  * implied. See the License for the specific language governing
46  * permissions and limitations under the License.
47  *
48  * Copyright 1994-2006 Rogue Wave Software.
49  *
50  **************************************************************************
51  *
52  * NOTICE: This File contains modifications made by Bentley Systems Inc. where designated.
53  *
54  *************************************************************************/
55 
56 // *** BENTLEY_CHANGE
57 #ifdef _MSC_VER
58 #pragma push_macro("max")
59 #pragma push_macro("min")
60 #undef max
61 #undef min
62 #endif
63 
64 // *** BENTLEY_CHANGE
65 NAMESPACE_BENTLEY_BSTDCXX_BEGIN
66 
67 template <class _TypeT, class _Allocator>
70 operator= (const bvector &__rhs)
71 {
72 #ifndef _RWSTD_NO_EXT_VECTOR_ASSIGN_IN_PLACE
73 
74  if (capacity () < __rhs.size ())
75  bvector (__rhs).swap (*this);
76  else if (&__rhs != this)
77  assign (__rhs.begin (), __rhs.end ());
78 
79 #else // if defined (_RWSTD_NO_EXT_VECTOR_ASSIGN_IN_PLACE)
80 
81  bvector (__rhs).swap (*this);
82 
83 #endif // _RWSTD_NO_EXT_VECTOR_ASSIGN_IN_PLACE
84 
85  return *this;
86 }
87 
88 
89 template <class _TypeT, class _Allocator>
90 void
92 _C_realloc (size_type __n)
93 {
94  const size_type __max_size = max_size ();
95 
96  // compute the new capacity from the greater of the current size
97  // and the requested size, but no greater than max_size()
98  size_type __cap = _RWSTD_NEW_CAPACITY (bvector, this, std::max(size (), __n));
99 
100  // do not exceed max_size()
101  if (__max_size < __cap)
102  __cap = __max_size;
103 
104  // create an empty temporary bvector
105  bvector __tmp (get_allocator ());
106 
107  // allocate storage of requested capacity
108  __tmp._C_alloc._C_begin = _C_alloc.allocate (__cap, this);
109 
110  // initialize pointers
111  __tmp._C_alloc._C_end = __tmp._C_alloc._C_begin;
112  __tmp._C_alloc._C_bufend = __tmp._C_alloc._C_begin + __cap;
113 
114  // copy *this into the temporary one element at a time, as if
115  // by calling std::unitialized_copy(), growing the temporary
116  // at each iteration so that an exception thrown by the copy
117  // ctor will cause the destruction of all already constructed
118  // elements (by invoking the temporary's dtor)
119  for (pointer __ptr = _C_alloc._C_begin; !(__ptr == _C_alloc._C_end);
120  ++__ptr) {
121  __tmp._C_push_back (*__ptr);
122  }
123 
124  // swap *this with the temporary, having its dtor clean up
125  swap (__tmp);
126 }
127 
128 
129 template <class _TypeT, class _Allocator>
131 _C_destroy (iterator __first)
132 {
133  _RWSTD_ASSERT_RANGE (__first, end ());
134 
135  for (size_type __n = end () - __first; !(0 == __n); --__n)
136  _C_alloc.destroy (--_C_alloc._C_end);
137 }
138 
139 
140 template <class _TypeT, class _Allocator>
142 _C_unsafe_swap (bvector &__other)
143 {
144  // called only from bvector::swap() for unequal allocators
145  _RWSTD_ASSERT (!(get_allocator () == __other.get_allocator ()));
146 
147  // avoid passing the whole object to other bvector member
148  // functions (i.e., assign()) in case they are implemented
149  // in terms of swap(); use iterators instead
150 
151  bvector __tmp (__other.get_allocator ());
152 
153  // assert that the copy of the allocator compares equal
154  // to the original (otherwise the swap() below will cause
155  // a recursive call)
156  _RWSTD_ASSERT (__tmp.get_allocator () == __other.get_allocator ());
157 
158  __tmp.assign (begin (), end ());
159  assign (__other.begin (), __other.end ());
160  __other.swap (__tmp);
161 }
162 
163 
164 template <class _TypeT, class _Allocator>
166 _C_assign_n (size_type __n, const_reference __x)
167 {
168 #ifndef _RWSTD_NO_EXT_VECTOR_ASSIGN_IN_PLACE
169 
170  // FIXME: implement in-place assignment with repetition
171 
172  clear ();
173  insert (begin (), __n, __x);
174 
175 #else // if defined (_RWSTD_NO_EXT_VECTOR_ASSIGN_IN_PLACE)
176 
177  clear ();
178  insert (begin (), __n, __x);
179 
180 #endif // _RWSTD_NO_EXT_VECTOR_ASSIGN_IN_PLACE
181 }
182 
183 
184 template <class _TypeT, class _Allocator>
186 _C_insert_1 (const iterator &__it, const_reference __x)
187 {
188  _RWSTD_ASSERT_RANGE (begin (), __it);
189 
190  if (size () < capacity ()) {
191 
192  if (__it < end ()) {
193 
194  const pointer __end = _C_alloc._C_end;
195 
196  // construct a copy of the last element in the range [it, end)
197  // in the uninitialized slot just past the end of the range
198  // and bump up end()
199  _C_push_back (*(_C_alloc._C_end - difference_type (1)));
200 
201  // move the remaining elements from the range above one slot
202  // toward the end starting with the last element
203  std::copy_backward (__it, end () - 2, __end);
204 
205  // overwrite the element at the given position
206  *__it = __x;
207  }
208  else {
209  // construct a copy of the value to be inserted
210  // in the uninitialized slot
211  _C_push_back (__x);
212  }
213  }
214  else {
215  _C_insert_n (__it, size_type (1), __x);
216  }
217 }
218 
219 
220 template <class _TypeT, class _Allocator>
222 _C_insert_n (const iterator &__it, size_type __n, const_reference __x)
223 {
224  _RWSTD_ASSERT_RANGE (begin (), __it);
225 
226  if (!__n)
227  return;
228 
229  // 23.2.4.2, p5: calls to insert() must not reallocate storage
230  // unless the new size of the container would exceed its capacity
231 
232  // compute the numbers of elements to be copied and inserted
233  const size_type __size1 = BC__DISTANCE (begin (), __it, size_type);
234  const size_type __size2 = size () + __n;
235 
236  if (capacity () < __size2) {
237 
238  // allocate a temporary bvector large enough to hold all elements
239  bvector __tmp (get_allocator ());
240  __tmp.reserve (__size2);
241 
242  _RWSTD_ASSERT (!(pointer () == __tmp._C_alloc._C_end));
243 
244  iterator __i;
245 
246  // copy the initial range prior to `it' as if by a call to
247  // uninitialized_copy (begin (), __it, __tmp._C_alloc._C_begin);
248  for (__i = begin (); !(__i == __it); ++__i) {
249 
250  _RWSTD_ASSERT (!( __tmp._C_alloc._C_end
251  == __tmp._C_alloc._C_bufend));
252 
253  __tmp._C_push_back (*__i);
254  }
255 
256  // construct `n' copies of `x' just past the initial range,
257  // as if by a call to
258  // uninitialized_fill_n (__tmp._C_aloc._C_begin + __size1, __n, __x);
259  for ( ; __n; --__n) {
260 
261  _RWSTD_ASSERT (!( __tmp._C_alloc._C_end
262  == __tmp._C_alloc._C_bufend));
263 
264  __tmp._C_push_back (__x);
265  }
266 
267  // copy the final range of elements starting with `it'
268  // as if by a call to
269  // uninitialized_copy (__it, end (),
270  // __tmp._C_alloc._C_begin + __size1 + __n);
271 
272  for (__i = __it; !(__i == end ()); ++__i) {
273 
274  _RWSTD_ASSERT (!( __tmp._C_alloc._C_end
275  == __tmp._C_alloc._C_bufend));
276 
277  __tmp._C_push_back (*__i);
278  }
279 
280  // swap the sequences controlled by the temporary bvector and *this
281  __tmp.swap (*this);
282 
283  return;
284  }
285 
286  // compute the beginning of the range of elements in the sequence
287  // controlled by *this that need to be moved (copy contructed past
288  // the end of the end of the sequence or assigned over existing
289  // elements)
290  const pointer __movbeg = _C_alloc._C_begin + __size1;
291  const pointer __movend = __movbeg + __n;
292 
293  _RWSTD_ASSERT (_C_make_iter (__movbeg) == __it);
294 
295  if (__movend <= _C_alloc._C_end) {
296 
297  // the end of the range of existing elements after being
298  // moved to make room for the elements to be inserted is
299  // before the current end of the sequence
300 
301  // compute the beginning of the range of elements whose copies
302  // will be constructed just past the current end of the sequence
303  const pointer __ucpbeg = _C_alloc._C_end - __n;
304  const pointer __ucpend = _C_alloc._C_end;
305 
306  // construct copies of elements that will be moved beyond
307  // the current end of the sequence controlled by *this
308  BC__RW::uninitialized_copy (__ucpbeg, _C_alloc._C_end,
309  _C_alloc._C_end, _C_alloc);
310 
311  // advance end to maintain consistent state
312  _C_alloc._C_end += __n;
313 
314  // copy elements the will be overwritten below
315  // over the range of elements moved above
316  std::copy_backward (__movbeg, __ucpbeg, __ucpend);
317  }
318  else {
319 
320  // compute the length of the initial subsequence of the range
321  // of element being inserted that overlaps the end of the
322  // sequence being inserted into
323  const size_type __n1 = size () - __size1;
324  const size_type __n2 = __n - __n1;
325 
326  BC__RW::uninitialized_fill_n (_C_alloc._C_end, __n2, __x, _C_alloc);
327 
328  const pointer __end = _C_alloc._C_end;
329 
330  _C_alloc._C_end += __n2;
331 
332  // construct copies of the range of elements [pos, end)
333  // past the end of the range of elements inserted above
334  BC__RW::uninitialized_copy (__movbeg, __end, _C_alloc._C_end, _C_alloc);
335 
336  _C_alloc._C_end += __end - __movbeg;
337 
338  __n = __n1;
339  }
340 
341  std::fill_n (__movbeg, __n, __x);
342 }
343 
344 
345 template<class _TypeT, class _Allocator>
346 template<class _InputIter>
348 _C_assign_range (_InputIter __first, _InputIter __last, std::input_iterator_tag)
349 {
350  _RWSTD_ASSERT_RANGE (__first, __last);
351 
352 #ifndef _RWSTD_NO_EXT_VECTOR_ASSIGN_IN_PLACE
353 
354  // assign over existing elements for better efficiency
355  // and exception safety
356 
357  // complexity: linear in distance(first, last)
358  // -- exactly A=min(size(), distance(first, last)) calls
359  // to value_type's assignment operator
360  // -- exactly (max(size(), distance(first, last)) - A)
361  // calls to value_type's copy ctor
362  //
363  // exception safety:
364  // -- nothrow if size() >= distance(first, last), and value_type's
365  // assignment operator and iterator operations do not throw
366  // -- basic otherwise
367 
368  const iterator __end = this->end ();
369 
370  for (iterator __it = this->begin (); __it != __end; ++__it, ++__first) {
371  if (__first == __last) {
372  this->erase (__it, __end);
373  return;
374  }
375  *__it = *__first;
376  }
377 
378  this->insert (__end, __first, __last);
379 
380 #else // if defined (_RWSTD_NO_EXT_VECTOR_ASSIGN_IN_PLACE)
381 
382  // follow the inefficient requirement in 23.2.4.1, p2
383 
384  // complexity: linear in distance(first, last)
385  // exactly distance(first, last) calls to value_type's copy ctor
386  // exception safety: basic
387 
388  this->clear ();
389  this->insert (this->begin (), __first, __last);
390 
391 #endif // _RWSTD_NO_EXT_VECTOR_ASSIGN_IN_PLACE
392 
393 }
394 
395 
396 template <class _TypeT, class _Allocator>
397 template <class _FwdIter>
399 _C_assign_range (_FwdIter __first, _FwdIter __last, std::forward_iterator_tag)
400 {
401  _RWSTD_ASSERT_RANGE (__first, __last);
402 
403 #ifndef _RWSTD_NO_EXT_VECTOR_ASSIGN_IN_PLACE
404 
405  // assign over existing elements for better efficiency
406  // and exception safety
407 
408  // complexity: linear in distance(first, last)
409  // exception safety:
410  // -- nothrow if size() >= distance(first, last), and value_type's
411  // assignment operator and iterator operations do not throw
412  // -- strong if capacity() < size() + distance(first, last)
413  // -- basic otherwise
414 
415  const size_type __size1 = BC__DISTANCE (__first, __last, size_type);
416  const size_type __size2 = this->size () + __size1;
417 
418  if (this->capacity () < __size2) {
419 
420  // exception safety: strong
421 
423  __tmp.reserve (__size2);
424 
425  // copy elements in the range [first, last) into the temporary
426  // one element at a time, as if by calling
427  // std::unitialized_copy(), growing the temporary at each
428  // iteration so that an exception thrown by the copy ctor will
429  // cause the destruction of all already constructed elements
430  // (by invoking the temporary's dtor)
431  for ( ; !(__first == __last); ++__first)
432  __tmp._C_push_back (*__first);
433 
434  // swap *this with the temporary, having its dtor clean up
435  this->swap (__tmp);
436  }
437  else {
438  // exception safety: nothrow or basic
439 
440  const iterator __end = this->end ();
441 
442  for (iterator __i = this->begin (); __i != __end; ++__i, ++__first) {
443  if (__first == __last) {
444  this->erase (__i, __end);
445  return;
446  }
447  *__i = *__first;
448  }
449 
450  this->insert (__end, __first, __last);
451  }
452 
453 #else // if defined (_RWSTD_NO_EXT_VECTOR_ASSIGN_IN_PLACE)
454 
455  // follow the inefficient requirement in 23.2.4.1, p2
456 
457  // complexity: linear in distance(first, last)
458  // exception safety: basic
459 
460  this->clear ();
461  this->insert (this->begin (), __first, __last);
462 
463 #endif // _RWSTD_NO_EXT_VECTOR_ASSIGN_IN_PLACE
464 
465 }
466 
467 
468 template <class _TypeT, class _Allocator>
469 template <class _InputIter>
471 _C_insert_range (iterator __it, _InputIter __first, _InputIter __last,
472  std::input_iterator_tag)
473 {
474  _RWSTD_ASSERT_RANGE (__it, end ());
475  _RWSTD_ASSERT_RANGE (__first, __last);
476 
477 #ifndef _RWSTD_NO_EXT_VECTOR_INSERT_IN_PLACE
478 
479  // note that this extension does not satisfy the strong exception
480  // safety requirement in 23.2.4.3, p1
481 
482  // complexity: linear in distance(first, last)
483  // exception safety: basic
484 
485  // append one element at a time to prevent the loss of data
486  // from the input sequence in the case of an exception
487 
488  const size_type __size = this->size ();
489  const size_type __inx = BC__DISTANCE (this->begin (), __it, size_type);
490 
491  _RWSTD_ASSERT (__inx <= __size);
492 
493  for (; !(__first == __last); ++__first)
494  this->push_back (*__first);
495 
496  if (__inx < __size) {
497  // swap the inserted elements with the elements before which
498  // they should be inserted, as if by calling
499  // std::rotate (__beg, __mid, _C_alloc._C_end)
500  const pointer __beg = this->_C_alloc._C_begin + __inx;
501  const pointer __mid = this->_C_alloc._C_begin + __size;
502 
503  if (__beg < __mid) {
504  for (pointer __p0 = __beg, __p1 = __mid; __p0 < --__p1; ++__p0)
505  std::iter_swap (__p0, __p1);
506  }
507 
508  if (__mid < this->_C_alloc._C_end) {
509  for (pointer __p0 = __mid, __p1 = this->_C_alloc._C_end;
510  __p0 < --__p1; ++__p0)
511  std::iter_swap (__p0, __p1);
512  }
513 
514  if (__beg < this->_C_alloc._C_end) {
515  for (pointer __p0 = __beg, __p1 = this->_C_alloc._C_end;
516  __p0 < --__p1; ++__p0)
517  std::iter_swap (__p0, __p1);
518  }
519  }
520 
521 #else // if defined (_RWSTD_NO_EXT_VECTOR_INSERT_IN_PLACE)
522 
523  // 23.2.4.3, p1: If an exception is thrown other than by the copy
524  // constructor or assignment operator of T there are no effects.
525  // see also lwg issue 406
526 
527  // complexity: linear in distance(first, last)
528  // exception safety:
529  // -- strong if capacity() < size() + distance(first, last) and
530  // value_type's assignment operator and copy ctor do not throw
531  // -- basic otherwise
532 
533  // insert input range into a temporary sequence rather than into *this
534  // to coid modifying *this in case an exception (e.g., bad_alloc) is
535  // thrown
537 
538  for ( ; !(__first == __last); ++__first)
539  __tmp.push_back (*__first);
540 
541  // insert into *this using a more efficient algorithm optimized
542  // for BidirectionalIterator (and better)
543  this->insert (__it, __tmp.begin (), __tmp.end ());
544 
545 #endif // _RWSTD_NO_EXT_VECTOR_INSERT_IN_PLACE
546 
547 }
548 
549 
550 template <class _TypeT, class _Allocator>
551 template <class _FwdIter>
553 _C_insert_range (iterator __it, _FwdIter __first, _FwdIter __last,
554  std::forward_iterator_tag)
555 {
556  _RWSTD_ASSERT_RANGE (__it, end ());
557  _RWSTD_ASSERT_RANGE (__first, __last);
558 
559  // 23.2.4.2, p5: calls to insert() must not reallocate storage
560  // unless the new size of the container would exceed its capacity
561 
562  // compute the sizes of the ranges of elements to be copied
563  const size_type __size1 = BC__DISTANCE (this->begin (), __it, size_type);
564  const size_type __size2 = BC__DISTANCE (__first, __last, size_type);
565 
566  if (!__size2)
567  return;
568 
569 #ifndef _RWSTD_NO_EXT_VECTOR_INSERT_IN_PLACE
570  const bool __insert_in_place =
571  this->size () + __size2 <= this->capacity ();
572 #else // if defined (_RWSTD_NO_EXT_VECTOR_INSERT_IN_PLACE)
573  const bool __insert_in_place = false;
574 #endif // _RWSTD_NO_EXT_VECTOR_INSERT_IN_PLACE
575 
576  if (__insert_in_place) {
577 
578  // compute the beginning an end of the range of elements
579  // in the sequence controlled by *this that need to be moved
580  // (copy contructed past the end of the end of the sequence
581  // or assigned over existing elements)
582  const pointer __movbeg = this->_C_alloc._C_begin + __size1;
583  const pointer __movend = __movbeg + __size2;
584 
585  _RWSTD_ASSERT (this->_C_make_iter (__movbeg) == __it);
586 
587  const pointer __end = this->_C_alloc._C_end;
588 
589  if (__movend <= __end) {
590  // compute the beginning of the range of elements whose copies
591  // will be copy-constructed in the uninitialized space just past
592  // the current end of the sequence
593  const pointer __ucpbeg = __end - __size2;
594 
595  // construct copies of elements that will be moved beyond
596  // the current end of the sequence controlled by *this
597  for (pointer __p = __ucpbeg; !(__p == __end); ++__p)
598  this->_C_push_back (*__p);
599 
600  // over the range of elements moved above
601  for (pointer __q = __end; __movend < __q; ) {
602  --__q;
603  *__q = *(__q - __size2);
604  }
605  }
606  else {
607  // compute the length of the initial subsequence of the range
608  // of elements being inserted that overlaps the end of the
609  // sequence being inserted into
610  const size_type __size2a = this->size () - __size1;
611  _FwdIter __mid = __first;
612  std::advance (__mid, __size2a);
613 
614  // construct copies of the trailing subsequence of the range
615  // of elements being inserted, as if by a call to
616  // std::uninitialized_copy (__mid, __last, _C_alloc._C_end);
617 
618  for (_FwdIter __m = __mid ; !(__m == __last); ++__m)
619  this->_C_push_back (*__m);
620 
621  // construct copies of the range of elements [pos, end)
622  // past the end of the range of elements inserted above,
623  // as if by a call to
624  // std::uninitialized_copy (__movbeg, __end, _C_alloc._C_end);
625 
626  for (pointer __p = __movbeg; !(__p == __end); ++__p)
627  this->_C_push_back (*__p);
628 
629  __last = __mid;
630  }
631 
632  std::copy (__first, __last, __movbeg);
633  }
634  else {
635  // 23.2.4.3, p1: If an exception is thrown other than by the copy
636  // constructor or assignment operator of T there are no effects.
637 
638  // create a temporary bvector and reserve sufficient space
640 
641  __tmp.reserve (this->size () + __size2);
642 
643  // avoid using the name __i or __it below so as not to trigger
644  // a (bogus) gcc 2.95.2 -Wshadow warning: declaration of `__i'
645  // shadows previous local
646  iterator __ix;
647 
648  // copy the initial subsequence of *this, [begin, it), into
649  // the temporary one element at a time, as if by calling
650  // std::unitialized_copy(), growing the temporary at each
651  // iteration so that an exception thrown by the copy ctor
652  // will cause the destruction of all already constructed
653  // elements (by invoking the temporary's dtor)
654  for (__ix = this->begin (); __ix != __it; ++__ix) {
655  __tmp._C_push_back (*__ix);
656  }
657 
658  // append the sequence [first, last) to the temporary,
659  // carefully increasing the size of tmp before performing
660  // any operations on `first' and `last' in case they throw
661  for (; !(__first == __last); ++__first) {
662  __tmp._C_push_back (*__first);
663  }
664 
665  // copy the remaining elements from *this
666  for ( ; __ix != this->end (); ++__ix) {
667  __tmp._C_push_back (*__ix);
668  }
669 
670  // swap *this with the temporary, having its dtor clean up
671  this->swap (__tmp);
672  }
673 }
674 
675 // *** BENTLEY_CHANGE
676 NAMESPACE_BENTLEY_BSTDCXX_END
677 
678 // *** BENTLEY_CHANGE
679 #ifdef _MSC_VER
680 #pragma pop_macro("max")
681 #pragma pop_macro("min")
682 #endif
683 
684 /// @endcond
void assign(_InputIter __first, _InputIter __last)
Definition: stdcxx/bvector.h:238
iterator begin()
Definition: stdcxx/bstdmap.h:178
iterator end()
Definition: stdcxx/bstdmap.h:186
void swap(basic_string< _CharT, _Traits, _Allocator > &__a, basic_string< _CharT, _Traits, _Allocator > &__b)
Definition: basic_string.h:1396
iterator begin()
Definition: stdcxx/bvector.h:251
iterator erase(iterator __it)
Definition: stdcxx/bstdmap.h:242
bvector & operator=(bvector &&rhs)
Definition: stdcxx/bvector.h:194
void swap(bvector &)
#define max(x, y)
Definition: MathUtils.h:24
size_type size() const
Definition: stdcxx/bvector.h:283
size_type max_size() const
Definition: stdcxx/bstdmap.h:218
A Bentley supplied implementation std::vector.
Definition: stdcxx/bvector.h:77
iterator end()
Definition: stdcxx/bvector.h:259
allocator_type get_allocator() const
Definition: stdcxx/bstdmap.h:174
void clear()
Definition: stdcxx/bstdmap.h:257
size_type size() const
Definition: stdcxx/bstdmap.h:214
allocator_type get_allocator() const
Definition: stdcxx/bvector.h:247
bpair< iterator, bool > insert(const value_type &__x)
Definition: stdcxx/bstdmap.h:228

Copyright © 2017 Bentley Systems, Incorporated. All rights reserved.