Sistema de eventos

Parte de la sección Programación Orientada a Objetos del Journey de C de Coddy. Lección 61 de 61.

Desafío

Fácil

Construyamos un sistema de notificaciones: una arquitectura basada en eventos en la que varios controladores pueden suscribirse a un evento y responder cuando se activa. Este patrón es la base de la programación reactiva y de los frameworks de GUI.

Organizarás tu código en tres archivos:

event.h: Define el tipo de puntero a función Handler que recibe un mensaje const char*. Crea una estructura Event que contenga un arreglo de hasta 5 controladores y un contador de controladores registrados. Declara funciones para inicializar un evento, suscribir un controlador y activar el evento para notificar a todos los suscriptores.
event.c: Implementa tu sistema de eventos:
- init_event: recibe un puntero a Event y establece el contador de controladores en 0
- subscribe: recibe un puntero a Event y un Handler, agrega el controlador al arreglo si hay espacio (el contador es menor que 5) e incrementa el contador
- fire: recibe un puntero a Event y una cadena de mensaje, después llama a cada controlador registrado con ese mensaje en el orden en que se suscribieron
main.c: Crea tres funciones de controlador diferentes que respondan a los eventos de maneras únicas:
- logger: imprime [LOG] seguido del mensaje
- alert: imprime [ALERT] seguido del mensaje
- counter: utiliza una variable estática para contar cuántas veces se ha llamado, después imprime [COUNT] X, donde X es el contador actual
Lee un entero que indique cuántos controladores suscribir (1, 2 o 3). Suscribe esa cantidad de controladores en orden: primero logger, después alert (si son 2 o más) y luego counter (si son 3). Lee una cadena de mensaje y después activa el evento con ese mensaje.

Tu programa recibirá:

El número de controladores que se suscribirán (1, 2 o 3)
El mensaje que se difundirá

Ejemplo de salida cuando las entradas son 3 y System started:

[LOG] System started
[ALERT] System started
[COUNT] 1

Ejemplo de salida cuando las entradas son 2 y Warning detected:

[LOG] Warning detected
[ALERT] Warning detected

Ejemplo de salida cuando las entradas son 1 y Hello:

[LOG] Hello

Esto demuestra el polimorfismo mediante punteros a funciones: la misma llamada a fire activa comportamientos completamente diferentes según los controladores que estén suscritos. Cada controlador responde a su manera al mismo evento, mostrando la naturaleza desacoplada del diseño basado en eventos.

Pruébalo tú mismo

#include <stdio.h>
#include <string.h>
#include "event.h"

// TODO: Implementar manejador logger
// Imprime "[LOG] " seguido del mensaje
void logger(const char* message) {
    // TODO: Implementar
}

// TODO: Implementar manejador alert
// Imprime "[ALERT] " seguido del mensaje
void alert(const char* message) {
    // TODO: Implementar
}

// TODO: Implementar manejador counter
// Usa una variable static para contar las llamadas
// Imprime "[COUNT] X" donde X es el conteo actual
void counter(const char* message) {
    // TODO: Implementar con variable static
}

int main() {
    // Lee el número de manejadores a suscribir
    int num_handlers;
    scanf("%d", &num_handlers);
    getchar(); // consumir el salto de línea
    
    // Lee el mensaje
    char message[256];
    fgets(message, sizeof(message), stdin);
    message[strcspn(message, "\n")] = '\0'; // eliminar el salto de línea
    
    // TODO: Crear e inicializar un Event
    
    // TODO: Suscribir manejadores basándose en num_handlers
    // 1 manejador: logger
    // 2 manejadores: logger, alert
    // 3 manejadores: logger, alert, counter
    
    // TODO: Disparar el evento con el mensaje
    
    return 0;
}