Como Modelar Modos Operacionais com Classes Seladas em Kotlin

Ao desenvolver sistemas com múltiplos estados, é fundamental ter um controle preciso sobre os modos operacionais. Uma maneira eficaz de implementar esse controle é definindo modos operacionais discretos, que podem ser gerenciados e alterados de acordo com as necessidades da aplicação. Em Kotlin, a utilização de classes seladas (sealed classes) oferece uma solução elegante para representar esses modos de operação de forma segura e controlada.

No contexto de um serviço de tarefas, por exemplo, podemos definir os seguintes modos operacionais:

kotlin
Copy code
sealed class AppState {

    object Running : AppState()
    object ReadOnly : AppState()
    object Maintenance : AppState()
}

Aqui, temos três modos distintos para o serviço de tarefas:

• Running: Modo normal de operação, onde é permitido adicionar, remover e listar tarefas.

• ReadOnly: Modo somente leitura, onde adições e remoções são desabilitadas, mas listagem de tarefas ainda é permitida.

• Maintenance: Modo de manutenção, onde apenas a remoção de todas as tarefas é permitida.

Para gerenciar esses modos dentro de um serviço de tarefas, adicionamos uma propriedade mutável que rastreia o estado atual:

kotlin
Copy code
var state: AppState = AppState.Running
    private set

A propriedade state é inicializada no modo Running por padrão, e o método setState permite alterar esse estado de forma controlada, preservando a encapsulação da lógica de negócios:

kotlin
Copy code
fun setState(newState: AppState) {

    state = newState
}

Verificação de Estado antes da Execução de Comandos

Uma das vantagens de se usar modos operacionais é a capacidade de verificar o estado antes de executar uma operação. Cada comando, como adicionar ou remover tarefas, deve verificar o estado atual do sistema antes de proceder. Isso previne a execução de operações inválidas e garante que o sistema se comporte conforme esperado.

Exemplo de verificação no AddHandler:

kotlin
Copy code
override fun execute(args: String) {

    if (service.state != AppState.Running) {
        println("Não é possível adicionar tarefas no modo ${service.state}.")
        return
    }
    // Lógica de adição de tarefa...
}

No RemoveHandler, a verificação pode ser mais complexa, uma vez que a remoção é permitida tanto no modo Running quanto no modo Maintenance, mas não no modo ReadOnly:

kotlin
Copy code
override fun execute(args: String) {
    when (service.state) {
        AppState.Running, AppState.Maintenance -> {
            // Permitir remoção
            handleRemove(args)
        }
        AppState.ReadOnly -> println("Remoção desabilitada no modo somente leitura.")
    }
}

Alternância de Modos via Comandos

Para permitir que os usuários alterem os modos operacionais de maneira flexível, podemos definir um manipulador de comandos. O ModeHandler permite alternar entre os diferentes estados com comandos específicos:

kotlin
Copy code
class ModeHandler(private val service: TaskService) : CommandHandler {

    override val commandName = "mode"
    override fun execute(args: String) {
        val mode = args.trim().lowercase()
        service.setState(when (mode) {
            "running" -> AppState.Running
            "readonly" -> AppState.ReadOnly
            "maintenance" -> AppState.Maintenance
            else -> {
                println("Modo desconhecido: $mode")
                return
            }
        })
        println("Estado alterado para ${service.state}")
    }
}

Esse manipulador permite que o sistema mude dinamicamente entre os modos Running, ReadOnly e Maintenance, facilitando a administração e a flexibilidade no controle das operações.

Combinando Flags de Funcionalidade e Verificações de Estado

Além dos modos operacionais, podemos utilizar flags booleanas para controlar o comportamento de funcionalidades específicas, como o autoSaveEnabled (salvamento automático). No serviço de tarefas, isso pode ser implementado da seguinte forma:

kotlin
Copy code
var autoSaveEnabled: Boolean = true

fun saveIfNeeded() {
    if (autoSaveEnabled) save()
}

Com essa abordagem, o sistema pode controlar a ativação ou desativação do salvamento automático, dependendo do valor da flag. O comando autosave permite aos usuários alternar essa configuração:

