one.microstream.collections

Class ChainStorageStrong<E,K,V,EN extends AbstractChainEntry<E,K,V,EN>>

java.lang.Object

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

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

All Implemented Interfaces:

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

Direct Known Subclasses:

AbstractChainKeyValueStorage

public class ChainStorageStrong<E,K,V,EN extends AbstractChainEntry<E,K,V,EN>>
extends AbstractChainStorage<E,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
ChainStorageStrong(AbstractChainCollection<E,K,V,EN> parent, EN head)

Method Summary

Modifier and Type	Method and Description
void	appendEntry(EN entry)
VarString	appendTo(VarString vc)
VarString	appendTo(VarString vc, BiConsumer<VarString,? super E> appender)
VarString	appendTo(VarString vc, BiConsumer<VarString,? super E> appender, char separator)
VarString	appendTo(VarString vc, BiConsumer<VarString,? super E> appender, String separator)
VarString	appendTo(VarString vc, char separator)
VarString	appendTo(VarString vc, String separator)
boolean	appliesAll(Predicate<? super E> predicate)
void	clear()
long	consolidate() Removes all empty entries from the passed chain and returns the number of removed entries.
boolean	contains(E element)
boolean	contains(E sample, Equalator<? super E> equalator)
boolean	containsAll(E[] elements, int elementsOffset, int elementsLength)
boolean	containsAll(XGettingCollection<? extends E> elements)
boolean	containsId(E element)
boolean	containsNull()
boolean	containsSearched(Predicate<? super E> predicate)
<C extends Consumer<? super E>> C	copySelection(C target, long[] indices)
<C extends Consumer<? super E>> C	copyTo(C target)
<C extends Consumer<? super E>> C	copyTo(C target, Predicate<? super E> predicate)
int	copyToArray(long offset, int length, Object[] target, int targetOffset)
long	count(E element)
long	count(E sample, Equalator<? super E> equalator)
long	count(Predicate<? super E> predicate)
protected void	disjoinEntry(EN entry)
<C extends Consumer<? super E>> C	distinct(C target)
<C extends Consumer<? super E>> C	distinct(C target, Equalator<? super E> equalator)
boolean	equalsContent(XGettingCollection<? extends E> other, Equalator<? super E> equalator)
<C extends Consumer<? super E>> C	except(XGettingCollection<? extends E> samples, Equalator<? super E> equalator, C target)
void	fill(long offset, long length, E element)
E	first()
E	get(long index)
EN	getChainEntry(long index)
EN	getIntervalLowChainEntry(long lowIndex, long highIndex)
EN	getRangeChainEntry(long offset, long length)
ReferenceType	getReferenceType()
boolean	hasDistinctValues()
boolean	hasDistinctValues(Equalator<? super E> equalator)
boolean	hasVolatileElements()
protected EN	head()
long	indexOf(E element)
long	indexOf(E sample, Equalator<? super E> equalator)
long	indexOf(Predicate<? super E> predicate)
<C extends Consumer<? super E>> C	intersect(XGettingCollection<? extends E> samples, Equalator<? super E> equalator, C target)
boolean	isSorted(Comparator<? super E> comparator)
void	iterate(Consumer<? super E> procedure)
void	iterate(Predicate<? super E> predicate, Consumer<? super E> procedure)
void	iterateIndexed(IndexedAcceptor<? super E> procedure)
Iterator<E>	iterator()
<A> void	join(BiConsumer<? super E,A> joiner, A aggregate)
E	last()
long	lastIndexBy(Predicate<? super E> predicate)
long	lastIndexOf(E element)
long	lastIndexOf(E sample, Equalator<? super E> equalator)
E	max(Comparator<? super E> comparator)
long	maxIndex(Comparator<? super E> comparator)
E	min(Comparator<? super E> comparator)
long	minIndex(Comparator<? super E> comparator)
long	moveRange(long offset, long length, Consumer<? super E> target)
long	moveSelection(Consumer<? super E> target, long... indices)
long	moveTo(Consumer<? super E> target, Predicate<? super E> predicate)
protected boolean	moveToEnd(EN entry)
protected boolean	moveToStart(EN entry)
void	prependEntry(EN entry)
long	process(Consumer<? super E> procedure)
long	reduce(Predicate<? super E> predicate)
long	remove(E element)
long	remove(E sample, Equalator<? super E> equalator)
E	remove(long index)
long	removeAll(E[] elements, int elementsOffset, int elementsLength)
long	removeAll(XGettingCollection<? extends E> elements)
long	removeDuplicates()
long	removeDuplicates(Equalator<? super E> equalator)
long	removeNull()
boolean	removeOne(E element)
boolean	removeOne(E sample, Equalator<? super E> equalator)
void	removeRange(long offset, long length)
long	removeSelection(long... indices) Removes all entries at the indices (offsets) given in the passed int array.
long	replace(E element, E replacement)
protected void	replace(EN doomedEntry, EN keptEntry)
long	replaceAll(E[] elements, int elementsOffset, int elementsLength, E replacement)
long	replaceAll(XGettingCollection<? extends E> elements, E replacement)
long	replaceBy(Predicate<? super E> predicate, E substitute)
long	replaceOne(E element, E replacement)
long	replaceOneBy(Predicate<? super E> predicate, E substitute)
long	retainAll(E[] elements, int elementsOffset, int elementsLength)
int	retainAll(E[] samples, int samplesOffset, int samplesLength, Equalator<? super E> equalator)
long	retainAll(XGettingCollection<? extends E> elements)
long	retainAll(XGettingCollection<? extends E> samples, Equalator<? super E> equalator)
void	retainRange(long offset, long length)
E	retrieve(E element)
E	retrieve(E sample, Equalator<? super E> equalator)
E	retrieve(Predicate<? super E> predicate)
void	reverse()
long	scan(Predicate<? super E> predicate)
E	search(Predicate<? super E> predicate)
E	seek(E sample)
E	seek(E sample, Equalator<? super E> equalator)
void	set(long offset, E[] elements)
void	set(long offset, E[] elements, int elementsOffset, int elementsLength)
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	sort(Comparator<? super E> comparator)
protected long	substitute(Function<? super E,? extends E> mapper, BiConsumer<EN,E> callback)
long	substitute(Function<E,E> mapper)
long	substitute(Predicate<? super E> predicate, Function<E,E> mapper)
void	swap(long indexA, long indexB)
void	swap(long indexA, long indexB, long length)
Object[]	toArray()
E[]	toArray(Class<E> type)
String	toString()
<C extends Consumer<? super E>> C	union(XGettingCollection<? extends E> samples, Equalator<? super E> equalator, C target)

