Package org.kodein.db

Types

Anticipate

common

class Anticipate(block: () -> Unit) : Options.Writes

AnticipateInLock

common

class AnticipateInLock(block: (KeyValueBatch) -> Unit) : Options.Writes

BaseCursor

common

interface BaseCursor : Closeable

Batch

common

interface Batch : DBWrite, Closeable

Body

common

fun fun interface Body

Cursor

common

interface Cursor<M : Any> : BaseCursor

common

interface DB : DBRead, DBWrite, Closeable

DBFactory

common

interface DBFactory<T : Any>

DBListener

common

interface DBListener<M : Any>

DBRead

common

interface DBRead : KeyMaker

DBWrite

common

interface DBWrite : KeyMaker

Entry

common

data class Entry<M : Any>(key: Key<M>, model: M)

ExecBatch

common

class ExecBatch(batch: Batch) : Batch

ExtensionKey

common

interface ExtensionKey<T : Any>

IndexValues

common

class IndexValues(values: Iterable<Any>) : ModelIndexData

Key

common

data class Key<out T : Any>(bytes: ReadMemory)

KeyAndSize

common

data class KeyAndSize<M : Any>(key: Key<M>, size: Int)

KeyMaker

common

interface KeyMaker

Middleware

common

interface Middleware : Options.Open

OpenPolicy

common

object OpenPolicy

Operation

common

sealed class Operation<M : Any>

Options

common

interface Options

React

common

class React(block: (Int) -> Unit) : Options.Writes

ReactInLock

common

class ReactInLock(block: (Int) -> Unit) : Options.Writes

Sized

common

interface Sized<out M>

Snapshot

common

interface Snapshot : DBRead, Closeable

TypeTable

common

interface TypeTable : Options.Open

UserOptions

common

interface UserOptions : Options

Value

common

interface Value : Body

ValueConverter

common

fun fun interface ValueConverter : Options.Open

ValueMaker

common

interface ValueMaker

Functions

all

common

inline fun <T : Options> Array<out Options>.all(): List<T>

asEntrySequence

common

fun <M : Any> Cursor<M>.asEntrySequence(reverse: Boolean = false, seekToStart: Boolean = true, vararg options: Options.Get): Sequence<Entry<M>>

asKeySequence

common

fun <M : Any> Cursor<M>.asKeySequence(reverse: Boolean = false, seekToStart: Boolean = true): Sequence<Key<M>>

asModelSequence

common

fun <M : Any> Cursor<M>.asModelSequence(reverse: Boolean = false, seekToStart: Boolean = true, vararg options: Options.Get): Sequence<M>

delete

common

inline fun <M : Any> DBWrite.delete(key: Key<M>)

inline fun <M : Any> Batch.delete(key: Key<M>, vararg options: Options.BatchDelete)

inline fun <M : Any> DB.delete(key: Key<M>, vararg options: Options.DirectDelete)

inline fun <M : Any> DBWrite.delete(key: Key<M>, vararg options: Options.Deletes)

deleteAll

common

inline fun <M : Any> DBWrite.deleteAll(cursor: Cursor<M>)

inline fun <M : Any> Batch.deleteAll(cursor: Cursor<M>, vararg options: Options.BatchDelete)

inline fun <M : Any> DB.deleteAll(cursor: Cursor<M>, vararg options: Options.DirectDelete)

inline fun <M : Any> DBWrite.deleteAll(cursor: Cursor<M>, vararg options: Options.Deletes)

deleteById

common

inline fun <M : Any> DBWrite.deleteById(vararg id: Any)

inline fun <M : Any> Batch.deleteById(vararg id: Any, options: Array<out Options.BatchDelete> = emptyArray())

inline fun <M : Any> DB.deleteById(vararg id: Any, options: Array<out Options.DirectDelete> = emptyArray())

inline fun <M : Any> DBWrite.deleteById(vararg id: Any, options: Array<out Options.Deletes> = emptyArray())

deleteFrom

common

inline fun <M : Any> DBWrite.deleteFrom(model: M)

inline fun <M : Any> DBWrite.deleteFrom(model: M, vararg options: Options.Deletes)

execBatch

common

inline fun DB.execBatch(vararg options: Options.BatchWrite, block: ExecBatch.() -> Unit)

find

common

inline fun <M : Any> DBRead.find(vararg options: Options.Find): DBRead.FindDsl<M>

flowOf

common

inline fun <M : Any> DB.flowOf(key: Key<M>, init: Boolean = true): Flow<M?>

get

common

inline operator fun <M : Any> DBRead.get(key: Key<M>, vararg options: Options.Get): M?

getById

common

inline fun <M : Any> DBRead.getById(vararg id: Any, options: Array<out Options.Get> = emptyArray()): M?

inDir

common

fun <T : Any> DBFactory<T>.inDir(path: String): DBFactory.Based<T>

invoke

common

inline operator fun <T : Options> Array<out Options>.invoke(): T?

keyById

common

inline fun <M : Any> KeyMaker.keyById(vararg id: Any): Key<M>

keyFromB64

common

inline fun <M : Any> KeyMaker.keyFromB64(b64: String): Key<M>

common

inline fun <M : Any> DB.on(): DB.RegisterDsl<M>

plus

common

inline operator fun <T : Options> Array<out T>.plus(add: T): Array<T>

prefixed

common

fun <T : Any> DBFactory<T>.prefixed(prefix: String): DBFactory.Based<T>

simpleTypeNameOf

common

fun simpleTypeNameOf(type: KClass<*>): String

stateFlowFrom

common

inline suspend fun <M : Any> DB.stateFlowFrom(scope: CoroutineScope, model: M): StateFlow<M?>

stateFlowOf

common

inline suspend fun <M : Any> DB.stateFlowOf(scope: CoroutineScope, key: Key<M>): StateFlow<M?>

suspend fun <M : Any> DB.stateFlowOf(scope: CoroutineScope, type: KClass<M>, key: Key<M>): StateFlow<M?>

stateFlowOfId

common

inline suspend fun <M : Any> DB.stateFlowOfId(scope: CoroutineScope, vararg id: Any): StateFlow<M?>

toArrayMemory

common

fun Value.toArrayMemory(): ByteArrayMemory

useEntries

common

fun <M : Any, R> Cursor<M>.useEntries(reverse: Boolean = false, seekToStart: Boolean = true, vararg options: Options.Get, block: (Sequence<Entry<M>>) -> R): R

useKeys

common

fun <M : Any, R> Cursor<M>.useKeys(reverse: Boolean = false, seekToStart: Boolean = true, block: (Sequence<Key<M>>) -> R): R

useModels

common

inline fun <M : Any, R> Cursor<M>.useModels(reverse: Boolean = false, seekToStart: Boolean = true, vararg options: Options.Get, block: (Sequence<M>) -> R): R

withFullName

jvm

fun TypeTable.Companion.withFullName(builder: TypeTable.Builder.() -> Unit = {}): TypeTable

writeBody

common

inline fun Writeable.writeBody(value: Body)

Properties

ExtensionPrefixByte

common

const val ExtensionPrefixByte: Byte