Sistema de Eventos

Parte da seção Programação Orientada a Objetos do Journey de C da Coddy. Lição 61 de 61.

Desafio

Fácil

Vamos criar um Sistema de Notificações: uma arquitetura orientada a eventos na qual vários manipuladores podem se inscrever em um evento e responder quando ele é acionado. Esse padrão é a base da programação reativa e dos frameworks de GUI.

Você organizará seu código em três arquivos:

event.h: defina o tipo de ponteiro para função Handler, que recebe uma mensagem const char*. Crie uma struct Event que contenha um array de até 5 manipuladores e uma contagem de manipuladores registrados. Declare funções para inicializar um evento, inscrever um manipulador e disparar o evento para notificar todos os inscritos.
event.c: implemente seu sistema de eventos:
- init_event: recebe um ponteiro para Event e define a contagem de manipuladores como 0
- subscribe: recebe um ponteiro para Event e um Handler, adiciona o manipulador ao array se houver espaço (contagem menor que 5) e incrementa a contagem
- fire: recebe um ponteiro para Event e uma string de mensagem; em seguida, chama cada manipulador registrado com essa mensagem na ordem em que foram inscritos
main.c: crie três funções de manipulador diferentes que respondam aos eventos de maneiras únicas:
- logger: imprime [LOG] seguido da mensagem
- alert: imprime [ALERT] seguido da mensagem
- counter: usa uma variável estática para contar quantas vezes foi chamada e, em seguida, imprime [COUNT] X, onde X é a contagem atual
Leia um inteiro indicando quantos manipuladores devem ser inscritos (1, 2 ou 3). Inscreva essa quantidade de manipuladores na ordem: primeiro logger, depois alert (se 2 ou mais) e, em seguida, counter (se 3). Leia uma string de mensagem e então dispare o evento com essa mensagem.

Seu programa receberá:

A quantidade de manipuladores a serem inscritos (1, 2 ou 3)
A mensagem a ser transmitida

Saída de exemplo quando as entradas são 3 e System started:

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

Saída de exemplo quando as entradas são 2 e Warning detected:

[LOG] Warning detected
[ALERT] Warning detected

Saída de exemplo quando as entradas são 1 e Hello:

[LOG] Hello

Isso demonstra polimorfismo por meio de ponteiros para funções: a mesma chamada fire aciona comportamentos completamente diferentes dependendo de quais manipuladores estão inscritos. Cada manipulador responde à sua própria maneira ao mesmo evento, evidenciando a natureza desacoplada do design orientado a eventos.

Experimente você mesmo

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

// TODO: Implementar handler logger
// Imprime "[LOG] " seguido da mensagem
void logger(const char* message) {
    // TODO: Implementar
}

// TODO: Implementar handler alert
// Imprime "[ALERT] " seguido da mensagem
void alert(const char* message) {
    // TODO: Implementar
}

// TODO: Implementar handler counter
// Usa uma variável static para contar as chamadas
// Imprime "[COUNT] X" onde X é a contagem atual
void counter(const char* message) {
    // TODO: Implementar com variável static
}

int main() {
    // Lê o número de handlers a inscrever
    int num_handlers;
    scanf("%d", &num_handlers);
    getchar(); // consome a nova linha
    
    // Lê a mensagem
    char message[256];
    fgets(message, sizeof(message), stdin);
    message[strcspn(message, "\n")] = '\0'; // remover a quebra de linha
    
    // TODO: Criar e inicializar um Event
    
    // TODO: Inscrever handlers com base em num_handlers
    // 1 handler: logger
    // 2 handlers: logger, alert
    // 3 handlers: logger, alert, counter
    
    // TODO: Disparar o evento com a mensagem
    
    return 0;
}