Package gnu.trove

Class TDecorators

java.lang.Object
gnu.trove.TDecorators

public class TDecorators extends Object
This is a static utility class that provides functions for simplifying creation of decorators.
Since:
Trove 2.1
  • Method Details

    • wrap

      public static Map<Double,Double> wrap(TDoubleDoubleMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TDoubleDoubleObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Double,Float> wrap(TDoubleFloatMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TDoubleFloatObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Double,Integer> wrap(TDoubleIntMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TDoubleIntObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Double,Long> wrap(TDoubleLongMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TDoubleLongObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Double,Byte> wrap(TDoubleByteMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TDoubleByteObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Double,Short> wrap(TDoubleShortMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TDoubleShortObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Double,Character> wrap(TDoubleCharMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TDoubleCharObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Float,Double> wrap(TFloatDoubleMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TFloatDoubleObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Float,Float> wrap(TFloatFloatMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TFloatFloatObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Float,Integer> wrap(TFloatIntMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TFloatIntObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Float,Long> wrap(TFloatLongMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TFloatLongObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Float,Byte> wrap(TFloatByteMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TFloatByteObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Float,Short> wrap(TFloatShortMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TFloatShortObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Float,Character> wrap(TFloatCharMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TFloatCharObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Integer,Double> wrap(TIntDoubleMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TIntDoubleObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Integer,Float> wrap(TIntFloatMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TIntFloatObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Integer,Integer> wrap(TIntIntMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TIntIntObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Integer,Long> wrap(TIntLongMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TIntLongObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Integer,Byte> wrap(TIntByteMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TIntByteObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Integer,Short> wrap(TIntShortMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TIntShortObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Integer,Character> wrap(TIntCharMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TIntCharObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Long,Double> wrap(TLongDoubleMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TLongDoubleObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Long,Float> wrap(TLongFloatMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TLongFloatObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Long,Integer> wrap(TLongIntMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TLongIntObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Long,Long> wrap(TLongLongMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TLongLongObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Long,Byte> wrap(TLongByteMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TLongByteObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Long,Short> wrap(TLongShortMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TLongShortObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Long,Character> wrap(TLongCharMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TLongCharObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Byte,Double> wrap(TByteDoubleMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TByteDoubleObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Byte,Float> wrap(TByteFloatMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TByteFloatObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Byte,Integer> wrap(TByteIntMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TByteIntObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Byte,Long> wrap(TByteLongMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TByteLongObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Byte,Byte> wrap(TByteByteMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TByteByteObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Byte,Short> wrap(TByteShortMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TByteShortObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Byte,Character> wrap(TByteCharMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TByteCharObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Short,Double> wrap(TShortDoubleMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TShortDoubleObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Short,Float> wrap(TShortFloatMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TShortFloatObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Short,Integer> wrap(TShortIntMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TShortIntObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Short,Long> wrap(TShortLongMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TShortLongObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Short,Byte> wrap(TShortByteMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TShortByteObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Short,Short> wrap(TShortShortMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TShortShortObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Short,Character> wrap(TShortCharMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TShortCharObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Character,Double> wrap(TCharDoubleMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TCharDoubleObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Character,Float> wrap(TCharFloatMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TCharFloatObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Character,Integer> wrap(TCharIntMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TCharIntObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Character,Long> wrap(TCharLongMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TCharLongObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Character,Byte> wrap(TCharByteMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TCharByteObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Character,Short> wrap(TCharShortMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TCharShortObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Map<Character,Character> wrap(TCharCharMap map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TCharCharObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static <T> Map<T,Double> wrap(TObjectDoubleMap<T> map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TObjectDoubleMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static <T> Map<T,Float> wrap(TObjectFloatMap<T> map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TObjectFloatMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static <T> Map<T,Integer> wrap(TObjectIntMap<T> map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TObjectIntMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static <T> Map<T,Long> wrap(TObjectLongMap<T> map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TObjectLongMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static <T> Map<T,Byte> wrap(TObjectByteMap<T> map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TObjectByteMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static <T> Map<T,Short> wrap(TObjectShortMap<T> map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TObjectShortMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static <T> Map<T,Character> wrap(TObjectCharMap<T> map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TObjectCharMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static <T> Map<Double,T> wrap(TDoubleObjectMap<T> map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TDoubleObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static <T> Map<Float,T> wrap(TFloatObjectMap<T> map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TFloatObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static <T> Map<Integer,T> wrap(TIntObjectMap<T> map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TIntObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static <T> Map<Long,T> wrap(TLongObjectMap<T> map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TLongObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static <T> Map<Byte,T> wrap(TByteObjectMap<T> map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TByteObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static <T> Map<Short,T> wrap(TShortObjectMap<T> map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TShortObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static <T> Map<Character,T> wrap(TCharObjectMap<T> map)
      Wrap the given map in a decorator that uses the standard Map interface.
      Parameters:
      map - the TCharObjectMap to be wrapped
      Returns:
      the wrapped map.
    • wrap

      public static Set<Double> wrap(TDoubleSet set)
      Wrap the given set in a decorator that uses the standard Set interface.
      Parameters:
      set - the TDoubleSet to be wrapped
      Returns:
      the wrapped set.
    • wrap

      public static Set<Float> wrap(TFloatSet set)
      Wrap the given set in a decorator that uses the standard Set interface.
      Parameters:
      set - the TFloatSet to be wrapped
      Returns:
      the wrapped set.
    • wrap

      public static Set<Integer> wrap(TIntSet set)
      Wrap the given set in a decorator that uses the standard Set interface.
      Parameters:
      set - the TIntSet to be wrapped
      Returns:
      the wrapped set.
    • wrap

      public static Set<Long> wrap(TLongSet set)
      Wrap the given set in a decorator that uses the standard Set interface.
      Parameters:
      set - the TLongSet to be wrapped
      Returns:
      the wrapped set.
    • wrap

      public static Set<Byte> wrap(TByteSet set)
      Wrap the given set in a decorator that uses the standard Set interface.
      Parameters:
      set - the TByteSet to be wrapped
      Returns:
      the wrapped set.
    • wrap

      public static Set<Short> wrap(TShortSet set)
      Wrap the given set in a decorator that uses the standard Set interface.
      Parameters:
      set - the TShortSet to be wrapped
      Returns:
      the wrapped set.
    • wrap

      public static Set<Character> wrap(TCharSet set)
      Wrap the given set in a decorator that uses the standard Set interface.
      Parameters:
      set - the TCharSet to be wrapped
      Returns:
      the wrapped set.
    • wrap

      public static List<Double> wrap(TDoubleList list)
      Wrap the given list in a decorator that uses the standard List interface.
      Parameters:
      list - the TDoubleList to be wrapped
      Returns:
      the wrapped list.
    • wrap

      public static List<Float> wrap(TFloatList list)
      Wrap the given list in a decorator that uses the standard List interface.
      Parameters:
      list - the TFloatList to be wrapped
      Returns:
      the wrapped list.
    • wrap

      public static List<Integer> wrap(TIntList list)
      Wrap the given list in a decorator that uses the standard List interface.
      Parameters:
      list - the TIntList to be wrapped
      Returns:
      the wrapped list.
    • wrap

      public static List<Long> wrap(TLongList list)
      Wrap the given list in a decorator that uses the standard List interface.
      Parameters:
      list - the TLongList to be wrapped
      Returns:
      the wrapped list.
    • wrap

      public static List<Byte> wrap(TByteList list)
      Wrap the given list in a decorator that uses the standard List interface.
      Parameters:
      list - the TByteList to be wrapped
      Returns:
      the wrapped list.
    • wrap

      public static List<Short> wrap(TShortList list)
      Wrap the given list in a decorator that uses the standard List interface.
      Parameters:
      list - the TShortList to be wrapped
      Returns:
      the wrapped list.
    • wrap

      public static List<Character> wrap(TCharList list)
      Wrap the given list in a decorator that uses the standard List interface.
      Parameters:
      list - the TCharList to be wrapped
      Returns:
      the wrapped list.