one.microstream.collections

Class ChainStrongStrongStorage<K,V,EN extends AbstractChainEntry<KeyValue<K,V>,K,V,EN>>

java.lang.Object

one.microstream.collections.AbstractChainStorage<E,K,V,EN>

one.microstream.collections.ChainStorageStrong<KeyValue<K,V>,K,V,EN>

one.microstream.collections.AbstractChainKeyValueStorage<K,V,EN>

one.microstream.collections.ChainStrongStrongStorage<K,V,EN>

All Implemented Interfaces:

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

public final class ChainStrongStrongStorage<K,V,EN extends AbstractChainEntry<KeyValue<K,V>,K,V,EN>>
extends AbstractChainKeyValueStorage<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>>

Constructor Summary

Constructors

Constructor and Description
ChainStrongStrongStorage(AbstractChainCollection<KeyValue<K,V>,K,V,EN> parent, EN head)

Method Summary

Modifier and Type	Method and Description
ReferenceType	getValueReferenceType()
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> samples, 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> samples, Equalator<? super K> equalator, C target)
boolean	keyIsSorted(Comparator<? super K> comparator)
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 aggregate)
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> comparator)
int	keyMaxIndex(Comparator<? super K> comparator)
K	keyMin(Comparator<? super K> comparator)
int	keyMinIndex(Comparator<? super K> comparator)
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(K[] samples, int samplesOffset, int samplesLength, Equalator<? super K> equalator)
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> comparator)
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 substitute)
int	keySubstituteOne(Predicate<? super K> predicate, K substitute)
Object[]	keyToArray()
K[]	keyToArray(Class<K> type)
<C extends Consumer<? super K>> C	keyUnion(XGettingCollection<? extends K> samples, Equalator<? super K> equalator, C target)
V	searchValue(K key, Equalator<? super K> equalator)
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[] elements, int elementsOffset, int elementsLength)
boolean	valuesContainsAll(V[] elements, 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> samples, Equalator<? super V> equalator, C target)
void	valuesFill(long offset, long length, V element)
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> samples, 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[] elements, 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[] elements, int elementsOffset, int elementsLength, 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[] elements, int elementsOffset, int elementsLength)
int	valuesRetainAll(V[] samples, int samplesOffset, int samplesLength, 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 element)
V	valuesSet(long offset, V value)
void	valuesSet(long offset, V[] elements)
void	valuesSet(long offset, V[] elements, int elementsOffset, int elementsLength)
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> samples, Equalator<? super V> equalator, C target)

Methods inherited from class one.microstream.collections.ChainStorageStrong

appendEntry, appendTo, appendTo, appendTo, appendTo, appendTo, appendTo, appliesAll, clear, consolidate, contains, contains, containsAll, containsAll, containsId, containsNull, containsSearched, copySelection, copyTo, copyTo, copyToArray, count, count, count, disjoinEntry, distinct, distinct, equalsContent, except, fill, first, get, getChainEntry, getIntervalLowChainEntry, getRangeChainEntry, getReferenceType, hasDistinctValues, hasDistinctValues, hasVolatileElements, head, indexOf, indexOf, indexOf, intersect, isSorted, iterate, iterate, iterateIndexed, iterator, join, last, lastIndexBy, lastIndexOf, lastIndexOf, max, maxIndex, min, minIndex, moveRange, moveSelection, moveTo, moveToEnd, moveToStart, prependEntry, process, reduce, remove, remove, remove, removeAll, removeAll, removeDuplicates, removeDuplicates, removeNull, removeOne, removeOne, removeRange, removeSelection, replace, replace, replaceAll, replaceAll, replaceBy, replaceOne, replaceOneBy, retainAll, retainAll, retainAll, retainAll, retainRange, retrieve, retrieve, retrieve, reverse, scan, search, seek, seek, set, set, shiftBy, shiftBy, shiftTo, shiftTo, shuffle, size, sort, substitute, substitute, substitute, swap, swap, toArray, toArray, toString, union

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

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

consolidate, getChainEntry, getIntervalLowChainEntry, getRangeChainEntry, getReferenceType, hasVolatileElements, removeRange, removeSelection, reverse, shiftBy, shiftBy, shiftTo, shiftTo, shuffle, size, swap, swap

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

Constructor Detail

ChainStrongStrongStorage

public ChainStrongStrongStorage(AbstractChainCollection<KeyValue<K,V>,K,V,EN> parent,
                                EN head)

Method Detail

keyIterator

public final Iterator<K> keyIterator()

keyEqualsContent

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

searchValue

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

keyContainsNull

public final boolean keyContainsNull()

keyContainsId

public final boolean keyContainsId(K element)

keyContains

public final boolean keyContains(K element)

keyContains

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

keyContainsAll

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

keyContainsAll

public final boolean keyContainsAll(XGettingCollection<? extends K> elements)

keyApplies

public final boolean keyApplies(Predicate<? super K> predicate)

keyAppliesAll

public final boolean keyAppliesAll(Predicate<? super K> predicate)

keyCount

public final int keyCount(K element)

keyCount

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

