commonMain.me.aartikov.replica.devtools.dto.DtoStore.kt Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of replica-devtools-dto Show documentation
Android libary for organizing of network communication in a declarative way
There is a newer version: 1.3.1-alpha1
package me.aartikov.replica.devtools.dto

import kotlinx.coroutines.flow.*

class DtoStore {

    private val _dtoFlow = MutableStateFlow(ReplicaClientDto())
    val dtoFlow: StateFlow = _dtoFlow.asStateFlow()

    private val _eventFlow = MutableSharedFlow(extraBufferCapacity = 1000)
    val eventFlow: Flow = _eventFlow.asSharedFlow()

    fun addReplica(replica: ReplicaDto) {
        _dtoFlow.update {
            it.copy(replicas = it.replicas.plus(replica.id to replica))
        }
        _eventFlow.tryEmit(ReplicaCreated(replica))
    }

    fun addKeyedReplica(keyedReplica: KeyedReplicaDto) {
        _dtoFlow.update {
            it.copy(keyedReplicas = it.keyedReplicas.plus(keyedReplica.id to keyedReplica))
        }
        _eventFlow.tryEmit(KeyedReplicaCreated(keyedReplica))
    }

    fun addKeyedReplicaChild(keyedReplicaId: Long, childReplica: ReplicaDto) {
        _dtoFlow.update {
            val keyedReplica = it.keyedReplicas[keyedReplicaId] ?: return
            val updatedKeyedReplica = keyedReplica.copy(
                childReplicas = keyedReplica.childReplicas.plus(childReplica.id to childReplica)
            )
            it.copy(
                keyedReplicas = it.keyedReplicas.plus(keyedReplicaId to updatedKeyedReplica)
            )
        }
        _eventFlow.tryEmit(KeyedReplicaChildCreated(keyedReplicaId, childReplica))
    }

    fun updateReplicaState(replicaId: Long, state: ReplicaStateDto) {
        _dtoFlow.update {
            val updatedReplica = it.replicas[replicaId]?.copy(state = state) ?: return
            it.copy(
                replicas = it.replicas.plus(replicaId to updatedReplica)
            )
        }
        _eventFlow.tryEmit(ReplicaUpdated(replicaId, state))
    }

    fun updateKeyedReplicaState(keyedReplicaId: Long, state: KeyedReplicaStateDto) {
        _dtoFlow.update {
            val updatedReplica = it.keyedReplicas[keyedReplicaId]?.copy(state = state) ?: return
            it.copy(
                keyedReplicas = it.keyedReplicas.plus(keyedReplicaId to updatedReplica)
            )
        }
        _eventFlow.tryEmit(KeyedReplicaUpdated(keyedReplicaId, state))
    }

    fun updateKeyedReplicaChildState(
        keyedReplicaId: Long,
        childReplicaId: Long,
        state: ReplicaStateDto
    ) {
        _dtoFlow.update {
            val keyedReplica = it.keyedReplicas[keyedReplicaId] ?: return
            val updatedChildReplica = keyedReplica.childReplicas[childReplicaId]
                ?.copy(state = state)
                ?: return
            val updatedKeyedReplica = keyedReplica.copy(
                childReplicas = keyedReplica.childReplicas.plus(
                    childReplicaId to updatedChildReplica
                )
            )
            it.copy(keyedReplicas = it.keyedReplicas.plus(keyedReplicaId to updatedKeyedReplica))
        }
        _eventFlow.tryEmit(
            KeyedReplicaChildUpdated(
                keyedReplicaId,
                childReplicaId,
                state
            )
        )
    }

    fun removeKeyedReplicaChild(keyedReplicaId: Long, childReplicaId: Long) {
        _dtoFlow.update {
            val keyedReplica = it.keyedReplicas[keyedReplicaId] ?: return
            val updatedKeyedReplica = keyedReplica.copy(
                childReplicas = keyedReplica.childReplicas.minus(childReplicaId)
            )
            it.copy(
                keyedReplicas = it.keyedReplicas.plus(keyedReplicaId to updatedKeyedReplica)
            )
        }
        _eventFlow.tryEmit(KeyedReplicaChildRemoved(keyedReplicaId, childReplicaId))
    }

    fun updateState(state: ReplicaClientDto) {
        _dtoFlow.update { state }
    }
}