one.microstream.collections.interfaces

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

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 and 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, 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)
VarString	keyAppendTo(VarString vc, char separator)
VarString	keyAppendTo(VarString vc, 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(K element)
int	keyCount(K sample, Equalator<? super K> equalator)
int	keyCount(Predicate<? super K> predicate)
<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)
int	keyRemove(K element)
int	keyRemove(K sample, Equalator<? super K> equalator)
K	keyRemove(long index)
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(K element)
K	keyRetrieve(K sample, Equalator<? super K> equalator)
K	keyRetrieve(Predicate<? super K> predicate)
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, 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)
VarString	valuesAppendTo(VarString vc, char separator)
VarString	valuesAppendTo(VarString vc, 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(V[] values, int elementsOffset, int elementsLength)
boolean	valuesContainsAll(V[] values, int elementsOffset, int elementsLength, Equalator<? super V> equalator)
boolean	valuesContainsAll(XGettingCollection<? extends V> elements)
boolean	valuesContainsAll(XGettingCollection<? extends V> elements, 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(V[] values, int elementsOffset, int elementsLength)
int	valuesRemoveAll(V[] samples, int samplesOffset, int samplesLength, Equalator<? super V> equalator)
int	valuesRemoveAll(XGettingCollection<? extends V> elements)
int	valuesRemoveAll(XGettingCollection<? extends V> samples, 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(V[] samples, int samplesOffset, int samplesLength, Equalator<? super V> equalator, V replacement)
int	valuesReplaceAll(V[] values, int valuesOffset, int valuesLength, V replacement)
int	valuesReplaceAll(XGettingCollection<? extends V> samples, Equalator<? super V> equalator, V replacement)
int	valuesReplaceAll(XGettingCollection<? extends V> elements, V replacement)
boolean	valuesReplaceOne(V sample, Equalator<? super V> equalator, V replacement)
boolean	valuesReplaceOne(V element, V replacement)
int	valuesRetainAll(V[] values, int elementsOffset, int elementsLength)
int	valuesRetainAll(V[] samples, int elementsOffset, int elementsLength, Equalator<? super V> equalator)
int	valuesRetainAll(XGettingCollection<? extends V> elements)
int	valuesRetainAll(XGettingCollection<? extends V> samples, 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 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()

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>>