///////////////////////////////////////////////////////////////////////////////
// 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({"UnusedDeclaration"})
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
* <tt>UnsupportedOperationException</tt>.<p>
*
* The returned collection does <i>not</i> pass the hashCode and equals
* operations through to the backing collection, but relies on
* <tt>Object</tt>'s <tt>equals</tt> and <tt>hashCode</tt> methods. This
* is necessary to preserve the contracts of these operations in the case
* that the backing collection is a set or a list.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* The returned collection does <i>not</i> pass the hashCode and equals
* operations through to the backing collection, but relies on
* <tt>Object</tt>'s <tt>equals</tt> and <tt>hashCode</tt> methods. This
* is necessary to preserve the contracts of these operations in the case
* that the backing collection is a set or a list.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* The returned collection does <i>not</i> pass the hashCode and equals
* operations through to the backing collection, but relies on
* <tt>Object</tt>'s <tt>equals</tt> and <tt>hashCode</tt> methods. This
* is necessary to preserve the contracts of these operations in the case
* that the backing collection is a set or a list.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* The returned collection does <i>not</i> pass the hashCode and equals
* operations through to the backing collection, but relies on
* <tt>Object</tt>'s <tt>equals</tt> and <tt>hashCode</tt> methods. This
* is necessary to preserve the contracts of these operations in the case
* that the backing collection is a set or a list.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* The returned collection does <i>not</i> pass the hashCode and equals
* operations through to the backing collection, but relies on
* <tt>Object</tt>'s <tt>equals</tt> and <tt>hashCode</tt> methods. This
* is necessary to preserve the contracts of these operations in the case
* that the backing collection is a set or a list.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* The returned collection does <i>not</i> pass the hashCode and equals
* operations through to the backing collection, but relies on
* <tt>Object</tt>'s <tt>equals</tt> and <tt>hashCode</tt> methods. This
* is necessary to preserve the contracts of these operations in the case
* that the backing collection is a set or a list.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* The returned collection does <i>not</i> pass the hashCode and equals
* operations through to the backing collection, but relies on
* <tt>Object</tt>'s <tt>equals</tt> and <tt>hashCode</tt> methods. This
* is necessary to preserve the contracts of these operations in the case
* that the backing collection is a set or a list.<p>
*
* 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 <tt>UnsupportedOperationException</tt>.<p>
*
* 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 <tt>UnsupportedOperationException</tt>.<p>
*
* 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 <tt>UnsupportedOperationException</tt>.<p>
*
* 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 <tt>UnsupportedOperationException</tt>.<p>
*
* 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 <tt>UnsupportedOperationException</tt>.<p>
*
* 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 <tt>UnsupportedOperationException</tt>.<p>
*
* 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 <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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 <V> TDoubleObjectMap<V> unmodifiableMap( TDoubleObjectMap<V> m ) {
return new TUnmodifiableDoubleObjectMap<V>( 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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 <V> TFloatObjectMap<V> unmodifiableMap( TFloatObjectMap<V> m ) {
return new TUnmodifiableFloatObjectMap<V>( 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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 <V> TIntObjectMap<V> unmodifiableMap( TIntObjectMap<V> m ) {
return new TUnmodifiableIntObjectMap<V>( 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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 <V> TLongObjectMap<V> unmodifiableMap( TLongObjectMap<V> m ) {
return new TUnmodifiableLongObjectMap<V>( 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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 <V> TByteObjectMap<V> unmodifiableMap( TByteObjectMap<V> m ) {
return new TUnmodifiableByteObjectMap<V>( 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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 <V> TShortObjectMap<V> unmodifiableMap( TShortObjectMap<V> m ) {
return new TUnmodifiableShortObjectMap<V>( 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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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 <V> TCharObjectMap<V> unmodifiableMap( TCharObjectMap<V> m ) {
return new TUnmodifiableCharObjectMap<V>( m );
}
/**
* Returns an unmodifiable view of the specified Trove Object/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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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 <K> TObjectDoubleMap<K> unmodifiableMap( TObjectDoubleMap<K> m ) {
return new TUnmodifiableObjectDoubleMap<K>( m );
}
/**
* Returns an unmodifiable view of the specified Trove Object/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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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 <K> TObjectFloatMap<K> unmodifiableMap( TObjectFloatMap<K> m ) {
return new TUnmodifiableObjectFloatMap<K>( m );
}
/**
* Returns an unmodifiable view of the specified Trove Object/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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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 <K> TObjectIntMap<K> unmodifiableMap( TObjectIntMap<K> m ) {
return new TUnmodifiableObjectIntMap<K>( m );
}
/**
* Returns an unmodifiable view of the specified Trove Object/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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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 <K> TObjectLongMap<K> unmodifiableMap( TObjectLongMap<K> m ) {
return new TUnmodifiableObjectLongMap<K>( m );
}
/**
* Returns an unmodifiable view of the specified Trove Object/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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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 <K> TObjectByteMap<K> unmodifiableMap( TObjectByteMap<K> m ) {
return new TUnmodifiableObjectByteMap<K>( m );
}
/**
* Returns an unmodifiable view of the specified Trove Object/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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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 <K> TObjectShortMap<K> unmodifiableMap( TObjectShortMap<K> m ) {
return new TUnmodifiableObjectShortMap<K>( m );
}
/**
* Returns an unmodifiable view of the specified Trove Object/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
* <tt>UnsupportedOperationException</tt>.<p>
*
* 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 <K> TObjectCharMap<K> unmodifiableMap( TObjectCharMap<K> m ) {
return new TUnmodifiableObjectCharMap<K>( m );
}
///////////////////////////
// TSynchronizedCollections
/**
* Returns a synchronized (thread-safe) Trove collection backed by the specified
* Trove collection. In order to guarantee serial access, it is critical that
* <strong>all</strong> access to the backing collection is accomplished
* through the returned collection.<p>
*
* It is imperative that the user manually synchronize on the returned
* collection when iterating over it:
* <pre>
* TDoubleCollection c = TCollections.synchronizedCollection( myCollection );
* ...
* synchronized( c ) {
* TDoubleIterator i = c.iterator(); // Must be in the synchronized block
* while ( i.hasNext() )
* foo( i.next() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>The returned collection does <i>not</i> pass the <tt>hashCode</tt>
* and <tt>equals</tt> operations through to the backing collection, but
* relies on <tt>Object</tt>'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.<p>
*
* 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
* <strong>all</strong> access to the backing collection is accomplished
* through the returned collection.<p>
*
* It is imperative that the user manually synchronize on the returned
* collection when iterating over it:
* <pre>
* TFloatCollection c = TCollections.synchronizedCollection( myCollection );
* ...
* synchronized( c ) {
* TFloatIterator i = c.iterator(); // Must be in the synchronized block
* while ( i.hasNext() )
* foo( i.next() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>The returned collection does <i>not</i> pass the <tt>hashCode</tt>
* and <tt>equals</tt> operations through to the backing collection, but
* relies on <tt>Object</tt>'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.<p>
*
* 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
* <strong>all</strong> access to the backing collection is accomplished
* through the returned collection.<p>
*
* It is imperative that the user manually synchronize on the returned
* collection when iterating over it:
* <pre>
* TIntCollection c = TCollections.synchronizedCollection( myCollection );
* ...
* synchronized( c ) {
* TIntIterator i = c.iterator(); // Must be in the synchronized block
* while ( i.hasNext() )
* foo( i.next() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>The returned collection does <i>not</i> pass the <tt>hashCode</tt>
* and <tt>equals</tt> operations through to the backing collection, but
* relies on <tt>Object</tt>'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.<p>
*
* 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
* <strong>all</strong> access to the backing collection is accomplished
* through the returned collection.<p>
*
* It is imperative that the user manually synchronize on the returned
* collection when iterating over it:
* <pre>
* TLongCollection c = TCollections.synchronizedCollection( myCollection );
* ...
* synchronized( c ) {
* TLongIterator i = c.iterator(); // Must be in the synchronized block
* while ( i.hasNext() )
* foo( i.next() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>The returned collection does <i>not</i> pass the <tt>hashCode</tt>
* and <tt>equals</tt> operations through to the backing collection, but
* relies on <tt>Object</tt>'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.<p>
*
* 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
* <strong>all</strong> access to the backing collection is accomplished
* through the returned collection.<p>
*
* It is imperative that the user manually synchronize on the returned
* collection when iterating over it:
* <pre>
* TByteCollection c = TCollections.synchronizedCollection( myCollection );
* ...
* synchronized( c ) {
* TByteIterator i = c.iterator(); // Must be in the synchronized block
* while ( i.hasNext() )
* foo( i.next() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>The returned collection does <i>not</i> pass the <tt>hashCode</tt>
* and <tt>equals</tt> operations through to the backing collection, but
* relies on <tt>Object</tt>'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.<p>
*
* 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
* <strong>all</strong> access to the backing collection is accomplished
* through the returned collection.<p>
*
* It is imperative that the user manually synchronize on the returned
* collection when iterating over it:
* <pre>
* TShortCollection c = TCollections.synchronizedCollection( myCollection );
* ...
* synchronized( c ) {
* TShortIterator i = c.iterator(); // Must be in the synchronized block
* while ( i.hasNext() )
* foo( i.next() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>The returned collection does <i>not</i> pass the <tt>hashCode</tt>
* and <tt>equals</tt> operations through to the backing collection, but
* relies on <tt>Object</tt>'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.<p>
*
* 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
* <strong>all</strong> access to the backing collection is accomplished
* through the returned collection.<p>
*
* It is imperative that the user manually synchronize on the returned
* collection when iterating over it:
* <pre>
* TCharCollection c = TCollections.synchronizedCollection( myCollection );
* ...
* synchronized( c ) {
* TCharIterator i = c.iterator(); // Must be in the synchronized block
* while ( i.hasNext() )
* foo( i.next() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>The returned collection does <i>not</i> pass the <tt>hashCode</tt>
* and <tt>equals</tt> operations through to the backing collection, but
* relies on <tt>Object</tt>'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.<p>
*
* 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
* <strong>all</strong> access to the backing set is accomplished
* through the returned set.<p>
*
* It is imperative that the user manually synchronize on the returned
* set when iterating over it:
* <pre>
* TDoubleSet s = TCollections.synchronizedSet( new TDoubleHashSet() );
* ...
* synchronized(s) {
* TDoubleIterator i = s.iterator(); // Must be in the synchronized block
* while ( i.hasNext() )
* foo( i.next() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing set is accomplished
* through the returned set.<p>
*
* It is imperative that the user manually synchronize on the returned
* set when iterating over it:
* <pre>
* TFloatSet s = TCollections.synchronizedSet( new TFloatHashSet() );
* ...
* synchronized(s) {
* TFloatIterator i = s.iterator(); // Must be in the synchronized block
* while ( i.hasNext() )
* foo( i.next() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing set is accomplished
* through the returned set.<p>
*
* It is imperative that the user manually synchronize on the returned
* set when iterating over it:
* <pre>
* TIntSet s = TCollections.synchronizedSet( new TIntHashSet() );
* ...
* synchronized(s) {
* TIntIterator i = s.iterator(); // Must be in the synchronized block
* while ( i.hasNext() )
* foo( i.next() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing set is accomplished
* through the returned set.<p>
*
* It is imperative that the user manually synchronize on the returned
* set when iterating over it:
* <pre>
* TLongSet s = TCollections.synchronizedSet( new TLongHashSet() );
* ...
* synchronized(s) {
* TLongIterator i = s.iterator(); // Must be in the synchronized block
* while ( i.hasNext() )
* foo( i.next() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing set is accomplished
* through the returned set.<p>
*
* It is imperative that the user manually synchronize on the returned
* set when iterating over it:
* <pre>
* TByteSet s = TCollections.synchronizedSet( new TByteHashSet() );
* ...
* synchronized(s) {
* TByteIterator i = s.iterator(); // Must be in the synchronized block
* while ( i.hasNext() )
* foo( i.next() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing set is accomplished
* through the returned set.<p>
*
* It is imperative that the user manually synchronize on the returned
* set when iterating over it:
* <pre>
* TShortSet s = TCollections.synchronizedSet( new TShortHashSet() );
* ...
* synchronized(s) {
* TShortIterator i = s.iterator(); // Must be in the synchronized block
* while ( i.hasNext() )
* foo( i.next() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing set is accomplished
* through the returned set.<p>
*
* It is imperative that the user manually synchronize on the returned
* set when iterating over it:
* <pre>
* TCharSet s = TCollections.synchronizedSet( new TCharHashSet() );
* ...
* synchronized(s) {
* TCharIterator i = s.iterator(); // Must be in the synchronized block
* while ( i.hasNext() )
* foo( i.next() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing list is accomplished
* through the returned list.<p>
*
* It is imperative that the user manually synchronize on the returned
* list when iterating over it:
* <pre>
* TDoubleList list = TCollections.synchronizedList( new TDoubleArrayList() );
* ...
* synchronized( list ) {
* TDoubleIterator i = list.iterator(); // Must be in synchronized block
* while ( i.hasNext() )
* foo( i.next() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing list is accomplished
* through the returned list.<p>
*
* It is imperative that the user manually synchronize on the returned
* list when iterating over it:
* <pre>
* TFloatList list = TCollections.synchronizedList( new TFloatArrayList() );
* ...
* synchronized( list ) {
* TFloatIterator i = list.iterator(); // Must be in synchronized block
* while ( i.hasNext() )
* foo( i.next() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing list is accomplished
* through the returned list.<p>
*
* It is imperative that the user manually synchronize on the returned
* list when iterating over it:
* <pre>
* TIntList list = TCollections.synchronizedList( new TIntArrayList() );
* ...
* synchronized( list ) {
* TIntIterator i = list.iterator(); // Must be in synchronized block
* while ( i.hasNext() )
* foo( i.next() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing list is accomplished
* through the returned list.<p>
*
* It is imperative that the user manually synchronize on the returned
* list when iterating over it:
* <pre>
* TLongList list = TCollections.synchronizedList( new TLongArrayList() );
* ...
* synchronized( list ) {
* TLongIterator i = list.iterator(); // Must be in synchronized block
* while ( i.hasNext() )
* foo( i.next() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing list is accomplished
* through the returned list.<p>
*
* It is imperative that the user manually synchronize on the returned
* list when iterating over it:
* <pre>
* TByteList list = TCollections.synchronizedList( new TByteArrayList() );
* ...
* synchronized( list ) {
* TByteIterator i = list.iterator(); // Must be in synchronized block
* while ( i.hasNext() )
* foo( i.next() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing list is accomplished
* through the returned list.<p>
*
* It is imperative that the user manually synchronize on the returned
* list when iterating over it:
* <pre>
* TShortList list = TCollections.synchronizedList( new TShortArrayList() );
* ...
* synchronized( list ) {
* TShortIterator i = list.iterator(); // Must be in synchronized block
* while ( i.hasNext() )
* foo( i.next() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing list is accomplished
* through the returned list.<p>
*
* It is imperative that the user manually synchronize on the returned
* list when iterating over it:
* <pre>
* TCharList list = TCollections.synchronizedList( new TCharArrayList() );
* ...
* synchronized( list ) {
* TCharIterator i = list.iterator(); // Must be in synchronized block
* while ( i.hasNext() )
* foo( i.next() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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 <V> TDoubleObjectMap<V> synchronizedMap( TDoubleObjectMap<V> m ) {
return new TSynchronizedDoubleObjectMap<V>( m );
}
/**
* Returns a synchronized (thread-safe) Trove map backed by the specified
* map. In order to guarantee serial access, it is critical that
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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 <V> TFloatObjectMap<V> synchronizedMap( TFloatObjectMap<V> m ) {
return new TSynchronizedFloatObjectMap<V>( m );
}
/**
* Returns a synchronized (thread-safe) Trove map backed by the specified
* map. In order to guarantee serial access, it is critical that
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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 <V> TIntObjectMap<V> synchronizedMap( TIntObjectMap<V> m ) {
return new TSynchronizedIntObjectMap<V>( m );
}
/**
* Returns a synchronized (thread-safe) Trove map backed by the specified
* map. In order to guarantee serial access, it is critical that
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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 <V> TLongObjectMap<V> synchronizedMap( TLongObjectMap<V> m ) {
return new TSynchronizedLongObjectMap<V>( m );
}
/**
* Returns a synchronized (thread-safe) Trove map backed by the specified
* map. In order to guarantee serial access, it is critical that
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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 <V> TByteObjectMap<V> synchronizedMap( TByteObjectMap<V> m ) {
return new TSynchronizedByteObjectMap<V>( m );
}
/**
* Returns a synchronized (thread-safe) Trove map backed by the specified
* map. In order to guarantee serial access, it is critical that
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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 <V> TShortObjectMap<V> synchronizedMap( TShortObjectMap<V> m ) {
return new TSynchronizedShortObjectMap<V>( m );
}
/**
* Returns a synchronized (thread-safe) Trove map backed by the specified
* map. In order to guarantee serial access, it is critical that
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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 <V> TCharObjectMap<V> synchronizedMap( TCharObjectMap<V> m ) {
return new TSynchronizedCharObjectMap<V>( m );
}
/**
* Returns a synchronized (thread-safe) Trove map backed by the specified
* map. In order to guarantee serial access, it is critical that
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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 <K> TObjectDoubleMap<K> synchronizedMap( TObjectDoubleMap<K> m ) {
return new TSynchronizedObjectDoubleMap<K>( m );
}
/**
* Returns a synchronized (thread-safe) Trove map backed by the specified
* map. In order to guarantee serial access, it is critical that
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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 <K> TObjectFloatMap<K> synchronizedMap( TObjectFloatMap<K> m ) {
return new TSynchronizedObjectFloatMap<K>( m );
}
/**
* Returns a synchronized (thread-safe) Trove map backed by the specified
* map. In order to guarantee serial access, it is critical that
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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 <K> TObjectIntMap<K> synchronizedMap( TObjectIntMap<K> m ) {
return new TSynchronizedObjectIntMap<K>( m );
}
/**
* Returns a synchronized (thread-safe) Trove map backed by the specified
* map. In order to guarantee serial access, it is critical that
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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 <K> TObjectLongMap<K> synchronizedMap( TObjectLongMap<K> m ) {
return new TSynchronizedObjectLongMap<K>( m );
}
/**
* Returns a synchronized (thread-safe) Trove map backed by the specified
* map. In order to guarantee serial access, it is critical that
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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 <K> TObjectByteMap<K> synchronizedMap( TObjectByteMap<K> m ) {
return new TSynchronizedObjectByteMap<K>( m );
}
/**
* Returns a synchronized (thread-safe) Trove map backed by the specified
* map. In order to guarantee serial access, it is critical that
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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 <K> TObjectShortMap<K> synchronizedMap( TObjectShortMap<K> m ) {
return new TSynchronizedObjectShortMap<K>( m );
}
/**
* Returns a synchronized (thread-safe) Trove map backed by the specified
* map. In order to guarantee serial access, it is critical that
* <strong>all</strong> access to the backing map is accomplished
* through the returned map.<p>
*
* It is imperative that the user manually synchronize on the returned
* map when iterating over any of its collection views:
* <pre>
* 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() );
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>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 <K> TObjectCharMap<K> synchronizedMap( TObjectCharMap<K> m ) {
return new TSynchronizedObjectCharMap<K>( m );
}
}