This type represents T as not only potentially nullable data, but also as a data which can not be presented. This type will be useful in cases when T is nullable and null as valuable data too in time of data absence should be presented by some third type.

PreviewFeature

@Target(allowedTargets = [AnnotationTarget.CLASS, AnnotationTarget.CONSTRUCTOR, AnnotationTarget.FIELD, AnnotationTarget.PROPERTY, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER, AnnotationTarget.FUNCTION, AnnotationTarget.TYPEALIAS])

annotation class PreviewFeature(val message: String = "It is possible, that behaviour of this thing will be changed or removed in future releases")

Progress

@Serializable

@JvmInline

value class Progress

SimpleMapper

interface SimpleMapper<T1, T2>

SimpleMapperImpl

class SimpleMapperImpl<T1, T2>(t1: (T2) -> T1, t2: (T1) -> T2) : SimpleMapper<T1, T2>

SimpleSuspendableMapper

interface SimpleSuspendableMapper<T1, T2>

SimpleSuspendableMapperImpl

class SimpleSuspendableMapperImpl<T1, T2>(t1: suspend (T2) -> T1, t2: suspend (T1) -> T2) : SimpleSuspendableMapper<T1, T2>

SuspendByteArrayAllocator

typealias SuspendByteArrayAllocator = suspend () -> ByteArray

Warning

annotation class Warning(val message: String)

Functions

alsoIfFalse

inline fun Boolean.alsoIfFalse(block: () -> Unit): Boolean

alsoIfTrue

inline fun Boolean.alsoIfTrue(block: () -> Unit): Boolean

applyDiff

fun <T> MutableList<T>.applyDiff(diff: Diff<T>)

Applies diff to this

fun <K, V> MutableMap<K, V>.applyDiff(mapDiff: MapDiff<K, V>)

Will apply mapDiff to this

fun <T> MutableList<T>.applyDiff(source: Iterable<T>, strictComparison: Boolean = false): Diff<T>

This method call calculateDiff with strict mode strictComparison and then apply differences to this mutable list

fun <T> MutableList<T>.applyDiff(source: Iterable<T>, comparisonFun: (T?, T?) -> Boolean): Diff<T>

This method call calculateDiff and then apply differences to this mutable list

fun <K, V> MutableMap<K, V>.applyDiff(from: Map<K, V>, strictComparison: Boolean = false): MapDiff<K, V>

fun <K, V> MutableMap<K, V>.applyDiff(from: Map<K, V>, compareFun: (K, V, V) -> Boolean): MapDiff<K, V>

Will apply changes with from map into this one

argumentOrNull

fun argumentOrNull(): ArgumentPropertyNullableDelegate

argumentOrThrow

fun argumentOrThrow(): ArgumentPropertyNonNullableDelegate

asAllocator

suspend fun SuspendByteArrayAllocator.asAllocator(): ByteArrayAllocator

bytes

suspend fun MPPFile.bytes(): ByteArray

bytesSync

fun MPPFile.bytesSync(): ByteArray

calculateDiff

fun <T> Iterable<T>.calculateDiff(other: Iterable<T>, strictComparison: Boolean = false): Diff<T>

fun <T> Iterable<T>.calculateDiff(other: Iterable<T>, comparisonFun: (T?, T?) -> Boolean): Diff<T>

Calculating Diff object

calculateStrictDiff

inline fun <T> Iterable<T>.calculateStrictDiff(other: Iterable<T>): Diff<T>

This method call calculateDiff with strict mode enabled

changeVisibility

fun View.changeVisibility(show: Boolean = !isShown, goneOnHide: Boolean = true)

collapse

fun View.collapse(duration: Long = 500)

collapseHorizontally

fun View.collapseHorizontally(duration: Long = 500)

compareTo

operator fun Progress.compareTo(other: Progress): Int

convert

@JvmName(name = "convertFromT2")

fun <T1, T2> SimpleMapper<T1, T2>.convert(from: T2): T1

@JvmName(name = "convertFromT1")

fun <T1, T2> SimpleMapper<T1, T2>.convert(from: T1): T2

@JvmName(name = "convertFromT2")

suspend fun <T1, T2> SimpleSuspendableMapper<T1, T2>.convert(from: T2): T1

@JvmName(name = "convertFromT1")

suspend fun <T1, T2> SimpleSuspendableMapper<T1, T2>.convert(from: T1): T2

dataOrElse

inline fun <T> Optional<T>.dataOrElse(block: () -> T): T

Returns Optional.data if Optional.dataPresented of this is true, or call block and returns the result of it

dataOrNull

fun <T> Optional<T>.dataOrNull(): T?

Returns Optional.data if Optional.dataPresented of this is true, or null otherwise

dataOrThrow

fun <T> Optional<T>.dataOrThrow(throwable: Throwable): T

Returns Optional.data if Optional.dataPresented of this is true, or throw throwable otherwise

Diff

inline fun <T> Diff(old: Iterable<T>, new: Iterable<T>): Diff<T>

diff

inline fun <T> Iterable<T>.diff(other: Iterable<T>, strictComparison: Boolean = false): Diff<T>

inline fun <T> Iterable<T>.diff(other: Iterable<T>, noinline comparisonFun: (T?, T?) -> Boolean): Diff<T>

fun <K, V> Map<K, V>.diff(other: Map<K, V>, strictComparison: Boolean = false): MapDiff<K, V>

fun <K, V> Map<K, V>.diff(other: Map<K, V>, compareFun: (K, V, V) -> Boolean): MapDiff<K, V>

Compare this with the other one in principle when other is newer than this

disable

fun View.disable()

div

operator fun Progress.div(i: Byte): Progress

operator fun Progress.div(i: Double): Progress

operator fun Progress.div(i: Float): Progress

operator fun Progress.div(i: Int): Progress

operator fun Progress.div(i: Long): Progress

operator fun Progress.div(i: Short): Progress

downloadToTempFile

fun InputStream.downloadToTempFile(fileName: String = UUID.randomUUID().toString(), fileExtension: String? = ".temp", folder: File? = null): File

either

inline fun <T1, T2> Any.either(): <Error class: unknown class>

emptyDiff

fun <T> emptyDiff(): Diff<T>

enable

fun View.enable()

expand

fun View.expand(duration: Long = 500, targetWidth: Int = ViewGroup.LayoutParams.MATCH_PARENT, targetHeight: Int = ViewGroup.LayoutParams.WRAP_CONTENT)

expandHorizontally

fun View.expandHorizontally(duration: Long = 500, targetWidth: Int = ViewGroup.LayoutParams.MATCH_PARENT, targetHeight: Int = ViewGroup.LayoutParams.WRAP_CONTENT)

findViewsByTag