io.lacuna.bifurcan

Class IntMap<V>

java.lang.Object

io.lacuna.bifurcan.IMap.Mixin<K,V>

io.lacuna.bifurcan.ISortedMap.Mixin<Long,V>

io.lacuna.bifurcan.IntMap<V>

All Implemented Interfaces:

ICollection<IMap<Long,V>,IEntry<Long,V>>, IMap<Long,V>, ISortedMap<Long,V>, Iterable<IEntry<Long,V>>, Function<Long,V>

public class IntMap<V>
extends ISortedMap.Mixin<Long,V>

A map which has integer keys, which is an combination of Okasaki and Gill's Fast Mergeable Integer Maps with the memory layout suggested by Steindorfer and Vinju used in Map, with which it shares the same broad performance characteristics.

This collection keeps the keys in sorted order, and can thought of as either a map of integers or a sparse vector. It provides IntMap#slice(Long, Long), inclusiveFloorIndex(Long), and ceilIndex(Long) methods which allow for lookups and filtering on its keys.

Nested Class Summary

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

ISortedMap.Mixin<K,V>

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

IMap.Durable<K,V>

Field Summary

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

hash

Constructor Summary

Constructors

Constructor and Description
IntMap()

Method Summary

Modifier and Type	Method and Description
OptionalLong	ceilIndex(long key)
OptionalLong	ceilIndex(Long key)
IntMap<V>	clone()
Comparator<Long>	comparator()
boolean	contains(long key)
boolean	contains(Long key)
IntMap<V>	difference(IMap<Long,?> b)
IntMap<V>	difference(ISet<Long> keys)
boolean	equals(IMap<Long,V> o, BiPredicate<V,V> valEquals)
boolean	equals(Object obj)
OptionalLong	floorIndex(long key)
IntMap<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> IntMap<V>	from(Collection<Map.Entry<Number,V>> collection)
static <V> IntMap<V>	from(IList<IEntry<Number,V>> list)
static <V> IntMap<V>	from(IMap<Number,V> m)
static <V> IntMap<V>	from(Map<Number,V> m)
Optional<V>	get(long key)
V	get(long key, V defaultValue)
V	get(Long key, V defaultValue)
OptionalLong	inclusiveFloorIndex(Long key)
OptionalLong	indexOf(long key)
OptionalLong	indexOf(Long key)
IntMap<V>	intersection(IMap<Long,?> b)
IntMap<V>	intersection(ISet<Long> keys)
boolean	isLinear()
Iterator<IEntry<Long,V>>	iterator()
BiPredicate<Long,Long>	keyEquality()
ToLongFunction<Long>	keyHash()
IntMap<V>	linear() This returns a data structure which is linear, or temporarily mutable.
<U> IntMap<U>	mapValues(BiFunction<Long,V,U> f)
IntMap<V>	merge(IMap<Long,V> b, BinaryOperator<V> mergeFn)
IEntry<Long,V>	nth(long idx)
IntMap<V>	put(long key, V value)
IntMap<V>	put(Long key, V value)
IntMap<V>	put(long key, V value, BinaryOperator<V> merge)
IntMap<V>	put(Long key, V value, BinaryOperator<V> merge)
IntMap<V>	put(long key, V value, BinaryOperator<V> merge, Object editor)
IntMap<V>	put(long key, V value, Object editor)
IntMap<V>	remove(long key)
IntMap<V>	remove(Long key)
IntMap<V>	remove(long key, Object editor)
long	size()
IntMap<V>	slice(long min, long max)
IntMap<V>	sliceReal(Long min, Long max)
List<IntMap<V>>	split(int parts) Splits the collection into roughly even pieces, for parallel processing.
IntMap<V>	union(IMap<Long,V> m)
IntMap<V>	update(long key, UnaryOperator<V> update)
IntMap<V>	update(Long key, UnaryOperator<V> update)
IntMap<V>	update(long key, UnaryOperator<V> update, Object editor)

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

hashCode, toString

Methods inherited from class java.lang.Object

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

Methods inherited from interface io.lacuna.bifurcan.ISortedMap

ceil, ceil, ceilIndex, diffSorted, first, floor, floor, floorIndex, floorIndex, keys, last, slice, slice, sliceIndices

Methods inherited from interface io.lacuna.bifurcan.IMap

apply, containsAll, containsAll, containsAny, containsAny, diff, entries, get, getOrCreate, hashSortedEntries, iterator, save, spliterator, stream, toMap, values

Methods inherited from interface io.lacuna.bifurcan.ICollection

nth

Methods inherited from interface java.lang.Iterable

forEach

Methods inherited from interface java.util.function.Function

andThen, compose, identity

Constructor Detail

IntMap

