CompiledReplicatedMapIterationContext (OpenHFT/Chronicle-Map 3.3.0-beta API)

java.lang.Object
- net.openhft.chronicle.hash.impl.stage.hash.ThreadLocalState
- - net.openhft.chronicle.hash.impl.stage.hash.ChainingInterface
  - - net.openhft.chronicle.map.impl.CompiledReplicatedMapIterationContext<K,V,R>

All Implemented Interfaces:

Closeable, AutoCloseable, ReadWriteLock, ChecksumEntry, HashAbsentEntry<K>, HashContext<K>, HashEntry<K>, HashSegmentContext<K,MapEntry<K,V>>, net.openhft.chronicle.hash.impl.stage.entry.Alloc, net.openhft.chronicle.hash.impl.stage.entry.KeyHashCode, net.openhft.chronicle.hash.impl.stage.entry.LocksInterface, net.openhft.chronicle.hash.impl.VanillaChronicleHashHolder<K>, InterProcessReadWriteUpdateLock, ReplicatedHashSegmentContext<K,MapEntry<K,V>>, RemoteOperationContext<K>, ReplicableEntry, SegmentLock, DefaultValueProvider<K,V>, net.openhft.chronicle.map.impl.IterationContext<K,V,R>, net.openhft.chronicle.map.impl.ReplicatedChronicleMapHolder<K,V,R>, net.openhft.chronicle.map.impl.ReplicatedIterationContext<K,V,R>, net.openhft.chronicle.map.impl.VanillaChronicleMapHolder<K,V,R>, MapAbsentEntry<K,V>, MapContext<K,V,R>, MapEntry<K,V>, MapEntryOperations<K,V,R>, MapSegmentContext<K,V,R>, MapReplicableEntry<K,V>, SetAbsentEntry<K>, SetContext<K,R>, SetEntryOperations<K,R>
```
public class CompiledReplicatedMapIterationContext<K,V,R>
extends net.openhft.chronicle.hash.impl.stage.hash.ChainingInterface
implements AutoCloseable, ChecksumEntry, HashEntry<K>, HashSegmentContext<K,MapEntry<K,V>>, ReplicatedHashSegmentContext<K,MapEntry<K,V>>, SegmentLock, net.openhft.chronicle.hash.impl.stage.entry.Alloc, net.openhft.chronicle.hash.impl.stage.entry.KeyHashCode, net.openhft.chronicle.hash.impl.stage.entry.LocksInterface, RemoteOperationContext<K>, ReplicableEntry, MapAbsentEntry<K,V>, MapContext<K,V,R>, MapEntry<K,V>, net.openhft.chronicle.map.impl.IterationContext<K,V,R>, net.openhft.chronicle.map.impl.ReplicatedChronicleMapHolder<K,V,R>, net.openhft.chronicle.map.impl.ReplicatedIterationContext<K,V,R>, MapReplicableEntry<K,V>, SetAbsentEntry<K>, SetContext<K,R>
```

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`class`	`CompiledReplicatedMapIterationContext.DummyValueZeroData`
`class`	`CompiledReplicatedMapIterationContext.EntryKeyBytesData`
`class`	`CompiledReplicatedMapIterationContext.EntryValueBytesData`
`class`	`CompiledReplicatedMapIterationContext.HashEntryChecksumStrategy`
`class`	`CompiledReplicatedMapIterationContext.ReadLock`
`class`	`CompiledReplicatedMapIterationContext.ReplicatedMapAbsentDelegatingForIteration`
`class`	`CompiledReplicatedMapIterationContext.ReplicatedMapEntryDelegating`
`static class`	`CompiledReplicatedMapIterationContext.SearchState`
`class`	`CompiledReplicatedMapIterationContext.UpdateLock`
`class`	`CompiledReplicatedMapIterationContext.WrappedValueInstanceDataHolder`
`class`	`CompiledReplicatedMapIterationContext.WriteLock`

Field Summary

Fields
Modifier and Type	Field and Description
`int`	`allocatedChunks`
`net.openhft.chronicle.hash.impl.stage.entry.ChecksumStrategy`	`checksumStrategy`
`List<net.openhft.chronicle.hash.impl.stage.hash.ChainingInterface>`	`contextChain`
`int`	`contextModCount`
`boolean`	`delayedUpdateChecksum`
`boolean`	`entryRemovedOnThisIteration`
`int`	`entrySizeInChunks`
`CompiledReplicatedMapIterationContext.EntryValueBytesData`	`entryValue`
`long`	`hashLookupEntry`
`long`	`hashLookupPos`
`int`	`indexInContextChain`
`CompiledReplicatedMapIterationContext.ReadLock`	`innerReadLock`
`byte`	`innerRemoteIdentifier`
`long`	`innerRemoteTimestamp`
`CompiledReplicatedMapIterationContext.UpdateLock`	`innerUpdateLock`
`CompiledReplicatedMapIterationContext.WriteLock`	`innerWriteLock`
`Data<K>`	`inputKey`
`long`	`keyOffset`
`SizedReader<K>`	`keyReader`
`long`	`keySize`
`long`	`keySizeOffset`
`int`	`latestSameThreadSegmentModCount`
`static org.slf4j.Logger`	`LOG`
`boolean`	`nestedContextsLockedOnSameSegment`
`long`	`pos`
`net.openhft.chronicle.hash.impl.stage.hash.ChainingInterface`	`rootContextInThisThread`
`net.openhft.chronicle.hash.impl.stage.entry.LocksInterface`	`rootContextLockedOnThisSegment`
`long`	`searchStartPos`
`protected CompiledReplicatedMapIterationContext.SearchState`	`searchState`
`PointerBytesStore`	`segmentBS`
`Bytes`	`segmentBytes`
`int`	`segmentIndex`
`int`	`tier`
`long`	`tierBaseAddr`
`long`	`tierIndex`
`long`	`valueOffset`
`SizedReader<V>`	`valueReader`
`long`	`valueSize`
`long`	`valueSizeOffset`

Fields inherited from class net.openhft.chronicle.hash.impl.stage.hash.ThreadLocalState
iterationContextLockedInThisThread

Constructor Summary

