HashSlotArrayBase (Hazelcast Root 3.12.9 API)

java.lang.Object
- com.hazelcast.internal.util.hashslot.impl.HashSlotArrayBase

All Implemented Interfaces:

HashSlotArray, Disposable

Direct Known Subclasses:

HashSlotArray12byteKeyImpl, HashSlotArray16byteKeyImpl, HashSlotArray8byteKeyImpl
```
public abstract class HashSlotArrayBase
extends Object
implements HashSlotArray
```
Implementation of HashSlotArray, common to all its subtype implementations.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected class`	`HashSlotArrayBase.Cursor`
`protected class`	`HashSlotArrayBase.CursorIntKey2`
`protected class`	`HashSlotArrayBase.CursorLongKey2`

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`CAPACITY_OFFSET`
`static int`	`EXPAND_THRESHOLD_OFFSET`
`static int`	`HEADER_SIZE`
`protected static int`	`KEY_1_OFFSET`
`protected static int`	`KEY_2_OFFSET`
`protected long`	`offsetOfUnassignedSentinel` Offset (from the slot's base address) where the unassigned sentinel value is to be found.
`static int`	`SIZE_OFFSET`
`protected int`	`slotLength` Total length of an array slot in bytes.
`protected long`	`unassignedSentinel` Sentinel value that marks a slot as "unassigned".
`protected static int`	`VALUE_SIZE_GRANULARITY`

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`HashSlotArrayBase(long unassignedSentinel, long offsetOfUnassignedSentinel, MemoryManager mm, MemoryAllocator auxMalloc, int keyLength, int valueLength, int initialCapacity, float loadFactor)` Constructs a new `HashSlotArrayImpl` with the given initial capacity and the load factor.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`long`	`address()`
`protected void`	`allocateArrayAndAdjustFields(long size, long newCapacity)`
`protected void`	`assertValid()`
`long`	`capacity()`
`void`	`clear()` After this method returns, all slots in the current hash slot array are unassigned.
`void`	`dispose()` Disposes this object and releases any data and/or resources associated with it.
`protected SlotAssignmentResult`	`ensure0(long key1, long key2)`
`protected boolean`	`equal(long key1a, long key2a, long key1b, long key2b)`
`long`	`expansionThreshold()` Array expansion and rehashing will be triggered when `size` reaches this value.
`protected long`	`get0(long key1, long key2)`
`void`	`gotoAddress(long address)` Position this flyweight to the supplied base address.
`long`	`gotoNew()` Allocate a new array and position this flyweight to its base address.
`protected boolean`	`isAssigned(long baseAddress, long slot)`
`protected long`	`key1OfSlot(long baseAddress, long slot)`
`protected long`	`key2OfSlot(long baseAddress, long slot)`
`protected long`	`keyHash(long key1, long key2)`
`protected MemoryAllocator`	`malloc()`
`protected void`	`markUnassigned(long baseAddress, long slot)`
`protected MemoryAccessor`	`mem()`
`void`	`migrateTo(MemoryAllocator newMalloc)` Migrates the backing memory region to a new allocator, freeing the current region.
`protected void`	`putKey(long baseAddress, long slot, long key1, long key2)`
`protected void`	`rehash(long oldCapacity, long oldAddress)`
`protected boolean`	`remove0(long key1, long key2)`
`protected void`	`resizeTo(long newCapacity)` Allocates a new slot array with the requested size and moves all the assigned slots from the current array into the new one.
`protected void`	`setMemMgr(MemoryManager memoryManager)`
`protected void`	`shiftConflictingKeys(long slotCurr)` Shift all the slot-conflicting keys allocated to (and including) `slot`.
`long`	`size()`
`protected long`	`slotBase(long baseAddr, long slot)`
`protected long`	`slotHash(long baseAddress, long slot)`
`boolean`	`trimToSize()` Compact the array by reducing its capacity, if allowed by the current size and load factor.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - HEADER_SIZE
```
public static final int HEADER_SIZE
```
    See Also:
    
    Constant Field Values
  - CAPACITY_OFFSET
```
public static final int CAPACITY_OFFSET
```
    See Also:
    
    Constant Field Values
  - SIZE_OFFSET
```
public static final int SIZE_OFFSET
```
    See Also:
    
    Constant Field Values
  - EXPAND_THRESHOLD_OFFSET
```
public static final int EXPAND_THRESHOLD_OFFSET
```
    See Also:
    
    Constant Field Values
  - VALUE_SIZE_GRANULARITY
```
protected static final int VALUE_SIZE_GRANULARITY
```
    See Also:
    
    Constant Field Values
  - KEY_1_OFFSET
```
protected static final int KEY_1_OFFSET
```
    See Also:
    
    Constant Field Values
  - KEY_2_OFFSET
```
protected static final int KEY_2_OFFSET
```
    See Also:
    
    Constant Field Values
  - unassignedSentinel
```
protected final long unassignedSentinel
```
    Sentinel value that marks a slot as "unassigned".
  - offsetOfUnassignedSentinel
```
protected final long offsetOfUnassignedSentinel
```
    Offset (from the slot's base address) where the unassigned sentinel value is to be found.
  - slotLength
```
protected final int slotLength
```
    Total length of an array slot in bytes.
- Constructor Detail
  - HashSlotArrayBase
```
protected HashSlotArrayBase(long unassignedSentinel,
                            long offsetOfUnassignedSentinel,
                            MemoryManager mm,
                            MemoryAllocator auxMalloc,
                            int keyLength,
                            int valueLength,
                            int initialCapacity,
                            float loadFactor)
