test_class.declarator: testMap
test_class.modifier: private
test_class.original_string: private InternalOakMap<Integer, Integer> testMap;
test_class.type: InternalOakMap<Integer, Integer>
test_class.var_name: testMap
test_class.declarator: OPERATION_DELAY = 100
test_class.modifier: private static final
test_class.original_string: private static final long OPERATION_DELAY = 100;
test_class.type: long
test_class.var_name: OPERATION_DELAY
test_class.declarator: LONG_TRANSFORMATION_DELAY = 1000
test_class.modifier: private static final
test_class.original_string: private static final long LONG_TRANSFORMATION_DELAY = 1000;
test_class.type: long
test_class.var_name: LONG_TRANSFORMATION_DELAY
test_class.file: core/src/test/java/com/yahoo/oak/InternalOakMapTest.java
test_class.identifier: InternalOakMapTest
test_case.body: @Test
      public void concurrentPuts() throws InterruptedException {
          Integer k = 1;
          Integer v1 = 1;
          Integer v2 = 2;
          Integer v3 = 3;
  
          final Integer[] results = new Integer[3];
  
          List<Thread> threadList = new ArrayList<>(results.length);
          threadList.add(new Thread(() -> results[0] = testMap.put(k, v1,
                  OakCommonBuildersFactory.DEFAULT_INT_SERIALIZER::deserialize)));
          threadList.add(new Thread(() -> results[1] = testMap.put(k, v2, InternalOakMapTest::slowDeserialize)));
          threadList.add(new Thread(() -> results[2] = testMap.put(k, v3,
                  OakCommonBuildersFactory.DEFAULT_INT_SERIALIZER::deserialize)));
  
          runThreads(threadList);
  
          Assert.assertNull(results[0]);
          Assert.assertNotEquals(results[1], results[2]);
      }
test_case.class_method_signature: InternalOakMapTest.concurrentPuts()
test_case.full_signature: @Test public void concurrentPuts()
test_case.identifier: concurrentPuts
test_case.invocations: add put add put add put runThreads assertNull assertNotEquals
test_case.modifiers: @Test public
test_case.parameters: ()
test_case.return: void
test_case.signature: void concurrentPuts()
focal_class.declarator: skiplist
focal_class.modifier: final
focal_class.original_string: final ConcurrentSkipListMap<Object, Chunk<K, V>> skiplist;
focal_class.type: ConcurrentSkipListMap<Object, Chunk<K, V>>
focal_class.var_name: skiplist
focal_class.declarator: head
focal_class.modifier: private final
focal_class.original_string: private final AtomicReference<Chunk<K, V>> head;
focal_class.type: AtomicReference<Chunk<K, V>>
focal_class.var_name: head
focal_class.declarator: comparator
focal_class.modifier: private final
focal_class.original_string: private final OakComparator<K> comparator;
focal_class.type: OakComparator<K>
focal_class.var_name: comparator
focal_class.declarator: valuesMemoryManager
focal_class.modifier: private final
focal_class.original_string: private final MemoryManager valuesMemoryManager;
focal_class.type: MemoryManager
focal_class.var_name: valuesMemoryManager
focal_class.declarator: keysMemoryManager
focal_class.modifier: private final
focal_class.original_string: private final MemoryManager keysMemoryManager;
focal_class.type: MemoryManager
focal_class.var_name: keysMemoryManager
focal_class.declarator: size
focal_class.modifier: private final
focal_class.original_string: private final AtomicInteger size;
focal_class.type: AtomicInteger
focal_class.var_name: size
focal_class.declarator: keySerializer
focal_class.modifier: private final
focal_class.original_string: private final OakSerializer<K> keySerializer;
focal_class.type: OakSerializer<K>
focal_class.var_name: keySerializer
focal_class.declarator: valueSerializer
focal_class.modifier: private final
focal_class.original_string: private final OakSerializer<V> valueSerializer;
focal_class.type: OakSerializer<V>
focal_class.var_name: valueSerializer
focal_class.declarator: referenceCount = new AtomicInteger(1)
focal_class.modifier: private final
focal_class.original_string: private final AtomicInteger referenceCount = new AtomicInteger(1);
focal_class.type: AtomicInteger
focal_class.var_name: referenceCount
focal_class.declarator: valueOperator
focal_class.modifier: private final
focal_class.original_string: private final ValueUtils valueOperator;
focal_class.type: ValueUtils
focal_class.var_name: valueOperator
focal_class.declarator: MAX_RETRIES = 1024
focal_class.modifier: static final
focal_class.original_string: static final int MAX_RETRIES = 1024;
focal_class.type: int
focal_class.var_name: MAX_RETRIES
focal_class.file: core/src/main/java/com/yahoo/oak/InternalOakMap.java
focal_class.identifier: InternalOakMap
focal_class.class_method_signature: InternalOakMap.InternalOakMap(K minKey, OakSerializer<K> keySerializer, OakSerializer<V> valueSerializer,
          OakComparator<K> oakComparator, MemoryManager vMM, MemoryManager kMM, int chunkMaxItems,
          ValueUtils valueOperator)
