All Superinterfaces:

ChainStorage<KeyValue<K,V>,K,V,EN>, Composition, Iterable<KeyValue<K,V>>

All Known Implementing Classes:

AbstractChainKeyValueStorage, ChainStrongStrongStorage
```
public interface ChainKeyValueStorage<K,V,EN extends AbstractChainEntry<KeyValue<K,V>,K,V,EN>>
extends ChainStorage<KeyValue<K,V>,K,V,EN>
```

Nested Class Summary
- Nested classes/interfaces inherited from interface one.microstream.collections.interfaces.ChainStorage
  ChainStorage.Entry<E,K,V,EN extends ChainStorage.Entry<E,K,V,EN>>

Method Summary

Modifier and Type	Method	Description
`long`	`consolidate()`	Removes all empty entries from the passed chain and returns the number of removed entries.
`EN`	`getChainEntry(long index)`
`EN`	`getIntervalLowChainEntry(long lowIndex, long highIndex)`
`EN`	`getRangeChainEntry(long offset, long length)`
`ReferenceType`	`getReferenceType()`
`ReferenceType`	`getValueReferenceType()`
`boolean`	`hasVolatileElements()`
`boolean`	`hasVolatileValues()`
`VarString`	`keyAppendTo(VarString vc)`
`VarString`	`keyAppendTo(VarString vc, char separator)`
`VarString`	`keyAppendTo(VarString vc, String separator)`
`VarString`	`keyAppendTo(VarString vc, BiConsumer<VarString,? super K> keyAppender)`
`VarString`	`keyAppendTo(VarString vc, BiConsumer<VarString,? super K> keyAppender, char separator)`
`VarString`	`keyAppendTo(VarString vc, BiConsumer<VarString,? super K> keyAppender, String separator)`
`boolean`	`keyApplies(Predicate<? super K> predicate)`
`boolean`	`keyAppliesAll(Predicate<? super K> predicate)`
`boolean`	`keyContains(K element)`
`boolean`	`keyContains(K sample, Equalator<? super K> equalator)`
`boolean`	`keyContainsAll(K[] elements, int elementsOffset, int elementsLength)`
`boolean`	`keyContainsAll(XGettingCollection<? extends K> elements)`
`boolean`	`keyContainsId(K element)`
`boolean`	`keyContainsNull()`
`<C extends Consumer<? super K>> C`	`keyCopySelection(C target, long... indices)`
`<C extends Consumer<? super K>> C`	`keyCopyTo(C target)`
`<C extends Consumer<? super K>> C`	`keyCopyTo(C target, Predicate<? super K> predicate)`
`int`	`keyCopyToArray(int offset, int length, Object[] target, int targetOffset)`
`int`	`keyCount(Predicate<? super K> predicate)`
`int`	`keyCount(K element)`
`int`	`keyCount(K sample, Equalator<? super K> equalator)`
`<C extends Consumer<? super K>> C`	`keyDistinct(C target)`
`<C extends Consumer<? super K>> C`	`keyDistinct(C target, Equalator<? super K> equalator)`
`boolean`	`keyEqualsContent(XGettingCollection<? extends K> other, Equalator<? super K> equalator)`
`<C extends Consumer<? super K>> C`	`keyExcept(XGettingCollection<? extends K> collection, Equalator<? super K> equalator, C target)`
`void`	`keyFill(int offset, int length, K element)`
`K`	`keyFirst()`
`K`	`keyGet(long index)`
`boolean`	`keyHasDistinctValues()`
`boolean`	`keyHasDistinctValues(Equalator<? super K> equalator)`
`int`	`keyIndexOf(Predicate<? super K> predicate)`
`int`	`keyIndexOf(K element)`
`int`	`keyIndexOf(K sample, Equalator<? super K> equalator)`
`<C extends Consumer<? super K>> C`	`keyIntersect(XGettingCollection<? extends K> collection, Equalator<? super K> equalator, C target)`
`boolean`	`keyIsSorted(Comparator<? super K> keyComparator)`
`void`	`keyIterate(Consumer<? super K> procedure)`
`void`	`keyIterate(Predicate<? super K> predicate, Consumer<? super K> procedure)`
`void`	`keyIterateIndexed(IndexedAcceptor<? super K> procedure)`
`Iterator<K>`	`keyIterator()`
`<A> void`	`keyJoin(BiConsumer<? super K,A> joiner, A keyAggregate)`
`K`	`keyLast()`
`K`	`keyMax(Comparator<? super K> keyComparator)`
`int`	`keyMaxIndex(Comparator<? super K> keyComparator)`
`K`	`keyMin(Comparator<? super K> keyComparator)`
`int`	`keyMinIndex(Comparator<? super K> keyComparator)`
`int`	`keyMoveRange(int offset, int length, Consumer<? super K> target)`
`int`	`keyMoveSelection(Consumer<? super K> target, long... indices)`
`int`	`keyMoveTo(Consumer<? super K> target, Predicate<? super K> predicate)`
`int`	`keyProcess(Consumer<? super K> procedure)`
`int`	`keyReduce(Predicate<? super K> predicate)`
`K`	`keyRemove(long index)`
`int`	`keyRemove(K element)`
`int`	`keyRemove(K sample, Equalator<? super K> equalator)`
`int`	`keyRemoveAll(K[] elements, int elementsOffset, int elementsLength)`
`int`	`keyRemoveAll(XGettingCollection<? extends K> elements)`
`int`	`keyRemoveDuplicates()`
`int`	`keyRemoveDuplicates(Equalator<? super K> equalator)`
`int`	`keyRemoveNull()`
`boolean`	`keyRemoveOne(K element)`
`boolean`	`keyRemoveOne(K sample, Equalator<? super K> equalator)`
`int`	`keyReplace(K element, K replacement)`
`int`	`keyReplaceAll(K[] elements, int elementsOffset, int elementsLength, K replacement)`
`int`	`keyReplaceAll(XGettingCollection<? extends K> elements, K replacement)`
`int`	`keyReplaceOne(K element, K replacement)`
`int`	`keyRetainAll(K[] elements, int elementsOffset, int elementsLength)`
`int`	`keyRetainAll(XGettingCollection<? extends K> elements)`
`int`	`keyRetainAll(XGettingCollection<? extends K> samples, Equalator<? super K> equalator)`
`K`	`keyRetrieve(Predicate<? super K> predicate)`
`K`	`keyRetrieve(K element)`
`K`	`keyRetrieve(K sample, Equalator<? super K> equalator)`
`VarString`	`keyRngAppendTo(int offset, int length, VarString vc)`
`VarString`	`keyRngAppendTo(int offset, int length, VarString vc, char separator)`
`VarString`	`keyRngAppendTo(int offset, int length, VarString vc, String separator)`
`VarString`	`keyRngAppendTo(int offset, int length, VarString vc, BiConsumer<VarString,? super K> keyAppender)`
`VarString`	`keyRngAppendTo(int offset, int length, VarString vc, BiConsumer<VarString,? super K> keyAppender, char separator)`
`VarString`	`keyRngAppendTo(int offset, int length, VarString vc, BiConsumer<VarString,? super K> keyAppender, String separator)`
`boolean`	`keyRngApplies(int offset, int length, Predicate<? super K> predicate)`
`boolean`	`keyRngAppliesAll(int offset, int length, Predicate<? super K> predicate)`
`boolean`	`keyRngContains(int offset, int length, K element)`
`boolean`	`keyRngContainsAll(int offset, int length, K[] elements, int elementsOffset, int elementsLength)`
`boolean`	`keyRngContainsAll(int offset, int length, XGettingCollection<? extends K> elements)`
`boolean`	`keyRngContainsId(int offset, int length, K element)`
`boolean`	`keyRngContainsNull(int offset, int length)`
`<C extends Consumer<? super K>> C`	`keyRngCopyTo(int offset, int length, C target)`
`<C extends Consumer<? super K>> C`	`keyRngCopyTo(int offset, int length, C target, Predicate<? super K> predicate)`
`int`	`keyRngCount(int offset, int length, Predicate<? super K> predicate)`
`int`	`keyRngCount(int offset, int length, K element)`
`<C extends Consumer<? super K>> C`	`keyRngDistinct(int offset, int length, C target)`
`<C extends Consumer<? super K>> C`	`keyRngDistinct(int offset, int length, C target, Equalator<? super K> equalator)`
`<C extends Consumer<? super K>> C`	`keyRngExcept(int offset, int length, XGettingCollection<? extends K> collection, Equalator<? super K> equalator, C target)`
`int`	`keyRngIndexOf(int offset, int length, Predicate<? super K> predicate)`
`int`	`keyRngIndexOf(int offset, int length, K element)`
`int`	`keyRngIndexOf(int offset, int length, K sample, Equalator<? super K> equalator)`
`<C extends Consumer<? super K>> C`	`keyRngIntersect(int offset, int length, XGettingCollection<? extends K> collection, Equalator<? super K> equalator, C target)`
`boolean`	`keyRngIsSorted(int offset, int length, Comparator<? super K> keyComparator)`
`void`	`keyRngIterate(int offset, int length, Consumer<? super K> procedure)`
`void`	`keyRngIterateIndexed(int offset, int length, IndexedAcceptor<? super K> procedure)`
`K`	`keyRngMax(int offset, int length, Comparator<? super K> keyComparator)`
`int`	`keyRngMaxIndex(int offset, int length, Comparator<? super K> keyComparator)`
`K`	`keyRngMin(int offset, int length, Comparator<? super K> keyComparator)`
`int`	`keyRngMinIndex(int offset, int length, Comparator<? super K> keyComparator)`
`int`	`keyRngMoveTo(int offset, int length, Consumer<? super K> target, Predicate<? super K> predicate)`
`int`	`keyRngProcess(int offset, int length, Consumer<? super K> procedure)`
`int`	`keyRngReduce(int offset, int length, Predicate<? super K> predicate)`
`int`	`keyRngRemove(int offset, int length, K element)`
`int`	`keyRngRemoveAll(int offset, int length, K[] elements, int elementsOffset, int elementsLength)`
`int`	`keyRngRemoveAll(int offset, int length, XGettingCollection<? extends K> elements)`
`int`	`keyRngRemoveDuplicates(int offset, int length)`
`int`	`keyRngRemoveDuplicates(int offset, int length, Equalator<? super K> equalator)`
`int`	`keyRngRemoveNull(long offset, long length)`
`int`	`keyRngReplace(int offset, int length, K element, K replacement)`
`int`	`keyRngReplace(int offset, int length, K sample, Equalator<? super K> equalator, K replacement)`
`int`	`keyRngReplaceAll(int offset, int length, K[] elements, int elementsOffset, int elementsLength, K replacement)`
`int`	`keyRngReplaceAll(int offset, int length, XGettingCollection<? extends K> elements, K replacement)`
`int`	`keyRngReplaceOne(int offset, int length, K element, K replacement)`
`int`	`keyRngRetainAll(int offset, int length, K[] elements, int elementsOffset, int elementsLength)`
`int`	`keyRngRetainAll(int offset, int length, XGettingCollection<? extends K> elements)`
`K`	`keyRngRetrieve(long offset, long length, K element)`
`K`	`keyRngRetrieve(long offset, long length, K sample, Equalator<? super K> equalator)`
`int`	`keyRngScan(int offset, int length, Predicate<? super K> predicate)`
`K`	`keyRngSearch(int offset, int length, Predicate<? super K> predicate)`
`void`	`keyRngSort(int offset, int length, Comparator<? super K> keyComparator)`
`int`	`keyRngSubstitute(int offset, int length, Function<? super K,? extends K> mapper)`
`int`	`keyRngSubstitute(int offset, int length, Predicate<? super K> predicate, Function<K,K> mapper)`
`int`	`keyRngSubstitute(int offset, int length, Predicate<? super K> predicate, K keySubstitute)`
`int`	`keyRngSubstituteOne(int offset, int length, Predicate<? super K> predicate, K keySubstitute)`
`Object[]`	`keyRngToArray(int offset, int length)`
`K[]`	`keyRngToArray(int offset, int length, Class<K> type)`
`<C extends Consumer<? super K>> C`	`keyRngUnion(int offset, int length, XGettingCollection<? extends K> collection, Equalator<? super K> equalator, C target)`
`int`	`keyScan(Predicate<? super K> predicate)`
`K`	`keySearch(Predicate<? super K> predicate)`
`K`	`keySeek(K sample)`
`K`	`keySeek(K sample, Equalator<? super K> equalator)`
`void`	`keySet(int offset, K... elements)`
`void`	`keySet(int offset, K[] elements, int elementsOffset, int elementsLength)`
`void`	`keySort(Comparator<? super K> keyComparator)`
`long`	`keySubstitute(Function<? super K,? extends K> mapper, BiConsumer<EN,K> callback)`
`int`	`keySubstitute(Predicate<? super K> predicate, Function<? super K,? extends K> mapper)`
`int`	`keySubstitute(Predicate<? super K> predicate, K keySubstitute)`
`int`	`keySubstituteOne(Predicate<? super K> predicate, K keySubstitute)`
`Object[]`	`keyToArray()`
`K[]`	`keyToArray(Class<K> type)`
`<C extends Consumer<? super K>> C`	`keyUnion(XGettingCollection<? extends K> collection, Equalator<? super K> equalator, C target)`
`void`	`removeRange(long offset, long length)`
`long`	`removeSelection(long... indices)`	Removes all entries at the indices (offsets) given in the passed `int` array.
`void`	`reverse()`
`void`	`rngReverse(long offset, long length)`
`void`	`rngShuffle(long offset, long length)`
`V`	`searchValue(K key, Equalator<? super K> equalator)`
`void`	`shiftBy(long sourceIndex, long distance)`
`void`	`shiftBy(long sourceIndex, long distance, long length)`
`void`	`shiftTo(long sourceIndex, long targetIndex)`
`void`	`shiftTo(long sourceIndex, long targetIndex, long length)`
`void`	`shuffle()`
`long`	`size()`
`void`	`swap(long indexA, long indexB)`
`void`	`swap(long indexA, long indexB, long length)`
`VarString`	`valuesAppendTo(VarString vc)`
`VarString`	`valuesAppendTo(VarString vc, char separator)`
`VarString`	`valuesAppendTo(VarString vc, String separator)`
`VarString`	`valuesAppendTo(VarString vc, BiConsumer<VarString,? super V> appender)`
`VarString`	`valuesAppendTo(VarString vc, BiConsumer<VarString,? super V> appender, char separator)`
`VarString`	`valuesAppendTo(VarString vc, BiConsumer<VarString,? super V> appender, String separator)`
`boolean`	`valuesApplies(Predicate<? super V> predicate)`
`boolean`	`valuesAppliesAll(Predicate<? super V> predicate)`
`boolean`	`valuesContains(V element)`
`boolean`	`valuesContains(V sample, Equalator<? super V> equalator)`
`boolean`	`valuesContainsAll(XGettingCollection<? extends V> elements)`
`boolean`	`valuesContainsAll(XGettingCollection<? extends V> elements, Equalator<? super V> equalator)`
`boolean`	`valuesContainsAll(V[] values, int elementsOffset, int elementsLength)`
`boolean`	`valuesContainsAll(V[] values, int elementsOffset, int elementsLength, Equalator<? super V> equalator)`
`boolean`	`valuesContainsId(V element)`
`boolean`	`valuesContainsNull()`
`<C extends Consumer<? super V>> C`	`valuesCopySelection(C target, long... indices)`
`<C extends Consumer<? super V>> C`	`valuesCopyTo(C target)`
`<C extends Consumer<? super V>> C`	`valuesCopyTo(C target, Predicate<? super V> predicate)`
`int`	`valuesCopyToArray(long offset, int length, Object[] target, int targetOffset)`
`int`	`valuesCount(Predicate<? super V> predicate)`
`int`	`valuesCount(V element)`
`int`	`valuesCount(V sample, Equalator<? super V> equalator)`
`<C extends Consumer<? super V>> C`	`valuesDistinct(C target)`
`<C extends Consumer<? super V>> C`	`valuesDistinct(C target, Equalator<? super V> equalator)`
`boolean`	`valuesEqualsContent(XGettingCollection<? extends V> other, Equalator<? super V> equalator)`
`<C extends Consumer<? super V>> C`	`valuesExcept(XGettingCollection<? extends V> collection, Equalator<? super V> equalator, C target)`
`void`	`valuesFill(long offset, long length, V value)`
`V`	`valuesFirst()`
`V`	`valuesGet(long index)`
`boolean`	`valuesHasDistinctValues()`
`boolean`	`valuesHasDistinctValues(Equalator<? super V> equalator)`
`int`	`valuesIndexOf(Predicate<? super V> predicate)`
`int`	`valuesIndexOf(V element)`
`int`	`valuesIndexOf(V sample, Equalator<? super V> equalator)`
`<C extends Consumer<? super V>> C`	`valuesIntersect(XGettingCollection<? extends V> collection, Equalator<? super V> equalator, C target)`
`boolean`	`valuesIsSorted(Comparator<? super V> comparator)`
`void`	`valuesIterate(Consumer<? super V> procedure)`
`void`	`valuesIterate(Predicate<? super V> predicate, Consumer<? super V> procedure)`
`void`	`valuesIterateIndexed(IndexedAcceptor<? super V> procedure)`
`Iterator<V>`	`valuesIterator()`
`<A> void`	`valuesJoin(BiConsumer<? super V,A> joiner, A aggregate)`
`V`	`valuesLast()`
`ListIterator<V>`	`valuesListIterator(long index)`
`V`	`valuesMax(Comparator<? super V> comparator)`
`int`	`valuesMaxIndex(Comparator<? super V> comparator)`
`V`	`valuesMin(Comparator<? super V> comparator)`
`int`	`valuesMinIndex(Comparator<? super V> comparator)`
`int`	`valuesMoveRange(int offset, int length, Consumer<? super V> target)`
`int`	`valuesMoveSelection(Consumer<? super V> target, long... indices)`
`int`	`valuesMoveTo(Consumer<? super V> target, Predicate<? super V> predicate)`
`int`	`valuesProcess(Consumer<? super V> procedure)`
`int`	`valuesReduce(Predicate<? super V> predicate)`
`V`	`valuesRemove(long index)`
`int`	`valuesRemove(V element)`
`int`	`valuesRemove(V sample, Equalator<? super V> equalator)`
`int`	`valuesRemoveAll(XGettingCollection<? extends V> elements)`
`int`	`valuesRemoveAll(XGettingCollection<? extends V> samples, Equalator<? super V> equalator)`
`int`	`valuesRemoveAll(V[] values, int elementsOffset, int elementsLength)`
`int`	`valuesRemoveAll(V[] samples, int samplesOffset, int samplesLength, Equalator<? super V> equalator)`
`int`	`valuesRemoveDuplicates()`
`int`	`valuesRemoveDuplicates(Equalator<? super V> equalator)`
`int`	`valuesRemoveNull()`
`boolean`	`valuesRemoveOne(V element)`
`boolean`	`valuesRemoveOne(V sample, Equalator<? super V> equalator)`
`int`	`valuesReplace(V sample, Equalator<? super V> equalator, V replacement)`
`int`	`valuesReplace(V element, V replacement)`
`int`	`valuesReplaceAll(XGettingCollection<? extends V> samples, Equalator<? super V> equalator, V replacement)`
`int`	`valuesReplaceAll(XGettingCollection<? extends V> elements, V replacement)`
`int`	`valuesReplaceAll(V[] samples, int samplesOffset, int samplesLength, Equalator<? super V> equalator, V replacement)`
`int`	`valuesReplaceAll(V[] values, int valuesOffset, int valuesLength, V replacement)`
`boolean`	`valuesReplaceOne(V sample, Equalator<? super V> equalator, V replacement)`
`boolean`	`valuesReplaceOne(V element, V replacement)`
`int`	`valuesRetainAll(XGettingCollection<? extends V> elements)`
`int`	`valuesRetainAll(XGettingCollection<? extends V> samples, Equalator<? super V> equalator)`
`int`	`valuesRetainAll(V[] values, int elementsOffset, int elementsLength)`
`int`	`valuesRetainAll(V[] samples, int elementsOffset, int elementsLength, Equalator<? super V> equalator)`
`V`	`valuesRetrieve(Predicate<? super V> predicate)`
`V`	`valuesRetrieve(V element)`
`VarString`	`valuesRngAppendTo(int offset, int length, VarString vc)`
`VarString`	`valuesRngAppendTo(int offset, int length, VarString vc, char separator)`
`VarString`	`valuesRngAppendTo(int offset, int length, VarString vc, String separator)`
`VarString`	`valuesRngAppendTo(int offset, int length, VarString vc, BiConsumer<VarString,? super V> appender)`
`VarString`	`valuesRngAppendTo(int offset, int length, VarString vc, BiConsumer<VarString,? super V> appender, char separator)`
`VarString`	`valuesRngAppendTo(int offset, int length, VarString vc, BiConsumer<VarString,? super V> appender, String separator)`
`boolean`	`valuesRngApplies(int offset, int length, Predicate<? super V> predicate)`
`boolean`	`valuesRngAppliesAll(int offset, int length, Predicate<? super V> predicate)`
`boolean`	`valuesRngContains(int offset, int length, V value)`
`boolean`	`valuesRngContains(int offset, int length, V sample, Equalator<? super V> equalator)`
`boolean`	`valuesRngContainsAll(int offset, int length, XGettingCollection<? extends V> elements)`
`boolean`	`valuesRngContainsAll(int offset, int length, XGettingCollection<? extends V> samples, Equalator<? super V> equalator)`
`boolean`	`valuesRngContainsAll(int offset, int length, V[] values, int elementsOffset, int elementsLength)`
`boolean`	`valuesRngContainsAll(int offset, int length, V[] values, int elementsOffset, int elementsLength, Equalator<? super V> equalator)`
`boolean`	`valuesRngContainsId(int offset, int length, V value)`
`boolean`	`valuesRngContainsNull(int offset, int length)`
`<C extends Consumer<? super V>> C`	`valuesRngCopyTo(int offset, int length, C target)`
`<C extends Consumer<? super V>> C`	`valuesRngCopyTo(int offset, int length, C target, Predicate<? super V> predicate)`
`int`	`valuesRngCount(int offset, int length, Predicate<? super V> predicate)`
`int`	`valuesRngCount(int offset, int length, V value)`
`int`	`valuesRngCount(int offset, int length, V sample, Equalator<? super V> equalator)`
`<C extends Consumer<? super V>> C`	`valuesRngDistinct(int offset, int length, C target)`
`<C extends Consumer<? super V>> C`	`valuesRngDistinct(int offset, int length, C target, Equalator<? super V> equalator)`
`<C extends Consumer<? super V>> C`	`valuesRngExcept(int offset, int length, XGettingCollection<? extends V> collection, Equalator<? super V> equalator, C target)`
`int`	`valuesRngIndexOf(int offset, int length, Predicate<? super V> predicate)`
`int`	`valuesRngIndexOf(int offset, int length, V value)`
`int`	`valuesRngIndexOf(int offset, int length, V sample, Equalator<? super V> equalator)`
`<C extends Consumer<? super V>> C`	`valuesRngIntersect(int offset, int length, XGettingCollection<? extends V> collection, Equalator<? super V> equalator, C target)`
`boolean`	`valuesRngIsSorted(int offset, int length, Comparator<? super V> comparator)`
`void`	`valuesRngIterate(int offset, int length, Consumer<? super V> procedure)`
`void`	`valuesRngIterateIndexed(int offset, int length, IndexedAcceptor<? super V> procedure)`
`V`	`valuesRngMax(int offset, int length, Comparator<? super V> comparator)`
`int`	`valuesRngMaxIndex(int offset, int length, Comparator<? super V> comparator)`
`V`	`valuesRngMin(int offset, int length, Comparator<? super V> comparator)`
`int`	`valuesRngMinIndex(int offset, int length, Comparator<? super V> comparator)`
`int`	`valuesRngMoveTo(int offset, int length, Consumer<? super V> target, Predicate<? super V> predicate)`
`int`	`valuesRngProcess(int offset, int length, Consumer<? super V> procedure)`
`int`	`valuesRngReduce(int offset, int length, Predicate<? super V> predicate)`
`int`	`valuesRngRemove(int offset, int length, V value)`
`int`	`valuesRngRemove(int offset, int length, V sample, Equalator<? super V> equalator)`
`int`	`valuesRngRemoveAll(int offset, int length, XGettingCollection<? extends V> elements)`
`int`	`valuesRngRemoveAll(int offset, int length, XGettingCollection<? extends V> samples, Equalator<? super V> equalator)`
`int`	`valuesRngRemoveAll(int offset, int length, V[] values, int elementsOffset, int elementsLength)`
`int`	`valuesRngRemoveAll(int offset, int length, V[] samples, int samplesOffset, int samplesLength, Equalator<? super V> equalator)`
`int`	`valuesRngRemoveDuplicates(int offset, int length)`
`int`	`valuesRngRemoveDuplicates(int offset, int length, Equalator<? super V> equalator)`
`int`	`valuesRngRemoveNull(int offset, int length)`
`boolean`	`valuesRngRemoveOne(int offset, int length, V value)`
`boolean`	`valuesRngRemoveOne(int offset, int length, V sample, Equalator<? super V> equalator)`
`int`	`valuesRngReplace(int offset, int length, V sample, Equalator<? super V> equalator, V replacement)`
`int`	`valuesRngReplace(int offset, int length, V value, V replacement)`
`int`	`valuesRngReplaceAll(int offset, int length, XGettingCollection<? extends V> samples, Equalator<? super V> equalator, V replacement)`
`int`	`valuesRngReplaceAll(int offset, int length, XGettingCollection<? extends V> elements, V replacement)`
`int`	`valuesRngReplaceAll(int offset, int length, V[] samples, int samplesOffset, int samplesLength, Equalator<? super V> equalator, V replacement)`
`int`	`valuesRngReplaceAll(int offset, int length, V[] values, int valuesOffset, int valuesLength, V replacement)`
`int`	`valuesRngReplaceOne(int offset, int length, V sample, Equalator<? super V> equalator, V replacement)`
`int`	`valuesRngReplaceOne(int offset, int length, V value, V replacement)`
`int`	`valuesRngRetainAll(int offset, int length, XGettingCollection<? extends V> elements)`
`int`	`valuesRngRetainAll(int offset, int length, XGettingCollection<? extends V> samples, Equalator<? super V> equalator)`
`int`	`valuesRngRetainAll(int offset, int length, V[] values, int elementsOffset, int elementsLength)`
`int`	`valuesRngRetainAll(int offset, int length, V[] samples, int elementsOffset, int elementsLength, Equalator<? super V> equalator)`
`V`	`valuesRngRetrieve(int offset, int length, V value)`
`V`	`valuesRngRetrieve(int offset, int length, V sample, Equalator<? super V> equalator)`
`int`	`valuesRngScan(int offset, int length, Predicate<? super V> predicate)`
`V`	`valuesRngSearch(int offset, int length, Predicate<? super V> predicate)`
`V`	`valuesRngSearch(int offset, int length, V sample, Equalator<? super V> equalator)`
`V`	`valuesRngSeek(int offset, int length, V sample)`
`void`	`valuesRngSort(int offset, int length, Comparator<? super V> comparator)`
`int`	`valuesRngSubstitute(int offset, int length, Function<V,V> mapper)`
`int`	`valuesRngSubstitute(int offset, int length, Predicate<? super V> predicate, Function<V,V> mapper)`
`int`	`valuesRngSubstitute(int offset, int length, Predicate<? super V> predicate, V substitute)`
`int`	`valuesRngSubstituteOne(int offset, int length, Predicate<? super V> predicate, V substitute)`
`Object[]`	`valuesRngToArray(int offset, int length)`
`V[]`	`valuesRngToArray(int offset, int length, Class<V> type)`
`<C extends Consumer<? super V>> C`	`valuesRngUnion(int offset, int length, XGettingCollection<? extends V> collection, Equalator<? super V> equalator, C target)`
`int`	`valuesScan(Predicate<? super V> predicate)`
`V`	`valuesSearch(Predicate<? super V> predicate)`
`V`	`valuesSearch(V sample, Equalator<? super V> equalator)`
`V`	`valuesSeek(V sample)`
`V`	`valuesSet(long offset, V value)`
`void`	`valuesSet(long offset, V[] values)`
`void`	`valuesSet(long offset, V[] values, int valuesOffset, int valuesLength)`
`void`	`valuesSort(Comparator<? super V> comparator)`
`int`	`valuesSubstitute(Function<? super V,? extends V> mapper)`
`int`	`valuesSubstitute(Predicate<? super V> predicate, Function<V,V> mapper)`
`int`	`valuesSubstitute(Predicate<? super V> predicate, V substitute)`
`boolean`	`valuesSubstituteOne(Predicate<? super V> predicate, V substitute)`
`Object[]`	`valuesToArray()`
`V[]`	`valuesToArray(Class<V> type)`
`String`	`valuesToString()`
`<C extends Consumer<? super V>> C`	`valuesUnion(XGettingCollection<? extends V> collection, Equalator<? super V> equalator, C target)`

