io.lacuna.bifurcan

Class LinearSet<V>

java.lang.Object

io.lacuna.bifurcan.ISet.Mixin<V>

io.lacuna.bifurcan.LinearSet<V>

All Implemented Interfaces:

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

public class LinearSet<V>
extends ISet.Mixin<V>

A set which builds atop LinearMap, and shares the same performance characteristics.

Nested Class Summary

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

ISet.Durable<V>, ISet.Mixin<V>

Field Summary

Fields inherited from class io.lacuna.bifurcan.ISet.Mixin

hash

Constructor Summary

Constructors

Constructor and Description
LinearSet()
LinearSet(int initialCapacity)
LinearSet(int initialCapacity, ToLongFunction<V> hashFn, BiPredicate<V,V> equalsFn)
LinearSet(ToLongFunction<V> hashFn, BiPredicate<V,V> equalsFn)

Method Summary

Modifier and Type	Method and Description
LinearSet<V>	add(V value)
LinearSet<V>	clear()
LinearSet<V>	clone()
boolean	contains(V value)
LinearSet<V>	difference(ISet<V> s)
ISet<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.
static <V> LinearSet<V>	from(Collection<V> collection)
static <V> LinearSet<V>	from(IList<V> list)
static <V> LinearSet<V>	from(ISet<V> set)
static <V> LinearSet<V>	from(Iterable<V> iterable)
static <V> LinearSet<V>	from(Iterator<V> iterator)
int	hashCode()
OptionalLong	indexOf(V element)
LinearSet<V>	intersection(ISet<V> s)
boolean	isLinear()
Iterator<V>	iterator()
LinearSet<V>	linear() This returns a data structure which is linear, or temporarily mutable.
V	nth(long idx)
static <V> LinearSet<V>	of(V... elements)
LinearSet<V>	remove(V value)
long	size()
List<LinearSet<V>>	split(int parts) Splits the collection into roughly even pieces, for parallel processing.
LinearSet<V>	union(ISet<V> s)
BiPredicate<V,V>	valueEquality()
ToLongFunction<V>	valueHash()
<U> LinearMap<V,U>	zip(Function<V,U> f)

Methods inherited from class io.lacuna.bifurcan.ISet.Mixin

equals, toString

Methods inherited from class java.lang.Object

finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface io.lacuna.bifurcan.ISet

containsAll, containsAll, containsAny, containsAny, diff, elements, iterator, sliceIndices, spliterator, stream, test, toArray, toArray, toSet

Methods inherited from interface io.lacuna.bifurcan.ICollection

nth, save

Methods inherited from interface java.lang.Iterable

forEach

Methods inherited from interface java.util.function.Predicate

and, isEqual, negate, or

Constructor Detail

LinearSet

public LinearSet()

LinearSet

public LinearSet(int initialCapacity)

Parameters:

initialCapacity - the initial capacity of the set

LinearSet

public LinearSet(int initialCapacity,
                 ToLongFunction<V> hashFn,
                 BiPredicate<V,V> equalsFn)

Parameters:

initialCapacity - the initial capacity of the set

hashFn - the hash function used by the set

equalsFn - the equality semantics used by the set

LinearSet

public LinearSet(ToLongFunction<V> hashFn,
                 BiPredicate<V,V> equalsFn)

Parameters:

hashFn - the hash function used by the set

equalsFn - the equality semantics used by the set

Method Detail

from

public static <V> LinearSet<V> from(IList<V> list)

Returns:

a set containing the elements in list

from

public static <V> LinearSet<V> from(Collection<V> collection)

Returns:

a set containing the elements in collection

from

public static <V> LinearSet<V> from(Iterator<V> iterator)

Returns:

a set containing the remaining elements in iterator

from

public static <V> LinearSet<V> from(Iterable<V> iterable)

Returns:

a set containing the elements in iterable

from

public static <V> LinearSet<V> from(ISet<V> set)

Returns:

a set containing the same elements as set, with the same equality semantics

of

public static <V> LinearSet<V> of(V... elements)

Returns:

a set containing elements

isLinear

public boolean isLinear()

Returns:

true, if the set is linear

valueHash

public ToLongFunction<V> valueHash()

Returns:

the hash function used by the set

valueEquality

public BiPredicate<V,V> valueEquality()

Returns:

the equality semantics used by the set

add

public LinearSet<V> add(V value)

Returns:

the set, containing value

remove

public LinearSet<V> remove(V value)

Returns:

the set, without value

clear

public LinearSet<V> clear()

contains

public boolean contains(V value)

Returns:

true, if the set contains value

size

public long size()

Returns:

the number of elements in the collection

indexOf

public OptionalLong indexOf(V element)

Returns:

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

nth

public V nth(long idx)

Returns:

the element at idx

iterator

public Iterator<V> iterator()

zip

public <U> LinearMap<V,U> zip(Function<V,U> f)

Returns:

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

union

public LinearSet<V> union(ISet<V> s)

Returns:

a new set, representing the union with set

difference

public LinearSet<V> difference(ISet<V> s)

Returns:

a new set, representing the difference with set

intersection

public LinearSet<V> intersection(ISet<V> s)

Returns:

a new set, representing the intersection with set

forked

public ISet<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.

Returns:

a forked form of the data structure

linear

public LinearSet<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.

Returns:

a linear form of this data structure

split

public List<LinearSet<V>> split(int parts)

Description copied from interface: ICollection

Splits the collection into roughly even pieces, for parallel processing. Depending on the size and contents of the collection, this function may not return exactly parts subsets.

Parameters:

parts - the target number of pieces

Returns:

a list containing subsets of the collection.

hashCode

public int hashCode()

Overrides:

hashCode in class ISet.Mixin<V>

clone

public LinearSet<V> clone()

Specified by:

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

Overrides:

clone in class ISet.Mixin<V>

Returns:

a cloned copy of the collection