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`	`keyIndexBy(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()`
`int`	`keyLastIndexBy(Predicate<? super K> predicate)`
`int`	`keyLastIndexOf(K element)`
`int`	`keyLastIndexOf(K sample, Equalator<? super K> equalator)`
`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)`
`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()`
`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`	`valuesIndexBy(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()`
`int`	`valuesLastIndexBy(Predicate<? super V> predicate)`
`int`	`valuesLastIndexOf(V element)`
`int`	`valuesLastIndexOf(V sample, Equalator<? super V> equalator)`
`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)`
`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, lastIndexBy, lastIndexOf, lastIndexOf, 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, scan, search, seek, seek, set, set, sort, substitute, substitute, toArray, toArray, toString, union

Methods inherited from interface java.lang.Iterable

forEach, spliterator

Method Details
- 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()
- keyContainsId
  
  boolean keyContainsId(K element)
- keyContains
  
  boolean keyContains(K element)
- keyContains
  
  boolean keyContains(K sample, Equalator<? super K> equalator)
- keyContainsAll
  
  boolean keyContainsAll(K[] elements, int elementsOffset, int elementsLength)
- keyContainsAll
  
  boolean keyContainsAll(XGettingCollection<? extends K> elements)
- keyApplies
  
  boolean keyApplies(Predicate<? super K> predicate)
- keyAppliesAll
  
  boolean keyAppliesAll(Predicate<? super K> predicate)
- keyCount
  
  int keyCount(K element)
- keyCount
  
  int keyCount(K sample, Equalator<? super K> equalator)
- keyCount
  
  int keyCount(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)
- keyCopyTo
  
  <C extends Consumer<? super K>> C keyCopyTo(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)
- keyToArray
  
  Object[] keyToArray()
- keyToArray
  
  K[] keyToArray(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)
- keyMin
  
  K keyMin(Comparator<? super K> keyComparator)
- keyMax
  
  K keyMax(Comparator<? super K> keyComparator)
- keyIterate
  
  void keyIterate(Consumer<? super K> procedure)
- keyJoin
  
  <A> void keyJoin(BiConsumer<? super K,A> joiner, A keyAggregate)
- keyIterateIndexed
  
  void keyIterateIndexed(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)
- keyIndexBy
  
  int keyIndexBy(Predicate<? super K> predicate)
- keyLastIndexOf
  
  int keyLastIndexOf(K element)
- keyLastIndexOf
  
  int keyLastIndexOf(K sample, Equalator<? super K> equalator)
- keyLastIndexBy
  
  int keyLastIndexBy(Predicate<? super K> predicate)
- keyMinIndex
  
  int keyMinIndex(Comparator<? super K> keyComparator)
- keyMaxIndex
  
  int keyMaxIndex(Comparator<? super K> keyComparator)
- keyScan
  
  int keyScan(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)
- 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)
- keyRemove
  
  K keyRemove(long index)
- keyRemoveNull
  
  int keyRemoveNull()
- keyRetrieve
  
  K keyRetrieve(K element)
- keyRetrieve
  
  K keyRetrieve(K sample, Equalator<? super K> equalator)
- keyRetrieve
  
  K keyRetrieve(Predicate<? super K> predicate)
- 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)
- keyRemoveAll
  
  int keyRemoveAll(K[] elements, int elementsOffset, int elementsLength)
- keyRemoveAll
  
  int keyRemoveAll(XGettingCollection<? extends K> elements)
- keyRemoveDuplicates
  
  int keyRemoveDuplicates()
- keyRemoveDuplicates
  
  int keyRemoveDuplicates(Equalator<? super K> equalator)
- keyReduce
  
  int keyReduce(Predicate<? super K> predicate)
- keyRetainAll
  
  int keyRetainAll(K[] elements, int elementsOffset, int elementsLength)
- keyRetainAll
  
  int keyRetainAll(XGettingCollection<? extends K> elements)
- keyRetainAll
  
  int keyRetainAll(XGettingCollection<? extends K> samples, Equalator<? super K> equalator)
- keyProcess
  
  int keyProcess(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)
- keySort
  
  void keySort(Comparator<? super K> keyComparator)
- keyIsSorted
  
  boolean keyIsSorted(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)
- keyReplace
  
  int keyReplace(K element, K replacement)
- keyReplaceAll
  
  int keyReplaceAll(K[] elements, int elementsOffset, int elementsLength, K replacement)
- keyReplaceAll
  
  int keyReplaceAll(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)
- keySubstituteOne
  
  int keySubstituteOne(Predicate<? super K> predicate, K keySubstitute)