Methods inherited from interface one.microstream.collections.interfaces.ChainStorage
appendEntry, appendTo, appendTo, appendTo, appendTo, appendTo, appendTo, appliesAll, clear, contains, contains, containsAll, containsAll, containsId, containsNull, containsSearched, copySelection, copyTo, copyTo, copyToArray, count, count, count, distinct, distinct, equalsContent, except, fill, first, get, hasDistinctValues, hasDistinctValues, indexOf, indexOf, indexOf, intersect, isSorted, iterate, iterate, iterateIndexed, iterator, join, last, max, maxIndex, min, minIndex, moveRange, moveSelection, moveTo, prependEntry, process, reduce, remove, remove, remove, removeAll, removeAll, removeDuplicates, removeDuplicates, removeNull, removeOne, removeOne, replace, replaceAll, replaceAll, replaceBy, replaceOne, replaceOneBy, retainAll, retainAll, retainAll, retainRange, retrieve, retrieve, retrieve, rngAppendTo, rngAppendTo, rngAppendTo, rngAppendTo, rngAppendTo, rngAppendTo, rngAppliesAll, rngContains, rngContainsAll, rngContainsAll, rngContainsId, rngContainsNull, rngContainsSearched, rngCopyTo, rngCopyTo, rngCount, rngCount, rngDistinct, rngDistinct, rngExcept, rngIndexOf, rngIndexOf, rngIndexOf, rngIntersect, rngIsSorted, rngIterate, rngIterateIndexed, rngMax, rngMaxIndex, rngMin, rngMinIndex, rngMoveTo, rngProcess, rngReduce, rngRemove, rngRemoveAll, rngRemoveAll, rngRemoveDuplicates, rngRemoveDuplicates, rngRemoveNull, rngReplace, rngReplace, rngReplaceAll, rngReplaceAll, rngReplaceOne, rngReplaceOne, rngReplaceOneBy, rngRetainAll, rngRetainAll, rngRetrieve, rngRetrieve, rngScan, rngSearch, rngSort, rngSubstitute, rngSubstitute, rngToArray, rngToArray, rngUnion, scan, search, seek, seek, set, set, sort, substitute, substitute, toArray, toArray, toString, union