focal_class.full_signature:   InternalOakMap(K minKey, OakSerializer<K> keySerializer, OakSerializer<V> valueSerializer,
          OakComparator<K> oakComparator, MemoryManager vMM, MemoryManager kMM, int chunkMaxItems,
          ValueUtils valueOperator)
focal_class.identifier: InternalOakMap
focal_class.parameters: (K minKey, OakSerializer<K> keySerializer, OakSerializer<V> valueSerializer,
          OakComparator<K> oakComparator, MemoryManager vMM, MemoryManager kMM, int chunkMaxItems,
          ValueUtils valueOperator)
focal_class.signature:  InternalOakMap(K minKey, OakSerializer<K> keySerializer, OakSerializer<V> valueSerializer,
          OakComparator<K> oakComparator, MemoryManager vMM, MemoryManager kMM, int chunkMaxItems,
          ValueUtils valueOperator)
focal_class.class_method_signature: InternalOakMap.close()
focal_class.full_signature:  void close()
focal_class.identifier: close
focal_class.parameters: ()
focal_class.return: void
focal_class.signature: void close()
focal_class.class_method_signature: InternalOakMap.open()
focal_class.full_signature:  void open()
focal_class.identifier: open
focal_class.parameters: ()
focal_class.return: void
focal_class.signature: void open()
focal_class.class_method_signature: InternalOakMap.memorySize()
focal_class.full_signature:  long memorySize()
focal_class.identifier: memorySize
focal_class.parameters: ()
focal_class.return: long
focal_class.signature: long memorySize()
focal_class.class_method_signature: InternalOakMap.entries()
focal_class.full_signature:  int entries()
focal_class.identifier: entries
focal_class.parameters: ()
focal_class.return: int
focal_class.signature: int entries()
focal_class.class_method_signature: InternalOakMap.getThreadContext()
focal_class.full_signature:  ThreadContext getThreadContext()
focal_class.identifier: getThreadContext
focal_class.parameters: ()
focal_class.return: ThreadContext
focal_class.signature: ThreadContext getThreadContext()
focal_class.class_method_signature: InternalOakMap.iterateChunks(final Chunk<K, V> inputChunk, K key)
focal_class.full_signature: private Chunk<K, V> iterateChunks(final Chunk<K, V> inputChunk, K key)
focal_class.identifier: iterateChunks
focal_class.modifiers: private
focal_class.parameters: (final Chunk<K, V> inputChunk, K key)
focal_class.return: Chunk<K, V>
focal_class.signature: Chunk<K, V> iterateChunks(final Chunk<K, V> inputChunk, K key)
focal_class.class_method_signature: InternalOakMap.overwriteExistingValueForMove(ThreadContext ctx, V newVal, Chunk<K, V> c)
focal_class.full_signature:  boolean overwriteExistingValueForMove(ThreadContext ctx, V newVal, Chunk<K, V> c)
focal_class.identifier: overwriteExistingValueForMove
focal_class.parameters: (ThreadContext ctx, V newVal, Chunk<K, V> c)
focal_class.return: boolean
focal_class.signature: boolean overwriteExistingValueForMove(ThreadContext ctx, V newVal, Chunk<K, V> c)
focal_class.class_method_signature: InternalOakMap.rebalance(Chunk<K, V> c)
focal_class.full_signature: private void rebalance(Chunk<K, V> c)
focal_class.identifier: rebalance
focal_class.modifiers: private
focal_class.parameters: (Chunk<K, V> c)
focal_class.return: void
focal_class.signature: void rebalance(Chunk<K, V> c)
focal_class.class_method_signature: InternalOakMap.checkRebalance(Chunk<K, V> c)
focal_class.full_signature: private void checkRebalance(Chunk<K, V> c)
focal_class.identifier: checkRebalance
focal_class.modifiers: private
focal_class.parameters: (Chunk<K, V> c)
focal_class.return: void
focal_class.signature: void checkRebalance(Chunk<K, V> c)
focal_class.class_method_signature: InternalOakMap.connectToChunkList(List<Chunk<K, V>> engaged, List<Chunk<K, V>> children)
focal_class.full_signature: private void connectToChunkList(List<Chunk<K, V>> engaged, List<Chunk<K, V>> children)
focal_class.identifier: connectToChunkList
focal_class.modifiers: private
focal_class.parameters: (List<Chunk<K, V>> engaged, List<Chunk<K, V>> children)
focal_class.return: void
focal_class.signature: void connectToChunkList(List<Chunk<K, V>> engaged, List<Chunk<K, V>> children)
focal_class.class_method_signature: InternalOakMap.updateLastChild(List<Chunk<K, V>> engaged, List<Chunk<K, V>> children)
focal_class.full_signature: private void updateLastChild(List<Chunk<K, V>> engaged, List<Chunk<K, V>> children)
focal_class.identifier: updateLastChild
focal_class.modifiers: private
focal_class.parameters: (List<Chunk<K, V>> engaged, List<Chunk<K, V>> children)
focal_class.return: void
focal_class.signature: void updateLastChild(List<Chunk<K, V>> engaged, List<Chunk<K, V>> children)
focal_class.class_method_signature: InternalOakMap.updateIndexAndNormalize(List<Chunk<K, V>> engagedChunks, List<Chunk<K, V>> children)
focal_class.full_signature: private void updateIndexAndNormalize(List<Chunk<K, V>> engagedChunks, List<Chunk<K, V>> children)
focal_class.identifier: updateIndexAndNormalize
focal_class.modifiers: private
focal_class.parameters: (List<Chunk<K, V>> engagedChunks, List<Chunk<K, V>> children)
focal_class.return: void
focal_class.signature: void updateIndexAndNormalize(List<Chunk<K, V>> engagedChunks, List<Chunk<K, V>> children)
focal_class.class_method_signature: InternalOakMap.inTheMiddleOfRebalance(Chunk<K, V> c)
focal_class.full_signature: private boolean inTheMiddleOfRebalance(Chunk<K, V> c)
focal_class.identifier: inTheMiddleOfRebalance
focal_class.modifiers: private
focal_class.parameters: (Chunk<K, V> c)
focal_class.return: boolean
focal_class.signature: boolean inTheMiddleOfRebalance(Chunk<K, V> c)
focal_class.class_method_signature: InternalOakMap.finalizeDeletion(Chunk<K, V> c, ThreadContext ctx)
focal_class.full_signature: private boolean finalizeDeletion(Chunk<K, V> c, ThreadContext ctx)
focal_class.identifier: finalizeDeletion
focal_class.modifiers: private
focal_class.parameters: (Chunk<K, V> c, ThreadContext ctx)
focal_class.return: boolean
focal_class.signature: boolean finalizeDeletion(Chunk<K, V> c, ThreadContext ctx)
focal_class.class_method_signature: InternalOakMap.isAfterRebalanceOrValueUpdate(Chunk c, ThreadContext ctx)
focal_class.full_signature: private boolean isAfterRebalanceOrValueUpdate(Chunk c, ThreadContext ctx)
focal_class.identifier: isAfterRebalanceOrValueUpdate
focal_class.modifiers: private
focal_class.parameters: (Chunk c, ThreadContext ctx)
focal_class.return: boolean
focal_class.signature: boolean isAfterRebalanceOrValueUpdate(Chunk c, ThreadContext ctx)
focal_class.class_method_signature: InternalOakMap.allocateAndLinkEntry(Chunk c, ThreadContext ctx, K key, boolean isPutIfAbsent)
focal_class.full_signature: private boolean allocateAndLinkEntry(Chunk c, ThreadContext ctx, K key, boolean isPutIfAbsent)
focal_class.identifier: allocateAndLinkEntry
focal_class.modifiers: private
focal_class.parameters: (Chunk c, ThreadContext ctx, K key, boolean isPutIfAbsent)
focal_class.return: boolean
focal_class.signature: boolean allocateAndLinkEntry(Chunk c, ThreadContext ctx, K key, boolean isPutIfAbsent)
focal_class.class_method_signature: InternalOakMap.put(K key, V value, OakTransformer<V> transformer)
focal_class.full_signature:  V put(K key, V value, OakTransformer<V> transformer)
focal_class.identifier: put
focal_class.parameters: (K key, V value, OakTransformer<V> transformer)
focal_class.return: V
focal_class.signature: V put(K key, V value, OakTransformer<V> transformer)
focal_class.class_method_signature: InternalOakMap.putIfAbsent(K key, V value, OakTransformer<V> transformer)
focal_class.full_signature:  Result putIfAbsent(K key, V value, OakTransformer<V> transformer)
focal_class.identifier: putIfAbsent
focal_class.parameters: (K key, V value, OakTransformer<V> transformer)
focal_class.return: Result
focal_class.signature: Result putIfAbsent(K key, V value, OakTransformer<V> transformer)
focal_class.class_method_signature: InternalOakMap.putIfAbsentComputeIfPresent(K key, V value, Consumer<OakScopedWriteBuffer> computer)
focal_class.full_signature:  boolean putIfAbsentComputeIfPresent(K key, V value, Consumer<OakScopedWriteBuffer> computer)
focal_class.identifier: putIfAbsentComputeIfPresent
focal_class.parameters: (K key, V value, Consumer<OakScopedWriteBuffer> computer)
focal_class.return: boolean
focal_class.signature: boolean putIfAbsentComputeIfPresent(K key, V value, Consumer<OakScopedWriteBuffer> computer)
focal_class.class_method_signature: InternalOakMap.remove(K key, V oldValue, OakTransformer<V> transformer)
focal_class.full_signature:  Result remove(K key, V oldValue, OakTransformer<V> transformer)
focal_class.identifier: remove
focal_class.parameters: (K key, V oldValue, OakTransformer<V> transformer)
focal_class.return: Result
focal_class.signature: Result remove(K key, V oldValue, OakTransformer<V> transformer)
focal_class.class_method_signature: InternalOakMap.get(K key)
focal_class.full_signature:  OakUnscopedBuffer get(K key)
focal_class.identifier: get
focal_class.parameters: (K key)
focal_class.return: OakUnscopedBuffer
focal_class.signature: OakUnscopedBuffer get(K key)
focal_class.class_method_signature: InternalOakMap.computeIfPresent(K key, Consumer<OakScopedWriteBuffer> computer)
focal_class.full_signature:  boolean computeIfPresent(K key, Consumer<OakScopedWriteBuffer> computer)
focal_class.identifier: computeIfPresent
focal_class.parameters: (K key, Consumer<OakScopedWriteBuffer> computer)
focal_class.return: boolean
focal_class.signature: boolean computeIfPresent(K key, Consumer<OakScopedWriteBuffer> computer)
focal_class.class_method_signature: InternalOakMap.refreshValuePosition(ThreadContext ctx)
focal_class.full_signature:  boolean refreshValuePosition(ThreadContext ctx)
focal_class.identifier: refreshValuePosition
focal_class.parameters: (ThreadContext ctx)
focal_class.return: boolean
focal_class.signature: boolean refreshValuePosition(ThreadContext ctx)
focal_class.class_method_signature: InternalOakMap.refreshValuePosition(Slice keySlice, Slice valueSlice)
focal_class.full_signature:  boolean refreshValuePosition(Slice keySlice, Slice valueSlice)
focal_class.identifier: refreshValuePosition
focal_class.parameters: (Slice keySlice, Slice valueSlice)
focal_class.return: boolean
focal_class.signature: boolean refreshValuePosition(Slice keySlice, Slice valueSlice)
focal_class.class_method_signature: InternalOakMap.getValueTransformation(OakScopedReadBuffer key, OakTransformer<T> transformer)
focal_class.full_signature: private T getValueTransformation(OakScopedReadBuffer key, OakTransformer<T> transformer)
focal_class.identifier: getValueTransformation
focal_class.modifiers: private
focal_class.parameters: (OakScopedReadBuffer key, OakTransformer<T> transformer)
focal_class.return: T
focal_class.signature: T getValueTransformation(OakScopedReadBuffer key, OakTransformer<T> transformer)
focal_class.class_method_signature: InternalOakMap.getValueTransformation(K key, OakTransformer<T> transformer)
focal_class.full_signature:  T getValueTransformation(K key, OakTransformer<T> transformer)
focal_class.identifier: getValueTransformation
focal_class.parameters: (K key, OakTransformer<T> transformer)
focal_class.return: T
focal_class.signature: T getValueTransformation(K key, OakTransformer<T> transformer)
focal_class.class_method_signature: InternalOakMap.getKeyTransformation(K key, OakTransformer<T> transformer)
focal_class.full_signature:  T getKeyTransformation(K key, OakTransformer<T> transformer)
focal_class.identifier: getKeyTransformation
focal_class.parameters: (K key, OakTransformer<T> transformer)
focal_class.return: T
focal_class.signature: T getKeyTransformation(K key, OakTransformer<T> transformer)
focal_class.class_method_signature: InternalOakMap.getMinKey()
focal_class.full_signature:  OakUnscopedBuffer getMinKey()
focal_class.identifier: getMinKey
focal_class.parameters: ()
focal_class.return: OakUnscopedBuffer
focal_class.signature: OakUnscopedBuffer getMinKey()
focal_class.class_method_signature: InternalOakMap.getMinKeyTransformation(OakTransformer<T> transformer)
focal_class.full_signature:  T getMinKeyTransformation(OakTransformer<T> transformer)
focal_class.identifier: getMinKeyTransformation
focal_class.parameters: (OakTransformer<T> transformer)
focal_class.return: T
focal_class.signature: T getMinKeyTransformation(OakTransformer<T> transformer)
focal_class.class_method_signature: InternalOakMap.getMaxKey()
focal_class.full_signature:  OakUnscopedBuffer getMaxKey()
focal_class.identifier: getMaxKey
focal_class.parameters: ()
focal_class.return: OakUnscopedBuffer
focal_class.signature: OakUnscopedBuffer getMaxKey()
focal_class.class_method_signature: InternalOakMap.getMaxKeyTransformation(OakTransformer<T> transformer)
focal_class.full_signature:  T getMaxKeyTransformation(OakTransformer<T> transformer)
focal_class.identifier: getMaxKeyTransformation
focal_class.parameters: (OakTransformer<T> transformer)
focal_class.return: T
focal_class.signature: T getMaxKeyTransformation(OakTransformer<T> transformer)
focal_class.class_method_signature: InternalOakMap.findChunk(K key)
focal_class.full_signature: private Chunk<K, V> findChunk(K key)
focal_class.identifier: findChunk
focal_class.modifiers: private
focal_class.parameters: (K key)
focal_class.return: Chunk<K, V>
focal_class.signature: Chunk<K, V> findChunk(K key)
focal_class.class_method_signature: InternalOakMap.replace(K key, V value, OakTransformer<V> valueDeserializeTransformer)
focal_class.full_signature:  V replace(K key, V value, OakTransformer<V> valueDeserializeTransformer)
focal_class.identifier: replace
focal_class.parameters: (K key, V value, OakTransformer<V> valueDeserializeTransformer)
focal_class.return: V
focal_class.signature: V replace(K key, V value, OakTransformer<V> valueDeserializeTransformer)
focal_class.class_method_signature: InternalOakMap.replace(K key, V oldValue, V newValue, OakTransformer<V> valueDeserializeTransformer)
focal_class.full_signature:  boolean replace(K key, V oldValue, V newValue, OakTransformer<V> valueDeserializeTransformer)
focal_class.identifier: replace
focal_class.parameters: (K key, V oldValue, V newValue, OakTransformer<V> valueDeserializeTransformer)
focal_class.return: boolean
focal_class.signature: boolean replace(K key, V oldValue, V newValue, OakTransformer<V> valueDeserializeTransformer)
focal_class.class_method_signature: InternalOakMap.lowerEntry(K key)
focal_class.full_signature:  Map.Entry<K, V> lowerEntry(K key)
focal_class.identifier: lowerEntry
focal_class.parameters: (K key)
focal_class.return: Map.Entry<K, V>
focal_class.signature: Map.Entry<K, V> lowerEntry(K key)
focal_class.class_method_signature: InternalOakMap.getKeyUnscopedBuffer(ThreadContext ctx)
focal_class.full_signature: private UnscopedBuffer getKeyUnscopedBuffer(ThreadContext ctx)
focal_class.identifier: getKeyUnscopedBuffer
focal_class.modifiers: private
focal_class.parameters: (ThreadContext ctx)
focal_class.return: UnscopedBuffer
focal_class.signature: UnscopedBuffer getKeyUnscopedBuffer(ThreadContext ctx)
focal_class.class_method_signature: InternalOakMap.getValueUnscopedBuffer(ThreadContext ctx)
focal_class.full_signature: private UnscopedValueBufferSynced getValueUnscopedBuffer(ThreadContext ctx)
focal_class.identifier: getValueUnscopedBuffer
focal_class.modifiers: private
focal_class.parameters: (ThreadContext ctx)
focal_class.return: UnscopedValueBufferSynced
focal_class.signature: UnscopedValueBufferSynced getValueUnscopedBuffer(ThreadContext ctx)
focal_class.class_method_signature: InternalOakMap.validateBoundariesOrder(K fromKey, K toKey)
focal_class.full_signature:  void validateBoundariesOrder(K fromKey, K toKey)
focal_class.identifier: validateBoundariesOrder
focal_class.parameters: (K fromKey, K toKey)
focal_class.return: void
focal_class.signature: void validateBoundariesOrder(K fromKey, K toKey)
focal_class.class_method_signature: InternalOakMap.valuesBufferViewIterator(K lo, boolean loInclusive, K hi, boolean hiInclusive,
                                                           boolean isDescending)
