micro_utils.dokka/dev.inmo.micro_utils.repos

Package-level declarations

Types

interface CRUDRepo<ObjectType, IdType, InputValueType> : ReadCRUDRepo<ObjectType, IdType> , WriteCRUDRepo<ObjectType, IdType, InputValueType>

CursorIterator

class CursorIterator(c: Cursor) : Iterator<Cursor>

DelegateBasedCRUDRepo

class DelegateBasedCRUDRepo<ObjectType, IdType, InputValueType>(readDelegate: ReadCRUDRepo<ObjectType, IdType>, writeDelegate: WriteCRUDRepo<ObjectType, IdType, InputValueType>) : CRUDRepo<ObjectType, IdType, InputValueType> , ReadCRUDRepo<ObjectType, IdType> , WriteCRUDRepo<ObjectType, IdType, InputValueType>

DelegateBasedKeyValueRepo

class DelegateBasedKeyValueRepo<Key, Value>(readDelegate: ReadKeyValueRepo<Key, Value>, writeDelegate: WriteKeyValueRepo<Key, Value>) : KeyValueRepo<Key, Value> , ReadKeyValueRepo<Key, Value> , WriteKeyValueRepo<Key, Value>

DelegateBasedKeyValuesRepo

class DelegateBasedKeyValuesRepo<Key, Value>(readDelegate: ReadKeyValuesRepo<Key, Value>, writeDelegate: WriteKeyValuesRepo<Key, Value>) : KeyValuesRepo<Key, Value> , ReadKeyValuesRepo<Key, Value> , WriteKeyValuesRepo<Key, Value>

FileKeyValueRepo

class FileKeyValueRepo(folder: File, filesChangedProcessingScope: CoroutineScope? = null) : KeyValueRepo<String, File> , WriteKeyValueRepo<String, File> , ReadKeyValueRepo<String, File>

FileReadKeyValueRepo

class FileReadKeyValueRepo(folder: File) : ReadKeyValueRepo<String, File>

FileWriteKeyValueRepo

class FileWriteKeyValueRepo(folder: File, filesChangedProcessingScope: CoroutineScope? = null) : WriteKeyValueRepo<String, File>

Files watching will not correctly works on Android with version of API lower than API 26

KeyValueRepo

interface KeyValueRepo<Key, Value> : ReadKeyValueRepo<Key, Value> , WriteKeyValueRepo<Key, Value>

Full version of standard key-value repository with all set/unset/clear/get methods

KeyValuesRepo

interface KeyValuesRepo<Key, Value> : ReadKeyValuesRepo<Key, Value> , WriteKeyValuesRepo<Key, Value>

MapCRUDRepo

abstract class MapCRUDRepo<ObjectType, IdType, InputValueType>(map: MutableMap<IdType, ObjectType>, locker: SmartRWLocker = SmartRWLocker()) : WriteMapCRUDRepo<ObjectType, IdType, InputValueType> , CRUDRepo<ObjectType, IdType, InputValueType> , ReadCRUDRepo<ObjectType, IdType>

MutableMap-based MapCRUDRepo. All internal operations will be locked with locker

MapKeyValueRepo

class MapKeyValueRepo<Key, Value>(map: MutableMap<Key, Value>, locker: SmartRWLocker) : KeyValueRepo<Key, Value> , ReadKeyValueRepo<Key, Value> , WriteKeyValueRepo<Key, Value>

MutableMap-based KeyValueRepo. All internal operations will be locked with locker

MapKeyValuesRepo

class MapKeyValuesRepo<Key, Value>(map: MutableMap<Key, MutableList<Value>> = mutableMapOf(), locker: SmartRWLocker = SmartRWLocker()) : KeyValuesRepo<Key, Value> , ReadKeyValuesRepo<Key, Value> , WriteKeyValuesRepo<Key, Value>

MutableMap-based KeyValuesRepo. All internal operations will be locked with locker

MapperRepo

