io.lacuna.bifurcan.nodes

Class MapNodes

java.lang.Object

io.lacuna.bifurcan.nodes.MapNodes

public class MapNodes
extends java.lang.Object

This is an implementation based on the one described in https://michael.steindorfer.name/publications/oopsla15.pdf.

It adds in support for transient/linear updates, and allows for empty buffer space between the nodes and nodes to minimize allocations when a node is repeatedly updated in-place.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	MapNodes.Collision<K,V>
static class	MapNodes.Node<K,V>

Constructor Summary

Constructors

Constructor and Description
MapNodes()

Method Summary

Modifier and Type	Method and Description
static <K,V> boolean	contains(MapNodes.Node<K,V> node, int shift, int hash, K key, java.util.function.BiPredicate<K,K> equals)
static <K,V> MapNodes.Node<K,V>	difference(int shift, java.lang.Object editor, MapNodes.Node<K,V> a, MapNodes.Node<K,V> b, java.util.function.BiPredicate<K,K> equals)
static <K,V> io.lacuna.bifurcan.nodes.MapNodes.INode<K,V>	diffNodes(int shift, java.lang.Object editor, io.lacuna.bifurcan.nodes.MapNodes.INode<K,V> a, io.lacuna.bifurcan.nodes.MapNodes.INode<K,V> b, java.util.function.BiPredicate<K,K> equals)
static <K,V> java.lang.Object	get(MapNodes.Node<K,V> node, int shift, int hash, K key, java.util.function.BiPredicate<K,K> equals, java.lang.Object defaultValue)
static <K,V> MapNodes.Node<K,V>	intersection(int shift, java.lang.Object editor, MapNodes.Node<K,V> a, MapNodes.Node<K,V> b, java.util.function.BiPredicate<K,K> equals)
static <K,V> io.lacuna.bifurcan.nodes.MapNodes.INode<K,V>	intersectNodes(int shift, java.lang.Object editor, io.lacuna.bifurcan.nodes.MapNodes.INode<K,V> a, io.lacuna.bifurcan.nodes.MapNodes.INode<K,V> b, java.util.function.BiPredicate<K,K> equals)
static <K,V> MapNodes.Node<K,V>	merge(int shift, java.lang.Object editor, MapNodes.Node<K,V> a, MapNodes.Node<K,V> b, java.util.function.BiPredicate<K,K> equals, java.util.function.BinaryOperator<V> merge)
static <K,V> io.lacuna.bifurcan.nodes.MapNodes.INode<K,V>	mergeNodes(int shift, java.lang.Object editor, io.lacuna.bifurcan.nodes.MapNodes.INode<K,V> a, io.lacuna.bifurcan.nodes.MapNodes.INode<K,V> b, java.util.function.BiPredicate<K,K> equals, java.util.function.BinaryOperator<V> merge)
static <K,V> IList<MapNodes.Node<K,V>>	split(java.lang.Object editor, MapNodes.Node<K,V> node, int targetSize)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

MapNodes

public MapNodes()

Method Detail

contains

public static <K,V> boolean contains(MapNodes.Node<K,V> node,
                                     int shift,
                                     int hash,
                                     K key,
                                     java.util.function.BiPredicate<K,K> equals)

get

public static <K,V> java.lang.Object get(MapNodes.Node<K,V> node,
                                         int shift,
                                         int hash,
                                         K key,
                                         java.util.function.BiPredicate<K,K> equals,
                                         java.lang.Object defaultValue)

mergeNodes

public static <K,V> io.lacuna.bifurcan.nodes.MapNodes.INode<K,V> mergeNodes(int shift,
                                                                            java.lang.Object editor,
                                                                            io.lacuna.bifurcan.nodes.MapNodes.INode<K,V> a,
                                                                            io.lacuna.bifurcan.nodes.MapNodes.INode<K,V> b,
                                                                            java.util.function.BiPredicate<K,K> equals,
                                                                            java.util.function.BinaryOperator<V> merge)

merge

public static <K,V> MapNodes.Node<K,V> merge(int shift,
                                             java.lang.Object editor,
                                             MapNodes.Node<K,V> a,
                                             MapNodes.Node<K,V> b,
                                             java.util.function.BiPredicate<K,K> equals,
                                             java.util.function.BinaryOperator<V> merge)

diffNodes

public static <K,V> io.lacuna.bifurcan.nodes.MapNodes.INode<K,V> diffNodes(int shift,
                                                                           java.lang.Object editor,
                                                                           io.lacuna.bifurcan.nodes.MapNodes.INode<K,V> a,
                                                                           io.lacuna.bifurcan.nodes.MapNodes.INode<K,V> b,
                                                                           java.util.function.BiPredicate<K,K> equals)

difference

public static <K,V> MapNodes.Node<K,V> difference(int shift,
                                                  java.lang.Object editor,
                                                  MapNodes.Node<K,V> a,
                                                  MapNodes.Node<K,V> b,
                                                  java.util.function.BiPredicate<K,K> equals)

intersectNodes

public static <K,V> io.lacuna.bifurcan.nodes.MapNodes.INode<K,V> intersectNodes(int shift,
                                                                                java.lang.Object editor,
                                                                                io.lacuna.bifurcan.nodes.MapNodes.INode<K,V> a,
                                                                                io.lacuna.bifurcan.nodes.MapNodes.INode<K,V> b,
                                                                                java.util.function.BiPredicate<K,K> equals)

intersection

public static <K,V> MapNodes.Node<K,V> intersection(int shift,
                                                    java.lang.Object editor,
                                                    MapNodes.Node<K,V> a,
                                                    MapNodes.Node<K,V> b,
                                                    java.util.function.BiPredicate<K,K> equals)

split

public static <K,V> IList<MapNodes.Node<K,V>> split(java.lang.Object editor,
                                                    MapNodes.Node<K,V> node,
                                                    int targetSize)