Methods inherited from interface java.lang.Iterable
forEach, spliterator

Method Detail

getChainEntry
```
EN getChainEntry(long index)
          throws IndexOutOfBoundsException
```
Specified by:

getChainEntry in interface ChainStorage<KeyValue<K,V>,K,V,EN extends AbstractChainEntry<KeyValue<K,V>,K,V,EN>>

Throws:

IndexOutOfBoundsException

getRangeChainEntry
```
EN getRangeChainEntry(long offset,
                      long length)
               throws IndexOutOfBoundsException
```
Specified by:

getRangeChainEntry in interface ChainStorage<KeyValue<K,V>,K,V,EN extends AbstractChainEntry<KeyValue<K,V>,K,V,EN>>

Throws:

IndexOutOfBoundsException

getIntervalLowChainEntry
```
EN getIntervalLowChainEntry(long lowIndex,
                            long highIndex)
                     throws IndexOutOfBoundsException
```
Specified by:

getIntervalLowChainEntry in interface ChainStorage<KeyValue<K,V>,K,V,EN extends AbstractChainEntry<KeyValue<K,V>,K,V,EN>>

Throws:

IndexOutOfBoundsException

searchValue

V searchValue(K key,
              Equalator<? super K> equalator)

size
```
long size()
```
Specified by:

size in interface ChainStorage<KeyValue<K,V>,K,V,EN extends AbstractChainEntry<KeyValue<K,V>,K,V,EN>>

consolidate
```
long consolidate()
```
Removes all empty entries from the passed chain and returns the number of removed entries.

Specified by:

consolidate in interface ChainStorage<KeyValue<K,V>,K,V,EN extends AbstractChainEntry<KeyValue<K,V>,K,V,EN>>

Returns:

the number of removed entries.

hasVolatileElements
```
boolean hasVolatileElements()
```
Specified by:

hasVolatileElements in interface ChainStorage<KeyValue<K,V>,K,V,EN extends AbstractChainEntry<KeyValue<K,V>,K,V,EN>>

getReferenceType
```
ReferenceType getReferenceType()
```
Specified by:

getReferenceType in interface ChainStorage<KeyValue<K,V>,K,V,EN extends AbstractChainEntry<KeyValue<K,V>,K,V,EN>>

keyIterator
```
Iterator<K> keyIterator()
```

keyEqualsContent

boolean keyEqualsContent(XGettingCollection<? extends K> other,
                         Equalator<? super K> equalator)

removeRange
```
void removeRange(long offset,
                 long length)
```
Specified by:

removeRange in interface ChainStorage<KeyValue<K,V>,K,V,EN extends AbstractChainEntry<KeyValue<K,V>,K,V,EN>>

removeSelection
```
long removeSelection(long... indices)
```
Removes all entries at the indices (offsets) given in the passed int array.
Note that the indices array gets presorted to increase algorithm performance. If the original int array shall be unchanged, a clone must be passed.

Specified by:

removeSelection in interface ChainStorage<KeyValue<K,V>,K,V,EN extends AbstractChainEntry<KeyValue<K,V>,K,V,EN>>

Parameters:

indices - the indices (offsets) of the entries to be removed.

Returns:

the amount of actually removed entries.

keyContainsNull
```
boolean keyContainsNull()
```

keyRngContainsNull

boolean keyRngContainsNull(int offset,
                           int length)

keyContainsId
```
boolean keyContainsId(K element)
```

keyRngContainsId

boolean keyRngContainsId(int offset,
                         int length,
                         K element)

keyContains
```
boolean keyContains(K element)
```

keyContains

boolean keyContains(K sample,
                    Equalator<? super K> equalator)

keyRngContains

boolean keyRngContains(int offset,
                       int length,
                       K element)

keyContainsAll

boolean keyContainsAll(K[] elements,
                       int elementsOffset,
                       int elementsLength)

keyRngContainsAll

boolean keyRngContainsAll(int offset,
                          int length,
                          K[] elements,
                          int elementsOffset,
                          int elementsLength)

keyContainsAll

boolean keyContainsAll(XGettingCollection<? extends K> elements)

keyRngContainsAll

boolean keyRngContainsAll(int offset,
                          int length,
                          XGettingCollection<? extends K> elements)

keyApplies

boolean keyApplies(Predicate<? super K> predicate)

keyRngApplies

boolean keyRngApplies(int offset,
                      int length,
                      Predicate<? super K> predicate)

keyAppliesAll

boolean keyAppliesAll(Predicate<? super K> predicate)

keyRngAppliesAll

boolean keyRngAppliesAll(int offset,
                         int length,
                         Predicate<? super K> predicate)

keyCount
```
int keyCount(K element)
```

keyCount

int keyCount(K sample,
             Equalator<? super K> equalator)

keyRngCount

int keyRngCount(int offset,
                int length,
                K element)

keyCount

int keyCount(Predicate<? super K> predicate)

keyRngCount

int keyRngCount(int offset,
                int length,
                Predicate<? super K> predicate)

keyIntersect

<C extends Consumer<? super K>> C keyIntersect(XGettingCollection<? extends K> collection,
                                               Equalator<? super K> equalator,
                                               C target)

keyExcept