Constructors
Constructor and Description
`CompiledReplicatedMapIterationContext(net.openhft.chronicle.hash.impl.stage.hash.ChainingInterface c, net.openhft.chronicle.map.ReplicatedChronicleMap<K,V,R> m)`
`CompiledReplicatedMapIterationContext(net.openhft.chronicle.map.ReplicatedChronicleMap<K,V,R> m)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`CompiledReplicatedMapIterationContext.ReplicatedMapAbsentDelegatingForIteration`	`absentEntryDelegating()`
`Data<K>`	`absentKey()` Returns the key is going to be inserted into the `ChronicleHash`.
`long`	`alloc(int chunks, long prevPos, int prevChunks)` Allocates a block of specified number of chunks in a segment tier, optionally clears the previous allocation.
`int`	`allocatedChunks()`
`boolean`	`allocatedChunksInit()`
`long`	`allocReturnCode(int chunks)`
`long`	`allocReturnCodeGuarded(int chunks)`
`int`	`changeAndGetLatestSameThreadSegmentModCount(int change)`
`int`	`changeAndGetTotalReadLockCount(int change)`
`int`	`changeAndGetTotalUpdateLockCount(int change)`
`int`	`changeAndGetTotalWriteLockCount(int change)`
`boolean`	`changed()`
`void`	`checkAccessingFromOwnerThread()`
`void`	`checkEntryNotRemovedOnThisIteration()`
`void`	`checkIterationContextNotLockedInThisThread()`
`void`	`checkNestedContextsQueryDifferentKeys(net.openhft.chronicle.hash.impl.stage.entry.LocksInterface innermostContextOnThisSegment)`
`void`	`checkOnEachPublicOperation()`
`boolean`	`checkSlotContainsExpectedKeyAndValue(long value)`
`boolean`	`checkSum()` Computes checksum from the entry bytes and checks whether it is equal to the stored checksum.
`net.openhft.chronicle.hash.impl.stage.entry.ChecksumStrategy`	`checksumStrategy()`
`void`	`close()`
`void`	`closeAllocatedChunks()`
`void`	`closeDelayedUpdateChecksum()`
`void`	`closeEntriesToTest()`
`void`	`closeEntryOffset()`
`void`	`closeEntryOffsetDependants()`
`void`	`closeEntryRemovedOnThisIteration()`
`void`	`closeEntrySizeInChunks()`
`void`	`closeHashLookupPos()`
`void`	`closeHashLookupPosDependants()`
`void`	`closeHashLookupSearchAddrDependants()`
`void`	`closeHashLookupSearchFoundDependants()`
`void`	`closeHashLookupSearchHlDependants()`
`void`	`closeHashLookupSearchNextPosDependants()`
`void`	`closeInputKey()`
`void`	`closeInputKeyDependants()`
`void`	`closeIterationCheckOnEachPublicOperationCheckOnEachPublicOperationDependants()`
`void`	`closeIterationKeyHashCodeKeyHashCodeDependants()`
`void`	`closeIterationSegmentStagesCheckNestedContextsQueryDifferentKeysDependants()`
`void`	`closeIterationSegmentStagesDeregisterIterationContextLockedInThisThreadDependants()`
`void`	`closeIterationSegmentStagesLowestPossiblyFreeChunkDependants()`
`void`	`closeIterationSegmentStagesRegisterIterationContextLockedInThisThreadDependants()`
`void`	`closeIterationSegmentStagesTierCountersAreaAddrDependants()`
`void`	`closeIterationSegmentStagesTierEntriesDependants()`
`void`	`closeKeyHash()`
`void`	`closeKeyHashDependants()`
`void`	`closeKeyOffset()`
`void`	`closeKeyOffsetDependants()`
`void`	`closeKeySearchKeyEqualsDependants()`
`void`	`closeKeySize()`
`void`	`closeKeySizeDependants()`
`void`	`closeLocksDependants()`
`void`	`closeOwnerThreadHolderCheckAccessingFromOwnerThreadDependants()`
`void`	`closePos()`
`void`	`closePosDependants()`
`void`	`closeReplicatedChronicleMapHolderImplContextAtIndexInChainDependants()`
`void`	`closeReplicatedChronicleMapHolderImplMDependants()`
`void`	`closeReplicatedMapEntryStagesCountValueSizeOffsetDependants()`
`void`	`closeReplicatedMapEntryStagesEntryEndDependants()`
`void`	`closeReplicatedMapEntryStagesEntrySizeDependants()`
`void`	`closeReplicatedMapEntryStagesKeyEndDependants()`
`void`	`closeReplicatedMapEntryStagesReadExistingEntryDependants()`
`void`	`closeReplicatedMapSegmentIterationCheckEntryNotRemovedOnThisIterationDependants()`
`void`	`closeReplicationState()`
`void`	`closeReplicationUpdate()`
`void`	`closeSearchKey()`
`void`	`closeSearchKeyDependants()`
`void`	`closeSegmentDependants()`
`void`	`closeSegmentHeader()`
`void`	`closeSegmentHeaderDependants()`
`void`	`closeSegmentIndex()`
`void`	`closeSegmentIndexDependants()`
`void`	`closeSegmentTier()`
`void`	`closeSegmentTierDependants()`
`void`	`closeValueSize()`
`void`	`closeValueSizeDependants()`
`void`	`closeValueSizeOffset()`
`void`	`closeValueSizeOffsetDependants()`
`CompiledReplicatedMapIterationContext<K,V,R>`	`context()` Returns the context, in which the entry is accessed.
`<T> T`	`contextAtIndexInChain(int index)`
`List<net.openhft.chronicle.hash.impl.stage.hash.ChainingInterface>`	`contextChain()`
`void`	`copyExistingEntry(long newPos, long bytesToCopy, long oldKeyAddr, long oldKeySizeAddr)`
`String`	`debugContextsAndLocks()`
`String`	`debugContextsAndLocksGuarded()`
`String`	`debugLocksState()`
`int`	`decrementRead()`
`int`	`decrementUpdate()`
`int`	`decrementUpdateGuarded()`
`int`	`decrementWrite()`
`int`	`decrementWriteGuarded()`
`Data<V>`	`defaultValue()` Returns the default (or nil) value, that should be inserted into the map in this context.
`Data<V>`	`defaultValue(MapAbsentEntry<K,V> absentEntry)` Returns the "nil" value, which should be inserted into the map, in the given `absentEntry` context.
`void`	`doInsert()` Inserts `the new key` into the set.
`void`	`doInsert(Data<V> value)` Inserts the new entry into the map, of the key and the given `value`.
`void`	`doRemove()` Removes the entry from the `ChronicleHash`.
`void`	`doRemoveCompletely()` Completely remove the entry from the Chronicle hash, not just mark is as deleted, what `MapEntry.doRemove()` does for Replicated Chronicle hash.
`void`	`doReplaceValue(Data<V> newValue)` Replaces the entry's value with the given `newValue`.
`void`	`dropChange()`
`void`	`dropChanged()` Suppress the entry, if it was scheduled to be replicated over to remote Chronicle nodes.
`CompiledReplicatedMapIterationContext.DummyValueZeroData`	`dummyValue()`
`net.openhft.chronicle.map.impl.CompiledReplicatedMapIterationContext.EntriesToTest`	`entriesToTest()`
`boolean`	`entriesToTestInit()`
`CompiledReplicatedMapIterationContext.ReplicatedMapEntryDelegating`	`entryDelegating()`
`boolean`	`entryDeleted()`
`protected long`	`entryEnd()`
`Object`	`entryForIteration()`
`CompiledReplicatedMapIterationContext.EntryKeyBytesData`	`entryKey()`
`boolean`	`entryOffsetInit()`
`long`	`entrySize(long keySize, long valueSize)`
`int`	`entrySizeInChunks()`
`boolean`	`entrySizeInChunksInit()`
`long`	`entrySpaceOffset()`
`CompiledReplicatedMapIterationContext.EntryValueBytesData`	`entryValue()`
`void`	`forEachSegmentEntry(Consumer<? super MapEntry<K,V>> action)` Performs the given action for each present entry in this segment until all entries have been processed or the action throws an `Exception`.
`boolean`	`forEachSegmentEntryWhile(Predicate<? super MapEntry<K,V>> predicate)` Checks the given predicate on each present entry in this segment until all entries have been processed or the predicate returns `false` for some entry, or throws an `Exception`.
`void`	`forEachSegmentReplicableEntry(Consumer<? super ReplicableEntry> action)`
`boolean`	`forEachSegmentReplicableEntryWhile(Predicate<? super ReplicableEntry> predicate)`
`void`	`found()`
`void`	`free(long fromPos, int chunks)`
`void`	`freeExtra(long pos, int oldChunks, int newChunks)`
`void`	`freeExtraAllocatedChunks()`
`void`	`freeExtraGuarded(long pos, int oldChunks, int newChunks)`
`void`	`freeGuarded(long fromPos, int chunks)`
`ReusableBitSet`	`freeList()`
`<T extends net.openhft.chronicle.hash.impl.stage.hash.ChainingInterface> T`	`getContext(Class<? extends T> contextClass, Function<net.openhft.chronicle.hash.impl.stage.hash.ChainingInterface,T> createChaining)`
`List<net.openhft.chronicle.hash.impl.stage.hash.ChainingInterface>`	`getContextChain()`
`void`	`goToFirstTier()`
`void`	`goToLastTier()`
`ChronicleHash<K,?,?,?>`	`hash()` Returns the accessed `ChronicleHash`.
`CompiledReplicatedMapIterationContext.HashEntryChecksumStrategy`	`hashEntryChecksumStrategy()`
`long`	`hashLookupEntry()`
`boolean`	`hashLookupEntryInit()`
`long`	`hashLookupPos()`
`boolean`	`hashLookupPosInit()`
`boolean`	`hasNextTier()`
`net.openhft.chronicle.hash.impl.CompactOffHeapLinearHashTable`	`hl()`
`void`	`incrementModCount()`
`void`	`incrementModCountGuarded()`
`void`	`incrementRead()`
`void`	`incrementReadGuarded()`
`void`	`incrementUpdate()`
`void`	`incrementUpdateGuarded()`
`void`	`incrementWrite()`
`void`	`incrementWriteGuarded()`
`int`	`indexInContextChain()`
`void`	`initAllocatedChunks(int allocatedChunks)`
`void`	`initDelayedUpdateChecksum(boolean delayedUpdateChecksum)`
`boolean`	`initEntryAndKeyCopying(long entrySize, long bytesToCopy, long prevPos, int prevChunks)`
`void`	`initEntryOffset()`
`protected void`	`initEntryRemovedOnThisIteration(boolean entryRemovedOnThisIteration)`
`void`	`initEntrySizeInChunks(int actuallyUsedChunks)`
`void`	`initHashLookupEntry(long entry)`
`void`	`initHashLookupPos()`
`void`	`initHashLookupPos(long hashLookupPos)`
`void`	`initInputKey(Data<K> inputKey)`
`void`	`initKeyOffset(long keyOffset)`
`void`	`initKeySearch()`
`void`	`initKeySize(long keySize)`
`void`	`initPos(long pos)`
`void`	`initReplicationUpdate(long timestamp, byte identifier)`
`void`	`initSearchKey(long searchKey)`
`void`	`initSegmentIndex(int segmentIndex)`
`void`	`initSegmentTier_WithBaseAddr(int tier, long tierBaseAddr, long tierIndex)`
`void`	`initSegmentTier()`
`void`	`initSegmentTier(int tier, long tierIndex, long tierBaseAddr)`
`void`	`initUsed(boolean used)`
`void`	`initValue_WithoutSize(Data<?> value, long oldValueSizeOffset, long oldValueSize, long oldValueOffset)`
`void`	`initValue(Data<?> value)`
`void`	`innerDefaultReplaceValue(Data<V> newValue)`
`long`	`innerEntrySize(long sizeOfEverythingBeforeValue, long valueSize)`
`<T> boolean`	`innerForEachSegmentEntryWhile(Predicate<? super T> predicate)`
`CompiledReplicatedMapIterationContext.ReadLock`	`innerReadLock()`
`byte`	`innerRemoteIdentifier()`
`long`	`innerRemoteTimestamp()`
`void`	`innerRemoveEntryExceptHashLookupUpdate()`
`CompiledReplicatedMapIterationContext.UpdateLock`	`innerUpdateLock()`
`CompiledReplicatedMapIterationContext.WriteLock`	`innerWriteLock()`
`Data<K>`	`inputKey()`
`R`	`insert(MapAbsentEntry<K,V> absentEntry, Data<V> value)` Inserts the new entry into the map, of `the key` from the given insertion context (`absentEntry`) and the given `value`.
`boolean`	`isChanged()` Check is the entry is scheduled to be replicated to the remote Chronicle nodes, to which the connection is currently established.
`void`	`iterationRemove()`
`Data<K>`	`key()` Returns the entry key.
`long`	`keyEnd()`
`long`	`keyHash()`
`long`	`keyHashCode()`
`boolean`	`keyHashInit()`
`long`	`keyOffset()`
`boolean`	`keyOffsetInit()`
`SizedReader<K>`	`keyReader()`
`long`	`keySize()`
`boolean`	`keySizeInit()`
`long`	`keySizeOffset()`
`int`	`latestSameThreadSegmentModCount()`
`net.openhft.chronicle.hash.impl.LocalLockState`	`localLockState()`
`boolean`	`locksInit()`
`org.slf4j.Logger`	`LOG()`
`void`	`lowestPossiblyFreeChunk(long lowestPossiblyFreeChunk)`
`net.openhft.chronicle.map.ReplicatedChronicleMap<K,V,R>`	`m()`
`ChronicleMap<K,V>`	`map()` Returns the accessed `ChronicleMap`.
`void`	`moveChange(long oldTierIndex, long oldPos, long newPos)`
`boolean`	`nestedContextsLockedOnSameSegment()`
`long`	`newEntrySize(Data<V> newValue, long entryStartOffset, long newValueOffset)`
`long`	`newSizeOfEverythingBeforeValue(Data<V> newValue)`
`net.openhft.chronicle.hash.impl.stage.entry.LocksInterface`	`nextNode()`
`long`	`nextPos()`
`void`	`nextTier()`
`long`	`nextTierIndex()`
`void`	`nextTierIndex(long nextTierIndex)`
`byte`	`originIdentifier()` The identifier, associated with this entry.
`long`	`originTimestamp()` The timestamp, associated with this entry.
`Thread`	`owner()`
`long`	`pos()`
`boolean`	`posInit()`
`void`	`prevTier()`
`long`	`prevTierIndex()`
`void`	`prevTierIndex(long prevTierIndex)`
`void`	`putNewVolatile(long value)`
`void`	`putValueDeletedEntry(Data<V> newValue)`
`void`	`putValueVolatile(long newValue)`
`void`	`raiseChange()`
`void`	`raiseChanged()` Propagate the entry, schedule it to be replicated over to remote Chronicle nodes.
`void`	`readExistingEntry(long pos)`
`InterProcessLock`	`readLock()` Returns the read-level lock.
`void`	`readUnlockAndDecrementCount()`
`void`	`readUnlockAndDecrementCountGuarded()`
`boolean`	`readZero()`
`boolean`	`readZeroGuarded()`
`boolean`	`realloc(long fromPos, int oldChunks, int newChunks)`
`boolean`	`reallocGuarded(long fromPos, int oldChunks, int newChunks)`
`protected void`	`relocation(Data<V> newValue, long newSizeOfEverythingBeforeValue)`
`byte`	`remoteIdentifier()`
`long`	`remoteTimestamp()`
`void`	`remove()`
`R`	`remove(MapEntry<K,V> entry)` Removes the given entry from the map.
`R`	`replaceValue(MapEntry<K,V> entry, Data<V> newValue)` Replaces the given entry's value with the new one.
`long`	`replicationBytesOffset()`
`boolean`	`replicationStateInit()`
`boolean`	`replicationUpdateInit()`
`net.openhft.chronicle.hash.impl.stage.hash.ChainingInterface`	`rootContextInThisThread()`
`net.openhft.chronicle.hash.impl.stage.entry.LocksInterface`	`rootContextLockedOnThisSegment()`
`long`	`searchKey()`
`boolean`	`searchKeyInit()`
`long`	`searchStartPos()`
`CompiledReplicatedMapIterationContext.SearchState`	`searchState()`
`boolean`	`searchStateAbsent()`
`boolean`	`searchStateDeleted()`
`boolean`	`searchStatePresent()`
`PointerBytesStore`	`segmentBS()`
`Bytes`	`segmentBytes()`
`Bytes`	`segmentBytesForRead()`
`Bytes`	`segmentBytesForReadGuarded()`
`Bytes`	`segmentBytesForWrite()`
`Bytes`	`segmentBytesForWriteGuarded()`
`net.openhft.chronicle.hash.impl.SegmentHeader`	`segmentHeader()`
`long`	`segmentHeaderAddress()`
`boolean`	`segmentHeaderInit()`
`int`	`segmentIndex()` Returns the index of the accessed segment.
`boolean`	`segmentIndexInit()`
`boolean`	`segmentTierInit()`
`ChronicleSet<K>`	`set()` Returns the accessed `ChronicleSet`.
`void`	`setHashLookupPos(long hashLookupPos)`
`void`	`setHashLookupPosGuarded(long hashLookupPos)`
`void`	`setLocalLockState(net.openhft.chronicle.hash.impl.LocalLockState newState)`
`void`	`setLocalLockStateGuarded(net.openhft.chronicle.hash.impl.LocalLockState newState)`
`void`	`setNestedContextsLockedOnSameSegment(boolean nestedContextsLockedOnSameSegment)`
`void`	`setNextNode(net.openhft.chronicle.hash.impl.stage.entry.LocksInterface nextNode)`
`void`	`setSearchState(CompiledReplicatedMapIterationContext.SearchState newSearchState)`
`boolean`	`shouldTestEntry()`
`long`	`size()` Returns the number of present entries in this segment.
`int`	`tier()`
`long`	`tierBaseAddr()`
`long`	`tierCountersAreaAddr()`
`long`	`tierDeleted()`
`void`	`tierDeleted(long tierDeleted)`
`long`	`tierEntries()`
`void`	`tierEntries(long tierEntries)`
`long`	`tierEntriesForIteration()`
`long`	`tierIndex()`
`long`	`timestamp()`
`int`	`totalReadLockCount()`
`int`	`totalUpdateLockCount()`
`int`	`totalWriteLockCount()`
`void`	`updateChange()`
`void`	`updateChecksum()` Re-computes and stores checksum for the entry.
`void`	`updatedReplicationStateOnAbsentEntry()`
`void`	`updatedReplicationStateOnPresentEntry()`
`InterProcessLock`	`updateLock()` Returns the update-level lock.
`void`	`updateOrigin(byte newIdentifier, long newTimestamp)` Overwrite the entry's associated identifier and timestamp.
`boolean`	`updateZero()`
`boolean`	`updateZeroGuarded()`
`boolean`	`usedInit()`
`Data<V>`	`value()` Returns the entry value.
`long`	`valueOffset()`
`SizedReader<V>`	`valueReader()`
`long`	`valueSize()`
`boolean`	`valueSizeInit()`
`long`	`valueSizeOffset()`
`boolean`	`valueSizeOffsetInit()`
`void`	`verifyTierCountersAreaData()`
`CompiledReplicatedMapIterationContext.WrappedValueInstanceDataHolder`	`wrappedValueInstanceValueHolder()`
`Data<V>`	`wrapValueAsData(V value)` Wraps the given value as a `Data`.
`void`	`writeEntryDeleted()`
`void`	`writeEntryPresent()`
`InterProcessLock`	`writeLock()` Returns the write-level lock.
`void`	`writeNewEntry(long pos, Data<?> key)`
`void`	`writeValue(Data<?> value)`
`void`	`writeValueAndPutPos(Data<V> value)`
`boolean`	`writeZero()`
`boolean`	`writeZeroGuarded()`

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

Methods inherited from interface net.openhft.chronicle.map.impl.VanillaChronicleMapHolder
h

Methods inherited from interface net.openhft.chronicle.core.io.Closeable
closeQuietly, notifyClosing

Methods inherited from interface net.openhft.chronicle.set.SetEntryOperations
insert, remove

- Field Detail
  - indexInContextChain
```
public final int indexInContextChain
```
  - innerReadLock
```
public final CompiledReplicatedMapIterationContext.ReadLock innerReadLock
```
  - LOG
```
public static final org.slf4j.Logger LOG
```
  - innerWriteLock
```
public final CompiledReplicatedMapIterationContext.WriteLock innerWriteLock
```
  - keyReader
```
public final SizedReader<K> keyReader
```
  - innerUpdateLock
```
public final CompiledReplicatedMapIterationContext.UpdateLock innerUpdateLock
```
  - valueReader
```
public final SizedReader<V> valueReader
```
  - rootContextInThisThread
```
public final net.openhft.chronicle.hash.impl.stage.hash.ChainingInterface rootContextInThisThread
```
  - contextChain
```
public final List<net.openhft.chronicle.hash.impl.stage.hash.ChainingInterface> contextChain
```
  - entryValue
```
public final CompiledReplicatedMapIterationContext.EntryValueBytesData entryValue
```
  - segmentBS
```
public final PointerBytesStore segmentBS
```
  - checksumStrategy
```
public final net.openhft.chronicle.hash.impl.stage.entry.ChecksumStrategy checksumStrategy
```
  - segmentBytes
```
public final Bytes segmentBytes
```
  - searchStartPos
```
public long searchStartPos
```
  - keySize
```
public long keySize
```
  - hashLookupEntry
```
public long hashLookupEntry
```
  - segmentIndex
```
public int segmentIndex
```
  - tier
```
public int tier
```
  - tierIndex
```
public long tierIndex
```
  - tierBaseAddr
```
public long tierBaseAddr
```
  - entryRemovedOnThisIteration
```
public boolean entryRemovedOnThisIteration
```
  - inputKey
```
public Data<K> inputKey
```
  - latestSameThreadSegmentModCount
```
public int latestSameThreadSegmentModCount
```
  - contextModCount
```
public int contextModCount
```
  - nestedContextsLockedOnSameSegment
```
public boolean nestedContextsLockedOnSameSegment
```
  - rootContextLockedOnThisSegment
```
public net.openhft.chronicle.hash.impl.stage.entry.LocksInterface rootContextLockedOnThisSegment
```
  - hashLookupPos
```
public long hashLookupPos
```
  - pos
```
public long pos
```
  - keySizeOffset
```
public long keySizeOffset
```
  - keyOffset
```
public long keyOffset
```
  - valueSizeOffset
```
public long valueSizeOffset
```
  - valueSize
```
public long valueSize
```
  - valueOffset
```
public long valueOffset
```
  - entrySizeInChunks
```
public int entrySizeInChunks
```
  - searchState
```
protected CompiledReplicatedMapIterationContext.SearchState searchState
```
  - delayedUpdateChecksum
```
public boolean delayedUpdateChecksum
```
  - allocatedChunks
```
public int allocatedChunks
```
  - innerRemoteTimestamp
```
public long innerRemoteTimestamp
```
  - innerRemoteIdentifier
```
public byte innerRemoteIdentifier
```
- Constructor Detail
  - CompiledReplicatedMapIterationContext
```
public CompiledReplicatedMapIterationContext(net.openhft.chronicle.hash.impl.stage.hash.ChainingInterface c,
                                             net.openhft.chronicle.map.ReplicatedChronicleMap<K,V,R> m)