```
    Constructs a new HashSlotArrayImpl with the given initial capacity and the load factor. valueLength must be a factor of 8. Does not allocate any memory, therefore the instance is unusable until one of the goto... methods is called.
    
    Parameters:
    
    unassignedSentinel - the value to be used to mark an unassigned slot
    
    offsetOfUnassignedSentinel - offset (from each slot's base address) where the unassigned sentinel is kept
    
    mm - the memory manager
    
    auxMalloc - memory allocator to use for temporary storage during resizing. Its memory must be accessible by the supplied memory manager's accessor.
    
    keyLength - length of key in bytes
    
    valueLength - length of value in bytes
    
    initialCapacity - Initial capacity of map (will be rounded to closest power of 2, if not already)
- Method Detail
  - address
```
public final long address()
```
    Specified by:
    
    address in interface HashSlotArray
    
    Returns:
    
    current base address of this flyweight
  - gotoAddress
```
public final void gotoAddress(long address)
```
    Description copied from interface: HashSlotArray
    
    Position this flyweight to the supplied base address.
    
    Specified by:
    
    gotoAddress in interface HashSlotArray
  - gotoNew
```
public final long gotoNew()
```
    Description copied from interface: HashSlotArray
    
    Allocate a new array and position this flyweight to its base address.
    
    Specified by:
    
    gotoNew in interface HashSlotArray
    
    Returns:
    
    the base address of the new array.
  - size
```
public final long size()
```
    Specified by:
    
    size in interface HashSlotArray
    
    Returns:
    
    the number of assigned slots in the current hash slot array
  - capacity
```
public final long capacity()
```
    Specified by:
    
    capacity in interface HashSlotArray
    
    Returns:
    
    the total number of slots in the current hash slot array
  - expansionThreshold
```
public final long expansionThreshold()
```
    Description copied from interface: HashSlotArray
    
    Array expansion and rehashing will be triggered when size reaches this value.
    
    Specified by:
    
    expansionThreshold in interface HashSlotArray
  - clear
```
public final void clear()
```
    Description copied from interface: HashSlotArray
    
    After this method returns, all slots in the current hash slot array are unassigned.
    
    Specified by:
    
    clear in interface HashSlotArray
  - trimToSize
```
public final boolean trimToSize()
```
    Description copied from interface: HashSlotArray
    
    Compact the array by reducing its capacity, if allowed by the current size and load factor.
    
    Specified by:
    
    trimToSize in interface HashSlotArray
    
    Returns:
    
    true if the array was compacted; false if no action was taken.
  - dispose
```
public final void dispose()
```
    Description copied from interface: Disposable
    
    Disposes this object and releases any data and/or resources associated with it. If this object is already disposed then invoking this method has no effect.
    
    Specified by:
    
    dispose in interface Disposable
  - migrateTo
```
public final void migrateTo(MemoryAllocator newMalloc)
```
    Migrates the backing memory region to a new allocator, freeing the current region. Memory allocated by the new allocator must be accessible by the same accessor as the current one.
  - ensure0
```
protected final SlotAssignmentResult ensure0(long key1,
                                             long key2)
```
  - get0
```
protected final long get0(long key1,
                          long key2)
```
  - remove0
```
protected final boolean remove0(long key1,
                                long key2)
```
  - shiftConflictingKeys
```
protected final void shiftConflictingKeys(long slotCurr)
```
    Shift all the slot-conflicting keys allocated to (and including) slot.
  - allocateArrayAndAdjustFields
```
protected final void allocateArrayAndAdjustFields(long size,
                                                  long newCapacity)
```
  - rehash
```
protected final void rehash(long oldCapacity,
                            long oldAddress)
```
  - setMemMgr
```
protected final void setMemMgr(MemoryManager memoryManager)
```
  - assertValid
```
protected final void assertValid()
```
  - malloc
```
protected final MemoryAllocator malloc()
```
  - mem
```
protected final MemoryAccessor mem()
```
  - slotBase
```
protected final long slotBase(long baseAddr,
                              long slot)
```
  - resizeTo
```
protected void resizeTo(long newCapacity)
```
    Allocates a new slot array with the requested size and moves all the assigned slots from the current array into the new one.
  - key1OfSlot
```
protected long key1OfSlot(long baseAddress,
                          long slot)
```
  - key2OfSlot
```
protected long key2OfSlot(long baseAddress,
                          long slot)
```
  - isAssigned
```
protected boolean isAssigned(long baseAddress,
                             long slot)
```
  - markUnassigned
```
protected void markUnassigned(long baseAddress,
                              long slot)
```
  - putKey
```
protected void putKey(long baseAddress,
                      long slot,
                      long key1,
                      long key2)
```
  - keyHash
```
protected long keyHash(long key1,
                       long key2)
```
  - slotHash
```
protected long slotHash(long baseAddress,
                        long slot)
```
  - equal
```
protected boolean equal(long key1a,
                        long key2a,
                        long key1b,
                        long key2b)
```

Class HashSlotArrayBase

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

HEADER_SIZE

CAPACITY_OFFSET

SIZE_OFFSET

EXPAND_THRESHOLD_OFFSET

VALUE_SIZE_GRANULARITY

KEY_1_OFFSET

KEY_2_OFFSET

unassignedSentinel

offsetOfUnassignedSentinel

slotLength

Constructor Detail

HashSlotArrayBase

Method Detail

address

gotoAddress

gotoNew

size

capacity

expansionThreshold

clear

trimToSize

dispose

migrateTo

ensure0

get0

remove0

shiftConflictingKeys

allocateArrayAndAdjustFields

rehash

setMemMgr

assertValid

malloc

mem

slotBase

resizeTo

key1OfSlot

key2OfSlot

isAssigned

markUnassigned

putKey

keyHash

slotHash

equal