Merge pull request mouredev#5977 from eulogioep/main

#23 - Kotlin

Author: Roswell468

Roadmap/23 - SINGLETON/kotlin/eulogioep.kt

@@ -0,0 +1,57 @@
+// Ejemplo genérico de Singleton
+object Singleton {
+    init {
+        println("Singleton inicializado")
+    }
+    
+    fun doSomething() {
+        println("Singleton está haciendo algo")
+    }
+}
+
+// Ejemplo de la dificultad extra: Sesión de usuario
+object UserSession {
+    private var userId: Int? = null
+    private var username: String? = null
+    private var name: String? = null
+    private var email: String? = null
+
+    fun setUser(id: Int, username: String, name: String, email: String) {
+        this.userId = id
+        this.username = username
+        this.name = name
+        this.email = email
+        println("Usuario asignado a la sesión")
+    }
+
+    fun getUserData(): Map<String, Any?> {
+        return mapOf(
+            "id" to userId,
+            "username" to username,
+            "name" to name,
+            "email" to email
+        )
+    }
+
+    fun clearSession() {
+        userId = null
+        username = null
+        name = null
+        email = null
+        println("Sesión borrada")
+    }
+}
+
+fun main() {
+    // Uso del Singleton genérico
+    println("Usando el Singleton genérico:")
+    Singleton.doSomething()
+    Singleton.doSomething()
+
+    println("\nUsando el UserSession:")
+    // Uso del UserSession
+    UserSession.setUser(1, "eulogioep", "Eulogio EP", "[email protected]")
+    println("Datos del usuario: ${UserSession.getUserData()}")
+    UserSession.clearSession()
+    println("Datos después de borrar: ${UserSession.getUserData()}")
+}

Roadmap/24 - DECORADORES/kotlin/eulogioep.kt

@@ -0,0 +1,52 @@
+/*
+ * Decoradores en Kotlin (Versión simplificada)
+ *
+ * Los decoradores son un patrón de diseño estructural que permite añadir
+ * nuevas funcionalidades a objetos existentes sin alterar su estructura.
+ * En Kotlin, podemos implementar decoradores de manera sencilla utilizando
+ * funciones de orden superior.
+ *
+ * En esta implementación, nos centraremos en decorar funciones específicas
+ * en lugar de intentar crear un decorador genérico para cualquier tipo de función.
+ */
+
+// Función que queremos decorar
+fun operation(x: Int, y: Int): Int = x + y
+
+// Decorador simple
+fun decorateOperation(func: (Int, Int) -> Int, before: () -> Unit, after: () -> Unit): (Int, Int) -> Int {
+    return { x, y ->
+        before()
+        val result = func(x, y)
+        after()
+        result
+    }
+}
+
+// Decorador para contar llamadas a función
+fun countCallsOperation(func: (Int, Int) -> Int): (Int, Int) -> Int {
+    var count = 0
+    return { x, y ->
+        count++
+        println("La función ha sido llamada $count veces")
+        func(x, y)
+    }
+}
+
+fun main() {
+    // Ejemplo de uso del decorador simple
+    val decoratedOperation = decorateOperation(
+        ::operation,
+        before = { println("Antes de la operación") },
+        after = { println("Después de la operación") }
+    )
+
+    println("Resultado: ${decoratedOperation(5, 3)}")
+
+    // Ejemplo de uso del decorador que cuenta llamadas
+    val countedOperation = countCallsOperation(::operation)
+
+    repeat(3) {
+        println("Resultado: ${countedOperation(it, it + 1)}")
+    }
+}

Roadmap/25 - LOGS/kotlin/eulogioep.kt

@@ -0,0 +1,85 @@
+import java.time.LocalDateTime
+import java.time.Duration
+
+// Concepto de LOGS (Logging):
+// Los logs son registros de eventos que ocurren durante la ejecución de un programa.
+// Son cruciales para el diagnóstico de problemas, monitoreo del rendimiento y
+// seguimiento de la actividad del sistema. En este ejemplo, implementaremos
+// un sistema de logging simple para evitar problemas de permisos.
+
+// Enum para los niveles de log
+enum class LogLevel {
+    INFO, WARNING, ERROR, DEBUG, TRACE
+}
+
+// Clase simple para manejar logging
+class SimpleLogger(private val name: String) {
+    fun log(level: LogLevel, message: String) {
+        println("${LocalDateTime.now()} [$level] $name: $message")
+    }
+
+    fun info(message: String) = log(LogLevel.INFO, message)
+    fun warning(message: String) = log(LogLevel.WARNING, message)
+    fun error(message: String) = log(LogLevel.ERROR, message)
+    fun debug(message: String) = log(LogLevel.DEBUG, message)
+    fun trace(message: String) = log(LogLevel.TRACE, message)
+}
+
+class TaskManager {
+    private val logger = SimpleLogger(TaskManager::class.java.simpleName)
+    private val tasks = mutableListOf<Task>()
+
+    fun addTask(name: String, description: String) {
+        val startTime = LocalDateTime.now()
+        logger.info("Iniciando añadir tarea: $name")
+        
+        tasks.add(Task(name, description))
+        
+        val endTime = LocalDateTime.now()
+        val duration = Duration.between(startTime, endTime)
+        logger.info("Tarea añadida: $name. Tiempo de ejecución: ${duration.toMillis()} ms")
+    }
+
+    fun removeTask(name: String) {
+        val startTime = LocalDateTime.now()
+        logger.warning("Iniciando eliminación de tarea: $name")
+        
+        val removed = tasks.removeIf { it.name == name }
+        if (removed) {
+            logger.info("Tarea eliminada: $name")
+        } else {
+            logger.error("No se encontró la tarea: $name")
+        }
+        
+        val endTime = LocalDateTime.now()
+        val duration = Duration.between(startTime, endTime)
+        logger.debug("Tiempo de ejecución para eliminar tarea: ${duration.toMillis()} ms")
+    }
+
+    fun listTasks() {
+        val startTime = LocalDateTime.now()
+        logger.info("Listando todas las tareas")
+        
+        tasks.forEach { task ->
+            logger.debug("Tarea: ${task.name}, Descripción: ${task.description}")
+        }
+        
+        val endTime = LocalDateTime.now()
+        val duration = Duration.between(startTime, endTime)
+        logger.trace("Tiempo de ejecución para listar tareas: ${duration.toMillis()} ms")
+    }
+}
+
+data class Task(val name: String, val description: String)
+
+fun main() {
+    val taskManager = TaskManager()
+
+    // Ejemplos de uso con diferentes niveles de severidad
+    taskManager.addTask("Comprar víveres", "Ir al supermercado y comprar alimentos")
+    taskManager.addTask("Hacer ejercicio", "30 minutos de cardio")
+    taskManager.listTasks()
+    taskManager.removeTask("Hacer ejercicio")
+    taskManager.removeTask("Tarea inexistente")
+    taskManager.listTasks()
+}