```
  - CompiledReplicatedMapIterationContext
```
public CompiledReplicatedMapIterationContext(net.openhft.chronicle.map.ReplicatedChronicleMap<K,V,R> m)
```
- Method Detail
  - readZeroGuarded
```
public boolean readZeroGuarded()
```
  - reallocGuarded
```
public boolean reallocGuarded(long fromPos,
                              int oldChunks,
                              int newChunks)
```
  - updateZeroGuarded
```
public boolean updateZeroGuarded()
```
  - writeZeroGuarded
```
public boolean writeZeroGuarded()
```
  - decrementUpdateGuarded
```
public int decrementUpdateGuarded()
```
  - decrementWriteGuarded
```
public int decrementWriteGuarded()
```
  - debugContextsAndLocksGuarded
```
public String debugContextsAndLocksGuarded()
```
  - allocReturnCodeGuarded
```
public long allocReturnCodeGuarded(int chunks)
```
  - segmentBytesForReadGuarded
```
public Bytes segmentBytesForReadGuarded()
```
  - segmentBytesForWriteGuarded
```
public Bytes segmentBytesForWriteGuarded()
```
  - close
```
public void close()
```
    Specified by:
    
    close in interface Closeable
    
    Specified by:
    
    close in interface AutoCloseable
  - freeExtraGuarded
```
public void freeExtraGuarded(long pos,
                             int oldChunks,
                             int newChunks)