<C extends Consumer<? super K>> C keyExcept(XGettingCollection<? extends K> collection,
                                            Equalator<? super K> equalator,
                                            C target)

keyUnion

<C extends Consumer<? super K>> C keyUnion(XGettingCollection<? extends K> collection,
                                           Equalator<? super K> equalator,
                                           C target)

keyRngIntersect

<C extends Consumer<? super K>> C keyRngIntersect(int offset,
                                                  int length,
                                                  XGettingCollection<? extends K> collection,
                                                  Equalator<? super K> equalator,
                                                  C target)

keyRngExcept

<C extends Consumer<? super K>> C keyRngExcept(int offset,
                                               int length,
                                               XGettingCollection<? extends K> collection,
                                               Equalator<? super K> equalator,
                                               C target)

keyRngUnion

<C extends Consumer<? super K>> C keyRngUnion(int offset,
                                              int length,
                                              XGettingCollection<? extends K> collection,
                                              Equalator<? super K> equalator,
                                              C target)

keyCopyTo

<C extends Consumer<? super K>> C keyCopyTo(C target)

keyRngCopyTo

<C extends Consumer<? super K>> C keyRngCopyTo(int offset,
                                               int length,
                                               C target)

keyCopySelection

<C extends Consumer<? super K>> C keyCopySelection(C target,
                                                   long... indices)

keyCopyToArray

int keyCopyToArray(int offset,
                   int length,
                   Object[] target,
                   int targetOffset)

keyCopyTo

<C extends Consumer<? super K>> C keyCopyTo(C target,
                                            Predicate<? super K> predicate)

keyRngCopyTo

<C extends Consumer<? super K>> C keyRngCopyTo(int offset,
                                               int length,
                                               C target,
                                               Predicate<? super K> predicate)

keyToArray
```
Object[] keyToArray()
```

keyToArray
```
K[] keyToArray(Class<K> type)
```

keyRngToArray

Object[] keyRngToArray(int offset,
                       int length)

keyRngToArray

K[] keyRngToArray(int offset,
                  int length,
                  Class<K> type)

keyFirst
```
K keyFirst()
```

keyLast
```
K keyLast()
```

keyGet
```
K keyGet(long index)
```

keySeek
```
K keySeek(K sample)
```

keySeek

K keySeek(K sample,
          Equalator<? super K> equalator)

keySearch

K keySearch(Predicate<? super K> predicate)

keyRngSearch

K keyRngSearch(int offset,
               int length,
               Predicate<? super K> predicate)

keyMin

K keyMin(Comparator<? super K> keyComparator)

keyMax

K keyMax(Comparator<? super K> keyComparator)

keyRngMin

K keyRngMin(int offset,
            int length,
            Comparator<? super K> keyComparator)

keyRngMax

K keyRngMax(int offset,
            int length,
            Comparator<? super K> keyComparator)

keyIterate

void keyIterate(Consumer<? super K> procedure)

keyJoin

<A> void keyJoin(BiConsumer<? super K,A> joiner,
                 A keyAggregate)

keyRngIterate

void keyRngIterate(int offset,
                   int length,
                   Consumer<? super K> procedure)

keyIterateIndexed

void keyIterateIndexed(IndexedAcceptor<? super K> procedure)

keyRngIterateIndexed

void keyRngIterateIndexed(int offset,
                          int length,
                          IndexedAcceptor<? super K> procedure)

keyIterate

void keyIterate(Predicate<? super K> predicate,
                Consumer<? super K> procedure)

keyIndexOf
```
int keyIndexOf(K element)
```

keyIndexOf

int keyIndexOf(K sample,
               Equalator<? super K> equalator)

keyRngIndexOf

int keyRngIndexOf(int offset,
                  int length,
                  K element)

keyRngIndexOf

int keyRngIndexOf(int offset,
                  int length,
                  K sample,
                  Equalator<? super K> equalator)

keyIndexOf

int keyIndexOf(Predicate<? super K> predicate)

keyRngIndexOf

int keyRngIndexOf(int offset,
                  int length,
                  Predicate<? super K> predicate)

keyMinIndex

int keyMinIndex(Comparator<? super K> keyComparator)

keyMaxIndex

int keyMaxIndex(Comparator<? super K> keyComparator)

keyRngMinIndex

int keyRngMinIndex(int offset,
                   int length,
                   Comparator<? super K> keyComparator)

keyRngMaxIndex

int keyRngMaxIndex(int offset,
                   int length,
                   Comparator<? super K> keyComparator)

keyScan

int keyScan(Predicate<? super K> predicate)

keyRngScan

int keyRngScan(int offset,
               int length,
               Predicate<? super K> predicate)

keyHasDistinctValues
```
boolean keyHasDistinctValues()
```

keyHasDistinctValues

boolean keyHasDistinctValues(Equalator<? super K> equalator)

keyDistinct

<C extends Consumer<? super K>> C keyDistinct(C target)

keyDistinct

<C extends Consumer<? super K>> C keyDistinct(C target,
                                              Equalator<? super K> equalator)

keyRngDistinct

<C extends Consumer<? super K>> C keyRngDistinct(int offset,
                                                 int length,
                                                 C target)

keyRngDistinct

<C extends Consumer<? super K>> C keyRngDistinct(int offset,
                                                 int length,
                                                 C target,
                                                 Equalator<? super K> equalator)

keyAppendTo

VarString keyAppendTo(VarString vc)

keyAppendTo

VarString keyAppendTo(VarString vc,
                      char separator)

keyAppendTo

VarString keyAppendTo(VarString vc,
                      String separator)

keyAppendTo

VarString keyAppendTo(VarString vc,
                      BiConsumer<VarString,? super K> keyAppender)

keyAppendTo

VarString keyAppendTo(VarString vc,
                      BiConsumer<VarString,? super K> keyAppender,
                      char separator)

keyAppendTo

VarString keyAppendTo(VarString vc,
                      BiConsumer<VarString,? super K> keyAppender,
                      String separator)

keyRngAppendTo

VarString keyRngAppendTo(int offset,
                         int length,
                         VarString vc)

keyRngAppendTo

VarString keyRngAppendTo(int offset,
                         int length,
                         VarString vc,
                         char separator)

keyRngAppendTo

VarString keyRngAppendTo(int offset,
                         int length,
                         VarString vc,
                         String separator)

keyRngAppendTo

VarString keyRngAppendTo(int offset,
                         int length,
                         VarString vc,
                         BiConsumer<VarString,? super K> keyAppender)

keyRngAppendTo

VarString keyRngAppendTo(int offset,
                         int length,
                         VarString vc,
                         BiConsumer<VarString,? super K> keyAppender,
                         char separator)

keyRngAppendTo

VarString keyRngAppendTo(int offset,
                         int length,
                         VarString vc,
                         BiConsumer<VarString,? super K> keyAppender,
                         String separator)

keyRemove
```
K keyRemove(long index)
```

keyRemoveNull
```
int keyRemoveNull()
```

keyRngRemoveNull

int keyRngRemoveNull(long offset,
                     long length)

keyRetrieve
```
K keyRetrieve(K element)
```

keyRetrieve

K keyRetrieve(K sample,
              Equalator<? super K> equalator)

keyRetrieve

K keyRetrieve(Predicate<? super K> predicate)

keyRngRetrieve

K keyRngRetrieve(long offset,
                 long length,
                 K element)

keyRngRetrieve

K keyRngRetrieve(long offset,
                 long length,
                 K sample,
                 Equalator<? super K> equalator)

keyRemoveOne
```
boolean keyRemoveOne(K element)
```

keyRemoveOne

boolean keyRemoveOne(K sample,
                     Equalator<? super K> equalator)

keyRemove
```
int keyRemove(K element)
```

keyRemove

int keyRemove(K sample,
              Equalator<? super K> equalator)

keyRngRemove

int keyRngRemove(int offset,
                 int length,
                 K element)

keyRemoveAll

int keyRemoveAll(K[] elements,
                 int elementsOffset,
                 int elementsLength)

keyRngRemoveAll

int keyRngRemoveAll(int offset,
                    int length,
                    K[] elements,
                    int elementsOffset,
                    int elementsLength)

keyRemoveAll

int keyRemoveAll(XGettingCollection<? extends K> elements)

keyRngRemoveAll

int keyRngRemoveAll(int offset,
                    int length,
                    XGettingCollection<? extends K> elements)

keyRemoveDuplicates
```
int keyRemoveDuplicates()
```

keyRemoveDuplicates

int keyRemoveDuplicates(Equalator<? super K> equalator)

keyRngRemoveDuplicates

int keyRngRemoveDuplicates(int offset,
                           int length)

keyRngRemoveDuplicates

int keyRngRemoveDuplicates(int offset,
                           int length,
                           Equalator<? super K> equalator)

keyReduce

int keyReduce(Predicate<? super K> predicate)

keyRngReduce

int keyRngReduce(int offset,
                 int length,
                 Predicate<? super K> predicate)

keyRetainAll

int keyRetainAll(K[] elements,
                 int elementsOffset,
                 int elementsLength)

keyRngRetainAll

int keyRngRetainAll(int offset,
                    int length,
                    K[] elements,
                    int elementsOffset,
                    int elementsLength)

keyRetainAll

int keyRetainAll(XGettingCollection<? extends K> elements)