keyCount

public final int keyCount(Predicate<? super K> predicate)

keyIntersect

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

keyExcept

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

keyUnion

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

keyCopyTo

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

keyCopySelection

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

keyCopyTo

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

keyToArray

public final Object[] keyToArray()

keyToArray

public final K[] keyToArray(Class<K> type)

keyFirst

public final K keyFirst()

keyLast

public final K keyLast()

keyGet

public final K keyGet(long index)

keySeek

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

keySeek

public final K keySeek(K sample)

keySearch

public final K keySearch(Predicate<? super K> predicate)

keyMin

public final K keyMin(Comparator<? super K> comparator)

keyMax

public final K keyMax(Comparator<? super K> comparator)

keyIterate

public final void keyIterate(Consumer<? super K> procedure)

keyJoin

public final <A> void keyJoin(BiConsumer<? super K,A> joiner,
                              A aggregate)

keyIterateIndexed

public final void keyIterateIndexed(IndexedAcceptor<? super K> procedure)

keyIterate

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

keyIndexOf

public final int keyIndexOf(K element)

keyIndexOf

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

keyIndexBy

public final int keyIndexBy(Predicate<? super K> predicate)

keyLastIndexOf

public final int keyLastIndexOf(K element)

keyLastIndexOf

public final int keyLastIndexOf(K sample,
                                Equalator<? super K> equalator)

keyLastIndexBy

public final int keyLastIndexBy(Predicate<? super K> predicate)

keyMinIndex

public final int keyMinIndex(Comparator<? super K> comparator)

keyMaxIndex

public final int keyMaxIndex(Comparator<? super K> comparator)

keyScan

public final int keyScan(Predicate<? super K> predicate)

keyHasDistinctValues

public final boolean keyHasDistinctValues()

keyHasDistinctValues

public final boolean keyHasDistinctValues(Equalator<? super K> equalator)

keyDistinct

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

keyDistinct

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

keyRemove

public final K keyRemove(long index)

keyRemoveNull

public final int keyRemoveNull()

keyRetrieve

public final K keyRetrieve(K element)

keyRetrieve

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

keyRetrieve

public final K keyRetrieve(Predicate<? super K> predicate)

keyRemoveOne

public final boolean keyRemoveOne(K element)

keyRemoveOne

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

keyRemove

public final int keyRemove(K element)

keyRemove

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

keyRemoveAll

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

keyRemoveAll

public final int keyRemoveAll(XGettingCollection<? extends K> elements)

keyRemoveDuplicates

public final int keyRemoveDuplicates()

keyRemoveDuplicates

public final int keyRemoveDuplicates(Equalator<? super K> equalator)

keyReduce

public final int keyReduce(Predicate<? super K> predicate)

keyRetainAll

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

keyRetainAll

public final int keyRetainAll(K[] samples,
                              int samplesOffset,
                              int samplesLength,
                              Equalator<? super K> equalator)

keyRetainAll

public final int keyRetainAll(XGettingCollection<? extends K> elements)

keyRetainAll

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

keyProcess

public final int keyProcess(Consumer<? super K> procedure)

keyMoveRange

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

keyMoveSelection

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

keyMoveTo

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

keySort

public final void keySort(Comparator<? super K> comparator)

keyIsSorted

public final boolean keyIsSorted(Comparator<? super K> comparator)

keySet

@SafeVarargs
public final void keySet(int offset,
                                      K... elements)

keySet

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

keyFill

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

keyReplaceOne

public final int keyReplaceOne(K element,
                               K replacement)

keyReplace

public final int keyReplace(K element,
                            K replacement)

keyReplaceAll

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

keyReplaceAll

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

keySubstituteOne

public final int keySubstituteOne(Predicate<? super K> predicate,
                                  K substitute)

keySubstitute

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

keySubstitute

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

keySubstitute

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

keyCopyToArray

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

keyAppendTo

public final VarString keyAppendTo(VarString vc)

keyAppendTo

public final VarString keyAppendTo(VarString vc,
                                   char separator)

keyAppendTo

public final VarString keyAppendTo(VarString vc,
                                   String separator)

keyAppendTo

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

keyAppendTo

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

keyAppendTo

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

valuesIterator

public final Iterator<V> valuesIterator()

valuesListIterator

public final ListIterator<V> valuesListIterator(long index)

valuesEqualsContent

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

hasVolatileValues

public final boolean hasVolatileValues()

getValueReferenceType

public final ReferenceType getValueReferenceType()

valuesContainsNull

public final boolean valuesContainsNull()

valuesContainsId

public final boolean valuesContainsId(V element)

valuesContains

public final boolean valuesContains(V element)

valuesContains

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

valuesContainsAll

public final boolean valuesContainsAll(V[] elements,
                                       int elementsOffset,
                                       int elementsLength)

valuesContainsAll

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

valuesContainsAll

public final boolean valuesContainsAll(XGettingCollection<? extends V> elements)

valuesContainsAll

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

valuesApplies

public final boolean valuesApplies(Predicate<? super V> predicate)

valuesAppliesAll