```
  - freeGuarded
```
public void freeGuarded(long fromPos,
                        int chunks)
```
  - incrementModCountGuarded
```
public void incrementModCountGuarded()
```
  - incrementReadGuarded
```
public void incrementReadGuarded()
```
  - incrementUpdateGuarded
```
public void incrementUpdateGuarded()
```
  - incrementWriteGuarded
```
public void incrementWriteGuarded()
```
  - readUnlockAndDecrementCountGuarded
```
public void readUnlockAndDecrementCountGuarded()
```
  - setHashLookupPosGuarded
```
public void setHashLookupPosGuarded(long hashLookupPos)
```
  - setLocalLockStateGuarded
```
public void setLocalLockStateGuarded(net.openhft.chronicle.hash.impl.LocalLockState newState)
```
  - changeAndGetLatestSameThreadSegmentModCount
```
public int changeAndGetLatestSameThreadSegmentModCount(int change)
```
    Specified by:
    
    changeAndGetLatestSameThreadSegmentModCount in interface net.openhft.chronicle.hash.impl.stage.entry.LocksInterface
  - changeAndGetTotalReadLockCount
```
public int changeAndGetTotalReadLockCount(int change)
```
    Specified by:
    
    changeAndGetTotalReadLockCount in interface net.openhft.chronicle.hash.impl.stage.entry.LocksInterface
  - changeAndGetTotalUpdateLockCount
```
public int changeAndGetTotalUpdateLockCount(int change)
```
    Specified by:
    
    changeAndGetTotalUpdateLockCount in interface net.openhft.chronicle.hash.impl.stage.entry.LocksInterface
  - changeAndGetTotalWriteLockCount
```
public int changeAndGetTotalWriteLockCount(int change)
```
    Specified by:
    
    changeAndGetTotalWriteLockCount in interface net.openhft.chronicle.hash.impl.stage.entry.LocksInterface
  - decrementRead
```
public int decrementRead()
```
  - decrementUpdate
```
public int decrementUpdate()
```
  - decrementWrite
```
public int decrementWrite()
```
  - allocReturnCode
```
public long allocReturnCode(int chunks)
```
  - free
```
public void free(long fromPos,
                 int chunks)
```
  - freeExtra
```
public void freeExtra(long pos,
                      int oldChunks,
                      int newChunks)
```
  - incrementModCount
```
public void incrementModCount()
```
  - incrementRead
```
public void incrementRead()
```
  - incrementUpdate
```
public void incrementUpdate()
```
  - incrementWrite
```
public void incrementWrite()
```
  - readUnlockAndDecrementCount
```
public void readUnlockAndDecrementCount()
```
  - setHashLookupPos
```
public void setHashLookupPos(long hashLookupPos)
```
  - setLocalLockState
```
public void setLocalLockState(net.openhft.chronicle.hash.impl.LocalLockState newState)
```
  - setNestedContextsLockedOnSameSegment
```
public void setNestedContextsLockedOnSameSegment(boolean nestedContextsLockedOnSameSegment)
```
    Specified by:
    
    setNestedContextsLockedOnSameSegment in interface net.openhft.chronicle.hash.impl.stage.entry.LocksInterface
  - setNextNode
```
public void setNextNode(net.openhft.chronicle.hash.impl.stage.entry.LocksInterface nextNode)
```
    Specified by:
    
    setNextNode in interface net.openhft.chronicle.hash.impl.stage.entry.LocksInterface
  - setSearchState
```
public void setSearchState(CompiledReplicatedMapIterationContext.SearchState newSearchState)
```
  - owner
```
public Thread owner()
```
  - segmentBytesForRead
```
public Bytes segmentBytesForRead()
```
  - segmentBytesForWrite
```
public Bytes segmentBytesForWrite()
```
  - debugContextsAndLocks
```
public String debugContextsAndLocks()
```
  - readZero
```
public boolean readZero()
```
  - realloc
```
public boolean realloc(long fromPos,
                       int oldChunks,
                       int newChunks)
```
  - updateZero
```
public boolean updateZero()
```
  - writeZero
```
public boolean writeZero()
```
  - indexInContextChain
```
public int indexInContextChain()
```
  - innerReadLock
```
public CompiledReplicatedMapIterationContext.ReadLock innerReadLock()
```
  - innerWriteLock
```
public CompiledReplicatedMapIterationContext.WriteLock innerWriteLock()
```
  - LOG
```
public org.slf4j.Logger LOG()
```
  - valueReader
```
public SizedReader<V> valueReader()
```
  - innerUpdateLock
```
public CompiledReplicatedMapIterationContext.UpdateLock innerUpdateLock()
```
  - keyReader
```
public SizedReader<K> keyReader()
```
  - entryKey
```
public CompiledReplicatedMapIterationContext.EntryKeyBytesData entryKey()
```
  - rootContextInThisThread
```
public net.openhft.chronicle.hash.impl.stage.hash.ChainingInterface rootContextInThisThread()
```
  - dummyValue
```
public CompiledReplicatedMapIterationContext.DummyValueZeroData dummyValue()
```
  - wrappedValueInstanceValueHolder
```
public CompiledReplicatedMapIterationContext.WrappedValueInstanceDataHolder wrappedValueInstanceValueHolder()
```
  - hashEntryChecksumStrategy
```
public CompiledReplicatedMapIterationContext.HashEntryChecksumStrategy hashEntryChecksumStrategy()
```
  - contextChain
```
public List<net.openhft.chronicle.hash.impl.stage.hash.ChainingInterface> contextChain()
```
  - entryValue
```
public CompiledReplicatedMapIterationContext.EntryValueBytesData entryValue()
```
  - entryDelegating
```
public CompiledReplicatedMapIterationContext.ReplicatedMapEntryDelegating entryDelegating()
```
  - freeList
```
public ReusableBitSet freeList()
```
  - absentEntryDelegating
```
public CompiledReplicatedMapIterationContext.ReplicatedMapAbsentDelegatingForIteration absentEntryDelegating()
```
  - checksumStrategy
```
public net.openhft.chronicle.hash.impl.stage.entry.ChecksumStrategy checksumStrategy()
```
  - segmentBytes
```
public Bytes segmentBytes()
```
  - closeIterationSegmentStagesDeregisterIterationContextLockedInThisThreadDependants
```
public void closeIterationSegmentStagesDeregisterIterationContextLockedInThisThreadDependants()
```
  - getContextChain
```
public List<net.openhft.chronicle.hash.impl.stage.hash.ChainingInterface> getContextChain()
```
    Specified by:
    
    getContextChain in class net.openhft.chronicle.hash.impl.stage.hash.ChainingInterface
  - contextAtIndexInChain
```
public <T> T contextAtIndexInChain(int index)
```
  - closeReplicatedChronicleMapHolderImplContextAtIndexInChainDependants
```
public void closeReplicatedChronicleMapHolderImplContextAtIndexInChainDependants()
```
  - getContext
```
public <T extends net.openhft.chronicle.hash.impl.stage.hash.ChainingInterface> T getContext(Class<? extends T> contextClass,
                                                                                             Function<net.openhft.chronicle.hash.impl.stage.hash.ChainingInterface,T> createChaining)
