Oracle Coherence for C++ API
Release 3.6.0.0

E15728-01

coherence/util/TypedCollections.hpp

00001 /*
00002 * TypedCollections.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_TYPED_COLLECTIONS_HPP
00017 #define COH_TYPED_COLLECTIONS_HPP
00018 
00019 #include "coherence/lang.ns"
00020 
00021 #include "coherence/util/Collection.hpp"
00022 #include "coherence/util/Converter.hpp"
00023 #include "coherence/util/ConverterCollections.hpp"
00024 #include "coherence/util/Iterator.hpp"
00025 #include "coherence/util/List.hpp"
00026 #include "coherence/util/Map.hpp"
00027 #include "coherence/util/Set.hpp"
00028 #include "coherence/util/WrapperCollections.hpp"
00029 
00030 COH_OPEN_NAMESPACE2(coherence,util)
00031 
00032 
00033 /**
00034 * A collection of wrapper classes which expose an underlying collection's
00035 * contents as explicit types rather then just as Objects.  Essentially these
00036 * are auto-casting collections.
00037 *
00038 * Each typed collection is templated based on one or more handle types
00039 * to a const coherence::lang::Object Object. For instance:
00040 * <tt>TypedCollection<String::View></tt> or
00041 * <tt>TypedMap<String::View, Integer32::View></tt>
00042 *
00043 * Alternate handle types may also be used for added functionality,
00044 * for example: <tt>TypedMap<String::View, BoxHandle<const Integer32> ></tt>
00045 * produces a TypedMap which will auto-box the supplied values to Integer32,
00046 * making statements such as <tt>hMap->put("abc", 456)</tt> possible.
00047 *
00048 * These typed wrappers only provide a convenience over the underlying
00049 * collection. Thus they cannot guarantee that external usage of the
00050 * the underlying collection will not violate the restrictions imposed by the
00051 * wrapper. For instance Objects of a type other then those specified by
00052 * this template may exist within the collection.  Any retrieval of those
00053 * elements from the wrapper will result in ClassCastException.
00054 * External usage is possible anytime the typed wrapper is passed by its
00055 * inherited collection interface, i.e. passing a TypedMap as a plain Map.
00056 *
00057 * Member functions which take no input parameters cannot have their return
00058 * type changed. Instead there will be an auxiliary function with the same name
00059 * plus a "Typed" suffix, e.g. TypedMap::keySetTyped().
00060 *
00061 * Example usage:
00062 * @code
00063 * typedef TypedCollections::TypedMap<String::View, Integer32::Handle> StringIntMap;
00064 * StringIntMap::Handle hMap = StringIntMap::create(HashMap::create());
00065 *
00066 * hMap->put("abc", Integer32::create(123));  // String's auto-boxing is utilized
00067 * Integer32::Handle hInt = hMap->get("abc"); // no cast of return type required
00068 * @endcode
00069 *
00070 * @author mf  2007.07.05
00071 */
00072 class COH_EXPORT TypedCollections
00073     {
00074     // ----- inner class: TypedIterator -------------------------------------
00075 
00076     public:
00077         /**
00078         * Typed wrapper over Iterator interface.
00079         */
00080         template<class T>
00081         class TypedIterator
00082             : public cloneable_spec<TypedIterator<T>,
00083                 extends<WrapperCollections::AbstractWrapperIterator> >
00084             {
00085             friend class factory<TypedIterator<T> >;
00086             typedef typename TypedIterator::super super;
00087 
00088             // ----- typedefs -------------------------------------------
00089 
00090             public:
00091                 /**
00092                 * The type of the handles returned by this iterator,
00093                 * e.g. String::View.
00094                 */
00095                 typedef T ValueType;
00096 
00097 
00098             // ----- constructors ---------------------------------------
00099 
00100             protected:
00101                 /**
00102                 * Create a new TypedIterator over the given Iterator.
00103                 *
00104                 * @param hIterDelegate a general "Object" Iterator to wrap
00105                 *        around
00106                 */
00107                 TypedIterator(Iterator::Handle hIterDelegate)
00108                     : super(hIterDelegate)
00109                     {
00110                     }
00111 
00112                 /**
00113                 * Copy constructor
00114                 */
00115                 TypedIterator(const TypedIterator& that)
00116                     : super(that)
00117                     {
00118                     }
00119 
00120             // ----- TypedIterator interface ----------------------------
00121 
00122             public:
00123                 /**
00124                 * The typed version of the method Iterator::next. Return the
00125                 * next element in the iteration.
00126                 *
00127                 * @return the next element in the iteration.
00128                 *
00129                 * @throws coherence::lang::NoSuchElementException
00130                 *         if iteration has no more elements.
00131                 * @throws ClassCastException
00132                 *         if the typed collection is broken by external usage
00133                 */
00134                 virtual ValueType nextTyped()
00135                     {
00136                     return cast<ValueType>(super::next());
00137                     }
00138             };
00139 
00140 
00141     // ----- inner class: TypedListIterator ---------------------------------
00142 
00143     public:
00144         /**
00145         * Typed wrapper over ListIterator interface.
00146         */
00147         template<class T>
00148         class TypedListIterator
00149             : public cloneable_spec<TypedListIterator<T>,
00150                 extends<WrapperCollections::AbstractWrapperListIterator> >
00151             {
00152             friend class factory<TypedListIterator<T> >;
00153             typedef typename TypedListIterator::super super;
00154 
00155             // ----- typedefs -------------------------------------------
00156 
00157             public:
00158                 /**
00159                 * The type of the handles returned by this iterator,
00160                 * e.g. String::View.
00161                 */
00162                 typedef T ValueType;
00163 
00164 
00165             // ----- constructors ---------------------------------------
00166 
00167             protected:
00168                 /**
00169                 * Create a new TypedListIterator over the given ListIterator.
00170                 *
00171                 * @param hIterDelegate a general "Object" Iterator to wrap
00172                 *        around
00173                 */
00174                 TypedListIterator(ListIterator::Handle hIterDelegate)
00175                     : super(hIterDelegate)
00176                     {
00177                     }
00178 
00179                 /**
00180                 * Copy constructor.
00181                 */
00182                 TypedListIterator(const TypedListIterator& that)
00183                     : super(that)
00184                     {
00185                     }
00186 
00187 
00188             // ----- TypedIterator interface ----------------------------
00189 
00190             public:
00191                 /**
00192                 * The typed version of the method Iterator::next. Return the
00193                 * next element in the iteration.
00194                 *
00195                 * @return the next element in the iteration.
00196                 *
00197                 * @throws coherence::lang::NoSuchElementException
00198                 *         if iteration has no more elements.
00199                 * @throws ClassCastException
00200                 *         if the typed collection is broken by external usage
00201                 */
00202                 virtual ValueType nextTyped()
00203                     {
00204                     return cast<ValueType>(super::next());
00205                     }
00206 
00207 
00208             // ----- ListIterator interface -----------------------------
00209 
00210             public:
00211                 /**
00212                 * The typed version of the method ListIterator::previous.
00213                 * <p> Return the previous element in the iteration.
00214                 *
00215                 * @return the previous element in the iteration.
00216                 *
00217                 * @throws coherence::lang::NoSuchElementException
00218                 *         if iteration has no previous elements.
00219                 * @throws ClassCastException
00220                 *         if the typed collection is broken by external usage
00221                 */
00222                 virtual ValueType previousTyped()
00223                     {
00224                     return cast<ValueType>(super::previous());
00225                     }
00226 
00227 
00228             // ----- ListMuterator interface ----------------------------
00229 
00230             public:
00231                 /**
00232                 * The typed version of the method ListIterator::add.
00233                 * <p>
00234                 * Insert the specified element immediately before the element
00235                 * to be returned from the next call to the next() method. A
00236                 * subsequent call to next() will not return the added
00237                 * element, while a call to previous() would return the added
00238                 * element.
00239                 *
00240                 * @param v  the element to add
00241                 *
00242                 * @throws UnsupportedOperationException if addition is not
00243                 *         supported
00244                 */
00245                 virtual void add(ValueType v)
00246                     {
00247                     super::add(v);
00248                     }
00249 
00250                 using super::add;
00251 
00252                 /**
00253                 * The typed version of the method ListIterator::set.
00254                 * <p>
00255                 * Replace the last element returned by next() or previous() with
00256                 * the specified element.
00257                 *
00258                 * @param oh  the element to store
00259                 *
00260                 * @throws UnsupportedOperationException if set is not supported
00261                 */
00262                 virtual void set(ValueType v)
00263                     {
00264                     super::set(v);
00265                     }
00266 
00267                 using super::set;
00268             };
00269 
00270 
00271         // ---- inner class: TypedCollection --------------------------------
00272 
00273         /**
00274         * Typed wrapper over Collection interface.
00275         */
00276         template<class T>
00277         class TypedCollection
00278             : public cloneable_spec<TypedCollection<T>,
00279                 extends<WrapperCollections::AbstractWrapperCollection> >
00280             {
00281             friend class factory<TypedCollection<T> >;
00282             typedef typename TypedCollection::this_spec super;
00283 
00284             // ----- typedefs -------------------------------------------
00285 
00286             public:
00287                 /**
00288                 * The type of the objects stored in this collection, that
00289                 * e.g. String::View.
00290                 */
00291                 typedef T ValueType;
00292 
00293                 /**
00294                 * The type of the iterator over this collection.
00295                 */
00296                 typedef TypedIterator<T> Iterator;
00297 
00298 
00299             // ----- constructors ---------------------------------------
00300 
00301             protected:
00302                 /**
00303                 * Create a new TypedCollection over the given Collection.
00304                 *
00305                 * @param ohCollDelegate  the Collection to delegate to
00306                 */
00307                 TypedCollection(Collection::Holder ohCollDelegate)
00308                     : super(ohCollDelegate)
00309                     {
00310                     }
00311 
00312                 /**
00313                 * Copy constructor.
00314                 */
00315                 TypedCollection(const TypedCollection& that)
00316                     : super(that)
00317                     {
00318                     }
00319 
00320 
00321             // ----- TypedCollection interface --------------------------
00322 
00323             public:
00324                 /**
00325                 * The typed version of the method Collection::iterator.
00326                 * Return a handle to an TypedIterator over the elements in
00327                 * this collection.
00328                 *
00329                 * @return a TypedIterator over the elements in this
00330                 *         collection
00331                 */
00332                 virtual typename TypedCollection::Iterator::Handle iteratorTyped() const
00333                     {
00334                     return TypedCollection::Iterator::create(super::iterator());
00335                     }
00336 
00337                 /**
00338                 * The typed version of the method Collection::iterator.
00339                 * Return a handle to an TypedIterator over the elements in
00340                 * this collection.
00341                 *
00342                 * @return a TypedIterator over the elements in this
00343                 *         collection
00344                 */
00345                 virtual typename TypedCollection::Iterator::Handle iteratorTyped()
00346                     {
00347                     return TypedCollection::Iterator::create(super::iterator());
00348                     }
00349 
00350                 /**
00351                 * {@inheritDoc}
00352                 */
00353                 virtual coherence::util::Iterator::Handle iterator() const
00354                     {
00355                     return iteratorTyped();
00356                     }
00357 
00358                 /**
00359                 * {@inheritDoc}
00360                 */
00361                 virtual coherence::util::Muterator::Handle iterator()
00362                     {
00363                     return iteratorTyped();
00364                     }
00365 
00366                 /**
00367                 * {@inheritDoc}
00368                 */
00369                 using super::contains;
00370 
00371                 /**
00372                 * The typed version of the method Collection::contains.
00373                 *
00374                 * Return true if this collection contains the specified
00375                 * element.
00376                 *
00377                 * @param v element whose presence in this collection is to
00378                 *          be tested
00379                 *
00380                 * @return true if this collection contains the specified
00381                 *         element
00382                 */
00383                 virtual bool contains(ValueType v) const
00384                     {
00385                     return super::contains(v);
00386                     }
00387 
00388                 /**
00389                 * {@inheritDoc}
00390                 */
00391                 using super::add;
00392 
00393                 /**
00394                 * The typed version of the method Collection::add. Ensure
00395                 * that this collection contains the specified element.
00396                 *
00397                 * @param v element whose presence in this collection is to be
00398                 *          ensured
00399                 *
00400                 * @return true if this collection changed as a result of the
00401                 *         call
00402                 *
00403                 * @throws coherence::lang::UnsupportedOperationException
00404                 *         if the #add() operation is not supported by this
00405                 *         collection
00406                 */
00407                 virtual bool add(ValueType v)
00408                     {
00409                     return super::add(v);
00410                     }
00411 
00412                 /**
00413                 * {@inheritDoc}
00414                 */
00415                 using super::remove;
00416 
00417                 /**
00418                 * The typed version of the method Collection::remove. Remove
00419                 * a single instance of the specified element from this
00420                 * collection, if it is present.
00421                 *
00422                 * @param v element to be removed from this collection, if
00423                 *          present
00424                 *
00425                 * @return true if this collection changed as a result of
00426                 *         the call
00427                 *
00428                 * @throws coherence::lang::UnsupportedOperationException
00429                 *         if the #remove() operation is not supported by this
00430                 *         collection
00431                 */
00432                 virtual bool remove(ValueType v)
00433                     {
00434                     return super::remove(v);
00435                     }
00436 
00437                 /**
00438                 * {@inheritDoc}
00439                 */
00440                 using super::addAll;
00441 
00442                 /**
00443                 * The typed version of the method Collection::addAll.
00444                 *
00445                 * Add all of the elements in the specified collection to this
00446                 * collection.
00447                 *
00448                 * @param vtc TypedCollection of elements to be inserted into
00449                 *            this collection
00450                 *
00451                 * @return true if this collection changed as a result of
00452                 *         the call
00453                 *
00454                 * @throws coherence::lang::NullPointerException
00455                 *         if the specified collection is NULL
00456                 * @throws coherence::lang::UnsupportedOperationException
00457                 *         if the #add() operation is not supported by this
00458                 *         collection
00459                 */
00460                 virtual bool addAll(typename TypedCollection::View vtc)
00461                     {
00462                     return super::addAll(vtc);
00463                     }
00464 
00465                 /**
00466                 * {@inheritDoc}
00467                 */
00468                 using super::removeAll;
00469 
00470                 /**
00471                 * The typed version of the method Collection::removeAll.
00472                 *
00473                 * Remove all this collection's elements that are also
00474                 * contained in the specified typed collection.
00475                 *
00476                 * @param vtc elements to be removed from this collection
00477                 *
00478                 * @return true if this collection changed as a result of
00479                 *         the call
00480                 *
00481                 * @throws coherence::lang::NullPointerException
00482                 *         if the specified collection is NULL
00483                 * @throws coherence::lang::UnsupportedOperationException
00484                 *         if the #remove() operation is not supported by this
00485                 *         collection
00486                 */
00487                 virtual bool removeAll(typename TypedCollection::View vtc)
00488                     {
00489                     return super::removeAll(vtc);
00490                     }
00491 
00492                 /**
00493                 * {@inheritDoc}
00494                 */
00495                 using super::retainAll;
00496 
00497                 /**
00498                 * The typed version of the method Collection::retainAll.
00499                 *
00500                 * Retain only the elements in this collection that are
00501                 * contained in the specified typed collection.
00502                 *
00503                 * @param vtc elements to be retained in this collection
00504                 *
00505                 * @return true if this collection changed as a result of
00506                 *         the call
00507                 *
00508                 * @throws coherence::lang::NullPointerException
00509                 *         if the specified collection is NULL
00510                 * @throws coherence::lang::UnsupportedOperationException
00511                 *         if the #remove() operation is not supported by this
00512                 *         collection
00513                 */
00514                 virtual bool retainAll(typename TypedCollection::View vtc)
00515                     {
00516                     return super::retainAll(vtc);
00517                     }
00518             };
00519 
00520 
00521         // ----- inner class: TypedSet --------------------------------------
00522 
00523         /**
00524         * Typed wrapper over Set interface.
00525         */
00526         template<class T>
00527         class TypedSet
00528             : public cloneable_spec<TypedSet<T>,
00529                 extends<WrapperCollections::AbstractWrapperSet> >
00530             {
00531             friend class factory<TypedSet<T> >;
00532             typedef typename TypedSet::super super;
00533 
00534             // ----- typedefs -------------------------------------------
00535 
00536             public:
00537                 /**
00538                 * The type of the objects stored in this set, that
00539                 * e.g. String::View.
00540                 */
00541                 typedef T ValueType;
00542 
00543                 /**
00544                 * The type of the iterator over this set.
00545                 */
00546                 typedef TypedIterator<T> Iterator;
00547 
00548 
00549             // ----- constructors ---------------------------------------
00550 
00551             protected:
00552                 /**
00553                 * Create a new TypedSet over the given Set.
00554                 *
00555                 * @param ohSetDelegate  the Set to delegate to
00556                 */
00557                 TypedSet(Set::Holder ohSetDelegate)
00558                     : super(ohSetDelegate)
00559                     {
00560                     }
00561 
00562                 /**
00563                 * Copy constructor.
00564                 */
00565                 TypedSet(const TypedSet& that)
00566                     : super(that)
00567                     {
00568                     }
00569 
00570 
00571             // ----- TypedSet interface ---------------------------------
00572 
00573             public:
00574                 /**
00575                 * {@inheritDoc}
00576                 */
00577                 using super::contains;
00578 
00579                 /**
00580                 * The typed version of the method Collection::contains.
00581                 * Return true if this set contains the specified element.
00582                 *
00583                 * @param v element whose presence in this set is to be tested
00584                 *
00585                 * @return true if this collection contains the specified
00586                 *         element
00587                 */
00588                 virtual bool contains(ValueType v) const
00589                     {
00590                     return super::contains(v);
00591                     }
00592 
00593                 /**
00594                 * The typed version of the method Collection::iterator.
00595                 * Return a handle to an TypedIterator over the elements in
00596                 * this set.
00597                 *
00598                 * @return a TypedIterator over the elements in this
00599                 *         set
00600                 */
00601                 virtual typename TypedSet::Iterator::Handle iteratorTyped() const
00602                     {
00603                     return TypedSet::Iterator::create(super::iterator());
00604                     }
00605 
00606                 /**
00607                 * The typed version of the method Collection::iterator.
00608                 * Return a handle to an TypedIterator over the elements in
00609                 * this set.
00610                 *
00611                 * @return a TypedIterator over the elements in this
00612                 *         set
00613                 */
00614                 virtual typename TypedSet::Iterator::Handle iteratorTyped()
00615                     {
00616                     return TypedSet::Iterator::create(super::iterator());
00617                     }
00618 
00619                 /**
00620                 * {@inheritDoc}
00621                 */
00622                 virtual coherence::util::Iterator::Handle iterator() const
00623                     {
00624                     return iteratorTyped();
00625                     }
00626 
00627                 /**
00628                 * {@inheritDoc}
00629                 */
00630                 virtual coherence::util::Muterator::Handle iterator()
00631                     {
00632                     return iteratorTyped();
00633                     }
00634 
00635                 /**
00636                 * {@inheritDoc}
00637                 */
00638                 using super::add;
00639 
00640                 /**
00641                 * The typed version of the method Set::add. Add the specified
00642                 * element to this set if it is not already present.
00643                 *
00644                 * @param v element to be added to this set.
00645                 *
00646                 * @return true if this set changed as a result of the
00647                 *         call
00648                 *
00649                 * @throws coherence::lang::UnsupportedOperationException
00650                 *         if the #add() operation is not supported by this
00651                 *         set
00652                 */
00653                 virtual bool add(ValueType v)
00654                     {
00655                     return super::add(v);
00656                     }
00657 
00658                 /**
00659                 * {@inheritDoc}
00660                 */
00661                 using super::remove;
00662 
00663                 /**
00664                 * The typed version of the method Collection::remove. Remove
00665                 * the specified element from this set, if it is present.
00666                 *
00667                 * @param v element to be removed from this set, if present
00668                 *
00669                 * @return true if this set changed as a result of
00670                 *         the call
00671                 *
00672                 * @throws coherence::lang::UnsupportedOperationException
00673                 *         if the #remove() operation is not supported by this
00674                 *         set
00675                 */
00676                 virtual bool remove(ValueType v)
00677                     {
00678                     return super::remove(v);
00679                     }
00680 
00681                 /**
00682                 * {@inheritDoc}
00683                 */
00684                 using super::addAll;
00685 
00686 #if (!defined(_MSC_VER) || _MSC_VER==1400) // COH-3357 - works on all compilers but VS2008+
00687                 /**
00688                 * The typed version of the method Collection::addAll.
00689                 *
00690                 * Add all of the elements in the specified TypedCollection to
00691                 * this set.
00692                 *
00693                 * @param vtc TypedCollection of elements to be inserted into
00694                 *            this set
00695                 *
00696                 * @return true if this set changed as a result of the call
00697                 *
00698                 * @throws coherence::lang::NullPointerException
00699                 *         if the specified collection is NULL
00700                 * @throws coherence::lang::UnsupportedOperationException
00701                 *         if the #add() operation is not supported by this set
00702                 */
00703                 virtual bool addAll(typename
00704                                 TypedCollection<ValueType>::View vtc)
00705                     {
00706                     return super::addAll(vtc);
00707                     }
00708 
00709                 /**
00710                 * The typed version of the method Collection::addAll.
00711                 *
00712                 * Add all of the elements in the specified TypedCollection to
00713                 * this set.
00714                 *
00715                 * @param htc TypedCollection of elements to be inserted into
00716                 *            this set
00717                 *
00718                 * @return true if this set changed as a result of the call
00719                 *
00720                 * @throws coherence::lang::NullPointerException
00721                 *         if the specified collection is NULL
00722                 * @throws coherence::lang::UnsupportedOperationException
00723                 *         if the #add() operation is not supported by this set
00724                 */
00725                 virtual bool addAll(typename
00726                                 TypedCollection<ValueType>::Handle htc)
00727                     {
00728                     return super::addAll(htc);
00729                     }
00730 #endif
00731 
00732                 /**
00733                 * The typed version of the method Collection::addAll.
00734                 *
00735                 * Add all of the elements in the specified TypedSet to this
00736                 * set.
00737                 *
00738                 * @param vts TypedSet of elements to be inserted into
00739                 *            this set
00740                 *
00741                 * @return true if this set changed as a result of the call
00742                 *
00743                 * @throws coherence::lang::NullPointerException
00744                 *         if the specified collection is NULL
00745                 * @throws coherence::lang::UnsupportedOperationException
00746                 *         if the #add() operation is not supported by this set
00747                 */
00748                 virtual bool addAll(typename TypedSet<ValueType>::View vts)
00749                     {
00750                     return super::addAll(vts);
00751                     }
00752 
00753                 /**
00754                 * The typed version of the method Collection::addAll.
00755                 *
00756                 * Add all of the elements in the specified TypedSet to this
00757                 * set.
00758                 *
00759                 * @param hts TypedSet of elements to be inserted into
00760                 *            this set
00761                 *
00762                 * @return true if this set changed as a result of the call
00763                 *
00764                 * @throws coherence::lang::NullPointerException
00765                 *         if the specified collection is NULL
00766                 * @throws coherence::lang::UnsupportedOperationException
00767                 *         if the #add() operation is not supported by this set
00768                 */
00769                 virtual bool addAll(typename TypedSet<ValueType>::Handle hts)
00770                     {
00771                     return super::addAll(hts);
00772                     }
00773 
00774                 /**
00775                 * {@inheritDoc}
00776                 */
00777                 using super::removeAll;
00778 
00779 #if (!defined(_MSC_VER) || _MSC_VER==1400) // COH-3357 - works on all compilers but VS2008+
00780                 /**
00781                 * The typed version of the method Collection::removeAll.
00782                 *
00783                 * Remove all this set's elements that are also contained in
00784                 * the specified typed collection.
00785                 *
00786                 * @param vtc elements to be removed from this set
00787                 *
00788                 * @return true if this set changed as a result of
00789                 *         the call
00790                 *
00791                 * @throws coherence::lang::NullPointerException
00792                 *         if the specified collection is NULL
00793                 * @throws coherence::lang::UnsupportedOperationException
00794                 *         if the #remove() operation is not supported by this
00795                 *         set
00796                 */
00797                 virtual bool removeAll(typename
00798                                 TypedCollection<ValueType>::View vtc)
00799                     {
00800                     return super::removeAll(vtc);
00801                     }
00802 
00803                 /**
00804                 * The typed version of the method Collection::removeAll.
00805                 *
00806                 * Remove all this set's elements that are also contained in
00807                 * the specified typed collection.
00808                 *
00809                 * @param htc elements to be removed from this set
00810                 *
00811                 * @return true if this set changed as a result of
00812                 *         the call
00813                 *
00814                 * @throws coherence::lang::NullPointerException
00815                 *         if the specified collection is NULL
00816                 * @throws coherence::lang::UnsupportedOperationException
00817                 *         if the #remove() operation is not supported by this
00818                 *         set
00819                 */
00820                 virtual bool removeAll(typename
00821                                 TypedCollection<ValueType>::Handle htc)
00822                     {
00823                     return super::removeAll(htc);
00824                     }
00825 #endif
00826 
00827                 /**
00828                 * The typed version of the method Collection::removeAll.
00829                 *
00830                 * Remove all this set's elements that are also contained in
00831                 * the specified typed set.
00832                 *
00833                 * @param vts elements to be removed from this set
00834                 *
00835                 * @return true if this set changed as a result of
00836                 *         the call
00837                 *
00838                 * @throws coherence::lang::NullPointerException
00839                 *         if the specified collection is NULL
00840                 * @throws coherence::lang::UnsupportedOperationException
00841                 *         if the #remove() operation is not supported by this
00842                 *         set
00843                 */
00844                 virtual bool removeAll(typename
00845                                 TypedSet<ValueType>::View vts)
00846                     {
00847                     return super::removeAll(vts);
00848                     }
00849 
00850                 /**
00851                 * The typed version of the method Collection::removeAll.
00852                 *
00853                 * Remove all this set's elements that are also contained in
00854                 * the specified typed set.
00855                 *
00856                 * @param hts elements to be removed from this set
00857                 *
00858                 * @return true if this set changed as a result of
00859                 *         the call
00860                 *
00861                 * @throws coherence::lang::NullPointerException
00862                 *         if the specified collection is NULL
00863                 * @throws coherence::lang::UnsupportedOperationException
00864                 *         if the #remove() operation is not supported by this
00865                 *         set
00866                 */
00867                 virtual bool removeAll(typename
00868                                 TypedSet<ValueType>::Handle hts)
00869                     {
00870                     return super::removeAll(hts);
00871                     }
00872 
00873                 /**
00874                 * {@inheritDoc}
00875                 */
00876                 using super::retainAll;
00877 
00878 #if (!defined(_MSC_VER) || _MSC_VER==1400) // COH-3357 - works on all compilers but VS2008+
00879                 /**
00880                 * The typed version of the method Collection::retainAll.
00881                 *
00882                 * Retain only the elements in this set that are
00883                 * contained in the specified typed collection.
00884                 *
00885                 * @param vtc elements to be retained in this set
00886                 *
00887                 * @return true if this set changed as a result of
00888                 *         the call
00889                 *
00890                 * @throws coherence::lang::NullPointerException
00891                 *         if the specified collection is NULL
00892                 * @throws coherence::lang::UnsupportedOperationException
00893                 *         if the #remove() operation is not supported by this
00894                 *         set
00895                 */
00896                 virtual bool retainAll(typename
00897                                 TypedCollection<ValueType>::View vtc)
00898                     {
00899                     return super::retainAll(vtc);
00900                     }
00901 
00902                 /**
00903                 * The typed version of the method Collection::retainAll.
00904                 *
00905                 * Retain only the elements in this set that are
00906                 * contained in the specified typed collection.
00907                 *
00908                 * @param htc elements to be retained in this set
00909                 *
00910                 * @return true if this set changed as a result of
00911                 *         the call
00912                 *
00913                 * @throws coherence::lang::NullPointerException
00914                 *         if the specified collection is NULL
00915                 * @throws coherence::lang::UnsupportedOperationException
00916                 *         if the #remove() operation is not supported by this
00917                 *         set
00918                 */
00919                 virtual bool retainAll(typename
00920                                 TypedCollection<ValueType>::Handle htc)
00921                     {
00922                     return super::retainAll(htc);
00923                     }
00924 #endif
00925 
00926                 /**
00927                 * The typed version of the method Collection::retainAll.
00928                 *
00929                 * Retain only the elements in this set that are
00930                 * contained in the specified typed set.
00931                 *
00932                 * @param vts elements to be retained in this set
00933                 *
00934                 * @return true if this set changed as a result of
00935                 *         the call
00936                 *
00937                 * @throws coherence::lang::NullPointerException
00938                 *         if the specified collection is NULL
00939                 * @throws coherence::lang::UnsupportedOperationException
00940                 *         if the #remove() operation is not supported by this
00941                 *         set
00942                 */
00943                 virtual bool retainAll(typename
00944                                 TypedSet<ValueType>::View vts)
00945                     {
00946                     return super::retainAll(vts);
00947                     }
00948 
00949                 /**
00950                 * The typed version of the method Collection::retainAll.
00951                 *
00952                 * Retain only the elements in this set that are
00953                 * contained in the specified typed set.
00954                 *
00955                 * @param hts elements to be retained in this set
00956                 *
00957                 * @return true if this set changed as a result of
00958                 *         the call
00959                 *
00960                 * @throws coherence::lang::NullPointerException
00961                 *         if the specified collection is NULL
00962                 * @throws coherence::lang::UnsupportedOperationException
00963                 *         if the #remove() operation is not supported by this
00964                 *         set
00965                 */
00966                 virtual bool retainAll(typename
00967                                 TypedSet<ValueType>::Handle hts)
00968                     {
00969                     return super::retainAll(hts);
00970                     }
00971 
00972                 /**
00973                 * Convert a TypedSet to a TypedCollection, wrapping the same
00974                 * underlying Collection::Handle.
00975                 *
00976                 * @return a handle to the new TypedCollection
00977                 */
00978                 virtual typename TypedCollection<ValueType>::Handle
00979                     asTypedCollection()
00980                     {
00981                     return TypedCollection<ValueType>::create(
00982                         cast<Collection::Handle>(super::getDelegate()));
00983                     }
00984 
00985                 /**
00986                 * Convert a TypedSet to a TypedCollection, wrapping the same
00987                 * underlying Collection::View.
00988                 *
00989                 * @return a view to the new TypedCollection
00990                 */
00991                 virtual typename TypedCollection<ValueType>::View
00992                     asTypedCollection() const
00993                     {
00994                     return TypedCollection<ValueType>::create(
00995                         cast<Collection::View>(super::getDelegate()));
00996                     }
00997             };
00998 
00999 
01000         // ----- inner class: TypedEntry ------------------------------------
01001 
01002         /**
01003         * Typed wrapper over Map::Entry interface. Both key and value objects
01004         * are typed. The types of key and value may differ.
01005         */
01006         template<class K, class V>
01007         class TypedEntry
01008             : public cloneable_spec<TypedEntry<K, V>,
01009                 extends<WrapperCollections::AbstractWrapperEntry> >
01010             {
01011             friend class factory<TypedEntry<K, V> >;
01012             typedef typename TypedEntry::this_spec super;
01013 
01014             // ----- typedefs -------------------------------------------
01015 
01016             public:
01017                 /**
01018                 * The type of the keys, e.g. String::View.
01019                 */
01020                 typedef K KeyType;
01021 
01022                 /**
01023                 * The type the values, e.g. String::View.
01024                 */
01025                 typedef V ValueType;
01026 
01027 
01028             // ----- constructors ---------------------------------------
01029 
01030             protected:
01031                 /**
01032                 * Create a new TypedEntry over the given Map::Entry.
01033                 *
01034                 *
01035                 * @param ohEntryDelegate  the Entry to delegate to
01036                 */
01037                 TypedEntry(Map::Entry::Holder ohEntryDelegate)
01038                     : super(ohEntryDelegate)
01039                     {
01040                     }
01041 
01042                 /**
01043                 * Copy constructor.
01044                 */
01045                 TypedEntry(const TypedEntry& that)
01046                     : super(that)
01047                     {
01048                     }
01049 
01050 
01051             // ----- TypedEntry interface -------------------------------
01052 
01053             public:
01054                 /**
01055                 * The typed version of the method Map::Entry::getKey.
01056                 *
01057                 * Return the key corresponding to this entry.
01058                 *
01059                 * @return the key corresponding to this entry.
01060                 *
01061                 * @throws ClassCastException
01062                 *         if the typed entry is broken by external usage
01063                 */
01064                 virtual KeyType getKeyTyped() const
01065                     {
01066                     return cast<KeyType>(super::getKey());
01067                     }
01068 
01069                 /**
01070                 * The typed version of the method Map::Entry::getKey.
01071                 *
01072                 * Return the value corresponding to this entry.
01073                 *
01074                 * @return the value corresponding to this entry.
01075                 *
01076                 * @throws ClassCastException
01077                 *         if the typed entry is broken by external usage
01078                 */
01079                 virtual ValueType getValueTyped() const
01080                     {
01081                     return cast<ValueType>(super::getValue());
01082                     }
01083 
01084                 /**
01085                 * The typed version of the method Map::Entry::getKey.
01086                 *
01087                 * Return the value corresponding to this entry.
01088                 *
01089                 * @return the value corresponding to this entry.
01090                 *
01091                 * @throws ClassCastException
01092                 *         if the typed entry is broken by external usage
01093                 */
01094                 virtual ValueType getValueTyped()
01095                     {
01096                     return cast<ValueType>(super::getValue());
01097                     }
01098 
01099                 /**
01100                 * {@inheritDoc}
01101                 */
01102                 using super::setValue;
01103 
01104                 /**
01105                 * Update the value of the map entry.
01106                 *
01107                 * @param ohValue  the new value for the entry
01108                 *
01109                 * @return the prior value
01110                 */
01111                 virtual ValueType setValue(ValueType ohValue)
01112                     {
01113                     return cast<ValueType>(super::setValue(ohValue));
01114                     }
01115             };
01116 
01117 
01118         // ----- inner class: TypedMap --------------------------------------
01119 
01120         /**
01121         * Typed wrapper over Map interface.
01122         */
01123         template<class K, class V>
01124         class TypedMap
01125             : public cloneable_spec<TypedMap<K, V>,
01126                 extends<WrapperCollections::AbstractWrapperMap> >
01127             {
01128             friend class factory<TypedMap<K, V> >;
01129             typedef typename TypedMap::this_spec super;
01130 
01131             // ----- typedefs -------------------------------------------
01132 
01133             public:
01134                 /**
01135                 * The type of the map's keys, e.g. String::View.
01136                 */
01137                 typedef K KeyType;
01138 
01139                 /**
01140                 * The type of the map's values, e.g. String::View.
01141                 */
01142                 typedef V ValueType;
01143 
01144                 /**
01145                 * The type of the entries stored in this map.
01146                 */
01147                 typedef TypedEntry<KeyType, ValueType> Entry;
01148 
01149                 /**
01150                 * The type of the key set associated with this map.
01151                 */
01152                 typedef TypedSet<KeyType> KeySet;
01153 
01154                 /**
01155                 * The type of the values collection associated with this map.
01156                 */
01157                 typedef TypedCollection<ValueType> ValueCollection;
01158 
01159                 /**
01160                 * The type of the entry set associated with this map.
01161                 */
01162                 typedef TypedSet<typename Entry::View> EntrySet;
01163 
01164 
01165             // ----- inner class: EntryConverter ------------------------
01166 
01167             protected:
01168                 /**
01169                 * A converter from untyped to typed entries:
01170                 * Map::Entry -> TypedEntry
01171                 */
01172                 class EntryConverter
01173                     : public class_spec<EntryConverter,
01174                         extends<Object>,
01175                         implements<Converter> >
01176                     {
01177                     friend class factory<EntryConverter>;
01178 
01179                     // ----- constructors ---------------------------
01180 
01181                     protected:
01182                         /**
01183                         * Create new EntryConverter instance.
01184                         */
01185                         EntryConverter()
01186                             {
01187                             }
01188 
01189                         /**
01190                         * Copy constructor.
01191                         */
01192                         EntryConverter(const EntryConverter&)
01193                             {
01194                             }
01195 
01196 
01197                     // ----- Converter interface --------------------
01198 
01199                     public:
01200                         /**
01201                         * {@inheritDoc}
01202                         */
01203                         virtual Object::Holder convert(Object::Holder oh) const
01204                             {
01205                             typename Entry::View vEntry =
01206                                     cast<typename Entry::View>(oh, false);
01207                             if (vEntry == NULL)
01208                                 {
01209                                 // conversion from Map::Entry to
01210                                 // TypedMap::Entry required
01211                                 // maintain Object::Holder view/handle
01212                                 Map::Entry::Handle h =
01213                                         cast<Map::Entry::Handle>(oh, false);
01214                                 if (h == NULL)
01215                                     {
01216                                     return Entry::create(
01217                                             cast<Map::Entry::View>(oh));
01218                                     }
01219                                 return Entry::create(h);
01220                                 }
01221                             else
01222                                 {
01223                                 // no conversion necessary
01224                                 return oh;
01225                                 }
01226                             }
01227 
01228                     // ----- Object interface -----------------------
01229 
01230                     public:
01231                         /**
01232                         * {@inheritDoc}
01233                         */
01234                         virtual bool isImmutable() const
01235                             {
01236                             return true;
01237                             }
01238                     };
01239 
01240             // ----- constructors -----------------------------------
01241 
01242             protected:
01243                 /**
01244                 * Create a new TypedMap over the given Map.
01245                 *
01246                 * @param ohMapDelegate  the Map to delegate to
01247                 */
01248                 TypedMap(Map::Holder ohMapDelegate)
01249                     : super(ohMapDelegate),
01250                       m_vConverter(Object::self(), EntryConverter::create())
01251                     {
01252                     }
01253 
01254                 /**
01255                 * Copy constructor.
01256                 */
01257                 TypedMap(const TypedMap& that)
01258                     : super(that),
01259                       m_vConverter(Object::self(), EntryConverter::create())
01260                     {
01261                     }
01262 
01263 
01264             // ----- TypedMap interface -----------------------------
01265 
01266             public:
01267                 /**
01268                 * {@inheritDoc}
01269                 */
01270                 using super::containsKey;
01271 
01272                 /**
01273                 * The typed version of the method Map::containsKey.
01274                 *
01275                 * Return <tt>true</tt> if this map contains a mapping for the
01276                 * specified key.
01277                 *
01278                 * @param vKey key whose presence in this map is to be tested.
01279                 *
01280                 * @return <tt>true</tt> if this map contains a mapping for
01281                 *         the specified key.
01282                 */
01283                 virtual bool containsKey(KeyType vKey) const
01284                     {
01285                     return super::containsKey(vKey);
01286                     }
01287 
01288                 /**
01289                 * {@inheritDoc}
01290                 */
01291                 using super::containsValue;
01292 
01293                 /**
01294                 * The typed version of the method Map::containsValue.
01295                 *
01296                 * Return <tt>true</tt> if this map maps one or more keys to
01297                 * the specified value.
01298                 *
01299                 * @param ohValue value whose presence in this map is to be
01300                 *               tested.
01301                 *
01302                 * @return <tt>true</tt> if this map maps one or more keys to
01303                 *          the specified value.
01304                 */
01305                 virtual bool containsValue(ValueType ohValue) const
01306                     {
01307                     return super::containsValue(ohValue);
01308                     }
01309 
01310                 /**
01311                 * {@inheritDoc}
01312                 */
01313                 using super::get;
01314 
01315                 /**
01316                 * The typed version of the method Map::get.
01317                 *
01318                 * Return the value to which this map maps the specified key,
01319                 * if any.
01320                 *
01321                 * @param vKey key whose associated value is to be returned.
01322                 *
01323                 * @return the value to which this map maps the specified key,
01324                 *          or <tt>NULL</tt> if the map contains no mapping
01325                 *          for this key.
01326                 *
01327                 * @throws ClassCastException
01328                 *         if the typed map is broken by external usage
01329                 */
01330                 virtual ValueType get(KeyType vKey) const
01331                     {
01332                     return cast<ValueType>(super::get(vKey));
01333                     }
01334 
01335                 /**
01336                 * The typed version of the method Map::get.
01337                 *
01338                 * Return the value to which this map maps the specified key,
01339                 * if any.
01340                 *
01341                 * @param vKey key whose associated value is to be returned.
01342                 *
01343                 * @return the value to which this map maps the specified key,
01344                 *          or <tt>NULL</tt> if the map contains no mapping
01345                 *          for this key.
01346                 *
01347                 * @throws ClassCastException
01348                 *         if the typed map is broken by external usage
01349                 */
01350                 virtual ValueType get(KeyType vKey)
01351                     {
01352                     return cast<ValueType>(super::get(vKey));
01353                     }
01354 
01355                 /**
01356                 * {@inheritDoc}
01357                 */
01358                 using super::put;
01359 
01360                 /**
01361                 * The typed version of the method Map::put.
01362                 *
01363                 * Associate the specified value with the specified key in
01364                 * this map.
01365                 *
01366                 * @param vKey   key with which the specified value is to be
01367                 *               associated.
01368                 * @param ohValue value to be associated with the specified
01369                 *               key.
01370                 *
01371                 * @return previous value associated with specified key, or
01372                 *         <tt>NULL</tt> if there was no mapping for key.  A
01373                 *         <tt>NULL</tt> return can also indicate that the map
01374                 *         previously associated <tt>NULL</tt> with the
01375                 *         specified key.
01376                 *
01377                 * @throws coherence::lang::UnsupportedOperationException
01378                 *         if the #put() operation is not supported by this map
01379                 * @throws ClassCastException
01380                 *         if the typed map is broken by external usage
01381                 */
01382                 virtual ValueType put(KeyType vKey, ValueType ohValue)
01383                     {
01384                     return cast<ValueType>(super::put(vKey, ohValue));
01385                     }
01386 
01387                 /**
01388                 * {@inheritDoc}
01389                 */
01390                 using super::remove;
01391 
01392                 /**
01393                 * The typed version of the method Map::put.
01394                 *
01395                 * Remove the mapping for this key from this map if it
01396                 * is present.
01397                 *
01398                 * @param vKey key whose mapping is to be removed from
01399                 *             the map.
01400                 *
01401                 * @return previous value associated with specified key, or
01402                 *         <tt>NULL</tt> if there was no mapping for key.
01403                 *
01404                 * @throws coherence::lang::UnsupportedOperationException
01405                 *         if the #remove() operation is not supported by this
01406                 *         map
01407                 * @throws ClassCastException
01408                 *         if the typed map is broken by external usage
01409                 */
01410                 virtual ValueType remove(KeyType vKey)
01411                     {
01412                     return cast<ValueType>(super::remove(vKey));
01413                     }
01414 
01415                 /**
01416                 * {@inheritDoc}
01417                 */
01418                 using super::putAll;
01419 
01420                 /**
01421                 * The typed version of the method Map::putAll.
01422                 *
01423                 * Copy all of the mappings from the specified typed map
01424                 * to this map.
01425                 *
01426                 * @param vMap mappings to be stored in this map.
01427                 *
01428                 * @throws coherence::lang::UnsupportedOperationException
01429                 *         if the #put() operation is not supported by this
01430                 *         map
01431                 */
01432                 virtual void putAll(typename TypedMap::View vMap)
01433                     {
01434                     super::putAll(vMap);
01435                     }
01436 
01437                 /**
01438                 * The typed version of the method Map::keySet.
01439                 *
01440                 * Return a typed set view of the keys contained in this map.
01441                 *
01442                 * @return a typed set view of the keys contained in this map.
01443                 */
01444                 virtual typename KeySet::View keySetTyped() const
01445                     {
01446                     return KeySet::create(super::keySet());
01447                     }
01448 
01449                 /**
01450                 * The typed version of the method Map::keySet.
01451                 *
01452                 * Return a typed set view of the keys contained in this map.
01453                 *
01454                 * @return a typed set view of the keys contained in this map.
01455                 */
01456                 virtual typename KeySet::Handle keySetTyped()
01457                     {
01458                     return KeySet::create(super::keySet());
01459                     }
01460 
01461                 /**
01462                 * {@inheritDoc}
01463                 */
01464                 virtual Set::View keySet() const
01465                     {
01466                     return keySetTyped();
01467                     }
01468 
01469                 /**
01470                 * {@inheritDoc}
01471                 */
01472                 virtual Set::Handle keySet()
01473                     {
01474                     return keySetTyped();
01475                     }
01476 
01477                 /**
01478                 * The typed version of the method Map::values.
01479                 *
01480                 * Return a typed collection view of the values contained in
01481                 * this map.
01482                 *
01483                 * @return a typed collection view of the values contained in
01484                 *         this map.
01485                 */
01486                 virtual typename ValueCollection::View valuesTyped() const
01487                     {
01488                     return ValueCollection::create(super::values());
01489                     }
01490 
01491                 /**
01492                 * The typed version of the method Map::values.
01493                 *
01494                 * Return a typed collection view of the values contained in
01495                 * this map.
01496                 *
01497                 * @return a typed collection view of the values contained in
01498                 *         this map.
01499                 */
01500                 virtual typename ValueCollection::Handle valuesTyped()
01501                     {
01502                     return ValueCollection::create(super::values());
01503                     }
01504 
01505                 /**
01506                 * {@inheritDoc}
01507                 */
01508                 virtual Collection::View values() const
01509                     {
01510                     return valuesTyped();
01511                     }
01512 
01513                 /**
01514                 * {@inheritDoc}
01515                 */
01516                 virtual Collection::Handle values()
01517                     {
01518                     return valuesTyped();
01519                     }
01520 
01521                 /**
01522                 * The typed version of the method Map::entrySet.
01523                 *
01524                 * Return a typed set view of the mappings contained in
01525                 * this map.
01526                 *
01527                 * @return a typed set view of the mappings contained in
01528                 *         this map.
01529                 */
01530                 virtual typename EntrySet::View entrySetTyped() const
01531                     {
01532                     return EntrySet::create(cast<Set::View>(
01533                         ConverterCollections::ConverterSet::create(
01534                             super::entrySet(), m_vConverter,
01535                             (Converter::View) NULL)));
01536                     }
01537 
01538                 /**
01539                 * The typed version of the method Map::entrySet.
01540                 *
01541                 * Return a typed set view of the mappings contained in
01542                 * this map.
01543                 *
01544                 * @return a typed set view of the mappings contained in
01545                 *         this map.
01546                 */
01547                 virtual typename EntrySet::Handle entrySetTyped()
01548                     {
01549                     return EntrySet::create(cast<Set::Handle>(
01550                         ConverterCollections::ConverterSet::create(
01551                             super::entrySet(), m_vConverter,
01552                             (Converter::View) NULL)));
01553                     }
01554 
01555                 /**
01556                 * {@inheritDoc}
01557                 */
01558                 virtual Set::View entrySet() const
01559                     {
01560                     return entrySetTyped();
01561                     }
01562 
01563                 /**
01564                 * {@inheritDoc}
01565                 */
01566                 virtual Set::Handle entrySet()
01567                     {
01568                     return entrySetTyped();
01569                     }
01570 
01571 
01572             // ----- data members ---------------------------------------
01573 
01574             protected:
01575                 /**
01576                 * The converter used to convert untyped entries to typed ones
01577                 */
01578                 FinalView<EntryConverter> m_vConverter;
01579             };
01580 
01581 
01582         // ----- inner class: TypedList -------------------------------------
01583 
01584         /**
01585         * Typed wrapper over List interface.
01586         */
01587         template<class T>
01588         class TypedList
01589             : public cloneable_spec<TypedList<T>,
01590                 extends<WrapperCollections::AbstractWrapperList> >
01591             {
01592             friend class factory<TypedList<T> >;
01593             typedef typename TypedList::super super;
01594 
01595             // ----- typedefs -------------------------------------------
01596 
01597             public:
01598                 /**
01599                 * The type of the objects stored in this list,
01600                 * e.g. String::View.
01601                 */
01602                 typedef T ValueType;
01603 
01604                 /**
01605                 * The type of the iterator over this list.
01606                 */
01607                 typedef TypedIterator<ValueType> Iterator;
01608 
01609                 /**
01610                 * The type of the list iterator over this list.
01611                 */
01612                 typedef TypedListIterator<ValueType> ListIterator;
01613 
01614 
01615             // ----- constructors ---------------------------------------
01616 
01617             protected:
01618                 /**
01619                 * Create a new TypedList over the given List.
01620                 *
01621                 * @param ohListDelegate  the list to delegate to
01622                 */
01623                 TypedList(List::Holder ohListDelegate)
01624                     : super(ohListDelegate)
01625                     {
01626                     }
01627 
01628                 /**
01629                 * Copy constructor.
01630                 */
01631                 TypedList(const TypedList& that)
01632                     : super(that)
01633                     {
01634                     }
01635 
01636 
01637             // ----- TypedList interface --------------------------------
01638 
01639             public:
01640                 /**
01641                 * The typed version of the method List::get.
01642                 * <p>
01643                 * Return the element from the specified position in the list.
01644                 *
01645                 * @param i  the position of the item to return
01646                 *
01647                 * @return the element from the specified position in the list
01648                 *
01649                 * @throws coherence::lang::IndexOutOfBoundsException if the
01650                 *         index is out of range
01651                 *
01652                 * @throws ClassCastException
01653                 *         if the typed map is broken by external usage
01654                 */
01655                 virtual ValueType getTyped(size32_t i) const
01656                     {
01657                     return cast<ValueType>(super::get(i));
01658                     }
01659 
01660                 /**
01661                 * {@inheritDoc}
01662                 */
01663                 using super::contains;
01664 
01665                 /**
01666                 * The typed version of the method Collection::contains.
01667                 * Return true if this list contains the specified element.
01668                 *
01669                 * @param v element whose presence in this list is to be
01670                 *          tested
01671                 *
01672                 * @return true if this collection contains the specified
01673                 *         element
01674                 */
01675                 virtual bool contains(ValueType v) const
01676                     {
01677                     return super::contains(v);
01678                     }
01679 
01680                 /**
01681                 * The typed version of the method Collection::iterator.
01682                 * Return a handle to an TypedIterator over the elements in
01683                 * this list.
01684                 *
01685                 * @return a TypedIterator over the elements in this list
01686                 */
01687                 virtual typename TypedList::Iterator::Handle
01688                         iteratorTyped() const
01689                     {
01690                     return TypedList::Iterator::create(
01691                             Iterator::create(super::iterator()));
01692                     }
01693 
01694                 /**
01695                 * {@inheritDoc}
01696                 */
01697                 virtual coherence::util::Iterator::Handle iterator() const
01698                     {
01699                     return iteratorTyped();
01700                     }
01701 
01702                 /**
01703                 * {@inheritDoc}
01704                 */
01705                 virtual coherence::util::Muterator::Handle iterator()
01706                     {
01707                     return iteratorTyped();
01708                     }
01709 
01710                 /**
01711                 * The typed version of the method List::listIterator.
01712                 * <p>
01713                 * Return a handle to an TypedListIterator over the elements
01714                 * in this list.
01715                 *
01716                 * @return a TypedListIterator over the elements in this list
01717                 */
01718                 virtual typename TypedList::ListIterator::Handle
01719                         listIteratorTyped() const
01720                     {
01721                     return TypedList::ListIterator::create(
01722                             super::listIterator());
01723                     }
01724 
01725                 /**
01726                 * The typed version of the method List::listIterator.
01727                 * <p>
01728                 * Return a handle to an TypedListIterator over the elements
01729                 * in this list.
01730                 *
01731                 * @return a TypedListIterator over the elements in this list
01732                 */
01733                 virtual typename TypedList::ListIterator::Handle
01734                         listIteratorTyped()
01735                     {
01736                     return TypedList::ListIterator::create(
01737                         super::listIterator());
01738                     }
01739 
01740                 /**
01741                 * {@inheritDoc}
01742                 */
01743                 virtual coherence::util::ListIterator::Handle listIterator() const
01744                     {
01745                     return listIteratorTyped();
01746                     }
01747 
01748                 /**
01749                 * {@inheritDoc}
01750                 */
01751                 virtual coherence::util::ListMuterator::Handle listIterator()
01752                     {
01753                     return listIteratorTyped();
01754                     }
01755 
01756                 /**
01757                 * The typed version of the method Collection::iterator.
01758                 * <p> Return a handle to an TypedList Iterator over the
01759                 * elements in this list starting at the position specified.
01760                 *
01761                 * @param i  the position in the list that the iterator will
01762                 *           start at
01763                 *
01764                 * @return a TypedListIterator over the elements in this list
01765                 *         starting at the specified position in the list
01766                 */
01767                 virtual typename TypedList::ListIterator::Handle
01768                         listIteratorTyped(size32_t i) const
01769                     {
01770                     return TypedList::ListIterator::create(
01771                         super::listIterator(i));
01772                     }
01773 
01774                 /**
01775                 * The typed version of the method Collection::iterator.
01776                 * <p> Return a handle to an TypedList Iterator over the
01777                 * elements in this list starting at the position specified.
01778                 *
01779                 * @param i  the position in the list that the iterator will
01780                 *           start at
01781                 *
01782                 * @return a TypedListIterator over the elements in this list
01783                 *         starting at the specified position in the list
01784                 */
01785                 virtual typename TypedList::ListIterator::Handle
01786                         listIteratorTyped(size32_t i)
01787                     {
01788                     return TypedList::ListIterator::create(
01789                         super::listIterator(i));
01790                     }
01791 
01792                 /**
01793                 * {@inheritDoc}
01794                 */
01795                 virtual coherence::util::ListIterator::Handle
01796                         listIterator(size32_t i) const
01797                     {
01798                     return listIteratorTyped(i);
01799                     }
01800 
01801                 /**
01802                 * {@inheritDoc}
01803                 */
01804                 virtual coherence::util::ListMuterator::Handle
01805                         listIterator(size32_t i)
01806                     {
01807                     return listIteratorTyped(i);
01808                     }
01809 
01810                 /**
01811                 * {@inheritDoc}
01812                 */
01813                 using super::add;
01814 
01815                 /**
01816                 * The typed version of the method List::add. Add the
01817                 * specified element to this list if it is not already
01818                 * present.
01819                 *
01820                 * @param v element to be added to this list.
01821                 *
01822                 * @return true if this list changed as a result of the
01823                 *         call
01824                 *
01825                 * @throws coherence::lang::UnsupportedOperationException
01826                 *         if the #add() operation is not supported by this
01827                 *         list
01828                 */
01829                 virtual bool add(ValueType v)
01830                     {
01831                     return super::add(v);
01832                     }
01833 
01834                 /**
01835                 * {@inheritDoc}
01836                 */
01837                 using super::set;
01838 
01839                 /**
01840                 * The typed version of the method List::set.
01841                 * <p>
01842                 * Replace the element at the specified position in this list
01843                 * with the specified element.
01844                 *
01845                 * @param idx  the position in the list to replace
01846                 * @param v    the object to replace at the specified position
01847                 *
01848                 * @return the element at the specified position prior to this
01849                 *         operation
01850                 *
01851                 * @throw coherence::lang::IndexOutOfBoundsException if the
01852                 *        index is out of range
01853                 */
01854                 virtual ValueType set(size32_t idx, ValueType v)
01855                     {
01856                     return cast<ValueType>(super::set(idx, v));
01857                     }
01858 
01859                 /**
01860                 * {@inheritDoc}
01861                 */
01862                 using super::remove;
01863 
01864                 /**
01865                 * The typed version of the method Collection::remove. Remove
01866                 * the specified element from this list, if it is present.
01867                 *
01868                 * @param v element to be removed from this list, if present
01869                 *
01870                 * @return true if this list changed as a result of
01871                 *         the call
01872                 *
01873                 * @throws coherence::lang::UnsupportedOperationException
01874                 *         if the #remove() operation is not supported by this
01875                 *         list
01876                 */
01877                 virtual bool remove(ValueType v)
01878                     {
01879                     return super::remove(v);
01880                     }
01881 
01882                 /**
01883                 * The typed version of the method Collection::remove.
01884                 * <p> Remove the element at the specified position in the
01885                 * list.
01886                 *
01887                 * @param idx  the index from which to remove an element
01888                 *
01889                 * @return the element at the specified position prior to this
01890                 *         operation
01891                 *
01892                 * @throw coherence::lang::IndexOutOfBoundsException if the
01893                 *        index is out of range
01894                 */
01895                 virtual ValueType removeTyped(size32_t idx)
01896                     {
01897                     return cast<ValueType>(super::remove(idx));
01898                     }
01899 
01900                 /**
01901                 * {@inheritDoc}
01902                 */
01903                 using super::addAll;
01904 
01905 #if (!defined(_MSC_VER) || _MSC_VER==1400) // COH-3357 - works on all compilers but VS2008+
01906                 /**
01907                 * The typed version of the method Collection::addAll.
01908                 *
01909                 * Add all of the elements in the specified TypedCollection to
01910                 * this list.
01911                 *
01912                 * @param vtc TypedCollection of elements to be inserted into
01913                 *            this list
01914                 *
01915                 * @return true if this list changed as a result of the call
01916                 *
01917                 * @throws coherence::lang::NullPointerException
01918                 *         if the specified collection is NULL
01919                 * @throws coherence::lang::UnsupportedOperationException
01920                 *         if the #add() operation is not supported by this
01921                 *         list
01922                 */
01923                 virtual bool addAll(typename
01924                                 TypedCollection<ValueType>::View vtc)
01925                     {
01926                     return super::addAll(vtc);
01927                     }
01928 
01929                 /**
01930                 * The typed version of the method Collection::addAll.
01931                 *
01932                 * Add all of the elements in the specified TypedCollection to
01933                 * this list.
01934                 *
01935                 * @param htc TypedCollection of elements to be inserted into
01936                 *            this list
01937                 *
01938                 * @return true if this list changed as a result of the call
01939                 *
01940                 * @throws coherence::lang::NullPointerException
01941                 *         if the specified collection is NULL
01942                 * @throws coherence::lang::UnsupportedOperationException
01943                 *         if the #add() operation is not supported by this
01944                 *         list
01945                 */
01946                 virtual bool addAll(typename
01947                                 TypedCollection<ValueType>::Handle htc)
01948                     {
01949                     return super::addAll(htc);
01950                     }
01951 #endif
01952 
01953                 /**
01954                 * The typed version of the method Collection::addAll.
01955                 *
01956                 * Add all of the elements in the specified TypedList to this
01957                 * list.
01958                 *
01959                 * @param vtl TypedList of elements to be inserted into
01960                 *            this list
01961                 *
01962                 * @return true if this list changed as a result of the call
01963                 *
01964                 * @throws coherence::lang::NullPointerException
01965                 *         if the specified collection is NULL
01966                 * @throws coherence::lang::UnsupportedOperationException
01967                 *         if the #add() operation is not supported by this
01968                 *         list
01969                 */
01970                 virtual bool addAll(
01971                         typename TypedList<ValueType>::View vtl)
01972                     {
01973                     return super::addAll(vtl);
01974                     }
01975 
01976                 /**
01977                 * The typed version of the method Collection::addAll.
01978                 *
01979                 * Add all of the elements in the specified TypedList to this
01980                 * list.
01981                 *
01982                 * @param htl TypedList of elements to be inserted into
01983                 *            this list
01984                 *
01985                 * @return true if this list changed as a result of the call
01986                 *
01987                 * @throws coherence::lang::NullPointerException
01988                 *         if the specified collection is NULL
01989                 * @throws coherence::lang::UnsupportedOperationException
01990                 *         if the #add() operation is not supported by this
01991                 *         list
01992                 */
01993                 virtual bool addAll(
01994                         typename TypedList<ValueType>::Handle htl)
01995                     {
01996                     return super::addAll(htl);
01997                     }
01998 
01999                 /**
02000                 * {@inheritDoc}
02001                 */
02002                 using super::removeAll;
02003 
02004 #if (!defined(_MSC_VER) || _MSC_VER==1400) // COH-3357 - works on all compilers but VS2008+
02005                 /**
02006                 * The typed version of the method Collection::removeAll.
02007                 *
02008                 * Remove all this list's elements that are also contained in
02009                 * the specified typed collection.
02010                 *
02011                 * @param vtc elements to be removed from this list
02012                 *
02013                 * @return true if this list changed as a result of
02014                 *         the call
02015                 *
02016                 * @throws coherence::lang::NullPointerException
02017                 *         if the specified collection is NULL
02018                 * @throws coherence::lang::UnsupportedOperationException
02019                 *         if the #remove() operation is not supported by this
02020                 *         list
02021                 */
02022                 virtual bool removeAll(typename
02023                                 TypedCollection<ValueType>::View vtc)
02024                     {
02025                     return super::removeAll(vtc);
02026                     }
02027 
02028                 /**
02029                 * The typed version of the method Collection::removeAll.
02030                 *
02031                 * Remove all this list's elements that are also contained in
02032                 * the specified typed collection.
02033                 *
02034                 * @param htc elements to be removed from this list
02035                 *
02036                 * @return true if this list changed as a result of
02037                 *         the call
02038                 *
02039                 * @throws coherence::lang::NullPointerException
02040                 *         if the specified collection is NULL
02041                 * @throws coherence::lang::UnsupportedOperationException
02042                 *         if the #remove() operation is not supported by this
02043                 *         list
02044                 */
02045                 virtual bool removeAll(typename
02046                                 TypedCollection<ValueType>::Handle htc)
02047                     {
02048                     return super::removeAll(htc);
02049                     }
02050 #endif
02051 
02052                 /**
02053                 * The typed version of the method Collection::removeAll.
02054                 *
02055                 * Remove all this list's elements that are also contained in
02056                 * the specified typed list.
02057                 *
02058                 * @param vtl elements to be removed from this list
02059                 *
02060                 * @return true if this list changed as a result of
02061                 *         the call
02062                 *
02063                 * @throws coherence::lang::NullPointerException
02064                 *         if the specified collection is NULL
02065                 * @throws coherence::lang::UnsupportedOperationException
02066                 *         if the #remove() operation is not supported by this
02067                 *         list
02068                 */
02069                 virtual bool removeAll(typename
02070                                 TypedList<ValueType>::View vtl)
02071                     {
02072                     return super::removeAll(vtl);
02073                     }
02074 
02075                 /**
02076                 * The typed version of the method Collection::removeAll.
02077                 *
02078                 * Remove all this list's elements that are also contained in
02079                 * the specified typed list.
02080                 *
02081                 * @param htl elements to be removed from this list
02082                 *
02083                 * @return true if this list changed as a result of
02084                 *         the call
02085                 *
02086                 * @throws coherence::lang::NullPointerException
02087                 *         if the specified collection is NULL
02088                 * @throws coherence::lang::UnsupportedOperationException
02089                 *         if the #remove() operation is not supported by this
02090                 *         list
02091                 */
02092                 virtual bool removeAll(typename
02093                                 TypedList<ValueType>::Handle htl)
02094                     {
02095                     return super::removeAll(htl);
02096                     }
02097 
02098                 /**
02099                 * {@inheritDoc}
02100                 */
02101                 using super::retainAll;
02102 
02103 #if (!defined(_MSC_VER) || _MSC_VER==1400) // COH-3357 - works on all compilers but VS2008+
02104                 /**
02105                 * The typed version of the method Collection::retainAll.
02106                 *
02107                 * Retain only the elements in this list that are
02108                 * contained in the specified typed collection.
02109                 *
02110                 * @param vtc elements to be retained in this list
02111                 *
02112                 * @return true if this list changed as a result of
02113                 *         the call
02114                 *
02115                 * @throws coherence::lang::NullPointerException
02116                 *         if the specified collection is NULL
02117                 * @throws coherence::lang::UnsupportedOperationException
02118                 *         if the #remove() operation is not supported by this
02119                 *         list
02120                 */
02121                 virtual bool retainAll(typename
02122                                 TypedCollection<ValueType>::View vtc)
02123                     {
02124                     return super::retainAll(vtc);
02125                     }
02126 
02127                 /**
02128                 * The typed version of the method Collection::retainAll.
02129                 *
02130                 * Retain only the elements in this list that are
02131                 * contained in the specified typed collection.
02132                 *
02133                 * @param htc elements to be retained in this list
02134                 *
02135                 * @return true if this list changed as a result of
02136                 *         the call
02137                 *
02138                 * @throws coherence::lang::NullPointerException
02139                 *         if the specified collection is NULL
02140                 * @throws coherence::lang::UnsupportedOperationException
02141                 *         if the #remove() operation is not supported by this
02142                 *         list
02143                 */
02144                 virtual bool retainAll(typename
02145                                 TypedCollection<ValueType>::Handle htc)
02146                     {
02147                     return super::retainAll(htc);
02148                     }
02149 #endif
02150 
02151                 /**
02152                 * The typed version of the method Collection::retainAll.
02153                 *
02154                 * Retain only the elements in this list that are
02155                 * contained in the specified typed list.
02156                 *
02157                 * @param vtl elements to be retained in this list
02158                 *
02159                 * @return true if this list changed as a result of
02160                 *         the call
02161                 *
02162                 * @throws coherence::lang::NullPointerException
02163                 *         if the specified collection is NULL
02164                 * @throws coherence::lang::UnsupportedOperationException
02165                 *         if the #remove() operation is not supported by this
02166                 *         list
02167                 */
02168                 virtual bool retainAll(typename
02169                                 TypedList<ValueType>::View vtl)
02170                     {
02171                     return super::retainAll(vtl);
02172                     }
02173 
02174                 /**
02175                 * The typed version of the method Collection::retainAll.
02176                 *
02177                 * Retain only the elements in this list that are
02178                 * contained in the specified typed list.
02179                 *
02180                 * @param htl elements to be retained in this list
02181                 *
02182                 * @return true if this list changed as a result of
02183                 *         the call
02184                 *
02185                 * @throws coherence::lang::NullPointerException
02186                 *         if the specified collection is NULL
02187                 * @throws coherence::lang::UnsupportedOperationException
02188                 *         if the #remove() operation is not supported by this
02189                 *         list
02190                 */
02191                 virtual bool retainAll(typename
02192                                 TypedList<ValueType>::Handle htl)
02193                     {
02194                     return super::retainAll(htl);
02195                     }
02196 
02197                 /**
02198                 * Convert a TypedList to a TypedCollection, wrapping the same
02199                 * underlying Collection::Handle.
02200                 *
02201                 * @return a handle to the new TypedCollection
02202                 */
02203                 virtual typename TypedCollection<ValueType>::Handle
02204                         asTypedCollection()
02205                     {
02206                     return TypedCollection<ValueType>::create(
02207                         cast<Collection::Handle>(super::getDelegate()));
02208                     }
02209 
02210                 /**
02211                 * Convert a TypedList to a TypedCollection, wrapping the same
02212                 * underlying Collection::View.
02213                 *
02214                 * @return a view to the new TypedCollection
02215                 */
02216                 virtual typename TypedCollection<ValueType>::View
02217                         asTypedCollection() const
02218                     {
02219                     return TypedCollection<ValueType>::create(
02220                         cast<Collection::View>(super::getDelegate()));
02221                     }
02222 
02223                 /**
02224                 * The typed version of the method Collection::subList.
02225                 * <p> Return a new typed list containing the contents of the
02226                 * list between the specified fromIndex (inclusive) and
02227                 * toIndex (exclusive).
02228                 *
02229                 * @param fromIndex  the start position in this list to create
02230                 *                   the sublist from (inclusive).
02231                 * @param toIndex    the end position in this list to end the
02232                 *                   sublist at (exclusive).
02233                 *
02234                 * @return the new typed sublist of this typed list
02235                 */
02236                 virtual typename TypedList::Handle subListTyped(
02237                         size32_t fromIndex, size32_t toIndex)
02238                     {
02239                     return create(super::subList(fromIndex, toIndex));
02240                     }
02241 
02242                 /**
02243                 * The typed version of the method Collection::subList.
02244                 * <p> Return a new typed list containing the contents of the
02245                 * list between the specified fromIndex (inclusive) and
02246                 * toIndex (exclusive).
02247                 *
02248                 * @param fromIndex  the start position in this list to create
02249                 *                   the sublist from (inclusive).
02250                 * @param toIndex    the end position in this list to end the
02251                 *                   sublist at (exclusive).
02252                 *
02253                 * @return the new typed sublist of this typed list
02254                 */
02255                 virtual typename TypedList::Handle subListTyped(
02256                         size32_t fromIndex, size32_t toIndex) const
02257                     {
02258                     return create(super::subList(fromIndex, toIndex));
02259                     }
02260             };
02261     };
02262 
02263 COH_CLOSE_NAMESPACE2
02264 
02265 #endif // COH_TYPED_COLLECTIONS_HPP
Copyright © 2000, 2010, Oracle and/or its affiliates. All rights reserved.