Package io.usethesource.capsule.core

Class PersistentTrieMap.CompactMapNode<K,V>

java.lang.Object

io.usethesource.capsule.core.PersistentTrieMap.AbstractMapNode<K,V>

io.usethesource.capsule.core.PersistentTrieMap.CompactMapNode<K,V>

All Implemented Interfaces:

MapNode<K,V,PersistentTrieMap.AbstractMapNode<K,V>>, Node, java.io.Serializable

Direct Known Subclasses:

PersistentTrieMap.CompactMixedMapNode, PersistentTrieMap.HashCollisionMapNode

Enclosing class:

PersistentTrieMap<K,V>

protected abstract static class PersistentTrieMap.CompactMapNode<K,V>
extends PersistentTrieMap.AbstractMapNode<K,V>

See Also:

Serialized Form

Field Summary

Fields

Modifier and Type	Field	Description
(package private) static int	BIT_PARTITION_MASK
(package private) static int	BIT_PARTITION_SIZE
(package private) static int	HASH_CODE_LENGTH

Fields inherited from class io.usethesource.capsule.core.PersistentTrieMap.AbstractMapNode

TUPLE_LENGTH

Fields inherited from interface io.usethesource.capsule.core.trie.Node

SIZE_EMPTY, SIZE_MORE_THAN_ONE, SIZE_ONE

Constructor Summary

Constructors

Modifier	Constructor	Description
protected	CompactMapNode()

Method Summary

Modifier and Type	Method	Description
(package private) static int	bitpos(int mask)
boolean	containsKey(K key, int keyHash, int shift, EqualityComparator<java.lang.Object> cmp)
(package private) abstract PersistentTrieMap.CompactMapNode<K,V>	copyAndInsertValue(java.util.concurrent.atomic.AtomicReference<java.lang.Thread> mutator, int bitpos, K key, V val)
(package private) abstract PersistentTrieMap.CompactMapNode<K,V>	copyAndMigrateFromInlineToNode(java.util.concurrent.atomic.AtomicReference<java.lang.Thread> mutator, int bitpos, PersistentTrieMap.AbstractMapNode<K,V> node)
(package private) abstract PersistentTrieMap.CompactMapNode<K,V>	copyAndMigrateFromNodeToInline(java.util.concurrent.atomic.AtomicReference<java.lang.Thread> mutator, int bitpos, PersistentTrieMap.AbstractMapNode<K,V> node)
(package private) abstract PersistentTrieMap.CompactMapNode<K,V>	copyAndRemoveValue(java.util.concurrent.atomic.AtomicReference<java.lang.Thread> mutator, int bitpos)
(package private) abstract PersistentTrieMap.CompactMapNode<K,V>	copyAndSetNode(java.util.concurrent.atomic.AtomicReference<java.lang.Thread> mutator, int bitpos, PersistentTrieMap.AbstractMapNode<K,V> node)
(package private) abstract PersistentTrieMap.CompactMapNode<K,V>	copyAndSetValue(java.util.concurrent.atomic.AtomicReference<java.lang.Thread> mutator, int bitpos, V val)
(package private) int	dataIndex(int bitpos)
(package private) abstract int	dataMap()
java.util.Optional<V>	findByKey(K key, int keyHash, int shift, EqualityComparator<java.lang.Object> cmp)
(package private) abstract PersistentTrieMap.CompactMapNode<K,V>	getNode(int index)
(package private) static int	index(int bitmap, int bitpos)
(package private) static int	index(int bitmap, int mask, int bitpos)
(package private) static int	mask(int keyHash, int shift)
(package private) static <K,V> PersistentTrieMap.CompactMapNode<K,V>	mergeTwoKeyValPairs(K key0, V val0, int keyHash0, K key1, V val1, int keyHash1, int shift)
(package private) PersistentTrieMap.CompactMapNode<K,V>	nodeAt(int bitpos)
(package private) int	nodeIndex(int bitpos)
(package private) boolean	nodeInvariant()
(package private) abstract int	nodeMap()
(package private) static <K,V> PersistentTrieMap.CompactMapNode<K,V>	nodeOf(java.util.concurrent.atomic.AtomicReference<java.lang.Thread> mutator)
(package private) static <K,V> PersistentTrieMap.CompactMapNode<K,V>	nodeOf(java.util.concurrent.atomic.AtomicReference<java.lang.Thread> mutator, int nodeMap, int dataMap, java.lang.Object[] nodes)
(package private) static <K,V> PersistentTrieMap.CompactMapNode<K,V>	nodeOf(java.util.concurrent.atomic.AtomicReference<java.lang.Thread> mutator, int nodeMap, int dataMap, K key, V val)
(package private) static byte	recoverMask(int map, byte i_th)
PersistentTrieMap.AbstractMapNode<K,V>	removed(java.util.concurrent.atomic.AtomicReference<java.lang.Thread> mutator, K key, int keyHash, int shift, MapNodeResult<K,V> details, EqualityComparator<java.lang.Object> cmp)
java.lang.String	toString()
PersistentTrieMap.AbstractMapNode<K,V>	updated(java.util.concurrent.atomic.AtomicReference<java.lang.Thread> mutator, K key, V val, int keyHash, int shift, MapNodeResult<K,V> details, EqualityComparator<java.lang.Object> cmp)

Methods inherited from class io.usethesource.capsule.core.PersistentTrieMap.AbstractMapNode

arity, dataArray, getKey, getKeyValueEntry, getSlot, getValue, hasNodes, hasPayload, hasSlots, isAllowedToEdit, nodeArity, nodeArray, nodeIterator, payloadArity, size, slotArity