focal_class.full_signature:  Iterator<OakUnscopedBuffer> valuesBufferViewIterator(K lo, boolean loInclusive, K hi, boolean hiInclusive,
                                                           boolean isDescending)
focal_class.identifier: valuesBufferViewIterator
focal_class.parameters: (K lo, boolean loInclusive, K hi, boolean hiInclusive,
                                                           boolean isDescending)
focal_class.return: Iterator<OakUnscopedBuffer>
focal_class.signature: Iterator<OakUnscopedBuffer> valuesBufferViewIterator(K lo, boolean loInclusive, K hi, boolean hiInclusive,
                                                           boolean isDescending)
focal_class.class_method_signature: InternalOakMap.entriesBufferViewIterator(K lo, boolean loInclusive,
                                                                                          K hi, boolean hiInclusive,
                                                                                          boolean isDescending)
focal_class.full_signature:  Iterator<Map.Entry<OakUnscopedBuffer, OakUnscopedBuffer>> entriesBufferViewIterator(K lo, boolean loInclusive,
                                                                                          K hi, boolean hiInclusive,
                                                                                          boolean isDescending)
focal_class.identifier: entriesBufferViewIterator
focal_class.parameters: (K lo, boolean loInclusive,
                                                                                          K hi, boolean hiInclusive,
                                                                                          boolean isDescending)
