rabosh-index/app.oreshkov.rabosh.index/Bitmap

Bitmap

class Bitmap : ReadableBitmap

A mutable set of document ordinals, held as one block per 65 536 ordinals.

This is what an index build accumulates: as a segment's documents are walked, the ordinals matching a value go into one of these, and encode turns it into the bytes a sidecar carries. Reading one back is BitmapView, which does not build this at all.

val matching = Bitmap()
matching.add(7)
matching.addAll(100..199)
matching.cardinality           // 101
val bytes = matching.encode()

Not thread-safe, and deliberately: one of these belongs to one sidecar build, the same rule the catalog's sketch collector follows. Several may be built at once — a compaction writes more than one segment — but each on its own thread.

Equality is by ordinals, not by representation. A bitmap built by adding values one at a time and one built by a union of two others are equal when they hold the same ordinals, and either is equal to a BitmapView over its own encode. That is the point: the encoding of a set of ordinals is unique, so a comparison of bytes is a comparison of contents, and the tests can assert the strong form.

hashCode walks the ordinals, so it is O(cardinality). Sound rather than fast, which is the right way round for a structure nobody puts in a hash map by design.

Constructors

constructor()

An empty bitmap.

Types

object Companion

Properties

open override val cardinality: Int

How many ordinals are present.

open val isEmpty: Boolean

Functions

fun add(ordinal: Int): Boolean

Adds ordinal. true if it was not already present.

fun addAll(ordinals: IntRange)

Adds every ordinal in ordinals.

open fun and(other: ReadableBitmap): Bitmap

The ordinals present in both.

open fun andCardinality(other: ReadableBitmap): Int

How many ordinals the two share, without building the intersection.

open fun andNot(other: ReadableBitmap): Bitmap

The ordinals present here and not in other.

fun andNotWith(other: ReadableBitmap)

Removes from this bitmap every ordinal present in other.

fun andWith(other: ReadableBitmap)

Replaces this bitmap's ordinals with the intersection of it and other.

fun clear()

Drops every ordinal.

open fun contains(ordinal: Int): Boolean

Whether ordinal is present. Any Int is a fair question; a negative one is simply absent.

fun copy(): Bitmap

An independent copy.

open fun cursor(): BitmapCursor

A walk over every present ordinal, ascending.

open fun encode(): ByteArray

This bitmap in the layout BitmapFormat describes, canonically encoded.

encodedByteSize

open fun encodedByteSize(): Int

The size encode will produce, without producing it.

open operator override fun equals(other: Any?): Boolean

open fun first(): Int

The smallest ordinal present.

open override fun hashCode(): Int

open fun intersects(other: ReadableBitmap): Boolean

Whether the two share an ordinal, without building the intersection.

open fun last(): Int

The largest ordinal present.

open fun or(other: ReadableBitmap): Bitmap

The ordinals present in either.

fun orWith(other: ReadableBitmap)

Replaces this bitmap's ordinals with the union of it and other.

open fun rank(ordinal: Int): Int

How many present ordinals are less than or equal to ordinal.

fun remove(ordinal: Int): Boolean

Removes ordinal. true if it was present.

fun removeAll(ordinals: IntRange)

Removes every ordinal in ordinals.

open fun select(index: Int): Int

The index-th smallest ordinal present, counting from zero.

open override fun toBitmap(): Bitmap

An independent, mutable bitmap holding the same ordinals.

open fun toIntArray(): IntArray

Every present ordinal, ascending. For tests and for small results; a cursor does not allocate.

open override fun toString(): String

open fun xor(other: ReadableBitmap): Bitmap

The ordinals present in exactly one of the two.

fun xorWith(other: ReadableBitmap)

Replaces this bitmap's ordinals with those present in exactly one of it and other.