Package sprouts.impl

Class TupleImpl<T extends @Nullable Object>

java.lang.Object
sprouts.impl.TupleImpl<T>
All Implemented Interfaces:
Iterable<T>, SequenceDiffOwner, Tuple<T>
public final class TupleImpl<T extends @Nullable Object> extends Object implements Tuple<T>, SequenceDiffOwner

  • Constructor Details

    • TupleImpl

      public TupleImpl(boolean allowsNull, Class<T> type, List<T> items)

    • TupleImpl

      public TupleImpl(boolean allowsNull, Class<T> type, @Nullable Object items, @Nullable SequenceDiff diffToPrevious)

  • Method Details

    • type

      public Class<T> type()
      Description copied from interface: Tuple
      Exposes the common type of the items in this tuple.
      The type of the items in this tuple is retrieved from the first Maybe in the tuple. See Maybe.type() for more information.
      Specified by:
      type in interface Tuple<T extends @Nullable Object>
      Returns:
      The type of the items in the tuple.

    • size

      public int size()
      Description copied from interface: Tuple
      Exposes the size of the tuple of items, which is the number of items in the tuple. This number may never be negative.
      Specified by:
      size in interface Tuple<T extends @Nullable Object>
      Returns:
      The number of items in the tuple, which may never be negative.

    • get

      public T get(int index)
      Description copied from interface: Tuple
      Exposes the Maybe at the specified index. If the index is out of bounds, an IndexOutOfBoundsException will be thrown.
      Specified by:
      get in interface Tuple<T extends @Nullable Object>
      Parameters:
      index - The index of the Maybe to get in the range from 0 to Tuple.size() - 1.
      Returns:
      The Maybe at the specified index.

    • allowsNull

      public boolean allowsNull()
      Description copied from interface: Tuple
      A tuple will only allow nullable items if it was constructed with a "ofNullable(..)" factory method. Otherwise, it will throw an IllegalArgumentException when trying to set a null reference. This flag cannot be changed after the tuple has been constructed!
      Specified by:
      allowsNull in interface Tuple<T extends @Nullable Object>
      Returns:
      true, if this tuple can contain null, false otherwise.

    • slice

      public Tuple<T> slice(int from, int to)
      Description copied from interface: Tuple
      Returns a new tuple of items consisting of the items in the range from inclusive and to exclusive.
      Specified by:
      slice in interface Tuple<T extends @Nullable Object>
      Parameters:
      from - the start index, inclusive.
      to - the end index, exclusive.
      Returns:
      The removed tuple of items.

    • removeRange

      public Tuple<T> removeRange(int from, int to)
      Description copied from interface: Tuple
      Remove all elements within the range from inclusive and to exclusive.
      Specified by:
      removeRange in interface Tuple<T extends @Nullable Object>
      Parameters:
      from - the start index, inclusive.
      to - the end index, exclusive.
      Returns:
      A new tuple of items with the desired change.

    • removeAll

      public Tuple<T> removeAll(Tuple<T> properties)
      Description copied from interface: Tuple
      Creates a new tuple of items without the items of the provided tuple of items. This is also true for duplicate items.
      Specified by:
      removeAll in interface Tuple<T extends @Nullable Object>
      Parameters:
      properties - the tuple of items to have removed in the new tuple.
      Returns:
      A new tuple of items with the desired change.

    • addAt

      public Tuple<T> addAt(int index, T item)
      Description copied from interface: Tuple
      Creates an updated tuple of items where the supplied item is inserted at the specified index.
      Specified by:
      addAt in interface Tuple<T extends @Nullable Object>
      Parameters:
      index - the index at which to add the item.
      item - the thing to add as an item.
      Returns:
      A new tuple of items with the desired change.

    • setAt

      public Tuple<T> setAt(int index, T item)
      Description copied from interface: Tuple
      Creates a new tuple of items where the item at the specified index is replaced with the supplied item.
      Specified by:
      setAt in interface Tuple<T extends @Nullable Object>
      Parameters:
      index - The index of the item to replace.
      item - The item to replace the existing item with.
      Returns:
      A new tuple of items with the desired change.

    • addAllAt

      public Tuple<T> addAllAt(int index, Tuple<T> tuple)
      Description copied from interface: Tuple
      Adds all items from the provided tuple of items to this tuple at a specified index.
      Specified by:
      addAllAt in interface Tuple<T extends @Nullable Object>
      Parameters:
      index - The index at which to add the items.
      tuple - The tuple of items to add.
      Returns:
      A new tuple of items with the desired change.

    • setAllAt

      public Tuple<T> setAllAt(int index, Tuple<T> tuple)
      Description copied from interface: Tuple
      Creates and returns a new tuple from this one where all items from the provided tuple of items, are set starting at the specified index, effectively replacing the items in the specified range of this tuple in the new tuple.
      Specified by:
      setAllAt in interface Tuple<T extends @Nullable Object>
      Parameters:
      index - The index at which to set the items.
      tuple - The tuple of items to set.
      Returns:
      A new tuple of items with the desired change.

    • retainAll

      public Tuple<T> retainAll(Tuple<T> tuple)
      Description copied from interface: Tuple
      Retains only the items in this tuple that are contained in the provided tuple of items. This is also true for duplicate items.
      Specified by:
      retainAll in interface Tuple<T extends @Nullable Object>
      Parameters:
      tuple - The tuple of items to retain. All other items will be removed.
      Returns:
      A new tuple of items with the desired change.

    • clear

      public Tuple<T> clear()
      Description copied from interface: Tuple
      Creates a new tuple of this one without any items but the same nullability (see Tuple.allowsNull()). This is conceptually equivalent to calling List.clear(), but instead of returning void, it returns a new tuple with the desired change. This instance remains completely unchanged.
      Specified by:
      clear in interface Tuple<T extends @Nullable Object>
      Returns:
      An empty tuple of items (which may remember internally that it was produced by a clear operation), with the same nullability as this tuple.

    • sort

      public Tuple<T> sort(Comparator<T> comparator)
      Description copied from interface: Tuple
      Use this for sorting the tuple of items.
      Specified by:
      sort in interface Tuple<T extends @Nullable Object>
      Parameters:
      comparator - The comparator to use for sorting (see Comparator).
      Returns:
      A new tuple of items with the items sorted according to the provided comparator.

    • makeDistinct

      public Tuple<T> makeDistinct()
      Description copied from interface: Tuple
      Returns a new tuple of unique items, meaning that all duplicates in the original tuple are absent in the returned tuple.
      Specified by:
      makeDistinct in interface Tuple<T extends @Nullable Object>
      Returns:
      A new tuple of items with all duplicates removed.

    • reversed

      public Tuple<T> reversed()
      Description copied from interface: Tuple
      Returns a new tuple with the exact same items as this tuple, but in reverse order.
      Specified by:
      reversed in interface Tuple<T extends @Nullable Object>
      Returns:
      A new tuple of items with the items in reverse order.

    • iterator

      public Iterator<T> iterator()
      Specified by:
      iterator in interface Iterable<T extends @Nullable Object>

    • toString

      public String toString()
      Overrides:
      toString in class Object

    • equals

      public boolean equals(Object obj)
      Overrides:
      equals in class Object

    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class Object

    • differenceFromPrevious

      public Optional<SequenceDiff> differenceFromPrevious()
      Description copied from interface: SequenceDiffOwner
      Provides a SequenceDiff object that describes the difference between the current tuple and a previous one (if any), in terms of a SequenceChange, the index of the change, and the number of changes. Use this at a consumer side to keep track of the changes and update the target object only according to the changes that have occurred, instead of rebuilding the target sequence entirely every time a change occurs.
      Specified by:
      differenceFromPrevious in interface SequenceDiffOwner
      Returns:
      An Optional containing the SequenceDiff object if there is a difference between the current tuple and a previous one, or an empty Optional otherwise.