00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021 template<class Key, class Compare>
00022 INLINE ordered_vector<Key, Compare>::
00023 ordered_vector(TypeHandle type_handle) :
00024 _compare(Compare()),
00025 _vector(type_handle)
00026 {
00027 }
00028
00029
00030
00031
00032
00033
00034 template<class Key, class Compare>
00035 INLINE ordered_vector<Key, Compare>::
00036 ordered_vector(const Compare &compare, TypeHandle type_handle) :
00037 _compare(compare),
00038 _vector(type_handle)
00039 {
00040 }
00041
00042
00043
00044
00045
00046
00047 template<class Key, class Compare>
00048 INLINE ordered_vector<Key, Compare>::
00049 ordered_vector(const ordered_vector<Key, Compare> ©) :
00050 _compare(copy._compare),
00051 _vector(copy._vector)
00052 {
00053 }
00054
00055
00056
00057
00058
00059
00060 template<class Key, class Compare>
00061 INLINE ordered_vector<Key, Compare> &ordered_vector<Key, Compare>::
00062 operator = (const ordered_vector<Key, Compare> ©) {
00063 _compare = copy._compare;
00064 _vector = copy._vector;
00065 return *this;
00066 }
00067
00068
00069
00070
00071
00072
00073 template<class Key, class Compare>
00074 INLINE ordered_vector<Key, Compare>::
00075 ~ordered_vector() {
00076 }
00077
00078
00079
00080
00081
00082
00083
00084 template<class Key, class Compare>
00085 INLINE TYPENAME ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
00086 begin() {
00087 return _vector.begin();
00088 }
00089
00090
00091
00092
00093
00094
00095
00096 template<class Key, class Compare>
00097 INLINE TYPENAME ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
00098 end() {
00099 return _vector.end();
00100 }
00101
00102
00103
00104
00105
00106
00107
00108 template<class Key, class Compare>
00109 INLINE TYPENAME ordered_vector<Key, Compare>::REVERSE_ITERATOR ordered_vector<Key, Compare>::
00110 rbegin() {
00111 return _vector.rbegin();
00112 }
00113
00114
00115
00116
00117
00118
00119
00120 template<class Key, class Compare>
00121 INLINE TYPENAME ordered_vector<Key, Compare>::REVERSE_ITERATOR ordered_vector<Key, Compare>::
00122 rend() {
00123 return _vector.rend();
00124 }
00125
00126
00127
00128
00129
00130
00131
00132 template<class Key, class Compare>
00133 INLINE TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
00134 begin() const {
00135 return _vector.begin();
00136 }
00137
00138
00139
00140
00141
00142
00143
00144 template<class Key, class Compare>
00145 INLINE TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
00146 end() const {
00147 return _vector.end();
00148 }
00149
00150
00151
00152
00153
00154
00155
00156 template<class Key, class Compare>
00157 INLINE TYPENAME ordered_vector<Key, Compare>::CONST_REVERSE_ITERATOR ordered_vector<Key, Compare>::
00158 rbegin() const {
00159 return _vector.rbegin();
00160 }
00161
00162
00163
00164
00165
00166
00167
00168 template<class Key, class Compare>
00169 INLINE TYPENAME ordered_vector<Key, Compare>::CONST_REVERSE_ITERATOR ordered_vector<Key, Compare>::
00170 rend() const {
00171 return _vector.rend();
00172 }
00173
00174
00175
00176
00177
00178
00179 template<class Key, class Compare>
00180 INLINE TYPENAME ordered_vector<Key, Compare>::REFERENCE ordered_vector<Key, Compare>::
00181 operator [] (TYPENAME ordered_vector<Key, Compare>::SIZE_TYPE n) {
00182 return _vector[n];
00183 }
00184
00185
00186
00187
00188
00189
00190 template<class Key, class Compare>
00191 INLINE TYPENAME ordered_vector<Key, Compare>::CONST_REFERENCE ordered_vector<Key, Compare>::
00192 operator [] (TYPENAME ordered_vector<Key, Compare>::SIZE_TYPE n) const {
00193 return _vector[n];
00194 }
00195
00196
00197
00198
00199
00200
00201 template<class Key, class Compare>
00202 INLINE TYPENAME ordered_vector<Key, Compare>::SIZE_TYPE ordered_vector<Key, Compare>::
00203 size() const {
00204 return _vector.size();
00205 }
00206
00207
00208
00209
00210
00211
00212
00213 template<class Key, class Compare>
00214 INLINE TYPENAME ordered_vector<Key, Compare>::SIZE_TYPE ordered_vector<Key, Compare>::
00215 max_size() const {
00216 return _vector.max_size();
00217 }
00218
00219
00220
00221
00222
00223
00224
00225 template<class Key, class Compare>
00226 INLINE bool ordered_vector<Key, Compare>::
00227 empty() const {
00228 return _vector.empty();
00229 }
00230
00231
00232
00233
00234
00235
00236
00237 template<class Key, class Compare>
00238 INLINE bool ordered_vector<Key, Compare>::
00239 operator == (const ordered_vector<Key, Compare> &other) const {
00240 return _vector == other._vector;
00241 }
00242
00243
00244
00245
00246
00247
00248
00249 template<class Key, class Compare>
00250 INLINE bool ordered_vector<Key, Compare>::
00251 operator != (const ordered_vector<Key, Compare> &other) const {
00252 return _vector != other._vector;
00253 }
00254
00255
00256
00257
00258
00259
00260
00261
00262 template<class Key, class Compare>
00263 INLINE bool ordered_vector<Key, Compare>::
00264 operator < (const ordered_vector<Key, Compare> &other) const {
00265 return _vector < other._vector;
00266 }
00267
00268
00269
00270
00271
00272
00273
00274
00275 template<class Key, class Compare>
00276 INLINE bool ordered_vector<Key, Compare>::
00277 operator > (const ordered_vector<Key, Compare> &other) const {
00278 return _vector > other._vector;
00279 }
00280
00281
00282
00283
00284
00285
00286
00287
00288 template<class Key, class Compare>
00289 INLINE bool ordered_vector<Key, Compare>::
00290 operator <= (const ordered_vector<Key, Compare> &other) const {
00291 return _vector <= other._vector;
00292 }
00293
00294
00295
00296
00297
00298
00299
00300
00301 template<class Key, class Compare>
00302 INLINE bool ordered_vector<Key, Compare>::
00303 operator >= (const ordered_vector<Key, Compare> &other) const {
00304 return _vector >= other._vector;
00305 }
00306
00307
00308
00309
00310
00311
00312
00313
00314
00315
00316
00317
00318
00319
00320
00321 template<class Key, class Compare>
00322 INLINE pair<TYPENAME ordered_vector<Key, Compare>::ITERATOR, bool> ordered_vector<Key, Compare>::
00323 insert_unique(const TYPENAME ordered_vector<Key, Compare>::VALUE_TYPE &key) {
00324 TAU_PROFILE("ordered_vector::insert_unique(const value_type &)", " ", TAU_USER);
00325 ITERATOR position = find_insert_position(begin(), end(), key);
00326 #ifdef NDEBUG
00327 pair<ITERATOR, bool> bogus_result(end(), false);
00328 nassertr(position >= begin() && position <= end(), bogus_result);
00329 #endif
00330
00331
00332
00333 if (position != begin() && !_compare(*(position - 1), key)) {
00334 pair<ITERATOR, bool> result(position - 1, false);
00335 nassertr(!_compare(key, *(position - 1)), result);
00336 return result;
00337 }
00338
00339 ITERATOR result = _vector.insert(position, key);
00340 return pair<ITERATOR, bool>(result, true);
00341 }
00342
00343
00344
00345
00346
00347
00348
00349
00350
00351
00352
00353
00354 template<class Key, class Compare>
00355 INLINE TYPENAME ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
00356 insert_nonunique(const TYPENAME ordered_vector<Key, Compare>::VALUE_TYPE &key) {
00357 TAU_PROFILE("ordered_vector::insert_nonunique(const value_type &)", " ", TAU_USER);
00358 ITERATOR position = find_insert_position(begin(), end(), key);
00359 nassertr(position >= begin() && position <= end(), end());
00360
00361 ITERATOR result = _vector.insert(position, key);
00362 return result;
00363 }
00364
00365
00366
00367
00368
00369
00370
00371
00372
00373
00374 template<class Key, class Compare>
00375 INLINE TYPENAME ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
00376 insert_unverified(TYPENAME ordered_vector<Key, Compare>::ITERATOR position,
00377 const TYPENAME ordered_vector<Key, Compare>::VALUE_TYPE &key) {
00378 TAU_PROFILE("ordered_vector::insert_unverified(iterator, const value_type &)", " ", TAU_USER);
00379 ITERATOR result = _vector.insert(position, key);
00380 return result;
00381 }
00382
00383
00384
00385
00386
00387
00388
00389 template<class Key, class Compare>
00390 INLINE TYPENAME ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
00391 erase(TYPENAME ordered_vector<Key, Compare>::ITERATOR position) {
00392 TAU_PROFILE("ordered_vector::erase(iterator)", " ", TAU_USER);
00393 SIZE_TYPE count = position - begin();
00394 _vector.erase(position);
00395 return begin() + count;
00396 }
00397
00398
00399
00400
00401
00402
00403
00404 template<class Key, class Compare>
00405 INLINE TYPENAME ordered_vector<Key, Compare>::SIZE_TYPE ordered_vector<Key, Compare>::
00406 erase(const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) {
00407 TAU_PROFILE("ordered_vector::erase(const key_type &)", " ", TAU_USER);
00408 pair<ITERATOR, ITERATOR> result = equal_range(key);
00409 SIZE_TYPE count = result.second - result.first;
00410 erase(result.first, result.second);
00411 return count;
00412 }
00413
00414
00415
00416
00417
00418
00419
00420 template<class Key, class Compare>
00421 INLINE void ordered_vector<Key, Compare>::
00422 erase(TYPENAME ordered_vector<Key, Compare>::ITERATOR first,
00423 TYPENAME ordered_vector<Key, Compare>::ITERATOR last) {
00424 TAU_PROFILE("ordered_vector::erase(iterator, iterator)", " ", TAU_USER);
00425 _vector.erase(first, last);
00426 }
00427
00428
00429
00430
00431
00432
00433 template<class Key, class Compare>
00434 INLINE void ordered_vector<Key, Compare>::
00435 clear() {
00436 TAU_PROFILE("ordered_vector::clear()", " ", TAU_USER);
00437 _vector.erase(_vector.begin(), _vector.end());
00438 }
00439
00440
00441
00442
00443
00444
00445
00446
00447
00448 template<class Key, class Compare>
00449 INLINE TYPENAME ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
00450 find(const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) {
00451 TAU_PROFILE("ordered_vector::find(const key_type &)", " ", TAU_USER);
00452 return nci(r_find(begin(), end(), end(), key));
00453 }
00454
00455
00456
00457
00458
00459
00460
00461
00462
00463 template<class Key, class Compare>
00464 INLINE TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
00465 find(const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) const {
00466 TAU_PROFILE("ordered_vector::find(const key_type &)", " ", TAU_USER);
00467 return r_find(begin(), end(), end(), key);
00468 }
00469
00470
00471
00472
00473
00474
00475
00476
00477
00478
00479
00480
00481
00482
00483
00484
00485
00486 template<class Key, class Compare>
00487 INLINE TYPENAME ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
00488 find_particular(const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) {
00489 TAU_PROFILE("ordered_vector::find_particular(const key_type &)", " ", TAU_USER);
00490 return nci(r_find_particular(begin(), end(), end(), key));
00491 }
00492
00493
00494
00495
00496
00497
00498
00499
00500
00501
00502
00503
00504
00505
00506 template<class Key, class Compare>
00507 INLINE TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
00508 find_particular(const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) const {
00509 TAU_PROFILE("ordered_vector::find_particular(const key_type &)", " ", TAU_USER);
00510 return r_find_particular(begin(), end(), end(), key);
00511 }
00512
00513
00514
00515
00516
00517
00518
00519 template<class Key, class Compare>
00520 INLINE TYPENAME ordered_vector<Key, Compare>::SIZE_TYPE ordered_vector<Key, Compare>::
00521 count(const key_type &key) const {
00522 TAU_PROFILE("ordered_vector::count(const key_type &)", " ", TAU_USER);
00523 return r_count(begin(), end(), key);
00524 }
00525
00526
00527
00528
00529
00530
00531
00532 template<class Key, class Compare>
00533 INLINE TYPENAME ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
00534 lower_bound(const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) {
00535 TAU_PROFILE("ordered_vector::lower_bound(const key_type &)", " ", TAU_USER);
00536 return nci(r_lower_bound(begin(), end(), key));
00537 }
00538
00539
00540
00541
00542
00543
00544
00545 template<class Key, class Compare>
00546 INLINE TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
00547 lower_bound(const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) const {
00548 TAU_PROFILE("ordered_vector::lower_bound(const key_type &)", " ", TAU_USER);
00549 return r_lower_bound(begin(), end(), key);
00550 }
00551
00552
00553
00554
00555
00556
00557
00558
00559 template<class Key, class Compare>
00560 INLINE TYPENAME ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
00561 upper_bound(const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) {
00562 TAU_PROFILE("ordered_vector::upper_bound(const key_type &)", " ", TAU_USER);
00563 return nci(r_upper_bound(begin(), end(), key));
00564 }
00565
00566
00567
00568
00569
00570
00571
00572
00573 template<class Key, class Compare>
00574 INLINE TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
00575 upper_bound(const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) const {
00576 TAU_PROFILE("ordered_vector::upper_bound(const key_type &)", " ", TAU_USER);
00577 return r_upper_bound(begin(), end(), key);
00578 }
00579
00580
00581
00582
00583
00584
00585 template<class Key, class Compare>
00586 INLINE pair<TYPENAME ordered_vector<Key, Compare>::ITERATOR, TYPENAME ordered_vector<Key, Compare>::ITERATOR> ordered_vector<Key, Compare>::
00587 equal_range(const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) {
00588 TAU_PROFILE("ordered_vector::equal_range(const key_type &)", " ", TAU_USER);
00589 pair<TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR, TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR> result;
00590 result = r_equal_range(begin(), end(), key);
00591 return pair<TYPENAME ordered_vector<Key, Compare>::ITERATOR, TYPENAME ordered_vector<Key, Compare>::ITERATOR>(nci(result.first), nci(result.second));
00592 }
00593
00594
00595
00596
00597
00598
00599 template<class Key, class Compare>
00600 INLINE pair<TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR, TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR> ordered_vector<Key, Compare>::
00601 equal_range(const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) const {
00602 TAU_PROFILE("ordered_vector::equal_range(const key_type &)", " ", TAU_USER);
00603 return r_equal_range(begin(), end(), key);
00604 }
00605
00606
00607
00608
00609
00610
00611
00612 template<class Key, class Compare>
00613 INLINE void ordered_vector<Key, Compare>::
00614 swap(ordered_vector<Key, Compare> ©) {
00615 TAU_PROFILE("ordered_vector::swap(ordered_vector &)", " ", TAU_USER);
00616 _vector.swap(copy._vector);
00617 }
00618
00619
00620
00621
00622
00623
00624
00625
00626 template<class Key, class Compare>
00627 INLINE void ordered_vector<Key, Compare>::
00628 reserve(TYPENAME ordered_vector<Key, Compare>::SIZE_TYPE n) {
00629 TAU_PROFILE("ordered_vector::reserve(size_type)", " ", TAU_USER);
00630 _vector.reserve(n);
00631 }
00632
00633
00634
00635
00636
00637
00638
00639
00640
00641
00642
00643
00644
00645 template<class Key, class Compare>
00646 INLINE void ordered_vector<Key, Compare>::
00647 sort_unique() {
00648 TAU_PROFILE("ordered_vector::sort_unique()", " ", TAU_USER);
00649 sort(begin(), end(), _compare);
00650 iterator new_end = unique(begin(), end(), EquivalentTest(_compare));
00651 erase(new_end, end());
00652 }
00653
00654
00655
00656
00657
00658
00659
00660
00661
00662
00663 template<class Key, class Compare>
00664 INLINE void ordered_vector<Key, Compare>::
00665 sort_nonunique() {
00666 TAU_PROFILE("ordered_vector::sort_nonunique()", " ", TAU_USER);
00667 stable_sort(begin(), end(), _compare);
00668 }
00669
00670
00671
00672
00673
00674
00675
00676
00677
00678 template<class Key, class Compare>
00679 INLINE void ordered_vector<Key, Compare>::
00680 push_back(const value_type &key) {
00681 TAU_PROFILE("ordered_vector::push_back()", " ", TAU_USER);
00682 _vector.push_back(key);
00683 }
00684
00685
00686
00687
00688
00689
00690 template<class Key, class Compare>
00691 INLINE void ordered_vector<Key, Compare>::
00692 pop_back() {
00693 TAU_PROFILE("ordered_vector::pop_back()", " ", TAU_USER);
00694 _vector.pop_back();
00695 }
00696
00697
00698
00699
00700
00701
00702
00703
00704
00705 template<class Key, class Compare>
00706 INLINE TYPENAME ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
00707 nci(TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR i) {
00708 return begin() + (i - begin());
00709 }
00710
00711
00712
00713
00714
00715
00716
00717
00718 template<class Key, class Compare>
00719 INLINE TYPENAME ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
00720 find_insert_position(TYPENAME ordered_vector<Key, Compare>::ITERATOR first,
00721 TYPENAME ordered_vector<Key, Compare>::ITERATOR last,
00722 const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) {
00723 ITERATOR result = r_find_insert_position(first, last, key);
00724 return result;
00725 }
00726
00727
00728
00729
00730
00731
00732 template<class Key, class Compare>
00733 INLINE ov_set<Key, Compare>::
00734 ov_set(TypeHandle type_handle) :
00735 ordered_vector<Key, Compare>(type_handle)
00736 {
00737 }
00738
00739
00740
00741
00742
00743
00744 template<class Key, class Compare>
00745 INLINE ov_set<Key, Compare>::
00746 ov_set(const Compare &compare, TypeHandle type_handle) :
00747 ordered_vector<Key, Compare>(compare, type_handle)
00748 {
00749 }
00750
00751
00752
00753
00754
00755
00756 template<class Key, class Compare>
00757 INLINE ov_set<Key, Compare>::
00758 ov_set(const ov_set<Key, Compare> ©) :
00759 ordered_vector<Key, Compare>(copy)
00760 {
00761 }
00762
00763
00764
00765
00766
00767
00768 template<class Key, class Compare>
00769 INLINE ov_set<Key, Compare> &ov_set<Key, Compare>::
00770 operator = (const ov_set<Key, Compare> ©) {
00771 ordered_vector<Key, Compare>::operator = (copy);
00772 return *this;
00773 }
00774
00775
00776
00777
00778
00779
00780 template<class Key, class Compare>
00781 TYPENAME ov_set<Key, Compare>::ITERATOR ov_set<Key, Compare>::
00782 insert(TYPENAME ov_set<Key, Compare>::ITERATOR position,
00783 const TYPENAME ov_set<Key, Compare>::VALUE_TYPE &key) {
00784 return ordered_vector<Key, Compare>::insert_unique(position, key);
00785 }
00786
00787
00788
00789
00790
00791
00792 template<class Key, class Compare>
00793 INLINE pair<TYPENAME ov_set<Key, Compare>::ITERATOR, bool> ov_set<Key, Compare>::
00794 insert(const TYPENAME ov_set<Key, Compare>::VALUE_TYPE &key) {
00795 return ordered_vector<Key, Compare>::insert_unique(key);
00796 }
00797
00798
00799
00800
00801
00802
00803 template<class Key, class Compare>
00804 INLINE void ov_set<Key, Compare>::
00805 sort() {
00806 ordered_vector<Key, Compare>::sort_unique();
00807 }
00808
00809
00810
00811
00812
00813
00814 template<class Key, class Compare>
00815 INLINE bool ov_set<Key, Compare>::
00816 verify_list() const {
00817 return ordered_vector<Key, Compare>::verify_list_unique();
00818 }
00819
00820
00821
00822
00823
00824
00825 template<class Key, class Compare>
00826 INLINE ov_multiset<Key, Compare>::
00827 ov_multiset(TypeHandle type_handle) :
00828 ordered_vector<Key, Compare>(type_handle)
00829 {
00830 }
00831
00832
00833
00834
00835
00836
00837 template<class Key, class Compare>
00838 INLINE ov_multiset<Key, Compare>::
00839 ov_multiset(const Compare &compare, TypeHandle type_handle) :
00840 ordered_vector<Key, Compare>(compare, type_handle)
00841 {
00842 }
00843
00844
00845
00846
00847
00848
00849 template<class Key, class Compare>
00850 INLINE ov_multiset<Key, Compare>::
00851 ov_multiset(const ov_multiset<Key, Compare> ©) :
00852 ordered_vector<Key, Compare>(copy)
00853 {
00854 }
00855
00856
00857
00858
00859
00860
00861 template<class Key, class Compare>
00862 INLINE ov_multiset<Key, Compare> &ov_multiset<Key, Compare>::
00863 operator = (const ov_multiset<Key, Compare> ©) {
00864 ordered_vector<Key, Compare>::operator = (copy);
00865 return *this;
00866 }
00867
00868
00869
00870
00871
00872
00873 template<class Key, class Compare>
00874 TYPENAME ov_multiset<Key, Compare>::ITERATOR ov_multiset<Key, Compare>::
00875 insert(TYPENAME ov_multiset<Key, Compare>::ITERATOR position,
00876 const TYPENAME ov_multiset<Key, Compare>::VALUE_TYPE &key) {
00877 return ordered_vector<Key, Compare>::insert_nonunique(position, key);
00878 }
00879
00880
00881
00882
00883
00884
00885 template<class Key, class Compare>
00886 INLINE TYPENAME ov_multiset<Key, Compare>::ITERATOR ov_multiset<Key, Compare>::
00887 insert(const TYPENAME ov_multiset<Key, Compare>::VALUE_TYPE &key) {
00888 return ordered_vector<Key, Compare>::insert_nonunique(key);
00889 }
00890
00891
00892
00893
00894
00895
00896 template<class Key, class Compare>
00897 INLINE void ov_multiset<Key, Compare>::
00898 sort() {
00899 ordered_vector<Key, Compare>::sort_nonunique();
00900 }
00901
00902
00903
00904
00905
00906
00907 template<class Key, class Compare>
00908 INLINE bool ov_multiset<Key, Compare>::
00909 verify_list() const {
00910 return ordered_vector<Key, Compare>::verify_list_nonunique();
00911 }