kotlin
Copy code
class AutoSaveHandler(private val service: TaskService) : CommandHandler {
    override val commandName = "autosave"

    override fun execute(args: String) {

        service.autoSaveEnabled = (args.trim().lowercase() == "on")
        println("Salvamento automático ${if (service.autoSaveEnabled) "habilitado" else "desabilitado"}.")
    }
}

Essa combinação de flags e verificações de estado permite um controle granular sobre o comportamento do sistema, possibilitando ajustes dinâmicos e flexíveis.

Centralizando as Condições de Pré-requisito com Funções Auxiliares

Para evitar a repetição de verificações de estado em diversos manipuladores, podemos centralizar essa lógica em uma função auxiliar no serviço de tarefas. A função withState permite que as operações sejam executadas apenas se o estado atual for permitido:

kotlin
Copy code
fun withState(vararg allowed: AppState, action: () -> Unit) {

    if (state in allowed) action()
    else println("Operação não permitida no modo $state.")
}

Essa abordagem simplifica os manipuladores, tornando-os mais concisos e fáceis de entender:

kotlin
Copy code
override fun execute(args: String) {
    service.withState(AppState.Running) {
        handleAdd(args)
    }
}

Ao centralizar as verificações de estado dessa forma, o código se torna mais reutilizável e claro, reduzindo a duplicação e aumentando a manutenção.

Ajustando a Interface de Usuário Dinamicamente com Base no Estado

Uma maneira adicional de melhorar a interação do usuário é ajustar os prompts do sistema conforme o estado atual. Isso torna a experiência mais intuitiva, pois o usuário sempre sabe em qual modo o sistema se encontra e quais comandos são permitidos.

kotlin
Copy code
while (true) {

    print("[${service.state}]> ")
    val input = readLine().orEmpty().trim()
    // Lógica de parsing e execução...
}

Isso reduz a confusão e melhora a clareza, ajudando o usuário a entender rapidamente os modos em que o sistema pode estar e as operações permitidas.

Ao integrar essas práticas, como modos operacionais baseados em classes seladas, flags de funcionalidade e verificações centralizadas, conseguimos criar uma aplicação robusta e flexível. A capacidade de reagir dinamicamente às ações do usuário e às mudanças de configuração permite que o sistema se adapte de forma suave e eficiente.

Como utilizar funções de encadeamento e lambdas para criar pipelines eficientes em Kotlin

O uso de funções como onEach, map, filter e flatMap no Kotlin permite criar pipelines de processamento de dados de maneira fluida e eficiente, sem a necessidade de loops ou verificações condicionais explícitas. Essas funções transformam as coleções de dados de forma clara e legível, oferecendo uma maneira intuitiva de manipular dados em sequência. Cada função dentro de uma pipeline tem um propósito específico, o que facilita a manutenção do código e reduz a complexidade cognitiva.

Ao trabalhar com pipelines, a aplicação de efeitos colaterais de maneira inline usando o onEach permite que você observe a transformação dos dados sem interromper o fluxo da pipeline. Isso é útil, por exemplo, para registro de logs ou métricas em tempo real durante o processamento. A vantagem dessa abordagem é que ela mantém o código limpo e evita a necessidade de loops adicionais ou variáveis temporárias, permitindo que o código permaneça expressivo e sem sobrecarga de implementações desnecessárias.

O conceito de Function Chaining em Kotlin se baseia na ideia de encadear operações sobre coleções, onde cada operação (como map, filter, sortedBy, flatMap) retorna uma nova coleção. Isso cria um fluxo contínuo de dados, sem a necessidade de manipulação explícita de variáveis intermediárias, o que torna o código mais limpo e fácil de entender. O Kotlin permite que você escreva essas operações de maneira concisa, o que elimina a necessidade de loops aninhados e outras estruturas imperativas complexas.

Por exemplo, ao precisar de uma lista de descrições de tarefas de alta prioridade e pendentes, ordenadas por data de criação, você pode criar uma pipeline simples e legível:

kotlin
Copy code
val pipeline = tasks.values

    .filter { it.highPriority && !it.completed }
    .sortedBy { it.createdTimestamp }
    .map { it.description }

Aqui, a função filter seleciona apenas as tarefas de alta prioridade e não concluídas, sortedBy ordena-as pela data de criação e map extrai a descrição de cada tarefa. A operação forEach(::println) vai imprimir essas descrições em ordem, de maneira eficiente e legível.

kotlin
Copy code
fun Collection.pendingHighPriority(): List = filter { it.highPriority && !it.completed }
fun List.sortByCreation(): List = sortedBy { it.createdTimestamp }

Com essas funções, a pipeline se torna ainda mais legível:

kotlin
Copy code
tasks.values

    .pendingHighPriority()
    .sortByCreation()
    .map(Task::description)
    .forEach(::println)

Além disso, a utilização de flatMap permite achatar estruturas de dados aninhadas. Quando temos listas de tags associadas a cada tarefa, por exemplo, podemos usar flatMap para juntar todas as tags em uma única lista. Isso elimina a necessidade de loops manuais e mantém o código conciso e compreensível.

kotlin
Copy code
val pendingTags: Set = tasks.values

    .filter { !it.completed }
    .flatMap { it.tags }
    .toSet()

Aqui, flatMap "achata" a lista de tags de cada tarefa em uma lista única, e toSet() remove duplicatas. Com isso, conseguimos extrair todas as tags de tarefas pendentes de forma eficiente e legível.

É possível também combinar várias pipelines para produzir relatórios ou dados agregados. Por exemplo, podemos separar as tarefas em duas categorias — overdue (atrasadas) e upcoming (próximas) — e combinar os resultados em um único relatório:

kotlin
Copy code
val now = System.currentTimeMillis()
val overdue = tasks.values
    .filter { !it.completed && it.dueTimestamp < now }
    .sortedBy { it.dueTimestamp }
    .map { "OVERDUE: ${it.id} due ${formatTime(it.dueTimestamp)}" }
val upcoming = tasks.values
    .filter { !it.completed && it.dueTimestamp in now until now + DAY_MS }
    .sortedBy { it.dueTimestamp }
    .map { "UPCOMING: ${it.id} due ${formatTime(it.dueTimestamp)}" }
(overdue + upcoming).forEach(::println)

Aqui, dividimos o processamento das tarefas em duas pipelines separadas, uma para as tarefas atrasadas e outra para as tarefas futuras, e as combinamos ao final para gerar um relatório unificado, sem a necessidade de lógica intercalada.

kotlin
Copy code
tasks.values.asSequence()
    .filter { !it.completed }
    .map { transformTask(it) }
    .sortedBy { it.createdTimestamp }
    .toList()
    .forEach(::println)

Quando se trata de manipulação de valores nulos, a função mapNotNull pode ser usada para transformar e filtrar valores de uma vez. Essa abordagem garante que apenas valores válidos sejam processados, evitando a propagação de nulos.

kotlin
Copy code
tasks.values

    .mapNotNull { task ->
        if (task.description.contains("!")) task.description.removePrefix("!") else null
    }
    .forEach { println("Cleaned: $it") }

kotlin
Copy code
fun TaskService.onTaskEvents(
    added: (Task) -> Unit = {},
    updated: (Task) -> Unit = {},
    removed: (Int) -> Unit = {}
) {
    addObserver(object : TaskObserver {

        override fun onTaskAdded(task: Task) = added(task)

        override fun onTaskUpdated(task: Task) = updated(task)

        override fun onTaskRemoved(id: Int) = removed(id)

    })
}

Essa abordagem facilita a adição de novos tipos de manipulação de eventos sem aumentar a complexidade do sistema.

Por fim, a utilização de corrotinas e fluxos assíncronos (como StateFlow) permite a execução de atualizações em tempo real, sem complicar a estrutura do código. Isso é particularmente útil em aplicações que exigem atualizações frequentes ou interações assíncronas, como interfaces de usuário dinâmicas ou processamento em segundo plano.