io.lacuna.bifurcan.diffs

Class DiffSortedSet<V>

java.lang.Object

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

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

io.lacuna.bifurcan.diffs.DiffSortedSet<V>

All Implemented Interfaces:

ICollection<ISet<V>,V>, IDiff<ISortedSet<V>>, IDiffSortedSet<V>, ISet<V>, ISortedSet<V>, Iterable<V>, Predicate<V>

public class DiffSortedSet<V>
extends ISortedSet.Mixin<V>
implements IDiffSortedSet<V>

Nested Class Summary

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

IDiffSortedSet.Durable<V>

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

ISortedSet.Bound, ISortedSet.Mixin<V>

Field Summary

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

hash

Constructor Summary

Constructors

Constructor and Description
DiffSortedSet(ISortedMap<V,Void> diffMap)
DiffSortedSet(ISortedSet<V> underlying)

Method Summary

Modifier and Type	Method and Description
DiffSortedSet<V>	add(V value)
DiffSortedSet<V>	clone()
IDiffSortedMap<V,Void>	diffMap()
DiffSortedSet<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.
boolean	isLinear()
DiffSortedSet<V>	linear() This returns a data structure which is linear, or temporarily mutable.
IDiffSortedSet<V>	rebase(ISortedSet<V> newUnderlying) Returns a new diff, which is rebased atop the new underlying collection.
DiffSortedSet<V>	remove(V value)
ISortedSet<V>	underlying() The underlying collection

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

equals, hashCode, toString

Methods inherited from class java.lang.Object

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

Methods inherited from interface io.lacuna.bifurcan.IDiffSortedSet

comparator, inclusiveFloorIndex, iterator, nth, size

Methods inherited from interface io.lacuna.bifurcan.ISortedSet

ceil, ceilIndex, ceilIndex, difference, diffSorted, first, floor, floorIndex, floorIndex, indexOf, intersection, last, slice, slice, sliceIndices, union, valueEquality, valueHash, zip

Methods inherited from interface io.lacuna.bifurcan.ISet

contains, containsAll, containsAll, containsAny, containsAny, diff, elements, iterator, split, 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

DiffSortedSet

public DiffSortedSet(ISortedMap<V,Void> diffMap)

DiffSortedSet

public DiffSortedSet(ISortedSet<V> underlying)

Method Detail

underlying

public ISortedSet<V> underlying()

Description copied from interface: IDiff

The underlying collection

Specified by:

underlying in interface IDiff<ISortedSet<V>>

Specified by:

underlying in interface IDiffSortedSet<V>

diffMap

public IDiffSortedMap<V,Void> diffMap()

Specified by:

diffMap in interface IDiffSortedSet<V>

rebase

public IDiffSortedSet<V> rebase(ISortedSet<V> newUnderlying)

Description copied from interface: IDiff

Returns a new diff, which is rebased atop the new underlying collection. The returned diff may not reflect any changes which cannot be applied to the new collection (removing an element which isn't present in the new collection, for instance), and so a.rebase(b).rebase(c) is not necessarily equivalent to a.rebase(c) .

Specified by:

rebase in interface IDiff<ISortedSet<V>>

Specified by:

rebase in interface IDiffSortedSet<V>

add

public DiffSortedSet<V> add(V value)

Specified by:

add in interface ISet<V>

Specified by:

add in interface ISortedSet<V>

Returns:

the set, containing value

remove

public DiffSortedSet<V> remove(V value)

Specified by:

remove in interface ISet<V>

Specified by:

remove in interface ISortedSet<V>

Returns:

the set, without value

forked

public DiffSortedSet<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>

Specified by:

forked in interface ISortedSet<V>

Returns:

a forked form of the data structure

linear

public DiffSortedSet<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>

Specified by:

linear in interface ISortedSet<V>

Returns:

a linear form of this data structure

isLinear

public boolean isLinear()

Specified by:

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

Specified by:

isLinear in interface ISet<V>

Returns:

true, if the set is linear

clone

public DiffSortedSet<V> clone()

Specified by:

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

Overrides:

clone in class ISortedSet.Mixin<V>

Returns:

a cloned copy of the collection