Methods inherited from class java.lang.Object

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

Methods inherited from interface io.usethesource.capsule.core.trie.MapNode

equivalent

Methods inherited from interface io.usethesource.capsule.core.trie.Node

sizePredicate

Field Detail

HASH_CODE_LENGTH

static final int HASH_CODE_LENGTH

See Also:

Constant Field Values

BIT_PARTITION_SIZE

static final int BIT_PARTITION_SIZE

See Also:

Constant Field Values

BIT_PARTITION_MASK

static final int BIT_PARTITION_MASK

See Also:

Constant Field Values

Constructor Detail

CompactMapNode

protected CompactMapNode()

Method Detail

mask

static final int mask(int keyHash,
                      int shift)

bitpos

static final int bitpos(int mask)

nodeMap

abstract int nodeMap()

dataMap

abstract int dataMap()

getNode

abstract PersistentTrieMap.CompactMapNode<K,V> getNode(int index)

Specified by:

getNode in class PersistentTrieMap.AbstractMapNode<K,V>

nodeInvariant

boolean nodeInvariant()

copyAndSetValue

abstract PersistentTrieMap.CompactMapNode<K,V> copyAndSetValue(java.util.concurrent.atomic.AtomicReference<java.lang.Thread> mutator,
                                                                     int bitpos,
                                                                     V val)

copyAndInsertValue

abstract PersistentTrieMap.CompactMapNode<K,V> copyAndInsertValue(java.util.concurrent.atomic.AtomicReference<java.lang.Thread> mutator,
                                                                        int bitpos,
                                                                        K key,
                                                                        V val)

copyAndRemoveValue

abstract PersistentTrieMap.CompactMapNode<K,V> copyAndRemoveValue(java.util.concurrent.atomic.AtomicReference<java.lang.Thread> mutator,
                                                                        int bitpos)

copyAndSetNode

abstract PersistentTrieMap.CompactMapNode<K,V> copyAndSetNode(java.util.concurrent.atomic.AtomicReference<java.lang.Thread> mutator,
                                                                    int bitpos,
                                                                    PersistentTrieMap.AbstractMapNode<K,V> node)

copyAndMigrateFromInlineToNode

abstract PersistentTrieMap.CompactMapNode<K,V> copyAndMigrateFromInlineToNode(java.util.concurrent.atomic.AtomicReference<java.lang.Thread> mutator,
                                                                                    int bitpos,
                                                                                    PersistentTrieMap.AbstractMapNode<K,V> node)

copyAndMigrateFromNodeToInline

abstract PersistentTrieMap.CompactMapNode<K,V> copyAndMigrateFromNodeToInline(java.util.concurrent.atomic.AtomicReference<java.lang.Thread> mutator,
                                                                                    int bitpos,
                                                                                    PersistentTrieMap.AbstractMapNode<K,V> node)

mergeTwoKeyValPairs

static final <K,V> PersistentTrieMap.CompactMapNode<K,V> mergeTwoKeyValPairs(K key0,
                                                                                         V val0,
                                                                                         int keyHash0,
                                                                                         K key1,
                                                                                         V val1,
                                                                                         int keyHash1,
                                                                                         int shift)

nodeOf

static final <K,V> PersistentTrieMap.CompactMapNode<K,V> nodeOf(java.util.concurrent.atomic.AtomicReference<java.lang.Thread> mutator,
                                                                            int nodeMap,
                                                                            int dataMap,
                                                                            java.lang.Object[] nodes)

nodeOf

static final <K,V> PersistentTrieMap.CompactMapNode<K,V> nodeOf(java.util.concurrent.atomic.AtomicReference<java.lang.Thread> mutator)

nodeOf

static final <K,V> PersistentTrieMap.CompactMapNode<K,V> nodeOf(java.util.concurrent.atomic.AtomicReference<java.lang.Thread> mutator,
                                                                            int nodeMap,
                                                                            int dataMap,
                                                                            K key,
                                                                            V val)

index

static final int index(int bitmap,
                       int bitpos)

index

static final int index(int bitmap,
                       int mask,
                       int bitpos)

dataIndex

int dataIndex(int bitpos)

nodeIndex

int nodeIndex(int bitpos)

nodeAt

PersistentTrieMap.CompactMapNode<K,V> nodeAt(int bitpos)

containsKey

public boolean containsKey(K key,
                           int keyHash,
                           int shift,
                           EqualityComparator<java.lang.Object> cmp)

findByKey

public java.util.Optional<V> findByKey(K key,
                                       int keyHash,
                                       int shift,
                                       EqualityComparator<java.lang.Object> cmp)

updated

public PersistentTrieMap.AbstractMapNode<K,V> updated(java.util.concurrent.atomic.AtomicReference<java.lang.Thread> mutator,
                                                            K key,
                                                            V val,
                                                            int keyHash,
                                                            int shift,
                                                            MapNodeResult<K,V> details,
                                                            EqualityComparator<java.lang.Object> cmp)

removed

public PersistentTrieMap.AbstractMapNode<K,V> removed(java.util.concurrent.atomic.AtomicReference<java.lang.Thread> mutator,
                                                            K key,
                                                            int keyHash,
                                                            int shift,
                                                            MapNodeResult<K,V> details,
                                                            EqualityComparator<java.lang.Object> cmp)

recoverMask

static byte recoverMask(int map,
                        byte i_th)

Returns:

0 <= mask <= 2^BIT_PARTITION_SIZE - 1

toString

public java.lang.String toString()

Overrides:

toString in class java.lang.Object