mirror of
https://github.com/OpenHFT/Chronicle-Map.git
synced 2021-09-13 01:26:12 +00:00
HCOLL-216 added removeLater
This commit is contained in:
Rob Austin
@@ -33,19 +33,19 @@ import java.util.concurrent.Future;
|
||||
/**
|
||||
* Extension of {@link ConcurrentMap} interface, stores the data off-heap.
|
||||
*
|
||||
* <p>For information on <ul> <li>how to construct a {@code ChronicleMap}</li> <li>{@code ChronicleMap}
|
||||
* flavors and properties</li> <li>available configurations</li> </ul> see {@link AbstractChronicleMapBuilder}
|
||||
* documentation.
|
||||
* <p>For information on <ul> <li>how to construct a {@code ChronicleMap}</li> <li>{@code
|
||||
* ChronicleMap} flavors and properties</li> <li>available configurations</li> </ul> see {@link
|
||||
* AbstractChronicleMapBuilder} documentation.
|
||||
*
|
||||
* <p>Functionally this interface defines some methods supporting garbage-free off-heap programming: {@link
|
||||
* #getUsing(Object, Object)}, {@link #acquireUsing(Object, Object)}.
|
||||
* <p>Functionally this interface defines some methods supporting garbage-free off-heap programming:
|
||||
* {@link #getUsing(Object, Object)}, {@link #acquireUsing(Object, Object)}.
|
||||
*
|
||||
* <p>Roughly speaking, {@code ChronicleMap} compares keys and values by their binary serialized form, that
|
||||
* shouldn't necessary be the same equality relation as defined by built-in {@link Object#equals(Object)}
|
||||
* method, which is prescribed by general {@link Map} contract.
|
||||
* <p>Roughly speaking, {@code ChronicleMap} compares keys and values by their binary serialized
|
||||
* form, that shouldn't necessary be the same equality relation as defined by built-in {@link
|
||||
* Object#equals(Object)} method, which is prescribed by general {@link Map} contract.
|
||||
*
|
||||
* <p>Note that {@code ChronicleMap} extends {@link Closeable}, don't forget to {@linkplain #close() close}
|
||||
* map when it is no longer needed.
|
||||
* <p>Note that {@code ChronicleMap} extends {@link Closeable}, don't forget to {@linkplain #close()
|
||||
* close} map when it is no longer needed.
|
||||
*
|
||||
* @param <K> the map key type
|
||||
* @param <V> the map value type
|
||||
@@ -60,38 +60,41 @@ public interface ChronicleMap<K, V> extends ConcurrentMap<K, V>, ChronicleHash {
|
||||
long longSize();
|
||||
|
||||
/**
|
||||
* Returns the value to which the specified key is mapped, or {@code null} if this map contains no mapping
|
||||
* for the key.
|
||||
* Returns the value to which the specified key is mapped, or {@code null} if this map contains
|
||||
* no mapping for the key.
|
||||
*
|
||||
* <p>If the value class allows reusing, particularly if it is a {@link Byteable} subclass, consider
|
||||
* {@link #getUsing(Object, Object)} method instead of this to reduce garbage creation.
|
||||
* <p>If the value class allows reusing, particularly if it is a {@link Byteable} subclass,
|
||||
* consider {@link #getUsing(Object, Object)} method instead of this to reduce garbage
|
||||
* creation.
|
||||
*
|
||||
* @param key the key whose associated value is to be returned
|
||||
* @return the value to which the specified key is mapped after this method call, or {@code null} if no
|
||||
* value is mapped
|
||||
* @return the value to which the specified key is mapped after this method call, or {@code
|
||||
* null} if no value is mapped
|
||||
* @see #getUsing(Object, Object)
|
||||
*/
|
||||
@Override
|
||||
V get(Object key);
|
||||
|
||||
/**
|
||||
* Returns the value to which the specified key is mapped, read to the provided {@code value} object, if
|
||||
* possible, or returns {@code null}, if this map contains no mapping for the key.
|
||||
* Returns the value to which the specified key is mapped, read to the provided {@code value}
|
||||
* object, if possible, or returns {@code null}, if this map contains no mapping for the key.
|
||||
*
|
||||
* <p>If the specified key is present in the map, the value data is read to the provided {@code value}
|
||||
* object via value marshaller's {@link BytesMarshaller#read(Bytes, Object) read(Bytes, value)} or value
|
||||
* reader's {@link BytesReader#read(Bytes, long, Object) read(Bytes, size, value)} method, depending on
|
||||
* what deserialization strategy is configured on the builder, using which this map was constructed. If
|
||||
* the value deserializer is able to reuse the given {@code value} object, calling this method instead of
|
||||
* {@link #get(Object)} could help to reduce garbage creation.
|
||||
* <p>If the specified key is present in the map, the value data is read to the provided {@code
|
||||
* value} object via value marshaller's {@link BytesMarshaller#read(Bytes, Object) read(Bytes,
|
||||
* value)} or value reader's {@link BytesReader#read(Bytes, long, Object) read(Bytes, size,
|
||||
* value)} method, depending on what deserialization strategy is configured on the builder,
|
||||
* using which this map was constructed. If the value deserializer is able to reuse the given
|
||||
* {@code value} object, calling this method instead of {@link #get(Object)} could help to
|
||||
* reduce garbage creation.
|
||||
*
|
||||
* <p>The provided {@code value} object is allowed to be {@code null}, in this case {@code
|
||||
* map.getUsing(key, null)} call is semantically equivalent to simple {@code map.get(key)} call.
|
||||
* map.getUsing(key, null)} call is semantically equivalent to simple {@code map.get(key)}
|
||||
* call.
|
||||
*
|
||||
* @param key the key whose associated value is to be returned
|
||||
* @param usingValue the object to read value data in, if possible
|
||||
* @return the value to which the specified key is mapped, or {@code null} if this map contains no mapping
|
||||
* for the key
|
||||
* @return the value to which the specified key is mapped, or {@code null} if this map contains
|
||||
* no mapping for the key
|
||||
* @see #get(Object)
|
||||
* @see #acquireUsing(Object, Object)
|
||||
* @see OnHeapUpdatableChronicleMapBuilder#valueMarshaller(BytesMarshaller)
|
||||
@@ -99,31 +102,33 @@ public interface ChronicleMap<K, V> extends ConcurrentMap<K, V>, ChronicleHash {
|
||||
V getUsing(K key, V usingValue);
|
||||
|
||||
/**
|
||||
* The method is similar {@link V getUsing(K key, V usingValue);} but in addition read locks the map
|
||||
* segment to operations to be performed atomically. ( see the example below )
|
||||
* The method is similar {@link V getUsing(K key, V usingValue);} but in addition read locks
|
||||
* the map segment to operations to be performed atomically. ( see the example below )
|
||||
*
|
||||
* Returns the ReadContext which holds a map segment lock and provides method to get the value ( to which
|
||||
* the specified key is mapped) atomically ( see example below for an explanation ), read to the provided
|
||||
* {@code value} object, if possible, or returns {@code null}, if this map contains no mapping for the
|
||||
* key.
|
||||
* Returns the ReadContext which holds a map segment lock and provides method to get the value
|
||||
* ( to which the specified key is mapped) atomically ( see example below for an explanation ),
|
||||
* read to the provided {@code value} object, if possible, or returns {@code null}, if this map
|
||||
* contains no mapping for the key.
|
||||
*
|
||||
* <p>If the specified key is present in the map, the readContext.value() uses the provided {@code
|
||||
* usingValue} object via value marshaller's {@link BytesMarshaller#read(Bytes, Object) read(Bytes,
|
||||
* value)} or value reader's {@link BytesReader#read(Bytes, long, Object) read(Bytes, size, value)}
|
||||
* method, depending on what deserialization strategy is configured on the builder, using which this map
|
||||
* was constructed. If the value deserializer is able to reuse the given {@code usingValue} object,
|
||||
* calling this method instead of {@link #get(Object)} could help to reduce garbage creation.
|
||||
* <p>If the specified key is present in the map, the readContext.value() uses the provided
|
||||
* {@code usingValue} object via value marshaller's {@link BytesMarshaller#read(Bytes, Object)
|
||||
* read(Bytes, value)} or value reader's {@link BytesReader#read(Bytes, long, Object)
|
||||
* read(Bytes, size, value)} method, depending on what deserialization strategy is configured on
|
||||
* the builder, using which this map was constructed. If the value deserializer is able to reuse
|
||||
* the given {@code usingValue} object, calling this method instead of {@link #get(Object)}
|
||||
* could help to reduce garbage creation.
|
||||
* <pre>{@code
|
||||
* try (ReadContext rc = map.getUsingLocked(key, bond)) {
|
||||
* if (rc.present ()) { // check whether the key was present
|
||||
* long issueDate = bond.getIssueDate();
|
||||
* String symbol = bond.getSymbol();
|
||||
* // add your logic here ( the lock will ensure this bond can not be changed by another thread )
|
||||
* // add your logic here ( the lock will ensure this bond can not be changed by another thread
|
||||
* )
|
||||
* }
|
||||
* } // the read lock is released here
|
||||
* }</pre>
|
||||
* To ensure that you can read the 'issueDate' and 'symbol' can be read atomically, these values must be
|
||||
* read while the segment lock is in place.
|
||||
* To ensure that you can read the 'issueDate' and 'symbol' can be read atomically, these values
|
||||
* must be read while the segment lock is in place.
|
||||
*
|
||||
*
|
||||
* <p>The provided {@code value} object is allowed to be {@code null}, in this case
|
||||
@@ -145,13 +150,14 @@ public interface ChronicleMap<K, V> extends ConcurrentMap<K, V>, ChronicleHash {
|
||||
*
|
||||
* <p>If the specified key is absent in the map, {@linkplain AbstractChronicleMapBuilder#defaultValue(Object)
|
||||
* default value} is taken or {@linkplain AbstractChronicleMapBuilder#defaultValueProvider(DefaultValueProvider)
|
||||
* default value provider} is called. Then this object is put to this map for the specified key.
|
||||
* default value provider} is called. Then this object is put to this map for the specified
|
||||
* key.
|
||||
*
|
||||
* <p>Then, either if the key was initially absent in the map or already present, the value is
|
||||
* deserialized just as during {@link #getUsing(Object, Object) getUsing(key, usingValue)} call, passed
|
||||
* the same {@code key} and {@code usingValue} as into this method call. This means, as in {@link
|
||||
* #getUsing}, {@code usingValue} could safely be {@code null}, in this case a new value instance is
|
||||
* created to deserialize the data.
|
||||
* deserialized just as during {@link #getUsing(Object, Object) getUsing(key, usingValue)} call,
|
||||
* passed the same {@code key} and {@code usingValue} as into this method call. This means, as
|
||||
* in {@link #getUsing}, {@code usingValue} could safely be {@code null}, in this case a new
|
||||
* value instance is created to deserialize the data.
|
||||
*
|
||||
* In code, {@code acquireUsing} is specified as :
|
||||
* <pre>{@code
|
||||
@@ -166,11 +172,11 @@ public interface ChronicleMap<K, V> extends ConcurrentMap<K, V>, ChronicleHash {
|
||||
* default value} or {@link AbstractChronicleMapBuilder#defaultValueProvider(DefaultValueProvider)
|
||||
* defaultValueProvider.}
|
||||
*
|
||||
* <p>If the {@code ChronicleMap} is off-heap updatable, i. e. created via {@link ChronicleMapBuilder}
|
||||
* builder (values are {@link Byteable}), there is one more option of what to do if the key is absent in
|
||||
* the map, see {@link ChronicleMapBuilder#prepareValueBytesOnAcquire(PrepareValueBytes)}. By default,
|
||||
* value bytes are just zeroed out, no default value, either provided for key or constant, is put for the
|
||||
* absent key.
|
||||
* <p>If the {@code ChronicleMap} is off-heap updatable, i. e. created via {@link
|
||||
* ChronicleMapBuilder} builder (values are {@link Byteable}), there is one more option of what
|
||||
* to do if the key is absent in the map, see {@link ChronicleMapBuilder#prepareValueBytesOnAcquire(PrepareValueBytes)}.
|
||||
* By default, value bytes are just zeroed out, no default value, either provided for key or
|
||||
* constant, is put for the absent key.
|
||||
*
|
||||
* @param key the key whose associated value is to be returned
|
||||
* @param usingValue the object to read value data in, if present. Can not be null
|
||||
@@ -194,8 +200,8 @@ public interface ChronicleMap<K, V> extends ConcurrentMap<K, V>, ChronicleHash {
|
||||
<R> R mapForKey(K key, @NotNull Function<? super V, R> function);
|
||||
|
||||
/**
|
||||
* Apply a mutator to the value for a key and return a result. A write lock is assumed. <p> If there is no
|
||||
* entry for this key it will be created and the value empty.
|
||||
* Apply a mutator to the value for a key and return a result. A write lock is assumed. <p> If
|
||||
* there is no entry for this key it will be created and the value empty.
|
||||
*
|
||||
* @param key to apply the mapping to
|
||||
* @param mutator to alter the value and calculate a result
|
||||
@@ -205,13 +211,16 @@ public interface ChronicleMap<K, V> extends ConcurrentMap<K, V>, ChronicleHash {
|
||||
<R> R updateForKey(K key, @NotNull Mutator<? super V, R> mutator);
|
||||
|
||||
/**
|
||||
* Returns a {@link java.util.concurrent.Future} containing the value to which the specified key is
|
||||
* mapped, or {@code null} if this map contains no mapping for the key. This method behaves the same as
|
||||
* {@link java.util.Map#get(java.lang.Object)} yet wraps result in a future a {@link
|
||||
* Returns a {@link java.util.concurrent.Future} containing the value to which the specified key
|
||||
* is mapped, or {@code null} if this map contains no mapping for the key. This method behaves
|
||||
* the same as {@link java.util.Map#get(java.lang.Object)} yet wraps result in a future a {@link
|
||||
* java.util.concurrent.Future}.
|
||||
*
|
||||
* @return a future containing the value to which the specified key is mapped after this method call, or
|
||||
* {@code null} if no value is mapped
|
||||
* Calling this method may or may not block until the operating is complete depending on the
|
||||
* implementation.
|
||||
*
|
||||
* @return a future containing the value to which the specified key is mapped after this method
|
||||
* call, or {@code null} if no value is mapped
|
||||
* @see java.util.Map#get(java.lang.Object)
|
||||
* @see java.util.concurrent.Future
|
||||
*/
|
||||
@@ -219,18 +228,46 @@ public interface ChronicleMap<K, V> extends ConcurrentMap<K, V>, ChronicleHash {
|
||||
|
||||
|
||||
/**
|
||||
* Associates the specified value with the specified key in this map (optional operation). If the map
|
||||
* previously contained a mapping for the key, the old value is replaced by the specified value. (A map
|
||||
* <tt>m</tt> is said to contain a mapping for a key <tt>k</tt> if and only if {@link #containsKey(Object)
|
||||
* m.containsKey(k)} would return <tt>true</tt>.)
|
||||
* Associates the specified value with the specified key in this map (optional operation). If
|
||||
* the map previously contained a mapping for the key, the old value is replaced by the
|
||||
* specified value. (A map <tt>m</tt> is said to contain a mapping for a key <tt>k</tt> if and
|
||||
* only if {@link #containsKey(Object) m.containsKey(k)} would return <tt>true</tt>.)
|
||||
*
|
||||
* @return a future containing the previous value associated with <tt>key</tt>, or <tt>null</tt> if there
|
||||
* was no mapping for <tt>key</tt>. (A <tt>null</tt> return can also indicate that the map previously
|
||||
* associated <tt>null</tt> with <tt>key</tt>, if the implementation supports <tt>null</tt> values.)
|
||||
* @see java.util.Map#get(java.lang.Object)
|
||||
* Calling this method may or may not block until the operating is complete depending on the
|
||||
* implementation.
|
||||
*
|
||||
* @return a future containing the previous value associated with <tt>key</tt>, or <tt>null</tt>
|
||||
* if there was no mapping for <tt>key</tt>. (A <tt>null</tt> return can also indicate that the
|
||||
* map previously associated <tt>null</tt> with <tt>key</tt>, if the implementation supports
|
||||
* <tt>null</tt> values.)
|
||||
* @see java.util.Map#put(java.lang.Object, java.lang.Object)
|
||||
* @see java.util.concurrent.Future
|
||||
*/
|
||||
Future<V> putLater(@NotNull K key,@NotNull V value);
|
||||
Future<V> putLater(@NotNull K key, @NotNull V value);
|
||||
|
||||
|
||||
/**
|
||||
* Removes the mapping for a key from this map if it is present (optional operation). More
|
||||
* formally, if this map contains a mapping from key <tt>k</tt> to value <tt>v</tt> such that
|
||||
* <code>(key==null ? k==null : key.equals(k))</code>, that mapping is removed. (The map can
|
||||
* contain at most one such mapping.)
|
||||
*
|
||||
* <p>Returns a future containing, either the value to which this map previously associated the
|
||||
* key, or <tt>null</tt> if the map contained no mapping for the key.
|
||||
*
|
||||
* This method behaves the same as {@link java.util.Map#remove(java.lang.Object)} yet wraps
|
||||
* result in a future a {@link java.util.concurrent.Future}.
|
||||
*
|
||||
* Calling this method may or may not block until the operating is complete depending on the
|
||||
* implementation.
|
||||
*
|
||||
* @param key key whose mapping is to be removed from the map
|
||||
* @return a future containing either, the previous value associated with <tt>key</tt>, or
|
||||
* <tt>null</tt> if there was no mapping for <tt>key</tt>.
|
||||
* @see java.util.Map#remove(java.lang.Object)
|
||||
* @see java.util.concurrent.Future
|
||||
*/
|
||||
Future<V> removeLater(@NotNull K key);
|
||||
|
||||
}
|
||||
|
||||
|
||||
@@ -155,6 +155,18 @@ class StatelessChronicleMap<K, V> implements ChronicleMap<K, V>, Closeable, Clon
|
||||
});
|
||||
}
|
||||
|
||||
@Override
|
||||
public Future<V> removeLater(@NotNull final K key) {
|
||||
return lazyExecutorService().submit(new Callable<V>() {
|
||||
@Override
|
||||
public V call() throws Exception {
|
||||
|
||||
V oldValue = StatelessChronicleMap.this.remove(key);
|
||||
return oldValue;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
private ExecutorService lazyExecutorService() {
|
||||
|
||||
@@ -485,7 +497,7 @@ class StatelessChronicleMap<K, V> implements ChronicleMap<K, V>, Closeable, Clon
|
||||
if (key == null)
|
||||
throw new NullPointerException("key can not be null");
|
||||
|
||||
final long sizeLocation = (removeReturnsNull) ? writeEvent(REMOVE_WITHOUT_ACC) : writeEventAnSkip(REMOVE);
|
||||
final long sizeLocation = removeReturnsNull ? writeEvent(REMOVE_WITHOUT_ACC) : writeEventAnSkip(REMOVE);
|
||||
|
||||
|
||||
writeKey((K) key);
|
||||
|
||||
@@ -1641,6 +1641,7 @@ class StatelessServerConnector<K, V> {
|
||||
final K key = readKey(reader, local);
|
||||
|
||||
try {
|
||||
LOG.info("removing entry key="+key);
|
||||
writeValue(map.remove(key), writer, local);
|
||||
} catch (Throwable e) {
|
||||
return sendException(writer, sizeLocation, e);
|
||||
|
||||
@@ -58,7 +58,8 @@ class VanillaChronicleMap<K, KI, MKI extends MetaBytesInterop<K, KI>,
|
||||
implements ChronicleMap<K, V>, Serializable {
|
||||
|
||||
/**
|
||||
* Because DirectBitSet implementations couldn't find more than 64 continuous clear or set bits.
|
||||
* Because DirectBitSet implementations couldn't find more than 64 continuous clear or set
|
||||
* bits.
|
||||
*/
|
||||
static final int MAX_ENTRY_OVERSIZE_FACTOR = 64;
|
||||
static final ThreadLocal<MultiStoreBytes> tmpBytes = new ThreadLocal<>();
|
||||
@@ -448,6 +449,38 @@ class VanillaChronicleMap<K, KI, MKI extends MetaBytesInterop<K, KI>,
|
||||
};
|
||||
}
|
||||
|
||||
@Override
|
||||
public Future<V> removeLater(@NotNull K key) {
|
||||
final V v = remove(key);
|
||||
return new Future<V>() {
|
||||
|
||||
@Override
|
||||
public boolean cancel(boolean mayInterruptIfRunning) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isCancelled() {
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isDone() {
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public V get() throws InterruptedException, ExecutionException {
|
||||
return v;
|
||||
}
|
||||
|
||||
@Override
|
||||
public V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
|
||||
return v;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public WriteContext<K, V> acquireUsingLocked(@NotNull K key, @NotNull V usingValue) {
|
||||
@@ -569,9 +602,9 @@ class VanillaChronicleMap<K, KI, MKI extends MetaBytesInterop<K, KI>,
|
||||
|
||||
|
||||
/**
|
||||
* removes ( if there exists ) an entry from the map, if the {@param key} and {@param expectedValue} match
|
||||
* that of a maps.entry. If the {@param expectedValue} equals null then ( if there exists ) an entry whose
|
||||
* key equals {@param key} this is removed.
|
||||
* removes ( if there exists ) an entry from the map, if the {@param key} and {@param
|
||||
* expectedValue} match that of a maps.entry. If the {@param expectedValue} equals null then (
|
||||
* if there exists ) an entry whose key equals {@param key} this is removed.
|
||||
*
|
||||
* @param k the key of the entry to remove
|
||||
* @param expectedValue null if not required
|
||||
@@ -631,8 +664,8 @@ class VanillaChronicleMap<K, KI, MKI extends MetaBytesInterop<K, KI>,
|
||||
* replace the value in a map, only if the existing entry equals {@param existingValue}
|
||||
*
|
||||
* @param key the key into the map
|
||||
* @param existingValue the expected existing value in the map ( could be null when we don't wish to do
|
||||
* this check )
|
||||
* @param existingValue the expected existing value in the map ( could be null when we don't
|
||||
* wish to do this check )
|
||||
* @param newValue the new value you wish to store in the map
|
||||
* @return the value that was replaced
|
||||
*/
|
||||
@@ -1174,13 +1207,13 @@ class VanillaChronicleMap<K, KI, MKI extends MetaBytesInterop<K, KI>,
|
||||
}
|
||||
|
||||
/**
|
||||
* Removes a key (or key-value pair) from the Segment. <p/> <p>The entry will only be removed if
|
||||
* {@code expectedValue} equals to {@code null} or the value previously corresponding to the specified
|
||||
* key.
|
||||
* Removes a key (or key-value pair) from the Segment. <p/> <p>The entry will only be
|
||||
* removed if {@code expectedValue} equals to {@code null} or the value previously
|
||||
* corresponding to the specified key.
|
||||
*
|
||||
* @param hash2 a hash code related to the {@code keyBytes}
|
||||
* @return the value of the entry that was removed if the entry corresponding to the {@code keyBytes}
|
||||
* exists and {@link #removeReturnsNull} is {@code false}, {@code null} otherwise
|
||||
* @return the value of the entry that was removed if the entry corresponding to the {@code
|
||||
* keyBytes} exists and {@link #removeReturnsNull} is {@code false}, {@code null} otherwise
|
||||
*/
|
||||
V remove(ThreadLocalCopies copies, MKI metaKeyInterop, KI keyInterop, K key,
|
||||
V expectedValue, long hash2) {
|
||||
@@ -1240,9 +1273,9 @@ class VanillaChronicleMap<K, KI, MKI extends MetaBytesInterop<K, KI>,
|
||||
}
|
||||
|
||||
/**
|
||||
* Replaces the specified value for the key with the given value. {@code newValue} is set only if the
|
||||
* existing value corresponding to the specified key is equal to {@code expectedValue} or {@code
|
||||
* expectedValue == null}.
|
||||
* Replaces the specified value for the key with the given value. {@code newValue} is set
|
||||
* only if the existing value corresponding to the specified key is equal to {@code
|
||||
* expectedValue} or {@code expectedValue == null}.
|
||||
*
|
||||
* @param hash2 a hash code related to the {@code keyBytes}
|
||||
* @return the replaced value or {@code null} if the value was not replaced
|
||||
@@ -1319,17 +1352,17 @@ class VanillaChronicleMap<K, KI, MKI extends MetaBytesInterop<K, KI>,
|
||||
}
|
||||
|
||||
/**
|
||||
* Replaces value in existing entry. May cause entry relocation, because there may be not enough space
|
||||
* for new value in location already allocated for this entry.
|
||||
* Replaces value in existing entry. May cause entry relocation, because there may be not
|
||||
* enough space for new value in location already allocated for this entry.
|
||||
*
|
||||
* @param pos index of the first block occupied by the entry
|
||||
* @param offset relative offset of the entry in Segment bytes (before, i. e. including
|
||||
* metaData)
|
||||
* @param offset relative offset of the entry in Segment bytes (before, i. e.
|
||||
* including metaData)
|
||||
* @param entry relative pointer in Segment bytes
|
||||
* @param valueSizePos relative position of value size in entry
|
||||
* @param entryEndAddr absolute address of the entry end
|
||||
* @return relative offset of the entry in Segment bytes after putting value (that may cause entry
|
||||
* relocation)
|
||||
* @return relative offset of the entry in Segment bytes after putting value (that may cause
|
||||
* entry relocation)
|
||||
*/
|
||||
long putValue(long pos, long offset, NativeBytes entry, long valueSizePos,
|
||||
long entryEndAddr, ThreadLocalCopies copies, V value, Bytes valueBytes,
|
||||
|
||||
Reference in New Issue
Block a user