Methods inherited from class java.lang.Object

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

Methods inherited from interface java.lang.Iterable

forEach, spliterator

Constructor Detail

ChainStorageStrong

public ChainStorageStrong(AbstractChainCollection<E,K,V,EN> parent,
                          EN head)

Method Detail

head

protected final EN head()

Specified by:

head in class AbstractChainStorage<E,K,V,EN extends AbstractChainEntry<E,K,V,EN>>

disjoinEntry

protected void disjoinEntry(EN entry)

Specified by:

disjoinEntry in class AbstractChainStorage<E,K,V,EN extends AbstractChainEntry<E,K,V,EN>>

replace

protected void replace(EN doomedEntry,
                       EN keptEntry)

Specified by:

replace in class AbstractChainStorage<E,K,V,EN extends AbstractChainEntry<E,K,V,EN>>

substitute

protected long substitute(Function<? super E,? extends E> mapper,
                          BiConsumer<EN,E> callback)

Specified by:

substitute in class AbstractChainStorage<E,K,V,EN extends AbstractChainEntry<E,K,V,EN>>

moveToStart

protected final boolean moveToStart(EN entry)

Specified by:

moveToStart in class AbstractChainStorage<E,K,V,EN extends AbstractChainEntry<E,K,V,EN>>

moveToEnd

protected final boolean moveToEnd(EN entry)

Specified by:

moveToEnd in class AbstractChainStorage<E,K,V,EN extends AbstractChainEntry<E,K,V,EN>>