public IntMap()

Method Detail

from

public static <V> IntMap<V> from(IMap<Number,V> m)

Parameters:

m - another map

Returns:

a forked copy of the map

from

public static <V> IntMap<V> from(Map<Number,V> m)

Returns:

a forked copy of m

from

public static <V> IntMap<V> from(Collection<Map.Entry<Number,V>> collection)

Parameters:

collection - a collection of Map.Entry objects

Returns:

an IntMap representing the entries in the collection

from

public static <V> IntMap<V> from(IList<IEntry<Number,V>> list)

Parameters:

list - a list of IEntry objects

Returns:

an IntMap representing the entries in the list

comparator

public Comparator<Long> comparator()

keyHash

public ToLongFunction<Long> keyHash()

Returns:

the hash function used by the map

keyEquality

public BiPredicate<Long,Long> keyEquality()

Returns:

the key equality semantics used by the map

slice

public IntMap<V> slice(long min,
                       long max)

Parameters:

min - the inclusive minimum key value

max - the inclusive maximum key value

Returns:

a map representing all entries within [min, max]

sliceReal

public IntMap<V> sliceReal(Long min,
                           Long max)

merge

public IntMap<V> merge(IMap<Long,V> b,
                       BinaryOperator<V> mergeFn)

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

public IntMap<V> difference(ISet<Long> keys)

Returns:

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

intersection

public IntMap<V> intersection(ISet<Long> keys)

Returns:

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

union

public IntMap<V> union(IMap<Long,V> m)

Returns:

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

difference

public IntMap<V> difference(IMap<Long,?> b)

Returns:

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

intersection

public IntMap<V> intersection(IMap<Long,?> b)

Returns:

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

put

public IntMap<V> put(long key,
                     V value)

Parameters:

key - a primitive long key

value - a value

Returns:

an updated IntMap with value under key

put

public IntMap<V> put(long key,
                     V value,
                     Object editor)

put

public IntMap<V> put(long key,
                     V value,
                     BinaryOperator<V> merge)

Parameters:

key - a primitive long key

value - a value

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

put

public IntMap<V> put(long key,
                     V value,
                     BinaryOperator<V> merge,
                     Object editor)

put

public IntMap<V> put(Long key,
                     V value)

Returns:

an updated map with value stored under key

put

public IntMap<V> put(Long key,
                     V value,
                     BinaryOperator<V> merge)

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

remove

public IntMap<V> remove(long key)

Returns:

an updated map that does not contain key

remove

public IntMap<V> remove(long key,
                        Object editor)

remove

public IntMap<V> remove(Long key)

Returns:

an updated map that does not contain key

mapValues

public <U> IntMap<U> mapValues(BiFunction<Long,V,U> f)

Type Parameters:

U - the new type of the values

Parameters:

f - a function which transforms the values

Returns:

a transformed map which shares the same equality semantics

get

public Optional<V> get(long key)

get

public V get(long key,
             V defaultValue)

get

public V get(Long key,
             V defaultValue)

Returns:

the value under key, or defaultValue if there is no such key

update

public IntMap<V> update(Long key,
                        UnaryOperator<V> update)

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.

update

public IntMap<V> update(long key,
                        UnaryOperator<V> update)

update

public IntMap<V> update(long key,
                        UnaryOperator<V> update,
                        Object editor)

contains

public boolean contains(long key)

contains

public boolean contains(Long key)

Returns:

true if key is in the map, false otherwise

indexOf

public OptionalLong indexOf(Long key)

Returns:

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

indexOf

public OptionalLong indexOf(long key)

nth

public IEntry<Long,V> nth(long idx)

Returns:

the element at idx

iterator

public Iterator<IEntry<Long,V>> iterator()

floorIndex

public OptionalLong floorIndex(long key)

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.

inclusiveFloorIndex

public OptionalLong inclusiveFloorIndex(Long key)

ceilIndex

public OptionalLong ceilIndex(long key)

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.

ceilIndex

public OptionalLong ceilIndex(Long key)

size

public long size()

Returns:

the number of elements in the collection

isLinear

public boolean isLinear()

Returns:

true, if the collection is linear

forked

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

equals

public boolean equals(IMap<Long,V> o,
                      BiPredicate<V,V> valEquals)

Parameters:

o - another map

valEquals - a predicate which checks value equalities

Returns:

true, if the maps are equivalent

equals

public boolean equals(Object obj)

Overrides:

equals in class IMap.Mixin<Long,V>

clone

public IntMap<V> clone()

Specified by:

clone in interface ICollection<IMap<Long,V>,IEntry<Long,V>>

Overrides:

clone in class ISortedMap.Mixin<Long,V>

Returns:

a cloned copy of the collection