Oracle Coherence for C++ API
Release 3.7.1.0
E22845-01
00001 /* 00002 * ConverterCollections.hpp 00003 * 00004 * Copyright (c) 2000, 2011, 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