java.lang.Object
speiger.src.collections.objects.utils.maps.Object2ShortMaps

public class Object2ShortMaps extends Object
A Helper class that provides you with Singleton/Empty/Synchronized/Unmodifyable Maps
  • Konstruktordetails

    • Object2ShortMaps

      public Object2ShortMaps()
  • Methodendetails

    • empty

      public static <T> Object2ShortMap<T> empty()
      Empty Map getter function that autocasts to the desired Key and Value
      Typparameter:
      T - the keyType of elements maintained by this Collection
      Gibt zurück:
      empty map of desired type
    • fastIterator

      public static <T> ObjectIterator<Object2ShortMap.Entry<T>> fastIterator(Object2ShortMap<T> map)
      Helper method that provides the fastIterator that recycles a single Entry to increase throughput.
      Typparameter:
      T - the keyType of elements maintained by this Collection
      Parameter:
      map - the map the fastIterator should be accessed from
      Gibt zurück:
      either a normal iterator if it does not support this feature to a fastIterator
    • fastIterable

      public static <T> ObjectIterable<Object2ShortMap.Entry<T>> fastIterable(Object2ShortMap<T> map)
      Helper method that provides the fastIterable that recycles a single Entry to increase throughput.
      Typparameter:
      T - the keyType of elements maintained by this Collection
      Parameter:
      map - the map the fastIterable should be accessed from
      Gibt zurück:
      either a normal iterable if it does not support this feature to a fastIterable
    • fastForEach

      public static <T> void fastForEach(Object2ShortMap<T> map, Consumer<Object2ShortMap.Entry<T>> action)
      A Helper function that provides a faster forEach iterator implementation that recycles the entry to increase throughput
      Typparameter:
      T - the keyType of elements maintained by this Collection
      Parameter:
      map - the map the fast forEach should be accessed from
      action - the action that should be performed on each entry
      Note:
      if the fast forEach is not supported will default to a normal forEach
    • synchronize

      public static <T> Object2ShortMap<T> synchronize(Object2ShortMap<T> map)
      Helper function that creates a Helper wrapper to synchronize access into the map.
      Typparameter:
      T - the keyType of elements maintained by this Collection
      Parameter:
      map - the map that should be synchronized
      Gibt zurück:
      a synchronized Map
      Note:
      if the inputted map is already synchronized then it will just return it instead, iterators do not support synchronization
    • synchronize

      public static <T> Object2ShortMap<T> synchronize(Object2ShortMap<T> map, Object mutex)
      Helper function that creates a Helper wrapper to synchronize access with custom access control into the map.
      Typparameter:
      T - the keyType of elements maintained by this Collection
      Parameter:
      map - the map that should be synchronized
      mutex - the object that controls access
      Gibt zurück:
      a synchronized Map
      Note:
      if the inputted map is already synchronized then it will just return it instead, iterators do not support synchronization
    • synchronize

      public static <T> Object2ShortSortedMap<T> synchronize(Object2ShortSortedMap<T> map)
      Helper function that creates a Helper wrapper to synchronize access into the SortedMap.
      Typparameter:
      T - the keyType of elements maintained by this Collection
      Parameter:
      map - the SortedMap that should be synchronized
      Gibt zurück:
      a synchronized SortedMap
      Note:
      if the inputted map is already synchronized then it will just return it instead, iterators do not support synchronization
    • synchronize

      public static <T> Object2ShortSortedMap<T> synchronize(Object2ShortSortedMap<T> map, Object mutex)
      Helper function that creates a Helper wrapper to synchronize access with custom access control into the SortedMap.
      Typparameter:
      T - the keyType of elements maintained by this Collection
      Parameter:
      map - the SortedMap that should be synchronized
      mutex - the object that controls access
      Gibt zurück:
      a synchronized SortedMap
      Note:
      if the inputted map is already synchronized then it will just return it instead, iterators do not support synchronization
    • synchronize

      public static <T> Object2ShortOrderedMap<T> synchronize(Object2ShortOrderedMap<T> map)
      Helper function that creates a Helper wrapper to synchronize access into the OrderedMap.
      Typparameter:
      T - the keyType of elements maintained by this Collection
      Parameter:
      map - the OrderedMap that should be synchronized
      Gibt zurück:
      a synchronized OrderedMap
      Note:
      if the inputted map is already synchronized then it will just return it instead, iterators do not support synchronization
    • synchronize

      public static <T> Object2ShortOrderedMap<T> synchronize(Object2ShortOrderedMap<T> map, Object mutex)
      Helper function that creates a Helper wrapper to synchronize access with custom access control into the OrderedMap.
      Typparameter:
      T - the keyType of elements maintained by this Collection
      Parameter:
      map - the OrderedMap that should be synchronized
      mutex - the object that controls access
      Gibt zurück:
      a synchronized OrderedMap
      Note:
      if the inputted map is already synchronized then it will just return it instead, iterators do not support synchronization
    • synchronize

      public static <T> Object2ShortNavigableMap<T> synchronize(Object2ShortNavigableMap<T> map)
      Helper function that creates a Helper wrapper to synchronize access into the NavigableMap.
      Typparameter:
      T - the keyType of elements maintained by this Collection
      Parameter:
      map - the NavigableMap that should be synchronized
      Gibt zurück:
      a synchronized NavigableMap
      Note:
      if the inputted map is already synchronized then it will just return it instead, iterators do not support synchronization
    • synchronize

      public static <T> Object2ShortNavigableMap<T> synchronize(Object2ShortNavigableMap<T> map, Object mutex)
      Helper function that creates a Helper wrapper to synchronize access with custom access control into the NavigableMap.
      Typparameter:
      T - the keyType of elements maintained by this Collection
      Parameter:
      map - the NavigableMap that should be synchronized
      mutex - the object that controls access
      Gibt zurück:
      a synchronized NavigableMap
      Note:
      if the inputted map is already synchronized then it will just return it instead, iterators do not support synchronization
    • unmodifiable

      public static <T> Object2ShortMap<T> unmodifiable(Object2ShortMap<T> map)
      A Helper function that creates a Helper wrapper to only allow Read Access into the Map
      Typparameter:
      T - the keyType of elements maintained by this Collection
      Parameter:
      map - the map that should be made Unmodifiable
      Gibt zurück:
      a unmodifiable Map
      Note:
      if the inputted map is already unmodifiable then it will just return it instead
    • unmodifiable

      public static <T> Object2ShortOrderedMap<T> unmodifiable(Object2ShortOrderedMap<T> map)
      A Helper function that creates a Helper wrapper to only allow Read Access into the OrderedMap
      Typparameter:
      T - the keyType of elements maintained by this Collection
      Parameter:
      map - the OrderedMap that should be made Unmodifiable
      Gibt zurück:
      a unmodifiable OrderedMap
      Note:
      if the inputted OrderedMap is already unmodifiable then it will just return it instead
    • unmodifiable

      public static <T> Object2ShortSortedMap<T> unmodifiable(Object2ShortSortedMap<T> map)
      A Helper function that creates a Helper wrapper to only allow Read Access into the SortedMap
      Typparameter:
      T - the keyType of elements maintained by this Collection
      Parameter:
      map - the SortedMap that should be made Unmodifiable
      Gibt zurück:
      a unmodifiable SortedMap
      Note:
      if the inputted SortedMap is already unmodifiable then it will just return it instead
    • unmodifiable

      public static <T> Object2ShortNavigableMap<T> unmodifiable(Object2ShortNavigableMap<T> map)
      A Helper function that creates a Helper wrapper to only allow Read Access into NavigableMap Map
      Typparameter:
      T - the keyType of elements maintained by this Collection
      Parameter:
      map - the NavigableMap that should be made Unmodifiable
      Gibt zurück:
      a unmodifiable NavigableMap
      Note:
      if the inputted NavigableMap is already unmodifiable then it will just return it instead
    • unmodifiable

      public static <T> Object2ShortMap.Entry<T> unmodifiable(Object2ShortMap.Entry<T> entry)
      A Helper function that creates a Unmodifyable Entry
      Typparameter:
      T - the keyType of elements maintained by this Collection
      Parameter:
      entry - the Entry that should be made unmodifiable
      Gibt zurück:
      a Unmodifyable Entry
    • unmodifiable

      public static <T> Object2ShortMap.Entry<T> unmodifiable(Map.Entry<T,Short> entry)
      A Helper function that creates a Unmodifyable Entry
      Typparameter:
      T - the keyType of elements maintained by this Collection
      Parameter:
      entry - the Entry that should be made unmodifiable
      Gibt zurück:
      a Unmodifyable Entry
    • singleton

      public static <T> Object2ShortMap<T> singleton(T key, short value)
      Creates a Singleton map from the provided values. This reduces overhead that normal Map implementations have.
      Typparameter:
      T - the keyType of elements maintained by this Collection
      Parameter:
      key - the key that should be turned into a singleton
      value - the value that should be turned into a singleton
      Gibt zurück:
      a unmodifiable Singleton map.