one.microstream.collections.interfaces

Interface ChainStorage<E,K,V,EN extends ChainStorage.Entry<E,K,V,EN>>

All Superinterfaces:

Composition, Iterable<E>

All Known Subinterfaces:

ChainKeyValueStorage<K,V,EN>

All Known Implementing Classes:

AbstractChainKeyValueStorage, AbstractChainStorage, ChainStorageStrong, ChainStrongStrongStorage

public interface ChainStorage<E,K,V,EN extends ChainStorage.Entry<E,K,V,EN>>
extends Iterable<E>, Composition

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static interface	ChainStorage.Entry<E,K,V,EN extends ChainStorage.Entry<E,K,V,EN>>

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)
<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()
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)
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)
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)
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)
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 interface java.lang.Iterable

forEach, spliterator

Method Detail

appendEntry

void appendEntry(EN entry)

prependEntry

void prependEntry(EN entry)

clear

void clear()

getChainEntry

EN getChainEntry(long index)
          throws IndexOutOfBoundsException

Throws:

IndexOutOfBoundsException

getRangeChainEntry

EN getRangeChainEntry(long offset,
                      long length)
               throws IndexOutOfBoundsException

Throws:

IndexOutOfBoundsException

getIntervalLowChainEntry

EN getIntervalLowChainEntry(long lowIndex,
                            long highIndex)
                     throws IndexOutOfBoundsException

Throws:

IndexOutOfBoundsException

size

long size()

consolidate

long consolidate()

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

Returns:

the number of removed entries.

hasVolatileElements

boolean hasVolatileElements()

getReferenceType

ReferenceType getReferenceType()

iterator

Iterator<E> iterator()

Specified by:

iterator in interface Iterable<E>

equalsContent

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

containsNull

boolean containsNull()

containsId

boolean containsId(E element)

contains

boolean contains(E element)

contains

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

containsAll

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

containsAll

boolean containsAll(XGettingCollection<? extends E> elements)

containsSearched

boolean containsSearched(Predicate<? super E> predicate)

appliesAll

boolean appliesAll(Predicate<? super E> predicate)

count

long count(E element)

count

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

count

long count(Predicate<? super E> predicate)

intersect

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

except

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

union

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

copyTo

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

copySelection

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

copyToArray

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

copyTo

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

toArray

Object[] toArray()

toArray

E[] toArray(Class<E> type)

first

E first()

last

E last()

get

E get(long index)

seek

E seek(E sample)

seek

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

search

E search(Predicate<? super E> predicate)

min

E min(Comparator<? super E> comparator)

max

E max(Comparator<? super E> comparator)

iterate

void iterate(Consumer<? super E> procedure)

join

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

iterateIndexed

void iterateIndexed(IndexedAcceptor<? super E> procedure)

iterate

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

indexOf

long indexOf(E element)

indexOf

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

indexOf

long indexOf(Predicate<? super E> predicate)

lastIndexOf

long lastIndexOf(E element)

lastIndexOf

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

lastIndexBy

long lastIndexBy(Predicate<? super E> predicate)

minIndex

long minIndex(Comparator<? super E> comparator)

maxIndex

long maxIndex(Comparator<? super E> comparator)

scan

long scan(Predicate<? super E> predicate)

hasDistinctValues

boolean hasDistinctValues()

hasDistinctValues

boolean hasDistinctValues(Equalator<? super E> equalator)

distinct

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

distinct

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

appendTo

VarString appendTo(VarString vc)

appendTo

VarString appendTo(VarString vc,
                   char separator)

appendTo

VarString appendTo(VarString vc,
                   String separator)

appendTo

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

appendTo

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

appendTo

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

toString

String toString()

Overrides:

toString in class Object

remove

E remove(long index)

removeRange

void removeRange(long offset,
                 long length)

retainRange

void retainRange(long offset,
                 long length)

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.

Parameters:

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

Returns:

the amount of actually removed entries.

removeNull

long removeNull()

retrieve

E retrieve(E element)

retrieve

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

retrieve

E retrieve(Predicate<? super E> predicate)

removeOne

boolean removeOne(E element)

removeOne

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

remove

long remove(E element)

remove

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

removeAll

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

removeAll

long removeAll(XGettingCollection<? extends E> elements)

removeDuplicates

long removeDuplicates()

removeDuplicates

long removeDuplicates(Equalator<? super E> equalator)

reduce

long reduce(Predicate<? super E> predicate)

retainAll

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

retainAll

long retainAll(XGettingCollection<? extends E> elements)

retainAll

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

process

long process(Consumer<? super E> procedure)

moveRange

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

moveSelection

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

moveTo

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

shiftTo

void shiftTo(long sourceIndex,
             long targetIndex)

shiftTo

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

shiftBy

void shiftBy(long sourceIndex,
             long distance)

shiftBy

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

swap

void swap(long indexA,
          long indexB)

swap

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

reverse

void reverse()

sort

void sort(Comparator<? super E> comparator)

isSorted

boolean isSorted(Comparator<? super E> comparator)

shuffle

void shuffle()

set

void set(long offset,
         E[] elements)

set

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

fill

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

replaceOne

long replaceOne(E element,
                E replacement)

replace

long replace(E element,
             E replacement)

replaceAll

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

replaceAll

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

replaceOneBy

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

replaceBy

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

substitute

long substitute(Function<E,E> mapper)

substitute

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