Package com.github.tommyettinger.ds

Class ObjectLongOrderedMap<K>

java.lang.Object
com.github.tommyettinger.ds.ObjectLongMap<K>
com.github.tommyettinger.ds.ObjectLongOrderedMap<K>
All Implemented Interfaces:
Arrangeable, Ordered<K>, Iterable<ObjectLongMap.Entry<K>>
public class ObjectLongOrderedMap<K> extends ObjectLongMap<K> implements Ordered<K>
An ObjectLongMap 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.

Iteration over the entrySet(), keySet(), and values() 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.

This class performs fast contains (typically O(1), worst case O(n) but that is rare in practice). Remove is somewhat slower due to order(). Add may be slightly slower, depending on hash collisions. Hashcodes are rehashed to reduce collisions and the need to resize. Load factors greater than 0.91 greatly increase the chances to resize to the next higher POT size.

Unordered sets and maps are not designed to provide especially fast iteration. Iteration is faster with Ordered types like ObjectOrderedSet and ObjectObjectOrderedMap.

You can customize most behavior of this map by extending it. ObjectLongMap.place(Object) can be overridden to change how hashCodes are calculated (which can be useful for types like StringBuilder that don't implement hashCode()), and ObjectLongMap.equate(Object, Object) can be overridden to change how equality is calculated.

This implementation uses linear probing with the backward shift algorithm for removal. It tries different hashes from a simple family, with the hash changing on resize. Linear probing continues to work even when all hashCodes collide; it just works more slowly in that case.

  • Field Details

  • Constructor Details

    • ObjectLongOrderedMap

      public ObjectLongOrderedMap(OrderType ordering)
      Creates a new map with an initial capacity of Utilities.getDefaultTableCapacity() and a load factor of Utilities.getDefaultLoadFactor().
      Parameters:
      ordering - determines what implementation order() will use

    • ObjectLongOrderedMap

      public ObjectLongOrderedMap(int initialCapacity, OrderType ordering)
      Creates a new map with the given starting capacity and a load factor of Utilities.getDefaultLoadFactor().
      Parameters:
      initialCapacity - If not a power of two, it is increased to the next nearest power of two.
      ordering - determines what implementation order() will use

    • ObjectLongOrderedMap

      public ObjectLongOrderedMap(int initialCapacity, float loadFactor, OrderType ordering)
      Creates a new map with the specified initial capacity and load factor. This map will hold initialCapacity items before growing the backing table.
      Parameters:
      initialCapacity - If not a power of two, it is increased to the next nearest power of two.
      loadFactor - what fraction of the capacity can be filled before this has to resize; 0 < loadFactor <= 1
      ordering - determines what implementation order() will use

    • ObjectLongOrderedMap

      public ObjectLongOrderedMap(ObjectLongOrderedMap<? extends K> map)
      Creates a new map identical to the specified map.
      Parameters:
      map - the map to copy

    • ObjectLongOrderedMap

      public ObjectLongOrderedMap(ObjectLongMap<? extends K> map, OrderType ordering)
      Creates a new map identical to the specified map.
      Parameters:
      map - the map to copy
      ordering - determines what implementation order() will use

    • ObjectLongOrderedMap

      public ObjectLongOrderedMap(ObjectLongOrderedMap<? extends K> other, int offset, int count)
      Creates a new set by copying count items from the given ObjectLongOrderedMap, starting at offset in that Map, into this.
      Parameters:
      other - another ObjectLongOrderedMap of the same type
      offset - the first index in other's ordering to draw an item from
      count - how many items to copy from other

    • ObjectLongOrderedMap

      public ObjectLongOrderedMap(ObjectLongMap<? extends K> map)
      Creates a new map identical to the specified map.
      Parameters:
      map - the map to copy

    • ObjectLongOrderedMap

      public ObjectLongOrderedMap(ObjectLongOrderedMap<? extends K> other, int offset, int count, OrderType ordering)
      Creates a new set by copying count items from the given ObjectLongOrderedMap, starting at offset in that Map, into this.
      Parameters:
      other - another ObjectLongOrderedMap of the same type
      offset - the first index in other's ordering to draw an item from
      count - how many items to copy from other
      ordering - determines what implementation order() will use

    • ObjectLongOrderedMap

      public ObjectLongOrderedMap(K[] keys, long[] values, OrderType ordering)
      Given two side-by-side arrays, one of keys, one of 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 keys
      values - an array of values
      ordering - determines what implementation order() will use

    • ObjectLongOrderedMap

      public ObjectLongOrderedMap(Collection<? extends K> keys, PrimitiveCollection.OfLong values, OrderType ordering)
      Given two side-by-side collections, one of keys, one of 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 keys
      values - a PrimitiveCollection of values
      ordering - determines what implementation order() will use

    • ObjectLongOrderedMap

      public ObjectLongOrderedMap()
      Creates a new map with an initial capacity of Utilities.getDefaultTableCapacity() and a load factor of Utilities.getDefaultLoadFactor().

    • ObjectLongOrderedMap

      public ObjectLongOrderedMap(int initialCapacity)
      Creates a new map with the given starting capacity and a load factor of Utilities.getDefaultLoadFactor().
      Parameters:
      initialCapacity - If not a power of two, it is increased to the next nearest power of two.

    • ObjectLongOrderedMap

      public ObjectLongOrderedMap(int initialCapacity, float loadFactor)
      Creates a new map with the specified initial capacity and load factor. This map will hold initialCapacity items before growing the backing table.
      Parameters:
      initialCapacity - If not a power of two, it is increased to the next nearest power of two.
      loadFactor - what fraction of the capacity can be filled before this has to resize; 0 < loadFactor <= 1

    • ObjectLongOrderedMap

      public ObjectLongOrderedMap(K[] keys, long[] values)
      Given two side-by-side arrays, one of keys, one of 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 keys
      values - an array of values

    • ObjectLongOrderedMap

      public ObjectLongOrderedMap(Collection<? extends K> keys, PrimitiveCollection.OfLong values)
      Given two side-by-side collections, one of keys, one of 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 keys
      values - a PrimitiveCollection of values

  • Method Details

    • put

      public long put(K key, long value)
      Description copied from class: ObjectLongMap
      Returns the old value associated with the specified key, or this map's ObjectLongMap.defaultValue if there was no prior value.
      Overrides:
      put in class ObjectLongMap<K>

    • put

      public long put(K key, long 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 - a K key; must not be null
      value - a long value
      index - the index in the order to place the given key and value; must be non-negative and less than ObjectLongMap.size()
      Returns:
      the previous value associated with key, if there was one, or ObjectLongMap.defaultValue otherwise

    • putOrDefault

      public long putOrDefault(K key, long value, long defaultValue)
      Description copied from class: ObjectLongMap
      Returns the old value associated with the specified key, or the given defaultValue if there was no prior value.
      Overrides:
      putOrDefault in class ObjectLongMap<K>

    • putAll

      public void putAll(ObjectLongOrderedMap<? extends K> 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(ObjectLongOrderedMap<? extends K> other, int offset, int count)
      Adds up to count entries, starting from offset, in the map other to this set, 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, ObjectLongOrderedMap<? extends K> other, int offset, int count)
      Adds up to count entries, starting from offset, in the map other to this set, 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 long remove(Object key)
      Overrides:
      remove in class ObjectLongMap<K>

    • removeAt

      public long 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 ObjectLongMap.size()
      Returns:
      the value of the removed entry

    • 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<K>
      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 ObjectLongMap<K>
      Parameters:
      newSize - the target size to try to reach by removing items, if smaller than the current size

    • ensureCapacity

      public void ensureCapacity(int additionalCapacity)
      Increases the size of the backing array to accommodate the specified number of additional items / loadFactor. Useful before adding many items to avoid multiple backing array resizes.
      Overrides:
      ensureCapacity in class ObjectLongMap<K>
      Parameters:
      additionalCapacity - how many additional items this should be able to hold without resizing (probably)

    • getAndIncrement

      public long getAndIncrement(K key, long defaultValue, long increment)
      Description copied from class: ObjectLongMap
      Returns the key's current value and increments the stored value. If the key is not in the map, defaultValue + increment is put into the map and defaultValue is returned.
      Overrides:
      getAndIncrement in class ObjectLongMap<K>

    • alter

      public boolean alter(K before, K 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 ObjectLongOrderedMap and before has been removed; returns false if after is already present or before is not present. If you are iterating over an ObjectLongOrderedMap and have an index, you should prefer alterAt(int, Object), 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, K 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(Object, Object), this operates in constant time.
      Parameters:
      index - the index in the order of the key to change; must be non-negative and less than ObjectLongMap.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 long setAt(int index, long 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 long 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 long getAt(int index)
      Gets the long value at the given index in the insertion order. The index should be between 0 (inclusive) and ObjectLongMap.size() (exclusive).
      Parameters:
      index - an index in the insertion order, between 0 (inclusive) and ObjectLongMap.size() (exclusive)
      Returns:
      the value at the given index

    • keyAt

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

    • clear

      public void clear(int maximumCapacity)
      Description copied from class: ObjectLongMap
      Clears the map and reduces the size of the backing arrays to be the specified capacity / loadFactor, if they are larger.
      Overrides:
      clear in class ObjectLongMap<K>

    • clear

      public void clear()
      Overrides:
      clear in class ObjectLongMap<K>

    • order

      public ObjectList<K> 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<K>
      Returns:
      the ObjectList of keys, in iteration order (usually insertion-order), that this uses

    • sort

      public void sort()
      Sorts this ObjectLongOrderedMap in-place by the keys' natural ordering; K must implement Comparable.

    • sort

      public void sort(Comparator<? super K> comp)
      Sorts this ObjectLongOrderedMap 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, which requires K to Comparable.
      Specified by:
      sort in interface Ordered<K>
      Parameters:
      comp - a Comparator that can compare two K keys, or null to use the keys' natural ordering

    • sortByValue

      public void sortByValue(LongComparator comp)
      Sorts this ObjectLongOrderedMap in-place by the given LongComparator used on the values. comp must not be null, and must be able to compare long values. You can use LongComparators.NATURAL_COMPARATOR to do what sort() does (just sorting values in this case instead of keys); there is also a reversed comparator available, LongComparators.OPPOSITE_COMPARATOR.
      Parameters:
      comp - a non-null LongComparator

    • keySet

      public ObjectLongMap.Keys<K> 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(ObjectLongOrderedMap) constructor for nested or multithreaded iteration.

      Overrides:
      keySet in class ObjectLongMap<K>
      Returns:
      a set view of the keys contained in this map

    • values

      public ObjectLongMap.Values<K> 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(ObjectLongOrderedMap) constructor for nested or multithreaded iteration.

      Overrides:
      values in class ObjectLongMap<K>
      Returns:
      a PrimitiveCollection.OfLong of the long values

    • entrySet

      public ObjectLongMap.Entries<K> 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(ObjectLongOrderedMap) constructor for nested or multithreaded iteration.

      Overrides:
      entrySet in class ObjectLongMap<K>
      Returns:
      a Set of Map.Entry key-value pairs

    • iterator

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

    • appendTo

      public StringBuilder appendTo(StringBuilder sb, String entrySeparator, String keyValueSeparator, boolean braces, Appender<K> keyAppender, LongAppender valueAppender)
      Appends to a StringBuilder from the contents of this ObjectLongOrderedMap, but uses the given Appender and LongAppender to convert each key and each value to a customizable representation and append them to a StringBuilder. These functions are often method references to methods in Base, such as Base.appendUnsigned(CharSequence, long). To use the default String representation, you can use Appender::append as an appender. To write numeric values so that they can be read back as Java source code, use LongAppender.READABLE for the valueAppender.
      Overrides:
      appendTo in class ObjectLongMap<K>
      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 a K, and returns the modified StringBuilder
      valueAppender - a function that takes a StringBuilder and a long, and returns the modified StringBuilder
      Returns:
      sb, with the appended keys and values of this map

    • with

      public static <K> ObjectLongOrderedMap<K> with()
      Constructs an empty map given the key 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:
      K - the type of keys
      Returns:
      a new map containing nothing

    • with

      public static <K> ObjectLongOrderedMap<K> with(K key0, Number value0)
      Constructs a single-entry map given one key and one value. This is mostly useful as an optimization for with(Object, Number, Object...) when there's no "rest" of the keys or values. Like the more-argument with(), this will convert its Number value to a primitive long, regardless of which Number type was used.
      Type Parameters:
      K - the type of key0
      Parameters:
      key0 - the first and only key
      value0 - the first and only value; will be converted to primitive long
      Returns:
      a new map containing just the entry mapping key0 to value0

    • with

      public static <K> ObjectLongOrderedMap<K> with(K key0, Number value0, K key1, Number value1)
      Constructs a map given alternating keys and values. This is mostly useful as an optimization for with(Object, Number, Object...) when there's no "rest" of the keys or values. Like the more-argument with(), this will convert its Number values to primitive longs, regardless of which Number type was used.
      Type Parameters:
      K - the type of keys
      Parameters:
      key0 - a K key
      value0 - a Number for a value; will be converted to primitive long
      key1 - a K key
      value1 - a Number for a value; will be converted to primitive long
      Returns:
      a new map containing the given key-value pairs

    • with

      public static <K> ObjectLongOrderedMap<K> with(K key0, Number value0, K key1, Number value1, K key2, Number value2)
      Constructs a map given alternating keys and values. This is mostly useful as an optimization for with(Object, Number, Object...) when there's no "rest" of the keys or values. Like the more-argument with(), this will convert its Number values to primitive longs, regardless of which Number type was used.
      Type Parameters:
      K - the type of keys
      Parameters:
      key0 - a K key
      value0 - a Number for a value; will be converted to primitive long
      key1 - a K key
      value1 - a Number for a value; will be converted to primitive long
      key2 - a K key
      value2 - a Number for a value; will be converted to primitive long
      Returns:
      a new map containing the given key-value pairs

    • with

      public static <K> ObjectLongOrderedMap<K> with(K key0, Number value0, K key1, Number value1, K key2, Number value2, K key3, Number value3)
      Constructs a map given alternating keys and values. This is mostly useful as an optimization for with(Object, Number, Object...) when there's no "rest" of the keys or values. Like the more-argument with(), this will convert its Number values to primitive longs, regardless of which Number type was used.
      Type Parameters:
      K - the type of keys
      Parameters:
      key0 - a K key
      value0 - a Number for a value; will be converted to primitive long
      key1 - a K key
      value1 - a Number for a value; will be converted to primitive long
      key2 - a K key
      value2 - a Number for a value; will be converted to primitive long
      key3 - a K key
      value3 - a Number for a value; will be converted to primitive long
      Returns:
      a new map containing the given key-value pairs

    • with

      public static <K> ObjectLongOrderedMap<K> with(K key0, Number 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 ObjectLongOrderedMap(Object[], long[]), which takes all keys and then all values. This needs all keys to have the same type, because it gets a generic type from the first key parameter. All values must be some type of boxed Number, such as Integer or Double, and will be converted to primitive longs. Any keys that don't have K as their type or values that aren't Numbers have that entry skipped.
      Type Parameters:
      K - the type of keys, inferred from key0
      Parameters:
      key0 - the first key; will be used to determine the type of all keys
      value0 - the first value; a Number that will be converted to primitive long
      rest - an array or varargs of alternating K, Number, K, Number... elements
      Returns:
      a new map containing the given keys and values

    • withPrimitive

      public static <K> ObjectLongOrderedMap<K> withPrimitive()
      Constructs an empty map given the key 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:
      K - the type of keys
      Returns:
      a new map containing nothing

    • withPrimitive

      public static <K> ObjectLongOrderedMap<K> withPrimitive(K key0, long value0)
      Constructs a single-entry map given one key and one value. This is mostly useful as an optimization for with(Object, Number, Object...) when there's no "rest" of the keys or values. Unlike with(), this takes unboxed long as its value type, and will not box it.
      Type Parameters:
      K - the type of key0
      Parameters:
      key0 - a K for a key
      value0 - a long for a value
      Returns:
      a new map containing just the entry mapping key0 to value0

    • withPrimitive

      public static <K> ObjectLongOrderedMap<K> withPrimitive(K key0, long value0, K key1, long value1)
      Constructs a map given alternating keys and values. This is mostly useful as an optimization for with(Object, Number, Object...) when there's no "rest" of the keys or values. Unlike with(), this takes unboxed long as its value type, and will not box it.
      Type Parameters:
      K - the type of keys
      Parameters:
      key0 - a K key
      value0 - a long for a value
      key1 - a K key
      value1 - a long for a value
      Returns:
      a new map containing the given key-value pairs

    • withPrimitive

      public static <K> ObjectLongOrderedMap<K> withPrimitive(K key0, long value0, K key1, long value1, K key2, long value2)
      Constructs a map given alternating keys and values. This is mostly useful as an optimization for with(Object, Number, Object...) when there's no "rest" of the keys or values. Unlike with(), this takes unboxed long as its value type, and will not box it.
      Type Parameters:
      K - the type of keys
      Parameters:
      key0 - a K key
      value0 - a long for a value
      key1 - a K key
      value1 - a long for a value
      key2 - a K key
      value2 - a long for a value
      Returns:
      a new map containing the given key-value pairs

    • withPrimitive

      public static <K> ObjectLongOrderedMap<K> withPrimitive(K key0, long value0, K key1, long value1, K key2, long value2, K key3, long value3)
      Constructs a map given alternating keys and values. This is mostly useful as an optimization for with(Object, Number, Object...) when there's no "rest" of the keys or values. Unlike with(), this takes unboxed long as its value type, and will not box it.
      Type Parameters:
      K - the type of keys
      Parameters:
      key0 - a K key
      value0 - a long for a value
      key1 - a K key
      value1 - a long for a value
      key2 - a K key
      value2 - a long for a value
      key3 - a K key
      value3 - a long for a value
      Returns:
      a new map containing the given key-value pairs

    • parse

      public static <K> ObjectLongOrderedMap<K> parse(String str, String entrySeparator, String keyValueSeparator, PartialParser<K> keyParser)
      Creates a new map by parsing all of str with the given PartialParser for keys, 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).
      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 a K key from a section of str

    • parse

      public static <K> ObjectLongOrderedMap<K> parse(String str, String entrySeparator, String keyValueSeparator, PartialParser<K> keyParser, 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, 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).
      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 a K key from a section of str
      brackets - if true, the first and last chars in str will be ignored

    • parse

      public static <K> ObjectLongOrderedMap<K> parse(String str, String entrySeparator, String keyValueSeparator, PartialParser<K> keyParser, int offset, int length)
      Creates a new map by parsing the given subrange of str with the given PartialParser for keys, 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).
      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 a K key 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