focal_class.return: Iterator<Map.Entry<OakUnscopedBuffer, OakUnscopedBuffer>>
focal_class.signature: Iterator<Map.Entry<OakUnscopedBuffer, OakUnscopedBuffer>> entriesBufferViewIterator(K lo, boolean loInclusive,
                                                                                          K hi, boolean hiInclusive,
                                                                                          boolean isDescending)
focal_class.class_method_signature: InternalOakMap.keysBufferViewIterator(K lo, boolean loInclusive, K hi, boolean hiInclusive,
                                                         boolean isDescending)
focal_class.full_signature:  Iterator<OakUnscopedBuffer> keysBufferViewIterator(K lo, boolean loInclusive, K hi, boolean hiInclusive,
                                                         boolean isDescending)
focal_class.identifier: keysBufferViewIterator
focal_class.parameters: (K lo, boolean loInclusive, K hi, boolean hiInclusive,
                                                         boolean isDescending)
focal_class.return: Iterator<OakUnscopedBuffer>
focal_class.signature: Iterator<OakUnscopedBuffer> keysBufferViewIterator(K lo, boolean loInclusive, K hi, boolean hiInclusive,
                                                         boolean isDescending)
focal_class.class_method_signature: InternalOakMap.valuesStreamIterator(K lo, boolean loInclusive, K hi, boolean hiInclusive,
                                                       boolean isDescending)
