Chain of Responsibility is a behavioral design pattern that allows multiple objects to handle a request or event in a specific order. Each object in the chain has the responsibility to either handle the request or pass it on to the next object in the chain until it is processed or no more objects are available to handle it.
In the provided code, we have implemented the Chain of Responsibility pattern to handle mathematical operations such as addition, subtraction, and multiplication using a sequence of handlers.
The `ChainOfResponsibility` protocol defines the basic structure for the chain, where each handler has a reference to the next handler in the chain. It also declares the `handleRequest` method, which is responsible for passing the request to the next object in the chain or handling it if the current object can handle the request.
In the provided code, we have implemented the Chain of Responsibility pattern to handle mathematical operations such as addition, subtraction, and multiplication using a sequence of handlers.
The `ChainOfResponsibility` protocol defines the basic structure for the chain, where each handler has a reference to the next handler in the chain. It also declares the `handleRequest` method, which is responsible for passing the request to the next object in the chain or handling it if the current object can handle the request.
The `Request` struct defines the type of the request and the value associated with it and the `RequestType` enum defines the operation cases.
The `MainRequestHandler` class implements the `ChainOfResponsibility` protocol and serves as the starting point of the chain. It defines the `canHandle` method, which determines whether the current object can handle the request or not. If it can handle the request, it calls the handle method to process the request. Otherwise, it passes the request to the next object in the chain using the `next` property.
The `AddRequestHandler`, `SubtractionRequestHandler`, and `MultiplyRequestHandler` classes inherit from MainRequestHandler and override the `canHandle` and `handle` methods to handle the specific types of requests they can handle.
To test the chain, we create three handlers for addition, multiplication, and subtraction operations. Then, we create a Request object with the type of operation and value. We call the handleRequest method of the MainRequestHandler object to start the chain. Depending on the type of the request, the request will be handled by one of the handlers in the chain.
In the first call, we create a request for addition and pass it to the `MainRequestHandler`. Since the `MainRequestHandler` can handle addition, it processes the request and prints the result to the console.
In the second call, we set the next object in the chain to be `MultiplyRequestHandler` and create a request for multiplication. Since the `MainRequestHandler` cannot handle multiplication, it passes the request to the next object in the chain, which is `MultiplyRequestHandler`. This object can handle multiplication, so it processes the request and prints the result to the console.
In the third call, we set the next object in the chain to be `SubtractionRequestHandler` and create a request for subtraction. Since the `MainRequestHandler` cannot handle subtraction, it passes the request to the next object in the chain, which is `SubtractionRequestHandler`. This object can handle subtraction, so it processes the request and prints the result to the console.
The Chain of Responsibility pattern is a powerful tool to implement complex workflows with multiple steps, where each step can be handled by a different object in the chain. This pattern makes the code more flexible and maintainable by reducing the coupling between objects and allowing them to evolve independently.