public final boolean valuesAppliesAll(Predicate<? super V> predicate)

valuesCount

public final int valuesCount(V element)

valuesCount

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

valuesCount

public final int valuesCount(Predicate<? super V> predicate)

valuesIntersect

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

valuesExcept

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

valuesUnion

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

valuesCopyTo

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

valuesCopySelection

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

valuesCopyToArray

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

valuesCopyTo

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

valuesToArray

public final Object[] valuesToArray()

valuesToArray

public final V[] valuesToArray(Class<V> type)

valuesFirst

public final V valuesFirst()

valuesLast

public final V valuesLast()

valuesGet

public final V valuesGet(long index)

valuesSeek

public final V valuesSeek(V element)

valuesSearch

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

valuesSearch

public final V valuesSearch(Predicate<? super V> predicate)

valuesMin

public final V valuesMin(Comparator<? super V> comparator)

valuesMax

public final V valuesMax(Comparator<? super V> comparator)

valuesIterate

public final void valuesIterate(Consumer<? super V> procedure)

valuesIterateIndexed

public final void valuesIterateIndexed(IndexedAcceptor<? super V> procedure)

valuesJoin

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

valuesIterate

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

valuesIndexOf

public final int valuesIndexOf(V element)

valuesIndexOf

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

valuesIndexBy

public final int valuesIndexBy(Predicate<? super V> predicate)

valuesLastIndexOf

public final int valuesLastIndexOf(V element)

valuesLastIndexOf

public final int valuesLastIndexOf(V sample,
                                   Equalator<? super V> equalator)

valuesLastIndexBy

public final int valuesLastIndexBy(Predicate<? super V> predicate)

valuesMinIndex

public final int valuesMinIndex(Comparator<? super V> comparator)

valuesMaxIndex

public final int valuesMaxIndex(Comparator<? super V> comparator)

valuesScan

public final int valuesScan(Predicate<? super V> predicate)

valuesHasDistinctValues

public final boolean valuesHasDistinctValues()

valuesHasDistinctValues

public final boolean valuesHasDistinctValues(Equalator<? super V> equalator)

valuesDistinct

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

valuesDistinct

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

valuesAppendTo

public final VarString valuesAppendTo(VarString vc)

valuesAppendTo

public final VarString valuesAppendTo(VarString vc,
                                      char separator)

valuesAppendTo

public final VarString valuesAppendTo(VarString vc,
                                      String separator)

valuesAppendTo

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

valuesAppendTo

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

valuesAppendTo

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

valuesToString

public final String valuesToString()

valuesRemove

public final V valuesRemove(long index)

valuesRemoveNull

public final int valuesRemoveNull()

valuesRetrieve

public final V valuesRetrieve(V element)

valuesRetrieve

public final V valuesRetrieve(Predicate<? super V> predicate)

valuesRemove

public final int valuesRemove(V element)

valuesRemove

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

valuesRemoveAll

public final int valuesRemoveAll(V[] elements,
                                 int elementsOffset,
                                 int elementsLength)

valuesRemoveAll

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

valuesRemoveAll

public final int valuesRemoveAll(XGettingCollection<? extends V> elements)

valuesRemoveAll

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

valuesRemoveDuplicates

public final int valuesRemoveDuplicates()

valuesRemoveDuplicates

public final int valuesRemoveDuplicates(Equalator<? super V> equalator)

valuesReduce

public final int valuesReduce(Predicate<? super V> predicate)

valuesRetainAll

public final int valuesRetainAll(V[] elements,
                                 int elementsOffset,
                                 int elementsLength)

valuesRetainAll

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

valuesRetainAll

public final int valuesRetainAll(XGettingCollection<? extends V> elements)

valuesRetainAll

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

valuesProcess

public final int valuesProcess(Consumer<? super V> procedure)

valuesMoveRange

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

valuesMoveSelection

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

valuesMoveTo

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

valuesSort

public final void valuesSort(Comparator<? super V> comparator)

valuesIsSorted

public final boolean valuesIsSorted(Comparator<? super V> comparator)

valuesSet

public final V valuesSet(long offset,
                         V value)

valuesSet

public final void valuesSet(long offset,
                            V[] elements)

valuesSet

public final void valuesSet(long offset,
                            V[] elements,
                            int elementsOffset,
                            int elementsLength)

valuesFill

public final void valuesFill(long offset,
                             long length,
                             V element)

valuesReplaceOne

public final boolean valuesReplaceOne(V element,
                                      V replacement)

valuesReplaceOne

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

valuesReplace

public final int valuesReplace(V element,
                               V replacement)

valuesReplace

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

valuesReplaceAll

public final int valuesReplaceAll(V[] elements,
                                  int elementsOffset,
                                  int elementsLength,
                                  V replacement)

valuesReplaceAll

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

valuesReplaceAll

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

valuesReplaceAll

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

valuesSubstituteOne

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

valuesSubstitute

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

valuesSubstitute

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

valuesSubstitute

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

valuesRemoveOne

public final boolean valuesRemoveOne(V element)

valuesRemoveOne

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