focal_class.full_signature:  Iterator<OakUnscopedBuffer> valuesStreamIterator(K lo, boolean loInclusive, K hi, boolean hiInclusive,
                                                       boolean isDescending)
focal_class.identifier: valuesStreamIterator
focal_class.parameters: (K lo, boolean loInclusive, K hi, boolean hiInclusive,
                                                       boolean isDescending)
focal_class.return: Iterator<OakUnscopedBuffer>
focal_class.signature: Iterator<OakUnscopedBuffer> valuesStreamIterator(K lo, boolean loInclusive, K hi, boolean hiInclusive,
                                                       boolean isDescending)
focal_class.class_method_signature: InternalOakMap.entriesStreamIterator(K lo, boolean loInclusive,
                                                                                      K hi, boolean hiInclusive,
                                                                                      boolean isDescending)
focal_class.full_signature:  Iterator<Map.Entry<OakUnscopedBuffer, OakUnscopedBuffer>> entriesStreamIterator(K lo, boolean loInclusive,
                                                                                      K hi, boolean hiInclusive,
                                                                                      boolean isDescending)
focal_class.identifier: entriesStreamIterator
focal_class.parameters: (K lo, boolean loInclusive,
                                                                                      K hi, boolean hiInclusive,
                                                                                      boolean isDescending)