keyRetainAll

int keyRetainAll(XGettingCollection<? extends K> samples,
                 Equalator<? super K> equalator)

keyRngRetainAll

int keyRngRetainAll(int offset,
                    int length,
                    XGettingCollection<? extends K> elements)

keyProcess

int keyProcess(Consumer<? super K> procedure)

keyRngProcess

int keyRngProcess(int offset,
                  int length,
                  Consumer<? super K> procedure)

keyMoveRange

int keyMoveRange(int offset,
                 int length,
                 Consumer<? super K> target)

keyMoveSelection

int keyMoveSelection(Consumer<? super K> target,
                     long... indices)

keyMoveTo

int keyMoveTo(Consumer<? super K> target,
              Predicate<? super K> predicate)

keyRngMoveTo

int keyRngMoveTo(int offset,
                 int length,
                 Consumer<? super K> target,
                 Predicate<? super K> predicate)

keySort

void keySort(Comparator<? super K> keyComparator)

keyRngSort

void keyRngSort(int offset,
                int length,
                Comparator<? super K> keyComparator)

keyIsSorted

boolean keyIsSorted(Comparator<? super K> keyComparator)

keyRngIsSorted

boolean keyRngIsSorted(int offset,
                       int length,
                       Comparator<? super K> keyComparator)

keySet

void keySet(int offset,
            K... elements)

keySet

void keySet(int offset,
            K[] elements,
            int elementsOffset,
            int elementsLength)

keyFill

void keyFill(int offset,
             int length,
             K element)

keyReplaceOne

int keyReplaceOne(K element,
                  K replacement)

keyRngReplaceOne

int keyRngReplaceOne(int offset,
                     int length,
                     K element,
                     K replacement)

keyReplace

int keyReplace(K element,
               K replacement)

keyRngReplace

int keyRngReplace(int offset,
                  int length,
                  K element,
                  K replacement)

keyRngReplace

int keyRngReplace(int offset,
                  int length,
                  K sample,
                  Equalator<? super K> equalator,
                  K replacement)

keyReplaceAll

int keyReplaceAll(K[] elements,
                  int elementsOffset,
                  int elementsLength,
                  K replacement)

keyRngReplaceAll

int keyRngReplaceAll(int offset,
                     int length,
                     K[] elements,
                     int elementsOffset,
                     int elementsLength,
                     K replacement)

keyReplaceAll

int keyReplaceAll(XGettingCollection<? extends K> elements,
                  K replacement)

keyRngReplaceAll

int keyRngReplaceAll(int offset,
                     int length,
                     XGettingCollection<? extends K> elements,
                     K replacement)

keySubstitute

long keySubstitute(Function<? super K,? extends K> mapper,
                   BiConsumer<EN,K> callback)

keySubstitute

int keySubstitute(Predicate<? super K> predicate,
                  Function<? super K,? extends K> mapper)

keyRngSubstitute

int keyRngSubstitute(int offset,
                     int length,
                     Function<? super K,? extends K> mapper)

keyRngSubstitute

int keyRngSubstitute(int offset,
                     int length,
                     Predicate<? super K> predicate,
                     Function<K,K> mapper)

keySubstituteOne

int keySubstituteOne(Predicate<? super K> predicate,
                     K keySubstitute)

keyRngSubstituteOne

int keyRngSubstituteOne(int offset,
                        int length,
                        Predicate<? super K> predicate,
                        K keySubstitute)

keySubstitute

int keySubstitute(Predicate<? super K> predicate,
                  K keySubstitute)

keyRngSubstitute

int keyRngSubstitute(int offset,
                     int length,
                     Predicate<? super K> predicate,
                     K keySubstitute)

hasVolatileValues
```
boolean hasVolatileValues()
```

getValueReferenceType
```
ReferenceType getValueReferenceType()
```

valuesIterator
```
Iterator<V> valuesIterator()
```

valuesListIterator

ListIterator<V> valuesListIterator(long index)

valuesEqualsContent

boolean valuesEqualsContent(XGettingCollection<? extends V> other,
                            Equalator<? super V> equalator)

valuesContainsNull
```
boolean valuesContainsNull()
```

valuesRngContainsNull

boolean valuesRngContainsNull(int offset,
                              int length)

valuesContainsId

boolean valuesContainsId(V element)

valuesRngContainsId

boolean valuesRngContainsId(int offset,
                            int length,
                            V value)

valuesContains
```
boolean valuesContains(V element)
```

valuesContains

boolean valuesContains(V sample,
                       Equalator<? super V> equalator)

valuesRngContains

boolean valuesRngContains(int offset,
                          int length,
                          V value)

valuesRngContains

boolean valuesRngContains(int offset,
                          int length,
                          V sample,
                          Equalator<? super V> equalator)

valuesContainsAll

boolean valuesContainsAll(V[] values,
                          int elementsOffset,
                          int elementsLength)

valuesContainsAll

boolean valuesContainsAll(V[] values,
                          int elementsOffset,
                          int elementsLength,
                          Equalator<? super V> equalator)

valuesRngContainsAll

boolean valuesRngContainsAll(int offset,
                             int length,
                             V[] values,
                             int elementsOffset,
                             int elementsLength)

valuesRngContainsAll

boolean valuesRngContainsAll(int offset,
                             int length,
                             V[] values,
                             int elementsOffset,
                             int elementsLength,
                             Equalator<? super V> equalator)

valuesContainsAll

boolean valuesContainsAll(XGettingCollection<? extends V> elements)

valuesContainsAll

boolean valuesContainsAll(XGettingCollection<? extends V> elements,
                          Equalator<? super V> equalator)

valuesRngContainsAll

boolean valuesRngContainsAll(int offset,
                             int length,
                             XGettingCollection<? extends V> elements)

valuesRngContainsAll

boolean valuesRngContainsAll(int offset,
                             int length,
                             XGettingCollection<? extends V> samples,
                             Equalator<? super V> equalator)

valuesApplies

boolean valuesApplies(Predicate<? super V> predicate)

valuesRngApplies

boolean valuesRngApplies(int offset,
                         int length,
                         Predicate<? super V> predicate)

valuesAppliesAll

boolean valuesAppliesAll(Predicate<? super V> predicate)

valuesRngAppliesAll

boolean valuesRngAppliesAll(int offset,
                            int length,
                            Predicate<? super V> predicate)

valuesCount
```
int valuesCount(V element)
```

valuesCount

int valuesCount(V sample,
                Equalator<? super V> equalator)

valuesRngCount

int valuesRngCount(int offset,
                   int length,
                   V value)

valuesRngCount

int valuesRngCount(int offset,
                   int length,
                   V sample,
                   Equalator<? super V> equalator)

valuesCount

int valuesCount(Predicate<? super V> predicate)

valuesRngCount

int valuesRngCount(int offset,
                   int length,
                   Predicate<? super V> predicate)

valuesIntersect

<C extends Consumer<? super V>> C valuesIntersect(XGettingCollection<? extends V> collection,
                                                  Equalator<? super V> equalator,
                                                  C target)

valuesExcept

<C extends Consumer<? super V>> C valuesExcept(XGettingCollection<? extends V> collection,
                                               Equalator<? super V> equalator,
                                               C target)

valuesUnion

<C extends Consumer<? super V>> C valuesUnion(XGettingCollection<? extends V> collection,
                                              Equalator<? super V> equalator,
                                              C target)

valuesRngIntersect

<C extends Consumer<? super V>> C valuesRngIntersect(int offset,
                                                     int length,
                                                     XGettingCollection<? extends V> collection,
                                                     Equalator<? super V> equalator,
                                                     C target)

valuesRngExcept

<C extends Consumer<? super V>> C valuesRngExcept(int offset,
                                                  int length,
                                                  XGettingCollection<? extends V> collection,
                                                  Equalator<? super V> equalator,
                                                  C target)

valuesRngUnion

<C extends Consumer<? super V>> C valuesRngUnion(int offset,
                                                 int length,
                                                 XGettingCollection<? extends V> collection,
                                                 Equalator<? super V> equalator,
                                                 C target)

valuesCopyTo

<C extends Consumer<? super V>> C valuesCopyTo(C target)

valuesRngCopyTo

<C extends Consumer<? super V>> C valuesRngCopyTo(int offset,
                                                  int length,
                                                  C target)

valuesCopySelection

<C extends Consumer<? super V>> C valuesCopySelection(C target,
                                                      long... indices)

valuesCopyToArray

int valuesCopyToArray(long offset,
                      int length,
                      Object[] target,
                      int targetOffset)

valuesCopyTo

<C extends Consumer<? super V>> C valuesCopyTo(C target,
                                               Predicate<? super V> predicate)

valuesRngCopyTo

<C extends Consumer<? super V>> C valuesRngCopyTo(int offset,
                                                  int length,
                                                  C target,
                                                  Predicate<? super V> predicate)

valuesToArray
```
Object[] valuesToArray()
```

valuesToArray
```
V[] valuesToArray(Class<V> type)
```

valuesRngToArray

Object[] valuesRngToArray(int offset,
                          int length)

valuesRngToArray

V[] valuesRngToArray(int offset,
                     int length,
                     Class<V> type)

valuesFirst
```
V valuesFirst()
```

