Package com.github.tommyettinger.ds

Class EnumOrderedMap<V>

java.lang.Object
com.github.tommyettinger.ds.EnumMap<V>
com.github.tommyettinger.ds.EnumOrderedMap<V>
All Implemented Interfaces:
Arrangeable, Ordered<Enum<?>>, Iterable<Map.Entry<Enum<?>,V>>, Map<Enum<?>,V>
public class EnumOrderedMap<V> extends EnumMap<V> implements Ordered<Enum<?>>
An EnumMap that also stores keys in an ObjectList using the insertion order. Null keys are not allowed. No allocation is done except when growing the table size. Unlike EnumMap, this does not require a Class at construction time, which can be useful for serialization purposes. Instead of storing a Class, this holds a "key universe" (which is almost always the same as an array returned by calling values() on an Enum type), and key universes are ideally shared between compatible EnumOrderedMaps. No allocation is done unless this is changing its table size and/or key universe. You can change the ordering of the Enum items using methods like sort(Comparator) and Ordered.shuffle(Random). You can also access enums via their index in the ordering, using methods such as getAt(int), alterAt(int, Enum), and removeAt(int).
The key universe is an important concept here; it is simply an array of all possible Enum values the EnumOrderedMap can use as keys, in the specific order they are declared. You almost always get a key universe by calling MyEnum.values(), but you can also use Class.getEnumConstants() for an Enum class. You can and generally should reuse key universes in order to avoid allocations and/or save memory; the static method noneOf(Enum[]) creates an empty EnumOrderedMap with a given key universe. If you need to use the zero-argument constructor, you can, and the key universe will be obtained from the first key placed into the EnumOrderedMap, though it won't be shared at first. You can also set the key universe with clearToUniverse(Enum[]), in the process of clearing the map.
Iteration is ordered and faster than an unordered map. Keys can also be accessed and the order changed using order(). There is some additional overhead for put and remove. Unordered sets and maps are not designed to provide especially fast iteration. Iteration is faster with Ordered types like EnumOrderedSet and EnumOrderedMap.
This class tries to be as compatible as possible with EnumMap, though this expands on that where possible.

  • Field Details

  • Constructor Details

    • EnumOrderedMap

      public EnumOrderedMap(OrderType type)
      Constructor that only specifies an OrderType; using this will postpone creating the key universe and allocating the value table until put(java.lang.Enum<?>, V) is first called (potentially indirectly). You can also use clearToUniverse(java.lang.Enum<?>[]) to set the key universe and value table.
      Parameters:
      type - either OrderType.BAG to use unreliable ordering with faster deletion, or anything else to use a list type that takes longer to delete but maintains insertion order reliably

    • EnumOrderedMap

      public EnumOrderedMap(Enum<?>[] universe, OrderType type)
      Initializes this map so that it has exactly enough capacity as needed to contain each Enum constant defined in universe, assuming universe stores every possible constant in one Enum type. This map will start empty. You almost always obtain universe from calling values() on an Enum type, and you can share one reference to one Enum array across many EnumOrderedMap instances if you don't modify the shared array. Sharing the same universe helps save some memory if you have (very) many EnumOrderedMap instances.
      Parameters:
      universe - almost always, the result of calling values() on an Enum type; used directly, not copied
      type - either OrderType.BAG to use unreliable ordering with faster deletion, or anything else to use a list type that takes longer to delete but maintains insertion order reliably

    • EnumOrderedMap

      public EnumOrderedMap(Class<? extends Enum<?>> universeClass, OrderType type)
      Initializes this map so that it has exactly enough capacity as needed to contain each Enum constant defined by the Class universeClass, assuming universeClass is non-null. This simply calls EnumOrderedMap(Enum[]) for convenience. Note that this constructor allocates a new array of Enum constants each time it is called, where if you use EnumOrderedMap(Enum[]), you can reuse an unmodified array to reduce allocations.
      Parameters:
      universeClass - the Class of an Enum type that defines the universe of valid Enum items this can hold
      type - either OrderType.BAG to use unreliable ordering with faster deletion, or anything else to use a list type that takes longer to delete but maintains insertion order reliably

    • EnumOrderedMap

      public EnumOrderedMap(EnumOrderedMap<? extends V> map, OrderType type)
      Creates a new map identical to the specified EnumOrderedMap. This will share a key universe with the given EnumOrderedMap, if non-null. This overload allows specifying the OrderType independently of the one used in map.
      Parameters:
      map - an EnumMap to copy
      type - either OrderType.BAG to use unreliable ordering with faster deletion, or anything else to use a list type that takes longer to delete but maintains insertion order reliably

    • EnumOrderedMap

      public EnumOrderedMap(Map<? extends Enum<?>,? extends V> map, OrderType type)
      Creates a new map identical to the specified map.
      Parameters:
      map - a Map to copy; EnumOrderedMap will be faster
      type - either OrderType.BAG to use unreliable ordering with faster deletion, or anything else to use a list type that takes longer to delete but maintains insertion order reliably

    • EnumOrderedMap

      public EnumOrderedMap(Enum<?>[] keys, V[] values, OrderType type)
      Given two side-by-side arrays, one of Enum keys, one of V values, this constructs a map and inserts each pair of key and value into it. If keys and values have different lengths, this only uses the length of the smaller array.
      Parameters:
      keys - an array of Enum keys
      values - an array of V values
      type - either OrderType.BAG to use unreliable ordering with faster deletion, or anything else to use a list type that takes longer to delete but maintains insertion order reliably

    • EnumOrderedMap

      public EnumOrderedMap(Collection<? extends Enum<?>> keys, Collection<? extends V> values, OrderType type)
      Given two side-by-side collections, one of Enum keys, one of V values, this constructs a map and inserts each pair of key and value into it. If keys and values have different lengths, this only uses the length of the smaller collection.
      Parameters:
      keys - a Collection of Enum keys
      values - a Collection of V values
      type - either OrderType.BAG to use unreliable ordering with faster deletion, or anything else to use a list type that takes longer to delete but maintains insertion order reliably

    • EnumOrderedMap

      public EnumOrderedMap(EnumOrderedMap<? extends V> other, int offset, int count, OrderType type)
      Creates a new map by copying count items from the given EnumOrderedMap, starting at offset in that Map, into this. This overload allows specifying the OrderType independently of the one used in other.
      Parameters:
      other - another EnumOrderedMap of the same types
      offset - the first index in other's ordering to draw an item from
      count - how many items to copy from other
      type - either OrderType.BAG to use unreliable ordering with faster deletion, or anything else to use a list type that takes longer to delete but maintains insertion order reliably

    • EnumOrderedMap

      public EnumOrderedMap()
      Empty constructor; using this will postpone creating the key universe and allocating the value table until put(java.lang.Enum<?>, V) is first called (potentially indirectly). You can also use clearToUniverse(java.lang.Enum<?>[]) to set the key universe and value table.

    • EnumOrderedMap

      public EnumOrderedMap(Enum<?>[] universe)
      Initializes this map so that it has exactly enough capacity as needed to contain each Enum constant defined in universe, assuming universe stores every possible constant in one Enum type. This map will start empty. You almost always obtain universe from calling values() on an Enum type, and you can share one reference to one Enum array across many EnumOrderedMap instances if you don't modify the shared array. Sharing the same universe helps save some memory if you have (very) many EnumOrderedMap instances.
      Parameters:
      universe - almost always, the result of calling values() on an Enum type; used directly, not copied

    • EnumOrderedMap

      public EnumOrderedMap(Class<? extends Enum<?>> universeClass)
      Initializes this map so that it has exactly enough capacity as needed to contain each Enum constant defined by the Class universeClass, assuming universeClass is non-null. This simply calls EnumOrderedMap(Enum[]) for convenience. Note that this constructor allocates a new array of Enum constants each time it is called, where if you use EnumOrderedMap(Enum[]), you can reuse an unmodified array to reduce allocations.
      Parameters:
      universeClass - the Class of an Enum type that defines the universe of valid Enum items this can hold

    • EnumOrderedMap

      public EnumOrderedMap(EnumOrderedMap<? extends V> map)
      Creates a new map identical to the specified EnumOrderedMap. This will share a key universe with the given EnumOrderedMap, if non-null. This overload uses the OrderType of the given map.
      Parameters:
      map - an EnumMap to copy

    • EnumOrderedMap

      public EnumOrderedMap(Map<? extends Enum<?>,? extends V> map)
      Creates a new map identical to the specified map.
      Parameters:
      map - a Map to copy; EnumOrderedMap will be faster

    • EnumOrderedMap

      public EnumOrderedMap(Enum<?>[] keys, V[] values)
      Given two side-by-side arrays, one of Enum keys, one of V values, this constructs a map and inserts each pair of key and value into it. If keys and values have different lengths, this only uses the length of the smaller array.
      Parameters:
      keys - an array of Enum keys
      values - an array of V values

    • EnumOrderedMap

      public EnumOrderedMap(Collection<? extends Enum<?>> keys, Collection<? extends V> values)
      Given two side-by-side collections, one of Enum keys, one of V values, this constructs a map and inserts each pair of key and value into it. If keys and values have different lengths, this only uses the length of the smaller collection.
      Parameters:
      keys - a Collection of Enum keys
      values - a Collection of V values

    • EnumOrderedMap

      public EnumOrderedMap(EnumOrderedMap<? extends V> other, int offset, int count)
      Creates a new map by copying count items from the given EnumOrderedMap, starting at offset in that Map, into this. This overload uses the OrderType of the given map.
      Parameters:
      other - another EnumOrderedMap of the same types
      offset - the first index in other's ordering to draw an item from
      count - how many items to copy from other

  • Method Details

    • put

      public V put(Enum<?> key, V value)
      Returns the old value associated with the specified key, or this map's EnumMap.defaultValue if there was no prior value. If this EnumOrderedMap does not yet have a key universe and/or value table, this gets the key universe from key and uses it from now on for this EnumOrderedMap.
      Specified by:
      put in interface Map<Enum<?>,V>
      Overrides:
      put in class EnumMap<V>
      Parameters:
      key - the Enum key to try to place into this EnumOrderedMap
      value - the V value to associate with key
      Returns:
      the previous value associated with key, or EnumMap.getDefaultValue() if the given key was not present

    • put

      public V put(Enum<?> key, V value, int index)
      Puts the given key and value into this map at the given index in its order. If the key is already present at a different index, it is moved to the given index and its value is set to the given value.
      Parameters:
      key - an Enum key; must not be null
      value - a V value; permitted to be null
      index - the index in the order to place the given key and value; must be non-negative and less than EnumMap.size()
      Returns:
      the previous value associated with key, if there was one, or null otherwise

    • putOrDefault

      public V putOrDefault(Enum<?> key, V value, V defaultValue)
      Description copied from class: EnumMap
      Acts like EnumMap.put(Enum, Object), but uses the specified defaultValue instead of the default value for this EnumMap.
      Overrides:
      putOrDefault in class EnumMap<V>
      Parameters:
      key - the Enum key to try to place into this EnumMap
      value - the V value to associate with key
      defaultValue - the V value to return if key was not already present
      Returns:
      the previous value associated with key, or the given defaultValue if the given key was not present

    • putAll

      public void putAll(EnumOrderedMap<? extends V> map)
      Puts every key-value pair in the given map into this, with the values from the given map overwriting the previous values if two keys are identical. This will put keys in the order of the given map.
      Parameters:
      map - a map with compatible key and value types; will not be modified

    • putAll

      public void putAll(EnumOrderedMap<? extends V> other, int offset, int count)
      Adds up to count entries, starting from offset, in the map other to this map, inserting at the end of the iteration order.
      Parameters:
      other - a non-null ordered map with the same type and compatible generic types
      offset - the first index in other to use
      count - how many indices in other to use

    • putAll

      public void putAll(int insertionIndex, EnumOrderedMap<? extends V> other, int offset, int count)
      Adds up to count entries, starting from offset, in the map other to this map, inserting starting at insertionIndex in the iteration order.
      Parameters:
      insertionIndex - where to insert into the iteration order
      other - a non-null ordered map with the same type and compatible generic types
      offset - the first index in other to use
      count - how many indices in other to use

    • remove

      public V remove(Object key)
      Specified by:
      remove in interface Map<Enum<?>,V>
      Overrides:
      remove in class EnumMap<V>

    • removeAt

      public V removeAt(int index)
      Removes the entry at the given index in the order, returning the value of that entry.
      Parameters:
      index - the index of the entry to remove; must be at least 0 and less than EnumMap.size()
      Returns:
      the value of the removed entry

    • alter

      public boolean alter(Enum<?> before, Enum<?> after)
      Changes the key before to after without changing its position in the order or its value. Returns true if after has been added to the EnumOrderedMap and before has been removed; returns false if after is already present or before is not present. If you are iterating over an EnumOrderedMap and have an index, you should prefer alterAt(int, Enum), which doesn't need to search for an index like this does and so can be faster.
      Parameters:
      before - a key that must be present for this to succeed
      after - a key that must not be in this map for this to succeed
      Returns:
      true if before was removed and after was added, false otherwise

    • alterAt

      public boolean alterAt(int index, Enum<?> after)
      Changes the key at the given index in the order to after, without changing the ordering of other entries or any values. If after is already present, this returns false; it will also return false if index is invalid for the size of this map. Otherwise, it returns true. Unlike alter(Enum, Enum), this operates in constant time.
      Parameters:
      index - the index in the order of the key to change; must be non-negative and less than EnumMap.size
      after - the key that will replace the contents at index; this key must not be present for this to succeed
      Returns:
      true if after successfully replaced the key at index, false otherwise

    • setAt

      public V setAt(int index, V v)
      Changes the value at a specified index in the iteration order to v, without changing keys at all. If index isn't currently a valid index in the iteration order, this returns null. Otherwise, it returns the value that was previously held at index, which may also be null.
      Parameters:
      v - the new V value to assign
      index - the index in the iteration order to set v at
      Returns:
      the previous value held at index in the iteration order, which may be null if the value was null or if index was invalid

    • getAt

      public V getAt(int index)
      Gets the V value at the given index in the insertion order. The index should be between 0 (inclusive) and EnumMap.size() (exclusive).
      Parameters:
      index - an index in the insertion order, between 0 (inclusive) and EnumMap.size() (exclusive)
      Returns:
      the value at the given index

    • keyAt

      public Enum<?> keyAt(int index)
      Gets the Enum key at the given index in the insertion order. The index should be between 0 (inclusive) and EnumMap.size() (exclusive).
      Parameters:
      index - an index in the insertion order, between 0 (inclusive) and EnumMap.size() (exclusive)
      Returns:
      the key at the given index

    • clear

      public void clear()
      Removes all the elements from this map. The map will be empty after this call returns. This does not change the universe of possible Enum items this can hold.
      Specified by:
      clear in interface Map<Enum<?>,V>
      Overrides:
      clear in class EnumMap<V>

    • clearToUniverse

      public void clearToUniverse(Enum<?>[] universe)
      Removes all the elements from this map and can reset the universe of possible Enum items this can hold. The map will be empty after this call returns. This changes the universe of possible Enum items this can hold to match universe. If universe is null, this resets this map to the state it would have after EnumOrderedMap() was called. If the table this would need is the same size as or smaller than the current table (such as if universe is the same as the universe here), this will not allocate, but will still clear any items this holds and will set the universe to the given one. Otherwise, this allocates and uses a new table of a larger size, with nothing in it, and uses the given universe. This always uses universe directly, without copying.
      This can be useful to allow an EnumOrderedMap that was created with EnumOrderedMap() to share a universe with other EnumOrderedMaps.
      Overrides:
      clearToUniverse in class EnumMap<V>
      Parameters:
      universe - the universe of possible Enum items this can hold; almost always produced by values() on an Enum

    • clearToUniverse

      public void clearToUniverse(Class<? extends Enum<?>> universe)
      Removes all the elements from this map and can reset the universe of possible Enum items this can hold. The map will be empty after this call returns. This changes the universe of possible Enum items this can hold to match the Enum constants in universe. If universe is null, this resets this map to the state it would have after EnumOrderedMap() was called. If the table this would need is the same size as or smaller than the current table (such as if universe is the same as the universe here), this will not allocate, but will still clear any items this holds and will set the universe to the given one. Otherwise, this allocates and uses a new table of a larger size, with nothing in it, and uses the given universe. This calls Class.getEnumConstants() if universe is non-null, which allocates a new array.
      You may want to prefer calling clearToUniverse(Enum[]) (the overload that takes an array), because it can be used to share one universe array between many EnumOrderedMap instances. This overload, given a Class, has to call Class.getEnumConstants() and thus allocate a new array each time this is called.
      Overrides:
      clearToUniverse in class EnumMap<V>
      Parameters:
      universe - the Class of an Enum type that stores the universe of possible Enum items this can hold

    • order

      public ObjectList<Enum<?>> order()
      Gets the ObjectList of keys in the order this class will iterate through them. Returns a direct reference to the same ObjectList this uses, so changes to the returned list will also change the iteration order here.
      Specified by:
      order in interface Ordered<V>
      Returns:
      the ObjectList of keys, in iteration order (usually insertion-order), that this uses

    • sort

      public void sort()
      Sorts this EnumOrderedMap in-place by the keys' natural ordering.

    • sort

      public void sort(Comparator<? super Enum<?>> comp)
      Sorts this EnumOrderedMap in-place by the given Comparator used on the keys. If comp is null, then this will sort by the natural ordering of the keys.
      Specified by:
      sort in interface Ordered<V>
      Parameters:
      comp - a Comparator that can compare two Enum keys, or null to use the keys' natural ordering

    • sortByValue

      public void sortByValue(Comparator<V> comp)
      Sorts this EnumOrderedMap in-place by the given Comparator used on the values. comp must be able to compare V values. If any null values are present in this EnumOrderedMap, then comp must be able to sort or otherwise handle null values. You can use pass null to do what sort() does when given null (just sorting values in this case instead of keys) if the values implement Comparable (requiring all of them to be non-null).
      Parameters:
      comp - a Comparator that can compare V values; may be null to use natural order of Comparable values

    • removeRange

      public void removeRange(int start, int end)
      Removes the items between the specified start index, inclusive, and end index, exclusive. Note that this takes different arguments than some other range-related methods; this needs a start index and an end index, rather than a count of items. This matches the behavior in the JDK collections.
      Specified by:
      removeRange in interface Ordered<V>
      Parameters:
      start - the first index to remove, inclusive
      end - the last index (after what should be removed), exclusive

    • truncate

      public void truncate(int newSize)
      Reduces the size of the map to the specified size. If the map is already smaller than the specified size, no action is taken.
      Overrides:
      truncate in class EnumMap<V>
      Parameters:
      newSize - the target size to try to reach by removing items, if smaller than the current size

    • keySet

      public EnumMap.Keys keySet()
      Returns a Set view of the keys contained in this map. The set is backed by the map, so changes to the map are reflected in the set, and vice versa. If the map is modified while an iteration over the set is in progress (except through the iterator's own remove operation), the results of the iteration are undefined. The set supports element removal, which removes the corresponding mapping from the map, via the Iterator.remove, Set.remove, removeAll, retainAll, and clear operations. It does not support the add or addAll operations.

      Note that the same Collection instance is returned each time this method is called. Use the OrderedMapKeys(EnumOrderedMap) constructor for nested or multithreaded iteration.

      Specified by:
      keySet in interface Map<Enum<?>,V>
      Overrides:
      keySet in class EnumMap<V>
      Returns:
      a set view of the keys contained in this map

    • values

      public EnumMap.Values<V> values()
      Returns a Collection for the values in the map. Remove is supported by the Collection's iterator.

      Note that the same Collection instance is returned each time this method is called. Use the OrderedMapValues(EnumOrderedMap) constructor for nested or multithreaded iteration.

      Specified by:
      values in interface Map<Enum<?>,V>
      Overrides:
      values in class EnumMap<V>
      Returns:
      a Collection of V values

    • entrySet

      public EnumMap.Entries<V> entrySet()
      Returns a Set of Map.Entry, containing the entries in the map. Remove is supported by the Set's iterator.

      Note that the same iterator instance is returned each time this method is called. Use the OrderedMapEntries(EnumOrderedMap) constructor for nested or multithreaded iteration.

      Specified by:
      entrySet in interface Map<Enum<?>,V>
      Overrides:
      entrySet in class EnumMap<V>
      Returns:
      a Set of Map.Entry key-value pairs

    • iterator

      public EnumMap.MapIterator<V,Map.Entry<Enum<?>,V>> iterator()
      Reuses the iterator of the reused EnumMap.Entries produced by entrySet(); does not permit nested iteration. Iterate over OrderedMapEntries(EnumOrderedMap) if you need nested or multithreaded iteration. You can remove an Entry from this EnumOrderedMap using this Iterator.
      Specified by:
      iterator in interface Iterable<V>
      Overrides:
      iterator in class EnumMap<V>
      Returns:
      an Iterator over key-value pairs as Map.Entry values

    • appendTo

      public StringBuilder appendTo(StringBuilder sb, String entrySeparator, String keyValueSeparator, boolean braces, Appender<Enum<?>> keyAppender, Appender<V> valueAppender)
      Appends to a StringBuilder from the contents of this EnumOrderedMap, but uses the given Appender and Appender to convert each key and each value to a customizable representation and append them to a StringBuilder. To use the default toString representation, you can use Appender::append as an appender, or to use the readable Enum Enum.name(), use Appender.ENUM_NAME_APPENDER.
      Overrides:
      appendTo in class EnumMap<V>
      Parameters:
      sb - a StringBuilder that this can append to
      entrySeparator - how to separate entries, such as ", "
      keyValueSeparator - how to separate each key from its value, such as "=" or ":"
      braces - true to wrap the output in curly braces, or false to omit them
      keyAppender - a function that takes a StringBuilder and an Enum, and returns the modified StringBuilder
      valueAppender - a function that takes a StringBuilder and a V, and returns the modified StringBuilder
      Returns:
      sb, with the appended keys and values of this map

    • with

      public static <V> EnumOrderedMap<V> with()
      Constructs an empty map given the value type as a generic type argument. This is usually less useful than just using the constructor, but can be handy in some code-generation scenarios when you don't know how many arguments you will have.
      Type Parameters:
      V - the type of values
      Returns:
      a new map containing nothing

    • with

      public static <V> EnumOrderedMap<V> with(Enum<?> key0, V value0)
      Constructs a single-entry map given one key and one value. This is mostly useful as an optimization for with(Enum, Object, Object...) when there's no "rest" of the keys or values.
      Type Parameters:
      V - the type of value0
      Parameters:
      key0 - the first and only key
      value0 - the first and only value
      Returns:
      a new map containing just the entry mapping key0 to value0

    • with

      public static <V> EnumOrderedMap<V> with(Enum<?> key0, V value0, Enum<?> key1, V value1)
      Constructs a single-entry map given two key-value pairs. This is mostly useful as an optimization for with(Enum, Object, Object...) when there's no "rest" of the keys or values.
      Type Parameters:
      V - the type of value0
      Parameters:
      key0 - an Enum key
      value0 - a V value
      key1 - an Enum key
      value1 - a V value
      Returns:
      a new map containing entries mapping each key to the following value

    • with

      public static <V> EnumOrderedMap<V> with(Enum<?> key0, V value0, Enum<?> key1, V value1, Enum<?> key2, V value2)
      Constructs a single-entry map given three key-value pairs. This is mostly useful as an optimization for with(Enum, Object, Object...) when there's no "rest" of the keys or values.
      Type Parameters:
      V - the type of value0
      Parameters:
      key0 - an Enum key
      value0 - a V value
      key1 - an Enum key
      value1 - a V value
      key2 - an Enum key
      value2 - a V value
      Returns:
      a new map containing entries mapping each key to the following value

    • with

      public static <V> EnumOrderedMap<V> with(Enum<?> key0, V value0, Enum<?> key1, V value1, Enum<?> key2, V value2, Enum<?> key3, V value3)
      Constructs a single-entry map given four key-value pairs. This is mostly useful as an optimization for with(Enum, Object, Object...) when there's no "rest" of the keys or values.
      Type Parameters:
      V - the type of value0
      Parameters:
      key0 - an Enum key
      value0 - a V value
      key1 - an Enum key
      value1 - a V value
      key2 - an Enum key
      value2 - a V value
      key3 - an Enum key
      value3 - a V value
      Returns:
      a new map containing entries mapping each key to the following value

    • with

      public static <V> EnumOrderedMap<V> with(Enum<?> key0, V value0, Object... rest)
      Constructs a map given alternating keys and values. This can be useful in some code-generation scenarios, or when you want to make a map conveniently by-hand and have it populated at the start. You can also use EnumOrderedMap(Enum[], Object[]), which takes all keys and then all values. This needs all keys to have the same type and all values to have the same type, because it gets those types from the first key parameter and first value parameter. Any keys that don't have Enum as their type or values that don't have V as their type have that entry skipped.
      Type Parameters:
      V - the type of values, inferred from value0
      Parameters:
      key0 - the first key
      value0 - the first value; will be used to determine the type of all values
      rest - an array or varargs of alternating Enum, V, Enum, V... elements
      Returns:
      a new map containing the given keys and values

    • parse

      public static <V> EnumOrderedMap<V> parse(String str, String entrySeparator, String keyValueSeparator, PartialParser<Enum<?>> keyParser, PartialParser<V> valueParser)
      Creates a new map by parsing all of str with the given PartialParser for keys and for values, with entries separated by entrySeparator, such as ", " and the keys separated from values by keyValueSeparator, such as "=".
      Various PartialParser instances are defined as constants, such as PartialParser.DEFAULT_STRING, and others can be created by static methods in PartialParser, such as PartialParser.objectListParser(PartialParser, String, boolean). The keyParser is often produced by PartialParser.enumParser(ObjToObjFunction).
      Parameters:
      str - a String containing parseable text
      entrySeparator - the String separating every key-value pair
      keyValueSeparator - the String separating every key from its corresponding value
      keyParser - a PartialParser that returns an Enum key from a section of str
      valueParser - a PartialParser that returns a V value from a section of str

    • parse

      public static <V> EnumOrderedMap<V> parse(String str, String entrySeparator, String keyValueSeparator, PartialParser<Enum<?>> keyParser, PartialParser<V> valueParser, boolean brackets)
      Creates a new map by parsing all of str (or if brackets is true, all but the first and last chars) with the given PartialParser for keys and for values, with entries separated by entrySeparator, such as ", " and the keys separated from values by keyValueSeparator, such as "=".
      Various PartialParser instances are defined as constants, such as PartialParser.DEFAULT_STRING, and others can be created by static methods in PartialParser, such as PartialParser.objectListParser(PartialParser, String, boolean). The keyParser is often produced by PartialParser.enumParser(ObjToObjFunction).
      Parameters:
      str - a String containing parseable text
      entrySeparator - the String separating every key-value pair
      keyValueSeparator - the String separating every key from its corresponding value
      keyParser - a PartialParser that returns an Enum key from a section of str
      valueParser - a PartialParser that returns a V value from a section of str
      brackets - if true, the first and last chars in str will be ignored

    • parse

      public static <V> EnumOrderedMap<V> parse(String str, String entrySeparator, String keyValueSeparator, PartialParser<Enum<?>> keyParser, PartialParser<V> valueParser, int offset, int length)
      Creates a new map by parsing the given subrange of str with the given PartialParser for keys and for values, with entries separated by entrySeparator, such as ", " and the keys separated from values by keyValueSeparator, such as "=".
      Various PartialParser instances are defined as constants, such as PartialParser.DEFAULT_STRING, and others can be created by static methods in PartialParser, such as PartialParser.objectListParser(PartialParser, String, boolean). The keyParser is often produced by PartialParser.enumParser(ObjToObjFunction).
      Parameters:
      str - a String containing parseable text
      entrySeparator - the String separating every key-value pair
      keyValueSeparator - the String separating every key from its corresponding value
      keyParser - a PartialParser that returns an Enum key from a section of str
      valueParser - a PartialParser that returns a V value from a section of str
      offset - the first position to read parseable text from in str
      length - how many chars to read; -1 is treated as maximum length

    • of

      public static <V> EnumOrderedMap<V> of()
      Constructs an empty map given the types as generic type arguments; an alias for with().
      Type Parameters:
      V - the type of values
      Returns:
      a new map containing nothing

    • of

      public static <V> EnumOrderedMap<V> of(Enum<?> key0, V value0)
      Constructs a single-entry map given one key and one value; an alias for with(Enum, Object).
      Type Parameters:
      V - the type of value0
      Parameters:
      key0 - the first and only key
      value0 - the first and only value
      Returns:
      a new map containing just the entry mapping key0 to value0

    • of

      public static <V> EnumOrderedMap<V> of(Enum<?> key0, V value0, Object... rest)
      Constructs a map given alternating keys and values; an alias for with(Enum, Object, Object...).
      Type Parameters:
      V - the type of values, inferred from value0
      Parameters:
      key0 - the first key (an Enum)
      value0 - the first value; will be used to determine the type of all values
      rest - an array or varargs of alternating Enum, V, Enum, V... elements
      Returns:
      a new map containing the given keys and values

    • noneOf

      public static <V> EnumOrderedMap<V> noneOf(Enum<?>[] universe)
      Constructs an empty map that can store keys from the given universe, using the specified generic type for values. The universe is usually obtained from an Enum type's values() method, and is often shared between Enum-keyed maps and sets.
      Type Parameters:
      V - the type of values
      Parameters:
      universe - a key universe, as an array of Enum constants typically obtained via values()
      Returns:
      a new map containing nothing