focal_class.return: Iterator<Map.Entry<OakUnscopedBuffer, OakUnscopedBuffer>>
focal_class.signature: Iterator<Map.Entry<OakUnscopedBuffer, OakUnscopedBuffer>> entriesStreamIterator(K lo, boolean loInclusive,
                                                                                      K hi, boolean hiInclusive,
                                                                                      boolean isDescending)
focal_class.class_method_signature: InternalOakMap.keysStreamIterator(K lo, boolean loInclusive, K hi, boolean hiInclusive,
                                                     boolean isDescending)
focal_class.full_signature:  Iterator<OakUnscopedBuffer> keysStreamIterator(K lo, boolean loInclusive, K hi, boolean hiInclusive,
                                                     boolean isDescending)
focal_class.identifier: keysStreamIterator
focal_class.parameters: (K lo, boolean loInclusive, K hi, boolean hiInclusive,
                                                     boolean isDescending)
focal_class.return: Iterator<OakUnscopedBuffer>
focal_class.signature: Iterator<OakUnscopedBuffer> keysStreamIterator(K lo, boolean loInclusive, K hi, boolean hiInclusive,
                                                     boolean isDescending)
focal_class.class_method_signature: InternalOakMap.valuesTransformIterator(K lo, boolean loInclusive, K hi, boolean hiInclusive,
                                              boolean isDescending, OakTransformer<T> transformer)
