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