00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013 #ifndef ACE_MAP_T_H
00014 #define ACE_MAP_T_H
00015 #include "ace/pre.h"
00016
00017 #include "ace/Pair_T.h"
00018 #include "ace/Map_Manager.h"
00019 #include "ace/Hash_Map_Manager_T.h"
00020 #include "ace/Active_Map_Manager.h"
00021
00022 #if !defined (ACE_LACKS_PRAGMA_ONCE)
00023 # pragma once
00024 #endif
00025
00026 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00027
00028
00029
00030
00031
00032
00033 template <class T>
00034 class ACE_Noop_Key_Generator
00035 {
00036 public:
00037
00038
00039 int operator () (T &);
00040 };
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055 template <class T>
00056 class ACE_Incremental_Key_Generator
00057 {
00058 public:
00059
00060
00061 ACE_Incremental_Key_Generator (void);
00062
00063
00064 int operator () (T &t);
00065
00066
00067 const T& current_value (void) const;
00068
00069 protected:
00070
00071
00072 T t_;
00073 };
00074
00075
00076
00077
00078
00079
00080
00081
00082 template <class T>
00083 class ACE_Iterator_Impl
00084 {
00085 public:
00086
00087
00088 virtual ~ACE_Iterator_Impl (void);
00089
00090
00091 virtual ACE_Iterator_Impl<T> *clone (void) const = 0;
00092
00093
00094 virtual int compare (const ACE_Iterator_Impl<T> &rhs) const = 0;
00095
00096
00097 virtual T dereference (void) const = 0;
00098
00099
00100 virtual void plus_plus (void) = 0;
00101
00102
00103 virtual void minus_minus (void) = 0;
00104 };
00105
00106
00107
00108
00109
00110
00111
00112
00113 template <class T>
00114 class ACE_Reverse_Iterator_Impl
00115 {
00116 public:
00117
00118
00119 virtual ~ACE_Reverse_Iterator_Impl (void);
00120
00121
00122 virtual ACE_Reverse_Iterator_Impl<T> *clone (void) const = 0;
00123
00124
00125 virtual int compare (const ACE_Reverse_Iterator_Impl<T> &rhs) const = 0;
00126
00127
00128 virtual T dereference (void) const = 0;
00129
00130
00131 virtual void plus_plus (void) = 0;
00132
00133
00134 virtual void minus_minus (void) = 0;
00135 };
00136
00137
00138
00139
00140
00141
00142
00143
00144 template <class T>
00145 class ACE_Iterator
00146 {
00147 public:
00148
00149
00150 typedef T value_type;
00151 typedef ACE_Iterator_Impl<T> implementation;
00152
00153
00154 ACE_Iterator (ACE_Iterator_Impl<T> *impl);
00155
00156
00157 ACE_Iterator (const ACE_Iterator<T> &rhs);
00158
00159
00160 ~ACE_Iterator (void);
00161
00162
00163 ACE_Iterator<T> &operator= (const ACE_Iterator<T> &rhs);
00164
00165
00166 bool operator== (const ACE_Iterator<T> &rhs) const;
00167 bool operator!= (const ACE_Iterator<T> &rhs) const;
00168
00169
00170 T operator *() const;
00171
00172
00173 ACE_Iterator<T> &operator++ (void);
00174
00175
00176 ACE_Iterator<T> operator++ (int);
00177
00178
00179 ACE_Iterator<T> &operator-- (void);
00180
00181
00182 ACE_Iterator<T> operator-- (int);
00183
00184
00185 ACE_Iterator_Impl<T> &impl (void);
00186
00187 protected:
00188
00189
00190 ACE_Iterator_Impl<T> *implementation_;
00191 };
00192
00193
00194
00195
00196
00197
00198
00199
00200 template <class T>
00201 class ACE_Reverse_Iterator
00202 {
00203 public:
00204
00205
00206 typedef T value_type;
00207 typedef ACE_Reverse_Iterator_Impl<T> implementation;
00208
00209
00210 ACE_Reverse_Iterator (ACE_Reverse_Iterator_Impl<T> *impl);
00211
00212
00213 ACE_Reverse_Iterator (const ACE_Reverse_Iterator<T> &rhs);
00214
00215
00216 ~ACE_Reverse_Iterator (void);
00217
00218
00219 ACE_Reverse_Iterator<T> &operator= (const ACE_Reverse_Iterator<T> &rhs);
00220
00221
00222
00223
00224
00225
00226
00227 bool operator== (const ACE_Reverse_Iterator<T> &rhs) const;
00228 bool operator!= (const ACE_Reverse_Iterator<T> &rhs) const;
00229
00230
00231
00232 T operator *() const;
00233
00234
00235 ACE_Reverse_Iterator<T> &operator++ (void);
00236
00237
00238 ACE_Reverse_Iterator<T> operator++ (int);
00239
00240
00241 ACE_Reverse_Iterator<T> &operator-- (void);
00242
00243
00244 ACE_Reverse_Iterator<T> operator-- (int);
00245
00246
00247 ACE_Reverse_Iterator_Impl<T> &impl (void);
00248
00249 protected:
00250
00251
00252 ACE_Reverse_Iterator_Impl<T> *implementation_;
00253 };
00254
00255
00256
00257
00258
00259
00260
00261
00262 template <class KEY, class VALUE>
00263 class ACE_Map
00264 {
00265 public:
00266
00267
00268 typedef KEY
00269 key_type;
00270 typedef VALUE
00271 mapped_type;
00272 typedef ACE_Reference_Pair<const KEY, VALUE>
00273 value_type;
00274 typedef ACE_Iterator<value_type>
00275 iterator;
00276 typedef ACE_Reverse_Iterator<value_type>
00277 reverse_iterator;
00278 typedef ACE_Iterator_Impl<value_type>
00279 iterator_implementation;
00280 typedef ACE_Reverse_Iterator_Impl<value_type>
00281 reverse_iterator_implementation;
00282
00283
00284 virtual ~ACE_Map (void);
00285
00286
00287 virtual int open (size_t length = ACE_DEFAULT_MAP_SIZE,
00288 ACE_Allocator *alloc = 0) = 0;
00289
00290
00291 virtual int close (void) = 0;
00292
00293
00294
00295
00296
00297
00298
00299 virtual int bind (const KEY &key,
00300 const VALUE &value) = 0;
00301
00302
00303
00304
00305
00306
00307
00308 virtual int bind_modify_key (const VALUE &value,
00309 KEY &key) = 0;
00310
00311
00312
00313
00314
00315
00316
00317
00318
00319 virtual int create_key (KEY &key) = 0;
00320
00321
00322
00323
00324
00325
00326
00327
00328
00329
00330 virtual int bind_create_key (const VALUE &value,
00331 KEY &key) = 0;
00332
00333
00334
00335
00336
00337
00338
00339
00340
00341
00342 virtual int bind_create_key (const VALUE &value) = 0;
00343
00344
00345
00346 virtual int recover_key (const KEY &modified_key,
00347 KEY &original_key) = 0;
00348
00349
00350
00351
00352
00353
00354
00355 virtual int rebind (const KEY &key,
00356 const VALUE &value) = 0;
00357
00358
00359
00360
00361
00362
00363
00364
00365 virtual int rebind (const KEY &key,
00366 const VALUE &value,
00367 VALUE &old_value) = 0;
00368
00369
00370
00371
00372
00373
00374
00375
00376
00377 virtual int rebind (const KEY &key,
00378 const VALUE &value,
00379 KEY &old_key,
00380 VALUE &old_value) = 0;
00381
00382
00383
00384
00385
00386
00387
00388
00389
00390 virtual int trybind (const KEY &key,
00391 VALUE &value) = 0;
00392
00393
00394 virtual int find (const KEY &key,
00395 VALUE &value) = 0;
00396
00397
00398 virtual int find (const KEY &key) = 0;
00399
00400
00401 virtual int unbind (const KEY &key) = 0;
00402
00403
00404
00405 virtual int unbind (const KEY &key,
00406 VALUE &value) = 0;
00407
00408
00409 virtual size_t current_size (void) const = 0;
00410
00411
00412 virtual size_t total_size (void) const = 0;
00413
00414
00415 virtual void dump (void) const = 0;
00416
00417
00418
00419
00420 iterator begin (void);
00421 iterator end (void);
00422
00423
00424 reverse_iterator rbegin (void);
00425 reverse_iterator rend (void);
00426
00427 protected:
00428
00429
00430 ACE_Map (void);
00431
00432
00433 virtual ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *begin_impl (void) = 0;
00434 virtual ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *end_impl (void) = 0;
00435
00436
00437 virtual ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *rbegin_impl (void) = 0;
00438 virtual ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *rend_impl (void) = 0;
00439
00440 private:
00441
00442
00443 ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Map<KEY, VALUE> &))
00444 ACE_UNIMPLEMENTED_FUNC (ACE_Map (const ACE_Map<KEY, VALUE> &))
00445 };
00446
00447
00448
00449
00450
00451
00452
00453
00454 template <class T, class IMPLEMENTATION, class ENTRY>
00455 class ACE_Map_Impl_Iterator_Adapter : public ACE_Iterator_Impl<T>
00456 {
00457 public:
00458
00459
00460 typedef IMPLEMENTATION
00461 implementation;
00462
00463
00464 ACE_Map_Impl_Iterator_Adapter (const IMPLEMENTATION &impl);
00465
00466
00467 virtual ~ACE_Map_Impl_Iterator_Adapter (void);
00468
00469
00470 virtual ACE_Iterator_Impl<T> *clone (void) const;
00471
00472
00473 virtual int compare (const ACE_Iterator_Impl<T> &rhs) const;
00474
00475
00476 virtual T dereference (void) const;
00477
00478
00479 virtual void plus_plus (void);
00480
00481
00482 virtual void minus_minus (void);
00483
00484
00485 IMPLEMENTATION &impl (void);
00486
00487 protected:
00488
00489
00490 IMPLEMENTATION implementation_;
00491 };
00492
00493
00494
00495
00496
00497
00498
00499
00500 template <class T, class IMPLEMENTATION, class ENTRY>
00501 class ACE_Map_Impl_Reverse_Iterator_Adapter : public ACE_Reverse_Iterator_Impl<T>
00502 {
00503 public:
00504
00505
00506 typedef IMPLEMENTATION
00507 implementation;
00508
00509
00510 ACE_Map_Impl_Reverse_Iterator_Adapter (const IMPLEMENTATION &impl);
00511
00512
00513 virtual ~ACE_Map_Impl_Reverse_Iterator_Adapter (void);
00514
00515
00516 virtual ACE_Reverse_Iterator_Impl<T> *clone (void) const;
00517
00518
00519 virtual int compare (const ACE_Reverse_Iterator_Impl<T> &rhs) const;
00520
00521
00522 virtual T dereference (void) const;
00523
00524
00525 virtual void plus_plus (void);
00526
00527
00528 virtual void minus_minus (void);
00529
00530
00531 IMPLEMENTATION &impl (void);
00532
00533 protected:
00534
00535
00536 IMPLEMENTATION implementation_;
00537 };
00538
00539
00540
00541
00542
00543
00544
00545
00546 template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY>
00547 class ACE_Map_Impl : public ACE_Map<KEY, VALUE>
00548 {
00549 public:
00550
00551
00552 typedef ACE_Map_Impl_Iterator_Adapter<ACE_TYPENAME ACE_Map<KEY, VALUE>::value_type, ITERATOR, ENTRY>
00553 iterator_impl;
00554 typedef ACE_Map_Impl_Reverse_Iterator_Adapter<ACE_TYPENAME ACE_Map<KEY, VALUE>::value_type, REVERSE_ITERATOR, ENTRY>
00555 reverse_iterator_impl;
00556
00557 typedef IMPLEMENTATION
00558 implementation;
00559
00560
00561
00562 ACE_Map_Impl (ACE_Allocator *alloc = 0);
00563
00564
00565
00566 ACE_Map_Impl (size_t size,
00567 ACE_Allocator *alloc = 0);
00568
00569
00570 virtual ~ACE_Map_Impl (void);
00571
00572
00573 virtual int open (size_t length = ACE_DEFAULT_MAP_SIZE,
00574 ACE_Allocator *alloc = 0);
00575
00576
00577 virtual int close (void);
00578
00579
00580
00581
00582
00583
00584
00585 virtual int bind (const KEY &key,
00586 const VALUE &value);
00587
00588
00589
00590
00591
00592
00593
00594 virtual int bind_modify_key (const VALUE &value,
00595 KEY &key);
00596
00597
00598
00599
00600
00601
00602
00603
00604
00605 virtual int create_key (KEY &key);
00606
00607
00608
00609
00610
00611
00612
00613
00614
00615
00616 virtual int bind_create_key (const VALUE &value,
00617 KEY &key);
00618
00619
00620
00621
00622
00623
00624
00625
00626
00627
00628 virtual int bind_create_key (const VALUE &value);
00629
00630
00631
00632 virtual int recover_key (const KEY &modified_key,
00633 KEY &original_key);
00634
00635
00636
00637
00638
00639
00640
00641 virtual int rebind (const KEY &key,
00642 const VALUE &value);
00643
00644
00645
00646
00647
00648
00649
00650
00651 virtual int rebind (const KEY &key,
00652 const VALUE &value,
00653 VALUE &old_value);
00654
00655
00656
00657
00658
00659
00660
00661
00662
00663 virtual int rebind (const KEY &key,
00664 const VALUE &value,
00665 KEY &old_key,
00666 VALUE &old_value);
00667
00668
00669
00670
00671
00672
00673
00674
00675
00676 virtual int trybind (const KEY &key,
00677 VALUE &value);
00678
00679
00680 virtual int find (const KEY &key,
00681 VALUE &value);
00682
00683
00684 virtual int find (const KEY &key);
00685
00686
00687 virtual int unbind (const KEY &key);
00688
00689
00690
00691 virtual int unbind (const KEY &key,
00692 VALUE &value);
00693
00694
00695 virtual size_t current_size (void) const;
00696
00697
00698 virtual size_t total_size (void) const;
00699
00700
00701 virtual void dump (void) const;
00702
00703
00704 IMPLEMENTATION &impl (void);
00705
00706 protected:
00707
00708
00709 IMPLEMENTATION implementation_;
00710
00711
00712
00713
00714 virtual ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *begin_impl (void);
00715 virtual ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *end_impl (void);
00716
00717
00718 virtual ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *rbegin_impl (void);
00719 virtual ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *rend_impl (void);
00720
00721 private:
00722
00723
00724 ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY> &))
00725 ACE_UNIMPLEMENTED_FUNC (ACE_Map_Impl (const ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY> &))
00726 };
00727
00728
00729
00730
00731
00732
00733
00734
00735 template <class T, class VALUE>
00736 class ACE_Active_Map_Manager_Iterator_Adapter : public ACE_Iterator_Impl<T>
00737 {
00738 public:
00739
00740
00741 typedef ACE_TYPENAME ACE_Active_Map_Manager<VALUE>::iterator
00742 implementation;
00743
00744
00745 ACE_Active_Map_Manager_Iterator_Adapter (const ACE_Map_Iterator<ACE_Active_Map_Manager_Key, VALUE, ACE_Null_Mutex> &impl);
00746
00747
00748 virtual ~ACE_Active_Map_Manager_Iterator_Adapter (void);
00749
00750
00751 virtual ACE_Iterator_Impl<T> *clone (void) const;
00752
00753
00754 virtual int compare (const ACE_Iterator_Impl<T> &rhs) const;
00755
00756
00757 virtual T dereference (void) const;
00758
00759
00760 virtual void plus_plus (void);
00761
00762
00763 virtual void minus_minus (void);
00764
00765
00766 ACE_Map_Iterator<ACE_Active_Map_Manager_Key, VALUE, ACE_Null_Mutex> &impl (void);
00767
00768 protected:
00769
00770
00771 ACE_Map_Iterator<ACE_Active_Map_Manager_Key, VALUE, ACE_Null_Mutex> implementation_;
00772 };
00773
00774
00775
00776
00777
00778
00779
00780
00781 template <class T, class VALUE>
00782 class ACE_Active_Map_Manager_Reverse_Iterator_Adapter : public ACE_Reverse_Iterator_Impl<T>
00783 {
00784 public:
00785
00786
00787 typedef ACE_TYPENAME ACE_Active_Map_Manager<VALUE>::reverse_iterator
00788 implementation;
00789
00790
00791 ACE_Active_Map_Manager_Reverse_Iterator_Adapter (const ACE_Map_Reverse_Iterator<ACE_Active_Map_Manager_Key, VALUE, ACE_Null_Mutex> &impl);
00792
00793
00794 virtual ~ACE_Active_Map_Manager_Reverse_Iterator_Adapter (void);
00795
00796
00797 virtual ACE_Reverse_Iterator_Impl<T> *clone (void) const;
00798
00799
00800 virtual int compare (const ACE_Reverse_Iterator_Impl<T> &rhs) const;
00801
00802
00803 virtual T dereference (void) const;
00804
00805
00806 virtual void plus_plus (void);
00807
00808
00809 virtual void minus_minus (void);
00810
00811
00812 ACE_Map_Reverse_Iterator<ACE_Active_Map_Manager_Key, VALUE, ACE_Null_Mutex> &impl (void);
00813
00814 protected:
00815
00816
00817 ACE_Map_Reverse_Iterator<ACE_Active_Map_Manager_Key, VALUE, ACE_Null_Mutex> implementation_;
00818 };
00819
00820
00821
00822
00823
00824
00825
00826
00827 template <class KEY, class VALUE, class KEY_ADAPTER>
00828 class ACE_Active_Map_Manager_Adapter : public ACE_Map<KEY, VALUE>
00829 {
00830 public:
00831
00832
00833 typedef ACE_Pair<KEY, VALUE>
00834 expanded_value;
00835 typedef ACE_Active_Map_Manager_Iterator_Adapter<ACE_Reference_Pair<const KEY, VALUE>, expanded_value>
00836 iterator_impl;
00837 typedef ACE_Active_Map_Manager_Reverse_Iterator_Adapter<ACE_Reference_Pair<const KEY, VALUE>, expanded_value>
00838 reverse_iterator_impl;
00839 typedef ACE_Active_Map_Manager<expanded_value>
00840 implementation;
00841
00842
00843
00844 ACE_Active_Map_Manager_Adapter (ACE_Allocator *alloc = 0);
00845
00846
00847
00848 ACE_Active_Map_Manager_Adapter (size_t size,
00849 ACE_Allocator *alloc = 0);
00850
00851
00852 virtual ~ACE_Active_Map_Manager_Adapter (void);
00853
00854
00855 virtual int open (size_t length = ACE_DEFAULT_MAP_SIZE,
00856 ACE_Allocator *alloc = 0);
00857
00858
00859 virtual int close (void);
00860
00861
00862
00863
00864
00865
00866
00867 virtual int bind (const KEY &key,
00868 const VALUE &value);
00869
00870
00871
00872
00873
00874
00875
00876 virtual int bind_modify_key (const VALUE &value,
00877 KEY &key);
00878
00879
00880
00881
00882
00883
00884
00885
00886
00887 virtual int create_key (KEY &key);
00888
00889
00890
00891
00892
00893
00894
00895
00896
00897
00898 virtual int bind_create_key (const VALUE &value,
00899 KEY &key);
00900
00901
00902
00903
00904
00905
00906
00907
00908
00909
00910 virtual int bind_create_key (const VALUE &value);
00911
00912
00913
00914 virtual int recover_key (const KEY &modified_key,
00915 KEY &original_key);
00916
00917
00918
00919
00920
00921
00922
00923 virtual int rebind (const KEY &key,
00924 const VALUE &value);
00925
00926
00927
00928
00929
00930
00931
00932
00933 virtual int rebind (const KEY &key,
00934 const VALUE &value,
00935 VALUE &old_value);
00936
00937
00938
00939
00940
00941
00942
00943
00944
00945 virtual int rebind (const KEY &key,
00946 const VALUE &value,
00947 KEY &old_key,
00948 VALUE &old_value);
00949
00950
00951
00952
00953
00954
00955
00956
00957
00958 virtual int trybind (const KEY &key,
00959 VALUE &value);
00960
00961
00962 virtual int find (const KEY &key,
00963 VALUE &value);
00964
00965
00966 virtual int find (const KEY &key);
00967
00968
00969 virtual int unbind (const KEY &key);
00970
00971
00972
00973 virtual int unbind (const KEY &key,
00974 VALUE &value);
00975
00976
00977 virtual size_t current_size (void) const;
00978
00979
00980 virtual size_t total_size (void) const;
00981
00982
00983 virtual void dump (void) const;
00984
00985
00986 ACE_Active_Map_Manager<ACE_Pair<KEY, VALUE> > &impl (void);
00987
00988
00989 KEY_ADAPTER &key_adapter (void);
00990
00991 protected:
00992
00993
00994 virtual int find (const KEY &key,
00995 expanded_value *&internal_value);
00996
00997
00998 virtual int unbind (const KEY &key,
00999 expanded_value *&internal_value);
01000
01001
01002 ACE_Active_Map_Manager<ACE_Pair<KEY, VALUE> > implementation_;
01003
01004
01005 KEY_ADAPTER key_adapter_;
01006
01007
01008
01009
01010 virtual ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *begin_impl (void);
01011 virtual ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *end_impl (void);
01012
01013
01014 virtual ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *rbegin_impl (void);
01015 virtual ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *rend_impl (void);
01016
01017 private:
01018
01019
01020 ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER> &))
01021 ACE_UNIMPLEMENTED_FUNC (ACE_Active_Map_Manager_Adapter (const ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER> &))
01022 };
01023
01024
01025
01026
01027
01028
01029
01030
01031 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS>
01032 class ACE_Hash_Map_Manager_Ex_Iterator_Adapter : public ACE_Iterator_Impl<T>
01033 {
01034 public:
01035
01036
01037 typedef ACE_TYPENAME ACE_Hash_Map_Manager_Ex<KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex>::iterator
01038 implementation;
01039
01040
01041 ACE_Hash_Map_Manager_Ex_Iterator_Adapter (const ACE_Hash_Map_Iterator_Ex<KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex> &impl);
01042
01043
01044 virtual ~ACE_Hash_Map_Manager_Ex_Iterator_Adapter (void);
01045
01046
01047 virtual ACE_Iterator_Impl<T> *clone (void) const;
01048
01049
01050 virtual int compare (const ACE_Iterator_Impl<T> &rhs) const;
01051
01052
01053 virtual T dereference (void) const;
01054
01055
01056 virtual void plus_plus (void);
01057
01058
01059 virtual void minus_minus (void);
01060
01061
01062 ACE_Hash_Map_Iterator_Ex<KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex> &impl (void);
01063
01064 protected:
01065
01066
01067 ACE_Hash_Map_Iterator_Ex<KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex> implementation_;
01068 };
01069
01070
01071
01072
01073
01074
01075
01076
01077 template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS>
01078 class ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter : public ACE_Reverse_Iterator_Impl<T>
01079 {
01080 public:
01081
01082
01083 typedef ACE_TYPENAME ACE_Hash_Map_Manager_Ex<KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex>::reverse_iterator
01084 implementation;
01085
01086
01087 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);
01088
01089
01090 virtual ~ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter (void);
01091
01092
01093 virtual ACE_Reverse_Iterator_Impl<T> *clone (void) const;
01094
01095
01096 virtual int compare (const ACE_Reverse_Iterator_Impl<T> &rhs) const;
01097
01098
01099 virtual T dereference (void) const;
01100
01101
01102 virtual void plus_plus (void);
01103
01104
01105 virtual void minus_minus (void);
01106
01107
01108 ACE_Hash_Map_Reverse_Iterator_Ex<KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex> &impl (void);
01109
01110 protected:
01111
01112
01113 ACE_Hash_Map_Reverse_Iterator_Ex<KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex> implementation_;
01114 };
01115
01116
01117
01118
01119
01120
01121
01122
01123 template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR>
01124 class ACE_Hash_Map_Manager_Ex_Adapter : public ACE_Map<KEY, VALUE>
01125 {
01126 public:
01127
01128
01129 typedef ACE_Hash_Map_Manager_Ex_Iterator_Adapter<ACE_Reference_Pair<const KEY, VALUE>, KEY, VALUE, HASH_KEY, COMPARE_KEYS>
01130 iterator_impl;
01131 typedef ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<ACE_Reference_Pair<const KEY, VALUE>, KEY, VALUE, HASH_KEY, COMPARE_KEYS>
01132 reverse_iterator_impl;
01133 typedef ACE_Hash_Map_Manager_Ex<KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex>
01134 implementation;
01135
01136
01137
01138 ACE_Hash_Map_Manager_Ex_Adapter (ACE_Allocator *alloc = 0);
01139
01140
01141
01142 ACE_Hash_Map_Manager_Ex_Adapter (size_t size,
01143 ACE_Allocator *alloc = 0);
01144
01145
01146 virtual ~ACE_Hash_Map_Manager_Ex_Adapter (void);
01147
01148
01149 virtual int open (size_t length = ACE_DEFAULT_MAP_SIZE,
01150 ACE_Allocator *alloc = 0);
01151
01152
01153 virtual int close (void);
01154
01155
01156
01157
01158
01159
01160
01161 virtual int bind (const KEY &key,
01162 const VALUE &value);
01163
01164
01165
01166
01167
01168
01169
01170 virtual int bind_modify_key (const VALUE &value,
01171 KEY &key);
01172
01173
01174
01175
01176
01177
01178
01179
01180
01181 virtual int create_key (KEY &key);
01182
01183
01184
01185
01186
01187
01188
01189
01190
01191
01192 virtual int bind_create_key (const VALUE &value,
01193 KEY &key);
01194
01195
01196
01197
01198
01199
01200
01201
01202
01203
01204 virtual int bind_create_key (const VALUE &value);
01205
01206
01207
01208 virtual int recover_key (const KEY &modified_key,
01209 KEY &original_key);
01210
01211
01212
01213
01214
01215
01216
01217 virtual int rebind (const KEY &key,
01218 const VALUE &value);
01219
01220
01221
01222
01223
01224
01225
01226
01227 virtual int rebind (const KEY &key,
01228 const VALUE &value,
01229 VALUE &old_value);
01230
01231
01232
01233
01234
01235
01236
01237
01238
01239 virtual int rebind (const KEY &key,
01240 const VALUE &value,
01241 KEY &old_key,
01242 VALUE &old_value);
01243
01244
01245
01246
01247
01248
01249
01250
01251
01252 virtual int trybind (const KEY &key,
01253 VALUE &value);
01254
01255
01256 virtual int find (const KEY &key,
01257 VALUE &value);
01258
01259
01260 virtual int find (const KEY &key);
01261
01262
01263 virtual int unbind (const KEY &key);
01264
01265
01266
01267 virtual int unbind (const KEY &key,
01268 VALUE &value);
01269
01270
01271 virtual size_t current_size (void) const;
01272
01273
01274 virtual size_t total_size (void) const;
01275
01276
01277 virtual void dump (void) const;
01278
01279
01280 ACE_Hash_Map_Manager_Ex<KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex> &impl (void);
01281
01282
01283 KEY_GENERATOR &key_generator (void);
01284
01285 protected:
01286
01287
01288 ACE_Hash_Map_Manager_Ex<KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex> implementation_;
01289
01290
01291 KEY_GENERATOR key_generator_;
01292
01293
01294
01295
01296 virtual ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *begin_impl (void);
01297 virtual ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *end_impl (void);
01298
01299
01300 virtual ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *rbegin_impl (void);
01301 virtual ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *rend_impl (void);
01302
01303 private:
01304
01305
01306 ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR> &))
01307 ACE_UNIMPLEMENTED_FUNC (ACE_Hash_Map_Manager_Ex_Adapter (const ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR> &))
01308 };
01309
01310
01311
01312
01313
01314
01315
01316
01317 template <class T, class KEY, class VALUE>
01318 class ACE_Map_Manager_Iterator_Adapter : public ACE_Iterator_Impl<T>
01319 {
01320 public:
01321
01322
01323 typedef ACE_TYPENAME ACE_Map_Manager<KEY, VALUE, ACE_Null_Mutex>::iterator
01324 implementation;
01325
01326
01327 ACE_Map_Manager_Iterator_Adapter (const ACE_Map_Iterator<KEY, VALUE, ACE_Null_Mutex> &impl);
01328
01329
01330 virtual ~ACE_Map_Manager_Iterator_Adapter (void);
01331
01332
01333 virtual ACE_Iterator_Impl<T> *clone (void) const;
01334
01335
01336 virtual int compare (const ACE_Iterator_Impl<T> &rhs) const;
01337
01338
01339 virtual T dereference (void) const;
01340
01341
01342 virtual void plus_plus (void);
01343
01344
01345 virtual void minus_minus (void);
01346
01347
01348 ACE_Map_Iterator<KEY, VALUE, ACE_Null_Mutex> &impl (void);
01349
01350 protected:
01351
01352
01353 ACE_Map_Iterator<KEY, VALUE, ACE_Null_Mutex> implementation_;
01354 };
01355
01356
01357
01358
01359
01360
01361
01362
01363 template <class T, class KEY, class VALUE>
01364 class ACE_Map_Manager_Reverse_Iterator_Adapter : public ACE_Reverse_Iterator_Impl<T>
01365 {
01366 public:
01367
01368
01369 typedef ACE_TYPENAME ACE_Map_Manager<KEY, VALUE, ACE_Null_Mutex>::reverse_iterator
01370 implementation;
01371
01372
01373 ACE_Map_Manager_Reverse_Iterator_Adapter (const ACE_Map_Reverse_Iterator<KEY, VALUE, ACE_Null_Mutex> &impl);
01374
01375
01376 virtual ~ACE_Map_Manager_Reverse_Iterator_Adapter (void);
01377
01378
01379 virtual ACE_Reverse_Iterator_Impl<T> *clone (void) const;
01380
01381
01382 virtual int compare (const ACE_Reverse_Iterator_Impl<T> &rhs) const;
01383
01384
01385 virtual T dereference (void) const;
01386
01387
01388 virtual void plus_plus (void);
01389
01390
01391 virtual void minus_minus (void);
01392
01393
01394 ACE_Map_Reverse_Iterator<KEY, VALUE, ACE_Null_Mutex> &impl (void);
01395
01396 protected:
01397
01398
01399 ACE_Map_Reverse_Iterator<KEY, VALUE, ACE_Null_Mutex> implementation_;
01400 };
01401
01402
01403
01404
01405
01406
01407
01408
01409 template <class KEY, class VALUE, class KEY_GENERATOR>
01410 class ACE_Map_Manager_Adapter : public ACE_Map<KEY, VALUE>
01411 {
01412 public:
01413
01414
01415 typedef ACE_Map_Manager_Iterator_Adapter<ACE_Reference_Pair<const KEY, VALUE>, KEY, VALUE>
01416 iterator_impl;
01417 typedef ACE_Map_Manager_Reverse_Iterator_Adapter<ACE_Reference_Pair<const KEY, VALUE>, KEY, VALUE>
01418 reverse_iterator_impl;
01419 typedef ACE_Map_Manager<KEY, VALUE, ACE_Null_Mutex>
01420 implementation;
01421
01422
01423
01424 ACE_Map_Manager_Adapter (ACE_Allocator *alloc = 0);
01425
01426
01427
01428 ACE_Map_Manager_Adapter (size_t size,
01429 ACE_Allocator *alloc = 0);
01430
01431
01432 virtual ~ACE_Map_Manager_Adapter (void);
01433
01434
01435 virtual int open (size_t length = ACE_DEFAULT_MAP_SIZE,
01436 ACE_Allocator *alloc = 0);
01437
01438
01439 virtual int close (void);
01440
01441
01442
01443
01444
01445
01446
01447 virtual int bind (const KEY &key,
01448 const VALUE &value);
01449
01450
01451
01452
01453
01454
01455
01456 virtual int bind_modify_key (const VALUE &value,
01457 KEY &key);
01458
01459
01460
01461
01462
01463
01464
01465
01466
01467 virtual int create_key (KEY &key);
01468
01469
01470
01471
01472
01473
01474
01475
01476
01477
01478 virtual int bind_create_key (const VALUE &value,
01479 KEY &key);
01480
01481
01482
01483
01484
01485
01486
01487
01488
01489
01490 virtual int bind_create_key (const VALUE &value);
01491
01492
01493
01494 virtual int recover_key (const KEY &modified_key,
01495 KEY &original_key);
01496
01497
01498
01499
01500
01501
01502
01503 virtual int rebind (const KEY &key,
01504 const VALUE &value);
01505
01506
01507
01508
01509
01510
01511
01512
01513 virtual int rebind (const KEY &key,
01514 const VALUE &value,
01515 VALUE &old_value);
01516
01517
01518
01519
01520
01521
01522
01523
01524
01525 virtual int rebind (const KEY &key,
01526 const VALUE &value,
01527 KEY &old_key,
01528 VALUE &old_value);
01529
01530
01531
01532
01533
01534
01535
01536
01537
01538 virtual int trybind (const KEY &key,
01539 VALUE &value);
01540
01541
01542 virtual int find (const KEY &key,
01543 VALUE &value);
01544
01545
01546 virtual int find (const KEY &key);
01547
01548
01549 virtual int unbind (const KEY &key);
01550
01551
01552
01553 virtual int unbind (const KEY &key,
01554 VALUE &value);
01555
01556
01557 virtual size_t current_size (void) const;
01558
01559
01560 virtual size_t total_size (void) const;
01561
01562
01563 virtual void dump (void) const;
01564
01565
01566 ACE_Map_Manager<KEY, VALUE, ACE_Null_Mutex> &impl (void);
01567
01568
01569 KEY_GENERATOR &key_generator (void);
01570
01571 protected:
01572
01573
01574 ACE_Map_Manager<KEY, VALUE, ACE_Null_Mutex> implementation_;
01575
01576
01577 KEY_GENERATOR key_generator_;
01578
01579
01580
01581
01582 virtual ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *begin_impl (void);
01583 virtual ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *end_impl (void);
01584
01585
01586 virtual ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *rbegin_impl (void);
01587 virtual ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *rend_impl (void);
01588
01589 private:
01590
01591
01592 ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR> &))
01593 ACE_UNIMPLEMENTED_FUNC (ACE_Map_Manager_Adapter (const ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR> &))
01594 };
01595
01596 ACE_END_VERSIONED_NAMESPACE_DECL
01597
01598 #if defined (__ACE_INLINE__)
01599 #include "ace/Map_T.inl"
01600 #endif
01601
01602 #if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
01603 #include "ace/Map_T.cpp"
01604 #endif
01605
01606 #if defined (ACE_TEMPLATES_REQUIRE_PRAGMA)
01607 #pragma implementation ("Map_T.cpp")
01608 #endif
01609
01610 #include "ace/post.h"
01611 #endif