```
    Specified by:
    
    getContext in class net.openhft.chronicle.hash.impl.stage.hash.ChainingInterface
  - context
```
@NotNull
public CompiledReplicatedMapIterationContext<K,V,R> context()
```
    Description copied from interface: HashEntry
    
    Returns the context, in which the entry is accessed.
    
    Specified by:
    
    context in interface HashAbsentEntry<K>
    
    Specified by:
    
    context in interface HashEntry<K>
    
    Specified by:
    
    context in interface MapAbsentEntry<K,V>
    
    Specified by:
    
    context in interface MapEntry<K,V>
    
    Specified by:
    
    context in interface SetAbsentEntry<K>
  - checkAccessingFromOwnerThread
```
public void checkAccessingFromOwnerThread()
```
  - closeOwnerThreadHolderCheckAccessingFromOwnerThreadDependants
```
public void closeOwnerThreadHolderCheckAccessingFromOwnerThreadDependants()
```
  - checkIterationContextNotLockedInThisThread
```
public void checkIterationContextNotLockedInThisThread()
```
  - checkEntryNotRemovedOnThisIteration
```
public void checkEntryNotRemovedOnThisIteration()
```
  - closeReplicatedMapSegmentIterationCheckEntryNotRemovedOnThisIterationDependants
```
public void closeReplicatedMapSegmentIterationCheckEntryNotRemovedOnThisIterationDependants()
```
  - checkOnEachPublicOperation
```
public void checkOnEachPublicOperation()
```
  - closeIterationCheckOnEachPublicOperationCheckOnEachPublicOperationDependants
```
public void closeIterationCheckOnEachPublicOperationCheckOnEachPublicOperationDependants()
```
  - checkSum
```
public boolean checkSum()
```
    Description copied from interface: ChecksumEntry
    
    Computes checksum from the entry bytes and checks whether it is equal to the stored checksum.
    
    Specified by:
    
    checkSum in interface ChecksumEntry
    
    Returns:
    
    true if stored checksum equals to checksum computed from the entry bytes
  - wrapValueAsData
```
public Data<V> wrapValueAsData(V value)
```
    Description copied from interface: MapContext
    
    Wraps the given value as a Data. Useful when you need to pass a value to some method accepting Data, for example, MapEntryOperations.replaceValue( MapEntry, Data), without allocating new objects (i. e. garbage) and ThreadLocals.
    The returned Data object shouldn't outlive this MapContext.
    
    Specified by:
    
    wrapValueAsData in interface MapContext<K,V,R>
    
    Parameters:
    
    value - the value object to wrap
    
    Returns:
    
    the value as Data
  - value
```
@NotNull
public Data<V> value()
```
    Description copied from interface: MapEntry
    
    Returns the entry value.
    
    Specified by:
    
    value in interface MapEntry<K,V>
  - key
```
@NotNull
public Data<K> key()
```
    Description copied from interface: HashEntry
    
    Returns the entry key.
    
    Specified by:
    
    key in interface HashEntry<K>
  - updateChecksum
```
public void updateChecksum()
```
    Description copied from interface: ChecksumEntry
    
    Re-computes and stores checksum for the entry. This method shouldn't be called before or after ordinary operations like MapAbsentEntry.doInsert(Data), MapEntry.doReplaceValue(Data): it is performed automatically underneath. Call this method, only when value bytes was updated directly, for example though flyweight implementation of a value interface.
    
    Specified by:
    
    updateChecksum in interface ChecksumEntry
  - writeLock
```
@NotNull
public InterProcessLock writeLock()
```
    Description copied from interface: InterProcessReadWriteUpdateLock
    
    Returns the write-level lock. Calling lock() or other locking methods (tryLock(), etc.) on this lock acquires the read and update locks, as well.
    Any attempt to acquire this lock (including tryLock(), if the read lock is already held by the current thread, but the update and write locks are not yet, is prevented by throwing IllegalInterProcessLockStateException.
    
    Specified by:
    
    writeLock in interface ReadWriteLock
    
    Specified by:
    
    writeLock in interface InterProcessReadWriteUpdateLock
    
    Returns:
    
    the update-level lock
  - readLock
```
@NotNull
public InterProcessLock readLock()
```
    Description copied from interface: InterProcessReadWriteUpdateLock
    
    Returns the read-level lock. Calling unlock() on this lock also releases the update and write locks, if held, as well.
    
    Specified by:
    
    readLock in interface ReadWriteLock
    
    Specified by:
    
    readLock in interface InterProcessReadWriteUpdateLock
    
    Returns:
    
    the read level lock
  - defaultValue
```
@NotNull
public Data<V> defaultValue()
```
    Description copied from interface: MapAbsentEntry
    
    Returns the default (or nil) value, that should be inserted into the map in this context. This is primarily used in ChronicleMap.acquireUsing(K, V) operation implementation, i. e. MapMethods.acquireUsing(net.openhft.chronicle.map.MapQueryContext<K, V, R>, net.openhft.chronicle.map.ReturnValue<V>).
    This method if the default implementation for DefaultValueProvider.defaultValue(MapAbsentEntry), which might be customized over the default.
    
    Specified by:
    
    defaultValue in interface MapAbsentEntry<K,V>
    
    See Also:
    
    DefaultValueProvider.defaultValue(MapAbsentEntry)
  - updateLock
```
@NotNull
public InterProcessLock updateLock()
```
    Description copied from interface: InterProcessReadWriteUpdateLock
    
    Returns the update-level lock. Calling lock() or other locking methods (tryLock(), etc.) on this lock acquires the read lock, as well. Calling unlock() on this lock also releases the write lock.
    Any attempt to acquire this lock (including tryLock(), if the read lock is already held by the current thread, but the update lock is not yet, is prevented by throwing IllegalInterProcessLockStateException.
    
    Specified by:
    
    updateLock in interface InterProcessReadWriteUpdateLock
    
    Returns:
    
    the update-level lock
  - m
```
public net.openhft.chronicle.map.ReplicatedChronicleMap<K,V,R> m()
```
    Specified by:
    
    m in interface net.openhft.chronicle.map.impl.ReplicatedChronicleMapHolder<K,V,R>
    
    Specified by:
    
    m in interface net.openhft.chronicle.map.impl.VanillaChronicleMapHolder<K,V,R>
  - closeReplicatedChronicleMapHolderImplMDependants
```
public void closeReplicatedChronicleMapHolderImplMDependants()
```
  - innerEntrySize
```
public long innerEntrySize(long sizeOfEverythingBeforeValue,
                           long valueSize)
```
  - defaultValue
```
public Data<V> defaultValue(@NotNull
                            MapAbsentEntry<K,V> absentEntry)
```
    Description copied from interface: DefaultValueProvider
    
    Returns the "nil" value, which should be inserted into the map, in the given absentEntry context. This is primarily used in ChronicleMap.acquireUsing(K, V) operation implementation, i. e. MapMethods.acquireUsing(net.openhft.chronicle.map.MapQueryContext<K, V, R>, net.openhft.chronicle.map.ReturnValue<V>). The default implementation simply delegates to MapAbsentEntry.defaultValue().
    
    Specified by:
    
    defaultValue in interface DefaultValueProvider<K,V>
  - replaceValue
```
public R replaceValue(@NotNull
                      MapEntry<K,V> entry,
                      Data<V> newValue)
```
    Description copied from interface: MapEntryOperations
    
    Replaces the given entry's value with the new one.
    
    Specified by:
    
    replaceValue in interface MapEntryOperations<K,V,R>
    
    Parameters:
    
    entry - the entry to replace the value in
  - entrySize
```
public final long entrySize(long keySize,
                            long valueSize)
```
  - remove
```
public R remove(@NotNull
                MapEntry<K,V> entry)
```
    Description copied from interface: MapEntryOperations
    
    Removes the given entry from the map.
    
    Specified by:
    
    remove in interface MapEntryOperations<K,V,R>
    
    Parameters:
    
    entry - the entry to remove
  - map
```
public ChronicleMap<K,V> map()
```
    Description copied from interface: MapContext
    
    Returns the accessed ChronicleMap. Synonym to MapContext.hash().
    
    Specified by:
    
    map in interface net.openhft.chronicle.map.impl.VanillaChronicleMapHolder<K,V,R>
    
    Specified by:
    
    map in interface MapContext<K,V,R>
  - insert
```
public R insert(@NotNull
                MapAbsentEntry<K,V> absentEntry,
                Data<V> value)
```
    Description copied from interface: MapEntryOperations
    
    Inserts the new entry into the map, of the key from the given insertion context (absentEntry) and the given value.
    
    Specified by:
    
    insert in interface MapEntryOperations<K,V,R>
  - newEntrySize
```
public long newEntrySize(Data<V> newValue,
                         long entryStartOffset,
                         long newValueOffset)