valuesLast
```
V valuesLast()
```

valuesGet
```
V valuesGet(long index)
```

valuesSeek
```
V valuesSeek(V sample)
```

valuesRngSeek

V valuesRngSeek(int offset,
                int length,
                V sample)

valuesSearch

V valuesSearch(V sample,
               Equalator<? super V> equalator)

valuesRngSearch

V valuesRngSearch(int offset,
                  int length,
                  V sample,
                  Equalator<? super V> equalator)

valuesSearch

V valuesSearch(Predicate<? super V> predicate)

valuesRngSearch

V valuesRngSearch(int offset,
                  int length,
                  Predicate<? super V> predicate)

valuesMin

V valuesMin(Comparator<? super V> comparator)

valuesMax

V valuesMax(Comparator<? super V> comparator)

valuesRngMin

V valuesRngMin(int offset,
               int length,
               Comparator<? super V> comparator)

valuesRngMax

V valuesRngMax(int offset,
               int length,
               Comparator<? super V> comparator)

valuesIterate

void valuesIterate(Consumer<? super V> procedure)

valuesRngIterate

void valuesRngIterate(int offset,
                      int length,
                      Consumer<? super V> procedure)

valuesIterateIndexed

void valuesIterateIndexed(IndexedAcceptor<? super V> procedure)

valuesRngIterateIndexed

void valuesRngIterateIndexed(int offset,
                             int length,
                             IndexedAcceptor<? super V> procedure)

valuesJoin

<A> void valuesJoin(BiConsumer<? super V,A> joiner,
                    A aggregate)

valuesIterate

void valuesIterate(Predicate<? super V> predicate,
                   Consumer<? super V> procedure)

valuesIndexOf
```
int valuesIndexOf(V element)
```

valuesIndexOf

int valuesIndexOf(V sample,
                  Equalator<? super V> equalator)

valuesRngIndexOf

int valuesRngIndexOf(int offset,
                     int length,
                     V value)

valuesRngIndexOf

int valuesRngIndexOf(int offset,
                     int length,
                     V sample,
                     Equalator<? super V> equalator)

valuesIndexOf

int valuesIndexOf(Predicate<? super V> predicate)

valuesRngIndexOf

int valuesRngIndexOf(int offset,
                     int length,
                     Predicate<? super V> predicate)

valuesMinIndex

int valuesMinIndex(Comparator<? super V> comparator)

valuesMaxIndex

int valuesMaxIndex(Comparator<? super V> comparator)

valuesRngMinIndex

int valuesRngMinIndex(int offset,
                      int length,
                      Comparator<? super V> comparator)

valuesRngMaxIndex

int valuesRngMaxIndex(int offset,
                      int length,
                      Comparator<? super V> comparator)

valuesScan

int valuesScan(Predicate<? super V> predicate)

valuesRngScan

int valuesRngScan(int offset,
                  int length,
                  Predicate<? super V> predicate)

valuesHasDistinctValues
```
boolean valuesHasDistinctValues()
```

valuesHasDistinctValues

boolean valuesHasDistinctValues(Equalator<? super V> equalator)

valuesDistinct

<C extends Consumer<? super V>> C valuesDistinct(C target)

valuesDistinct

<C extends Consumer<? super V>> C valuesDistinct(C target,
                                                 Equalator<? super V> equalator)

valuesRngDistinct

<C extends Consumer<? super V>> C valuesRngDistinct(int offset,
                                                    int length,
                                                    C target)

valuesRngDistinct

<C extends Consumer<? super V>> C valuesRngDistinct(int offset,
                                                    int length,
                                                    C target,
                                                    Equalator<? super V> equalator)

valuesAppendTo

VarString valuesAppendTo(VarString vc)

valuesAppendTo

VarString valuesAppendTo(VarString vc,
                         char separator)

valuesAppendTo

VarString valuesAppendTo(VarString vc,
                         String separator)

valuesAppendTo

VarString valuesAppendTo(VarString vc,
                         BiConsumer<VarString,? super V> appender)

valuesAppendTo

VarString valuesAppendTo(VarString vc,
                         BiConsumer<VarString,? super V> appender,
                         char separator)

valuesAppendTo

VarString valuesAppendTo(VarString vc,
                         BiConsumer<VarString,? super V> appender,
                         String separator)

valuesRngAppendTo

VarString valuesRngAppendTo(int offset,
                            int length,
                            VarString vc)

valuesRngAppendTo

VarString valuesRngAppendTo(int offset,
                            int length,
                            VarString vc,
                            char separator)

valuesRngAppendTo

VarString valuesRngAppendTo(int offset,
                            int length,
                            VarString vc,
                            String separator)

valuesRngAppendTo

VarString valuesRngAppendTo(int offset,
                            int length,
                            VarString vc,
                            BiConsumer<VarString,? super V> appender)

valuesRngAppendTo

VarString valuesRngAppendTo(int offset,
                            int length,
                            VarString vc,
                            BiConsumer<VarString,? super V> appender,
                            char separator)

valuesRngAppendTo

VarString valuesRngAppendTo(int offset,
                            int length,
                            VarString vc,
                            BiConsumer<VarString,? super V> appender,
                            String separator)

valuesToString
```
String valuesToString()
```

valuesRemove
```
V valuesRemove(long index)
```

valuesRemoveNull
```
int valuesRemoveNull()
```

valuesRngRemoveNull

int valuesRngRemoveNull(int offset,
                        int length)

valuesRetrieve
```
V valuesRetrieve(V element)
```

valuesRetrieve

V valuesRetrieve(Predicate<? super V> predicate)

valuesRngRetrieve

V valuesRngRetrieve(int offset,
                    int length,
                    V value)

valuesRngRetrieve

V valuesRngRetrieve(int offset,
                    int length,
                    V sample,
                    Equalator<? super V> equalator)

valuesRemoveOne
```
boolean valuesRemoveOne(V element)
```

valuesRemoveOne

boolean valuesRemoveOne(V sample,
                        Equalator<? super V> equalator)

valuesRngRemoveOne

boolean valuesRngRemoveOne(int offset,
                           int length,
                           V value)

valuesRngRemoveOne

boolean valuesRngRemoveOne(int offset,
                           int length,
                           V sample,
                           Equalator<? super V> equalator)

valuesRemove
```
int valuesRemove(V element)
```

valuesRemove

int valuesRemove(V sample,
                 Equalator<? super V> equalator)

valuesRngRemove

int valuesRngRemove(int offset,
                    int length,
                    V value)

valuesRngRemove

int valuesRngRemove(int offset,
                    int length,
                    V sample,
                    Equalator<? super V> equalator)

valuesRemoveAll

int valuesRemoveAll(V[] values,
                    int elementsOffset,
                    int elementsLength)

valuesRemoveAll

int valuesRemoveAll(V[] samples,
                    int samplesOffset,
                    int samplesLength,
                    Equalator<? super V> equalator)

valuesRngRemoveAll

int valuesRngRemoveAll(int offset,
                       int length,
                       V[] values,
                       int elementsOffset,
                       int elementsLength)

valuesRngRemoveAll

int valuesRngRemoveAll(int offset,
                       int length,
                       V[] samples,
                       int samplesOffset,
                       int samplesLength,
                       Equalator<? super V> equalator)

valuesRemoveAll

int valuesRemoveAll(XGettingCollection<? extends V> elements)

valuesRemoveAll

int valuesRemoveAll(XGettingCollection<? extends V> samples,
                    Equalator<? super V> equalator)

valuesRngRemoveAll

int valuesRngRemoveAll(int offset,
                       int length,
                       XGettingCollection<? extends V> elements)

valuesRngRemoveAll

int valuesRngRemoveAll(int offset,
                       int length,
                       XGettingCollection<? extends V> samples,
                       Equalator<? super V> equalator)

valuesRemoveDuplicates
```
int valuesRemoveDuplicates()
```

valuesRemoveDuplicates

int valuesRemoveDuplicates(Equalator<? super V> equalator)

valuesRngRemoveDuplicates

int valuesRngRemoveDuplicates(int offset,
                              int length)

valuesRngRemoveDuplicates

int valuesRngRemoveDuplicates(int offset,
                              int length,
                              Equalator<? super V> equalator)

valuesReduce

int valuesReduce(Predicate<? super V> predicate)

valuesRngReduce

int valuesRngReduce(int offset,
                    int length,
                    Predicate<? super V> predicate)

valuesRetainAll

int valuesRetainAll(V[] values,
                    int elementsOffset,
                    int elementsLength)

valuesRetainAll

int valuesRetainAll(V[] samples,
                    int elementsOffset,
                    int elementsLength,
                    Equalator<? super V> equalator)

valuesRngRetainAll

int valuesRngRetainAll(int offset,
                       int length,
                       V[] values,
                       int elementsOffset,
                       int elementsLength)

valuesRngRetainAll

int valuesRngRetainAll(int offset,
                       int length,
                       V[] samples,
                       int elementsOffset,
                       int elementsLength,
                       Equalator<? super V> equalator)

valuesRetainAll

int valuesRetainAll(XGettingCollection<? extends V> elements)

valuesRetainAll

int valuesRetainAll(XGettingCollection<? extends V> samples,
                    Equalator<? super V> equalator)

valuesRngRetainAll