- keySubstitute
  
  int keySubstitute(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()
- valuesContainsId
  
  boolean valuesContainsId(V element)
- valuesContains
  
  boolean valuesContains(V element)
- valuesContains
  
  boolean valuesContains(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)
- valuesContainsAll
  
  boolean valuesContainsAll(XGettingCollection<? extends V> elements)
- valuesContainsAll
  
  boolean valuesContainsAll(XGettingCollection<? extends V> elements, Equalator<? super V> equalator)
- valuesApplies
  
  boolean valuesApplies(Predicate<? super V> predicate)
- valuesAppliesAll
  
  boolean valuesAppliesAll(Predicate<? super V> predicate)
- valuesCount
  
  int valuesCount(V element)
- valuesCount
  
  int valuesCount(V sample, Equalator<? super V> equalator)
- valuesCount
  
  int valuesCount(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)
- valuesCopyTo
  
  <C extends Consumer<? super V>> C valuesCopyTo(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)
- valuesToArray
  
  Object[] valuesToArray()
- valuesToArray
  
  V[] valuesToArray(Class<V> type)
- valuesFirst
  
  V valuesFirst()
- valuesLast
  
  V valuesLast()
- valuesGet
  
  V valuesGet(long index)
- valuesSeek
  
  V valuesSeek(V sample)
- valuesSearch
  
  V valuesSearch(V sample, Equalator<? super V> equalator)
- valuesSearch
  
  V valuesSearch(Predicate<? super V> predicate)
- valuesMin
  
  V valuesMin(Comparator<? super V> comparator)
- valuesMax
  
  V valuesMax(Comparator<? super V> comparator)
- valuesIterate
  
  void valuesIterate(Consumer<? super V> procedure)
- valuesIterateIndexed
  
  void valuesIterateIndexed(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)
- valuesIndexBy
  
  int valuesIndexBy(Predicate<? super V> predicate)
- valuesLastIndexOf
  
  int valuesLastIndexOf(V element)
- valuesLastIndexOf
  
  int valuesLastIndexOf(V sample, Equalator<? super V> equalator)
- valuesLastIndexBy
  
  int valuesLastIndexBy(Predicate<? super V> predicate)
- valuesMinIndex
  
  int valuesMinIndex(Comparator<? super V> comparator)
- valuesMaxIndex
  
  int valuesMaxIndex(Comparator<? super V> comparator)
- valuesScan
  
  int valuesScan(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)
- 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)
- valuesToString
  
  String valuesToString()
- valuesRemove
  
  V valuesRemove(long index)
- valuesRemoveNull
  
  int valuesRemoveNull()
- valuesRetrieve
  
  V valuesRetrieve(V element)
- valuesRetrieve
  
  V valuesRetrieve(Predicate<? super V> predicate)
- valuesRemoveOne
  
  boolean valuesRemoveOne(V element)
- valuesRemoveOne
  
  boolean valuesRemoveOne(V sample, Equalator<? super V> equalator)
- valuesRemove
  
  int valuesRemove(V element)
- valuesRemove
  
  int valuesRemove(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)
- valuesRemoveAll
  
  int valuesRemoveAll(XGettingCollection<? extends V> elements)
- valuesRemoveAll
  
  int valuesRemoveAll(XGettingCollection<? extends V> samples, Equalator<? super V> equalator)
- valuesRemoveDuplicates
  
  int valuesRemoveDuplicates()
- valuesRemoveDuplicates
  
  int valuesRemoveDuplicates(Equalator<? super V> equalator)
- valuesReduce
  
  int valuesReduce(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)
- valuesRetainAll
  
  int valuesRetainAll(XGettingCollection<? extends V> elements)
- valuesRetainAll
  
  int valuesRetainAll(XGettingCollection<? extends V> samples, Equalator<? super V> equalator)
- valuesProcess
  
  int valuesProcess(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)
- valuesSort
  
  void valuesSort(Comparator<? super V> comparator)
- valuesIsSorted
  
  boolean valuesIsSorted(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)
- valuesReplace
  
  int valuesReplace(V element, V replacement)
- valuesReplace
  
  int valuesReplace(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)
- valuesReplaceAll
  
  int valuesReplaceAll(XGettingCollection<? extends V> elements, V replacement)
- valuesReplaceAll
  
  int valuesReplaceAll(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)
- valuesSubstituteOne
  
  boolean valuesSubstituteOne(Predicate<? super V> predicate, V substitute)
- valuesSubstitute
  
  int valuesSubstitute(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>>
- shuffle
  
  void shuffle()
  
  Specified by:
  
  shuffle 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 Details

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