Oracle Coherence for C++ API
Release 3.6.0.0
E15728-01

- Main Page
- Namespaces
- Classes
- Files

# coherence/util/WrapperCollections.hpp

    00001 /*
    00002 * WrapperCollections.hpp
    00003 *
    00004 * Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
    00005 *
    00006 * Oracle is a registered trademarks of Oracle Corporation and/or its
    00007 * affiliates.
    00008 *
    00009 * This software is the confidential and proprietary information of Oracle
    00010 * Corporation. You shall not disclose such confidential and proprietary
    00011 * information and shall use it only in accordance with the terms of the
    00012 * license agreement you entered into with Oracle.
    00013 *
    00014 * This notice may not be removed or altered.
    00015 */
    00016 #ifndef COH_WRAPPER_COLLECTIONS_HPP
    00017 #define COH_WRAPPER_COLLECTIONS_HPP
    00018
    00019 #include "coherence/lang.ns"
    00020
    00021 #include "coherence/util/Collection.hpp"
    00022 #include "coherence/util/Iterator.hpp"
    00023 #include "coherence/util/List.hpp"
    00024 #include "coherence/util/ListIterator.hpp"
    00025 #include "coherence/util/Map.hpp"
    00026 #include "coherence/util/Muterator.hpp"
    00027 #include "coherence/util/Set.hpp"
    00028
    00029 #include <cstddef>
    00030 #include <ostream>
    00031
    00032 COH_OPEN_NAMESPACE2(coherence,util)
    00033
    00034
    00035 /**
    00036 * A collection of abstract Collection implementation classes for wrapping
    00037 * Collection types.
    00038 *
    00039 * @author mf  2007.07.05
    00040 */
    00041 class COH_EXPORT WrapperCollections
    00042     {
    00043     // ----- inner classes --------------------------------------------------
    00044
    00045     public:
    00046         /**
    00047         * Iterator implementation which delegates all calls to another
    00048         * Iterator.
    00049         */
    00050         class COH_EXPORT AbstractWrapperIterator
    00051             : public abstract_spec<AbstractWrapperIterator,
    00052                 extends<Object>,
    00053                 implements<Muterator> >
    00054             {
    00055             // ----- constructors ---------------------------------------
    00056
    00057             protected:
    00058                 /**
    00059                 * Create an AbstractWrapperIterator which delegates to the
    00060                 * specified Iterator.
    00061                 *
    00062                 * @param hiterDelegate a handle to the specified delegate
    00063                 *        Iterator
    00064                 */
    00065                 AbstractWrapperIterator(Iterator::Handle hiterDelegate);
    00066
    00067                 /**
    00068                 * Copy constructor.
    00069                 */
    00070                 AbstractWrapperIterator(const AbstractWrapperIterator& that);
    00071
    00072
    00073             // ----- Iterator interface ---------------------------------
    00074
    00075             public:
    00076                 /**
    00077                 * {@inheritDoc}
    00078                 */
    00079                 virtual bool hasNext() const;
    00080
    00081                 /**
    00082                 * {@inheritDoc}
    00083                 */
    00084                 virtual Object::Holder next();
    00085
    00086
    00087             // ----- Muterator interface --------------------------------
    00088
    00089             public:
    00090                 /**
    00091                 * {@inheritDoc}
    00092                 */
    00093                 virtual void remove();
    00094
    00095             // ----- Object interface -----------------------------------
    00096
    00097             public:
    00098                 /**
    00099                 * {@inheritDoc}
    00100                 */
    00101                 virtual void toStream(std::ostream& out) const;
    00102
    00103                 /**
    00104                 * {@inheritDoc}
    00105                 */
    00106                 virtual size32_t hashCode() const;
    00107
    00108                 /**
    00109                 * {@inheritDoc}
    00110                 */
    00111                 virtual bool equals(Object::View v) const;
    00112
    00113
    00114             // ----- accessors ------------------------------------------
    00115
    00116             protected:
    00117                 /**
    00118                 * Return a handle to the delegate.
    00119                 *
    00120                 * @return the delegate handle
    00121                 *
    00122                 * @throw UnsupportedOperationException if the delegate is a
    00123                 *        view
    00124                 */
    00125                 virtual Iterator::Handle getDelegate();
    00126
    00127                 /**
    00128                 * Return a view to the delegate.
    00129                 *
    00130                 * @return the delegate view
    00131                 */
    00132                 virtual Iterator::View getDelegate() const;
    00133
    00134             // ----- data members ---------------------------------------
    00135
    00136             private:
    00137                 /**
    00138                 * The Iterator to which this wrapper delegates.
    00139                 */
    00140                 FinalHolder<Iterator> m_ohDelegate;
    00141             };
    00142
    00143
    00144         /**
    00145         * ListIterator implementation which delegates all calls to another
    00146         * ListIterator.
    00147         */
    00148         class COH_EXPORT AbstractWrapperListIterator
    00149             : public abstract_spec<AbstractWrapperListIterator,
    00150                 extends<AbstractWrapperIterator>,
    00151                 implements<ListMuterator> >
    00152             {
    00153             // ----- constructors ---------------------------------------
    00154
    00155             protected:
    00156                 /**
    00157                 * Create an AbstractWrapperListIterator which delegates to
    00158                 * the specified ListIterator.
    00159                 *
    00160                 * @param hIterDelegate  the Iterator to delegate to
    00161                 */
    00162                 AbstractWrapperListIterator(
    00163                         ListIterator::Handle hIterDelegate);
    00164
    00165                 /**
    00166                 * Copy constructor.
    00167                 */
    00168                 AbstractWrapperListIterator(
    00169                         const AbstractWrapperListIterator& that);
    00170
    00171             // ----- ListIterator interface ----------------------------
    00172
    00173             public:
    00174                 /**
    00175                 * {@inheritDoc}
    00176                 */
    00177                 virtual bool hasPrevious() const;
    00178
    00179                 /**
    00180                 * {@inheritDoc}
    00181                 */
    00182                 virtual Object::Holder previous();
    00183
    00184                 /**
    00185                 * {@inheritDoc}
    00186                 */
    00187                 virtual size32_t nextIndex() const;
    00188
    00189                 /**
    00190                 * {@inheritDoc}
    00191                 */
    00192                 virtual size32_t previousIndex() const;
    00193
    00194             // ----- ListMuterator interface ----------------------------
    00195
    00196             public:
    00197                 /**
    00198                 * {@inheritDoc}
    00199                 */
    00200                 virtual void remove();
    00201                 /**
    00202                 * {@inheritDoc}
    00203                 */
    00204                 virtual void add(Object::Holder oh);
    00205
    00206                 /**
    00207                 * {@inheritDoc}
    00208                 */
    00209                 virtual void set(Object::Holder oh);
    00210
    00211             // ----- Iterator interface ---------------------------------
    00212
    00213             public:
    00214                 /**
    00215                 * {@inheritDoc}
    00216                 */
    00217                 virtual bool hasNext() const;
    00218
    00219                 /**
    00220                 * {@inheritDoc}
    00221                 */
    00222                 virtual Object::Holder next();
    00223
    00224
    00225             // ----- helper methods -------------------------------------
    00226
    00227             protected:
    00228                 /**
    00229                 * Return a handle to the delegate.
    00230                 *
    00231                 * @return the delegate handle
    00232                 *
    00233                 * @throw UnsupportedOperationException if the delegate is a
    00234                 *        view
    00235                 */
    00236                 virtual ListIterator::Handle getListDelegate();
    00237
    00238                 /**
    00239                 * Return a view to the delegate.
    00240                 *
    00241                 * @return the delegate view
    00242                 */
    00243                 virtual ListIterator::View getListDelegate() const;
    00244
    00245
    00246             // ----- data members -------------------------------------------
    00247
    00248             private:
    00249                 /**
    00250                 * The ListIterator to which this wrapper delegates.
    00251                 */
    00252                 FinalHolder<ListIterator> m_ohDelegate;
    00253             };
    00254
    00255
    00256         /**
    00257         * Collection implementation which delegates all calls to another
    00258         * Collection.
    00259         */
    00260         class COH_EXPORT AbstractWrapperCollection
    00261             : public abstract_spec<AbstractWrapperCollection,
    00262                 extends<Object>,
    00263                 implements<Collection> >
    00264             {
    00265             // ----- constructors ---------------------------------------
    00266
    00267             protected:
    00268                 /**
    00269                 * Create an AbstractWrapperCollection which delegates to the
    00270                 * specified Collection.
    00271                 *
    00272                 * @param ohCollDelegate  the Collection to delegate to
    00273                 */
    00274                 AbstractWrapperCollection(Collection::Holder ohCollDelegate);
    00275
    00276                 /**
    00277                 * Copy constructor.
    00278                 */
    00279                 AbstractWrapperCollection(const AbstractWrapperCollection& that);
    00280
    00281             // ----- Collection interface -------------------------------
    00282
    00283             public:
    00284                 /**
    00285                 * {@inheritDoc}
    00286                 */
    00287                 virtual size32_t size() const;
    00288
    00289                 /**
    00290                 * {@inheritDoc}
    00291                 */
    00292                 virtual bool isEmpty() const;
    00293
    00294                 /**
    00295                 * {@inheritDoc}
    00296                 */
    00297                 virtual bool contains(Object::View v) const;
    00298
    00299                 /**
    00300                 * {@inheritDoc}
    00301                 */
    00302                 virtual Iterator::Handle iterator() const;
    00303
    00304                 /**
    00305                 * {@inheritDoc}
    00306                 */
    00307                 virtual Muterator::Handle iterator();
    00308
    00309                 /**
    00310                 * {@inheritDoc}
    00311                 */
    00312                 virtual ObjectArray::Handle toArray(
    00313                         ObjectArray::Handle hao = NULL) const;
    00314
    00315                 /**
    00316                 * {@inheritDoc}
    00317                 */
    00318                 virtual bool add(Object::Holder oh);
    00319
    00320                 /**
    00321                 * {@inheritDoc}
    00322                 */
    00323                 virtual bool remove(Object::View v);
    00324
    00325                 /**
    00326                 * {@inheritDoc}
    00327                 */
    00328                 virtual bool containsAll(Collection::View vc) const;
    00329
    00330                 /**
    00331                 * {@inheritDoc}
    00332                 */
    00333                 virtual bool addAll(Collection::View vc);
    00334
    00335                 /**
    00336                 * {@inheritDoc}
    00337                 */
    00338                 virtual bool removeAll(Collection::View vc);
    00339
    00340                 /**
    00341                 * {@inheritDoc}
    00342                 */
    00343                 virtual bool retainAll(Collection::View vc);
    00344
    00345                 /**
    00346                 * {@inheritDoc}
    00347                 */
    00348                 virtual void clear();
    00349
    00350             // ----- Object interface -----------------------------------
    00351
    00352             public:
    00353                 /**
    00354                 * {@inheritDoc}
    00355                 */
    00356                 virtual void toStream(std::ostream& out) const;
    00357
    00358                 /**
    00359                 * {@inheritDoc}
    00360                 */
    00361                 virtual size32_t hashCode() const;
    00362
    00363                 /**
    00364                 * {@inheritDoc}
    00365                 */
    00366                 virtual bool equals(Object::View v) const;
    00367
    00368                 /**
    00369                 * {@inheritDoc}
    00370                 */
    00371                 virtual bool isImmutable() const;
    00372
    00373             // ----- accessors ------------------------------------------
    00374
    00375             protected:
    00376                 /**
    00377                 * Return a handle to the delegate.
    00378                 *
    00379                 * @return the delegate handle
    00380                 *
    00381                 * @throw UnsupportedOperationException if the delegate is a
    00382                 *        view
    00383                 */
    00384                 virtual Collection::Handle getDelegate();
    00385
    00386                 /**
    00387                 * Return a view to the delegate.
    00388                 *
    00389                 * @return the delegate view
    00390                 */
    00391                 virtual Collection::View getDelegate() const;
    00392
    00393             // ----- data members ---------------------------------------
    00394
    00395             private:
    00396                 /**
    00397                 * The Collection to which this wrapper delegates.
    00398                 */
    00399                 FinalHolder<Collection> m_ohDelegate;
    00400             };
    00401
    00402         /**
    00403         * Set implementation which delegates all calls to another Set.
    00404         */
    00405         class COH_EXPORT AbstractWrapperSet
    00406             : public abstract_spec<AbstractWrapperSet,
    00407                 extends<Object>,
    00408                 implements<Set> >
    00409             {
    00410             // ----- constructors ---------------------------------------
    00411
    00412             protected:
    00413                 /**
    00414                 * Create an AbstractWrapperSet which delegates to the
    00415                 * specified Set.
    00416                 *
    00417                 * @param ohSetDelegate  the Set to delegate to
    00418                 */
    00419                 AbstractWrapperSet(Set::Holder ohSetDelegate);
    00420
    00421                 /**
    00422                 * Copy constructor.
    00423                 */
    00424                 AbstractWrapperSet(const AbstractWrapperSet& that);
    00425
    00426             // ----- Set interface --------------------------------------
    00427
    00428             public:
    00429                 /**
    00430                 * {@inheritDoc}
    00431                 */
    00432                 virtual size32_t size() const;
    00433
    00434                 /**
    00435                 * {@inheritDoc}
    00436                 */
    00437                 virtual bool isEmpty() const;
    00438
    00439                 /**
    00440                 * {@inheritDoc}
    00441                 */
    00442                 virtual bool contains(Object::View v) const;
    00443
    00444                 /**
    00445                 * {@inheritDoc}
    00446                 */
    00447                 virtual Iterator::Handle iterator() const;
    00448
    00449                 /**
    00450                 * {@inheritDoc}
    00451                 */
    00452                 virtual Muterator::Handle iterator();
    00453
    00454                 /**
    00455                 * {@inheritDoc}
    00456                 */
    00457                 virtual ObjectArray::Handle toArray(
    00458                         ObjectArray::Handle hao = NULL) const;
    00459
    00460                 /**
    00461                 * {@inheritDoc}
    00462                 */
    00463                 virtual bool add(Object::Holder oh);
    00464
    00465                 /**
    00466                 * {@inheritDoc}
    00467                 */
    00468                 virtual bool remove(Object::View v);
    00469
    00470                 /**
    00471                 * {@inheritDoc}
    00472                 */
    00473                 virtual bool containsAll(Collection::View vc) const;
    00474
    00475                 /**
    00476                 * {@inheritDoc}
    00477                 */
    00478                 virtual bool addAll(Collection::View vc);
    00479
    00480                 /**
    00481                 * {@inheritDoc}
    00482                 */
    00483                 virtual bool removeAll(Collection::View vc);
    00484
    00485                 /**
    00486                 * {@inheritDoc}
    00487                 */
    00488                 virtual bool retainAll(Collection::View vc);
    00489
    00490                 /**
    00491                 * {@inheritDoc}
    00492                 */
    00493                 virtual void clear();
    00494
    00495             // ----- Object interface -----------------------------------
    00496
    00497             public:
    00498                 /**
    00499                 * {@inheritDoc}
    00500                 */
    00501                 virtual void toStream(std::ostream& out) const;
    00502
    00503                 /**
    00504                 * {@inheritDoc}
    00505                 */
    00506                 virtual size32_t hashCode() const;
    00507
    00508                 /**
    00509                 * {@inheritDoc}
    00510                 */
    00511                 virtual bool equals(Object::View v) const;
    00512
    00513                 /**
    00514                 * {@inheritDoc}
    00515                 */
    00516                 virtual bool isImmutable() const;
    00517
    00518             // ----- accessors ------------------------------------------
    00519
    00520             protected:
    00521                 /**
    00522                 * Return a handle to the delegate.
    00523                 *
    00524                 * @return the delegate handle
    00525                 *
    00526                 * @throw UnsupportedOperationException if the delegate is a
    00527                 *        view
    00528                 */
    00529                 virtual Set::Handle getDelegate();
    00530
    00531                 /**
    00532                 * Return a view to the delegate.
    00533                 *
    00534                 * @return the delegate view
    00535                 */
    00536                 virtual Set::View getDelegate() const;
    00537
    00538             // ----- data members ---------------------------------------
    00539
    00540             private:
    00541                 /**
    00542                 * The Set to which this wrapper delegates.
    00543                 */
    00544                 FinalHolder<Set> m_ohDelegate;
    00545             };
    00546
    00547
    00548         /**
    00549         * List implementation which delegates all calls to another List.
    00550         */
    00551         class COH_EXPORT AbstractWrapperList
    00552             : public abstract_spec<AbstractWrapperList,
    00553                 extends<Object>,
    00554                 implements<List> >
    00555             {
    00556             // ----- constructors -------------------------------------------
    00557
    00558             protected:
    00559                 /**
    00560                 * Create an AbstractWrapperList which delegates to the
    00561                 * specified List.
    00562                 *
    00563                 * @param ohListDelegate  the List to delegate to
    00564                 */
    00565                 AbstractWrapperList(List::Holder ohListDelegate);
    00566
    00567                 /**
    00568                 * Copy constructor.
    00569                 */
    00570                 AbstractWrapperList(const AbstractWrapperList& that);
    00571
    00572
    00573             // ----- List interface ------------------------------------------
    00574
    00575             public:
    00576                 /**
    00577                 * {@inheritDoc}
    00578                 */
    00579                 virtual bool add(size32_t i, Object::Holder oh);
    00580
    00581                 /**
    00582                 * {@inheritDoc}
    00583                 */
    00584                 virtual bool addAll(size32_t i, Collection::View vc);
    00585
    00586                 /**
    00587                 * {@inheritDoc}
    00588                 */
    00589                 virtual Object::Holder get(size32_t i) const;
    00590
    00591                 /**
    00592                 * {@inheritDoc}
    00593                 */
    00594                 virtual Object::Holder get(size32_t i);
    00595
    00596                 /**
    00597                 * {@inheritDoc}
    00598                 */
    00599                 virtual size32_t indexOf(Object::View v) const;
    00600
    00601                 /**
    00602                 * {@inheritDoc}
    00603                 */
    00604                 virtual size32_t lastIndexOf(Object::View v) const;
    00605
    00606                 /**
    00607                 * {@inheritDoc}
    00608                 */
    00609                 virtual ListIterator::Handle listIterator() const;
    00610
    00611                 /**
    00612                 * {@inheritDoc}
    00613                 */
    00614                 virtual ListIterator::Handle listIterator(size32_t index) const;
    00615
    00616                 /**
    00617                 * {@inheritDoc}
    00618                 */
    00619                 virtual ListMuterator::Handle listIterator();
    00620
    00621                 /**
    00622                 * {@inheritDoc}
    00623                 */
    00624                 virtual ListMuterator::Handle listIterator(size32_t index);
    00625
    00626                 /**
    00627                 * {@inheritDoc}
    00628                 */
    00629                 virtual Object::Holder remove(size32_t idx);
    00630
    00631                 /**
    00632                 * {@inheritDoc}
    00633                 */
    00634                 virtual Object::Holder set(size32_t idx, Object::Holder oh);
    00635
    00636                 /**
    00637                 * {@inheritDoc}
    00638                 */
    00639                 virtual List::Handle subList(size32_t fromIndex,
    00640                         size32_t toIndex);
    00641
    00642                 /**
    00643                 * {@inheritDoc}
    00644                 */
    00645                 virtual List::View subList(size32_t fromIndex,
    00646                         size32_t toIndex) const;
    00647
    00648
    00649             // ----- Collection interface -----------------------------------
    00650
    00651             public:
    00652                 /**
    00653                 * {@inheritDoc}
    00654                 */
    00655                 virtual size32_t size() const;
    00656
    00657                 /**
    00658                 * {@inheritDoc}
    00659                 */
    00660                 virtual bool isEmpty() const;
    00661
    00662                 /**
    00663                 * {@inheritDoc}
    00664                 */
    00665                 virtual bool contains(Object::View v) const;
    00666
    00667                 /**
    00668                 * {@inheritDoc}
    00669                 */
    00670                 virtual bool containsAll(Collection::View vCol) const;
    00671
    00672                 /**
    00673                 * {@inheritDoc}
    00674                 */
    00675                 virtual Iterator::Handle iterator() const;
    00676
    00677                 /**
    00678                 * {@inheritDoc}
    00679                 */
    00680                 virtual Muterator::Handle iterator();
    00681
    00682                 /**
    00683                 * {@inheritDoc}
    00684                 */
    00685                 virtual ObjectArray::Handle toArray(
    00686                         ObjectArray::Handle hao = NULL) const;
    00687
    00688                 /**
    00689                 * {@inheritDoc}
    00690                 */
    00691                 virtual bool add(Object::Holder oh);
    00692
    00693                 /**
    00694                 * {@inheritDoc}
    00695                 */
    00696                 virtual bool addAll(Collection::View vCol);
    00697
    00698                 /**
    00699                 * {@inheritDoc}
    00700                 */
    00701                 virtual bool remove(Object::View v);
    00702
    00703                 /**
    00704                 * {@inheritDoc}
    00705                 */
    00706                 virtual bool removeAll(Collection::View vCol);
    00707
    00708                 /**
    00709                 * {@inheritDoc}
    00710                 */
    00711                 virtual bool retainAll(Collection::View vCol);
    00712
    00713                 /**
    00714                 * {@inheritDoc}
    00715                 */
    00716                 virtual void clear();
    00717
    00718
    00719             // ----- Object interface ---------------------------------------
    00720
    00721             public:
    00722                 /**
    00723                 * {@inheritDoc}
    00724                 */
    00725                 virtual void toStream(std::ostream& out) const;
    00726
    00727                 /**
    00728                 * {@inheritDoc}
    00729                 */
    00730                 virtual size32_t hashCode() const;
    00731
    00732                 /**
    00733                 * {@inheritDoc}
    00734                 */
    00735                 virtual bool equals(Object::View v) const;
    00736
    00737                 /**
    00738                 * {@inheritDoc}
    00739                 */
    00740                 virtual bool isImmutable() const;
    00741
    00742
    00743             // ----- helper methods -----------------------------------------
    00744
    00745             protected:
    00746                 /**
    00747                 * Return a handle to the delegate.
    00748                 *
    00749                 * @return the delegate handle
    00750                 *
    00751                 * @throw UnsupportedOperationException if the delegate is a
    00752                 *        view
    00753                 */
    00754                 virtual List::Handle getDelegate();
    00755
    00756                 /**
    00757                 * Return a view to the delegate.
    00758                 *
    00759                 * @return the delegate view
    00760                 */
    00761                 virtual List::View getDelegate() const;
    00762
    00763
    00764             // ----- data members -------------------------------------------
    00765
    00766             private:
    00767                 /**
    00768                 * The List to which this wrapper delegates.
    00769                 */
    00770                 FinalHolder<List> m_ohDelegate;
    00771             };
    00772
    00773         /**
    00774         * Map implementation which delegates all calls to another Map.
    00775         */
    00776         class COH_EXPORT AbstractWrapperMap
    00777             : public abstract_spec<AbstractWrapperMap,
    00778                 extends<Object>,
    00779                 implements<Map> >
    00780             {
    00781             // ----- constructors ---------------------------------------
    00782
    00783             protected:
    00784                 /**
    00785                 * Create an AbstractWrapperMap which delegates to the
    00786                 * specified Map.
    00787                 *
    00788                 * @param ohMapDelegate  the Map to delegate to
    00789                 */
    00790                 AbstractWrapperMap(Map::Holder ohMapDelegate);
    00791
    00792                 /**
    00793                 * Copy constructor.
    00794                 */
    00795                 AbstractWrapperMap(const AbstractWrapperMap& that);
    00796
    00797             // ----- Map interface --------------------------------------
    00798
    00799             public:
    00800                 /**
    00801                 * {@inheritDoc}
    00802                 */
    00803                 virtual size32_t size() const;
    00804
    00805                 /**
    00806                 * {@inheritDoc}
    00807                 */
    00808                 virtual bool isEmpty() const;
    00809
    00810                 /**
    00811                 * {@inheritDoc}
    00812                 */
    00813                 virtual bool containsKey(Object::View vKey) const;
    00814
    00815                 /**
    00816                 * {@inheritDoc}
    00817                 */
    00818                 virtual bool containsValue(Object::View vValue) const;
    00819
    00820                 /**
    00821                 * {@inheritDoc}
    00822                 */
    00823                 virtual Object::Holder get(Object::View vKey) const;
    00824
    00825                 /**
    00826                 * {@inheritDoc}
    00827                 */
    00828                 virtual Object::Holder get(Object::View vKey);
    00829
    00830                 /**
    00831                 * {@inheritDoc}
    00832                 */
    00833                 virtual Object::Holder put(Object::View vKey,
    00834                                          Object::Holder ohValue);
    00835
    00836                 /**
    00837                 * {@inheritDoc}
    00838                 */
    00839                 virtual Object::Holder remove(Object::View vKey);
    00840
    00841                 /**
    00842                 * {@inheritDoc}
    00843                 */
    00844                 virtual void putAll(Map::View vMap);
    00845
    00846                 /**
    00847                 * {@inheritDoc}
    00848                 */
    00849                 virtual void clear();
    00850
    00851                 /**
    00852                 * {@inheritDoc}
    00853                 */
    00854                 virtual Set::View keySet() const;
    00855
    00856                 /**
    00857                 * {@inheritDoc}
    00858                 */
    00859                 virtual Set::Handle keySet();
    00860
    00861                 /**
    00862                 * {@inheritDoc}
    00863                 */
    00864                 virtual Collection::View values() const;
    00865
    00866                 /**
    00867                 * {@inheritDoc}
    00868                 */
    00869                 virtual Collection::Handle values();
    00870
    00871                 /**
    00872                 * {@inheritDoc}
    00873                 */
    00874                 virtual Set::View entrySet() const;
    00875
    00876                 /**
    00877                 * {@inheritDoc}
    00878                 */
    00879                 virtual Set::Handle entrySet();
    00880
    00881             // ----- Object interface -----------------------------------
    00882
    00883             public:
    00884                 /**
    00885                 * {@inheritDoc}
    00886                 */
    00887                 virtual void toStream(std::ostream& out) const;
    00888
    00889                 /**
    00890                 * {@inheritDoc}
    00891                 */
    00892                 virtual size32_t hashCode() const;
    00893
    00894                 /**
    00895                 * {@inheritDoc}
    00896                 */
    00897                 virtual bool equals(Object::View v) const;
    00898
    00899                 /**
    00900                 * {@inheritDoc}
    00901                 */
    00902                 virtual bool isImmutable() const;
    00903
    00904             // ----- accessors ------------------------------------------
    00905
    00906             protected:
    00907                 /**
    00908                 * Return a handle to the delegate.
    00909                 *
    00910                 * @return the delegate handle
    00911                 *
    00912                 * @throw UnsupportedOperationException if the delegate is a
    00913                 *        view
    00914                 */
    00915                 virtual Map::Handle getDelegate();
    00916
    00917                 /**
    00918                 * Return a view to the delegate.
    00919                 *
    00920                 * @return the delegate view
    00921                 */
    00922                 virtual Map::View getDelegate() const;
    00923
    00924             // ----- data members ---------------------------------------
    00925
    00926             private:
    00927                 /**
    00928                 * The Map to which this wrapper delegates.
    00929                 */
    00930                 FinalHolder<Map> m_ohDelegate;
    00931             };
    00932
    00933
    00934     // ----- inner class: AbstractWrapperEntry ------------------------------
    00935
    00936     public:
    00937         /**
    00938         * Map#Entry implementation which delegates all calls to another
    00939         * Map#Entry.
    00940         */
    00941         class COH_EXPORT AbstractWrapperEntry
    00942             : public abstract_spec<AbstractWrapperEntry,
    00943                 extends<Object>,
    00944                 implements<Map::Entry> >
    00945             {
    00946             // ----- constructors ---------------------------------------
    00947
    00948             protected:
    00949                 /**
    00950                 * Create an AbstractWrapperEntry which delegates to the
    00951                 * specified Map#Entry.
    00952                 *
    00953                 * @param ohEntryDelegate  the Entry to delegate to
    00954                 */
    00955                 AbstractWrapperEntry(Map::Entry::Holder ohEntryDelegate);
    00956
    00957                 /**
    00958                 * Copy constructor.
    00959                 */
    00960                 AbstractWrapperEntry(const AbstractWrapperEntry& that);
    00961
    00962             // ----- Map::Entry interface -------------------------------
    00963
    00964             public:
    00965                 /**
    00966                 * {@inheritDoc}
    00967                 */
    00968                 virtual Object::View getKey() const;
    00969
    00970                 /**
    00971                 * {@inheritDoc}
    00972                 */
    00973                 virtual Object::Holder getValue() const;
    00974
    00975                 /**
    00976                 * {@inheritDoc}
    00977                 */
    00978                 virtual Object::Holder getValue();
    00979
    00980                 /**
    00981                 * {@inheritDoc}
    00982                 */
    00983                 virtual Object::Holder setValue(Object::Holder ohValue);
    00984
    00985             // ----- Object interface -----------------------------------
    00986
    00987             public:
    00988                 /**
    00989                 * {@inheritDoc}
    00990                 */
    00991                 virtual void toStream(std::ostream& out) const;
    00992
    00993                 /**
    00994                 * {@inheritDoc}
    00995                 */
    00996                 virtual size32_t hashCode() const;
    00997
    00998                 /**
    00999                 * {@inheritDoc}
    01000                 */
    01001                 virtual bool equals(Object::View v) const;
    01002
    01003                 /**
    01004                 * {@inheritDoc}
    01005                 */
    01006                 virtual bool isImmutable() const;
    01007
    01008             // ----- accessors ------------------------------------------
    01009
    01010             protected:
    01011                 /**
    01012                 * Return a handle to the delegate.
    01013                 *
    01014                 * @return the delegate handle
    01015                 *
    01016                 * @throw UnsupportedOperationException if the delegate is a
    01017                 *        view
    01018                 */
    01019                 virtual Map::Entry::Handle getDelegate();
    01020
    01021                 /**
    01022                 * Return a view to the delegate.
    01023                 *
    01024                 * @return the delegate view
    01025                 */
    01026                 virtual Map::Entry::View getDelegate() const;
    01027
    01028             // ----- data members ---------------------------------------
    01029
    01030             private:
    01031                 /**
    01032                 * The Map::Entry to which this wrapper delegates.
    01033                 */
    01034                 FinalHolder<Map::Entry> m_ohDelegate;
    01035             };
    01036     };
    01037
    01038 COH_CLOSE_NAMESPACE2
    01039
    01040 #endif // COH_WRAPPER_COLLECTIONS_HPP

Copyright © 2000, 2010, Oracle and/or its affiliates. All rights reserved.