Index

All Superinterfaces:

Iterable<Long>, com.fishlib.base.log.LogOutputAppendable, LongSizedDataStructure
```
public interface Index
extends com.fishlib.base.log.LogOutputAppendable, Iterable<Long>, LongSizedDataStructure
```
A set of sorted long keys between 0 and Long.MAX_VALUE

Nested Class Summary

Nested Classes
Modifier and Type	Interface and Description
`static interface`	`Index.Evaluator<T extends Comparable<T>>`
`static interface`	`Index.Factory`
`static class`	`Index.IndexUpdateCoalescer`
`static interface`	`Index.Iterator`
`static interface`	`Index.RandomBuilder`
`static interface`	`Index.RangeIterator`
`static interface`	`Index.SequentialBuilder`
`static interface`	`Index.TargetComparator`

Field Summary

Fields
Modifier and Type	Field and Description
`static Index.Iterator`	`EMPTY_ITERATOR`
`static Index.Factory`	`FACTORY`
`static long`	`NULL_KEY`
`static boolean`	`USE_PRIORITY_QUEUE_RANDOM_BUILDER`

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`void`	`clear()`
`Index`	`clone()`
`default boolean`	`empty()` Queries whether this Index is empty (i.e.
`long`	`find(long key)` Returns the position in [0..(size-1)] where the key is found.
`gnu.trove.list.array.TLongArrayList[]`	`findMissing(Index keys)` For the given keys Index, under the assertion that none of them are present in the current index, return the tentative insertion points in the current index with the count for each of them
`long`	`findPrev(long key)` Returns the position in [0..(size-1)] where the key is found in the previous index.
`long`	`firstKey()`
`long`	`get(long pos)`
`Map<Object,Index>`	`getGrouping(TupleSource tupleSource)`
`Map<Object,Index>`	`getGroupingForKeySet(Set<Object> keys, TupleSource tupleSource)` Return a grouping that contains keys that match the values in keySet.
`long`	`getPrev(long pos)`
`Map<Object,Index>`	`getPrevGrouping(TupleSource tupleSource)`
`Index`	`getPrevIndex()`
`Index`	`getSubIndexForKeySet(Set<Object> keySet, TupleSource tupleSource)` Return a subIndex that contains indices that match the values in keySet.
`boolean`	`hasGrouping(ColumnSource... keyColumns)`
`void`	`initializePreviousValue()` Initializes our previous value from the current value.
`void`	`insert(Index added)` Adds the keys from a given index to the current index
`void`	`insert(long key)`
`void`	`insertRange(long startKey, long endKey)`
`Index`	`intersect(Index range)` Returns a new index representing the intersection of the current index with the input index
`Index`	`invert(Index keys)` Returns an Index with the positions of keys in this Index.
`Index`	`invert(Index keys, long maximumPosition)` Returns the positions of keys in the current set as an Index, stopping at maximumPosition.
`boolean`	`isFlat()` Returns whether or not this index is flat.
`boolean`	`isSorted()`
`Index.Iterator`	`iterator()`
`long`	`lastKey()`
`Index`	`minus(Index indexToRemove)` Returns a new index representing the keys of the current set not present inside indexToRemove
`default boolean`	`nonempty()` Queries whether this Index is non-empty (i.e.
`default boolean`	`overlaps(Index index)` Returns true if an index has any overlap.
`Index.RangeIterator`	`rangeIterator()`
`int`	`refCount()`
`void`	`release()`
`void`	`remove(Index removed)` Removes all the keys from removed index that are present in the current set
`void`	`remove(long key)` Removes the given key from the current set if present
`void`	`removeRange(long start, long end)` Removes any key in the given range from the current set.
`Index.Iterator`	`reverseIterator()`
`Index`	`shift(long shiftAmount)`
`long`	`size()` How many keys are in this index.
`Index`	`subindexByKey(long startKey, long endKey)` Get a subset of this index within this range of keys.
`Index`	`subindexByPos(long startPos, long endPos)` Get a subset of this index within this range of positions
`default boolean`	`subsetOf(Index other)` Returns true if this index is a (possibly improper) subset of other.
`void`	`update(Index added, Index removed)` Simultaneously adds the keys from the first index and removes the keys from the second one.
`void`	`validate()`

Methods inherited from interface com.fishlib.base.log.LogOutputAppendable
append

Methods inherited from interface java.lang.Iterable
forEach, spliterator

Methods inherited from interface com.illumon.iris.db.util.LongSizedDataStructure
intSize, intSize, intSize

- Field Detail
  - USE_PRIORITY_QUEUE_RANDOM_BUILDER
```
static final boolean USE_PRIORITY_QUEUE_RANDOM_BUILDER
```
  - NULL_KEY
```
static final long NULL_KEY
```
    See Also:
    
    Constant Field Values
  - EMPTY_ITERATOR
```
static final Index.Iterator EMPTY_ITERATOR
```
  - FACTORY
```
static final Index.Factory FACTORY
```
- Method Detail
  - release
```
void release()
```
  - refCount
```
@VisibleForTesting
int refCount()
```
  - insert
```
void insert(long key)
```
  - insertRange
```
void insertRange(long startKey,
                 long endKey)
```
  - insert
```
void insert(Index added)
```
    Adds the keys from a given index to the current index
  - remove
```
void remove(Index removed)
```
    Removes all the keys from removed index that are present in the current set
  - clone
```
Index clone()
```
  - remove
```
void remove(long key)
```
    Removes the given key from the current set if present
  - removeRange
```
void removeRange(long start,
                 long end)
```
    Removes any key in the given range from the current set. end is inclusive.
  - update
```
void update(Index added,
            Index removed)
```
    Simultaneously adds the keys from the first index and removes the keys from the second one. API assumption: the intersection of added and removed is empty.
  - lastKey
```
long lastKey()
```
  - firstKey
```
long firstKey()
```
  - invert
```
Index invert(Index keys)
```
    Returns an Index with the positions of keys in this Index. This can be thought of as an iterative find() over the values in keys, but all keys must exist within this index, because an Index result can not represent negative values.
    
    Parameters:
    
    keys - the keys to find positions for
    
    Returns:
    
    a new Index containing the positions of the keys in this index
    
    Throws:
    
    IllegalArgumentException - if an element in keys is missing from this Index
  - invert
```
Index invert(Index keys,
             long maximumPosition)
```
    Returns the positions of keys in the current set as an Index, stopping at maximumPosition. This can be thought of as an iterative find() over the values in keys, but all keys must exist within this index, because an Index result can not represent negative values.
    
    Parameters:
    
    keys - the keys to find positions for
    
    maximumPosition - the largest position for which we will find a key
    
    Returns:
    
    a new Index containing the positions of the keys in this index
  - findMissing
```
gnu.trove.list.array.TLongArrayList[] findMissing(Index keys)
```
    For the given keys Index, under the assertion that none of them are present in the current index, return the tentative insertion points in the current index with the count for each of them
    
    Parameters:
    
    keys - the keys to identify insertion locations
    
    Returns:
    
    two TLongArrayLists; [0] contains the positions, [1] contains the counts.
  - intersect
```
@NotNull
Index intersect(@NotNull
                         Index range)
```
    Returns a new index representing the intersection of the current index with the input index
  - overlaps
```
default boolean overlaps(@NotNull
                         Index index)
```
    Returns true if an index has any overlap.
  - subsetOf
```
default boolean subsetOf(@NotNull
                         Index other)
```
    Returns true if this index is a (possibly improper) subset of other.
    
    Returns:
    
    true if every element of this exists within other
  - minus
```
Index minus(Index indexToRemove)
```
    Returns a new index representing the keys of the current set not present inside indexToRemove
  - clear
```
void clear()
```
  - shift
```
Index shift(long shiftAmount)
```
  - getGrouping
```
Map<Object,Index> getGrouping(TupleSource tupleSource)
```
  - getPrevGrouping
```
Map<Object,Index> getPrevGrouping(TupleSource tupleSource)
```
  - getGroupingForKeySet
```
Map<Object,Index> getGroupingForKeySet(Set<Object> keys,
                                       TupleSource tupleSource)
```
    Return a grouping that contains keys that match the values in keySet.
    
    Parameters:
    
    keys - a set of values that keyColumns should match. For a single keyColumns, the values within the set are the values that we would like to find. For multiple keyColumns, the values are SmartKeys.
    
    tupleSource - the tuple factory for the keyColumns
    
    Returns:
    
    an Map from keys to Indices, for each of the keys in keySet and this Index.
  - getSubIndexForKeySet
```
Index getSubIndexForKeySet(Set<Object> keySet,
                           TupleSource tupleSource)
```
    Return a subIndex that contains indices that match the values in keySet.
    
    Parameters:
    
    keySet - a set of values that keyColumns should match. For a single keyColumns, the values within the set are the values that we would like to find. For multiple keyColumns, the values are SmartKeys.
    
    tupleSource - the tuple factory for the keyColumn
    
    Returns:
    
    an Index containing only keys that match keySet.
  - hasGrouping
```
boolean hasGrouping(ColumnSource... keyColumns)
```
  - validate
```
void validate()
```
  - subindexByPos
```
Index subindexByPos(long startPos,
                    long endPos)
```
    Get a subset of this index within this range of positions
    
    Parameters:
    
    startPos - The first position to included in the output (inclusive)
    
    endPos - The last position to included in the output (exclusive)
    
    Returns:
    
    A new index, containing only positions >= startPos and < endPos
  - subindexByKey
```
Index subindexByKey(long startKey,
                    long endKey)
```
    Get a subset of this index within this range of keys.
    
    Parameters:
    
    startKey - The first key to include in the output.
    
    endKey - The last key (inclusive) to include in the output.
    
    Returns:
    
    A new index, containing only values >= startKey and <= endKey.
  - get
```
long get(long pos)
```
  - getPrev
```
long getPrev(long pos)
```
  - getPrevIndex
```
Index getPrevIndex()
```
  - initializePreviousValue
```
void initializePreviousValue()
```
    Initializes our previous value from the current value. This call is used by operations that manipulate an Index while constructing it, but need to set the state at the end of the initial operation to the current state. Calling this in other circumstances will yield undefined results.
  - find
```
long find(long key)
```
    Returns the position in [0..(size-1)] where the key is found. If not found, then return -("position it would be" - 1), a la Array.binarySearch.
    
    Parameters:
    
    key - the key to search for
    
    Returns:
    
    a position from [0..(size-1)] if the key was found. If the key was not found, then -(position - 1) as in Array.binarySearch.
  - findPrev
```
long findPrev(long key)
```
    Returns the position in [0..(size-1)] where the key is found in the previous index. If not found, then return -("position it would be" - 1), as in Array.binarySearch.
    
    Parameters:
    
    key - the key to search for
    
    Returns:
    
    a position from [0..(size-1)] if the key was found. If the key was not found, then -(position - 1) as in Array.binarySearch.
  - isSorted
```
boolean isSorted()
```
  - iterator
```
Index.Iterator iterator()
```
    Specified by:
    
    iterator in interface Iterable<Long>
  - reverseIterator
```
Index.Iterator reverseIterator()
```
  - rangeIterator
```
Index.RangeIterator rangeIterator()
```
  - size
```
long size()
```
    How many keys are in this index.
    
    Specified by:
    
    size in interface LongSizedDataStructure
    
    Returns:
    
    the number of keys in this index.
  - isFlat
```
boolean isFlat()
```
    Returns whether or not this index is flat. Unlike a table, this is a mutable property; which may change from step to step.
    
    Returns:
    
    true if the index keys are continguous and start at zero.
  - empty
```
default boolean empty()
```
    Queries whether this Index is empty (i.e. has no keys).
    
    Returns:
    
    true if the size() of this Index is zero, false if the size is greater than zero
  - nonempty
```
default boolean nonempty()
```
    Queries whether this Index is non-empty (i.e. has at least one key).
    
    Returns:
    
    true if the size() of this Index greater than zero, false if the size is zero

Interface Index

Nested Class Summary

Field Summary

Method Summary

Methods inherited from interface com.fishlib.base.log.LogOutputAppendable

Methods inherited from interface java.lang.Iterable

Methods inherited from interface com.illumon.iris.db.util.LongSizedDataStructure

Field Detail

USE_PRIORITY_QUEUE_RANDOM_BUILDER

NULL_KEY

EMPTY_ITERATOR

FACTORY

Method Detail

release

refCount

insert

insertRange

insert

remove

clone

remove

removeRange

update

lastKey

firstKey

invert

invert

findMissing

intersect

overlaps

subsetOf

minus

clear

shift

getGrouping

getPrevGrouping

getGroupingForKeySet

getSubIndexForKeySet

hasGrouping

validate

subindexByPos

subindexByKey

get

getPrev

getPrevIndex

initializePreviousValue

find

findPrev

isSorted

iterator

reverseIterator

rangeIterator

size

isFlat

empty

nonempty