Design Patterns: Chain of Responsibilit with Swift – Unlocking the Power of Programming

By /

Design Patterns: Chain of Responsibility with Swift – Unlocking the Power of Programming

Programming has been around for decades, and it has evolved immensely in that time. One of the more interesting and powerful aspects of programming is design patterns. Design patterns are a way to structure code so that it is easier to understand and maintain. One of the most popular design patterns is the Chain of Responsibility pattern. In this blog post, we will look at what the Chain of Responsibility pattern is, how to implement it in Swift, and how it can help you unlock the power of programming.

The Chain of Responsibility pattern is a behavioral design pattern used to create a chain of objects that can process a request. The concept is simple: an object sends a request to the first object in the chain, which then passes the request along to the next object in the chain until it reaches the final object, which handles the request. This allows for complex behavior to be broken down into smaller, more manageable pieces.

To illustrate how the Chain of Responsibility pattern works, let’s look at an example. Imagine we have a shopping cart application, and when a user adds an item to their cart, we need to check if they are eligible for a discount. To do this, we can create a chain of objects that each check if the user is eligible for a discount. The first object in the chain could check if the user has a coupon code, the second object could check if the user has made any previous purchases, and the third object could check if the user is a returning customer. If the user passes all the checks, then the final object in the chain would apply the discount to the user’s cart.

Now that we have an understanding of the concept, let’s look at how to implement this pattern in Swift. As with most design patterns, the Chain of Responsibility pattern relies heavily on the use of protocols. We will create a protocol called Handler that our objects will conform to. This protocol will define the methods that our objects must implement.

 protocol Handler { 
    func handle(request: Request) -> Bool 
    var nextHandler: Handler? { get set } 
}

This protocol defines two methods. The first method, handle, is responsible for processing the request and returning a boolean value indicating whether or not the request was handled successfully. The second method, nextHandler, is a reference to the next object in the chain.

Now that we have our protocol defined, let’s create some objects that conform to it. We will create three objects, each of which will check for different criteria when determining if the user is eligible for a discount.

class CouponChecker: Handler { 
    func handle(request: Request) -> Bool { 
        // Check if user has a coupon code 
        if request.couponCode != "" { 
            return true 
        } else { 
            return false 
        } 
    } 
    var nextHandler: Handler? 
} 

class PurchasesChecker: Handler { 
    func handle(request: Request) -> Bool { 
        // Check if user has made any previous purchases 
        if request.numberOfPurchases > 0 { 
            return true 
        } else { 
            return false 
        } 
    } 
    var nextHandler: Handler? 
} 

class ReturningCustomerChecker: Handler { 
    func handle(request: Request) -> Bool { 
        // Check if user is a returning customer 
        if request.isReturningCustomer { 
            return true 
        } else { 
            return false 
        } 
    } 
    var nextHandler: Handler? 
}

Once we have our objects created, we need to create a chain of them. To do this, we will simply set the nextHandler property of each object to the next one in the chain. 

let couponChecker = CouponChecker() 
let purchasesChecker = PurchasesChecker() 
let returningCustomerChecker = ReturningCustomerChecker() 

couponChecker.nextHandler = purchasesChecker 
purchasesChecker.nextHandler = returningCustomerChecker

Now that we have our chain of objects set up, we can process our request. To do this, we simply call the handle method on the first object in the chain and pass in our request object.

let request = Request(couponCode: "SUMMERSALE", numberOfPurchases: 3, isReturningCustomer: true) 

couponChecker.handle(request: request) // returns true

The Chain of Responsibility pattern is a powerful tool for breaking down complex behavior into smaller, more manageable pieces. By using protocols and chaining objects together, we can easily create chains of objects that can process requests in a structured and organized way. With the power of the Chain of Responsibility pattern, you can unlock the power of programming and create more robust and maintainable code.

Scroll to Top