io.lacuna.bifurcan

Interface ISortedMap<K,V>

All Superinterfaces:

Function<K,V>, ICollection<IMap<K,V>,IEntry<K,V>>, IMap<K,V>, Iterable<IEntry<K,V>>

All Known Subinterfaces:

IDiffSortedMap<K,V>, IDiffSortedMap.Durable<K,V>

All Known Implementing Classes:

ConcatSortedMap, FloatMap, IntMap, ISortedMap.Mixin, Slice.SortedMap, SortedMap

public interface ISortedMap<K,V>
extends IMap<K,V>

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	ISortedMap.Mixin<K,V>

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

IMap.Durable<K,V>

Method Summary

Modifier and Type	Method and Description
default IEntry<K,V>	ceil(K key)
default IEntry<K,V>	ceil(K key, ISortedSet.Bound bound)
default OptionalLong	ceilIndex(K key)
default OptionalLong	ceilIndex(K key, ISortedSet.Bound bound)
Comparator<K>	comparator()
default ISortedMap<K,V>	difference(IMap<K,?> m)
default ISortedMap<K,V>	difference(ISet<K> keys)
default IDiffSortedMap<K,V>	diffSorted()
default IEntry<K,V>	first()
default IEntry<K,V>	floor(K key)
default IEntry<K,V>	floor(K key, ISortedSet.Bound bound)
default OptionalLong	floorIndex(K key)
default OptionalLong	floorIndex(K key, ISortedSet.Bound bound)
default ISortedMap<K,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(K key)
default OptionalLong	indexOf(K key)
default ISortedMap<K,V>	intersection(ISet<K> keys)
default BiPredicate<K,K>	keyEquality()
default ToLongFunction<K>	keyHash()
default ISortedSet<K>	keys()
default IEntry<K,V>	last()
default ISortedMap<K,V>	linear() This returns a data structure which is linear, or temporarily mutable.
default ISortedMap<K,V>	merge(IMap<K,V> b, BinaryOperator<V> mergeFn)
default ISortedMap<K,V>	put(K key, V value)
default ISortedMap<K,V>	put(K key, V value, BinaryOperator<V> merge)
default ISortedMap<K,V>	remove(K key)
default IDiffSortedMap<K,V>	slice(K min, ISortedSet.Bound minBound, K max, ISortedSet.Bound maxBound)
default IDiffSortedMap<K,V>	slice(K min, K max)
default ISortedMap<K,V>	sliceIndices(long startIndex, long endIndex)
default ISortedMap<K,V>	union(IMap<K,V> m)
default ISortedMap<K,V>	update(K key, UnaryOperator<V> update)

Methods inherited from interface io.lacuna.bifurcan.IMap

apply, contains, containsAll, containsAll, containsAny, containsAny, diff, entries, equals, get, get, getOrCreate, hashSortedEntries, intersection, isLinear, iterator, mapValues, save, split, spliterator, stream, toMap, values

Methods inherited from interface io.lacuna.bifurcan.ICollection

clone, iterator, nth, nth, size

Methods inherited from interface java.lang.Iterable

forEach

Methods inherited from interface java.util.function.Function

andThen, compose, identity

Method Detail

comparator

Comparator<K> comparator()

inclusiveFloorIndex

OptionalLong inclusiveFloorIndex(K key)

floorIndex

default OptionalLong floorIndex(K key)

floorIndex

default OptionalLong floorIndex(K key,
                                ISortedSet.Bound bound)

ceilIndex

default OptionalLong ceilIndex(K key)

ceilIndex

default OptionalLong ceilIndex(K key,
                               ISortedSet.Bound bound)

keyHash

default ToLongFunction<K> keyHash()

Specified by:

keyHash in interface IMap<K,V>

Returns:

the hash function used by the map

keyEquality

default BiPredicate<K,K> keyEquality()

Specified by:

keyEquality in interface IMap<K,V>

Returns:

the key equality semantics used by the map

keys

default ISortedSet<K> keys()

Specified by:

keys in interface IMap<K,V>

Returns:

a set representing all keys in the map

indexOf

default OptionalLong indexOf(K key)

Specified by:

indexOf in interface IMap<K,V>

Returns:

the index of key within the collection, if it's present

floor

default IEntry<K,V> floor(K key)

floor

default IEntry<K,V> floor(K key,
                          ISortedSet.Bound bound)

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 IEntry<K,V> ceil(K key)

ceil

default IEntry<K,V> ceil(K key,
                         ISortedSet.Bound bound)

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 IDiffSortedMap<K,V> slice(K min,
                                  K 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 IDiffSortedMap<K,V> slice(K min,
                                  ISortedSet.Bound minBound,
                                  K max,
                                  ISortedSet.Bound maxBound)

sliceIndices

default ISortedMap<K,V> sliceIndices(long startIndex,
                                     long endIndex)

Specified by:

sliceIndices in interface IMap<K,V>

merge

default ISortedMap<K,V> merge(IMap<K,V> b,
                              BinaryOperator<V> mergeFn)

Specified by:

merge in interface IMap<K,V>

Parameters:

b - another map

mergeFn - a function which, in the case of key collisions, takes two values and returns the merged result

Returns:

a new map representing the merger of the two maps

difference

default ISortedMap<K,V> difference(ISet<K> keys)

Specified by:

difference in interface IMap<K,V>

Returns:

a new map representing the current map, less the keys in keys

intersection

default ISortedMap<K,V> intersection(ISet<K> keys)

Specified by:

intersection in interface IMap<K,V>

Returns:

a new map representing the current map, but only with the keys in keys

union

default ISortedMap<K,V> union(IMap<K,V> m)

Specified by:

union in interface IMap<K,V>

Returns:

a combined map, with the values from m shadowing those in this amp

difference

default ISortedMap<K,V> difference(IMap<K,?> m)

Specified by:

difference in interface IMap<K,V>

Returns:

a new map representing the current map, less the keys in m

put

default ISortedMap<K,V> put(K key,
                            V value,
                            BinaryOperator<V> merge)

Specified by:

put in interface IMap<K,V>

merge - a function which will be invoked if there is a pre-existing value under key, with the current value as the first argument and new value as the second, to determine the combined result

Returns:

an updated map with value under key

update

default ISortedMap<K,V> update(K key,
                               UnaryOperator<V> update)

Specified by:

update in interface IMap<K,V>

update - a function which takes the existing value, or null if none exists, and returns an updated value.

Returns:

an updated map with update(value) under key.

put

default ISortedMap<K,V> put(K key,
                            V value)

Specified by:

put in interface IMap<K,V>

Returns:

an updated map with value stored under key

remove

default ISortedMap<K,V> remove(K key)

Specified by:

remove in interface IMap<K,V>

Returns:

an updated map that does not contain key

forked

default ISortedMap<K,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<IMap<K,V>,IEntry<K,V>>

Specified by:

forked in interface IMap<K,V>

Returns:

a forked form of the data structure

linear

default ISortedMap<K,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<IMap<K,V>,IEntry<K,V>>

Specified by:

linear in interface IMap<K,V>

Returns:

a linear form of this data structure

diffSorted

default IDiffSortedMap<K,V> diffSorted()

Returns:

a diff wrapper around this collection which preserves the sorting

first

default IEntry<K,V> first()

last

default IEntry<K,V> last()