Package com.github.tommyettinger.ds

Class HolderOrderedSet<T,K>

java.lang.Object
com.github.tommyettinger.ds.HolderSet<T,K>
com.github.tommyettinger.ds.HolderOrderedSet<T,K>
All Implemented Interfaces:
Arrangeable, EnhancedCollection<T>, Ordered<T>, Iterable<T>, Collection<T>, Set<T>
public class HolderOrderedSet<T,K> extends HolderSet<T,K> implements Ordered<T>
A HolderSet that also stores items in an ObjectList using the insertion order. This acts like HolderSet instead of like ObjectSet, with the constructors typically taking an extractor function, HolderSet.contains(Object) and remove(Object) accepting a K key instead of a T item, and HolderSet.get(Object) used to get a T item from a K key. Neither null items nor null keys are allowed. No allocation is done except when growing the table size.

Iteration is ordered over items and faster than an unordered set. Items 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 HolderOrderedSet and ObjectObjectOrderedMap.

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

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, just more slowly.

  • Field Details

  • Constructor Details

    • HolderOrderedSet

      public HolderOrderedSet(OrderType type)
      Creates a new set with an initial capacity of Utilities.getDefaultTableCapacity() and a load factor of Utilities.getDefaultLoadFactor(). This does not set the extractor, so the HolderSet will not be usable until HolderSet.setExtractor(ObjToObjFunction) is called with a valid ObjToObjFunction that gets K keys from T items.
      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

    • HolderOrderedSet

      public HolderOrderedSet(com.github.tommyettinger.function.ObjToObjFunction<T,K> extractor, OrderType type)
      Creates a new set with an initial capacity of Utilities.getDefaultTableCapacity() and a load factor of Utilities.getDefaultLoadFactor().
      Parameters:
      extractor - a function that will be used to extract K keys from the T items put into this
      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

    • HolderOrderedSet

      public HolderOrderedSet(com.github.tommyettinger.function.ObjToObjFunction<T,K> extractor, int initialCapacity, OrderType type)
      Creates a new set with a load factor of Utilities.getDefaultLoadFactor().
      Parameters:
      extractor - a function that will be used to extract K keys from the T items put into this
      initialCapacity - If not a power of two, it is increased to the next nearest power of two.
      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

    • HolderOrderedSet

      public HolderOrderedSet(com.github.tommyettinger.function.ObjToObjFunction<T,K> extractor, int initialCapacity, float loadFactor, OrderType type)
      Creates a new set with the specified initial capacity and load factor. This set will hold initialCapacity items before growing the backing table.
      Parameters:
      extractor - a function that will be used to extract K keys from the T items put into this
      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
      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

    • HolderOrderedSet

      public HolderOrderedSet(com.github.tommyettinger.function.ObjToObjFunction<T,K> extractor, Iterator<? extends T> coll, OrderType type)
      Creates a new instance containing the items in the specified iterator.
      Parameters:
      coll - an iterator that will have its remaining contents added to this
      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

    • HolderOrderedSet

      public HolderOrderedSet(HolderOrderedSet<T,K> set, OrderType type)
      Creates a new set identical to the specified set. This doesn't copy the extractor; instead it references the same ObjToObjFunction from the argument. This can have issues if the extractor causes side effects or is stateful.
      Parameters:
      set - another HolderOrderedSet which will have its contents 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

    • HolderOrderedSet

      public HolderOrderedSet(com.github.tommyettinger.function.ObjToObjFunction<T,K> extractor, Collection<? extends T> coll, OrderType type)
      Creates a new set that contains all distinct elements in coll, using extractor to get the keys that determine distinctness.
      Parameters:
      extractor - a function that will be used to extract K keys from the T items in coll
      coll - a Collection of T items; depending on extractor, some different T items may not be added because their K key is equal
      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

    • HolderOrderedSet

      public HolderOrderedSet(com.github.tommyettinger.function.ObjToObjFunction<T,K> extractor, T[] items, OrderType type)
      Creates a new set that contains all distinct elements in items, using extractor to get the keys that determine distinctness.
      Parameters:
      extractor - a function that will be used to extract K keys from the T items in coll
      items - an array of T items; depending on extractor, some different T items may not be added because their K key is equal
      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

    • HolderOrderedSet

      public HolderOrderedSet(com.github.tommyettinger.function.ObjToObjFunction<T,K> extractor, Ordered<T> other, int offset, int count, OrderType type)
      Creates a new set by copying count items from the given Ordered, starting at offset in that Ordered, into this, using extractor to get the keys that determine distinctness.
      Parameters:
      extractor - a function that will be used to extract K keys from the T items in coll
      other - another Ordered 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
      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

    • HolderOrderedSet

      public HolderOrderedSet()
      Creates a new set with an initial capacity of Utilities.getDefaultTableCapacity() and a load factor of Utilities.getDefaultLoadFactor(). This does not set the extractor, so the HolderSet will not be usable until HolderSet.setExtractor(ObjToObjFunction) is called with a valid ObjToObjFunction that gets K keys from T items.

    • HolderOrderedSet

      public HolderOrderedSet(com.github.tommyettinger.function.ObjToObjFunction<T,K> extractor)
      Creates a new set with an initial capacity of Utilities.getDefaultTableCapacity() and a load factor of Utilities.getDefaultLoadFactor().
      Parameters:
      extractor - a function that will be used to extract K keys from the T items put into this

    • HolderOrderedSet

      public HolderOrderedSet(com.github.tommyettinger.function.ObjToObjFunction<T,K> extractor, int initialCapacity)
      Creates a new set with a load factor of Utilities.getDefaultLoadFactor().
      Parameters:
      extractor - a function that will be used to extract K keys from the T items put into this
      initialCapacity - If not a power of two, it is increased to the next nearest power of two.

    • HolderOrderedSet

      public HolderOrderedSet(com.github.tommyettinger.function.ObjToObjFunction<T,K> extractor, int initialCapacity, float loadFactor)
      Creates a new set with the specified initial capacity and load factor. This set will hold initialCapacity items before growing the backing table.
      Parameters:
      extractor - a function that will be used to extract K keys from the T items put into this
      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

    • HolderOrderedSet

      public HolderOrderedSet(com.github.tommyettinger.function.ObjToObjFunction<T,K> extractor, Iterator<? extends T> coll)
      Creates a new instance containing the items in the specified iterator.
      Parameters:
      coll - an iterator that will have its remaining contents added to this

    • HolderOrderedSet

      public HolderOrderedSet(HolderOrderedSet<T,K> set)
      Creates a new set identical to the specified set. This doesn't copy the extractor; instead it references the same ObjToObjFunction from the argument. This can have issues if the extractor causes side effects or is stateful.

    • HolderOrderedSet

      public HolderOrderedSet(com.github.tommyettinger.function.ObjToObjFunction<T,K> extractor, Collection<? extends T> coll)
      Creates a new set that contains all distinct elements in coll, using extractor to get the keys that determine distinctness.
      Parameters:
      extractor - a function that will be used to extract K keys from the T items in coll
      coll - a Collection of T items; depending on extractor, some different T items may not be added because their K key is equal

    • HolderOrderedSet

      public HolderOrderedSet(com.github.tommyettinger.function.ObjToObjFunction<T,K> extractor, T[] items)
      Creates a new set that contains all distinct elements in items, using extractor to get the keys that determine distinctness.
      Parameters:
      extractor - a function that will be used to extract K keys from the T items in coll
      items - an array of T items; depending on extractor, some different T items may not be added because their K key is equal

    • HolderOrderedSet

      public HolderOrderedSet(com.github.tommyettinger.function.ObjToObjFunction<T,K> extractor, Ordered<T> other, int offset, int count)
      Creates a new set by copying count items from the given Ordered, starting at offset in that Ordered, into this, using extractor to get the keys that determine distinctness.
      Parameters:
      extractor - a function that will be used to extract K keys from the T items in coll
      other - another Ordered 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

  • Method Details

    • add

      public boolean add(T key)
      Description copied from class: HolderSet
      Returns true if the item was not already in the set. If this set already contains the item, the call leaves the set unchanged and returns false. Note that this does not take a K key, but a T item
      Specified by:
      add in interface Collection<T>
      Specified by:
      add in interface Set<T>
      Overrides:
      add in class HolderSet<T,K>

    • add

      public boolean add(int index, T key)
      Sets the key at the specified index. Returns true if the key was not already in the set. If this set already contains the key, the existing key's index is changed if needed and false is returned. Note, the order of the parameters matches the order in ObjectList and the rest of the JDK, not OrderedSet in libGDX.
      Parameters:
      index - where in the iteration order to add the given key, or to move it if already present
      key - what T item to try to add, if not already present
      Returns:
      true if the key was added for the first time, or false if the key was already present (even if moved)

    • addAll

      public boolean addAll(HolderOrderedSet<T,?> set)

    • addAll

      public boolean addAll(Ordered<T> other, int offset, int count)
      Adds up to count items, starting from offset, in the Ordered other to this set, inserting at the end of the iteration order.
      Parameters:
      other - a non-null Ordered of T
      offset - the first index in other to use
      count - how many indices in other to use
      Returns:
      true if this is modified by this call, as HolderSet.addAll(Collection) does

    • addAll

      public boolean addAll(int insertionIndex, Ordered<T> other, int offset, int count)
      Adds up to count items, starting from offset, in the Ordered 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 of T
      offset - the first index in other to use
      count - how many indices in other to use
      Returns:
      true if this is modified by this call, as HolderSet.addAll(Collection) does

    • remove

      public boolean remove(Object key)
      Takes a K key to remove from this HolderOrderedSet, not a T item.
      Specified by:
      remove in interface Collection<T>
      Specified by:
      remove in interface Set<T>
      Overrides:
      remove in class HolderSet<T,K>
      Parameters:
      key - should be a K key, not a T item
      Returns:
      true if this was modified

    • removeAt

      public T removeAt(int index)
      Removes and returns the item at the given index in this set's order.
      Parameters:
      index - the index of the item to remove
      Returns:
      the removed item

    • first

      public T first()
      Gets the first item in the order. If the set is empty, this returns null. Note that this set cannot contain null.
      Specified by:
      first in interface EnhancedCollection<T>
      Overrides:
      first in class HolderSet<T,K>
      Returns:
      the first item in this set's order

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

    • alter

      public boolean alter(T before, T after)
      Changes the item before to after without changing its position in the order. Returns true if after has been added to the ObjectOrderedSet and before has been removed; returns false if after is already present or before is not present. If you are iterating over an ObjectOrderedSet 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 - an item that must be present for this to succeed
      after - an item that must not be in this set for this to succeed
      Returns:
      true if before was removed and after was added, false otherwise

    • alterAt

      public boolean alterAt(int index, T after)
      Changes the item at the given index in the order to after, without changing the ordering of other items. If after is already present, this returns false; it will also return false if index is invalid for the size of this set. Otherwise, it returns true. Unlike alter(Object, Object), this operates in constant time.
      Parameters:
      index - the index in the order of the item to change; must be non-negative and less than HolderSet.size
      after - the item that will replace the contents at index; this item must not be present for this to succeed
      Returns:
      true if after successfully replaced the contents at index, false otherwise

    • getAt

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

    • clear

      public void clear(int maximumCapacity)
      Description copied from class: HolderSet
      Clears the set and reduces the size of the backing arrays to be the specified capacity / loadFactor, if they are larger. The reduction is done by allocating new arrays, though for large arrays this can be faster than clearing the existing array.
      Overrides:
      clear in class HolderSet<T,K>

    • clear

      public void clear()
      Description copied from class: HolderSet
      Clears the set, leaving the backing arrays at the current capacity. When the capacity is high and the population is low, iteration can be unnecessarily slow. HolderSet.clear(int) can be used to reduce the capacity.
      Specified by:
      clear in interface Collection<T>
      Specified by:
      clear in interface Set<T>
      Overrides:
      clear in class HolderSet<T,K>

    • order

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

    • sort

      public void sort()
      Sorts this ObjectOrderedSet in-place by the T items' natural ordering; T must implement Comparable.

    • sort

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

    • 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<T>
      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 set to the specified size. If the set is already smaller than the specified size, no action is taken.
      Overrides:
      truncate in class HolderSet<T,K>
      Parameters:
      newSize - the target size to try to reach by removing items, if smaller than the current size

    • iterator

      public HolderSet.HolderSetIterator<T,K> iterator()
      Iterates through items in the same order as order(). Reuses one of two iterators, and does not permit nested iteration; use HolderOrderedSetIterator(HolderOrderedSet) to nest iterators.
      Specified by:
      iterator in interface Collection<T>
      Specified by:
      iterator in interface Iterable<T>
      Specified by:
      iterator in interface Set<T>
      Overrides:
      iterator in class HolderSet<T,K>
      Returns:
      an Iterator over the T items in this, in order

    • hashCode

      public int hashCode()
      Specified by:
      hashCode in interface Collection<T>
      Specified by:
      hashCode in interface Set<T>
      Overrides:
      hashCode in class HolderSet<T,K>

    • toString

      public String toString(String itemSeparator)
      Description copied from interface: EnhancedCollection
      Delegates to EnhancedCollection.toString(String, boolean) with the given itemSeparator and without surrounding brackets.
      Specified by:
      toString in interface EnhancedCollection<T>
      Parameters:
      itemSeparator - how to separate items, such as ", "
      Returns:
      a new String representing this map

    • toString

      public String toString()
      Overrides:
      toString in class HolderSet<T,K>

    • with

      public static <T, K> HolderOrderedSet<T,K> with(com.github.tommyettinger.function.ObjToObjFunction<T,K> extractor)
      Constructs an empty set given only an extractor function. 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:
      T - the type of items; must be given explicitly
      K - the type of keys that extractor pulls from T items
      Parameters:
      extractor - a ObjToObjFunction that takes a T and gets a unique K from it; often a method reference
      Returns:
      a new set containing nothing

    • with

      public static <T, K> HolderOrderedSet<T,K> with(com.github.tommyettinger.function.ObjToObjFunction<T,K> extractor, T item)
      Creates a new HolderOrderedSet that holds only the given item, but can be resized.
      Type Parameters:
      T - the type of item, typically inferred
      K - the type of keys that extractor pulls from T items
      Parameters:
      extractor - a ObjToObjFunction that takes a T and gets a unique K from it; often a method reference
      item - one T item
      Returns:
      a new HolderOrderedSet that holds the given item

    • with

      public static <T, K> HolderOrderedSet<T,K> with(com.github.tommyettinger.function.ObjToObjFunction<T,K> extractor, T item0, T item1)
      Creates a new HolderOrderedSet that holds only the given items, but can be resized.
      Type Parameters:
      T - the type of item, typically inferred
      K - the type of keys that extractor pulls from T items
      Parameters:
      extractor - a ObjToObjFunction that takes a T and gets a unique K from it; often a method reference
      item0 - a T item
      item1 - a T item
      Returns:
      a new HolderOrderedSet that holds the given items

    • with

      public static <T, K> HolderOrderedSet<T,K> with(com.github.tommyettinger.function.ObjToObjFunction<T,K> extractor, T item0, T item1, T item2)
      Creates a new HolderOrderedSet that holds only the given items, but can be resized.
      Type Parameters:
      T - the type of item, typically inferred
      K - the type of keys that extractor pulls from T items
      Parameters:
      extractor - a ObjToObjFunction that takes a T and gets a unique K from it; often a method reference
      item0 - a T item
      item1 - a T item
      item2 - a T item
      Returns:
      a new HolderOrderedSet that holds the given items

    • with

      public static <T, K> HolderOrderedSet<T,K> with(com.github.tommyettinger.function.ObjToObjFunction<T,K> extractor, T item0, T item1, T item2, T item3)
      Creates a new HolderOrderedSet that holds only the given items, but can be resized.
      Type Parameters:
      T - the type of item, typically inferred
      K - the type of keys that extractor pulls from T items
      Parameters:
      extractor - a ObjToObjFunction that takes a T and gets a unique K from it; often a method reference
      item0 - a T item
      item1 - a T item
      item2 - a T item
      item3 - a T item
      Returns:
      a new HolderOrderedSet that holds the given items

    • with

      public static <T, K> HolderOrderedSet<T,K> with(com.github.tommyettinger.function.ObjToObjFunction<T,K> extractor, T item0, T item1, T item2, T item3, T item4)
      Creates a new HolderOrderedSet that holds only the given items, but can be resized.
      Type Parameters:
      T - the type of item, typically inferred
      K - the type of keys that extractor pulls from T items
      Parameters:
      extractor - a ObjToObjFunction that takes a T and gets a unique K from it; often a method reference
      item0 - a T item
      item1 - a T item
      item2 - a T item
      item3 - a T item
      item4 - a T item
      Returns:
      a new HolderOrderedSet that holds the given items

    • with

      public static <T, K> HolderOrderedSet<T,K> with(com.github.tommyettinger.function.ObjToObjFunction<T,K> extractor, T item0, T item1, T item2, T item3, T item4, T item5)
      Creates a new HolderOrderedSet that holds only the given items, but can be resized.
      Type Parameters:
      T - the type of item, typically inferred
      K - the type of keys that extractor pulls from T items
      Parameters:
      extractor - a ObjToObjFunction that takes a T and gets a unique K from it; often a method reference
      item0 - a T item
      item1 - a T item
      item2 - a T item
      item3 - a T item
      item4 - a T item
      item5 - a T item
      Returns:
      a new HolderOrderedSet that holds the given items

    • with

      public static <T, K> HolderOrderedSet<T,K> with(com.github.tommyettinger.function.ObjToObjFunction<T,K> extractor, T item0, T item1, T item2, T item3, T item4, T item5, T item6)
      Creates a new HolderOrderedSet that holds only the given items, but can be resized.
      Type Parameters:
      T - the type of item, typically inferred
      K - the type of keys that extractor pulls from T items
      Parameters:
      extractor - a ObjToObjFunction that takes a T and gets a unique K from it; often a method reference
      item0 - a T item
      item1 - a T item
      item2 - a T item
      item3 - a T item
      item4 - a T item
      item5 - a T item
      item6 - a T item
      Returns:
      a new HolderOrderedSet that holds the given items

    • with

      public static <T, K> HolderOrderedSet<T,K> with(com.github.tommyettinger.function.ObjToObjFunction<T,K> extractor, T item0, T item1, T item2, T item3, T item4, T item5, T item6, T item7)
      Creates a new HolderOrderedSet that holds only the given items, but can be resized.
      Type Parameters:
      T - the type of item, typically inferred
      K - the type of keys that extractor pulls from T items
      Parameters:
      extractor - a ObjToObjFunction that takes a T and gets a unique K from it; often a method reference
      item0 - a T item
      item1 - a T item
      item2 - a T item
      item3 - a T item
      item4 - a T item
      item5 - a T item
      item6 - a T item
      Returns:
      a new HolderOrderedSet that holds the given items

    • with

      @SafeVarargs public static <T, K> HolderOrderedSet<T,K> with(com.github.tommyettinger.function.ObjToObjFunction<T,K> extractor, T... varargs)
      Creates a new HolderOrderedSet that holds only the given items, but can be resized. This overload will only be used when an array is supplied and the type of the items requested is the component type of the array, or if varargs are used and there are 9 or more arguments.
      Type Parameters:
      T - the type of item, typically inferred
      K - the type of keys that extractor pulls from T items
      Parameters:
      extractor - a ObjToObjFunction that takes a T and gets a unique K from it; often a method reference
      varargs - a T varargs or T array; remember that varargs allocate
      Returns:
      a new HolderOrderedSet that holds the given items

    • parse

      public static <T, K> HolderOrderedSet<T,K> parse(com.github.tommyettinger.function.ObjToObjFunction<T,K> extractor, String str, String delimiter, PartialParser<T> parser)
      Calls parse(ObjToObjFunction, String, String, PartialParser, boolean) with brackets set to false.
      Type Parameters:
      T - the type of item, typically inferred
      K - the type of keys that extractor pulls from T items
      Parameters:
      extractor - a ObjToObjFunction that takes a T and gets a unique K from it; often a method reference
      str - a String that will be parsed in full
      delimiter - the delimiter between items in str
      parser - a PartialParser that returns a T item from a section of str
      Returns:
      a new collection parsed from str

    • parse

      public static <T, K> HolderOrderedSet<T,K> parse(com.github.tommyettinger.function.ObjToObjFunction<T,K> extractor, String str, String delimiter, PartialParser<T> parser, boolean brackets)
      Creates a new HolderOrderedSet using extractor and fills it by calling EnhancedCollection.addLegible(String, String, PartialParser, int, int) on either all of str (if brackets is false) or str without its first and last chars (if brackets is true). Each item is expected to be separated by delimiter.
      Type Parameters:
      T - the type of item, typically inferred
      K - the type of keys that extractor pulls from T items
      Parameters:
      extractor - a ObjToObjFunction that takes a T and gets a unique K from it; often a method reference
      str - a String that will be parsed in full (depending on brackets)
      delimiter - the delimiter between items in str
      parser - a PartialParser that returns a T item from a section of str
      brackets - if true, the first and last chars in str will be ignored
      Returns:
      a new collection parsed from str

    • parse

      public static <T, K> HolderOrderedSet<T,K> parse(com.github.tommyettinger.function.ObjToObjFunction<T,K> extractor, String str, String delimiter, PartialParser<T> parser, int offset, int length)
      Creates a new HolderOrderedSet using extractor and fills it by calling EnhancedCollection.addLegible(String, String, PartialParser, int, int) with the other five parameters as-is.
      Type Parameters:
      T - the type of item, typically inferred
      K - the type of keys that extractor pulls from T items
      Parameters:
      extractor - a ObjToObjFunction that takes a T and gets a unique K from it; often a method reference
      str - a String that will have the given section parsed
      delimiter - the delimiter between items in str
      parser - a PartialParser that returns a T item from a section of str
      offset - the first position to parse in str, inclusive
      length - how many chars to parse, starting from offset
      Returns:
      a new collection parsed from str