Design Patterns in Swift: Visitor Pattern Explained

By /

Design Patterns in Swift: Visitor Pattern Explained

Design patterns are an important part of software development. They help create reusable, maintainable and extensible code. The Visitor pattern is a behavioral design pattern used when you want to add new functionality to existing classes without modifying their code. In this blog post, we will look at how to implement the Visitor pattern in Swift.

First, let’s look at what the Visitor pattern is and why it is useful. The Visitor pattern allows you to define a new operation on an existing object structure without changing the classes of the elements that make up the structure. This is useful when you need to add new behavior to existing classes but don’t want to modify their code.

The Visitor pattern is composed of two main components: the Visitor and the Element. The Visitor is an abstract class or interface that contains a single method for each type of element in the object structure. The Element is an abstract class or interface that contains an accept() method. This method takes a Visitor as an argument and calls the appropriate visit() method on the visitor.

Let’s look at an example to better understand the Visitor pattern. Suppose we have a class called Shape that has two subclasses: Circle and Rectangle. We want to add a new operation to these classes that calculates the area of the shape. To do this, we can use the Visitor pattern.

First, we create an interface called Visitor with a single method for each type of shape: 

protocol Visitor {
    func visit(circle: Circle)
    func visit(rectangle: Rectangle)
}

Next, we create an abstract class called Shape with an accept() method that takes a Visitor as an argument: 

abstract class Shape {
    func accept(visitor: Visitor)
}

Finally, we create concrete subclasses of Shape for each type of shape: 

class Circle: Shape {
    var radius: Double
    
    init(radius: Double) {
        self.radius = radius
    }
    
    override func accept(visitor: Visitor) {
        visitor.visit(circle: self)
    }
}

class Rectangle: Shape {
    var width: Double
    var height: Double
    
    init(width: Double, height: Double) {
        self.width = width
        self.height = height
    }
    
    override func accept(visitor: Visitor) {
        visitor.visit(rectangle: self)
    }
}

Now that we have our Shape classes set up, we can create a Visitor that implements the visit() methods for each type of shape. In this case, we will create a visitor that calculates the area of the shape: 

class AreaVisitor: Visitor {
    var totalArea = 0.0
    
    func visit(circle: Circle) {
        totalArea += 3.14 * (circle.radius * circle.radius)
    }
    
    func visit(rectangle: Rectangle) {
        totalArea += rectangle.width * rectangle.height
    }
}

Once we have our AreaVisitor class, we can use it to calculate the area of any shape. All we need to do is create an instance of the AreaVisitor and call the accept() method on the Shape we want to calculate the area of: 

let circle = Circle(radius: 5.0)
let rectangle = Rectangle(width: 10.0, height: 5.0)

let areaVisitor = AreaVisitor()

circle.accept(visitor: areaVisitor)
rectangle.accept(visitor: areaVisitor)

print(areaVisitor.totalArea) // prints 78.5

In this example, we used the Visitor pattern to add a new operation (calculating the area of a shape) to our existing Shape classes without modifying their code.

The Visitor pattern is a powerful tool for adding new behavior to existing classes. It is especially useful when you need to add new operations to a large number of classes without making changes to their code. It also makes it easy to add new types of visitors without having to modify the existing classes.

In summary, the Visitor pattern is a behavioral design pattern used when you want to add new functionality to existing classes without modifying their code. It is composed of two main components: the Visitor and the Element. The Visitor contains a single method for each type of element in the object structure, and the Element contains an accept() method that calls the appropriate visit() method on the visitor. The Visitor pattern is a powerful tool for adding new behavior to existing classes without making changes to their code.

Scroll to Top