```
  - set
```
public ChronicleSet<K> set()
```
    Description copied from interface: SetContext
    
    Returns the accessed ChronicleSet. Synonym to SetContext.hash().
    
    Specified by:
    
    set in interface net.openhft.chronicle.map.impl.VanillaChronicleMapHolder<K,V,R>
    
    Specified by:
    
    set in interface SetContext<K,R>
  - hash
```
public ChronicleHash<K,?,?,?> hash()
```
    Description copied from interface: HashContext
    
    Returns the accessed ChronicleHash.
    
    Specified by:
    
    hash in interface HashContext<K>
    
    Specified by:
    
    hash in interface MapContext<K,V,R>
    
    Specified by:
    
    hash in interface SetContext<K,R>
  - closeIterationSegmentStagesRegisterIterationContextLockedInThisThreadDependants
```
public void closeIterationSegmentStagesRegisterIterationContextLockedInThisThreadDependants()
```
  - hl
```
public net.openhft.chronicle.hash.impl.CompactOffHeapLinearHashTable hl()
```
  - closeHashLookupSearchHlDependants
```
public void closeHashLookupSearchHlDependants()
```
  - searchKeyInit
```
public boolean searchKeyInit()
```
  - initSearchKey
```
public void initSearchKey(long searchKey)
```
  - searchKey
```
public long searchKey()
```
  - searchStartPos
```
public long searchStartPos()
```
  - closeSearchKey
```
public void closeSearchKey()
```
  - closeSearchKeyDependants
```
public void closeSearchKeyDependants()
```
  - putValueDeletedEntry
```
public void putValueDeletedEntry(Data<V> newValue)
```
  - keySizeInit
```
public boolean keySizeInit()
```
  - initKeySize
```
public void initKeySize(long keySize)
```
  - keySize
```
public long keySize()
```
  - closeKeySize
```
public void closeKeySize()
```
  - closeKeySizeDependants
```
public void closeKeySizeDependants()
```
  - hashLookupEntryInit
```
public boolean hashLookupEntryInit()
```
  - initHashLookupEntry
```
public void initHashLookupEntry(long entry)
```
  - hashLookupEntry
```
public long hashLookupEntry()
```
  - segmentIndexInit
```
public boolean segmentIndexInit()
```
  - initSegmentIndex
```
public void initSegmentIndex(int segmentIndex)
```
    Specified by:
    
    initSegmentIndex in interface net.openhft.chronicle.map.impl.IterationContext<K,V,R>
  - segmentIndex
```
public int segmentIndex()
```
    Description copied from interface: SegmentLock
    
    Returns the index of the accessed segment.
    
    Specified by:
    
    segmentIndex in interface SegmentLock
  - closeSegmentIndex
```
public void closeSegmentIndex()
```
  - closeSegmentIndexDependants
```
public void closeSegmentIndexDependants()
```
  - segmentHeaderInit
```
public boolean segmentHeaderInit()
```
    Specified by:
    
    segmentHeaderInit in interface net.openhft.chronicle.hash.impl.stage.entry.LocksInterface
  - segmentHeaderAddress
```
public long segmentHeaderAddress()
```
    Specified by:
    
    segmentHeaderAddress in interface net.openhft.chronicle.hash.impl.stage.entry.LocksInterface
  - segmentHeader
```
public net.openhft.chronicle.hash.impl.SegmentHeader segmentHeader()
```
  - closeSegmentHeader
```
public void closeSegmentHeader()
```
  - closeSegmentHeaderDependants
```
public void closeSegmentHeaderDependants()
```
  - segmentTierInit
```
public boolean segmentTierInit()
```
  - initSegmentTier
```
public void initSegmentTier()
```
  - initSegmentTier
```
public void initSegmentTier(int tier,
                            long tierIndex,
                            long tierBaseAddr)
```
  - initSegmentTier_WithBaseAddr
```
public void initSegmentTier_WithBaseAddr(int tier,
                                         long tierBaseAddr,
                                         long tierIndex)
```
  - tier
```
public int tier()
```
  - tierBaseAddr
```
public long tierBaseAddr()
```
  - tierIndex
```
public long tierIndex()
```
  - closeSegmentTier
```
public void closeSegmentTier()
```
  - closeSegmentTierDependants
```
public void closeSegmentTierDependants()
```
  - tierCountersAreaAddr
```
public long tierCountersAreaAddr()
```
  - closeIterationSegmentStagesTierCountersAreaAddrDependants
```
public void closeIterationSegmentStagesTierCountersAreaAddrDependants()
```
  - prevTierIndex
```
public long prevTierIndex()
```
  - prevTier
```
public void prevTier()
```
  - prevTierIndex
```
public void prevTierIndex(long prevTierIndex)
```
  - nextTierIndex
```
public long nextTierIndex()
```
  - hasNextTier
```
public boolean hasNextTier()
```
  - nextTierIndex
```
public void nextTierIndex(long nextTierIndex)
```
  - goToFirstTier
```
public void goToFirstTier()
```
  - tierEntries
```
public long tierEntries()
```
  - tierEntries
```
public void tierEntries(long tierEntries)
```
  - closeIterationSegmentStagesTierEntriesDependants
```
public void closeIterationSegmentStagesTierEntriesDependants()
```
  - tierDeleted
```
public long tierDeleted()
```
  - tierDeleted
```
public void tierDeleted(long tierDeleted)
```
  - closeHashLookupSearchAddrDependants
```
public void closeHashLookupSearchAddrDependants()
```
  - closeIterationSegmentStagesLowestPossiblyFreeChunkDependants
```
public void closeIterationSegmentStagesLowestPossiblyFreeChunkDependants()
```
  - lowestPossiblyFreeChunk
```
public void lowestPossiblyFreeChunk(long lowestPossiblyFreeChunk)
```
  - entrySpaceOffset
```
public long entrySpaceOffset()
```
  - segmentBS
```
public PointerBytesStore segmentBS()
```
  - closeSegmentDependants
```
public void closeSegmentDependants()
```
  - nextTier
```
public void nextTier()
```
  - goToLastTier
```
public void goToLastTier()
```
  - size
```
public long size()
```
    Description copied from interface: HashSegmentContext
    
    Returns the number of present entries in this segment.
    
    Specified by:
    
    size in interface HashSegmentContext<K,MapEntry<K,V>>
  - alloc
```
public long alloc(int chunks,
                  long prevPos,
                  int prevChunks)
```
    Description copied from interface: net.openhft.chronicle.hash.impl.stage.entry.Alloc
    
    Allocates a block of specified number of chunks in a segment tier, optionally clears the previous allocation.
    
    Specified by:
    
    alloc in interface net.openhft.chronicle.hash.impl.stage.entry.Alloc
    
    Parameters:
    
    chunks - chunks to allocate
    
    prevPos - the previous position to clear, -1 if not needed
    
    prevChunks - the size of the previous allocation to clear, 0 if not needed
    
    Returns:
    
    the new allocation position
  - verifyTierCountersAreaData
```
public void verifyTierCountersAreaData()
```
  - usedInit
```
public boolean usedInit()
```
    Specified by:
    
    usedInit in class net.openhft.chronicle.hash.impl.stage.hash.ChainingInterface
  - initUsed
```
public void initUsed(boolean used)
```
    Specified by:
    
    initUsed in class net.openhft.chronicle.hash.impl.stage.hash.ChainingInterface
  - entriesToTestInit
```
public boolean entriesToTestInit()
```
  - entriesToTest
```
public net.openhft.chronicle.map.impl.CompiledReplicatedMapIterationContext.EntriesToTest entriesToTest()
```
  - closeEntriesToTest
```
public void closeEntriesToTest()
```
  - tierEntriesForIteration
```
public long tierEntriesForIteration()
```
  - initEntryRemovedOnThisIteration
```
protected void initEntryRemovedOnThisIteration(boolean entryRemovedOnThisIteration)
```
  - closeEntryRemovedOnThisIteration
```
public void closeEntryRemovedOnThisIteration()
```
  - initInputKey
```
public void initInputKey(Data<K> inputKey)
```
  - inputKey
```
public Data<K> inputKey()
```
  - closeInputKey
```
public void closeInputKey()
```
  - closeInputKeyDependants
```
public void closeInputKeyDependants()
```
  - checkNestedContextsQueryDifferentKeys
```
public void checkNestedContextsQueryDifferentKeys(net.openhft.chronicle.hash.impl.stage.entry.LocksInterface innermostContextOnThisSegment)
```
  - closeIterationSegmentStagesCheckNestedContextsQueryDifferentKeysDependants
```
public void closeIterationSegmentStagesCheckNestedContextsQueryDifferentKeysDependants()
```
  - locksInit
```
public boolean locksInit()
```
    Specified by:
    
    locksInit in interface net.openhft.chronicle.hash.impl.stage.entry.LocksInterface
  - nestedContextsLockedOnSameSegment
```
public boolean nestedContextsLockedOnSameSegment()
```
  - latestSameThreadSegmentModCount
```
public int latestSameThreadSegmentModCount()
```
    Specified by:
    
    latestSameThreadSegmentModCount in interface net.openhft.chronicle.hash.impl.stage.entry.LocksInterface
  - totalReadLockCount
```
public int totalReadLockCount()
```
    Specified by:
    
    totalReadLockCount in interface net.openhft.chronicle.hash.impl.stage.entry.LocksInterface
  - totalUpdateLockCount
```
public int totalUpdateLockCount()
```
    Specified by:
    
    totalUpdateLockCount in interface net.openhft.chronicle.hash.impl.stage.entry.LocksInterface
  - totalWriteLockCount
```
public int totalWriteLockCount()
```
    Specified by:
    
    totalWriteLockCount in interface net.openhft.chronicle.hash.impl.stage.entry.LocksInterface
  - localLockState
```
public net.openhft.chronicle.hash.impl.LocalLockState localLockState()
```
  - nextNode
```
public net.openhft.chronicle.hash.impl.stage.entry.LocksInterface nextNode()
```
    Specified by:
    
    nextNode in interface net.openhft.chronicle.hash.impl.stage.entry.LocksInterface
  - rootContextLockedOnThisSegment
```
public net.openhft.chronicle.hash.impl.stage.entry.LocksInterface rootContextLockedOnThisSegment()
```
    Specified by:
    
    rootContextLockedOnThisSegment in interface net.openhft.chronicle.hash.impl.stage.entry.LocksInterface
  - closeLocksDependants
```
public void closeLocksDependants()
```
  - hashLookupPosInit
```
public boolean hashLookupPosInit()
```
  - initHashLookupPos
```
public void initHashLookupPos()
```
  - initHashLookupPos
```
public void initHashLookupPos(long hashLookupPos)
```
  - hashLookupPos
```
public long hashLookupPos()
```
  - closeHashLookupPos
```
public void closeHashLookupPos()
```
  - closeHashLookupPosDependants
```
public void closeHashLookupPosDependants()
```
  - nextPos
```
public long nextPos()
```
  - closeHashLookupSearchNextPosDependants
```
public void closeHashLookupSearchNextPosDependants()
```
  - putValueVolatile
```
public void putValueVolatile(long newValue)
```
  - found
```
public void found()
```
  - closeHashLookupSearchFoundDependants
```
public void closeHashLookupSearchFoundDependants()
```
  - checkSlotContainsExpectedKeyAndValue
```
public boolean checkSlotContainsExpectedKeyAndValue(long value)
```
  - remove
```
public void remove()
```
  - debugLocksState
```
public String debugLocksState()
```
    Specified by:
    
    debugLocksState in interface net.openhft.chronicle.hash.impl.stage.entry.LocksInterface
  - absentKey
```
@NotNull
public Data<K> absentKey()
```
    Description copied from interface: HashAbsentEntry
    
    Returns the key is going to be inserted into the ChronicleHash.
    
    Specified by:
    
    absentKey in interface HashAbsentEntry<K>
  - posInit
```
public boolean posInit()
```
  - initPos
```
public void initPos(long pos)
```
  - pos
```
public long pos()
```
    Specified by:
    
    pos in interface net.openhft.chronicle.map.impl.IterationContext<K,V,R>
  - closePos
```
public void closePos()
```
  - closePosDependants
```
public void closePosDependants()
```
  - dropChange
```
public void dropChange()
```
  - dropChanged
```
public void dropChanged()
```
    Description copied from interface: ReplicableEntry
    
    Suppress the entry, if it was scheduled to be replicated over to remote Chronicle nodes.
    
    Specified by:
    
    dropChanged in interface ReplicableEntry
  - changed
```
public boolean changed()
```
  - isChanged
```
public boolean isChanged()
```
    Description copied from interface: ReplicableEntry
    
    Check is the entry is scheduled to be replicated to the remote Chronicle nodes, to which the connection is currently established.
    
    Specified by:
    
    isChanged in interface ReplicableEntry
    
    Returns:
    
    true is the entry is "dirty" locally, i. e. should be replicated to remote Chronicle nodes, false otherwise
  - entryOffsetInit
```
public boolean entryOffsetInit()
```
  - initEntryOffset
```
public void initEntryOffset()
```
  - keySizeOffset
```
public long keySizeOffset()
```
  - closeEntryOffset
```
public void closeEntryOffset()
```
  - closeEntryOffsetDependants
```
public void closeEntryOffsetDependants()
```
  - readExistingEntry
```
public void readExistingEntry(long pos)
```
    Specified by:
    
    readExistingEntry in interface net.openhft.chronicle.map.impl.ReplicatedIterationContext<K,V,R>
  - closeReplicatedMapEntryStagesReadExistingEntryDependants
```
public void closeReplicatedMapEntryStagesReadExistingEntryDependants()
```
  - copyExistingEntry
```
public void copyExistingEntry(long newPos,
                              long bytesToCopy,
                              long oldKeyAddr,
                              long oldKeySizeAddr)