interface MapperRepo<FromKey, FromValue, ToKey, ToValue>

MapReadKeyValuesRepo

class MapReadKeyValuesRepo<Key, Value>(map: Map<Key, List<Value>> = emptyMap(), locker: SmartRWLocker = SmartRWLocker()) : ReadKeyValuesRepo<Key, Value>

Map-based ReadKeyValuesRepo. All internal operations will be locked with locker (mostly with SmartRWLocker.withReadAcquire)

MapWriteKeyValuesRepo

class MapWriteKeyValuesRepo<Key, Value>(map: MutableMap<Key, MutableList<Value>> = mutableMapOf(), locker: SmartRWLocker = SmartRWLocker()) : WriteKeyValuesRepo<Key, Value>

MutableMap-based WriteKeyValuesRepo. All internal operations will be locked with locker (mostly with SmartRWLocker.withWriteLock)

OneToManyKeyValueRepo

typealias OneToManyKeyValueRepo<Key, Value> = KeyValuesRepo<Key, Value>

ReadCRUDRepo

interface ReadCRUDRepo<ObjectType, IdType> : Repo

ReadKeyValueRepo

interface ReadKeyValueRepo<Key, Value> : Repo

Read part of KeyValueRepo

ReadKeyValuesRepo

interface ReadKeyValuesRepo<Key, Value> : Repo

ReadMapCRUDRepo

class ReadMapCRUDRepo<ObjectType, IdType>(map: Map<IdType, ObjectType> = emptyMap(), locker: SmartRWLocker = SmartRWLocker()) : ReadCRUDRepo<ObjectType, IdType>

Map-based ReadMapCRUDRepo. All internal operations will be locked with locker (mostly with SmartRWLocker.withReadAcquire)

ReadMapKeyValueRepo

class ReadMapKeyValueRepo<Key, Value>(map: Map<Key, Value>, locker: SmartRWLocker) : ReadKeyValueRepo<Key, Value>

Map-based ReadKeyValueRepo. All internal operations will be locked with locker (mostly with SmartRWLocker.withReadAcquire)

ReadOneToManyKeyValueRepo

typealias ReadOneToManyKeyValueRepo<Key, Value> = ReadKeyValuesRepo<Key, Value>

ReadStandardCRUDRepo

typealias ReadStandardCRUDRepo<ObjectType, IdType> = ReadCRUDRepo<ObjectType, IdType>

ReadStandardKeyValueRepo

typealias ReadStandardKeyValueRepo<Key, Value> = ReadKeyValueRepo<Key, Value>

Repo

interface Repo

SimpleMapperRepo

class SimpleMapperRepo<FromKey, FromValue, ToKey, ToValue>(keyFromToTo: suspend FromKey.() -> ToKey, valueFromToTo: suspend FromValue.() -> ToValue, keyToToFrom: suspend ToKey.() -> FromKey, valueToToFrom: suspend ToValue.() -> FromValue) : MapperRepo<FromKey, FromValue, ToKey, ToValue>

StandardCRUDRepo

typealias StandardCRUDRepo<ObjectType, IdType, InputValueType> = CRUDRepo<ObjectType, IdType, InputValueType>

StandardKeyValueRepo

typealias StandardKeyValueRepo<Key, Value> = KeyValueRepo<Key, Value>

StandardSQLHelper

class StandardSQLHelper(context: Context, name: String, factory: SQLiteDatabase.CursorFactory? = null, version: Int = 1, errorHandler: DatabaseErrorHandler? = null, useSharedPreferencesForVersions: Boolean = false)

TransactionContext

class TransactionContext(val databaseContext: CoroutineContext) : CoroutineContext.Element

UpdatedValuePair

typealias UpdatedValuePair<IdType, ValueType> = Pair<IdType, ValueType>

WriteCRUDRepo

interface WriteCRUDRepo<ObjectType, IdType, InputValueType> : Repo

WriteKeyValueRepo

interface WriteKeyValueRepo<Key, Value> : Repo

