traverseArea(Vec3 vec, AABB boundingBox) {
+ double toTravel = Math.min(16.0 / vec.length(), 1.0);
+ Vec3 movement = vec.scale(toTravel);
+ AABB fromBB = boundingBox.move(-vec.x, -vec.y, -vec.z);
+ AABB searchArea = fromBB.expandTowards(movement);
+ return BlockPosIterator.iterable(searchArea);
+ }
+
+ public BlockPosIterator(AABB bb) {
+ this.startX = Mth.floor(bb.minX);
+ this.startY = Mth.floor(bb.minY);
+ this.startZ = Mth.floor(bb.minZ);
+ this.endX = Mth.floor(bb.maxX);
+ this.endY = Mth.floor(bb.maxY);
+ this.endZ = Mth.floor(bb.maxZ);
+ }
+
+ @Override
+ protected BlockPos computeNext() {
+ MutableBlockPos pos = this.pos;
+ if (pos == null) {
+ return this.pos = new MutableBlockPos(this.startX, this.startY, this.startZ);
+ } else {
+ int x = pos.getX();
+ int y = pos.getY();
+ int z = pos.getZ();
+
+ if (y < this.endY) {
+ y += 1;
+ } else if (x < this.endX) {
+ x += 1;
+ y = this.startY;
+ } else if (z < this.endZ) {
+ z += 1;
+ x = this.startX;
+ } else {
+ return this.endOfData();
+ }
+
+ pos.set(x, y, z);
+ return pos;
+ }
+ }
+}
diff --git a/leaf-server/src/main/java/org/dreeam/leaf/util/map/ConcurrentLongHashSet.java b/leaf-server/src/main/java/org/dreeam/leaf/util/map/ConcurrentLongHashSet.java
index b699f723..4d9fea75 100644
--- a/leaf-server/src/main/java/org/dreeam/leaf/util/map/ConcurrentLongHashSet.java
+++ b/leaf-server/src/main/java/org/dreeam/leaf/util/map/ConcurrentLongHashSet.java
@@ -1,6 +1,9 @@
package org.dreeam.leaf.util.map;
-import it.unimi.dsi.fastutil.longs.*;
+import it.unimi.dsi.fastutil.longs.LongCollection;
+import it.unimi.dsi.fastutil.longs.LongIterator;
+import it.unimi.dsi.fastutil.longs.LongOpenHashSet;
+import it.unimi.dsi.fastutil.longs.LongSet;
import org.jetbrains.annotations.NotNull;
import java.util.Arrays;
diff --git a/leaf-server/src/main/java/org/dreeam/leaf/util/map/spottedleaf/LeafConcurrentLong2ReferenceChainedHashTable.java b/leaf-server/src/main/java/org/dreeam/leaf/util/map/spottedleaf/LeafConcurrentLong2ReferenceChainedHashTable.java
new file mode 100644
index 00000000..27698be1
--- /dev/null
+++ b/leaf-server/src/main/java/org/dreeam/leaf/util/map/spottedleaf/LeafConcurrentLong2ReferenceChainedHashTable.java
@@ -0,0 +1,2294 @@
+package org.dreeam.leaf.util.map.spottedleaf;
+
+import ca.spottedleaf.concurrentutil.function.BiLong1Function;
+import ca.spottedleaf.concurrentutil.util.ConcurrentUtil;
+import ca.spottedleaf.concurrentutil.util.HashUtil;
+import ca.spottedleaf.concurrentutil.util.IntegerUtil;
+import ca.spottedleaf.concurrentutil.util.ThrowUtil;
+import ca.spottedleaf.concurrentutil.util.Validate;
+
+import java.lang.invoke.VarHandle;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.NoSuchElementException;
+import java.util.Objects;
+import java.util.PrimitiveIterator;
+import java.util.Set;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.atomic.LongAdder;
+import java.util.function.BiFunction;
+import java.util.function.Consumer;
+import java.util.function.LongConsumer;
+import java.util.function.LongFunction;
+import java.util.function.Predicate;
+
+/**
+ * Optimized concurrent hashtable implementation supporting mapping arbitrary {@code long} keys onto non-null {@code Object}
+ * values with support for multiple writer and multiple reader threads. Utilizes lock-free read paths,
+ * optimistic lock-free write attempts, and fine-grained locking during modifications and resizing.
+ *
+ * Happens-before relationship
+ *
+ * As with {@link ConcurrentMap}, actions in a thread prior to placing an object into this map
+ * happen-before actions subsequent to the access or removal of that object in another thread.
+ *
+ *
+ * Atomicity of functional methods
+ *
+ * Functional methods (like {@code compute}, {@code merge}, etc.) are performed atomically per key.
+ * The function provided is guaranteed to be invoked at most once per call under a lock specific to the
+ * entry's bin. Consequently, invoking other map modification methods on this map from within the function
+ * can lead to undefined behavior or deadlock.
+ *
+ *
+ * @param The type of mapped values (must be non-null).
+ * @see java.util.concurrent.ConcurrentHashMap
+ */
+
+public class LeafConcurrentLong2ReferenceChainedHashTable implements Iterable> {
+
+ // --- Constants ---
+
+ protected static final int DEFAULT_CAPACITY = 16;
+ protected static final float DEFAULT_LOAD_FACTOR = 0.75f;
+ /**
+ * The maximum capacity, used if a higher value is implicitly specified by either
+ * of the constructors with arguments. MUST be a power of two <= 1<<30.
+ */
+ protected static final int MAXIMUM_CAPACITY = 1 << 30; // 2^30
+
+ protected static final int THRESHOLD_NO_RESIZE = -1; // Sentinel value: table cannot be resized
+ protected static final int THRESHOLD_RESIZING = -2; // Sentinel value: table is currently resizing
+
+ // --- Instance Fields ---
+
+ /**
+ * Tracks the number of mappings, using LongAdder for better high-contention performance.
+ */
+ protected final LongAdder size = new LongAdder();
+
+ /**
+ * The load factor for the hash table.
+ */
+ protected final float loadFactor;
+
+ /**
+ * The hash table array. Elements are accessed using VarHandles.
+ */
+ protected volatile TableEntry[] table;
+
+ /**
+ * The next size value at which to resize (unless {@code <= 0}).
+ * Accessed via VarHandle {@link #THRESHOLD_HANDLE}.
+ */
+ protected volatile int threshold;
+
+ // --- VarHandles ---
+
+ protected static final VarHandle THRESHOLD_HANDLE;
+
+ static {
+ try {
+ THRESHOLD_HANDLE = ConcurrentUtil.getVarHandle(LeafConcurrentLong2ReferenceChainedHashTable.class, "threshold", int.class);
+ } catch (Throwable t) {
+ throw new Error("Failed to initialize VarHandles", t);
+ }
+ // Static initialization for TableEntry VarHandles is inside the TableEntry class
+ }
+
+ // --- Views (lazily initialized) ---
+
+ protected transient Values values;
+ protected transient EntrySet entrySet;
+
+ // --- Constructors ---
+
+ /**
+ * Creates a new, empty map with the default initial capacity (16) and load factor (0.75).
+ */
+ public LeafConcurrentLong2ReferenceChainedHashTable() {
+ this(DEFAULT_CAPACITY, DEFAULT_LOAD_FACTOR);
+ }
+
+ /**
+ * Creates a new, empty map with the specified initial capacity and load factor.
+ *
+ * @param initialCapacity The initial capacity. The implementation performs internal
+ * sizing to accommodate this many elements.
+ * @param loadFactor The load factor threshold, used to control resizing.
+ * @throws IllegalArgumentException if the initial capacity is negative or the load
+ * factor is non-positive or NaN.
+ */
+ @SuppressWarnings("unchecked")
+ protected LeafConcurrentLong2ReferenceChainedHashTable(final int initialCapacity, final float loadFactor) {
+ if (loadFactor <= 0.0f || !Float.isFinite(loadFactor)) {
+ throw new IllegalArgumentException("Invalid load factor: " + loadFactor);
+ }
+ if (initialCapacity < 0) {
+ throw new IllegalArgumentException("Invalid initial capacity: " + initialCapacity);
+ }
+
+ final int tableSize = getCapacityFor(initialCapacity);
+ this.loadFactor = loadFactor;
+ this.setThresholdPlain(getTargetThreshold(tableSize, loadFactor)); // Use plain set, happens-before established by volatile table write
+ this.table = (TableEntry[]) new TableEntry[tableSize]; // Volatile write publishes the initial state
+ }
+
+ /**
+ * Creates a new, empty map with the specified initial capacity and the default load factor (0.75).
+ *
+ * @param capacity The initial capacity.
+ * @throws IllegalArgumentException if the initial capacity is negative.
+ */
+ public static LeafConcurrentLong2ReferenceChainedHashTable createWithCapacity(final int capacity) {
+ return createWithCapacity(capacity, DEFAULT_LOAD_FACTOR);
+ }
+
+ /**
+ * Creates a new, empty map with the specified initial capacity and load factor.
+ *
+ * @param capacity The initial capacity.
+ * @param loadFactor The load factor threshold.
+ * @throws IllegalArgumentException if the initial capacity is negative or the load factor is non-positive/NaN.
+ */
+ public static LeafConcurrentLong2ReferenceChainedHashTable createWithCapacity(final int capacity, final float loadFactor) {
+ return new LeafConcurrentLong2ReferenceChainedHashTable<>(capacity, loadFactor);
+ }
+
+ /**
+ * Creates a new, empty map with an initial capacity sufficient to hold the specified number of elements
+ * without resizing, using the default load factor (0.75).
+ *
+ * @param expected The expected number of elements.
+ * @throws IllegalArgumentException if the expected size is negative.
+ */
+ public static LeafConcurrentLong2ReferenceChainedHashTable createWithExpected(final int expected) {
+ return createWithExpected(expected, DEFAULT_LOAD_FACTOR);
+ }
+
+ /**
+ * Creates a new, empty map with an initial capacity sufficient to hold the specified number of elements
+ * without resizing, using the specified load factor.
+ *
+ * @param expected The expected number of elements.
+ * @param loadFactor The load factor threshold.
+ * @throws IllegalArgumentException if the expected size is negative or the load factor is non-positive/NaN.
+ */
+ public static LeafConcurrentLong2ReferenceChainedHashTable createWithExpected(final int expected, final float loadFactor) {
+ if (expected < 0) {
+ throw new IllegalArgumentException("Invalid expected size: " + expected);
+ }
+ // Calculate initial capacity based on expected size and load factor
+ final double capacityEstimate = ((double) expected / (double) loadFactor) + 1.0;
+ final int capacity = (capacityEstimate >= (double) MAXIMUM_CAPACITY)
+ ? MAXIMUM_CAPACITY
+ : (int) Math.min(MAXIMUM_CAPACITY, Math.max(DEFAULT_CAPACITY, Math.ceil(capacityEstimate)));
+ return createWithCapacity(capacity, loadFactor);
+ }
+
+ // --- Internal Helper Methods ---
+
+ /**
+ * Calculates the target resize threshold.
+ */
+ protected static int getTargetThreshold(final int capacity, final float loadFactor) {
+ if (capacity >= MAXIMUM_CAPACITY) {
+ return THRESHOLD_NO_RESIZE; // Max capacity reached, no more resizing
+ }
+ // Calculate threshold, preventing overflow and ensuring it's at least 1
+ final double calculatedThreshold = (double) capacity * (double) loadFactor;
+ if (calculatedThreshold >= (double) MAXIMUM_CAPACITY) {
+ return MAXIMUM_CAPACITY; // Cap threshold at maximum capacity if calculation exceeds it
+ }
+ // Use ceil to ensure threshold is met strictly *after* the size reaches it
+ return (int) Math.max(1, Math.ceil(calculatedThreshold));
+ }
+
+
+ /**
+ * Calculates the power-of-two capacity for a given initial capacity request.
+ */
+ protected static int getCapacityFor(final int requestedCapacity) {
+ if (requestedCapacity <= 0) {
+ // Default capacity if non-positive requested, could also throw exception
+ return DEFAULT_CAPACITY;
+ }
+ if (requestedCapacity >= MAXIMUM_CAPACITY) {
+ return MAXIMUM_CAPACITY;
+ }
+ // Round up to the next power of two
+ return IntegerUtil.roundCeilLog2(Math.max(DEFAULT_CAPACITY, requestedCapacity));
+ }
+
+ /**
+ * Computes the hash code for the key. Uses mixing to spread keys more evenly.
+ */
+ protected static int getHash(final long key) {
+ return (int) HashUtil.mix(key); // Assumes HashUtil.mix provides good distribution
+ }
+
+ /**
+ * Returns the load factor associated with this map.
+ */
+ public final float getLoadFactor() {
+ return this.loadFactor;
+ }
+
+ // --- VarHandle Accessors for 'threshold' ---
+
+ protected final int getThresholdAcquire() {
+ return (int) THRESHOLD_HANDLE.getAcquire(this);
+ }
+
+ protected final int getThresholdVolatile() {
+ return (int) THRESHOLD_HANDLE.getVolatile(this);
+ }
+
+ protected final void setThresholdPlain(final int threshold) {
+ THRESHOLD_HANDLE.set(this, threshold);
+ }
+
+ protected final void setThresholdRelease(final int threshold) {
+ THRESHOLD_HANDLE.setRelease(this, threshold);
+ }
+
+ protected final void setThresholdVolatile(final int threshold) {
+ THRESHOLD_HANDLE.setVolatile(this, threshold);
+ }
+
+ protected final int compareExchangeThresholdVolatile(final int expect, final int update) {
+ return (int) THRESHOLD_HANDLE.compareAndExchange(this, expect, update);
+ }
+
+ // --- VarHandle Accessors for 'table' array elements ---
+
+ @SuppressWarnings("unchecked")
+ protected static TableEntry getAtIndexVolatile(final TableEntry[] table, final int index) {
+ return (TableEntry) TableEntry.TABLE_ENTRY_ARRAY_HANDLE.getVolatile(table, index);
+ }
+
+ protected static void setAtIndexRelease(final TableEntry[] table, final int index, final TableEntry value) {
+ TableEntry.TABLE_ENTRY_ARRAY_HANDLE.setRelease(table, index, value);
+ }
+
+ protected static void setAtIndexVolatile(final TableEntry[] table, final int index, final TableEntry value) {
+ TableEntry.TABLE_ENTRY_ARRAY_HANDLE.setVolatile(table, index, value);
+ }
+
+ @SuppressWarnings("unchecked")
+ protected static TableEntry compareAndExchangeAtIndexVolatile(final TableEntry[] table, final int index,
+ final TableEntry expect, final TableEntry update) {
+ return (TableEntry) TableEntry.TABLE_ENTRY_ARRAY_HANDLE.compareAndExchange(table, index, expect, update);
+ }
+
+ // --- Core Map Operations ---
+
+ /**
+ * Retrieves the node associated with the key. This is the core lookup logic.
+ * It handles concurrent resizes without locking for reads.
+ * Returns null if the key is not found.
+ * The returned node's value might be null if it's a placeholder during a compute operation.
+ */
+ protected final TableEntry getNode(final long key) {
+ final int hash = getHash(key);
+ TableEntry[] currentTable = this.table; // Volatile read
+
+ outer_loop:
+ for (;;) { // Loop handles table resizes detected during traversal
+ final int tableLength = currentTable.length;
+ if (tableLength == 0) {
+ // Table might not be initialized yet (race in constructor?), re-read.
+ currentTable = this.table;
+ if (currentTable.length == 0) {
+ // Still not initialized? Should not happen normally. Return null safely.
+ return null;
+ }
+ continue; // Retry with the initialized table
+ }
+
+ final int index = hash & (tableLength - 1); // Calculate index using mask
+ TableEntry head = getAtIndexVolatile(currentTable, index); // Volatile read of bin head
+
+ if (head == null) {
+ return null; // Bin is empty
+ }
+
+ // Check if the bin head is a resize marker
+ if (head.isResizeMarker()) {
+ currentTable = helpResizeOrGetNextTable(currentTable, head);
+ continue outer_loop; // Retry operation with the new table
+ }
+
+ // Check if the head node itself contains the key
+ // Reduces chain traversal for head hits
+ if (head.key == key) {
+ return head;
+ }
+
+ // Traverse the linked list (chain) in the bin
+ // Volatile read is necessary here to observe concurrent modifications (removals/resizes)
+ TableEntry node = head.getNextVolatile();
+ while (node != null) {
+ if (node.key == key) {
+ return node; // Key found
+ }
+ node = node.getNextVolatile(); // Move to the next node using volatile read
+ }
+
+ // Key not found in the chain.
+ // Crucial check: Re-read table reference to see if a resize occurred *during* traversal.
+ TableEntry[] latestTable = this.table; // Volatile read
+ if (currentTable != latestTable) {
+ // Table reference changed, a resize happened. Retry the whole lookup.
+ currentTable = latestTable;
+ continue outer_loop;
+ }
+
+ // Key not found, and table reference is stable since traversal started.
+ return null;
+ }
+ }
+
+ /**
+ * Helps with resizing or gets the reference to the next table if the current
+ * bin contains a resize marker.
+ */
+ @SuppressWarnings("unchecked")
+ private TableEntry[] helpResizeOrGetNextTable(TableEntry[] currentTable, TableEntry resizeMarker) {
+ // The new table reference is stored in the 'value' field of the resize marker
+ V markerValue = resizeMarker.getValuePlain(); // Plain read is safe, marker itself is effectively final
+ if (markerValue instanceof TableEntry[]) {
+ // Consider adding active resizing help here in a contended scenario
+ return (TableEntry[]) markerValue;
+ }
+ // Fallback: Should not happen if markers are correct. Force retry by re-reading table.
+ return this.table;
+ }
+
+
+ /**
+ * Returns the value to which the specified key is mapped,
+ * or {@code null} if this map contains no mapping for the key.
+ *
+ * @param key the key whose associated value is to be returned
+ * @return the value mapped to the key, or {@code null} if none
+ */
+ public V get(final long key) {
+ final TableEntry node = this.getNode(key);
+ // Use volatile read on value to ensure happens-before visibility
+ return (node == null) ? null : node.getValueVolatile();
+ }
+
+ /**
+ * Returns the value to which the specified key is mapped, or
+ * {@code defaultValue} if this map contains no mapping for the key.
+ *
+ * @param key the key whose associated value is to be returned
+ * @param defaultValue the default mapping of the key
+ * @return the value mapped to the key, or {@code defaultValue} if none
+ */
+ public V getOrDefault(final long key, final V defaultValue) {
+ final TableEntry node = this.getNode(key);
+ if (node == null) {
+ return defaultValue;
+ }
+ // Use volatile read for visibility. Check for null in case it's a compute placeholder.
+ final V value = node.getValueVolatile();
+ return (value == null) ? defaultValue : value;
+ }
+
+ /**
+ * Returns {@code true} if this map contains a mapping for the specified key.
+ *
+ * @param key The key whose presence in this map is to be tested
+ * @return {@code true} if this map contains a mapping for the specified key
+ */
+ public boolean containsKey(final long key) {
+ final TableEntry node = this.getNode(key);
+ // Must check value is non-null, as getNode might return a placeholder
+ return node != null && node.getValueVolatile() != null; // Volatile read for visibility
+ }
+
+ /**
+ * Returns {@code true} if this map maps one or more keys to the specified value.
+ * Note: This operation requires traversing the entire map.
+ *
+ * @param value value whose presence in this map is to be tested
+ * @return {@code true} if this map maps one or more keys to the specified value
+ * @throws NullPointerException if the specified value is null
+ */
+ public boolean containsValue(final V value) {
+ Validate.notNull(value, "Value cannot be null");
+ // Use an iterator that handles concurrent modifications and resizes safely.
+ NodeIterator iterator = new NodeIterator<>(this.table, this);
+ TableEntry node;
+ while ((node = iterator.findNext()) != null) { // findNext safely iterates through nodes
+ V nodeValue = node.getValueVolatile(); // Volatile read for visibility
+ if (value.equals(nodeValue)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Returns the number of key-value mappings in this map. If the
+ * number of elements exceeds {@code Integer.MAX_VALUE}, returns
+ * {@code Integer.MAX_VALUE}.
+ *
+ * @return the number of key-value mappings in this map
+ */
+ public int size() {
+ final long ret = this.size.sum();
+ // Cap the size at Integer.MAX_VALUE as per ConcurrentMap contract
+ return (ret >= (long) Integer.MAX_VALUE) ? Integer.MAX_VALUE : (int) ret;
+ }
+
+ /**
+ * Returns {@code true} if this map contains no key-value mappings.
+ *
+ * @return {@code true} if this map contains no key-value mappings
+ */
+ public boolean isEmpty() {
+ // Check size first for a quick exit, but verify with iteration if size is 0
+ // as LongAdder.sum() might be transiently inaccurate.
+ if (this.size.sum() > 0L) {
+ return false;
+ }
+ // If size reports 0, double-check by looking for any actual node
+ NodeIterator it = new NodeIterator<>(this.table, this);
+ return it.findNext() == null;
+ }
+
+ /**
+ * Increments the size count and initiates resizing if the threshold is exceeded.
+ */
+ protected final void addSize(final long count) {
+ this.size.add(count);
+ int currentThreshold;
+ do {
+ currentThreshold = this.getThresholdAcquire(); // Acquire fence for reading threshold
+ if (currentThreshold <= 0) return; // THRESHOLD_NO_RESIZE or THRESHOLD_RESIZING
+
+ final long currentSum = this.size.sum(); // Get current estimated size
+ if (currentSum < (long) currentThreshold) {
+ // Double check threshold hasn't changed due to another thread finishing resize
+ if (currentThreshold == this.getThresholdVolatile()) return;
+ continue; // Threshold changed, retry the loop
+ }
+
+ // Size exceeds threshold, attempt to initiate resize
+ if (this.compareExchangeThresholdVolatile(currentThreshold, THRESHOLD_RESIZING) == currentThreshold) {
+ this.resize(currentSum); // Pass estimated size
+ return; // Resize initiated or completed
+ }
+ // CAS failed, another thread initiated resize. Loop might retry.
+ } while (true);
+ }
+
+ /**
+ * Decrements the size count.
+ */
+ protected final void subSize(final long count) {
+ this.size.add(-count);
+ // Note: No resize check needed on removal
+ }
+
+ /**
+ * Resizes the table to accommodate more entries. Called by the thread
+ * that successfully sets the threshold to THRESHOLD_RESIZING.
+ */
+ @SuppressWarnings("unchecked")
+ private void resize(final long estimatedSize) { // estimatedSize might not be perfectly accurate
+ final TableEntry[] oldTable = this.table; // Volatile read
+ final int oldCapacity = oldTable.length;
+
+ if (oldCapacity >= MAXIMUM_CAPACITY) {
+ this.setThresholdVolatile(THRESHOLD_NO_RESIZE);
+ return;
+ }
+
+ int newCapacity = oldCapacity << 1; // Double the capacity
+ if (newCapacity <= oldCapacity || newCapacity > MAXIMUM_CAPACITY) { // Handle overflow or max
+ newCapacity = MAXIMUM_CAPACITY;
+ }
+ if (newCapacity == oldCapacity) { // Already maxed out
+ this.setThresholdVolatile(THRESHOLD_NO_RESIZE);
+ return;
+ }
+
+ final int newThreshold = getTargetThreshold(newCapacity, this.loadFactor);
+ final TableEntry[] newTable = (TableEntry[]) new TableEntry[newCapacity];
+ final TableEntry resizeMarker = new TableEntry<>(0L, (V) newTable, true); // Key irrelevant for marker
+
+ for (int i = 0; i < oldCapacity; ++i) {
+ TableEntry head = getAtIndexVolatile(oldTable, i);
+
+ if (head == null) {
+ // Try to CAS marker into empty bin
+ if (compareAndExchangeAtIndexVolatile(oldTable, i, null, resizeMarker) == null) {
+ continue; // Marked empty bin
+ }
+ // CAS failed, re-read
+ head = getAtIndexVolatile(oldTable, i);
+ if (head == null || head.isResizeMarker()) continue; // Still null or handled
+ }
+
+ if (head.isResizeMarker()) {
+ continue; // Already processed
+ }
+
+ // Bin has entries, lock head to transfer chain
+ synchronized (head) {
+ TableEntry currentHead = getAtIndexVolatile(oldTable, i);
+ // Re-check after lock
+ if (currentHead != head) {
+ i--; // Reprocess index 'i' if head changed while waiting
+ continue;
+ }
+ if (head.isResizeMarker()) {
+ continue; // Marked while waiting
+ }
+
+ // Split chain: index 'i' vs 'i + oldCapacity'
+ TableEntry lowH = null, lowT = null;
+ TableEntry highH = null, highT = null;
+
+ TableEntry current = head;
+ while (current != null) {
+ TableEntry next = current.getNextPlain(); // Plain read inside lock
+ int hash = getHash(current.key);
+
+ if ((hash & oldCapacity) == 0) { // Low bin (index i)
+ if (lowT == null) lowH = current;
+ else lowT.setNextPlain(current);
+ lowT = current;
+ } else { // High bin (index i + oldCapacity)
+ if (highT == null) highH = current;
+ else highT.setNextPlain(current);
+ highT = current;
+ }
+ current = next;
+ }
+
+ if (lowT != null) lowT.setNextPlain(null);
+ if (highT != null) highT.setNextPlain(null);
+
+ // Place chains into new table (volatile writes)
+ setAtIndexVolatile(newTable, i, lowH);
+ setAtIndexVolatile(newTable, i + oldCapacity, highH);
+
+ // Mark old bin as processed (release write)
+ setAtIndexRelease(oldTable, i, resizeMarker);
+ } // End synchronized
+ } // End loop over old table bins
+
+ // Finalize: publish new table and threshold
+ this.table = newTable;
+ this.setThresholdVolatile(newThreshold);
+ }
+
+
+ /**
+ * Maps the specified key to the specified value in this table.
+ * Neither the key nor the value can be null.
+ *
+ * @param key key with which the specified value is to be associated
+ * @param value value to be associated with the specified key
+ * @return the previous value associated with {@code key}, or
+ * {@code null} if there was no mapping for {@code key}.
+ * @throws NullPointerException if the specified value is null
+ */
+ public V put(final long key, final V value) {
+ Validate.notNull(value, "Value may not be null");
+ final int hash = getHash(key);
+ int sizeDelta;
+ V oldValue;
+ TableEntry[] currentTable = this.table;
+
+ table_loop:
+ for (;;) {
+ final int tableLength = currentTable.length;
+ // Init check
+ if (tableLength == 0) {
+ currentTable = this.table;
+ if (currentTable.length == 0) continue;
+ }
+
+ final int index = hash & (tableLength - 1);
+ TableEntry head = getAtIndexVolatile(currentTable, index);
+
+ // Case 1: Bin is empty
+ if (head == null) {
+ TableEntry newNode = new TableEntry<>(key, value);
+ if (compareAndExchangeAtIndexVolatile(currentTable, index, null, newNode) == null) {
+ this.addSize(1L);
+ return null; // Inserted successfully
+ }
+ continue table_loop; // CAS failed, retry
+ }
+
+ // Case 2: Resize marker
+ if (head.isResizeMarker()) {
+ currentTable = helpResizeOrGetNextTable(currentTable, head);
+ continue table_loop;
+ }
+
+ // Case 3: Optimistic lock-free update attempt
+ TableEntry node = head;
+ while (node != null) {
+ if (node.key == key) {
+ V currentVal = node.getValueVolatile(); // Volatile read
+ if (currentVal == null) break; // Placeholder requires lock
+ // Try atomic update
+ if (node.compareAndSetValueVolatile(currentVal, value)) {
+ return currentVal; // Lock-free success
+ }
+ break; // CAS failed, need lock
+ }
+ node = node.getNextVolatile(); // Volatile read
+ }
+
+ // Case 4: Locking path
+ synchronized (head) {
+ TableEntry currentHead = getAtIndexVolatile(currentTable, index);
+ // Re-check state after lock
+ if (currentHead != head || head.isResizeMarker()) {
+ continue table_loop;
+ }
+
+ // Traverse again within lock
+ TableEntry prev = null;
+ node = head;
+ while (node != null) {
+ if (node.key == key) {
+ oldValue = node.getValuePlain(); // Plain read in lock
+ node.setValueVolatile(value); // Volatile write for visibility
+ sizeDelta = (oldValue == null) ? 1 : 0; // Adjust size if replacing placeholder
+ break table_loop; // Update done
+ }
+ prev = node;
+ node = node.getNextPlain(); // Plain read in lock
+ }
+
+ // Key not found, add new node to end of chain
+ if (prev != null) {
+ TableEntry newNode = new TableEntry<>(key, value);
+ prev.setNextRelease(newNode); // Release write to link safely
+ sizeDelta = 1;
+ oldValue = null;
+ } else {
+ continue table_loop; // Should not happen if head was non-null/non-marker. Retry.
+ }
+ } // End synchronized
+ break table_loop; // Operation completed within lock
+ } // End table_loop
+
+ if (sizeDelta != 0) {
+ this.addSize(sizeDelta);
+ }
+ return oldValue;
+ }
+
+
+ /**
+ * If the specified key is not already associated with a value, associates
+ * it with the given value.
+ *
+ * @param key key with which the specified value is to be associated
+ * @param value value to be associated with the specified key
+ * @return the previous value associated with the specified key, or
+ * {@code null} if there was no mapping for the key.
+ * @throws NullPointerException if the specified value is null
+ */
+ public V putIfAbsent(final long key, final V value) {
+ Validate.notNull(value, "Value may not be null");
+ final int hash = getHash(key);
+ int sizeDelta = 0;
+ V existingValue;
+ TableEntry[] currentTable = this.table;
+
+ table_loop:
+ for (;;) {
+ final int tableLength = currentTable.length;
+ if (tableLength == 0) {
+ currentTable = this.table;
+ continue;
+ }
+
+ final int index = hash & (tableLength - 1);
+ TableEntry head = getAtIndexVolatile(currentTable, index);
+
+ // Case 1: Bin is empty
+ if (head == null) {
+ TableEntry newNode = new TableEntry<>(key, value);
+ if (compareAndExchangeAtIndexVolatile(currentTable, index, null, newNode) == null) {
+ this.addSize(1L);
+ return null; // Inserted
+ }
+ continue table_loop; // CAS failed, retry
+ }
+
+ // Case 2: Resize marker
+ if (head.isResizeMarker()) {
+ currentTable = helpResizeOrGetNextTable(currentTable, head);
+ continue table_loop;
+ }
+
+ // Case 3: Lock-free check (optimistic)
+ TableEntry node = head;
+ while (node != null) {
+ if (node.key == key) {
+ existingValue = node.getValueVolatile(); // Volatile read
+ if (existingValue != null) {
+ return existingValue; // Key present with value
+ }
+ // Placeholder found, need lock
+ break;
+ }
+ node = node.getNextVolatile();
+ }
+
+
+ // Case 4: Locking path
+ synchronized (head) {
+ TableEntry currentHead = getAtIndexVolatile(currentTable, index);
+ if (currentHead != head || head.isResizeMarker()) {
+ continue table_loop; // State changed, retry
+ }
+
+ TableEntry prev = null;
+ node = head;
+ while (node != null) {
+ if (node.key == key) {
+ existingValue = node.getValuePlain(); // Plain read in lock
+ if (existingValue != null) {
+ break table_loop; // Return existing value
+ } else {
+ // Placeholder: update it
+ node.setValueVolatile(value); // Volatile write
+ sizeDelta = 1;
+ existingValue = null; // Return null as per contract
+ break table_loop;
+ }
+ }
+ prev = node;
+ node = node.getNextPlain(); // Plain read in lock
+ }
+
+ // Key not found, add new node
+ if (prev != null) {
+ TableEntry newNode = new TableEntry<>(key, value);
+ prev.setNextRelease(newNode); // Release write
+ sizeDelta = 1;
+ existingValue = null;
+ } else {
+ continue table_loop; // Should not happen
+ }
+ } // End synchronized
+ break table_loop;
+ } // End table_loop
+
+ if (sizeDelta != 0) {
+ this.addSize(sizeDelta);
+ }
+ return existingValue;
+ }
+
+ /**
+ * Replaces the entry for a key only if currently mapped to some value.
+ *
+ * @param key key with which the specified value is associated
+ * @param value value to be associated with the specified key
+ * @return the previous value associated with the specified key, or
+ * {@code null} if there was no mapping for the key.
+ * @throws NullPointerException if the specified value is null
+ */
+ public V replace(final long key, final V value) {
+ Validate.notNull(value, "Value may not be null");
+ final int hash = getHash(key);
+ V oldValue;
+ TableEntry[] currentTable = this.table;
+
+ table_loop:
+ for (;;) {
+ final int tableLength = currentTable.length;
+ if (tableLength == 0) return null;
+
+ final int index = hash & (tableLength - 1);
+ TableEntry head = getAtIndexVolatile(currentTable, index);
+
+ if (head == null) return null;
+
+ if (head.isResizeMarker()) {
+ currentTable = helpResizeOrGetNextTable(currentTable, head);
+ continue table_loop;
+ }
+
+ // Try Lock-Free Replace Attempt
+ TableEntry node = head;
+ while (node != null) {
+ if (node.key == key) {
+ do { // CAS retry loop
+ oldValue = node.getValueVolatile(); // Volatile read
+ if (oldValue == null) return null; // Cannot replace placeholder
+
+ if (node.compareAndSetValueVolatile(oldValue, value)) {
+ return oldValue; // Lock-free success
+ }
+ // CAS failed, retry if key still matches
+ } while (node.key == key);
+ // Key changed or CAS keeps failing, fall back to lock
+ break;
+ }
+ node = node.getNextVolatile();
+ }
+
+ // Locking Path
+ synchronized (head) {
+ TableEntry currentHead = getAtIndexVolatile(currentTable, index);
+ if (currentHead != head || head.isResizeMarker()) {
+ continue table_loop; // Retry
+ }
+ node = head;
+ while (node != null) {
+ if (node.key == key) {
+ oldValue = node.getValuePlain(); // Plain read in lock
+ if (oldValue != null) {
+ node.setValueVolatile(value); // Volatile write
+ return oldValue;
+ } else {
+ return null; // Cannot replace placeholder
+ }
+ }
+ node = node.getNextPlain(); // Plain read in lock
+ }
+ } // End synchronized
+
+ // Key not found after checks
+ return null;
+ } // End table_loop
+ }
+
+ /**
+ * Replaces the entry for a key only if currently mapped to a given value.
+ *
+ * @param key key with which the specified value is associated
+ * @param expect value expected to be associated with the specified key
+ * @param update value to be associated with the specified key
+ * @return {@code true} if the value was replaced
+ * @throws NullPointerException if {@code expect} or {@code update} is null
+ */
+ public boolean replace(final long key, final V expect, final V update) {
+ Validate.notNull(expect, "Expected value may not be null");
+ Validate.notNull(update, "Update value may not be null");
+ final int hash = getHash(key);
+ TableEntry[] currentTable = this.table;
+
+ table_loop:
+ for (;;) {
+ final int tableLength = currentTable.length;
+ if (tableLength == 0) return false;
+
+ final int index = hash & (tableLength - 1);
+ TableEntry head = getAtIndexVolatile(currentTable, index);
+
+ if (head == null) return false;
+
+ if (head.isResizeMarker()) {
+ currentTable = helpResizeOrGetNextTable(currentTable, head);
+ continue table_loop;
+ }
+
+ // Lock-Free CAS Attempt
+ TableEntry node = head;
+ while (node != null) {
+ if (node.key == key) {
+ V currentVal = node.getValueVolatile(); // Volatile read
+ if (!Objects.equals(currentVal, expect)) {
+ return false; // Value doesn't match
+ }
+ // Value matches, try CAS
+ if (node.compareAndSetValueVolatile(expect, update)) {
+ return true; // Lock-free success
+ }
+ // CAS failed, need lock
+ break;
+ }
+ node = node.getNextVolatile();
+ }
+
+ // Locking Path
+ synchronized (head) {
+ TableEntry currentHead = getAtIndexVolatile(currentTable, index);
+ if (currentHead != head || head.isResizeMarker()) {
+ continue table_loop; // Retry
+ }
+ node = head;
+ while (node != null) {
+ if (node.key == key) {
+ V currentVal = node.getValuePlain(); // Plain read in lock
+ if (Objects.equals(currentVal, expect)) {
+ node.setValueVolatile(update); // Volatile write
+ return true; // Replaced successfully
+ } else {
+ return false; // Value doesn't match
+ }
+ }
+ node = node.getNextPlain(); // Plain read in lock
+ }
+ } // End synchronized
+
+ // Key not found
+ return false;
+ } // End table_loop
+ }
+
+ /**
+ * Removes the mapping for a key from this map if it is present.
+ *
+ * @param key key whose mapping is to be removed from the map
+ * @return the previous value associated with {@code key}, or
+ * {@code null} if there was no mapping for {@code key}
+ */
+ public V remove(final long key) {
+ final int hash = getHash(key);
+ int sizeDelta = 0;
+ V oldValue = null;
+ TableEntry[] currentTable = this.table;
+
+ table_loop:
+ for (;;) {
+ final int tableLength = currentTable.length;
+ if (tableLength == 0) return null;
+
+ final int index = hash & (tableLength - 1);
+ TableEntry head = getAtIndexVolatile(currentTable, index);
+
+ if (head == null) return null;
+
+ if (head.isResizeMarker()) {
+ currentTable = helpResizeOrGetNextTable(currentTable, head);
+ continue table_loop;
+ }
+
+ // Removal needs locking
+ synchronized (head) {
+ TableEntry currentHead = getAtIndexVolatile(currentTable, index);
+ if (currentHead != head || head.isResizeMarker()) {
+ continue table_loop; // Retry
+ }
+
+ TableEntry prev = null;
+ TableEntry node = head;
+ while (node != null) {
+ if (node.key == key) {
+ oldValue = node.getValuePlain(); // Plain read in lock
+ sizeDelta = (oldValue != null) ? -1 : 0; // Decrement if actual mapping
+
+ TableEntry next = node.getNextPlain(); // Plain read
+ // Update links with release semantics
+ if (prev == null) {
+ setAtIndexRelease(currentTable, index, next); // Removed head
+ } else {
+ prev.setNextRelease(next); // Removed middle/end
+ }
+ break table_loop; // Removed, exit loop
+ }
+ prev = node;
+ node = node.getNextPlain(); // Plain read
+ }
+ // Key not found in chain within lock
+ break table_loop;
+ } // End synchronized
+ } // End table_loop
+
+ if (sizeDelta != 0) {
+ this.subSize(-sizeDelta); // subSize takes positive count
+ }
+ return oldValue;
+ }
+
+
+ /**
+ * Removes the entry for a key only if currently mapped to a given value.
+ *
+ * @param key key with which the specified value is associated
+ * @param expect value expected to be associated with the specified key
+ * @return {@code true} if the value was removed
+ */
+ public boolean remove(final long key, final V expect) {
+ final int hash = getHash(key);
+ int sizeDelta = 0;
+ boolean removed = false;
+ TableEntry