byte value
+ * @return true if the collection contains the specified element.
+ */
+ boolean contains( byte entry );
+
+
+ /**
+ * Creates an iterator over the values of the collection. The iterator
+ * supports element deletion.
+ *
+ * @return an TByteIterator value
+ */
+ TByteIterator iterator();
+
+
+ /**
+ * Returns an array containing all of the elements in this collection.
+ * If this collection makes any guarantees as to what order its elements
+ * are returned by its iterator, this method must return the
+ * elements in the same order.
+ *
+ * The returned array will be "safe" in that no references to it + * are maintained by this collection. (In other words, this method must + * allocate a new array even if this collection is backed by an array). + * The caller is thus free to modify the returned array. + * + *
This method acts as bridge between array-based and collection-based + * APIs. + * + * @return an array containing all the elements in this collection + */ + byte[] toArray(); + + + /** + * Returns an array containing elements in this collection. + * + *
If this collection fits in the specified array with room to spare + * (i.e., the array has more elements than this collection), the element in + * the array immediately following the end of the collection is collection to + * {@link #getNoEntryValue()}. (This is useful in determining + * the length of this collection only if the caller knows that this + * collection does not contain any elements representing null.) + * + *
If the native array is smaller than the collection size, + * the array will be filled with elements in Iterator order + * until it is full and exclude the remainder. + * + *
If this collection makes any guarantees as to what order its elements
+ * are returned by its iterator, this method must return the elements
+ * in the same order.
+ *
+ * @param dest the array into which the elements of this collection are to be
+ * stored.
+ * @return an byte[] containing all the elements in this collection
+ * @throws NullPointerException if the specified array is null
+ */
+ byte[] toArray( byte[] dest );
+
+
+ /**
+ * Inserts a value into the collection.
+ *
+ * @param entry a byte value
+ * @return true if the collection was modified by the add operation
+ */
+ boolean add( byte entry );
+
+
+ /**
+ * Removes entry from the collection.
+ *
+ * @param entry an byte value
+ * @return true if the collection was modified by the remove operation.
+ */
+ boolean remove( byte entry );
+
+
+ /**
+ * Tests the collection to determine if all of the elements in
+ * collection are present.
+ *
+ * @param collection a Collection value
+ * @return true if all elements were present in the collection.
+ */
+ boolean containsAll( Collection collection );
+
+
+ /**
+ * Tests the collection to determine if all of the elements in
+ * TByteCollection are present.
+ *
+ * @param collection a TByteCollection value
+ * @return true if all elements were present in the collection.
+ */
+ boolean containsAll( TByteCollection collection );
+
+
+ /**
+ * Tests the collection to determine if all of the elements in
+ * array are present.
+ *
+ * @param array as array of byte primitives.
+ * @return true if all elements were present in the collection.
+ */
+ boolean containsAll( byte[] array );
+
+
+ /**
+ * Adds all of the elements in collection to the collection.
+ *
+ * @param collection a Collection value
+ * @return true if the collection was modified by the add all operation.
+ */
+ boolean addAll( Collection collection );
+
+
+ /**
+ * Adds all of the elements in the TByteCollection to the collection.
+ *
+ * @param collection a TByteCollection value
+ * @return true if the collection was modified by the add all operation.
+ */
+ boolean addAll( TByteCollection collection );
+
+
+ /**
+ * Adds all of the elements in the array to the collection.
+ *
+ * @param array a array of byte primitives.
+ * @return true if the collection was modified by the add all operation.
+ */
+ boolean addAll( byte[] array );
+
+
+ /**
+ * Removes any values in the collection which are not contained in
+ * collection.
+ *
+ * @param collection a Collection value
+ * @return true if the collection was modified by the retain all operation
+ */
+ boolean retainAll( Collection collection );
+
+
+ /**
+ * Removes any values in the collection which are not contained in
+ * TByteCollection.
+ *
+ * @param collection a TByteCollection value
+ * @return true if the collection was modified by the retain all operation
+ */
+ boolean retainAll( TByteCollection collection );
+
+
+ /**
+ * Removes any values in the collection which are not contained in
+ * array.
+ *
+ * @param array an array of byte primitives.
+ * @return true if the collection was modified by the retain all operation
+ */
+ boolean retainAll( byte[] array );
+
+
+ /**
+ * Removes all of the elements in collection from the collection.
+ *
+ * @param collection a Collection value
+ * @return true if the collection was modified by the remove all operation.
+ */
+ boolean removeAll( Collection collection );
+
+
+ /**
+ * Removes all of the elements in TByteCollection from the collection.
+ *
+ * @param collection a TByteCollection value
+ * @return true if the collection was modified by the remove all operation.
+ */
+ boolean removeAll( TByteCollection collection );
+
+
+ /**
+ * Removes all of the elements in array from the collection.
+ *
+ * @param array an array of byte primitives.
+ * @return true if the collection was modified by the remove all operation.
+ */
+ boolean removeAll( byte[] array );
+
+
+ /**
+ * Empties the collection.
+ */
+ void clear();
+
+
+ /**
+ * Executes procedure for each element in the collection.
+ *
+ * @param procedure a TByteProcedure value
+ * @return false if the loop over the collection terminated because
+ * the procedure returned false for some value.
+ */
+ boolean forEach( TByteProcedure procedure );
+
+
+ // Comparison and hashing
+
+ /**
+ * Compares the specified object with this collection for equality. Returns
+ * true if the specified object is also a collection, the two collection
+ * have the same size, and every member of the specified collection is
+ * contained in this collection (or equivalently, every member of this collection is
+ * contained in the specified collection). This definition ensures that the
+ * equals method works properly across different implementations of the
+ * collection interface.
+ *
+ * @param o object to be compared for equality with this collection
+ * @return true if the specified object is equal to this collection
+ */
+ boolean equals( Object o );
+
+
+ /**
+ * Returns the hash code value for this collection. The hash code of a collection is
+ * defined to be the sum of the hash codes of the elements in the collection.
+ * This ensures that s1.equals(s2) implies that
+ * s1.hashCode()==s2.hashCode() for any two collection s1
+ * and s2, as required by the general contract of
+ * {@link Object#hashCode}.
+ *
+ * @return the hash code value for this collection
+ * @see Object#equals(Object)
+ * @see Collection#equals(Object)
+ */
+ int hashCode();
+
+
+} // TByteCollection
diff --git a/src/gnu/trove/TCharCollection.java b/src/gnu/trove/TCharCollection.java
new file mode 100644
index 0000000..6b49f60
--- /dev/null
+++ b/src/gnu/trove/TCharCollection.java
@@ -0,0 +1,316 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (c) 2001, Eric D. Friedman All Rights Reserved.
+// Copyright (c) 2009, Rob Eden All Rights Reserved.
+// Copyright (c) 2009, Jeff Randall All Rights Reserved.
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+///////////////////////////////////////////////////////////////////////////////
+
+package gnu.trove;
+
+
+import java.util.Collection;
+
+//////////////////////////////////////////////////
+// THIS IS A GENERATED CLASS. DO NOT HAND EDIT! //
+//////////////////////////////////////////////////
+
+import gnu.trove.iterator.TCharIterator;
+import gnu.trove.procedure.TCharProcedure;
+
+/**
+ * An interface that mimics the Collection interface.
+ *
+ * @author Eric D. Friedman
+ * @author Rob Eden
+ * @author Jeff Randall
+ * @version $Id: _E_Collection.template,v 1.1.2.2 2009/09/15 02:38:30 upholderoftruth Exp $
+ */
+
+public interface TCharCollection {
+ static final long serialVersionUID = 1L;
+
+ /**
+ * Returns the value that is used to represent null. The default
+ * value is generally zero, but can be changed during construction
+ * of the collection.
+ *
+ * @return the value that represents null
+ */
+ char getNoEntryValue();
+
+
+ /**
+ * Returns the number of elements in this collection (its cardinality). If this
+ * collection contains more than Integer.MAX_VALUE elements, returns
+ * Integer.MAX_VALUE.
+ *
+ * @return the number of elements in this collection (its cardinality)
+ */
+ int size();
+
+
+ /**
+ * Returns true if this collection contains no elements.
+ *
+ * @return true if this collection contains no elements
+ */
+ boolean isEmpty();
+
+
+ /**
+ * Returns true if this collection contains the specified element.
+ *
+ * @param entry an char value
+ * @return true if the collection contains the specified element.
+ */
+ boolean contains( char entry );
+
+
+ /**
+ * Creates an iterator over the values of the collection. The iterator
+ * supports element deletion.
+ *
+ * @return an TCharIterator value
+ */
+ TCharIterator iterator();
+
+
+ /**
+ * Returns an array containing all of the elements in this collection.
+ * If this collection makes any guarantees as to what order its elements
+ * are returned by its iterator, this method must return the
+ * elements in the same order.
+ *
+ *
The returned array will be "safe" in that no references to it + * are maintained by this collection. (In other words, this method must + * allocate a new array even if this collection is backed by an array). + * The caller is thus free to modify the returned array. + * + *
This method acts as bridge between array-based and collection-based + * APIs. + * + * @return an array containing all the elements in this collection + */ + char[] toArray(); + + + /** + * Returns an array containing elements in this collection. + * + *
If this collection fits in the specified array with room to spare + * (i.e., the array has more elements than this collection), the element in + * the array immediately following the end of the collection is collection to + * {@link #getNoEntryValue()}. (This is useful in determining + * the length of this collection only if the caller knows that this + * collection does not contain any elements representing null.) + * + *
If the native array is smaller than the collection size, + * the array will be filled with elements in Iterator order + * until it is full and exclude the remainder. + * + *
If this collection makes any guarantees as to what order its elements
+ * are returned by its iterator, this method must return the elements
+ * in the same order.
+ *
+ * @param dest the array into which the elements of this collection are to be
+ * stored.
+ * @return an char[] containing all the elements in this collection
+ * @throws NullPointerException if the specified array is null
+ */
+ char[] toArray( char[] dest );
+
+
+ /**
+ * Inserts a value into the collection.
+ *
+ * @param entry a char value
+ * @return true if the collection was modified by the add operation
+ */
+ boolean add( char entry );
+
+
+ /**
+ * Removes entry from the collection.
+ *
+ * @param entry an char value
+ * @return true if the collection was modified by the remove operation.
+ */
+ boolean remove( char entry );
+
+
+ /**
+ * Tests the collection to determine if all of the elements in
+ * collection are present.
+ *
+ * @param collection a Collection value
+ * @return true if all elements were present in the collection.
+ */
+ boolean containsAll( Collection collection );
+
+
+ /**
+ * Tests the collection to determine if all of the elements in
+ * TCharCollection are present.
+ *
+ * @param collection a TCharCollection value
+ * @return true if all elements were present in the collection.
+ */
+ boolean containsAll( TCharCollection collection );
+
+
+ /**
+ * Tests the collection to determine if all of the elements in
+ * array are present.
+ *
+ * @param array as array of char primitives.
+ * @return true if all elements were present in the collection.
+ */
+ boolean containsAll( char[] array );
+
+
+ /**
+ * Adds all of the elements in collection to the collection.
+ *
+ * @param collection a Collection value
+ * @return true if the collection was modified by the add all operation.
+ */
+ boolean addAll( Collection collection );
+
+
+ /**
+ * Adds all of the elements in the TCharCollection to the collection.
+ *
+ * @param collection a TCharCollection value
+ * @return true if the collection was modified by the add all operation.
+ */
+ boolean addAll( TCharCollection collection );
+
+
+ /**
+ * Adds all of the elements in the array to the collection.
+ *
+ * @param array a array of char primitives.
+ * @return true if the collection was modified by the add all operation.
+ */
+ boolean addAll( char[] array );
+
+
+ /**
+ * Removes any values in the collection which are not contained in
+ * collection.
+ *
+ * @param collection a Collection value
+ * @return true if the collection was modified by the retain all operation
+ */
+ boolean retainAll( Collection collection );
+
+
+ /**
+ * Removes any values in the collection which are not contained in
+ * TCharCollection.
+ *
+ * @param collection a TCharCollection value
+ * @return true if the collection was modified by the retain all operation
+ */
+ boolean retainAll( TCharCollection collection );
+
+
+ /**
+ * Removes any values in the collection which are not contained in
+ * array.
+ *
+ * @param array an array of char primitives.
+ * @return true if the collection was modified by the retain all operation
+ */
+ boolean retainAll( char[] array );
+
+
+ /**
+ * Removes all of the elements in collection from the collection.
+ *
+ * @param collection a Collection value
+ * @return true if the collection was modified by the remove all operation.
+ */
+ boolean removeAll( Collection collection );
+
+
+ /**
+ * Removes all of the elements in TCharCollection from the collection.
+ *
+ * @param collection a TCharCollection value
+ * @return true if the collection was modified by the remove all operation.
+ */
+ boolean removeAll( TCharCollection collection );
+
+
+ /**
+ * Removes all of the elements in array from the collection.
+ *
+ * @param array an array of char primitives.
+ * @return true if the collection was modified by the remove all operation.
+ */
+ boolean removeAll( char[] array );
+
+
+ /**
+ * Empties the collection.
+ */
+ void clear();
+
+
+ /**
+ * Executes procedure for each element in the collection.
+ *
+ * @param procedure a TCharProcedure value
+ * @return false if the loop over the collection terminated because
+ * the procedure returned false for some value.
+ */
+ boolean forEach( TCharProcedure procedure );
+
+
+ // Comparison and hashing
+
+ /**
+ * Compares the specified object with this collection for equality. Returns
+ * true if the specified object is also a collection, the two collection
+ * have the same size, and every member of the specified collection is
+ * contained in this collection (or equivalently, every member of this collection is
+ * contained in the specified collection). This definition ensures that the
+ * equals method works properly across different implementations of the
+ * collection interface.
+ *
+ * @param o object to be compared for equality with this collection
+ * @return true if the specified object is equal to this collection
+ */
+ boolean equals( Object o );
+
+
+ /**
+ * Returns the hash code value for this collection. The hash code of a collection is
+ * defined to be the sum of the hash codes of the elements in the collection.
+ * This ensures that s1.equals(s2) implies that
+ * s1.hashCode()==s2.hashCode() for any two collection s1
+ * and s2, as required by the general contract of
+ * {@link Object#hashCode}.
+ *
+ * @return the hash code value for this collection
+ * @see Object#equals(Object)
+ * @see Collection#equals(Object)
+ */
+ int hashCode();
+
+
+} // TCharCollection
diff --git a/src/gnu/trove/TCollections.java b/src/gnu/trove/TCollections.java
new file mode 100644
index 0000000..8e0b22c
--- /dev/null
+++ b/src/gnu/trove/TCollections.java
@@ -0,0 +1,4362 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (c) 2008, Robert D. Eden All Rights Reserved.
+// Copyright (c) 2009, Jeff Randall All Rights Reserved.
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+///////////////////////////////////////////////////////////////////////////////
+
+package gnu.trove;
+
+
+//////////////////////////////////////////////////
+// THIS IS A GENERATED CLASS. DO NOT HAND EDIT! //
+//////////////////////////////////////////////////
+
+
+import gnu.trove.set.*;
+import gnu.trove.list.*;
+import gnu.trove.map.*;
+import gnu.trove.impl.unmodifiable.*;
+import gnu.trove.impl.sync.*;
+
+import java.util.RandomAccess;
+
+
+/**
+ * Trove equivalent of the {@link java.util.Collections} class.
+ */
+@SuppressWarnings({})
+public class TCollections {
+
+ // Disallow creation of instances of this class
+ private TCollections() { }
+
+
+///////////////////////////
+// TUnmodifiableCollections
+
+ /**
+ * Returns an unmodifiable view of the specified Trove primitive collection. This method
+ * allows modules to provide users with "read-only" access to internal
+ * collections. Query operations on the returned collection "read through"
+ * to the specified collection, and attempts to modify the returned
+ * collection, whether direct or via its iterator, result in an
+ * UnsupportedOperationException.
+ * + * The returned collection does not pass the hashCode and equals + * operations through to the backing collection, but relies on + * Object's equals and hashCode methods. This + * is necessary to preserve the contracts of these operations in the case + * that the backing collection is a set or a list.
+ * + * The returned collection will be serializable if the specified collection + * is serializable. + * + * @param c the collection for which an unmodifiable view is to be + * returned. + * @return an unmodifiable view of the specified Trove primitive collection. + */ + public static TDoubleCollection unmodifiableCollection( TDoubleCollection c ) { + return new TUnmodifiableDoubleCollection( c ); + } + + + /** + * Returns an unmodifiable view of the specified Trove primitive collection. This method + * allows modules to provide users with "read-only" access to internal + * collections. Query operations on the returned collection "read through" + * to the specified collection, and attempts to modify the returned + * collection, whether direct or via its iterator, result in an + * UnsupportedOperationException.
+ * + * The returned collection does not pass the hashCode and equals + * operations through to the backing collection, but relies on + * Object's equals and hashCode methods. This + * is necessary to preserve the contracts of these operations in the case + * that the backing collection is a set or a list.
+ * + * The returned collection will be serializable if the specified collection + * is serializable. + * + * @param c the collection for which an unmodifiable view is to be + * returned. + * @return an unmodifiable view of the specified Trove primitive collection. + */ + public static TFloatCollection unmodifiableCollection( TFloatCollection c ) { + return new TUnmodifiableFloatCollection( c ); + } + + + /** + * Returns an unmodifiable view of the specified Trove primitive collection. This method + * allows modules to provide users with "read-only" access to internal + * collections. Query operations on the returned collection "read through" + * to the specified collection, and attempts to modify the returned + * collection, whether direct or via its iterator, result in an + * UnsupportedOperationException.
+ * + * The returned collection does not pass the hashCode and equals + * operations through to the backing collection, but relies on + * Object's equals and hashCode methods. This + * is necessary to preserve the contracts of these operations in the case + * that the backing collection is a set or a list.
+ * + * The returned collection will be serializable if the specified collection + * is serializable. + * + * @param c the collection for which an unmodifiable view is to be + * returned. + * @return an unmodifiable view of the specified Trove primitive collection. + */ + public static TIntCollection unmodifiableCollection( TIntCollection c ) { + return new TUnmodifiableIntCollection( c ); + } + + + /** + * Returns an unmodifiable view of the specified Trove primitive collection. This method + * allows modules to provide users with "read-only" access to internal + * collections. Query operations on the returned collection "read through" + * to the specified collection, and attempts to modify the returned + * collection, whether direct or via its iterator, result in an + * UnsupportedOperationException.
+ * + * The returned collection does not pass the hashCode and equals + * operations through to the backing collection, but relies on + * Object's equals and hashCode methods. This + * is necessary to preserve the contracts of these operations in the case + * that the backing collection is a set or a list.
+ * + * The returned collection will be serializable if the specified collection + * is serializable. + * + * @param c the collection for which an unmodifiable view is to be + * returned. + * @return an unmodifiable view of the specified Trove primitive collection. + */ + public static TLongCollection unmodifiableCollection( TLongCollection c ) { + return new TUnmodifiableLongCollection( c ); + } + + + /** + * Returns an unmodifiable view of the specified Trove primitive collection. This method + * allows modules to provide users with "read-only" access to internal + * collections. Query operations on the returned collection "read through" + * to the specified collection, and attempts to modify the returned + * collection, whether direct or via its iterator, result in an + * UnsupportedOperationException.
+ * + * The returned collection does not pass the hashCode and equals + * operations through to the backing collection, but relies on + * Object's equals and hashCode methods. This + * is necessary to preserve the contracts of these operations in the case + * that the backing collection is a set or a list.
+ * + * The returned collection will be serializable if the specified collection + * is serializable. + * + * @param c the collection for which an unmodifiable view is to be + * returned. + * @return an unmodifiable view of the specified Trove primitive collection. + */ + public static TByteCollection unmodifiableCollection( TByteCollection c ) { + return new TUnmodifiableByteCollection( c ); + } + + + /** + * Returns an unmodifiable view of the specified Trove primitive collection. This method + * allows modules to provide users with "read-only" access to internal + * collections. Query operations on the returned collection "read through" + * to the specified collection, and attempts to modify the returned + * collection, whether direct or via its iterator, result in an + * UnsupportedOperationException.
+ * + * The returned collection does not pass the hashCode and equals + * operations through to the backing collection, but relies on + * Object's equals and hashCode methods. This + * is necessary to preserve the contracts of these operations in the case + * that the backing collection is a set or a list.
+ * + * The returned collection will be serializable if the specified collection + * is serializable. + * + * @param c the collection for which an unmodifiable view is to be + * returned. + * @return an unmodifiable view of the specified Trove primitive collection. + */ + public static TShortCollection unmodifiableCollection( TShortCollection c ) { + return new TUnmodifiableShortCollection( c ); + } + + + /** + * Returns an unmodifiable view of the specified Trove primitive collection. This method + * allows modules to provide users with "read-only" access to internal + * collections. Query operations on the returned collection "read through" + * to the specified collection, and attempts to modify the returned + * collection, whether direct or via its iterator, result in an + * UnsupportedOperationException.
+ * + * The returned collection does not pass the hashCode and equals + * operations through to the backing collection, but relies on + * Object's equals and hashCode methods. This + * is necessary to preserve the contracts of these operations in the case + * that the backing collection is a set or a list.
+ * + * The returned collection will be serializable if the specified collection + * is serializable. + * + * @param c the collection for which an unmodifiable view is to be + * returned. + * @return an unmodifiable view of the specified Trove primitive collection. + */ + public static TCharCollection unmodifiableCollection( TCharCollection c ) { + return new TUnmodifiableCharCollection( c ); + } + + + + /** + * Returns an unmodifiable view of the specified Trove primitive set. This method allows + * modules to provide users with "read-only" access to internal sets. + * Query operations on the returned set "read through" to the specified + * set, and attempts to modify the returned set, whether direct or via its + * iterator, result in an UnsupportedOperationException.
+ * + * The returned set will be serializable if the specified set + * is serializable. + * + * @param s the set for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive set. + */ + public static TDoubleSet unmodifiableSet( TDoubleSet s ) { + return new TUnmodifiableDoubleSet( s ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive set. This method allows + * modules to provide users with "read-only" access to internal sets. + * Query operations on the returned set "read through" to the specified + * set, and attempts to modify the returned set, whether direct or via its + * iterator, result in an UnsupportedOperationException.
+ * + * The returned set will be serializable if the specified set + * is serializable. + * + * @param s the set for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive set. + */ + public static TFloatSet unmodifiableSet( TFloatSet s ) { + return new TUnmodifiableFloatSet( s ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive set. This method allows + * modules to provide users with "read-only" access to internal sets. + * Query operations on the returned set "read through" to the specified + * set, and attempts to modify the returned set, whether direct or via its + * iterator, result in an UnsupportedOperationException.
+ * + * The returned set will be serializable if the specified set + * is serializable. + * + * @param s the set for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive set. + */ + public static TIntSet unmodifiableSet( TIntSet s ) { + return new TUnmodifiableIntSet( s ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive set. This method allows + * modules to provide users with "read-only" access to internal sets. + * Query operations on the returned set "read through" to the specified + * set, and attempts to modify the returned set, whether direct or via its + * iterator, result in an UnsupportedOperationException.
+ * + * The returned set will be serializable if the specified set + * is serializable. + * + * @param s the set for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive set. + */ + public static TLongSet unmodifiableSet( TLongSet s ) { + return new TUnmodifiableLongSet( s ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive set. This method allows + * modules to provide users with "read-only" access to internal sets. + * Query operations on the returned set "read through" to the specified + * set, and attempts to modify the returned set, whether direct or via its + * iterator, result in an UnsupportedOperationException.
+ * + * The returned set will be serializable if the specified set + * is serializable. + * + * @param s the set for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive set. + */ + public static TByteSet unmodifiableSet( TByteSet s ) { + return new TUnmodifiableByteSet( s ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive set. This method allows + * modules to provide users with "read-only" access to internal sets. + * Query operations on the returned set "read through" to the specified + * set, and attempts to modify the returned set, whether direct or via its + * iterator, result in an UnsupportedOperationException.
+ * + * The returned set will be serializable if the specified set + * is serializable. + * + * @param s the set for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive set. + */ + public static TShortSet unmodifiableSet( TShortSet s ) { + return new TUnmodifiableShortSet( s ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive set. This method allows + * modules to provide users with "read-only" access to internal sets. + * Query operations on the returned set "read through" to the specified + * set, and attempts to modify the returned set, whether direct or via its + * iterator, result in an UnsupportedOperationException.
+ * + * The returned set will be serializable if the specified set + * is serializable. + * + * @param s the set for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive set. + */ + public static TCharSet unmodifiableSet( TCharSet s ) { + return new TUnmodifiableCharSet( s ); + } + + + /** + * Returns an unmodifiable view of the specified Trove primitive list. This method allows + * modules to provide users with "read-only" access to internal + * lists. Query operations on the returned list "read through" to the + * specified list, and attempts to modify the returned list, whether + * direct or via its iterator, result in an + * UnsupportedOperationException.
+ * + * The returned list will be serializable if the specified list + * is serializable. Similarly, the returned list will implement + * {@link RandomAccess} if the specified list does. + * + * @param list the list for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive list. + */ + public static TDoubleList unmodifiableList( TDoubleList list) { + return ( list instanceof RandomAccess ? + new TUnmodifiableRandomAccessDoubleList( list ) : + new TUnmodifiableDoubleList( list ) ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive list. This method allows + * modules to provide users with "read-only" access to internal + * lists. Query operations on the returned list "read through" to the + * specified list, and attempts to modify the returned list, whether + * direct or via its iterator, result in an + * UnsupportedOperationException.
+ * + * The returned list will be serializable if the specified list + * is serializable. Similarly, the returned list will implement + * {@link RandomAccess} if the specified list does. + * + * @param list the list for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive list. + */ + public static TFloatList unmodifiableList( TFloatList list) { + return ( list instanceof RandomAccess ? + new TUnmodifiableRandomAccessFloatList( list ) : + new TUnmodifiableFloatList( list ) ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive list. This method allows + * modules to provide users with "read-only" access to internal + * lists. Query operations on the returned list "read through" to the + * specified list, and attempts to modify the returned list, whether + * direct or via its iterator, result in an + * UnsupportedOperationException.
+ * + * The returned list will be serializable if the specified list + * is serializable. Similarly, the returned list will implement + * {@link RandomAccess} if the specified list does. + * + * @param list the list for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive list. + */ + public static TIntList unmodifiableList( TIntList list) { + return ( list instanceof RandomAccess ? + new TUnmodifiableRandomAccessIntList( list ) : + new TUnmodifiableIntList( list ) ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive list. This method allows + * modules to provide users with "read-only" access to internal + * lists. Query operations on the returned list "read through" to the + * specified list, and attempts to modify the returned list, whether + * direct or via its iterator, result in an + * UnsupportedOperationException.
+ * + * The returned list will be serializable if the specified list + * is serializable. Similarly, the returned list will implement + * {@link RandomAccess} if the specified list does. + * + * @param list the list for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive list. + */ + public static TLongList unmodifiableList( TLongList list) { + return ( list instanceof RandomAccess ? + new TUnmodifiableRandomAccessLongList( list ) : + new TUnmodifiableLongList( list ) ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive list. This method allows + * modules to provide users with "read-only" access to internal + * lists. Query operations on the returned list "read through" to the + * specified list, and attempts to modify the returned list, whether + * direct or via its iterator, result in an + * UnsupportedOperationException.
+ * + * The returned list will be serializable if the specified list + * is serializable. Similarly, the returned list will implement + * {@link RandomAccess} if the specified list does. + * + * @param list the list for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive list. + */ + public static TByteList unmodifiableList( TByteList list) { + return ( list instanceof RandomAccess ? + new TUnmodifiableRandomAccessByteList( list ) : + new TUnmodifiableByteList( list ) ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive list. This method allows + * modules to provide users with "read-only" access to internal + * lists. Query operations on the returned list "read through" to the + * specified list, and attempts to modify the returned list, whether + * direct or via its iterator, result in an + * UnsupportedOperationException.
+ * + * The returned list will be serializable if the specified list + * is serializable. Similarly, the returned list will implement + * {@link RandomAccess} if the specified list does. + * + * @param list the list for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive list. + */ + public static TShortList unmodifiableList( TShortList list) { + return ( list instanceof RandomAccess ? + new TUnmodifiableRandomAccessShortList( list ) : + new TUnmodifiableShortList( list ) ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive list. This method allows + * modules to provide users with "read-only" access to internal + * lists. Query operations on the returned list "read through" to the + * specified list, and attempts to modify the returned list, whether + * direct or via its iterator, result in an + * UnsupportedOperationException.
+ * + * The returned list will be serializable if the specified list + * is serializable. Similarly, the returned list will implement + * {@link RandomAccess} if the specified list does. + * + * @param list the list for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive list. + */ + public static TCharList unmodifiableList( TCharList list) { + return ( list instanceof RandomAccess ? + new TUnmodifiableRandomAccessCharList( list ) : + new TUnmodifiableCharList( list ) ); + } + + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TDoubleDoubleMap unmodifiableMap( TDoubleDoubleMap m ) { + return new TUnmodifiableDoubleDoubleMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TDoubleFloatMap unmodifiableMap( TDoubleFloatMap m ) { + return new TUnmodifiableDoubleFloatMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TDoubleIntMap unmodifiableMap( TDoubleIntMap m ) { + return new TUnmodifiableDoubleIntMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TDoubleLongMap unmodifiableMap( TDoubleLongMap m ) { + return new TUnmodifiableDoubleLongMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TDoubleByteMap unmodifiableMap( TDoubleByteMap m ) { + return new TUnmodifiableDoubleByteMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TDoubleShortMap unmodifiableMap( TDoubleShortMap m ) { + return new TUnmodifiableDoubleShortMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TDoubleCharMap unmodifiableMap( TDoubleCharMap m ) { + return new TUnmodifiableDoubleCharMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TFloatDoubleMap unmodifiableMap( TFloatDoubleMap m ) { + return new TUnmodifiableFloatDoubleMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TFloatFloatMap unmodifiableMap( TFloatFloatMap m ) { + return new TUnmodifiableFloatFloatMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TFloatIntMap unmodifiableMap( TFloatIntMap m ) { + return new TUnmodifiableFloatIntMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TFloatLongMap unmodifiableMap( TFloatLongMap m ) { + return new TUnmodifiableFloatLongMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TFloatByteMap unmodifiableMap( TFloatByteMap m ) { + return new TUnmodifiableFloatByteMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TFloatShortMap unmodifiableMap( TFloatShortMap m ) { + return new TUnmodifiableFloatShortMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TFloatCharMap unmodifiableMap( TFloatCharMap m ) { + return new TUnmodifiableFloatCharMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TIntDoubleMap unmodifiableMap( TIntDoubleMap m ) { + return new TUnmodifiableIntDoubleMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TIntFloatMap unmodifiableMap( TIntFloatMap m ) { + return new TUnmodifiableIntFloatMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TIntIntMap unmodifiableMap( TIntIntMap m ) { + return new TUnmodifiableIntIntMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TIntLongMap unmodifiableMap( TIntLongMap m ) { + return new TUnmodifiableIntLongMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TIntByteMap unmodifiableMap( TIntByteMap m ) { + return new TUnmodifiableIntByteMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TIntShortMap unmodifiableMap( TIntShortMap m ) { + return new TUnmodifiableIntShortMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TIntCharMap unmodifiableMap( TIntCharMap m ) { + return new TUnmodifiableIntCharMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TLongDoubleMap unmodifiableMap( TLongDoubleMap m ) { + return new TUnmodifiableLongDoubleMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TLongFloatMap unmodifiableMap( TLongFloatMap m ) { + return new TUnmodifiableLongFloatMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TLongIntMap unmodifiableMap( TLongIntMap m ) { + return new TUnmodifiableLongIntMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TLongLongMap unmodifiableMap( TLongLongMap m ) { + return new TUnmodifiableLongLongMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TLongByteMap unmodifiableMap( TLongByteMap m ) { + return new TUnmodifiableLongByteMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TLongShortMap unmodifiableMap( TLongShortMap m ) { + return new TUnmodifiableLongShortMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TLongCharMap unmodifiableMap( TLongCharMap m ) { + return new TUnmodifiableLongCharMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TByteDoubleMap unmodifiableMap( TByteDoubleMap m ) { + return new TUnmodifiableByteDoubleMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TByteFloatMap unmodifiableMap( TByteFloatMap m ) { + return new TUnmodifiableByteFloatMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TByteIntMap unmodifiableMap( TByteIntMap m ) { + return new TUnmodifiableByteIntMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TByteLongMap unmodifiableMap( TByteLongMap m ) { + return new TUnmodifiableByteLongMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TByteByteMap unmodifiableMap( TByteByteMap m ) { + return new TUnmodifiableByteByteMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TByteShortMap unmodifiableMap( TByteShortMap m ) { + return new TUnmodifiableByteShortMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TByteCharMap unmodifiableMap( TByteCharMap m ) { + return new TUnmodifiableByteCharMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TShortDoubleMap unmodifiableMap( TShortDoubleMap m ) { + return new TUnmodifiableShortDoubleMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TShortFloatMap unmodifiableMap( TShortFloatMap m ) { + return new TUnmodifiableShortFloatMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TShortIntMap unmodifiableMap( TShortIntMap m ) { + return new TUnmodifiableShortIntMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TShortLongMap unmodifiableMap( TShortLongMap m ) { + return new TUnmodifiableShortLongMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TShortByteMap unmodifiableMap( TShortByteMap m ) { + return new TUnmodifiableShortByteMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TShortShortMap unmodifiableMap( TShortShortMap m ) { + return new TUnmodifiableShortShortMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TShortCharMap unmodifiableMap( TShortCharMap m ) { + return new TUnmodifiableShortCharMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TCharDoubleMap unmodifiableMap( TCharDoubleMap m ) { + return new TUnmodifiableCharDoubleMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TCharFloatMap unmodifiableMap( TCharFloatMap m ) { + return new TUnmodifiableCharFloatMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TCharIntMap unmodifiableMap( TCharIntMap m ) { + return new TUnmodifiableCharIntMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TCharLongMap unmodifiableMap( TCharLongMap m ) { + return new TUnmodifiableCharLongMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TCharByteMap unmodifiableMap( TCharByteMap m ) { + return new TUnmodifiableCharByteMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TCharShortMap unmodifiableMap( TCharShortMap m ) { + return new TUnmodifiableCharShortMap( m ); + } + + /** + * Returns an unmodifiable view of the specified Trove primitive/primitive map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ * + * The returned map will be serializable if the specified map + * is serializable. + * + * @param m the map for which an unmodifiable view is to be returned. + * @return an unmodifiable view of the specified Trove primitive/primitive map. + */ + public static TCharCharMap unmodifiableMap( TCharCharMap m ) { + return new TUnmodifiableCharCharMap( m ); + } + + + /** + * Returns an unmodifiable view of the specified Trove primitive/Object map. This method + * allows modules to provide users with "read-only" access to internal + * maps. Query operations on the returned map "read through" + * to the specified map, and attempts to modify the returned + * map, whether direct or via its collection views, result in an + * UnsupportedOperationException.
+ *
+ * The returned map will be serializable if the specified map
+ * is serializable.
+ *
+ * @param m the map for which an unmodifiable view is to be returned.
+ * @return an unmodifiable view of the specified Trove primitive/primitive map.
+ */
+ public static
+ *
+ * The returned map will be serializable if the specified map
+ * is serializable.
+ *
+ * @param m the map for which an unmodifiable view is to be returned.
+ * @return an unmodifiable view of the specified Trove primitive/primitive map.
+ */
+ public static
+ *
+ * The returned map will be serializable if the specified map
+ * is serializable.
+ *
+ * @param m the map for which an unmodifiable view is to be returned.
+ * @return an unmodifiable view of the specified Trove primitive/primitive map.
+ */
+ public static
+ *
+ * The returned map will be serializable if the specified map
+ * is serializable.
+ *
+ * @param m the map for which an unmodifiable view is to be returned.
+ * @return an unmodifiable view of the specified Trove primitive/primitive map.
+ */
+ public static
+ *
+ * The returned map will be serializable if the specified map
+ * is serializable.
+ *
+ * @param m the map for which an unmodifiable view is to be returned.
+ * @return an unmodifiable view of the specified Trove primitive/primitive map.
+ */
+ public static
+ *
+ * The returned map will be serializable if the specified map
+ * is serializable.
+ *
+ * @param m the map for which an unmodifiable view is to be returned.
+ * @return an unmodifiable view of the specified Trove primitive/primitive map.
+ */
+ public static
+ *
+ * The returned map will be serializable if the specified map
+ * is serializable.
+ *
+ * @param m the map for which an unmodifiable view is to be returned.
+ * @return an unmodifiable view of the specified Trove primitive/primitive map.
+ */
+ public static
+ *
+ * The returned map will be serializable if the specified map
+ * is serializable.
+ *
+ * @param m the map for which an unmodifiable view is to be returned.
+ * @return an unmodifiable view of the specified Trove primitive/primitive map.
+ */
+ public static
+ *
+ * The returned map will be serializable if the specified map
+ * is serializable.
+ *
+ * @param m the map for which an unmodifiable view is to be returned.
+ * @return an unmodifiable view of the specified Trove primitive/primitive map.
+ */
+ public static
+ *
+ * The returned map will be serializable if the specified map
+ * is serializable.
+ *
+ * @param m the map for which an unmodifiable view is to be returned.
+ * @return an unmodifiable view of the specified Trove primitive/primitive map.
+ */
+ public static
+ *
+ * The returned map will be serializable if the specified map
+ * is serializable.
+ *
+ * @param m the map for which an unmodifiable view is to be returned.
+ * @return an unmodifiable view of the specified Trove primitive/primitive map.
+ */
+ public static
+ *
+ * The returned map will be serializable if the specified map
+ * is serializable.
+ *
+ * @param m the map for which an unmodifiable view is to be returned.
+ * @return an unmodifiable view of the specified Trove primitive/primitive map.
+ */
+ public static
+ *
+ * The returned map will be serializable if the specified map
+ * is serializable.
+ *
+ * @param m the map for which an unmodifiable view is to be returned.
+ * @return an unmodifiable view of the specified Trove primitive/primitive map.
+ */
+ public static
+ *
+ * The returned map will be serializable if the specified map
+ * is serializable.
+ *
+ * @param m the map for which an unmodifiable view is to be returned.
+ * @return an unmodifiable view of the specified Trove primitive/primitive map.
+ */
+ public static
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * collection when iterating over it:
+ * The returned collection does not pass the hashCode
+ * and equals operations through to the backing collection, but
+ * relies on Object's equals and hashCode methods. This is
+ * necessary to preserve the contracts of these operations in the case
+ * that the backing collection is a set or a list.
+ *
+ * The returned collection will be serializable if the specified collection
+ * is serializable.
+ *
+ * @param c the collection to be "wrapped" in a synchronized collection.
+ * @return a synchronized view of the specified collection.
+ */
+ public static TDoubleCollection synchronizedCollection( TDoubleCollection c ) {
+ return new TSynchronizedDoubleCollection(c);
+ }
+
+ static TDoubleCollection synchronizedCollection( TDoubleCollection c, Object mutex ) {
+ return new TSynchronizedDoubleCollection( c, mutex );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove collection backed by the specified
+ * Trove collection. In order to guarantee serial access, it is critical that
+ * all access to the backing collection is accomplished
+ * through the returned collection.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * collection when iterating over it:
+ * The returned collection does not pass the hashCode
+ * and equals operations through to the backing collection, but
+ * relies on Object's equals and hashCode methods. This is
+ * necessary to preserve the contracts of these operations in the case
+ * that the backing collection is a set or a list.
+ *
+ * The returned collection will be serializable if the specified collection
+ * is serializable.
+ *
+ * @param c the collection to be "wrapped" in a synchronized collection.
+ * @return a synchronized view of the specified collection.
+ */
+ public static TFloatCollection synchronizedCollection( TFloatCollection c ) {
+ return new TSynchronizedFloatCollection(c);
+ }
+
+ static TFloatCollection synchronizedCollection( TFloatCollection c, Object mutex ) {
+ return new TSynchronizedFloatCollection( c, mutex );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove collection backed by the specified
+ * Trove collection. In order to guarantee serial access, it is critical that
+ * all access to the backing collection is accomplished
+ * through the returned collection.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * collection when iterating over it:
+ * The returned collection does not pass the hashCode
+ * and equals operations through to the backing collection, but
+ * relies on Object's equals and hashCode methods. This is
+ * necessary to preserve the contracts of these operations in the case
+ * that the backing collection is a set or a list.
+ *
+ * The returned collection will be serializable if the specified collection
+ * is serializable.
+ *
+ * @param c the collection to be "wrapped" in a synchronized collection.
+ * @return a synchronized view of the specified collection.
+ */
+ public static TIntCollection synchronizedCollection( TIntCollection c ) {
+ return new TSynchronizedIntCollection(c);
+ }
+
+ static TIntCollection synchronizedCollection( TIntCollection c, Object mutex ) {
+ return new TSynchronizedIntCollection( c, mutex );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove collection backed by the specified
+ * Trove collection. In order to guarantee serial access, it is critical that
+ * all access to the backing collection is accomplished
+ * through the returned collection.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * collection when iterating over it:
+ * The returned collection does not pass the hashCode
+ * and equals operations through to the backing collection, but
+ * relies on Object's equals and hashCode methods. This is
+ * necessary to preserve the contracts of these operations in the case
+ * that the backing collection is a set or a list.
+ *
+ * The returned collection will be serializable if the specified collection
+ * is serializable.
+ *
+ * @param c the collection to be "wrapped" in a synchronized collection.
+ * @return a synchronized view of the specified collection.
+ */
+ public static TLongCollection synchronizedCollection( TLongCollection c ) {
+ return new TSynchronizedLongCollection(c);
+ }
+
+ static TLongCollection synchronizedCollection( TLongCollection c, Object mutex ) {
+ return new TSynchronizedLongCollection( c, mutex );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove collection backed by the specified
+ * Trove collection. In order to guarantee serial access, it is critical that
+ * all access to the backing collection is accomplished
+ * through the returned collection.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * collection when iterating over it:
+ * The returned collection does not pass the hashCode
+ * and equals operations through to the backing collection, but
+ * relies on Object's equals and hashCode methods. This is
+ * necessary to preserve the contracts of these operations in the case
+ * that the backing collection is a set or a list.
+ *
+ * The returned collection will be serializable if the specified collection
+ * is serializable.
+ *
+ * @param c the collection to be "wrapped" in a synchronized collection.
+ * @return a synchronized view of the specified collection.
+ */
+ public static TByteCollection synchronizedCollection( TByteCollection c ) {
+ return new TSynchronizedByteCollection(c);
+ }
+
+ static TByteCollection synchronizedCollection( TByteCollection c, Object mutex ) {
+ return new TSynchronizedByteCollection( c, mutex );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove collection backed by the specified
+ * Trove collection. In order to guarantee serial access, it is critical that
+ * all access to the backing collection is accomplished
+ * through the returned collection.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * collection when iterating over it:
+ * The returned collection does not pass the hashCode
+ * and equals operations through to the backing collection, but
+ * relies on Object's equals and hashCode methods. This is
+ * necessary to preserve the contracts of these operations in the case
+ * that the backing collection is a set or a list.
+ *
+ * The returned collection will be serializable if the specified collection
+ * is serializable.
+ *
+ * @param c the collection to be "wrapped" in a synchronized collection.
+ * @return a synchronized view of the specified collection.
+ */
+ public static TShortCollection synchronizedCollection( TShortCollection c ) {
+ return new TSynchronizedShortCollection(c);
+ }
+
+ static TShortCollection synchronizedCollection( TShortCollection c, Object mutex ) {
+ return new TSynchronizedShortCollection( c, mutex );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove collection backed by the specified
+ * Trove collection. In order to guarantee serial access, it is critical that
+ * all access to the backing collection is accomplished
+ * through the returned collection.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * collection when iterating over it:
+ * The returned collection does not pass the hashCode
+ * and equals operations through to the backing collection, but
+ * relies on Object's equals and hashCode methods. This is
+ * necessary to preserve the contracts of these operations in the case
+ * that the backing collection is a set or a list.
+ *
+ * The returned collection will be serializable if the specified collection
+ * is serializable.
+ *
+ * @param c the collection to be "wrapped" in a synchronized collection.
+ * @return a synchronized view of the specified collection.
+ */
+ public static TCharCollection synchronizedCollection( TCharCollection c ) {
+ return new TSynchronizedCharCollection(c);
+ }
+
+ static TCharCollection synchronizedCollection( TCharCollection c, Object mutex ) {
+ return new TSynchronizedCharCollection( c, mutex );
+ }
+
+
+ /**
+ * Returns a synchronized (thread-safe) Trove set backed by the specified
+ * set. In order to guarantee serial access, it is critical that
+ * all access to the backing set is accomplished
+ * through the returned set.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * set when iterating over it:
+ * The returned set will be serializable if the specified set is
+ * serializable.
+ *
+ * @param s the set to be "wrapped" in a synchronized set.
+ * @return a synchronized view of the specified set.
+ */
+ public static TDoubleSet synchronizedSet( TDoubleSet s ) {
+ return new TSynchronizedDoubleSet( s );
+ }
+
+ static TDoubleSet synchronizedSet( TDoubleSet s, Object mutex ) {
+ return new TSynchronizedDoubleSet( s, mutex );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove set backed by the specified
+ * set. In order to guarantee serial access, it is critical that
+ * all access to the backing set is accomplished
+ * through the returned set.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * set when iterating over it:
+ * The returned set will be serializable if the specified set is
+ * serializable.
+ *
+ * @param s the set to be "wrapped" in a synchronized set.
+ * @return a synchronized view of the specified set.
+ */
+ public static TFloatSet synchronizedSet( TFloatSet s ) {
+ return new TSynchronizedFloatSet( s );
+ }
+
+ static TFloatSet synchronizedSet( TFloatSet s, Object mutex ) {
+ return new TSynchronizedFloatSet( s, mutex );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove set backed by the specified
+ * set. In order to guarantee serial access, it is critical that
+ * all access to the backing set is accomplished
+ * through the returned set.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * set when iterating over it:
+ * The returned set will be serializable if the specified set is
+ * serializable.
+ *
+ * @param s the set to be "wrapped" in a synchronized set.
+ * @return a synchronized view of the specified set.
+ */
+ public static TIntSet synchronizedSet( TIntSet s ) {
+ return new TSynchronizedIntSet( s );
+ }
+
+ static TIntSet synchronizedSet( TIntSet s, Object mutex ) {
+ return new TSynchronizedIntSet( s, mutex );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove set backed by the specified
+ * set. In order to guarantee serial access, it is critical that
+ * all access to the backing set is accomplished
+ * through the returned set.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * set when iterating over it:
+ * The returned set will be serializable if the specified set is
+ * serializable.
+ *
+ * @param s the set to be "wrapped" in a synchronized set.
+ * @return a synchronized view of the specified set.
+ */
+ public static TLongSet synchronizedSet( TLongSet s ) {
+ return new TSynchronizedLongSet( s );
+ }
+
+ static TLongSet synchronizedSet( TLongSet s, Object mutex ) {
+ return new TSynchronizedLongSet( s, mutex );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove set backed by the specified
+ * set. In order to guarantee serial access, it is critical that
+ * all access to the backing set is accomplished
+ * through the returned set.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * set when iterating over it:
+ * The returned set will be serializable if the specified set is
+ * serializable.
+ *
+ * @param s the set to be "wrapped" in a synchronized set.
+ * @return a synchronized view of the specified set.
+ */
+ public static TByteSet synchronizedSet( TByteSet s ) {
+ return new TSynchronizedByteSet( s );
+ }
+
+ static TByteSet synchronizedSet( TByteSet s, Object mutex ) {
+ return new TSynchronizedByteSet( s, mutex );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove set backed by the specified
+ * set. In order to guarantee serial access, it is critical that
+ * all access to the backing set is accomplished
+ * through the returned set.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * set when iterating over it:
+ * The returned set will be serializable if the specified set is
+ * serializable.
+ *
+ * @param s the set to be "wrapped" in a synchronized set.
+ * @return a synchronized view of the specified set.
+ */
+ public static TShortSet synchronizedSet( TShortSet s ) {
+ return new TSynchronizedShortSet( s );
+ }
+
+ static TShortSet synchronizedSet( TShortSet s, Object mutex ) {
+ return new TSynchronizedShortSet( s, mutex );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove set backed by the specified
+ * set. In order to guarantee serial access, it is critical that
+ * all access to the backing set is accomplished
+ * through the returned set.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * set when iterating over it:
+ * The returned set will be serializable if the specified set is
+ * serializable.
+ *
+ * @param s the set to be "wrapped" in a synchronized set.
+ * @return a synchronized view of the specified set.
+ */
+ public static TCharSet synchronizedSet( TCharSet s ) {
+ return new TSynchronizedCharSet( s );
+ }
+
+ static TCharSet synchronizedSet( TCharSet s, Object mutex ) {
+ return new TSynchronizedCharSet( s, mutex );
+ }
+
+
+ /**
+ * Returns a synchronized (thread-safe) Trove list backed by the specified
+ * list. In order to guarantee serial access, it is critical that
+ * all access to the backing list is accomplished
+ * through the returned list.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * list when iterating over it:
+ * The returned list will be serializable if the specified list is
+ * serializable.
+ *
+ * @param list the list to be "wrapped" in a synchronized list.
+ * @return a synchronized view of the specified list.
+ */
+ public static TDoubleList synchronizedList( TDoubleList list ) {
+ return ( list instanceof RandomAccess ?
+ new TSynchronizedRandomAccessDoubleList( list ) :
+ new TSynchronizedDoubleList( list ) );
+ }
+
+ static TDoubleList synchronizedList( TDoubleList list, Object mutex ) {
+ return ( list instanceof RandomAccess ?
+ new TSynchronizedRandomAccessDoubleList( list, mutex ) :
+ new TSynchronizedDoubleList( list, mutex ) );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove list backed by the specified
+ * list. In order to guarantee serial access, it is critical that
+ * all access to the backing list is accomplished
+ * through the returned list.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * list when iterating over it:
+ * The returned list will be serializable if the specified list is
+ * serializable.
+ *
+ * @param list the list to be "wrapped" in a synchronized list.
+ * @return a synchronized view of the specified list.
+ */
+ public static TFloatList synchronizedList( TFloatList list ) {
+ return ( list instanceof RandomAccess ?
+ new TSynchronizedRandomAccessFloatList( list ) :
+ new TSynchronizedFloatList( list ) );
+ }
+
+ static TFloatList synchronizedList( TFloatList list, Object mutex ) {
+ return ( list instanceof RandomAccess ?
+ new TSynchronizedRandomAccessFloatList( list, mutex ) :
+ new TSynchronizedFloatList( list, mutex ) );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove list backed by the specified
+ * list. In order to guarantee serial access, it is critical that
+ * all access to the backing list is accomplished
+ * through the returned list.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * list when iterating over it:
+ * The returned list will be serializable if the specified list is
+ * serializable.
+ *
+ * @param list the list to be "wrapped" in a synchronized list.
+ * @return a synchronized view of the specified list.
+ */
+ public static TIntList synchronizedList( TIntList list ) {
+ return ( list instanceof RandomAccess ?
+ new TSynchronizedRandomAccessIntList( list ) :
+ new TSynchronizedIntList( list ) );
+ }
+
+ static TIntList synchronizedList( TIntList list, Object mutex ) {
+ return ( list instanceof RandomAccess ?
+ new TSynchronizedRandomAccessIntList( list, mutex ) :
+ new TSynchronizedIntList( list, mutex ) );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove list backed by the specified
+ * list. In order to guarantee serial access, it is critical that
+ * all access to the backing list is accomplished
+ * through the returned list.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * list when iterating over it:
+ * The returned list will be serializable if the specified list is
+ * serializable.
+ *
+ * @param list the list to be "wrapped" in a synchronized list.
+ * @return a synchronized view of the specified list.
+ */
+ public static TLongList synchronizedList( TLongList list ) {
+ return ( list instanceof RandomAccess ?
+ new TSynchronizedRandomAccessLongList( list ) :
+ new TSynchronizedLongList( list ) );
+ }
+
+ static TLongList synchronizedList( TLongList list, Object mutex ) {
+ return ( list instanceof RandomAccess ?
+ new TSynchronizedRandomAccessLongList( list, mutex ) :
+ new TSynchronizedLongList( list, mutex ) );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove list backed by the specified
+ * list. In order to guarantee serial access, it is critical that
+ * all access to the backing list is accomplished
+ * through the returned list.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * list when iterating over it:
+ * The returned list will be serializable if the specified list is
+ * serializable.
+ *
+ * @param list the list to be "wrapped" in a synchronized list.
+ * @return a synchronized view of the specified list.
+ */
+ public static TByteList synchronizedList( TByteList list ) {
+ return ( list instanceof RandomAccess ?
+ new TSynchronizedRandomAccessByteList( list ) :
+ new TSynchronizedByteList( list ) );
+ }
+
+ static TByteList synchronizedList( TByteList list, Object mutex ) {
+ return ( list instanceof RandomAccess ?
+ new TSynchronizedRandomAccessByteList( list, mutex ) :
+ new TSynchronizedByteList( list, mutex ) );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove list backed by the specified
+ * list. In order to guarantee serial access, it is critical that
+ * all access to the backing list is accomplished
+ * through the returned list.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * list when iterating over it:
+ * The returned list will be serializable if the specified list is
+ * serializable.
+ *
+ * @param list the list to be "wrapped" in a synchronized list.
+ * @return a synchronized view of the specified list.
+ */
+ public static TShortList synchronizedList( TShortList list ) {
+ return ( list instanceof RandomAccess ?
+ new TSynchronizedRandomAccessShortList( list ) :
+ new TSynchronizedShortList( list ) );
+ }
+
+ static TShortList synchronizedList( TShortList list, Object mutex ) {
+ return ( list instanceof RandomAccess ?
+ new TSynchronizedRandomAccessShortList( list, mutex ) :
+ new TSynchronizedShortList( list, mutex ) );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove list backed by the specified
+ * list. In order to guarantee serial access, it is critical that
+ * all access to the backing list is accomplished
+ * through the returned list.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * list when iterating over it:
+ * The returned list will be serializable if the specified list is
+ * serializable.
+ *
+ * @param list the list to be "wrapped" in a synchronized list.
+ * @return a synchronized view of the specified list.
+ */
+ public static TCharList synchronizedList( TCharList list ) {
+ return ( list instanceof RandomAccess ?
+ new TSynchronizedRandomAccessCharList( list ) :
+ new TSynchronizedCharList( list ) );
+ }
+
+ static TCharList synchronizedList( TCharList list, Object mutex ) {
+ return ( list instanceof RandomAccess ?
+ new TSynchronizedRandomAccessCharList( list, mutex ) :
+ new TSynchronizedCharList( list, mutex ) );
+ }
+
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TDoubleDoubleMap synchronizedMap( TDoubleDoubleMap m ) {
+ return new TSynchronizedDoubleDoubleMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TDoubleFloatMap synchronizedMap( TDoubleFloatMap m ) {
+ return new TSynchronizedDoubleFloatMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TDoubleIntMap synchronizedMap( TDoubleIntMap m ) {
+ return new TSynchronizedDoubleIntMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TDoubleLongMap synchronizedMap( TDoubleLongMap m ) {
+ return new TSynchronizedDoubleLongMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TDoubleByteMap synchronizedMap( TDoubleByteMap m ) {
+ return new TSynchronizedDoubleByteMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TDoubleShortMap synchronizedMap( TDoubleShortMap m ) {
+ return new TSynchronizedDoubleShortMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TDoubleCharMap synchronizedMap( TDoubleCharMap m ) {
+ return new TSynchronizedDoubleCharMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TFloatDoubleMap synchronizedMap( TFloatDoubleMap m ) {
+ return new TSynchronizedFloatDoubleMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TFloatFloatMap synchronizedMap( TFloatFloatMap m ) {
+ return new TSynchronizedFloatFloatMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TFloatIntMap synchronizedMap( TFloatIntMap m ) {
+ return new TSynchronizedFloatIntMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TFloatLongMap synchronizedMap( TFloatLongMap m ) {
+ return new TSynchronizedFloatLongMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TFloatByteMap synchronizedMap( TFloatByteMap m ) {
+ return new TSynchronizedFloatByteMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TFloatShortMap synchronizedMap( TFloatShortMap m ) {
+ return new TSynchronizedFloatShortMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TFloatCharMap synchronizedMap( TFloatCharMap m ) {
+ return new TSynchronizedFloatCharMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TIntDoubleMap synchronizedMap( TIntDoubleMap m ) {
+ return new TSynchronizedIntDoubleMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TIntFloatMap synchronizedMap( TIntFloatMap m ) {
+ return new TSynchronizedIntFloatMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TIntIntMap synchronizedMap( TIntIntMap m ) {
+ return new TSynchronizedIntIntMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TIntLongMap synchronizedMap( TIntLongMap m ) {
+ return new TSynchronizedIntLongMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TIntByteMap synchronizedMap( TIntByteMap m ) {
+ return new TSynchronizedIntByteMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TIntShortMap synchronizedMap( TIntShortMap m ) {
+ return new TSynchronizedIntShortMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TIntCharMap synchronizedMap( TIntCharMap m ) {
+ return new TSynchronizedIntCharMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TLongDoubleMap synchronizedMap( TLongDoubleMap m ) {
+ return new TSynchronizedLongDoubleMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TLongFloatMap synchronizedMap( TLongFloatMap m ) {
+ return new TSynchronizedLongFloatMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TLongIntMap synchronizedMap( TLongIntMap m ) {
+ return new TSynchronizedLongIntMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TLongLongMap synchronizedMap( TLongLongMap m ) {
+ return new TSynchronizedLongLongMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TLongByteMap synchronizedMap( TLongByteMap m ) {
+ return new TSynchronizedLongByteMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TLongShortMap synchronizedMap( TLongShortMap m ) {
+ return new TSynchronizedLongShortMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TLongCharMap synchronizedMap( TLongCharMap m ) {
+ return new TSynchronizedLongCharMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TByteDoubleMap synchronizedMap( TByteDoubleMap m ) {
+ return new TSynchronizedByteDoubleMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TByteFloatMap synchronizedMap( TByteFloatMap m ) {
+ return new TSynchronizedByteFloatMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TByteIntMap synchronizedMap( TByteIntMap m ) {
+ return new TSynchronizedByteIntMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TByteLongMap synchronizedMap( TByteLongMap m ) {
+ return new TSynchronizedByteLongMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TByteByteMap synchronizedMap( TByteByteMap m ) {
+ return new TSynchronizedByteByteMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TByteShortMap synchronizedMap( TByteShortMap m ) {
+ return new TSynchronizedByteShortMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TByteCharMap synchronizedMap( TByteCharMap m ) {
+ return new TSynchronizedByteCharMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TShortDoubleMap synchronizedMap( TShortDoubleMap m ) {
+ return new TSynchronizedShortDoubleMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TShortFloatMap synchronizedMap( TShortFloatMap m ) {
+ return new TSynchronizedShortFloatMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TShortIntMap synchronizedMap( TShortIntMap m ) {
+ return new TSynchronizedShortIntMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TShortLongMap synchronizedMap( TShortLongMap m ) {
+ return new TSynchronizedShortLongMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TShortByteMap synchronizedMap( TShortByteMap m ) {
+ return new TSynchronizedShortByteMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TShortShortMap synchronizedMap( TShortShortMap m ) {
+ return new TSynchronizedShortShortMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TShortCharMap synchronizedMap( TShortCharMap m ) {
+ return new TSynchronizedShortCharMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TCharDoubleMap synchronizedMap( TCharDoubleMap m ) {
+ return new TSynchronizedCharDoubleMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TCharFloatMap synchronizedMap( TCharFloatMap m ) {
+ return new TSynchronizedCharFloatMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TCharIntMap synchronizedMap( TCharIntMap m ) {
+ return new TSynchronizedCharIntMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TCharLongMap synchronizedMap( TCharLongMap m ) {
+ return new TSynchronizedCharLongMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TCharByteMap synchronizedMap( TCharByteMap m ) {
+ return new TSynchronizedCharByteMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TCharShortMap synchronizedMap( TCharShortMap m ) {
+ return new TSynchronizedCharShortMap( m );
+ }
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static TCharCharMap synchronizedMap( TCharCharMap m ) {
+ return new TSynchronizedCharCharMap( m );
+ }
+
+
+ /**
+ * Returns a synchronized (thread-safe) Trove map backed by the specified
+ * map. In order to guarantee serial access, it is critical that
+ * all access to the backing map is accomplished
+ * through the returned map.
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static
+ *
+ * It is imperative that the user manually synchronize on the returned
+ * map when iterating over any of its collection views:
+ * The returned map will be serializable if the specified map is
+ * serializable.
+ *
+ * @param m the map to be "wrapped" in a synchronized map.
+ * @return a synchronized view of the specified map.
+ */
+ public static
+ * TDoubleCollection c = TCollections.synchronizedCollection( myCollection );
+ * ...
+ * synchronized( c ) {
+ * TDoubleIterator i = c.iterator(); // Must be in the synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TFloatCollection c = TCollections.synchronizedCollection( myCollection );
+ * ...
+ * synchronized( c ) {
+ * TFloatIterator i = c.iterator(); // Must be in the synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TIntCollection c = TCollections.synchronizedCollection( myCollection );
+ * ...
+ * synchronized( c ) {
+ * TIntIterator i = c.iterator(); // Must be in the synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TLongCollection c = TCollections.synchronizedCollection( myCollection );
+ * ...
+ * synchronized( c ) {
+ * TLongIterator i = c.iterator(); // Must be in the synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TByteCollection c = TCollections.synchronizedCollection( myCollection );
+ * ...
+ * synchronized( c ) {
+ * TByteIterator i = c.iterator(); // Must be in the synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TShortCollection c = TCollections.synchronizedCollection( myCollection );
+ * ...
+ * synchronized( c ) {
+ * TShortIterator i = c.iterator(); // Must be in the synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TCharCollection c = TCollections.synchronizedCollection( myCollection );
+ * ...
+ * synchronized( c ) {
+ * TCharIterator i = c.iterator(); // Must be in the synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TDoubleSet s = TCollections.synchronizedSet( new TDoubleHashSet() );
+ * ...
+ * synchronized(s) {
+ * TDoubleIterator i = s.iterator(); // Must be in the synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TFloatSet s = TCollections.synchronizedSet( new TFloatHashSet() );
+ * ...
+ * synchronized(s) {
+ * TFloatIterator i = s.iterator(); // Must be in the synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TIntSet s = TCollections.synchronizedSet( new TIntHashSet() );
+ * ...
+ * synchronized(s) {
+ * TIntIterator i = s.iterator(); // Must be in the synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TLongSet s = TCollections.synchronizedSet( new TLongHashSet() );
+ * ...
+ * synchronized(s) {
+ * TLongIterator i = s.iterator(); // Must be in the synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TByteSet s = TCollections.synchronizedSet( new TByteHashSet() );
+ * ...
+ * synchronized(s) {
+ * TByteIterator i = s.iterator(); // Must be in the synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TShortSet s = TCollections.synchronizedSet( new TShortHashSet() );
+ * ...
+ * synchronized(s) {
+ * TShortIterator i = s.iterator(); // Must be in the synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TCharSet s = TCollections.synchronizedSet( new TCharHashSet() );
+ * ...
+ * synchronized(s) {
+ * TCharIterator i = s.iterator(); // Must be in the synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TDoubleList list = TCollections.synchronizedList( new TDoubleArrayList() );
+ * ...
+ * synchronized( list ) {
+ * TDoubleIterator i = list.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TFloatList list = TCollections.synchronizedList( new TFloatArrayList() );
+ * ...
+ * synchronized( list ) {
+ * TFloatIterator i = list.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TIntList list = TCollections.synchronizedList( new TIntArrayList() );
+ * ...
+ * synchronized( list ) {
+ * TIntIterator i = list.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TLongList list = TCollections.synchronizedList( new TLongArrayList() );
+ * ...
+ * synchronized( list ) {
+ * TLongIterator i = list.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TByteList list = TCollections.synchronizedList( new TByteArrayList() );
+ * ...
+ * synchronized( list ) {
+ * TByteIterator i = list.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TShortList list = TCollections.synchronizedList( new TShortArrayList() );
+ * ...
+ * synchronized( list ) {
+ * TShortIterator i = list.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TCharList list = TCollections.synchronizedList( new TCharArrayList() );
+ * ...
+ * synchronized( list ) {
+ * TCharIterator i = list.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TDoubleDoubleMap m = TCollections.synchronizedMap( new TDoubleDoubleHashMap() );
+ * ...
+ * TDoubleSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TDoubleIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TDoubleFloatMap m = TCollections.synchronizedMap( new TDoubleFloatHashMap() );
+ * ...
+ * TDoubleSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TDoubleIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TDoubleIntMap m = TCollections.synchronizedMap( new TDoubleIntHashMap() );
+ * ...
+ * TDoubleSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TDoubleIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TDoubleLongMap m = TCollections.synchronizedMap( new TDoubleLongHashMap() );
+ * ...
+ * TDoubleSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TDoubleIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TDoubleByteMap m = TCollections.synchronizedMap( new TDoubleByteHashMap() );
+ * ...
+ * TDoubleSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TDoubleIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TDoubleShortMap m = TCollections.synchronizedMap( new TDoubleShortHashMap() );
+ * ...
+ * TDoubleSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TDoubleIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TDoubleCharMap m = TCollections.synchronizedMap( new TDoubleCharHashMap() );
+ * ...
+ * TDoubleSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TDoubleIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TFloatDoubleMap m = TCollections.synchronizedMap( new TFloatDoubleHashMap() );
+ * ...
+ * TFloatSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TFloatIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TFloatFloatMap m = TCollections.synchronizedMap( new TFloatFloatHashMap() );
+ * ...
+ * TFloatSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TFloatIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TFloatIntMap m = TCollections.synchronizedMap( new TFloatIntHashMap() );
+ * ...
+ * TFloatSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TFloatIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TFloatLongMap m = TCollections.synchronizedMap( new TFloatLongHashMap() );
+ * ...
+ * TFloatSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TFloatIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TFloatByteMap m = TCollections.synchronizedMap( new TFloatByteHashMap() );
+ * ...
+ * TFloatSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TFloatIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TFloatShortMap m = TCollections.synchronizedMap( new TFloatShortHashMap() );
+ * ...
+ * TFloatSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TFloatIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TFloatCharMap m = TCollections.synchronizedMap( new TFloatCharHashMap() );
+ * ...
+ * TFloatSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TFloatIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TIntDoubleMap m = TCollections.synchronizedMap( new TIntDoubleHashMap() );
+ * ...
+ * TIntSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TIntIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TIntFloatMap m = TCollections.synchronizedMap( new TIntFloatHashMap() );
+ * ...
+ * TIntSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TIntIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TIntIntMap m = TCollections.synchronizedMap( new TIntIntHashMap() );
+ * ...
+ * TIntSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TIntIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TIntLongMap m = TCollections.synchronizedMap( new TIntLongHashMap() );
+ * ...
+ * TIntSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TIntIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TIntByteMap m = TCollections.synchronizedMap( new TIntByteHashMap() );
+ * ...
+ * TIntSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TIntIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TIntShortMap m = TCollections.synchronizedMap( new TIntShortHashMap() );
+ * ...
+ * TIntSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TIntIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TIntCharMap m = TCollections.synchronizedMap( new TIntCharHashMap() );
+ * ...
+ * TIntSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TIntIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TLongDoubleMap m = TCollections.synchronizedMap( new TLongDoubleHashMap() );
+ * ...
+ * TLongSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TLongIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TLongFloatMap m = TCollections.synchronizedMap( new TLongFloatHashMap() );
+ * ...
+ * TLongSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TLongIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TLongIntMap m = TCollections.synchronizedMap( new TLongIntHashMap() );
+ * ...
+ * TLongSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TLongIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TLongLongMap m = TCollections.synchronizedMap( new TLongLongHashMap() );
+ * ...
+ * TLongSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TLongIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TLongByteMap m = TCollections.synchronizedMap( new TLongByteHashMap() );
+ * ...
+ * TLongSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TLongIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TLongShortMap m = TCollections.synchronizedMap( new TLongShortHashMap() );
+ * ...
+ * TLongSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TLongIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TLongCharMap m = TCollections.synchronizedMap( new TLongCharHashMap() );
+ * ...
+ * TLongSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TLongIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TByteDoubleMap m = TCollections.synchronizedMap( new TByteDoubleHashMap() );
+ * ...
+ * TByteSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TByteIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TByteFloatMap m = TCollections.synchronizedMap( new TByteFloatHashMap() );
+ * ...
+ * TByteSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TByteIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TByteIntMap m = TCollections.synchronizedMap( new TByteIntHashMap() );
+ * ...
+ * TByteSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TByteIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TByteLongMap m = TCollections.synchronizedMap( new TByteLongHashMap() );
+ * ...
+ * TByteSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TByteIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TByteByteMap m = TCollections.synchronizedMap( new TByteByteHashMap() );
+ * ...
+ * TByteSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TByteIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TByteShortMap m = TCollections.synchronizedMap( new TByteShortHashMap() );
+ * ...
+ * TByteSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TByteIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TByteCharMap m = TCollections.synchronizedMap( new TByteCharHashMap() );
+ * ...
+ * TByteSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TByteIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TShortDoubleMap m = TCollections.synchronizedMap( new TShortDoubleHashMap() );
+ * ...
+ * TShortSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TShortIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TShortFloatMap m = TCollections.synchronizedMap( new TShortFloatHashMap() );
+ * ...
+ * TShortSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TShortIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TShortIntMap m = TCollections.synchronizedMap( new TShortIntHashMap() );
+ * ...
+ * TShortSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TShortIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TShortLongMap m = TCollections.synchronizedMap( new TShortLongHashMap() );
+ * ...
+ * TShortSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TShortIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TShortByteMap m = TCollections.synchronizedMap( new TShortByteHashMap() );
+ * ...
+ * TShortSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TShortIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TShortShortMap m = TCollections.synchronizedMap( new TShortShortHashMap() );
+ * ...
+ * TShortSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TShortIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TShortCharMap m = TCollections.synchronizedMap( new TShortCharHashMap() );
+ * ...
+ * TShortSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TShortIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TCharDoubleMap m = TCollections.synchronizedMap( new TCharDoubleHashMap() );
+ * ...
+ * TCharSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TCharIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TCharFloatMap m = TCollections.synchronizedMap( new TCharFloatHashMap() );
+ * ...
+ * TCharSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TCharIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TCharIntMap m = TCollections.synchronizedMap( new TCharIntHashMap() );
+ * ...
+ * TCharSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TCharIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TCharLongMap m = TCollections.synchronizedMap( new TCharLongHashMap() );
+ * ...
+ * TCharSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TCharIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TCharByteMap m = TCollections.synchronizedMap( new TCharByteHashMap() );
+ * ...
+ * TCharSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TCharIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TCharShortMap m = TCollections.synchronizedMap( new TCharShortHashMap() );
+ * ...
+ * TCharSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TCharIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TCharCharMap m = TCollections.synchronizedMap( new TCharCharHashMap() );
+ * ...
+ * TCharSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TCharIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TDoubleObjectMap m = TCollections.synchronizedMap( new TDoubleObjectHashMap() );
+ * ...
+ * TDoubleSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TDoubleIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TFloatObjectMap m = TCollections.synchronizedMap( new TFloatObjectHashMap() );
+ * ...
+ * TFloatSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TFloatIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TIntObjectMap m = TCollections.synchronizedMap( new TIntObjectHashMap() );
+ * ...
+ * TIntSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TIntIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TLongObjectMap m = TCollections.synchronizedMap( new TLongObjectHashMap() );
+ * ...
+ * TLongSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TLongIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TByteObjectMap m = TCollections.synchronizedMap( new TByteObjectHashMap() );
+ * ...
+ * TByteSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TByteIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TShortObjectMap m = TCollections.synchronizedMap( new TShortObjectHashMap() );
+ * ...
+ * TShortSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TShortIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TCharObjectMap m = TCollections.synchronizedMap( new TCharObjectHashMap() );
+ * ...
+ * TCharSet s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * TCharIterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TObjectDoubleMap m = TCollections.synchronizedMap( new TObjectDoubleHashMap() );
+ * ...
+ * Set s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * Iterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TObjectFloatMap m = TCollections.synchronizedMap( new TObjectFloatHashMap() );
+ * ...
+ * Set s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * Iterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TObjectIntMap m = TCollections.synchronizedMap( new TObjectIntHashMap() );
+ * ...
+ * Set s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * Iterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TObjectLongMap m = TCollections.synchronizedMap( new TObjectLongHashMap() );
+ * ...
+ * Set s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * Iterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TObjectByteMap m = TCollections.synchronizedMap( new TObjectByteHashMap() );
+ * ...
+ * Set s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * Iterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TObjectShortMap m = TCollections.synchronizedMap( new TObjectShortHashMap() );
+ * ...
+ * Set s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * Iterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *
+ * TObjectCharMap m = TCollections.synchronizedMap( new TObjectCharHashMap() );
+ * ...
+ * Set s = m.keySet(); // Needn't be in synchronized block
+ * ...
+ * synchronized( m ) { // Synchronizing on m, not s!
+ * Iterator i = s.iterator(); // Must be in synchronized block
+ * while ( i.hasNext() )
+ * foo( i.next() );
+ * }
+ *
+ * Failure to follow this advice may result in non-deterministic behavior.
+ *
+ *