int valuesRngRetainAll(int offset,
                       int length,
                       XGettingCollection<? extends V> elements)

valuesRngRetainAll

int valuesRngRetainAll(int offset,
                       int length,
                       XGettingCollection<? extends V> samples,
                       Equalator<? super V> equalator)

valuesProcess

int valuesProcess(Consumer<? super V> procedure)

valuesRngProcess

int valuesRngProcess(int offset,
                     int length,
                     Consumer<? super V> procedure)

valuesMoveRange

int valuesMoveRange(int offset,
                    int length,
                    Consumer<? super V> target)

valuesMoveSelection

int valuesMoveSelection(Consumer<? super V> target,
                        long... indices)

valuesMoveTo

int valuesMoveTo(Consumer<? super V> target,
                 Predicate<? super V> predicate)

valuesRngMoveTo

int valuesRngMoveTo(int offset,
                    int length,
                    Consumer<? super V> target,
                    Predicate<? super V> predicate)

valuesSort

void valuesSort(Comparator<? super V> comparator)

valuesRngSort

void valuesRngSort(int offset,
                   int length,
                   Comparator<? super V> comparator)

valuesIsSorted

boolean valuesIsSorted(Comparator<? super V> comparator)

valuesRngIsSorted

boolean valuesRngIsSorted(int offset,
                          int length,
                          Comparator<? super V> comparator)

valuesSet

V valuesSet(long offset,
            V value)

valuesSet

void valuesSet(long offset,
               V[] values)

valuesSet

void valuesSet(long offset,
               V[] values,
               int valuesOffset,
               int valuesLength)

valuesFill

void valuesFill(long offset,
                long length,
                V value)

valuesReplaceOne

boolean valuesReplaceOne(V element,
                         V replacement)

valuesReplaceOne

boolean valuesReplaceOne(V sample,
                         Equalator<? super V> equalator,
                         V replacement)

valuesRngReplaceOne

int valuesRngReplaceOne(int offset,
                        int length,
                        V value,
                        V replacement)

valuesRngReplaceOne

int valuesRngReplaceOne(int offset,
                        int length,
                        V sample,
                        Equalator<? super V> equalator,
                        V replacement)

valuesReplace

int valuesReplace(V element,
                  V replacement)

valuesReplace

int valuesReplace(V sample,
                  Equalator<? super V> equalator,
                  V replacement)

valuesRngReplace

int valuesRngReplace(int offset,
                     int length,
                     V value,
                     V replacement)

valuesRngReplace

int valuesRngReplace(int offset,
                     int length,
                     V sample,
                     Equalator<? super V> equalator,
                     V replacement)

valuesReplaceAll

int valuesReplaceAll(V[] values,
                     int valuesOffset,
                     int valuesLength,
                     V replacement)

valuesReplaceAll

int valuesReplaceAll(V[] samples,
                     int samplesOffset,
                     int samplesLength,
                     Equalator<? super V> equalator,
                     V replacement)

valuesRngReplaceAll

int valuesRngReplaceAll(int offset,
                        int length,
                        V[] values,
                        int valuesOffset,
                        int valuesLength,
                        V replacement)

valuesRngReplaceAll

int valuesRngReplaceAll(int offset,
                        int length,
                        V[] samples,
                        int samplesOffset,
                        int samplesLength,
                        Equalator<? super V> equalator,
                        V replacement)

valuesReplaceAll

int valuesReplaceAll(XGettingCollection<? extends V> elements,
                     V replacement)

valuesReplaceAll

int valuesReplaceAll(XGettingCollection<? extends V> samples,
                     Equalator<? super V> equalator,
                     V replacement)

valuesRngReplaceAll

int valuesRngReplaceAll(int offset,
                        int length,
                        XGettingCollection<? extends V> elements,
                        V replacement)

valuesRngReplaceAll

int valuesRngReplaceAll(int offset,
                        int length,
                        XGettingCollection<? extends V> samples,
                        Equalator<? super V> equalator,
                        V replacement)

valuesSubstitute

int valuesSubstitute(Function<? super V,? extends V> mapper)

valuesSubstitute

int valuesSubstitute(Predicate<? super V> predicate,
                     Function<V,V> mapper)

valuesRngSubstitute

int valuesRngSubstitute(int offset,
                        int length,
                        Function<V,V> mapper)

valuesRngSubstitute

int valuesRngSubstitute(int offset,
                        int length,
                        Predicate<? super V> predicate,
                        Function<V,V> mapper)

valuesSubstituteOne

boolean valuesSubstituteOne(Predicate<? super V> predicate,
                            V substitute)

valuesRngSubstituteOne

int valuesRngSubstituteOne(int offset,
                           int length,
                           Predicate<? super V> predicate,
                           V substitute)

valuesSubstitute

int valuesSubstitute(Predicate<? super V> predicate,
                     V substitute)

valuesRngSubstitute

int valuesRngSubstitute(int offset,
                        int length,
                        Predicate<? super V> predicate,
                        V substitute)

shiftTo
```
void shiftTo(long sourceIndex,
             long targetIndex)
```
Specified by:

shiftTo in interface ChainStorage<KeyValue<K,V>,K,V,EN extends AbstractChainEntry<KeyValue<K,V>,K,V,EN>>

shiftTo
```
void shiftTo(long sourceIndex,
             long targetIndex,
             long length)
```
Specified by:

shiftTo in interface ChainStorage<KeyValue<K,V>,K,V,EN extends AbstractChainEntry<KeyValue<K,V>,K,V,EN>>

shiftBy
```
void shiftBy(long sourceIndex,
             long distance)
```
Specified by:

shiftBy in interface ChainStorage<KeyValue<K,V>,K,V,EN extends AbstractChainEntry<KeyValue<K,V>,K,V,EN>>

shiftBy
```
void shiftBy(long sourceIndex,
             long distance,
             long length)
```
Specified by:

shiftBy in interface ChainStorage<KeyValue<K,V>,K,V,EN extends AbstractChainEntry<KeyValue<K,V>,K,V,EN>>

swap
```
void swap(long indexA,
          long indexB)
```
Specified by:

swap in interface ChainStorage<KeyValue<K,V>,K,V,EN extends AbstractChainEntry<KeyValue<K,V>,K,V,EN>>

swap
```
void swap(long indexA,
          long indexB,
          long length)
```
Specified by:

swap in interface ChainStorage<KeyValue<K,V>,K,V,EN extends AbstractChainEntry<KeyValue<K,V>,K,V,EN>>

reverse
```
void reverse()
```
Specified by:

reverse in interface ChainStorage<KeyValue<K,V>,K,V,EN extends AbstractChainEntry<KeyValue<K,V>,K,V,EN>>

rngReverse
```
void rngReverse(long offset,
                long length)
```
Specified by:

rngReverse in interface ChainStorage<KeyValue<K,V>,K,V,EN extends AbstractChainEntry<KeyValue<K,V>,K,V,EN>>

shuffle
```
void shuffle()
```
Specified by:

shuffle in interface ChainStorage<KeyValue<K,V>,K,V,EN extends AbstractChainEntry<KeyValue<K,V>,K,V,EN>>

rngShuffle
```
void rngShuffle(long offset,
                long length)
```
Specified by:

rngShuffle in interface ChainStorage<KeyValue<K,V>,K,V,EN extends AbstractChainEntry<KeyValue<K,V>,K,V,EN>>

Interface ChainKeyValueStorage<K,​V,​EN extends AbstractChainEntry<KeyValue<K,​V>,​K,​V,​EN>>

Nested Class Summary

Nested classes/interfaces inherited from interface one.microstream.collections.interfaces.ChainStorage

Method Summary

Methods inherited from interface one.microstream.collections.interfaces.ChainStorage

Methods inherited from interface java.lang.Iterable

Method Detail

getChainEntry

getRangeChainEntry

getIntervalLowChainEntry

searchValue

size

consolidate

hasVolatileElements

getReferenceType

keyIterator

keyEqualsContent

removeRange

removeSelection

keyContainsNull

keyRngContainsNull

keyContainsId

keyRngContainsId

keyContains

keyContains

keyRngContains

keyContainsAll

keyRngContainsAll

keyContainsAll

keyRngContainsAll

keyApplies

keyRngApplies

keyAppliesAll

keyRngAppliesAll

keyCount

keyCount

keyRngCount

keyCount

keyRngCount

keyIntersect

keyExcept

keyUnion

keyRngIntersect

keyRngExcept

keyRngUnion

keyCopyTo

keyRngCopyTo

keyCopySelection

keyCopyToArray

keyCopyTo

keyRngCopyTo

keyToArray

keyToArray

keyRngToArray

keyRngToArray

keyFirst

keyLast

keyGet

keySeek

keySeek

keySearch

keyRngSearch

keyMin

keyMax

keyRngMin

keyRngMax

keyIterate

keyJoin

keyRngIterate

keyIterateIndexed

keyRngIterateIndexed

keyIterate

keyIndexOf

keyIndexOf

keyRngIndexOf

keyRngIndexOf

keyIndexOf

keyRngIndexOf

keyMinIndex

keyMaxIndex

Interface ChainKeyValueStorage<K,V,EN extends AbstractChainEntry<KeyValue<K,V>,K,V,EN>>