Write part of KeyValueRepo

WriteKeyValuesRepo

interface WriteKeyValuesRepo<Key, Value> : Repo

WriteMapCRUDRepo

abstract class WriteMapCRUDRepo<ObjectType, IdType, InputValueType>(map: MutableMap<IdType, ObjectType> = mutableMapOf(), locker: SmartRWLocker = SmartRWLocker()) : WriteCRUDRepo<ObjectType, IdType, InputValueType>

MutableMap-based WriteMapCRUDRepo. All internal operations will be locked with locker (mostly with SmartRWLocker.withWriteLock)

WriteMapKeyValueRepo

class WriteMapKeyValueRepo<Key, Value>(map: MutableMap<Key, Value>, locker: SmartRWLocker) : WriteKeyValueRepo<Key, Value>

MutableMap-based WriteKeyValueRepo. All internal operations will be locked with locker (mostly with SmartRWLocker.withWriteLock)

WriteOneToManyKeyValueRepo

typealias WriteOneToManyKeyValueRepo<Key, Value> = WriteKeyValuesRepo<Key, Value>

WriteStandardCRUDRepo

typealias WriteStandardCRUDRepo<ObjectType, IdType, InputValueType> = WriteCRUDRepo<ObjectType, IdType, InputValueType>

WriteStandardKeyValueRepo

typealias WriteStandardKeyValueRepo<Key, Value> = WriteKeyValueRepo<Key, Value>

Properties

DatabaseCoroutineContext

val DatabaseCoroutineContext: CoroutineContext

val <IdType> UpdatedValuePair<IdType, *>.id: IdType

internalId

val internalId: String

internalIdType

val internalIdType: ColumnType.Numeric.INTEGER

value

val <ValueType> UpdatedValuePair<*, ValueType>.value: ValueType

Functions

add

inline suspend fun <Key, Value, REPO : WriteKeyValuesRepo<Key, Value>> REPO.add(vararg keysAndValues: Pair<Key, List<Value>>)

inline suspend fun <Key, Value, REPO : WriteKeyValuesRepo<Key, Value>> REPO.add(keysAndValues: List<Pair<Key, List<Value>>>)

inline suspend fun <Key, Value> WriteKeyValuesRepo<Key, Value>.add(k: Key, vararg v: Value)

inline suspend fun <Key, Value> WriteKeyValuesRepo<Key, Value>.add(k: Key, v: List<Value>)

asCrudRepo

fun <ObjectType, IdType, InputValueType> MutableMap<IdType, ObjectType>.asCrudRepo(updateCallback: suspend MutableMap<IdType, ObjectType>.(newValue: InputValueType, id: IdType, old: ObjectType) -> ObjectType, locker: SmartRWLocker = SmartRWLocker(), createCallback: suspend MutableMap<IdType, ObjectType>.(newValue: InputValueType) -> Pair<IdType, ObjectType>): MapCRUDRepo<ObjectType, IdType, newValue: InputValueType>

MutableMap-based MapCRUDRepo. All internal operations will be locked with locker

asKeyValueRepo

fun <K, V> MutableMap<K, V>.asKeyValueRepo(locker: SmartRWLocker = SmartRWLocker()): KeyValueRepo<K, V>

MutableMap-based KeyValueRepo. All internal operations will be locked with locker

asKeyValuesRepo

fun <K, V> MutableMap<K, List<V>>.asKeyValuesRepo(locker: SmartRWLocker = SmartRWLocker()): KeyValuesRepo<K, V>

MutableMap-based KeyValuesRepo. All internal operations will be locked with locker

blockingReadableTransaction

fun <T> SQLiteOpenHelper.blockingReadableTransaction(block: SQLiteDatabase.() -> T): T

fun <T> StandardSQLHelper.blockingReadableTransaction(block: SQLiteDatabase.() -> T): T

blockingTransaction

fun <T> SQLiteDatabase.blockingTransaction(block: SQLiteDatabase.() -> T): T

