Oracle Coherence for C++ API
Release 3.6.1.0
E18813-01

- Main Page
- Namespaces
- Classes
- Files

# coherence/util/ConverterCollections.hpp

    00001 /*
    00002 * ConverterCollections.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_CONVERTER_COLLECTIONS_HPP
    00017 #define COH_CONVERTER_COLLECTIONS_HPP
    00018
    00019 #include "coherence/lang.ns"
    00020
    00021
    00022 #include "coherence/net/cache/CacheEvent.hpp"
    00023 #include "coherence/net/cache/CacheMap.hpp"
    00024 #include "coherence/net/CacheService.hpp"
    00025 #include "coherence/net/NamedCache.hpp"
    00026 #include "coherence/util/Collection.hpp"
    00027 #include "coherence/util/ConcurrentMap.hpp"
    00028 #include "coherence/util/Converter.hpp"
    00029 #include "coherence/util/Filter.hpp"
    00030 #include "coherence/util/InvocableMap.hpp"
    00031 #include "coherence/util/Iterator.hpp"
    00032 #include "coherence/util/MapEvent.hpp"
    00033 #include "coherence/util/ObservableMap.hpp"
    00034 #include "coherence/util/Set.hpp"
    00035 #include "coherence/util/WrapperCollections.hpp"
    00036
    00037 COH_OPEN_NAMESPACE2(coherence,util)
    00038
    00039 using coherence::net::cache::CacheEvent;
    00040 using coherence::net::cache::CacheMap;
    00041 using coherence::net::CacheService;
    00042 using coherence::net::NamedCache;
    00043
    00044 /**
    00045 * A collection of Collection implementation classes that use the Converter
    00046 * interface to convert the items stored in underlying Collection objects.
    00047 *
    00048 * @author mf  2007.07.05
    00049 */
    00050 class COH_EXPORT ConverterCollections
    00051     {
    00052     // ----- ConverterCollections interface ---------------------------------
    00053     public:
    00054         /**
    00055         * Return a new lang#ObjectArray whose contents are the converted
    00056         * contents of the supplied array.
    00057         *
    00058         * @param hArray  the supplied array
    00059         * @param vConvUp the converter to use
    00060         *
    00061         * @return a handle to the converted array
    00062         */
    00063         static ObjectArray::Handle convertArray(ObjectArray::Handle hArray,
    00064                                                 Converter::View vConvUp);
    00065
    00066         /**
    00067         * Return a new lang#ObjectArray whose contents are the converted
    00068         * contents of the supplied array.
    00069         *
    00070         * @param vArray  the supplied array
    00071         * @param vConvUp the converter to use
    00072         *
    00073         * @return a view of the converted array
    00074         */
    00075         static ObjectArray::View convertArray(ObjectArray::View vArray,
    00076                                               Converter::View vConvUp);
    00077
    00078
    00079     // ----- inner classes --------------------------------------------------
    00080
    00081     public:
    00082         /**
    00083         * A ConverterIterator views an underlying Iterator through a
    00084         * Converter.
    00085         */
    00086         class COH_EXPORT ConverterIterator
    00087             : public cloneable_spec<ConverterIterator,
    00088                 extends<WrapperCollections::AbstractWrapperIterator> >
    00089             {
    00090             friend class factory<ConverterIterator>;
    00091
    00092             // ----- constructor ----------------------------------------
    00093
    00094             protected:
    00095                 /**
    00096                 * Create a WrapperCollections#AbstractWrapperIterator which
    00097                 * delegates to the specified Iterator.
    00098                 *
    00099                 * @param hiterDelegate the specified Iterator
    00100                 * @param vConvUp       the Converter to view through
    00101                 */
    00102                 ConverterIterator(Iterator::Handle hiterDelegate,
    00103                                   Converter::View vConvUp);
    00104
    00105                 /**
    00106                 * Copy constructor.
    00107                 */
    00108                 ConverterIterator(const ConverterIterator& that);
    00109
    00110             // ----- Iterator interface ---------------------------------
    00111
    00112             public:
    00113                 /**
    00114                 * {@inheritDoc}
    00115                 */
    00116                 virtual Object::Holder next();
    00117
    00118
    00119             // ----- data members ---------------------------------------
    00120
    00121             protected:
    00122                 /**
    00123                 * The Converter from the underlying container
    00124                 */
    00125                 FinalView<Converter> m_vConvUp;
    00126             };
    00127
    00128
    00129         /**
    00130         * A ConverterCollection views an underlying Collection through a
    00131         * Converter.
    00132         */
    00133         class COH_EXPORT ConverterCollection
    00134             : public cloneable_spec<ConverterCollection,
    00135                 extends<WrapperCollections::AbstractWrapperCollection> >
    00136             {
    00137             friend class factory<ConverterCollection>;
    00138
    00139             // ----- constructors ---------------------------------------
    00140
    00141             protected:
    00142                 /**
    00143                 * Create a WrapperCollections#AbstractWrapperCollection which
    00144                 * delegates to the specified Collection.
    00145                 *
    00146                 * @param hcollDelegate the specified collection
    00147                 * @param vConvUp       the converter from the underlying
    00148                 *                      Collection
    00149                 * @param vConvDown     the converter to the underlying
    00150                 *                      Collection
    00151                 */
    00152                 ConverterCollection(Collection::Handle hcollDelegate,
    00153                                     Converter::View vConvUp,
    00154                                     Converter::View vConvDown);
    00155
    00156                 /**
    00157                 * Create a WrapperCollections#AbstractWrapperCollection which
    00158                 * delegates to the specified Collection.
    00159                 *
    00160                 * @param vcollDelegate the specified collection
    00161                 * @param vConvUp       the converter from the underlying
    00162                 *                      Collection
    00163                 * @param vConvDown     the converter to the underlying
    00164                 *                      Collection
    00165                 */
    00166                 ConverterCollection(Collection::View vcollDelegate,
    00167                                     Converter::View vConvUp,
    00168                                     Converter::View vConvDown);
    00169
    00170                 /**
    00171                 * Copy constructor.
    00172                 */
    00173                 ConverterCollection(const ConverterCollection& that);
    00174
    00175
    00176             // ----- Collection interface -------------------------------
    00177
    00178             public:
    00179                 /**
    00180                 * {@inheritDoc}
    00181                 */
    00182                 virtual bool contains(Object::View v) const;
    00183
    00184                 /**
    00185                 * {@inheritDoc}
    00186                 */
    00187                 virtual Iterator::Handle iterator() const;
    00188
    00189                 /**
    00190                 * {@inheritDoc}
    00191                 */
    00192                 virtual Muterator::Handle iterator();
    00193
    00194                 /**
    00195                 * {@inheritDoc}
    00196                 */
    00197                 virtual ObjectArray::Handle toArray(
    00198                         ObjectArray::Handle hao = NULL) const;
    00199
    00200                 /**
    00201                 * {@inheritDoc}
    00202                 */
    00203                 virtual bool add(Object::Holder oh);
    00204
    00205                 /**
    00206                 * {@inheritDoc}
    00207                 */
    00208                 virtual bool remove(Object::View v);
    00209
    00210                 /**
    00211                 * {@inheritDoc}
    00212                 */
    00213                 virtual bool containsAll(Collection::View vc) const;
    00214
    00215                 /**
    00216                 * {@inheritDoc}
    00217                 */
    00218                 virtual bool addAll(Collection::View vc);
    00219
    00220                 /**
    00221                 * {@inheritDoc}
    00222                 */
    00223                 virtual bool removeAll(Collection::View vc);
    00224
    00225                 /**
    00226                 * {@inheritDoc}
    00227                 */
    00228                 virtual bool retainAll(Collection::View vc);
    00229
    00230             // ----- Object interface -----------------------------------
    00231
    00232             public:
    00233                 /**
    00234                 * {@inheritDoc}
    00235                 */
    00236                 virtual bool equals(Object::View that) const;
    00237
    00238                 /**
    00239                 * {@inheritDoc}
    00240                 */
    00241                 virtual size32_t hashCode() const;
    00242
    00243                 /**
    00244                 * {@inheritDoc}
    00245                 */
    00246                 virtual void toStream(std::ostream& out) const;
    00247
    00248             // ----- data members ---------------------------------------
    00249
    00250             protected:
    00251                 /**
    00252                 * The Converter from the underlying container
    00253                 */
    00254                 FinalView<Converter> m_vConvUp;
    00255
    00256                 /**
    00257                 * The Converter to the underlying container
    00258                 */
    00259                 FinalView<Converter> m_vConvDown;
    00260             };
    00261
    00262
    00263         /**
    00264         * A ConverterSet views an underlying Set through a Converter.
    00265         */
    00266         class COH_EXPORT ConverterSet
    00267             : public cloneable_spec<ConverterSet,
    00268                 extends<WrapperCollections::AbstractWrapperSet> >
    00269             {
    00270             friend class factory<ConverterSet>;
    00271
    00272             // ----- constructors ---------------------------------------
    00273
    00274             protected:
    00275                 /**
    00276                 * Create a WrapperCollections#AbstractWrapperSet which
    00277                 * delegates to the specified Set.
    00278                 *
    00279                 * @param hSet      the specified Set
    00280                 * @param vConvUp   the Converter from the underlying Set
    00281                 * @param vConvDown the Converter to the underlying Set
    00282                 */
    00283                 ConverterSet(Set::Handle hsetDelegate,
    00284                              Converter::View vConvUp,
    00285                              Converter::View vConvDown);
    00286
    00287                 /**
    00288                 * Create a WrapperCollections#AbstractWrapperSet which
    00289                 * delegates to the specified Set.
    00290                 *
    00291                 * @param vSet      the specified Set
    00292                 * @param vConvUp   the Converter from the underlying Set
    00293                 * @param vConvDown the Converter to the underlying Set
    00294                 */
    00295                 ConverterSet(Set::View vsetDelegate,
    00296                              Converter::View vConvUp,
    00297                              Converter::View vConvDown);
    00298
    00299                 /**
    00300                 * Copy constructor.
    00301                 */
    00302                 ConverterSet(const ConverterSet& that);
    00303
    00304             // ----- Set interface --------------------------------------
    00305
    00306             public:
    00307
    00308                 /**
    00309                 * {@inheritDoc}
    00310                 */
    00311                 virtual bool contains(Object::View v) const;
    00312
    00313                 /**
    00314                 * {@inheritDoc}
    00315                 */
    00316                 virtual Iterator::Handle iterator() const;
    00317
    00318                 /**
    00319                 * {@inheritDoc}
    00320                 */
    00321                 virtual Muterator::Handle iterator();
    00322
    00323                 /**
    00324                 * {@inheritDoc}
    00325                 */
    00326                 virtual ObjectArray::Handle toArray(
    00327                         ObjectArray::Handle hoa = NULL) const;
    00328
    00329                 /**
    00330                 * {@inheritDoc}
    00331                 */
    00332                 virtual bool add(Object::Holder oh);
    00333
    00334                 /**
    00335                 * {@inheritDoc}
    00336                 */
    00337                 virtual bool remove(Object::View v);
    00338
    00339                 /**
    00340                 * {@inheritDoc}
    00341                 */
    00342                 virtual bool containsAll(Collection::View vc) const;
    00343
    00344                 /**
    00345                 * {@inheritDoc}
    00346                 */
    00347                 virtual bool addAll(Collection::View vc);
    00348
    00349                 /**
    00350                 * {@inheritDoc}
    00351                 */
    00352                 virtual bool removeAll(Collection::View vc);
    00353
    00354                 /**
    00355                 * {@inheritDoc}
    00356                 */
    00357                 virtual bool retainAll(Collection::View vc);
    00358
    00359             // ----- Object interface -----------------------------------
    00360
    00361             public:
    00362                 /**
    00363                 * {@inheritDoc}
    00364                 */
    00365                 virtual bool equals(Object::View that) const;
    00366
    00367                 /**
    00368                 * {@inheritDoc}
    00369                 */
    00370                 virtual size32_t hashCode() const;
    00371
    00372                 /**
    00373                 * {@inheritDoc}
    00374                 */
    00375                 virtual void toStream(std::ostream& out) const;
    00376
    00377             // ----- data members ---------------------------------------
    00378
    00379             protected:
    00380                 /**
    00381                 * The Converter from the underlying Set
    00382                 */
    00383                 FinalView<Converter> m_vConvUp;
    00384
    00385                 /**
    00386                 * The Converter to the underlying Set
    00387                 */
    00388                 FinalView<Converter> m_vConvDown;
    00389             };
    00390
    00391
    00392         /**
    00393         * Map::Entry Converter, supporting key and value conversion.
    00394         */
    00395         class COH_EXPORT EntryConverter
    00396             : public class_spec<EntryConverter,
    00397                 extends<Object>,
    00398                 implements<Converter> >
    00399             {
    00400             friend class factory<EntryConverter>;
    00401
    00402             // ----- constructor ----------------------------------------
    00403
    00404             public:
    00405                 /**
    00406                 * Create a Map entry Converter.
    00407                 *
    00408                 * @param vConvKey   the key Converter
    00409                 * @param vConvVal   the value Converter
    00410                 */
    00411                 EntryConverter(Converter::View vConvKey,
    00412                         Converter::View vConvVal);
    00413
    00414                 /**
    00415                 * Copy constructor.
    00416                 */
    00417                 EntryConverter(const EntryConverter& that);
    00418
    00419             // ----- Converter interface --------------------------------
    00420
    00421             public:
    00422                 /**
    00423                 * {@inheritDoc}
    00424                 */
    00425                 virtual Object::Holder convert(Object::Holder oh) const;
    00426
    00427             // ----- EntryConverter interface ---------------------------
    00428
    00429             public:
    00430                 /**
    00431                 * @return a view of the key Converter
    00432                 */
    00433                 virtual Converter::View getKeyConverter() const;
    00434
    00435                 /**
    00436                 * @return a view of the value Converter
    00437                 */
    00438                 virtual Converter::View getValueConverter() const;
    00439
    00440             // ----- static helper methods ------------------------------
    00441
    00442             public:
    00443                 /**
    00444                 * @param vConvert the EntryConverter
    00445                 *
    00446                 * @return a view of the vConvert's key Converter
    00447                 */
    00448                 static Converter::View getKeyConverter
    00449                     (EntryConverter::View vConvert);
    00450
    00451                 /**
    00452                 * @param vConvert the EntryConverter
    00453                 *
    00454                 * @return a view of the vConvert's value Converter
    00455                 */
    00456                 static Converter::View getValueConverter
    00457                     (EntryConverter::View vConvert);
    00458
    00459                 /**
    00460                 * Convert the key of the map entry referenced by the
    00461                 * supplied handle using the supplied EntryConverter.
    00462                 *
    00463                 * @param vConvert a view of the EntryConverter to use
    00464                 * @param vKey     a view to the key to convert
    00465                 *
    00466                 * @return a handle to the key, or the unconverted key
    00467                 *         if the vConvert is NULL
    00468                 */
    00469                 static Object::View convertKey
    00470                     (EntryConverter::View vConvert, Object::View vKey);
    00471
    00472                 /**
    00473                 * Convert the value of the map entry referenced by
    00474                 * the supplied view using the supplied
    00475                 * EntryConverter.
    00476                 *
    00477                 * @param vConvert  a view of the EntryConverter to
    00478                 *                  use
    00479                 * @param ohValue   a holder to the value to convert
    00480                 *
    00481                 * @return a view of the value, or the unconverted
    00482                 *         value if the vConvert is NULL
    00483                 */
    00484                 static Object::Holder convertValue
    00485                     (EntryConverter::View vConvert, Object::Holder ohValue);
    00486
    00487             // ----- data members ---------------------------------------
    00488
    00489             protected:
    00490                 /**
    00491                 * The key Converter.
    00492                 */
    00493                 FinalView<Converter> m_vConvKey;
    00494
    00495                 /**
    00496                 * The value Converter.
    00497                 */
    00498                 FinalView<Converter> m_vConvVal;
    00499             };
    00500
    00501
    00502         /**
    00503         * A ConverterMap views an underlying Map through a Converter.
    00504         */
    00505         class COH_EXPORT ConverterMap
    00506             : public cloneable_spec<ConverterMap,
    00507                 extends<WrapperCollections::AbstractWrapperMap> >
    00508             {
    00509             friend class factory<ConverterMap>;
    00510
    00511             // ----- constructors ---------------------------------------
    00512
    00513             protected:
    00514                 /**
    00515                 * Create a WrapperCollections#AbstractWrapperMap which
    00516                 * delegates to the specified Map.
    00517                 *
    00518                 * @param hMap      the specified Map
    00519                 * @param vConvUp   the EntryConverter from the underlying Map
    00520                 * @param vConvDown the EntryConverter to the underlying Map
    00521                 */
    00522                 ConverterMap(Map::Handle hMapDelegate,
    00523                              EntryConverter::View vConvUp,
    00524                              EntryConverter::View vConvDown);
    00525
    00526                 /**
    00527                 * Create a WrapperCollections#AbstractWrapperMap which
    00528                 * delegates to the specified Map.
    00529                 *
    00530                 * @param vMap      the specified Map
    00531                 * @param vConvUp   the EntryConverter from the underlying Map
    00532                 * @param vConvDown the EntryConverter to the underlying Map
    00533                 */
    00534                 ConverterMap(Map::View vMapDelegate,
    00535                              EntryConverter::View vConvUp,
    00536                              EntryConverter::View vConvDown);
    00537
    00538                 /**
    00539                 * Copy constructor.
    00540                 */
    00541                 ConverterMap(const ConverterMap& that);
    00542
    00543             // ----- Map interface --------------------------------------
    00544
    00545             public:
    00546                 /**
    00547                 * {@inheritDoc}
    00548                 */
    00549                 virtual bool containsKey(Object::View vKey) const;
    00550
    00551                 /**
    00552                 * {@inheritDoc}
    00553                 */
    00554                 virtual bool containsValue(Object::View vValue) const;
    00555
    00556                 /**
    00557                 * {@inheritDoc}
    00558                 */
    00559                 virtual Object::Holder get(Object::View vKey) const;
    00560
    00561                 /**
    00562                 * {@inheritDoc}
    00563                 */
    00564                 using Map::get;
    00565
    00566                 /**
    00567                 * {@inheritDoc}
    00568                 */
    00569                 virtual Object::Holder put(Object::View vKey,
    00570                                          Object::Holder ohValue);
    00571
    00572                 /**
    00573                 * {@inheritDoc}
    00574                 */
    00575                 virtual Object::Holder remove(Object::View vKey);
    00576
    00577                 /**
    00578                 * {@inheritDoc}
    00579                 */
    00580                 virtual void putAll(Map::View vMap);
    00581
    00582                 /**
    00583                 * {@inheritDoc}
    00584                 */
    00585                 virtual Set::View keySet() const;
    00586
    00587                 /**
    00588                 * {@inheritDoc}
    00589                 */
    00590                 virtual Set::Handle keySet();
    00591
    00592                 /**
    00593                 * {@inheritDoc}
    00594                 */
    00595                 virtual Collection::View values() const;
    00596
    00597                 /**
    00598                 * {@inheritDoc}
    00599                 */
    00600                 virtual Collection::Handle values();
    00601
    00602                 /**
    00603                 * {@inheritDoc}
    00604                 */
    00605                 virtual Set::View entrySet() const;
    00606
    00607                 /**
    00608                 * {@inheritDoc}
    00609                 */
    00610                 virtual Set::Handle entrySet();
    00611
    00612             // ----- Object interface -----------------------------------
    00613
    00614             public:
    00615                 /**
    00616                 * {@inheritDoc}
    00617                 */
    00618                 virtual bool equals(Object::View that) const;
    00619
    00620                 /**
    00621                 * {@inheritDoc}
    00622                 */
    00623                 virtual size32_t hashCode() const;
    00624
    00625                 /**
    00626                 * {@inheritDoc}
    00627                 */
    00628                 virtual void toStream(std::ostream& out) const;
    00629
    00630             // ----- accessors ------------------------------------------
    00631
    00632             public:
    00633                 /**
    00634                 * Get the up converter, which is used to convert from the
    00635                 * underlying entries in the Map.
    00636                 *
    00637                 * @return the up converter
    00638                 */
    00639                 virtual EntryConverter::View getUpConverter() const;
    00640
    00641                 /**
    00642                 * Get the down converter, which is used to convert to the
    00643                 * underlying entries in the Map.
    00644                 *
    00645                 * @return the down converter
    00646                 */
    00647                 virtual EntryConverter::View getDownConverter() const;
    00648
    00649             // ----- data members ---------------------------------------
    00650
    00651             protected:
    00652                 /**
    00653                 * The Converter from the underlying entries in the Map
    00654                 */
    00655                 FinalView<EntryConverter> m_vConvUp;
    00656
    00657                 /**
    00658                 * The Converter to the underlying entries in the Map
    00659                 */
    00660                 FinalView<EntryConverter> m_vConvDown;
    00661             };
    00662
    00663
    00664         /**
    00665         * A ConverterEntry views an underlying Map#Entry through a Converter.
    00666         */
    00667         class COH_EXPORT ConverterEntry
    00668             : public cloneable_spec<ConverterEntry,
    00669                 extends<WrapperCollections::AbstractWrapperEntry> >
    00670             {
    00671             friend class factory<ConverterEntry>;
    00672
    00673             // ----- constructors ---------------------------------------
    00674
    00675             protected:
    00676                 /**
    00677                 * Create a WrapperCollections::AbstractWrapperEntry which
    00678                 * delegates to the specified Map#Entry.
    00679                 *
    00680                 * @param hMapEntry  a handle to the specified Map#Entry
    00681                 * @param vConvUp    the EntryConverter from the underlying
    00682                 *                   Map
    00683                 * @param vConvDown  the EntryConverter to the underlying Map
    00684                 */
    00685                 ConverterEntry(Map::Entry::Handle hMapDelegate,
    00686                              EntryConverter::View vConvUp,
    00687                              EntryConverter::View vConvDown);
    00688
    00689                 /**
    00690                 * Create a WrapperCollections::AbstractWrapperEntry which
    00691                 * delegates to the specified Map#Entry.
    00692                 *
    00693                 * @param vMapEntry  a view of the specified Map#Entry
    00694                 * @param vConvUp    the EntryConverter from the underlying
    00695                 *                   Map
    00696                 * @param vConvDown  the EntryConverter to the underlying Map
    00697                 */
    00698                 ConverterEntry(Map::Entry::View vMapDelegate,
    00699                              EntryConverter::View vConvUp,
    00700                              EntryConverter::View vConvDown);
    00701
    00702                 /**
    00703                 * Copy constructor.
    00704                 */
    00705                 ConverterEntry(const ConverterEntry& that);
    00706
    00707
    00708             // ----- Map::Entry interface -------------------------------
    00709
    00710             public:
    00711                 /**
    00712                 * {@inheritDoc}
    00713                 */
    00714                 virtual Object::View getKey() const;
    00715
    00716                 /**
    00717                 * {@inheritDoc}
    00718                 */
    00719                 virtual Object::Holder getValue() const;
    00720
    00721                 /**
    00722                 * {@inheritDoc}
    00723                 */
    00724                 using Map::Entry::getValue;
    00725
    00726                 /**
    00727                 * {@inheritDoc}
    00728                 */
    00729                 virtual Object::Holder setValue(Object::Holder ohValue);
    00730
    00731             // ----- Object interface -----------------------------------
    00732
    00733             public:
    00734                 /**
    00735                 * {@inheritDoc}
    00736                 */
    00737                 virtual bool equals(Object::View that) const;
    00738
    00739                 /**
    00740                 * {@inheritDoc}
    00741                 */
    00742                 virtual size32_t hashCode() const;
    00743
    00744
    00745                 /**
    00746                 * {@inheritDoc}
    00747                 */
    00748                 virtual void toStream(std::ostream& out) const;
    00749
    00750             // ----- data members ---------------------------------------
    00751
    00752             protected:
    00753                 /**
    00754                 * The Converter from the underlying Entry.
    00755                 */
    00756                 FinalView<EntryConverter> m_vConvUp;
    00757
    00758                 /**
    00759                 * The Converter from the underlying Entry.
    00760                 */
    00761                 FinalView<EntryConverter> m_vConvDown;
    00762             };
    00763
    00764
    00765         // ----- inner class: ConverterCacheEvent ---------------------------
    00766
    00767         /**
    00768         * A Converter CacheEvent views an underlying CacheEvent through a set
    00769         * of key and value Converters.
    00770         */
    00771         class COH_EXPORT ConverterCacheEvent
    00772             : public class_spec<ConverterCacheEvent,
    00773                 extends<CacheEvent> >
    00774             {
    00775             friend class factory<ConverterCacheEvent>;
    00776
    00777             // ----- constructors ---------------------------------------
    00778
    00779             protected:
    00780                 /**
    00781                 * Create a ConverterCacheEvent.
    00782                 *
    00783                 * @param hMap      the new event's source
    00784                 * @param vEvent    the underlying CacheEvent
    00785                 * @param vConvKey  the Converter to view the underlying
    00786                 *                  CacheEvent's key
    00787                 * @param vConvVal  the Converter to view the underlying
    00788                 *                  CacheEvent's values
    00789                 */
    00790                 ConverterCacheEvent(ObservableMap::Handle hMap,
    00791                         CacheEvent::View vEvent, Converter::View vConvKey,
    00792                         Converter::View vConvVal);
    00793
    00794             // ----- MapEvent interface ---------------------------------
    00795
    00796             public:
    00797                 /**
    00798                 * {@inheritDoc}
    00799                 */
    00800                 virtual Object::View getKey() const;
    00801
    00802                 /**
    00803                 * {@inheritDoc}
    00804                 */
    00805                 virtual Object::View getOldValue() const;
    00806
    00807                 /**
    00808                 * {@inheritDoc}
    00809                 */
    00810                 virtual Object::View getNewValue() const;
    00811
    00812             // ----- accessors ------------------------------------------
    00813
    00814             public:
    00815                 /**
    00816                 * Return the underlying CacheEvent.
    00817                 *
    00818                 * @return the underlying CacheEvent
    00819                 */
    00820                 virtual CacheEvent::View getCacheEvent() const;
    00821
    00822                 /**
    00823                 * Return the Converter used to view the underlying
    00824                 * CacheEvent's key through.
    00825                 *
    00826                 * @return the Converter from the underlying CacheEvent's key
    00827                 */
    00828                 virtual Converter::View getConverterKeyUp() const;
    00829
    00830                 /**
    00831                 * Return the Converter used to view the underlying
    00832                 * CacheEvent's value through.
    00833                 *
    00834                 * @return the Converter from the underlying CacheEvent's
    00835                 *         value
    00836                 */
    00837                 virtual Converter::View getConverterValueUp() const;
    00838
    00839                 /**
    00840                 * Set the cached converted old value associated with this
    00841                 * event.
    00842                 *
    00843                 * @param voValue the new converted "old" value
    00844                 */
    00845                 virtual void setOldValue(Object::View voValue);
    00846
    00847                 /**
    00848                 * Set the cached converted new value associated with this
    00849                 * event.
    00850                 *
    00851                 * @param voValue the new converted "new" value
    00852                 */
    00853                 virtual void setNewValue(Object::View voValue);
    00854
    00855             // ----- data members ---------------------------------------
    00856
    00857             protected:
    00858                 /**
    00859                 * The underlying CacheEvent.
    00860                 */
    00861                 MemberView<CacheEvent> m_vEvent;
    00862
    00863                 /**
    00864                 * The Converter to view the underlying CacheEvent's key.
    00865                 */
    00866                 MemberView<Converter> m_vConvKey;
    00867
    00868                 /**
    00869                 * The Converter to view the underlying CacheEvent's value.
    00870                 */
    00871                 MemberView<Converter> m_vConvVal;
    00872             };
    00873
    00874
    00875         // ----- inner class: ConverterMapEvent -----------------------------
    00876
    00877         /**
    00878         * A Converter MapEvent views an underlying MapEvent through a set of
    00879         * key and value Converters.
    00880         */
    00881         class COH_EXPORT ConverterMapEvent
    00882             : public class_spec<ConverterMapEvent,
    00883                 extends<MapEvent> >
    00884             {
    00885             friend class factory<ConverterMapEvent>;
    00886
    00887             // ----- constructors ---------------------------------------
    00888
    00889             protected:
    00890                 /**
    00891                 * Create a ConverterMapEvent.
    00892                 *
    00893                 * @param hMap      the new event's source
    00894                 * @param vEvent    the underlying MapEvent
    00895                 * @param vConvKey  the Converter to view the underlying
    00896                 *                  MapEvent's key
    00897                 * @param vConvVal  the Converter to view the underlying
    00898                 *                  MapEvent's values
    00899                 */
    00900                 ConverterMapEvent(ObservableMap::Handle hMap,
    00901                         MapEvent::View vEvent, Converter::View vConvKey,
    00902                         Converter::View vConvVal);
    00903
    00904             // ----- MapEvent interface ---------------------------------
    00905
    00906             public:
    00907                 /**
    00908                 * {@inheritDoc}
    00909                 */
    00910                 virtual Object::View getKey() const;
    00911
    00912                 /**
    00913                 * {@inheritDoc}
    00914                 */
    00915                 virtual Object::View getOldValue() const;
    00916
    00917                 /**
    00918                 * {@inheritDoc}
    00919                 */
    00920                 virtual Object::View getNewValue() const;
    00921
    00922             // ----- accessors ------------------------------------------
    00923
    00924             public:
    00925                 /**
    00926                 * Return the underlying MapEvent.
    00927                 *
    00928                 * @return the underlying MapEvent
    00929                 */
    00930                 virtual MapEvent::View getMapEvent() const;
    00931
    00932                 /**
    00933                 * Return the Converter used to view the underlying MapEvent's
    00934                 * key through.
    00935                 *
    00936                 * @return the Converter from the underlying MapEvent's key
    00937                 */
    00938                 virtual Converter::View getConverterKeyUp() const;
    00939
    00940                 /**
    00941                 * Return the Converter used to view the underlying MapEvent's
    00942                 * value through.
    00943                 *
    00944                 * @return the Converter from the underlying MapEvent's value
    00945                 */
    00946                 virtual Converter::View getConverterValueUp() const;
    00947
    00948                 /**
    00949                 * Set the cached converted key associated with this event.
    00950                 *
    00951                 * @param voKey the converted key value
    00952                 */
    00953                 virtual void setKey(Object::View voKey);
    00954
    00955                 /**
    00956                 * Set the cached converted old value associated with this
    00957                 * event.
    00958                 *
    00959                 * @param voValue the new converted "old" value
    00960                 */
    00961                 virtual void setOldValue(Object::View voValue);
    00962
    00963                 /**
    00964                 * Set the cached converted new value associated with this
    00965                 * event.
    00966                 *
    00967                 * @param voValue the new converted "new" value
    00968                 */
    00969                 virtual void setNewValue(Object::View voValue);
    00970
    00971                 /**
    00972                 * Check if the event's key has been converted.
    00973                 *
    00974                 * @return true iff the key has been converted
    00975                 */
    00976                 virtual bool isKeyConverted() const;
    00977
    00978                 /**
    00979                 * Check if the event's old value has been converted.
    00980                 *
    00981                 * @return true iff the old value has been converted
    00982                 */
    00983                 virtual bool isOldValueConverted() const;
    00984
    00985                 /**
    00986                 * Check if the event's new value has been converted.
    00987                 *
    00988                 * @return true iff the new value has been converted
    00989                 */
    00990                 virtual bool isNewValueConverted() const;
    00991
    00992             // ----- data members ---------------------------------------
    00993
    00994             protected:
    00995                 /**
    00996                 * The underlying MapEvent.
    00997                 */
    00998                 MemberView<MapEvent> m_vEvent;
    00999
    01000                 /**
    01001                 * The Converter to view the underlying MapEvent's key.
    01002                 */
    01003                 MemberView<Converter> m_vConvKey;
    01004
    01005                 /**
    01006                 * The Converter to view the underlying MapEvent's value.
    01007                 */
    01008                 MemberView<Converter> m_vConvVal;
    01009             };
    01010
    01011
    01012         // ----- inner class: ConverterMapListener --------------------------
    01013
    01014         /**
    01015         * A converter MapListener that converts events of the underlying
    01016         * MapListener for the underlying map.
    01017         */
    01018         class COH_EXPORT ConverterMapListener
    01019             : public class_spec<ConverterMapListener,
    01020                 extends<Object>,
    01021                 implements<MapListener> >
    01022             {
    01023             friend class factory<ConverterMapListener>;
    01024
    01025             // ----- constructors ---------------------------------------
    01026
    01027             protected:
    01028                 /**
    01029                 * Create a ConverterMapListener that converts events of the
    01030                 * underlying MapListener for the underlying map.
    01031                 */
    01032                 ConverterMapListener(ObservableMap::Handle hMap,
    01033                         MapListener::Handle hListener, Converter::View vConvKey,
    01034                         Converter::View vConvVal);
    01035
    01036             // ----- MapListener interface ------------------------------
    01037
    01038             public:
    01039                 /**
    01040                 * {@inheritDoc}
    01041                 */
    01042                 virtual void entryInserted(MapEvent::View vEvent);
    01043
    01044                 /**
    01045                 * {@inheritDoc}
    01046                 */
    01047                 virtual void entryUpdated(MapEvent::View vEvent);
    01048
    01049                 /**
    01050                 * {@inheritDoc}
    01051                 */
    01052                 virtual void entryDeleted(MapEvent::View vEvent);
    01053
    01054             // ----- Object interface -----------------------------------
    01055
    01056             public:
    01057                 /**
    01058                 * {@inheritDoc}
    01059                 */
    01060                 virtual bool equals(Object::View v) const;
    01061
    01062                 /**
    01063                 * {@inheritDoc}
    01064                 */
    01065                 virtual size32_t hashCode() const;
    01066
    01067             // ----- accessors ------------------------------------------
    01068
    01069             public:
    01070                 /**
    01071                 * Get the underlying ObservableMap.
    01072                 *
    01073                 * @return the underlying map
    01074                 */
    01075                 virtual ObservableMap::Handle getObservableMap();
    01076
    01077                 /**
    01078                 * Get the underlying ObservableMap.
    01079                 *
    01080                 * @return the underlying map
    01081                 */
    01082                 virtual ObservableMap::View getObservableMap() const;
    01083
    01084                 /**
    01085                 * Get the underling MapListener.
    01086                 *
    01087                 * @return the underlying listener
    01088                 */
    01089                 virtual MapListener::Handle getMapListener();
    01090
    01091                 /**
    01092                 * Get the underling MapListener.
    01093                 *
    01094                 * @return the underlying listener
    01095                 */
    01096                 virtual MapListener::View getMapListener() const;
    01097
    01098                 /**
    01099                 * Get the Converter used to view an underlying CacheEvent's
    01100                 * key through.
    01101                 *
    01102                 * @return the Converter used to view an underlying
    01103                 *         CacheEvent's key
    01104                 */
    01105                 virtual Converter::View getConverterKeyUp() const;
    01106
    01107                 /**
    01108                 * Get the Converter used to view an underlying CacheEvent's
    01109                 * value through.
    01110                 *
    01111                 * @return the Converter used to view an underlying
    01112                 *         CacheEvent's value
    01113                 */
    01114                 virtual Converter::View getConverterValueUp() const;
    01115
    01116             // ----- data members -------------------------------------------
    01117
    01118             protected:
    01119                 /**
    01120                 * The converting Map the will be the source of converted
    01121                 * events.
    01122                 */
    01123                 MemberHandle<ObservableMap> m_hMap;
    01124
    01125                 /**
    01126                 * The underlying MapListener.
    01127                 */
    01128                 MemberHandle<MapListener> m_hListener;
    01129
    01130                 /**
    01131                 * The Converter to view an underlying CacheEvent's key.
    01132                 */
    01133                 MemberView<Converter> m_vConvKey;
    01134
    01135                 /**
    01136                 * The Converter to view an underlying CacheEvent's value.
    01137                 */
    01138                 MemberView<Converter> m_vConvVal;
    01139             };
    01140
    01141
    01142         // ----- inner class: ConverterObservableMap ------------------------
    01143
    01144         /**
    01145         * A Converter ObservableMap views an underlying ObservableMap through
    01146         * a set of key and value Converters.
    01147         */
    01148         class COH_EXPORT ConverterObservableMap
    01149             : public class_spec<ConverterObservableMap,
    01150                 extends<ConverterMap>,
    01151                 implements<ObservableMap> >
    01152             {
    01153             friend class factory<ConverterObservableMap>;
    01154
    01155             // ----- constructors ---------------------------------------
    01156
    01157             protected:
    01158                 /**
    01159                 * Create a ConverterObservableMap which delegates to the
    01160                 * specified ObservableMap.
    01161                 *
    01162                 * @param hMap      underlying ObservableMap
    01163                 * @param vConvUp   EntryConverter from the underlying Map
    01164                 * @param vConvDown EntryConverter to the underlying Map
    01165                 */
    01166                 ConverterObservableMap(ObservableMap::Handle hMap,
    01167                         EntryConverter::View vConvUp,
    01168                         EntryConverter::View vConvDown);
    01169
    01170                 /**
    01171                 * Create a ConverterObservableMap which delegates to the
    01172                 * specified ObservableMap.
    01173                 *
    01174                 * @param vMap      underlying ObservableMap
    01175                 * @param vConvUp   EntryConverter from the underlying Map
    01176                 * @param vConvDown EntryConverter to the underlying Map
    01177                 */
    01178                 ConverterObservableMap(ObservableMap::View vMap,
    01179                         EntryConverter::View vConvUp,
    01180                         EntryConverter::View vConvDown);
    01181
    01182             // ----- ObservableMap interface ----------------------------
    01183
    01184             public:
    01185                 /**
    01186                 * {@inheritDoc}
    01187                 */
    01188                 virtual void addKeyListener(MapListener::Handle hListener,
    01189                         Object::View vKey, bool fLite);
    01190
    01191                 /**
    01192                 * {@inheritDoc}
    01193                 */
    01194                 virtual void removeKeyListener(MapListener::Handle hListener,
    01195                         Object::View vKey);
    01196
    01197                 /**
    01198                 * {@inheritDoc}
    01199                 */
    01200                 virtual void addFilterListener(MapListener::Handle hListener,
    01201                         Filter::View vFilter, bool fLite);
    01202
    01203                 /**
    01204                 * {@inheritDoc}
    01205                 */
    01206                 virtual void removeFilterListener(
    01207                         MapListener::Handle hListener, Filter::View vFilter);
    01208
    01209             // ----- helper methods -------------------------------------
    01210
    01211             protected:
    01212                 /**
    01213                 * Create a converter listener for the specified listener.
    01214                 *
    01215                 * @param hListener  the underlying listener
    01216                 *
    01217                 * @return the converting listener
    01218                 */
    01219                 virtual MapListener::Handle getConverterListener(
    01220                         MapListener::Handle hListener);
    01221
    01222             // ----- accessors ------------------------------------------
    01223
    01224             public:
    01225                 /**
    01226                 * Return the underlying ObservableMap.
    01227                 *
    01228                 * @return the underlying ObservableMap
    01229                 */
    01230                 virtual ObservableMap::Handle getObservableMap();
    01231
    01232                 /**
    01233                 * Return the underlying ObservableMap.
    01234                 *
    01235                 * @return the underlying ObservableMap
    01236                 */
    01237                 virtual ObservableMap::View getObservableMap() const;
    01238             };
    01239
    01240
    01241         // ----- inner class: ConverterCacheMap -----------------------------
    01242
    01243         /**
    01244         * A ConverterCacheMap views an underlying CacheMap through a set
    01245         * of key and value Converters.
    01246         */
    01247         class COH_EXPORT ConverterCacheMap
    01248             : public class_spec<ConverterCacheMap,
    01249                 extends<ConverterObservableMap>,
    01250                 implements<CacheMap> >
    01251             {
    01252             friend class factory<ConverterCacheMap>;
    01253
    01254             // ----- constructors ---------------------------------------
    01255
    01256             protected:
    01257                 /**
    01258                 * Create a ConverterCacheMap which delegates to the specified
    01259                 * CacheMap.
    01260                 *
    01261                 * @param hMap      the specified CacheMap
    01262                 * @param vConvUp   the EntryConverter from the underlying
    01263                 *                  Map
    01264                 * @param vConvDown the EntryConverter to the underlying
    01265                 *                  Map
    01266                 */
    01267                 ConverterCacheMap(CacheMap::Handle hMapDelegate,
    01268                              EntryConverter::View vConvUp,
    01269                              EntryConverter::View vConvDown);
    01270
    01271                 /**
    01272                 * Create a ConverterCacheMap which delegates to the specified
    01273                 * CacheMap.
    01274                 *
    01275                 * @param vMap      the specified CacheMap
    01276                 * @param vConvUp   the EntryConverter from the underlying
    01277                 *                  Map
    01278                 * @param vConvDown the EntryConverter to the underlying
    01279                 *                  Map
    01280                 */
    01281                 ConverterCacheMap(CacheMap::View vMapDelegate,
    01282                              EntryConverter::View vConvUp,
    01283                              EntryConverter::View vConvDown);
    01284
    01285             // ----- CacheMap interface -----------------------------
    01286
    01287             public:
    01288                 /**
    01289                 * {@inheritDoc}
    01290                 */
    01291                 virtual Map::View getAll(Collection::View vKeys) const;
    01292
    01293                 /**
    01294                 * {@inheritDoc}
    01295                 */
    01296                 using ConverterMap::put;
    01297
    01298                 /**
    01299                 * {@inheritDoc}
    01300                 */
    01301                 virtual Object::Holder put(Object::View vKey,
    01302                         Object::Holder ohValue, int64_t cMillis);
    01303
    01304                 // ----- accessors --------------------------------------
    01305
    01306                 /**
    01307                 * Return the underlying CacheMap.
    01308                 *
    01309                 * @return the underlying CacheMap
    01310                 */
    01311                 virtual CacheMap::View getCacheMap() const;
    01312
    01313                 /**
    01314                 * Return the underlying CacheMap.
    01315                 *
    01316                 * @return the underlying CacheMap
    01317                 */
    01318                 virtual CacheMap::Handle getCacheMap();
    01319             };
    01320
    01321         /**
    01322         * A Converter ConverterConcurrentMap views an underlying
    01323         * ConcurrentMap through a set of key and value Converters.
    01324         */
    01325         class COH_EXPORT ConverterConcurrentMap
    01326             : public class_spec<ConverterConcurrentMap,
    01327                 extends<ConverterMap>,
    01328                 implements<ConcurrentMap> >
    01329             {
    01330             friend class factory<ConverterConcurrentMap>;
    01331
    01332             // ----- constructors ---------------------------------------
    01333
    01334             protected:
    01335                 /**
    01336                 * Create a ConverterConcurrentMap which delegates to the
    01337                 * specified ConcurrentMap.
    01338                 *
    01339                 * @param hMap      the specified ConcurrentMap
    01340                 * @param vConvUp   the EntryConverter from the underlying
    01341                 *                  Map
    01342                 * @param vConvDown the EntryConverter to the underlying
    01343                 *                  Map
    01344                 */
    01345                 ConverterConcurrentMap(ConcurrentMap::Handle hMapDelegate,
    01346                              EntryConverter::View vConvUp,
    01347                              EntryConverter::View vConvDown);
    01348
    01349                 /**
    01350                 * Create a ConverterConcurrentMap which delegates to the
    01351                 * specified ConcurrentMap.
    01352                 *
    01353                 * @param vMap      the specified ConcurrentMap
    01354                 * @param vConvUp   the EntryConverter from the underlying
    01355                 *                  Map
    01356                 * @param vConvDown the EntryConverter to the underlying
    01357                 *                  Map
    01358                 */
    01359                 ConverterConcurrentMap(ConcurrentMap::View vMapDelegate,
    01360                              EntryConverter::View vConvUp,
    01361                              EntryConverter::View vConvDown);
    01362
    01363             // ----- ConcurrentMap interface ----------------------------
    01364
    01365             public:
    01366                 /**
    01367                 * {@inheritDoc}
    01368                 */
    01369                 virtual bool lock(Object::View vKey, int64_t cWait) const;
    01370
    01371                 /**
    01372                 * {@inheritDoc}
    01373                 */
    01374                 virtual bool lock(Object::View vKey) const;
    01375
    01376                 /**
    01377                 * {@inheritDoc}
    01378                 */
    01379                 virtual bool unlock(Object::View vKey) const;
    01380
    01381             // ----- accessors ------------------------------------------
    01382
    01383             public:
    01384                 /**
    01385                 * Return the underlying ConcurrentMap.
    01386                 *
    01387                 * @return the underlying ConcurrentMap
    01388                 */
    01389                 virtual ConcurrentMap::View getConcurrentMap() const;
    01390
    01391                 /**
    01392                 * Return the underlying ConcurrentMap.
    01393                 *
    01394                 * @return the underlying ConcurrentMap
    01395                 */
    01396                 virtual ConcurrentMap::Handle getConcurrentMap();
    01397
    01398             };
    01399
    01400         /**
    01401         * A ConverterInvocable views an underlying InvocableMap through a set
    01402         * of key and value Converters.
    01403         */
    01404         class COH_EXPORT ConverterInvocableMap
    01405             : public class_spec<ConverterInvocableMap,
    01406                 extends<ConverterMap>,
    01407                 implements<InvocableMap> >
    01408             {
    01409             friend class factory<ConverterInvocableMap>;
    01410
    01411             // ----- constructors ---------------------------------------
    01412
    01413             protected:
    01414                 /**
    01415                 * Create a ConverterInvocableMap which delegates to the s
    01416                 * pecified InvocableMap.
    01417                 *
    01418                 * @param hMap      the specified InvocableMap
    01419                 * @param vConvUp   the EntryConverter from the underlying
    01420                 *                  Map
    01421                 * @param vConvDown the EntryConverter to the underlying
    01422                 *                  Map
    01423                 */
    01424                 ConverterInvocableMap(InvocableMap::Handle hMapDelegate,
    01425                              EntryConverter::View vConvUp,
    01426                              EntryConverter::View vConvDown);
    01427
    01428                 /**
    01429                 * Create a ConverterInvocableMap which delegates to the s
    01430                 * pecified InvocableMap.
    01431                 *
    01432                 * @param vMap      the specified InvocableMap
    01433                 * @param vConvUp   the EntryConverter from the underlying
    01434                 *                  Map
    01435                 * @param vConvDown the EntryConverter to the underlying
    01436                 *                  Map
    01437                 */
    01438                 ConverterInvocableMap(InvocableMap::View vMapDelegate,
    01439                              EntryConverter::View vConvUp,
    01440                              EntryConverter::View vConvDown);
    01441
    01442             // ----- InvocableMap interface -----------------------------
    01443
    01444             public:
    01445                 /**
    01446                 * {@inheritDoc}
    01447                 */
    01448                 virtual Object::Holder invoke(Object::View vKey,
    01449                         InvocableMap::EntryProcessor::Handle hAgent);
    01450
    01451                 /**
    01452                 * {@inheritDoc}
    01453                 */
    01454                 virtual Map::View invokeAll(Collection::View vCollKeys,
    01455                         InvocableMap::EntryProcessor::Handle hAgent);
    01456
    01457                 /**
    01458                 * {@inheritDoc}
    01459                 */
    01460                 virtual Map::View invokeAll(Filter::View vFilter,
    01461                         InvocableMap::EntryProcessor::Handle hAgent);
    01462
    01463                 /**
    01464                 * {@inheritDoc}
    01465                 */
    01466                 virtual Object::Holder aggregate(Collection::View vCollKeys,
    01467                         InvocableMap::EntryAggregator::Handle hAgent) const;
    01468
    01469                 /**
    01470                 * {@inheritDoc}
    01471                 */
    01472                 virtual Object::Holder aggregate(Filter::View vFilter,
    01473                         InvocableMap::EntryAggregator::Handle hAgent) const;
    01474
    01475             // ----- accessors ------------------------------------------
    01476
    01477             public:
    01478                 /**
    01479                 * Return the underlying InvocableMap.
    01480                 *
    01481                 * @return the underlying InvocableMap
    01482                 */
    01483                 virtual InvocableMap::View getInvocableMap() const;
    01484
    01485                 /**
    01486                 * Return the underlying CacheMap.
    01487                 *
    01488                 * @return the underlying CacheMap
    01489                 */
    01490                 virtual InvocableMap::Handle getInvocableMap();
    01491             };
    01492
    01493
    01494         // ----- inner class: ConverterQueryMap -----------------------------
    01495
    01496         /**
    01497         * A Converter QueryMap views an underlying QueryMap through a set of
    01498         * key and value Converters.
    01499         */
    01500         class COH_EXPORT ConverterQueryMap
    01501             : public class_spec<ConverterQueryMap,
    01502                 extends<ConverterMap>,
    01503                 implements<QueryMap> >
    01504             {
    01505             friend class factory<ConverterQueryMap>;
    01506
    01507             // ----- constructors -----------------------------------
    01508
    01509             protected:
    01510                 /**
    01511                 * Create a ConverterQueryMap which delegates to the specified
    01512                 * QueryMap.
    01513                 *
    01514                 * @param hMap      the specified InvocableMap
    01515                 * @param vConvUp   the EntryConverter from the underlying
    01516                 *                  Map
    01517                 * @param vConvDown the EntryConverter to the underlying
    01518                 *                  Map
    01519                 */
    01520                 ConverterQueryMap(QueryMap::Handle hMapDelegate,
    01521                              EntryConverter::View vConvUp,
    01522                              EntryConverter::View vConvDown);
    01523
    01524                 /**
    01525                 * Create a ConverterQueryMap which delegates to the s
    01526                 * pecified QueryMap.
    01527                 *
    01528                 * @param vMap      the specified InvocableMap
    01529                 * @param vConvUp   the EntryConverter from the underlying
    01530                 *                  Map
    01531                 * @param vConvDown the EntryConverter to the underlying
    01532                 *                  Map
    01533                 */
    01534                 ConverterQueryMap(QueryMap::View vMapDelegate,
    01535                              EntryConverter::View vConvUp,
    01536                              EntryConverter::View vConvDown);
    01537
    01538             // ----- QueryMap interface ---------------------------------
    01539
    01540             public:
    01541                 /**
    01542                 * {@inheritDoc}
    01543                 */
    01544                 virtual Set::View keySet(Filter::View vFilter) const;
    01545
    01546                 /**
    01547                 * {@inheritDoc}
    01548                 */
    01549                 virtual Set::View entrySet(Filter::View vFilter) const;
    01550
    01551                 /**
    01552                 * {@inheritDoc}
    01553                 */
    01554                 virtual Set::View entrySet(Filter::View vFilter,
    01555                         Comparator::View vComparator) const;
    01556
    01557                 /**
    01558                 * {@inheritDoc}
    01559                 */
    01560                 virtual void addIndex(ValueExtractor::View vExtractor,
    01561                         bool fOrdered, Comparator::View vComparator);
    01562
    01563                 /**
    01564                 * {@inheritDoc}
    01565                 */
    01566                 virtual void removeIndex(ValueExtractor::View vExtractor);
    01567
    01568             // ----- Map interface --------------------------------------
    01569
    01570             public:
    01571                 /**
    01572                 * {@inheritDoc}
    01573                 */
    01574                 using Map::keySet;
    01575
    01576                 /**
    01577                 * {@inheritDoc}
    01578                 */
    01579                 using Map::entrySet;
    01580
    01581             // ----- accessors ----------------------------------------------
    01582
    01583             public:
    01584                 /**
    01585                 * Return the underlying InvocableMap.
    01586                 *
    01587                 * @return the underlying InvocableMap
    01588                 */
    01589                 virtual QueryMap::View getQueryMap() const;
    01590
    01591                 /**
    01592                 * Return the underlying CacheMap.
    01593                 *
    01594                 * @return the underlying CacheMap
    01595                 */
    01596                 virtual QueryMap::Handle getQueryMap();
    01597             };
    01598
    01599
    01600         /**
    01601         * A ConverterNamedCache views an underlying NamedCache through a set
    01602         * of key and value Converters.
    01603         */
    01604         class COH_EXPORT ConverterNamedCache
    01605             : public class_spec<ConverterNamedCache,
    01606                 extends<ConverterCacheMap>,
    01607                 implements<NamedCache> >
    01608             {
    01609             friend class factory<ConverterNamedCache>;
    01610
    01611             // ----- constructors -----------------------------------
    01612
    01613             protected:
    01614                 /**
    01615                 * Create a ConverterQueryMap which delegates to the s
    01616                 * pecified QueryMap.
    01617                 *
    01618                 * @param hMap      the specified InvocableMap
    01619                 * @param vConvUp   the EntryConverter from the underlying
    01620                 *                  Map
    01621                 * @param vConvDown the EntryConverter to the underlying
    01622                 *                  Map
    01623                 */
    01624                 ConverterNamedCache(NamedCache::Handle hMapDelegate,
    01625                              EntryConverter::View vConvUp,
    01626                              EntryConverter::View vConvDown);
    01627
    01628                 /**
    01629                 * Create a ConverterQueryMap which delegates to the s
    01630                 * pecified QueryMap.
    01631                 *
    01632                 * @param vMap      the specified InvocableMap
    01633                 * @param vConvUp   the EntryConverter from the underlying
    01634                 *                  Map
    01635                 * @param vConvDown the EntryConverter to the underlying
    01636                 *                  Map
    01637                 */
    01638                 ConverterNamedCache(NamedCache::View vMapDelegate,
    01639                              EntryConverter::View vConvUp,
    01640                              EntryConverter::View vConvDown);
    01641
    01642             // ----- NamedCache interface -------------------------------
    01643
    01644             public:
    01645                 /**
    01646                 * Return the cache name.
    01647                 *
    01648                 * @return the cache name
    01649                 */
    01650                 virtual String::View getCacheName() const;
    01651
    01652                 /**
    01653                 * Return the CacheService that this NamedCache is a part of.
    01654                 *
    01655                 * @return the CacheService
    01656                 */
    01657                 virtual CacheService::Handle getCacheService();
    01658
    01659                 /**
    01660                 * Return the CacheService that this NamedCache is a part of.
    01661                 *
    01662                 * @return the CacheService
    01663                 */
    01664                 virtual CacheService::View getCacheService() const;
    01665
    01666                 /**
    01667                 * Specifies whether or not the NamedCache is active.
    01668                 *
    01669                 * @return true if the NamedCache is active; false otherwise
    01670                 */
    01671                 virtual bool isActive() const;
    01672
    01673                 /**
    01674                 * Release local resources associated with this instance of
    01675                 * NamedCache.
    01676                 *
    01677                 * Releasing a cache makes it no longer usable, but does not
    01678                 * affect the cache itself. In other words, all other
    01679                 * references to the cache will still be valid, and the cache
    01680                 * data is not affected by releasing the reference. Any
    01681                 * attempt to use this reference afterword will result in an
    01682                 * exception.
    01683                 *
    01684                 * @see CacheService#releaseCache
    01685                 */
    01686                 virtual void release();
    01687
    01688                 /**
    01689                 * Release and destroy this instance of NamedCache.
    01690                 *
    01691                 * <b>Warning:</b> This method is used to completely destroy
    01692                 * the specified cache across the cluster. All references in
    01693                 * the entire cluster to this cache will be invalidated, the
    01694                 * cached data will be cleared, and all resources will be
    01695                 * released.
    01696                 *
    01697                 * @see CacheService#destroyCache
    01698                 */
    01699                 virtual void destroy();
    01700
    01701             // ----- ConcurrentMap interface ----------------------------
    01702
    01703             public:
    01704                 /**
    01705                 * {@inheritDoc}
    01706                 */
    01707                 virtual bool lock(Object::View vKey, int64_t cWait) const;
    01708
    01709                 /**
    01710                 * {@inheritDoc}
    01711                 */
    01712                 virtual bool lock(Object::View vKey) const;
    01713
    01714                 /**
    01715                 * {@inheritDoc}
    01716                 */
    01717                 virtual bool unlock(Object::View vKey) const;
    01718
    01719             // ----- InvocableMap interface -----------------------------
    01720
    01721             public:
    01722                 /**
    01723                 * {@inheritDoc}
    01724                 */
    01725                 virtual Object::Holder invoke(Object::View vKey,
    01726                         InvocableMap::EntryProcessor::Handle hAgent);
    01727
    01728                 /**
    01729                 * {@inheritDoc}
    01730                 */
    01731                 virtual Map::View invokeAll(Collection::View vCollKeys,
    01732                         InvocableMap::EntryProcessor::Handle hAgent);
    01733
    01734                 /**
    01735                 * {@inheritDoc}
    01736                 */
    01737                 virtual Map::View invokeAll(Filter::View vFilter,
    01738                         InvocableMap::EntryProcessor::Handle hAgent);
    01739
    01740                 /**
    01741                 * {@inheritDoc}
    01742                 */
    01743                 virtual Object::Holder aggregate(Collection::View vCollKeys,
    01744                         InvocableMap::EntryAggregator::Handle hAgent) const;
    01745
    01746                 /**
    01747                 * {@inheritDoc}
    01748                 */
    01749                 virtual Object::Holder aggregate(Filter::View vFilter,
    01750                         InvocableMap::EntryAggregator::Handle hAgent) const;
    01751
    01752             // ----- QueryMap interface ---------------------------------
    01753
    01754             public:
    01755                 /**
    01756                 * {@inheritDoc}
    01757                 */
    01758                 virtual Set::View keySet(Filter::View vFilter) const;
    01759
    01760                 /**
    01761                 * {@inheritDoc}
    01762                 */
    01763                 virtual Set::View entrySet(Filter::View vFilter) const;
    01764
    01765                 /**
    01766                 * {@inheritDoc}
    01767                 */
    01768                 virtual Set::View entrySet(Filter::View vFilter,
    01769                         Comparator::View vComparator) const;
    01770
    01771                 /**
    01772                 * {@inheritDoc}
    01773                 */
    01774                 virtual void addIndex(ValueExtractor::View vExtractor,
    01775                         bool fOrdered, Comparator::View vComparator);
    01776
    01777                 /**
    01778                 * {@inheritDoc}
    01779                 */
    01780                 virtual void removeIndex(ValueExtractor::View vExtractor);
    01781
    01782             // ----- Map interface --------------------------------------
    01783
    01784             public:
    01785                 /**
    01786                 * {@inheritDoc}
    01787                 */
    01788                 using Map::keySet;
    01789
    01790                 /**
    01791                 * {@inheritDoc}
    01792                 */
    01793                 using Map::entrySet;
    01794
    01795             // ----- accessors ------------------------------------------
    01796
    01797             public:
    01798                 /**
    01799                 * Return the underlying InvocableMap.
    01800                 *
    01801                 * @return the underlying InvocableMap
    01802                 */
    01803                 virtual NamedCache::View getNamedCache() const;
    01804
    01805                 /**
    01806                 * Return the underlying CacheMap.
    01807                 *
    01808                 * @return the underlying CacheMap
    01809                 */
    01810                 virtual NamedCache::Handle getNamedCache();
    01811
    01812                 /**
    01813                 * Return the underlying ConcurrentMap.
    01814                 *
    01815                 * @return the underlying ConcurrentMap
    01816                 */
    01817                 virtual ConcurrentMap::View getConcurrentMap() const;
    01818
    01819                 /**
    01820                 * Return the underlying ConcurrentMap.
    01821                 *
    01822                 * @return the underlying ConcurrentMap
    01823                 */
    01824                 virtual ConcurrentMap::Handle getConcurrentMap();
    01825
    01826                 /**
    01827                 * Return the underlying InvocableMap.
    01828                 *
    01829                 * @return the underlying InvocableMap
    01830                 */
    01831                 virtual InvocableMap::View getInvocableMap() const;
    01832
    01833                 /**
    01834                 * Return the underlying InvocableMap.
    01835                 *
    01836                 * @return the underlying InvocableMap
    01837                 */
    01838                 virtual InvocableMap::Handle getInvocableMap();
    01839
    01840                 /**
    01841                 * Return the underlying QueryMap.
    01842                 *
    01843                 * @return the underlying QueryMap
    01844                 */
    01845                 virtual QueryMap::View getQueryMap() const;
    01846
    01847                 /**
    01848                 * Return the underlying QueryMap.
    01849                 *
    01850                 * @return the underlying QueryMap
    01851                 */
    01852                 virtual QueryMap::Handle getQueryMap();
    01853
    01854             // ---- data members ----------------------------------------
    01855
    01856             protected:
    01857                 /**
    01858                 * A Converter ConcurrentMap around the underlying NamedCache.
    01859                 */
    01860                 FinalHolder<ConverterConcurrentMap> m_ohMapConcurrent;
    01861
    01862                 /**
    01863                 * A Converter InvocableMap around the underlying NamedCache.
    01864                 */
    01865                 FinalHolder<ConverterInvocableMap> m_ohMapInvocable;
    01866
    01867                 /**
    01868                 * A Converter QueryMap around the underlying NamedCache.
    01869                 */
    01870                 FinalHolder<ConverterQueryMap> m_ohMapQuery;
    01871             };
    01872
    01873
    01874         // ----- inner class: UnsupportedConverter --------------------------
    01875
    01876         /**
    01877         * Converter which always throws an UnsupportedOperationException.
    01878         */
    01879         class COH_EXPORT UnsupportedConverter
    01880             : public class_spec<UnsupportedConverter,
    01881                 extends<Object>,
    01882                 implements<Converter> >
    01883             {
    01884             friend class factory<UnsupportedConverter>;
    01885
    01886             // ----- constructor ----------------------------------------
    01887
    01888             public:
    01889                 /**
    01890                 * Create an UnsupportedConverter
    01891                 *
    01892                 * return a handle to the new UnsupportedConverter
    01893                 */
    01894                 UnsupportedConverter();
    01895
    01896             // ----- Converter interface --------------------------------
    01897
    01898             public:
    01899                 /**
    01900                 * {@inheritDoc}
    01901                 *
    01902                 * @throws UnsupportedOperationException always
    01903                 */
    01904                 virtual Object::Holder convert(Object::Holder oh) const;
    01905
    01906                 /**
    01907                 * Return a singleton instance of the UnsupportedConverter.
    01908                 */
    01909                 static UnsupportedConverter::View getInstance();
    01910             };
    01911     };
    01912
    01913 COH_CLOSE_NAMESPACE2
    01914
    01915 #endif // COH_CONVERTER_COLLECTIONS_HPP

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