Цепочка обязанностей на C

Паттерны проектирования / Поведенческие паттерны

//Handler: C has no classes, a rescuer is a struct,
//and a pointer to a function plays the virtual toHelp()
typedef struct Rescuer {
    struct Rescuer *next;
    int code;
    void (*toHelp)(void);
} Rescuer;

//HandleRequest()
void rescuerHelp(const Rescuer *rescuer, int code) {
    if (rescuer->code == code) {
        rescuer->toHelp();
    } else if (rescuer->next != nullptr) {
        rescuerHelp(rescuer->next, code);
    }
}

//ConcreteHandler: the initializer sets the code and the function
void firefighterToHelp(void) {
    printf("call firefighters\n");
}

Rescuer firefighterMake(Rescuer *next) {
    return (Rescuer){next, 1, firefighterToHelp};
}

//ConcreteHandler
void policeToHelp(void) {
    printf("call the police\n");
}

Rescuer policeMake(Rescuer *next) {
    return (Rescuer){next, 2, policeToHelp};
}

//ConcreteHandler
void ambulanceToHelp(void) {
    printf("call an ambulance\n");
}

Rescuer ambulanceMake(Rescuer *next) {
    return (Rescuer){next, 3, ambulanceToHelp};
}

Rescuer ambulance = ambulanceMake(nullptr);
Rescuer police = policeMake(&ambulance);
Rescuer firefighter = firefighterMake(&police);
rescuerHelp(&firefighter, 1);
//printed: call firefighters
rescuerHelp(&firefighter, 2);
//printed: call the police
rescuerHelp(&firefighter, 3);
//printed: call an ambulance

Можно избежать жесткой зависимости отправителя запроса от его получателя, при этом запросом начинает обрабатываться один из нескольких объектов. Объекты-получатели связываются в цепочку, и запрос передается по цепочке, пока какой-то объект его не обработает.

Задача. В службу поддержки приходят запросы разного масштаба. Мелкий идёт к помощнику, покрупнее - к менеджеру, совсем крупный - к директору. Если бы код, который отправляет запрос, сам выбирал получателя, ему пришлось бы знать каждого получателя и каждое правило. Каждый новый получатель требовал бы правки в отправителе.

Идея. Получатели, их называют обработчиками, выстроены в заданном порядке: это и есть цепочка. Отправитель отдаёт запрос только первому обработчику. Каждый обработчик проверяет, его ли это запрос. Если его, обработчик делает работу, и дальше запрос не идёт. Если нет, обработчик передаёт запрос следующему. Отправитель не знает, какой обработчик ответит и ответит ли кто-нибудь вообще.

Как читать пример. Несколько обработчиков соединены в цепочку. Каждый по своему правилу решает, его ли это запрос. Клиентский код отправляет несколько запросов, всегда в начало цепочки. Каждый запрос движется по цепочке, пока какой-нибудь обработчик его не примет. В большинстве языков каждый обработчик хранит ссылку на следующий; в некоторых цепочка - простой список, который проверяют по порядку. Некоторые примеры отправляют ещё и запрос, который не принимает ни один обработчик, и вывод об этом сообщает.

Когда применять. Цепочка нужна, когда запрос могут обработать несколько объектов, а их набор или порядок может меняться. Если получатель всегда один и тот же, она ни к чему: прямой вызов проще и понятнее.

Частая ошибка. Забыть о конце цепочки. Тогда запрос, который не принял ни один обработчик, пропадает без единого сообщения. Нужно решить, что происходит в конце: ошибка, обработчик по умолчанию или внятное сообщение.