blockingWritableTransaction

fun <T> SQLiteOpenHelper.blockingWritableTransaction(block: SQLiteDatabase.() -> T): T

fun <T> StandardSQLHelper.blockingWritableTransaction(block: SQLiteDatabase.() -> T): T

contentValuesOfNotNull

fun contentValuesOfNotNull(vararg pairs: Pair<String, Any?>?): ContentValues

create

suspend fun <ObjectType, IdType, InputValueType> WriteCRUDRepo<ObjectType, IdType, InputValueType>.create(vararg values: InputValueType): List<ObjectType>

createTable

fun SQLiteDatabase.createTable(tableName: String, vararg columnsToTypes: Pair<String, ColumnType>, onInit: SQLiteDatabase.() -> Unit? = null): Boolean

createTableQuery

fun createTableQuery(tableName: String, vararg columnsToTypes: Pair<String, ColumnType>): String

deleteById

suspend fun <ObjectType, IdType, InputValueType> WriteCRUDRepo<ObjectType, IdType, InputValueType>.deleteById(vararg ids: IdType)

firstOrNull

fun Cursor.firstOrNull(): Cursor?

getDouble

fun Cursor.getDouble(columnName: String): Double

getDoubleOrNull

fun Cursor.getDoubleOrNull(columnName: String): Double?

getFloat

fun Cursor.getFloat(columnName: String): Float

getFloatOrNull

fun Cursor.getFloatOrNull(columnName: String): Float?

getInt

fun Cursor.getInt(columnName: String): Int

getIntOrNull

fun Cursor.getIntOrNull(columnName: String): Int?

getLong

fun Cursor.getLong(columnName: String): Long

getLongOrNull

fun Cursor.getLongOrNull(columnName: String): Long?

getShort

fun Cursor.getShort(columnName: String): Short

getShortOrNull

fun Cursor.getShortOrNull(columnName: String): Short?

getString

fun Cursor.getString(columnName: String): String

getStringOrNull

fun Cursor.getStringOrNull(columnName: String): String?

inlineTransaction

inline fun <T> SQLiteDatabase.inlineTransaction(crossinline block: SQLiteDatabase.() -> T): T

invoke

operator fun <FromKey, FromValue, ToKey, ToValue> MapperRepo.Companion.invoke(keyFromToTo: suspend FromKey.() -> ToKey, valueFromToTo: suspend FromValue.() -> ToValue, keyToToFrom: suspend ToKey.() -> FromKey, valueToToFrom: suspend ToValue.() -> FromValue): SimpleMapperRepo<FromKey, FromValue, ToKey, ToValue>

iterator

operator fun Cursor.iterator(): CursorIterator

limitClause

fun limitClause(size: Int, since: Int? = null): String

fun limitClause(size: Long, since: Long? = null): String

limitClause

fun Pagination.limitClause(): String

makePlaceholders

fun makePlaceholders(count: Int): String

makeStringPlaceholders

fun makeStringPlaceholders(count: Int): String

map

inline fun <T> Cursor.map(block: (Cursor) -> T): List<T>

MapCRUDRepo

fun <ObjectType, IdType, InputValueType> MapCRUDRepo(updateCallback: suspend MutableMap<IdType, ObjectType>.(newValue: InputValueType, id: IdType, old: ObjectType) -> ObjectType, locker: SmartRWLocker = SmartRWLocker(), createCallback: suspend MutableMap<IdType, ObjectType>.(newValue: InputValueType) -> Pair<IdType, ObjectType>): MapCRUDRepo<ObjectType, IdType, newValue: InputValueType>

fun <ObjectType, IdType, InputValueType> MapCRUDRepo(map: MutableMap<IdType, ObjectType>, updateCallback: suspend MutableMap<IdType, ObjectType>.(newValue: InputValueType, id: IdType, old: ObjectType) -> ObjectType, locker: SmartRWLocker = SmartRWLocker(), createCallback: suspend MutableMap<IdType, ObjectType>.(newValue: InputValueType) -> Pair<IdType, ObjectType>): MapCRUDRepo<ObjectType, IdType, InputValueType>

