io.lacuna.bifurcan

Interface ISortedSet<V>

All Superinterfaces:

ICollection<ISet<V>,V>, ISet<V>, Iterable<V>, Predicate<V>

All Known Subinterfaces:

IDiffSortedSet<V>, IDiffSortedSet.Durable<V>

All Known Implementing Classes:

DiffSortedSet, IntSet, ISortedSet.Mixin, Slice.SortedSet, SortedSet

public interface ISortedSet<V>
extends ISet<V>

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	ISortedSet.Bound
static class	ISortedSet.Mixin<V>

Nested classes/interfaces inherited from interface io.lacuna.bifurcan.ISet

ISet.Durable<V>

Method Summary

Modifier and Type	Method and Description
default ISortedSet<V>	add(V value)
default V	ceil(V val)
default OptionalLong	ceilIndex(V val)
default OptionalLong	ceilIndex(V val, ISortedSet.Bound bound)
Comparator<V>	comparator()
default ISortedSet<V>	difference(ISet<V> s)
default IDiffSortedSet<V>	diffSorted()
default V	first()
default V	floor(V val)
default OptionalLong	floorIndex(V val)
default OptionalLong	floorIndex(V val, ISortedSet.Bound bound)
default ISortedSet<V>	forked() This returns a data structure which is forked, which is equivalent to Clojure's persistent data structures, also sometimes called functional or immutable.
OptionalLong	inclusiveFloorIndex(V val)
default OptionalLong	indexOf(V element)
default ISortedSet<V>	intersection(ISet<V> s)
default V	last()
default ISortedSet<V>	linear() This returns a data structure which is linear, or temporarily mutable.
default ISortedSet<V>	remove(V value)
default IDiffSortedSet<V>	slice(V min, ISortedSet.Bound minBound, V max, ISortedSet.Bound maxBound)
default IDiffSortedSet<V>	slice(V min, V max)
default ISortedSet<V>	sliceIndices(long startIndex, long endIndex)
default ISortedSet<V>	union(ISet<V> s)
default BiPredicate<V,V>	valueEquality()
default ToLongFunction<V>	valueHash()
default <U> ISortedMap<V,U>	zip(Function<V,U> f)

Methods inherited from interface io.lacuna.bifurcan.ISet

contains, containsAll, containsAll, containsAny, containsAny, diff, elements, isLinear, iterator, split, spliterator, stream, test, toArray, toArray, toSet

Methods inherited from interface io.lacuna.bifurcan.ICollection

clone, iterator, nth, nth, save, size

Methods inherited from interface java.lang.Iterable

forEach

Methods inherited from interface java.util.function.Predicate

and, isEqual, negate, or

Method Detail

comparator

Comparator<V> comparator()

inclusiveFloorIndex

OptionalLong inclusiveFloorIndex(V val)

Returns:

the entry whose key is either equal to key, or just below it. If key is less than the minimum value in the map, returns null.

valueHash

default ToLongFunction<V> valueHash()

Specified by:

valueHash in interface ISet<V>

Returns:

the hash function used by the set

valueEquality

default BiPredicate<V,V> valueEquality()

Specified by:

valueEquality in interface ISet<V>

Returns:

the equality semantics used by the set

floorIndex

default OptionalLong floorIndex(V val,
                                ISortedSet.Bound bound)

ceilIndex

default OptionalLong ceilIndex(V val,
                               ISortedSet.Bound bound)

ceilIndex

default OptionalLong ceilIndex(V val)

Returns:

the entry whose key is either equal to key, or just above it. If key is greater than the maximum value in the map, returns null.

floorIndex

default OptionalLong floorIndex(V val)

indexOf

default OptionalLong indexOf(V element)

Specified by:

indexOf in interface ISet<V>

Returns:

the position of element in the collection, if it's present

floor

default V floor(V val)

Returns:

the entry whose key is either equal to key, or just below it. If key is less than the minimum value in the map, returns null.

ceil

default V ceil(V val)

Returns:

the entry whose key is either equal to key, or just above it. If key is greater than the maximum value in the map, returns null.

slice

default IDiffSortedSet<V> slice(V min,
                                V max)

Parameters:

min - the inclusive minimum key value

max - the inclusive maximum key value

Returns:

a map representing all entries within [min, max]

slice

default IDiffSortedSet<V> slice(V min,
                                ISortedSet.Bound minBound,
                                V max,
                                ISortedSet.Bound maxBound)

zip

default <U> ISortedMap<V,U> zip(Function<V,U> f)

Specified by:

zip in interface ISet<V>

Returns:

a map which has a corresponding value, computed by f, for each element in the set

sliceIndices

default ISortedSet<V> sliceIndices(long startIndex,
                                   long endIndex)

Specified by:

sliceIndices in interface ISet<V>

add

default ISortedSet<V> add(V value)

Specified by:

add in interface ISet<V>

Returns:

the set, containing value

remove

default ISortedSet<V> remove(V value)

Specified by:

remove in interface ISet<V>

Returns:

the set, without value

union

default ISortedSet<V> union(ISet<V> s)

Specified by:

union in interface ISet<V>

Returns:

a new set, representing the union with set

difference

default ISortedSet<V> difference(ISet<V> s)

Specified by:

difference in interface ISet<V>

Returns:

a new set, representing the difference with set

intersection

default ISortedSet<V> intersection(ISet<V> s)

Specified by:

intersection in interface ISet<V>

Returns:

a new set, representing the intersection with set

forked

default ISortedSet<V> forked()

Description copied from interface: ICollection

This returns a data structure which is forked, which is equivalent to Clojure's persistent data structures, also sometimes called functional or immutable. This is called "forked" because it means that multiple functions can make divergent changes to the data structure without affecting each other.

If only a single function or scope uses the data structure, it can be left as a linear data structure, which can have significant performance benefits.

If the data structure is already forked, it will simply return itself.

Specified by:

forked in interface ICollection<ISet<V>,V>

Specified by:

forked in interface ISet<V>

Returns:

a forked form of the data structure

linear

default ISortedSet<V> linear()

Description copied from interface: ICollection

This returns a data structure which is linear, or temporarily mutable. The term "linear", as used here, does not completely align with the formal definition of linear types as used in type theory. It is meant to describe the linear dataflow of the method calls, and as a converse to "forked" data structures.

If ICollection.forked() is called on a linear collection, all references to that linear collection should be discarded.

If the data structure is already linear, it will simply return itself.

Specified by:

linear in interface ICollection<ISet<V>,V>

Specified by:

linear in interface ISet<V>

Returns:

a linear form of this data structure

diffSorted

default IDiffSortedSet<V> diffSorted()

first

default V first()

last

default V last()