Package com.github.tommyettinger.ds

Class ObjectObjectMap<K,V>

java.lang.Object
com.github.tommyettinger.ds.ObjectObjectMap<K,V>
All Implemented Interfaces:
Iterable<Map.Entry<K,V>>, Map<K,V>
Direct Known Subclasses:
CaseInsensitiveMap, FilteredIterableMap, FilteredStringMap, IdentityObjectMap, ObjectObjectOrderedMap
public class ObjectObjectMap<K,V> extends Object implements Map<K,V>, Iterable<Map.Entry<K,V>>
An unordered map where the keys and values are objects. Null keys are not allowed. No allocation is done except when growing the table size.

This class performs fast contains and remove (typically O(1), worst case O(n) but that is rare in practice). 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. 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 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

    • size

      protected int size

    • keyTable

      protected K[] keyTable

    • valueTable

      protected V[] valueTable

    • loadFactor

      protected float loadFactor
      Between 0f (exclusive) and 1f (inclusive, if you're careful), this determines how full the backing tables can get before this increases their size. Larger values use less memory but make the data structure slower.

    • threshold

      protected int threshold
      Precalculated value of (int)(keyTable.length * loadFactor), used to determine when to resize.

    • shift

      protected int shift
      Used by place(Object) typically, this should always equal BitConversion.countLeadingZeros(mask). For a table that could hold 2 items (with 1 bit indices), this would be 64 - 1 == 63. For a table that could hold 256 items (with 8 bit indices), this would be 64 - 8 == 56.

    • mask

      protected int mask
      A bitmask used to confine hashcodes to the size of the table. Must be all 1-bits in its low positions, ie a power of two minus 1. If place(Object) is overridden, this can be used instead of shift to isolate usable bits of a hash.

    • hashMultiplier

      protected int hashMultiplier
      Used by place(Object) to mix hashCode() results. Changes on every call to resize(int) by default. This should always change when shift changes, meaning, when the backing table resizes. This only needs to be serialized if the full key and value tables are serialized, or if the iteration order should be the same before and after serialization. Iteration order is better handled by using ObjectObjectOrderedMap.

    • entries1

      protected transient ObjectObjectMap.Entries<K,V> entries1

    • entries2

      protected transient ObjectObjectMap.Entries<K,V> entries2

    • values1

      protected transient ObjectObjectMap.Values<K,V> values1

    • values2

      protected transient ObjectObjectMap.Values<K,V> values2

    • keys1

      protected transient ObjectObjectMap.Keys<K,V> keys1

    • keys2

      protected transient ObjectObjectMap.Keys<K,V> keys2

    • defaultValue

      public V defaultValue
      Returned by get(Object) when no value exists for the given key, as well as some other methods to indicate that no value in the Map could be returned.

  • Constructor Details

    • ObjectObjectMap

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

    • ObjectObjectMap

      public ObjectObjectMap(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.

    • ObjectObjectMap

      public ObjectObjectMap(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

    • ObjectObjectMap

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

    • ObjectObjectMap

      public ObjectObjectMap(Map<? extends K,? extends V> map)
      Creates a new map identical to the specified map.
      Parameters:
      map - a Map to copy; ObjectObjectMap or its subclasses will be faster

    • ObjectObjectMap

      public ObjectObjectMap(K[] keys, V[] 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

    • ObjectObjectMap

      public ObjectObjectMap(Collection<? extends K> keys, Collection<? extends V> 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 Collection of values

  • Method Details

    • place

      protected int place(Object item)
      Returns an index >= 0 and <= mask for the specified item, mixed.
      Parameters:
      item - a non-null Object; its hashCode() method should be used by most implementations
      Returns:
      an index between 0 and mask (both inclusive)

    • equate

      protected boolean equate(Object left, Object right)
      Compares the objects left and right, which are usually keys, for equality, returning true if they are considered equal. This is used by the rest of this class to determine whether two keys are considered equal. Normally, this returns left.equals(right), but subclasses can override it to use reference equality, fuzzy equality, deep array equality, or any other custom definition of equality. Usually, place(Object) is also overridden if this method is.
      Parameters:
      left - must be non-null; typically a key being compared, but not necessarily
      right - may be null; typically a key being compared, but can often be null for an empty key slot, or some other type
      Returns:
      true if left and right are considered equal for the purposes of this class

    • locateKey

      protected int locateKey(Object key)
      Returns the index of the key if already present, else ~index for the next empty index. This calls equate(Object, Object) to determine if two keys are equivalent.
      Parameters:
      key - a non-null K key
      Returns:
      a negative index if the key was not found, or the non-negative index of the existing key if found

    • put

      public V put(K key, V value)
      Returns the old value associated with the specified key, or this map's defaultValue if there was no prior value.
      Specified by:
      put in interface Map<K,V>

    • putOrDefault

      public V putOrDefault(K key, V value, V defaultValue)

    • putAll

      public void putAll(Map<? extends K,? extends V> m)
      Copies all the mappings from the specified map to this map (optional operation). The effect of this call is equivalent to that of calling put(k, v) on this map once for each mapping from key k to value v in the specified map. The behavior of this operation is undefined if the specified map is modified while the operation is in progress.
      Note that putAll(ObjectObjectMap) is more specific and can be more efficient by using the internal details of this class.
      Specified by:
      putAll in interface Map<K,V>
      Parameters:
      m - mappings to be stored in this map
      Throws:
      UnsupportedOperationException - if the putAll operation is not supported by this map
      ClassCastException - if the class of a key or value in the specified map prevents it from being stored in this map
      NullPointerException - if the specified map is null, or if this map does not permit null keys or values, and the specified map contains null keys or values
      IllegalArgumentException - if some property of a key or value in the specified map prevents it from being stored in this map

    • putAll

      public void putAll(ObjectObjectMap<? extends K,? 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.
      Parameters:
      map - a map with compatible key and value types; will not be modified

    • putAll

      public void putAll(Collection<? extends K> keys, Collection<? extends V> values)
      Given two side-by-side collections, one of keys, one of values, this inserts each pair of key and value into this map with put().
      Parameters:
      keys - a Collection of keys
      values - a Collection of values

    • putAll

      public void putAll(K[] keys, V[] values)
      Given two side-by-side arrays, one of keys, one of values, this inserts each pair of key and value into this map with put().
      Parameters:
      keys - an array of keys
      values - an array of values

    • putAll

      public void putAll(K[] keys, V[] values, int length)
      Given two side-by-side arrays, one of keys, one of values, this inserts each pair of key and value into this map with put().
      Parameters:
      keys - an array of keys
      values - an array of values
      length - how many items from keys and values to insert, at-most

    • putAll

      public void putAll(K[] keys, int keyOffset, V[] values, int valueOffset, int length)
      Given two side-by-side arrays, one of keys, one of values, this inserts each pair of key and value into this map with put().
      Parameters:
      keys - an array of keys
      keyOffset - the first index in keys to insert
      values - an array of values
      valueOffset - the first index in values to insert
      length - how many items from keys and values to insert, at-most

    • putResize

      protected void putResize(K key, V value)
      Skips checks for existing keys, doesn't increment size.

    • get

      public V get(Object key)
      Returns the value for the specified key, or defaultValue if the key is not in the map. Note that defaultValue is often null, which is also a valid value that can be assigned to a legitimate key. Checking that the result of this method is null does not guarantee that the key is not present.
      Specified by:
      get in interface Map<K,V>
      Parameters:
      key - a non-null Object that should almost always be a K (or an instance of a subclass of K)

    • getOrDefault

      public V getOrDefault(Object key, V defaultValue)
      Returns the value for the specified key, or the given default value if the key is not in the map.
      Specified by:
      getOrDefault in interface Map<K,V>

    • remove

      public V remove(Object key)
      Specified by:
      remove in interface Map<K,V>

    • notEmpty

      public boolean notEmpty()
      Returns true if the map has one or more items.

    • size

      public int size()
      Returns the number of key-value mappings in this map. If the map contains more than Integer.MAX_VALUE elements, returns Integer.MAX_VALUE.
      Specified by:
      size in interface Map<K,V>
      Returns:
      the number of key-value mappings in this map

    • isEmpty

      public boolean isEmpty()
      Returns true if the map is empty.
      Specified by:
      isEmpty in interface Map<K,V>

    • getDefaultValue

      public V getDefaultValue()
      Gets the default value, a V which is returned by get(Object) if the key is not found. If not changed, the default value is null.
      Returns:
      the current default value

    • setDefaultValue

      public void setDefaultValue(V defaultValue)
      Sets the default value, a V which is returned by get(Object) if the key is not found. If not changed, the default value is null. Note that getOrDefault(Object, Object) is also available, which allows specifying a "not-found" value per-call.
      Parameters:
      defaultValue - may be any V object or null; should usually be one that doesn't occur as a typical value

    • shrink

      public void shrink(int maximumCapacity)
      Reduces the size of the backing arrays to be the specified capacity / loadFactor, or less. If the capacity is already less, nothing is done. If the map contains more items than the specified capacity, the next highest power of two capacity is used instead.

    • clear

      public void clear(int maximumCapacity)
      Clears the map and reduces the size of the backing arrays to be the specified capacity / loadFactor, if they are larger.

    • clear

      public void clear()
      Specified by:
      clear in interface Map<K,V>

    • containsValue

      public boolean containsValue(Object value, boolean identity)
      Returns true if the specified value is in the map. Note this traverses the entire map and compares every value, which may be an expensive operation.
      Parameters:
      identity - If true, uses == to compare the specified value with values in the map. If false, uses equals(Object).

    • containsKey

      public boolean containsKey(Object key)
      Specified by:
      containsKey in interface Map<K,V>

    • containsValue

      public boolean containsValue(Object value)
      Returns true if this map maps one or more keys to the specified value. More formally, returns true if and only if this map contains at least one mapping to a value v such that (value==null ? v==null : value.equals(v)). This operation will probably require time linear in the map size for most implementations of the Map interface.
      Specified by:
      containsValue in interface Map<K,V>
      Parameters:
      value - value whose presence in this map is to be tested
      Returns:
      true if this map maps one or more keys to the specified value
      Throws:
      ClassCastException - if the value is of an inappropriate type for this map (optional)
      NullPointerException - if the specified value is null and this map does not permit null values (optional)

    • findKey

      public K findKey(Object value)
      Returns a key that maps to the specified value, or null if value is not in the map. Note, this traverses the entire map and compares every value using Object.equals(Object), which may be an expensive operation. This is the same as calling findKey(value, false).
      Parameters:
      value - the value to search for
      Returns:
      a key that maps to value, if present, or null if value cannot be found

    • findKey

      public K findKey(Object value, boolean identity)
      Returns the key for the specified value, or null if it is not in the map. Note this traverses the entire map and compares every value, which may be an expensive operation.
      Parameters:
      value - the value to search for
      identity - If true, uses == to compare the specified value with values in the map. If false, uses equals(Object).
      Returns:
      a key that maps to value, if present, or null if value cannot be found

    • 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.
      Parameters:
      additionalCapacity - how many additional items this should be able to hold without resizing (probably)

    • resize

      protected void resize(int newSize)

    • getHashMultiplier

      public int getHashMultiplier()
      Gets the current hashMultiplier, used in place(Object) to mix hash codes. If setHashMultiplier(int) is never called, the hashMultiplier will always be drawn from Utilities.GOOD_MULTIPLIERS, with the index equal to 64 - shift.
      Returns:
      the current hashMultiplier

    • setHashMultiplier

      public void setHashMultiplier(int hashMultiplier)
      Sets the hashMultiplier to the given int, which will be made odd if even and always negative (by OR-ing with 0x80000001). This can be any negative, odd int, but should almost always be drawn from Utilities.GOOD_MULTIPLIERS or something like it.
      Parameters:
      hashMultiplier - any int; will be made odd if even.

    • getTableSize

      public int getTableSize()
      Gets the length of the internal array used to store all keys, as well as empty space awaiting more items to be entered. This length is equal to the length of the array used to store all values, and empty space for values, here. This is also called the capacity.
      Returns:
      the length of the internal array that holds all keys

    • getLoadFactor

      public float getLoadFactor()

    • setLoadFactor

      public void setLoadFactor(float loadFactor)

    • hashCode

      public int hashCode()
      Specified by:
      hashCode in interface Map<K,V>
      Overrides:
      hashCode in class Object

    • equals

      public boolean equals(Object obj)
      Specified by:
      equals in interface Map<K,V>
      Overrides:
      equals in class Object

    • equalsIdentity

      public boolean equalsIdentity(Object obj)
      Uses == for comparison of each value.

    • toString

      public String toString()
      Overrides:
      toString in class Object

    • toString

      public String toString(String entrySeparator)
      Delegates to toString(String, boolean) with the given entrySeparator and without braces. This is different from toString(), which includes braces by default.
      Parameters:
      entrySeparator - how to separate entries, such as ", "
      Returns:
      a new String representing this map

    • toString

      public String toString(String entrySeparator, boolean braces)

    • toString

      public String toString(String entrySeparator, String keyValueSeparator, boolean braces, Appender<K> keyAppender, Appender<V> valueAppender)
      Makes a String from the contents of this ObjectObjectMap, but uses the given Appender and Appender to convert each key and each value to a customizable representation and append them to a temporary StringBuilder. To use the default String representation, you can use Appender::append as an appender.
      Parameters:
      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 V, and returns the modified StringBuilder
      Returns:
      a new String representing this map

    • appendTo

      public StringBuilder appendTo(StringBuilder sb, String entrySeparator, boolean braces)

    • appendTo

      public StringBuilder appendTo(StringBuilder sb, String entrySeparator, String keyValueSeparator, boolean braces, Appender<K> keyAppender, Appender<V> valueAppender)
      Appends to a StringBuilder from the contents of this ObjectObjectMap, 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 String representation, you can use Appender::append as an appender.
      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 V, and returns the modified StringBuilder
      Returns:
      sb, with the appended keys and values of this map

    • 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. This indiscriminately removes items from the backing array until the requested newSize is reached, or until the full backing array has had its elements removed.
      This tries to remove from the end of the iteration order, but because the iteration order is not guaranteed by an unordered map, this can remove essentially any item(s) from the map if it is larger than newSize.
      Parameters:
      newSize - the target size to try to reach by removing items, if smaller than the current size

    • replace

      public V replace(K key, V value)
      Specified by:
      replace in interface Map<K,V>

    • combine

      public V combine(K key, V value, com.github.tommyettinger.function.ObjObjToObjBiFunction<? super V,? super V,? extends V> remappingFunction)
      Just like Map's merge() default method, but this doesn't use Java 8 APIs (so it should work on RoboVM), and this won't remove entries if the remappingFunction returns null (in that case, it will call put(key, null)). This also uses a functional interface from Funderby instead of the JDK, for RoboVM support.
      Parameters:
      key - key with which the resulting value is to be associated
      value - the value to be merged with the existing value associated with the key or, if no existing value is associated with the key, to be associated with the key
      remappingFunction - given a V from this and the V value, this should return what V to use
      Returns:
      the value now associated with key

    • combine

      public void combine(Map<? extends K,? extends V> other, com.github.tommyettinger.function.ObjObjToObjBiFunction<? super V,? super V,? extends V> remappingFunction)
      Simply calls combine(Object, Object, ObjObjToObjBiFunction) on this map using every key-value pair in other. If other isn't empty, calling this will probably modify this map, though this depends on the remappingFunction.
      Parameters:
      other - a non-null Map (or subclass) with compatible key and value types
      remappingFunction - given a V value from this and a value from other, this should return what V to use

    • iterator

      public ObjectObjectMap.MapIterator<K,V,Map.Entry<K,V>> iterator()
      Reuses the iterator of the reused ObjectObjectMap.Entries produced by entrySet(); does not permit nested iteration. Iterate over Entries(ObjectObjectMap) if you need nested or multithreaded iteration. You can remove an Entry from this ObjectObjectMap using this Iterator.
      Specified by:
      iterator in interface Iterable<K>
      Returns:
      an Iterator over Map.Entry key-value pairs; remove is supported.

    • keySet

      public ObjectObjectMap.Keys<K,V> 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 ObjectObjectMap.Keys constructor for nested or multithreaded iteration.

      Specified by:
      keySet in interface Map<K,V>
      Returns:
      a set view of the keys contained in this map

    • values

      public ObjectObjectMap.Values<K,V> values()
      Returns a Collection of the values in the map. Remove is supported. Note that the same Collection instance is returned each time this method is called. Use the ObjectObjectMap.Values constructor for nested or multithreaded iteration.
      Specified by:
      values in interface Map<K,V>
      Returns:
      a Collection of V values

    • entrySet

      public ObjectObjectMap.Entries<K,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 ObjectObjectMap.Entries constructor for nested or multithreaded iteration.
      Specified by:
      entrySet in interface Map<K,V>
      Returns:
      a Set of Map.Entry key-value pairs

    • with

      public static <K, V> ObjectObjectMap<K,V> with()
      Constructs an empty map given the types as generic type arguments. 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
      V - the type of values
      Returns:
      a new map containing nothing

    • with

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

    • with

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

    • with

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

    • with

      public static <K, V> ObjectObjectMap<K,V> with(K 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 ObjectObjectMap(Object[], 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 K as their type or values that don't have V as their type have that entry skipped.
      Type Parameters:
      K - the type of keys, inferred from key0
      V - the type of values, inferred from value0
      Parameters:
      key0 - the first key; will be used to determine the type of all keys
      value0 - the first value; will be used to determine the type of all values
      rest - a varargs or non-null array of alternating K, V, K, V... elements
      Returns:
      a new map containing the given keys and values

    • putPairs

      public void putPairs(Object... pairs)
      Attempts to put alternating key-value pairs into this map, drawing a key, then a value from pairs, then another key, another value, and so on until another pair cannot be drawn. Any keys that don't have K as their type or values that don't have V as their type have that entry skipped.
      If any item in pairs cannot be cast to the appropriate K or V type for its position in the arguments, that pair is ignored and neither that key nor value is put into the map. If any key is null, that pair is ignored, as well. If pairs is an Object array that is null, the entire call to putPairs() is ignored. If the length of pairs is odd, the last item (which will be unpaired) is ignored.
      Parameters:
      pairs - an array or varargs of alternating K, V, K, V... elements

    • putLegible

      public void putLegible(String str, PartialParser<K> keyParser, PartialParser<V> valueParser)
      Adds items to this map drawn from the result of toString(String) or appendTo(StringBuilder, String, boolean). Every key-value pair should be separated by ", ", and every key should be followed by "=" before the value (which toString() does). A PartialParser will be used to parse keys from sections of str, and a different PartialParser to parse values. Any brackets inside the given range of characters will ruin the parsing, so increase offset by 1 and reduce length by 2 if the original String had brackets added to it.
      Parameters:
      str - a String containing parseable text
      keyParser - a PartialParser that returns a K key from a section of str
      valueParser - a PartialParser that returns a V value from a section of str

    • putLegible

      public void putLegible(String str, String entrySeparator, PartialParser<K> keyParser, PartialParser<V> valueParser)
      Adds items to this map drawn from the result of toString(String) or appendTo(StringBuilder, String, boolean). Every key-value pair should be separated by entrySeparator, and every key should be followed by "=" before the value (which toString(String) does). A PartialParser will be used to parse keys from sections of str, and a different PartialParser to parse values. Any brackets inside the given range of characters will ruin the parsing, so increase offset by 1 and reduce length by 2 if the original String had brackets added to it.
      Parameters:
      str - a String containing parseable text
      entrySeparator - the String separating every key-value pair
      keyParser - a PartialParser that returns a K key from a section of str
      valueParser - a PartialParser that returns a V value from a section of str

    • putLegible

      public void putLegible(String str, String entrySeparator, String keyValueSeparator, PartialParser<K> keyParser, PartialParser<V> valueParser)
      Adds items to this map drawn from the result of toString(String) or appendTo(StringBuilder, String, String, boolean, Appender, Appender). A PartialParser will be used to parse keys from sections of str, and a different PartialParser to parse values. Any brackets inside the given range of characters will ruin the parsing, so increase offset by 1 and reduce length by 2 if the original String had brackets added to it.
      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
      valueParser - a PartialParser that returns a V value from a section of str

    • putLegible

      public void putLegible(String str, String entrySeparator, String keyValueSeparator, PartialParser<K> keyParser, PartialParser<V> valueParser, int offset, int length)
      Puts key-value pairs into this map drawn from the result of toString(String) or appendTo(StringBuilder, String, String, boolean, Appender, Appender). A PartialParser will be used to parse keys from sections of str, and a different PartialParser to parse values. Any brackets inside the given range of characters will ruin the parsing, so increase offset by 1 and reduce length by 2 if the original String had brackets added to it.
      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
      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

    • parse

      public static <K, V> ObjectObjectMap<K,V> parse(String str, String entrySeparator, String keyValueSeparator, PartialParser<K> 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).
      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
      valueParser - a PartialParser that returns a V value from a section of str

    • parse

      public static <K, V> ObjectObjectMap<K,V> parse(String str, String entrySeparator, String keyValueSeparator, PartialParser<K> 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).
      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
      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 <K, V> ObjectObjectMap<K,V> parse(String str, String entrySeparator, String keyValueSeparator, PartialParser<K> 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).
      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
      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