MutableMap-based MapCRUDRepo. All internal operations will be locked with locker

mapper

inline fun <FromKey, FromValue, ToKey, ToValue> mapper(noinline keyFromToTo: suspend FromKey.() -> ToKey = { this as ToKey }, noinline valueFromToTo: suspend FromValue.() -> ToValue = { this as ToValue }, noinline keyToToFrom: suspend ToKey.() -> FromKey = { this as FromKey }, noinline valueToToFrom: suspend ToValue.() -> FromValue = { this as FromValue }): SimpleMapperRepo<FromKey, FromValue, ToKey, ToValue>

MapsReposDefaultMutableSharedFlow

fun <T> MapsReposDefaultMutableSharedFlow(): MutableSharedFlow<T>

readableTransaction

suspend fun <T> SQLiteOpenHelper.readableTransaction(block: suspend SQLiteDatabase.() -> T): T

remove

inline suspend fun <Key, Value> WriteKeyValuesRepo<Key, Value>.remove(vararg keysAndValues: Pair<Key, List<Value>>)

inline suspend fun <Key, Value> WriteKeyValuesRepo<Key, Value>.remove(keysAndValues: List<Pair<Key, List<Value>>>)

inline suspend fun <Key, Value> WriteKeyValuesRepo<Key, Value>.remove(k: Key, vararg v: Value)

inline suspend fun <Key, Value> WriteKeyValuesRepo<Key, Value>.remove(k: Key, v: List<Value>)

select

fun SQLiteDatabase.select(table: String, columns: Array<String>? = null, selection: String? = null, selectionArgs: Array<String>? = null, groupBy: String? = null, having: String? = null, orderBy: String? = null, limit: String? = null): Cursor

selectDistinct

fun SQLiteDatabase.selectDistinct(table: String, columns: Array<String>? = null, selection: String? = null, selectionArgs: Array<String>? = null, groupBy: String? = null, having: String? = null, orderBy: String? = null, limit: String? = null): Cursor

set

inline suspend fun <Key, Value, REPO : WriteKeyValuesRepo<Key, Value>> REPO.set(vararg keysAndValues: Pair<Key, List<Value>>)

inline suspend fun <Key, Value, REPO : WriteKeyValuesRepo<Key, Value>> REPO.set(keysAndValues: List<Pair<Key, List<Value>>>)

inline suspend fun <Key, Value> WriteKeyValueRepo<Key, Value>.set(vararg toSet: Pair<Key, Value>)

inline suspend fun <Key, Value> WriteKeyValueRepo<Key, Value>.set(toSet: List<Pair<Key, Value>>)

inline suspend fun <Key, Value> WriteKeyValueRepo<Key, Value>.set(k: Key, v: Value)

inline suspend fun <Key, Value> WriteKeyValuesRepo<Key, Value>.set(k: Key, vararg v: Value)

inline suspend fun <Key, Value> WriteKeyValuesRepo<Key, Value>.set(k: Key, v: List<Value>)

transaction

suspend fun <T> SQLiteDatabase.transaction(block: suspend SQLiteDatabase.() -> T): T

unset

inline suspend fun <Key, Value> WriteKeyValueRepo<Key, Value>.unset(vararg k: Key)

unsetWithValues

inline suspend fun <Key, Value> WriteKeyValueRepo<Key, Value>.unsetWithValues(vararg v: Value)

update

suspend fun <ObjectType, IdType, InputValueType> WriteCRUDRepo<ObjectType, IdType, InputValueType>.update(vararg values: UpdatedValuePair<IdType, InputValueType>): List<ObjectType>

writableTransaction

suspend fun <T> SQLiteOpenHelper.writableTransaction(block: suspend SQLiteDatabase.() -> T): T