focal_class.full_signature:  Iterator<T> valuesTransformIterator(K lo, boolean loInclusive, K hi, boolean hiInclusive,
                                              boolean isDescending, OakTransformer<T> transformer)
focal_class.identifier: valuesTransformIterator
focal_class.parameters: (K lo, boolean loInclusive, K hi, boolean hiInclusive,
                                              boolean isDescending, OakTransformer<T> transformer)
focal_class.return: Iterator<T>
focal_class.signature: Iterator<T> valuesTransformIterator(K lo, boolean loInclusive, K hi, boolean hiInclusive,
                                              boolean isDescending, OakTransformer<T> transformer)
focal_class.class_method_signature: InternalOakMap.entriesTransformIterator(K lo, boolean loInclusive, K hi, boolean hiInclusive,
                                               boolean isDescending,
                                               Function<Map.Entry<OakScopedReadBuffer, OakScopedReadBuffer>,
                                                       T> transformer)
focal_class.full_signature:  Iterator<T> entriesTransformIterator(K lo, boolean loInclusive, K hi, boolean hiInclusive,
                                               boolean isDescending,
                                               Function<Map.Entry<OakScopedReadBuffer, OakScopedReadBuffer>,
                                                       T> transformer)
focal_class.identifier: entriesTransformIterator
focal_class.parameters: (K lo, boolean loInclusive, K hi, boolean hiInclusive,
                                               boolean isDescending,
                                               Function<Map.Entry<OakScopedReadBuffer, OakScopedReadBuffer>,
                                                       T> transformer)
