commonMain.dev.inmo.micro_utils.repos.mappers.OneToManyKeyValueMappers.kt Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of micro_utils.repos.common Show documentation
It is set of projects with micro tools for avoiding of routines coding
There is a newer version: 0.24.4
Show newest version
package dev.inmo.micro_utils.repos.mappers

import dev.inmo.micro_utils.pagination.*
import dev.inmo.micro_utils.repos.*
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.map

open class MapperReadKeyValuesRepo(
    private val to: ReadKeyValuesRepo,
    mapper: MapperRepo
) : ReadKeyValuesRepo, MapperRepo by mapper {
    override suspend fun get(
        k: FromKey,
        pagination: Pagination,
        reversed: Boolean
    ): PaginationResult = to.get(
        k.toOutKey(),
        pagination,
        reversed
    ).let {
        it.changeResultsUnchecked(
            it.results.map { it.toInnerValue() }
        )
    }

    override suspend fun keys(
        pagination: Pagination,
        reversed: Boolean
    ): PaginationResult = to.keys(
        pagination,
        reversed
    ).let {
        it.changeResultsUnchecked(
            it.results.map { it.toInnerKey() }
        )
    }

    override suspend fun keys(
        v: FromValue,
        pagination: Pagination,
        reversed: Boolean
    ): PaginationResult = to.keys(
        v.toOutValue(),
        pagination,
        reversed
    ).let {
        it.changeResultsUnchecked(
            it.results.map { it.toInnerKey() }
        )
    }

    override suspend fun contains(k: FromKey): Boolean = to.contains(k.toOutKey())
    override suspend fun contains(k: FromKey, v: FromValue): Boolean = to.contains(k.toOutKey(), v.toOutValue())

    override suspend fun count(): Long = to.count()
    override suspend fun count(k: FromKey): Long = to.count(k.toOutKey())
}

@Suppress("NOTHING_TO_INLINE")
inline fun  ReadKeyValuesRepo.withMapper(
    mapper: MapperRepo
): ReadKeyValuesRepo = MapperReadKeyValuesRepo(this, mapper)

@Suppress("NOTHING_TO_INLINE")
inline fun  ReadKeyValuesRepo.withMapper(
    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 },
): ReadKeyValuesRepo = withMapper(
    mapper(keyFromToTo, valueFromToTo, keyToToFrom, valueToToFrom)
)

open class MapperWriteKeyValuesRepo(
    private val to: WriteKeyValuesRepo,
    mapper: MapperRepo
) : WriteKeyValuesRepo, MapperRepo by mapper {
    override val onNewValue: Flow> = to.onNewValue.map { (k, v) ->
        k.toInnerKey() to v.toInnerValue()
    }
    override val onValueRemoved: Flow> = to.onValueRemoved.map { (k, v) ->
        k.toInnerKey() to v.toInnerValue()
    }
    override val onDataCleared: Flow = to.onDataCleared.map { k ->
        k.toInnerKey()
    }

    override suspend fun add(toAdd: Map>) = to.add(
        toAdd.map { (k, v) ->
            k.toOutKey() to v.map { it.toOutValue() }
        }.toMap()
    )

    override suspend fun remove(toRemove: Map>) = to.remove(
        toRemove.map { (k, v) ->
            k.toOutKey() to v.map { it.toOutValue() }
        }.toMap()
    )

    override suspend fun removeWithValue(v: FromValue) = to.removeWithValue(v.toOutValue())

    override suspend fun set(toSet: Map>) {
        to.set(
            toSet.map { (k, vs) -> k.toOutKey() to vs.map { v -> v.toOutValue() } }.toMap()
        )
    }

    override suspend fun clear(k: FromKey) = to.clear(k.toOutKey())
    override suspend fun clearWithValue(v: FromValue) = to.clearWithValue(v.toOutValue())
}

@Suppress("NOTHING_TO_INLINE")
inline fun  WriteKeyValuesRepo.withMapper(
    mapper: MapperRepo
): WriteKeyValuesRepo = MapperWriteKeyValuesRepo(this, mapper)

@Suppress("NOTHING_TO_INLINE")
inline fun  WriteKeyValuesRepo.withMapper(
    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 },
): WriteKeyValuesRepo = withMapper(
    mapper(keyFromToTo, valueFromToTo, keyToToFrom, valueToToFrom)
)

@Suppress("DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE")
open class MapperKeyValuesRepo(
    private val to: KeyValuesRepo,
    mapper: MapperRepo
) : KeyValuesRepo,
    MapperRepo by mapper,
    ReadKeyValuesRepo by MapperReadKeyValuesRepo(to, mapper),
    WriteKeyValuesRepo by MapperWriteKeyValuesRepo(to, mapper)

@Suppress("NOTHING_TO_INLINE")
inline fun  KeyValuesRepo.withMapper(
    mapper: MapperRepo
): KeyValuesRepo = MapperKeyValuesRepo(this, mapper)

@Suppress("NOTHING_TO_INLINE")
inline fun  KeyValuesRepo.withMapper(
    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 },
): KeyValuesRepo = withMapper(
    mapper(keyFromToTo, valueFromToTo, keyToToFrom, valueToToFrom)
)