appendEntry

public final void appendEntry(EN entry)

prependEntry

public final void prependEntry(EN entry)

clear

public void clear()

shiftBy

public final void shiftBy(long sourceIndex,
                          long distance)

shiftBy

public final void shiftBy(long sourceIndex,
                          long distance,
                          long length)

shiftTo

public final void shiftTo(long sourceIndex,
                          long targetIndex)

shiftTo

public final void shiftTo(long sourceIndex,
                          long targetIndex,
                          long length)

removeRange

public final void removeRange(long offset,
                              long length)

retainRange

public final void retainRange(long offset,
                              long length)

removeSelection

public final 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. Pass a clone if the original int array shall be unchanged.

Parameters:

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

Returns:

the amount of actually removed entries.

iterator

public final Iterator<E> iterator()

equalsContent

public final boolean equalsContent(XGettingCollection<? extends E> other,
                                   Equalator<? super E> equalator)

getChainEntry

public EN getChainEntry(long index)
                 throws IndexOutOfBoundsException

Throws:

IndexOutOfBoundsException

getRangeChainEntry

public EN getRangeChainEntry(long offset,
                             long length)
                      throws IndexOutOfBoundsException

Throws:

IndexOutOfBoundsException

getIntervalLowChainEntry

public EN getIntervalLowChainEntry(long lowIndex,
                                   long highIndex)
                            throws IndexOutOfBoundsException

Throws:

IndexOutOfBoundsException

size

public final long size()

consolidate

public final long consolidate()

Description copied from interface: ChainStorage

Removes all empty entries from the passed chain and returns the number of removed entries.

Returns:

the number of removed entries.

hasVolatileElements

public final boolean hasVolatileElements()

getReferenceType

public final ReferenceType getReferenceType()

containsNull

public final boolean containsNull()

containsId

public final boolean containsId(E element)

contains

public final boolean contains(E element)

contains

public final boolean contains(E sample,
                              Equalator<? super E> equalator)

containsAll

public final boolean containsAll(E[] elements,
                                 int elementsOffset,
                                 int elementsLength)

containsAll

public final boolean containsAll(XGettingCollection<? extends E> elements)

containsSearched

public final boolean containsSearched(Predicate<? super E> predicate)

appliesAll

public final boolean appliesAll(Predicate<? super E> predicate)

count

public final long count(E element)

count

public final long count(E sample,
                        Equalator<? super E> equalator)

count

public final long count(Predicate<? super E> predicate)

intersect

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

except

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

union

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

copyTo

public final <C extends Consumer<? super E>> C copyTo(C target)

copySelection

public final <C extends Consumer<? super E>> C copySelection(C target,
                                                             long[] indices)

copyToArray

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

copyTo

public final <C extends Consumer<? super E>> C copyTo(C target,
                                                      Predicate<? super E> predicate)

toArray

public final Object[] toArray()

toArray

public final E[] toArray(Class<E> type)

first

public final E first()

last

public final E last()

get

public final E get(long index)

seek

public final E seek(E sample,
                    Equalator<? super E> equalator)

seek

public final E seek(E sample)

search

public final E search(Predicate<? super E> predicate)

min

public final E min(Comparator<? super E> comparator)

max

public final E max(Comparator<? super E> comparator)

iterate

public final void iterate(Consumer<? super E> procedure)

join

public final <A> void join(BiConsumer<? super E,A> joiner,
                           A aggregate)

iterateIndexed

public final void iterateIndexed(IndexedAcceptor<? super E> procedure)

iterate

public final void iterate(Predicate<? super E> predicate,
                          Consumer<? super E> procedure)

indexOf

public final long indexOf(E element)

indexOf

public final long indexOf(E sample,
                          Equalator<? super E> equalator)

lastIndexOf

public final long lastIndexOf(E element)

lastIndexOf

public final long lastIndexOf(E sample,
                              Equalator<? super E> equalator)

indexOf

public final long indexOf(Predicate<? super E> predicate)

lastIndexBy

public final long lastIndexBy(Predicate<? super E> predicate)