focal_class.return: Iterator<T>
focal_class.signature: Iterator<T> entriesTransformIterator(K lo, boolean loInclusive, K hi, boolean hiInclusive,
                                               boolean isDescending,
                                               Function<Map.Entry<OakScopedReadBuffer, OakScopedReadBuffer>,
                                                       T> transformer)
focal_class.class_method_signature: InternalOakMap.keysTransformIterator(K lo, boolean loInclusive, K hi, boolean hiInclusive, boolean isDescending,
                                            OakTransformer<T> transformer)
focal_class.full_signature:  Iterator<T> keysTransformIterator(K lo, boolean loInclusive, K hi, boolean hiInclusive, boolean isDescending,
                                            OakTransformer<T> transformer)
focal_class.identifier: keysTransformIterator
focal_class.parameters: (K lo, boolean loInclusive, K hi, boolean hiInclusive, boolean isDescending,
                                            OakTransformer<T> transformer)
focal_class.return: Iterator<T>
focal_class.signature: Iterator<T> keysTransformIterator(K lo, boolean loInclusive, K hi, boolean hiInclusive, boolean isDescending,
                                            OakTransformer<T> transformer)
focal_method.body: V put(K key, V value, OakTransformer<V> transformer) {
          if (key == null || value == null) {
              throw new NullPointerException();
          }
  
          ThreadContext ctx = getThreadContext();
  
          for (int i = 0; i < MAX_RETRIES; i++) {
              Chunk<K, V> c = findChunk(key); // find chunk matching key
              c.lookUp(ctx, key);
              // If there is a matching value reference for the given key, and it is not marked as deleted,
              // then this put changes the slice pointed by this value reference.
              if (ctx.isValueValid()) {
                  // there is a value and it is not deleted
                  Result res = valueOperator.exchange(c, ctx, value, transformer, valueSerializer,
                      valuesMemoryManager,
                          this);
                  if (res.operationResult == ValueUtils.ValueResult.TRUE) {
                      return (V) res.value;
                  }
                  // Exchange failed because the value was deleted/moved between lookup and exchange. Continue with
                  // insertion.
                  continue;
              }
  
              if (isAfterRebalanceOrValueUpdate(c, ctx)) {
                  continue;
              }
  
              // AT THIS POINT EITHER (in all cases context is updated):
              // (1) Key wasn't found (key and value not valid)
              // (2) Key was found and it's value is deleted/invalid (key valid value invalid)
              if (!ctx.isKeyValid()) {
                  if (!allocateAndLinkEntry(c, ctx, key, false)) {
                      continue; // allocation wasn't successfull and resulted in rebalance - retry
                  }
              }
  
              c.writeValue(ctx, value, false); // write value in place
  
              if (!c.publish()) {
                  c.releaseNewValue(ctx);
                  rebalance(c);
                  continue;
              }
  
              if (c.linkValue(ctx) != ValueUtils.ValueResult.TRUE) {
                  c.releaseNewValue(ctx);
                  c.unpublish();
              } else {
                  c.unpublish();
                  checkRebalance(c);
                  return null; // null can be returned only in zero-copy case
              }
          }
          throw new RuntimeException("put failed: reached retry limit (1024).");
      }
focal_method.class_method_signature: InternalOakMap.put(K key, V value, OakTransformer<V> transformer)
focal_method.full_signature:  V put(K key, V value, OakTransformer<V> transformer)
focal_method.identifier: put
focal_method.invocations: getThreadContext findChunk lookUp isValueValid exchange isAfterRebalanceOrValueUpdate isKeyValid allocateAndLinkEntry writeValue publish releaseNewValue rebalance linkValue releaseNewValue unpublish unpublish checkRebalance
focal_method.parameters: (K key, V value, OakTransformer<V> transformer)
focal_method.return: V
focal_method.signature: V put(K key, V value, OakTransformer<V> transformer)