```
  - keyOffsetInit
```
public boolean keyOffsetInit()
```
  - initKeyOffset
```
public void initKeyOffset(long keyOffset)
```
  - keyOffset
```
public long keyOffset()
```
  - closeKeyOffset
```
public void closeKeyOffset()
```
  - closeKeyOffsetDependants
```
public void closeKeyOffsetDependants()
```
  - keyEnd
```
public long keyEnd()
```
  - closeReplicatedMapEntryStagesKeyEndDependants
```
public void closeReplicatedMapEntryStagesKeyEndDependants()
```
  - closeReplicatedMapEntryStagesCountValueSizeOffsetDependants
```
public void closeReplicatedMapEntryStagesCountValueSizeOffsetDependants()
```
  - valueSizeOffsetInit
```
public boolean valueSizeOffsetInit()
```
  - valueSizeOffset
```
public long valueSizeOffset()
```
  - closeValueSizeOffset
```
public void closeValueSizeOffset()
```
  - closeValueSizeOffsetDependants
```
public void closeValueSizeOffsetDependants()
```
  - valueSizeInit
```
public boolean valueSizeInit()
```
  - valueOffset
```
public long valueOffset()
```
  - valueSize
```
public long valueSize()
```
  - closeValueSize
```
public void closeValueSize()
```
  - closeValueSizeDependants
```
public void closeValueSizeDependants()
```
  - writeValue
```
public void writeValue(Data<?> value)
```
  - initValue_WithoutSize
```
public void initValue_WithoutSize(Data<?> value,
                                  long oldValueSizeOffset,
                                  long oldValueSize,
                                  long oldValueOffset)
```
  - initValue
```
public void initValue(Data<?> value)
```
  - newSizeOfEverythingBeforeValue
```
public long newSizeOfEverythingBeforeValue(Data<V> newValue)
```
  - replicationStateInit
```
public boolean replicationStateInit()
```
  - replicationBytesOffset
```
public long replicationBytesOffset()
```
  - closeReplicationState
```
public void closeReplicationState()
```
  - updatedReplicationStateOnAbsentEntry
```
public void updatedReplicationStateOnAbsentEntry()
```
  - updateOrigin
```
public void updateOrigin(byte newIdentifier,
                         long newTimestamp)
```
    Description copied from interface: ReplicableEntry
    
    Overwrite the entry's associated identifier and timestamp. After this call ReplicableEntry.originIdentifier() returns the given newIdentifier and ReplicableEntry.originTimestamp() returns the given newTimestamp respectively.
    
    Specified by:
    
    updateOrigin in interface ReplicableEntry
    
    Parameters:
    
    newIdentifier - the new identifier for the entry
    
    newTimestamp - the new timestamp for the entry
  - writeEntryDeleted
```
public void writeEntryDeleted()
```
  - writeEntryPresent
```
public void writeEntryPresent()
```
  - entryDeleted
```
public boolean entryDeleted()
```
  - entryForIteration
```
public Object entryForIteration()
```
  - shouldTestEntry
```
public boolean shouldTestEntry()
```
  - innerForEachSegmentEntryWhile
```
public <T> boolean innerForEachSegmentEntryWhile(Predicate<? super T> predicate)
```
  - forEachSegmentEntryWhile
```
public boolean forEachSegmentEntryWhile(Predicate<? super MapEntry<K,V>> predicate)
```
    Description copied from interface: HashSegmentContext
    
    Checks the given predicate on each present entry in this segment until all entries have been processed or the predicate returns false for some entry, or throws an Exception. Exceptions thrown by the predicate are relayed to the caller.
    If this segment is empty (i. e. HashSegmentContext.size() call returns 0), this method returns true immediately.
    
    Specified by:
    
    forEachSegmentEntryWhile in interface HashSegmentContext<K,MapEntry<K,V>>
    
    Parameters:
    
    predicate - the predicate to be checked for each entry in this segment
    
    Returns:
    
    true if the predicate returned true for all checked entries, false if it returned false for some entry
  - forEachSegmentEntry
```
public void forEachSegmentEntry(Consumer<? super MapEntry<K,V>> action)
```
    Description copied from interface: HashSegmentContext
    
    Performs the given action for each present entry in this segment until all entries have been processed or the action throws an Exception. Exceptions thrown by the action are relayed to the caller.
    
    Specified by:
    
    forEachSegmentEntry in interface HashSegmentContext<K,MapEntry<K,V>>
    
    Parameters:
    
    action - the action to be performed for each entry in this segment
  - forEachSegmentReplicableEntryWhile
```
public boolean forEachSegmentReplicableEntryWhile(Predicate<? super ReplicableEntry> predicate)
```
    Specified by:
    
    forEachSegmentReplicableEntryWhile in interface ReplicatedHashSegmentContext<K,MapEntry<K,V>>
  - forEachSegmentReplicableEntry
```
public void forEachSegmentReplicableEntry(Consumer<? super ReplicableEntry> action)
```
    Specified by:
    
    forEachSegmentReplicableEntry in interface ReplicatedHashSegmentContext<K,MapEntry<K,V>>
  - doRemoveCompletely
```
public void doRemoveCompletely()
```
    Description copied from interface: ReplicableEntry
    
    Completely remove the entry from the Chronicle hash, not just mark is as deleted, what MapEntry.doRemove() does for Replicated Chronicle hash. After calling this method the entry won't be replicated over to remote Chronicle nodes, as if ReplicableEntry.dropChanged() was called, and incoming entry replication event with the key if this entry will be processed, as the entry have never been present in the Chronicle hash. After calling this method any subsequent call of any method of ReplicableEntry class throws IllegalStateException.
    
    Specified by:
    
    doRemoveCompletely in interface ReplicableEntry
    
    See Also:
    
    ChronicleHashBuilder.cleanupRemovedEntries(boolean), ChronicleHashBuilder.removedEntryCleanupTimeout(long, TimeUnit)
  - timestamp
```
public long timestamp()
```
  - raiseChange
```
public void raiseChange()
```
  - updateChange
```
public void updateChange()
```
  - raiseChanged
```
public void raiseChanged()
```
    Description copied from interface: ReplicableEntry
    
    Propagate the entry, schedule it to be replicated over to remote Chronicle nodes.
    
    Specified by:
    
    raiseChanged in interface ReplicableEntry
  - originTimestamp
```
public long originTimestamp()
```
    Description copied from interface: ReplicableEntry
    
    The timestamp, associated with this entry. Originally, and by default, this timestamp means the time of the last.
    When the entry is replicated, this timestamp comes to remote nodes as RemoteOperationContext.remoteTimestamp().
    On ChronicleHash local operations with entries, like Map.put( Object, Object), this timestamp is overwritten using the configured time provider. On remote operations, proxied through MapRemoteOperations or SetRemoteOperations, you are free to overwrite this timestamp by any value, using ReplicableEntry.updateOrigin(byte, long) method.
    
    Specified by:
    
    originTimestamp in interface ReplicableEntry
    
    Returns:
    
    the timestamp, associated with this entry
    
    See Also:
    
    TimeProvider
  - moveChange
```
public void moveChange(long oldTierIndex,
                       long oldPos,
                       long newPos)