minIndex

public final long minIndex(Comparator<? super E> comparator)

maxIndex

public final long maxIndex(Comparator<? super E> comparator)

scan

public final long scan(Predicate<? super E> predicate)

hasDistinctValues

public final boolean hasDistinctValues()

hasDistinctValues

public final boolean hasDistinctValues(Equalator<? super E> equalator)

distinct

public final <C extends Consumer<? super E>> C distinct(C target)

distinct

public final <C extends Consumer<? super E>> C distinct(C target,
                                                        Equalator<? super E> equalator)

appendTo

public final VarString appendTo(VarString vc)

appendTo

public final VarString appendTo(VarString vc,
                                char separator)

appendTo

public final VarString appendTo(VarString vc,
                                String separator)

appendTo

public final VarString appendTo(VarString vc,
                                BiConsumer<VarString,? super E> appender)

appendTo

public final VarString appendTo(VarString vc,
                                BiConsumer<VarString,? super E> appender,
                                char separator)

appendTo

public final VarString appendTo(VarString vc,
                                BiConsumer<VarString,? super E> appender,
                                String separator)

toString

public final String toString()

Specified by:

toString in interface ChainStorage<E,K,V,EN extends AbstractChainEntry<E,K,V,EN>>

Overrides:

toString in class Object

remove

public final E remove(long index)

removeNull

public final long removeNull()

retrieve

public final E retrieve(E element)

retrieve

public final E retrieve(E sample,
                        Equalator<? super E> equalator)

retrieve

public final E retrieve(Predicate<? super E> predicate)

removeOne

public final boolean removeOne(E element)

removeOne

public final boolean removeOne(E sample,
                               Equalator<? super E> equalator)

remove

public final long remove(E element)

remove

public final long remove(E sample,
                         Equalator<? super E> equalator)

removeAll

public final long removeAll(E[] elements,
                            int elementsOffset,
                            int elementsLength)

removeAll

public final long removeAll(XGettingCollection<? extends E> elements)

removeDuplicates

public final long removeDuplicates()

removeDuplicates

public final long removeDuplicates(Equalator<? super E> equalator)

reduce

public final long reduce(Predicate<? super E> predicate)

retainAll

public final long retainAll(E[] elements,
                            int elementsOffset,
                            int elementsLength)

retainAll

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

retainAll

public final long retainAll(XGettingCollection<? extends E> elements)

retainAll

public final long retainAll(XGettingCollection<? extends E> samples,
                            Equalator<? super E> equalator)

process

public final long process(Consumer<? super E> procedure)

moveRange

public final long moveRange(long offset,
                            long length,
                            Consumer<? super E> target)

moveSelection

public final long moveSelection(Consumer<? super E> target,
                                long... indices)

moveTo

public final long moveTo(Consumer<? super E> target,
                         Predicate<? super E> predicate)

sort

public final void sort(Comparator<? super E> comparator)

isSorted

public final boolean isSorted(Comparator<? super E> comparator)

shuffle

public final void shuffle()

set

public final void set(long offset,
                      E[] elements)

set

public final void set(long offset,
                      E[] elements,
                      int elementsOffset,
                      int elementsLength)

fill

public final void fill(long offset,
                       long length,
                       E element)

replaceOne

public final long replaceOne(E element,
                             E replacement)

replace

public final long replace(E element,
                          E replacement)

replaceAll

public final long replaceAll(E[] elements,
                             int elementsOffset,
                             int elementsLength,
                             E replacement)

replaceAll

public final long replaceAll(XGettingCollection<? extends E> elements,
                             E replacement)

replaceOneBy

public final long replaceOneBy(Predicate<? super E> predicate,
                               E substitute)

replaceBy

public final long replaceBy(Predicate<? super E> predicate,
                            E substitute)

substitute

public final long substitute(Function<E,E> mapper)

substitute

public final long substitute(Predicate<? super E> predicate,
                             Function<E,E> mapper)

swap

public final void swap(long indexA,
                       long indexB)

swap

public final void swap(long indexA,
                       long indexB,
                       long length)

reverse

public final void reverse()