```
  - updatedReplicationStateOnPresentEntry
```
public void updatedReplicationStateOnPresentEntry()
```
  - originIdentifier
```
public byte originIdentifier()
```
    Description copied from interface: ReplicableEntry
    
    The identifier, associated with this entry. Originally, and by default, this identifier means the identifier of the ChronicleHash node on which this entry was updated last.
    When the entry is replicated, this identifier comes to remote nodes as RemoteOperationContext.remoteIdentifier().
    On ChronicleHash local operations with entries, like Map.put( Object, Object), this identifier is overwritten to the own ChronicleHash Replica.identifier(). On remote operations, proxied through MapRemoteOperations or SetRemoteOperations, you are free to overwrite this identifier to any value, using ReplicableEntry.updateOrigin(byte, long) method.
    
    Specified by:
    
    originIdentifier in interface ReplicableEntry
    
    Returns:
    
    the identifier, associated with this entry
  - entryEnd
```
protected long entryEnd()
```
  - closeReplicatedMapEntryStagesEntryEndDependants
```
public void closeReplicatedMapEntryStagesEntryEndDependants()
```
  - closeReplicatedMapEntryStagesEntrySizeDependants
```
public void closeReplicatedMapEntryStagesEntrySizeDependants()
```
  - entrySizeInChunksInit
```
public boolean entrySizeInChunksInit()
```
  - initEntrySizeInChunks
```
public void initEntrySizeInChunks(int actuallyUsedChunks)
```
  - entrySizeInChunks
```
public int entrySizeInChunks()
```
  - closeEntrySizeInChunks
```
public void closeEntrySizeInChunks()
```
  - innerRemoveEntryExceptHashLookupUpdate
```
public void innerRemoveEntryExceptHashLookupUpdate()
```
  - iterationRemove
```
public void iterationRemove()
```
  - writeNewEntry
```
public void writeNewEntry(long pos,
                          Data<?> key)
```
  - closeKeySearchKeyEqualsDependants
```
public void closeKeySearchKeyEqualsDependants()
```
  - initKeySearch
```
public void initKeySearch()
```
  - searchState
```
public CompiledReplicatedMapIterationContext.SearchState searchState()
```
  - searchStateDeleted
```
public boolean searchStateDeleted()
```
  - searchStatePresent
```
public boolean searchStatePresent()
```
  - searchStateAbsent
```
public boolean searchStateAbsent()
```
  - putNewVolatile
```
public void putNewVolatile(long value)
```
  - keyHashInit
```
public boolean keyHashInit()
```
  - keyHash
```
public long keyHash()
```
  - closeKeyHash
```
public void closeKeyHash()
```
  - closeKeyHashDependants
```
public void closeKeyHashDependants()
```
  - keyHashCode
```
public long keyHashCode()
```
    Specified by:
    
    keyHashCode in interface net.openhft.chronicle.hash.impl.stage.entry.KeyHashCode
  - closeIterationKeyHashCodeKeyHashCodeDependants
```
public void closeIterationKeyHashCodeKeyHashCodeDependants()
```
  - initDelayedUpdateChecksum
```
public void initDelayedUpdateChecksum(boolean delayedUpdateChecksum)
```
  - closeDelayedUpdateChecksum
```
public void closeDelayedUpdateChecksum()
```
  - allocatedChunksInit
```
public boolean allocatedChunksInit()
```
  - initAllocatedChunks
```
public void initAllocatedChunks(int allocatedChunks)
```
  - allocatedChunks
```
public int allocatedChunks()
```
  - closeAllocatedChunks
```
public void closeAllocatedChunks()
```
  - freeExtraAllocatedChunks
```
public final void freeExtraAllocatedChunks()
```
  - writeValueAndPutPos
```
public void writeValueAndPutPos(Data<V> value)
```
  - initEntryAndKeyCopying
```
public boolean initEntryAndKeyCopying(long entrySize,
                                      long bytesToCopy,
                                      long prevPos,
                                      int prevChunks)
```
  - relocation
```
protected void relocation(Data<V> newValue,
                          long newSizeOfEverythingBeforeValue)
```
  - innerDefaultReplaceValue
```
public void innerDefaultReplaceValue(Data<V> newValue)
```
  - doInsert
```
public void doInsert(Data<V> value)
```
    Description copied from interface: MapAbsentEntry
    
    Inserts the new entry into the map, of the key and the given value.
    This method is the default implementation for MapEntryOperations.insert( MapAbsentEntry, Data), which might be customized over the default.
    
    Specified by:
    
    doInsert in interface MapAbsentEntry<K,V>
    
    Parameters:
    
    value - the value to insert into the map along with the key
    
    See Also:
    
    MapEntryOperations.insert(MapAbsentEntry, Data)
  - doInsert
```
public void doInsert()
```
    Description copied from interface: SetAbsentEntry
    
    Inserts the new key into the set.
    This method is the default implementation for SetEntryOperations.insert( SetAbsentEntry), which might be customized over the default.
    
    Specified by:
    
    doInsert in interface SetAbsentEntry<K>
    
    See Also:
    
    SetEntryOperations.insert(SetAbsentEntry)
  - doReplaceValue
```
public void doReplaceValue(Data<V> newValue)
```
    Description copied from interface: MapEntry
    
    Replaces the entry's value with the given newValue.
    This method is the default implementation for MapEntryOperations.replaceValue( MapEntry, Data), which might be customized over the default.
    
    Specified by:
    
    doReplaceValue in interface MapEntry<K,V>
    
    Parameters:
    
    newValue - the value to be put into the map instead of the current value
  - doRemove
```
public void doRemove()
```
    Description copied from interface: HashEntry
    
    Removes the entry from the ChronicleHash.
    
    Specified by:
    
    doRemove in interface HashEntry<K>
    
    Specified by:
    
    doRemove in interface MapEntry<K,V>
  - replicationUpdateInit
```
public boolean replicationUpdateInit()
```
  - initReplicationUpdate
```
public void initReplicationUpdate(long timestamp,
                                  byte identifier)
```
  - innerRemoteIdentifier
```
public byte innerRemoteIdentifier()
```
  - innerRemoteTimestamp
```
public long innerRemoteTimestamp()
```
  - closeReplicationUpdate
```
public void closeReplicationUpdate()
```
  - remoteTimestamp
```
public long remoteTimestamp()
```
    Specified by:
    
    remoteTimestamp in interface RemoteOperationContext<K>
  - remoteIdentifier
```
public byte remoteIdentifier()
```
    Specified by:
    
    remoteIdentifier in interface RemoteOperationContext<K>

Class CompiledReplicatedMapIterationContext<K,V,R>

Nested Class Summary

Field Summary

Fields inherited from class net.openhft.chronicle.hash.impl.stage.hash.ThreadLocalState

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface net.openhft.chronicle.map.impl.VanillaChronicleMapHolder

Methods inherited from interface net.openhft.chronicle.core.io.Closeable

Methods inherited from interface net.openhft.chronicle.set.SetEntryOperations

Field Detail

indexInContextChain

innerReadLock

LOG

innerWriteLock

keyReader

innerUpdateLock

valueReader

rootContextInThisThread

contextChain

entryValue

segmentBS

checksumStrategy

segmentBytes

searchStartPos

keySize

hashLookupEntry

segmentIndex

tier

tierIndex

tierBaseAddr

entryRemovedOnThisIteration

inputKey

latestSameThreadSegmentModCount

contextModCount

nestedContextsLockedOnSameSegment

rootContextLockedOnThisSegment

hashLookupPos

pos

keySizeOffset

keyOffset

valueSizeOffset

valueSize

valueOffset

entrySizeInChunks

searchState

delayedUpdateChecksum

allocatedChunks

innerRemoteTimestamp

innerRemoteIdentifier

Constructor Detail

CompiledReplicatedMapIterationContext

CompiledReplicatedMapIterationContext

Method Detail

readZeroGuarded

reallocGuarded

updateZeroGuarded

writeZeroGuarded

decrementUpdateGuarded

decrementWriteGuarded

debugContextsAndLocksGuarded

allocReturnCodeGuarded

segmentBytesForReadGuarded

segmentBytesForWriteGuarded

close

freeExtraGuarded

freeGuarded

incrementModCountGuarded

incrementReadGuarded

incrementUpdateGuarded

incrementWriteGuarded

readUnlockAndDecrementCountGuarded

setHashLookupPosGuarded

setLocalLockStateGuarded

changeAndGetLatestSameThreadSegmentModCount

changeAndGetTotalReadLockCount

changeAndGetTotalUpdateLockCount

changeAndGetTotalWriteLockCount

decrementRead

decrementUpdate