Design Pattern: Composite in Swift: A Guide to Building Structures

By /

Design Pattern: Composite in Swift: A Guide to Building Structures

Design Patterns are a powerful tool for developers to build robust and maintainable software. Among the most popular is the Composite Pattern, which allows developers to create structures of objects in a tree-like manner. In this article, we’ll explore the Composite Pattern in the context of Swift programming language, with examples of how to use it in your own projects.

The Composite Pattern is a structural design pattern that allows developers to create structures of objects in a tree-like manner. The pattern is composed of two main components: the Component, which is the base interface for all objects in the structure, and the Composite, which is a component that contains other components. The Composite is responsible for managing the components it contains and providing an interface for manipulating the components.

Let’s look at a simple example of the Composite Pattern in Swift. We will create a basic data structure containing a collection of objects. We’ll call this data structure “Tree”. The Tree will have two components: a Root, which is the top-level object in the structure, and a Node, which is a child of the Root.

First, we’ll define the Component protocol: 

protocol Component {
    func add(component: Component)
    func remove(component: Component)
    func getChild(at index: Int) -> Component?
}

The Component protocol provides methods for adding and removing components from the structure, as well as getting a specific component from the structure.

Next, we’ll define the Root and Node classes. The Root class will implement the Component protocol, while the Node class will not. 

class Root: Component {
    private var components: [Component] = []

    func add(component: Component) {
        components.append(component)
    }

    func remove(component: Component) {
        if let index = components.firstIndex(of: component) {
            components.remove(at: index)
        }
    }

    func getChild(at index: Int) -> Component? {
        guard index >= 0 && index < components.count else { return nil }
        return components[index]
    }
}

class Node: Component {
    private weak var parent: Root?
    private var value: Int

    init(value: Int, parent: Root) {
        self.value = value
        self.parent = parent
    }

    func add(component: Component) {
        parent?.add(component: component)
    }

    func remove(component: Component) {
        parent?.remove(component: component)
    }

    func getChild(at index: Int) -> Component? {
        return parent?.getChild(at: index)
    }
}

The Root class implements the Component protocol by maintaining an array of its children components. The add and remove methods simply add or remove components from the array. The getChild method returns the component at the given index.

The Node class is a bit more complex. It has an instance variable for the parent, which is a reference to the Root object. It also has an instance variable for the value, which is an integer value associated with the Node. The Node class also implements the Component protocol, but delegates the methods to its parent. This allows the Node to be manipulated from the Root.

Now that we have our classes defined, let’s create a Tree object and add some Nodes to it: 

let tree = Root()
let node1 = Node(value: 1, parent: tree)
let node2 = Node(value: 2, parent: tree)
let node3 = Node(value: 3, parent: tree)

tree.add(component: node1)
tree.add(component: node2)
tree.add(component: node3)

The code above creates a Root object and three Node objects. We then add the Node objects to the Root using the add method. The Tree now looks like this:

Tree Structure

We can now manipulate the Tree structure using the methods defined in the Component protocol. For example, we can remove a Node from the Tree: 

tree.remove(component: node2)

The Tree now looks like this:

Tree Structure with Node Removed

We can also get a specific Node from the Tree: 

if let node = tree.getChild(at: 1) as? Node {
    print(node.value) // Prints "3"
}

The Composite Pattern is a powerful tool for creating structures of objects in a tree-like manner. By defining a Component protocol and providing implementations of the protocol’s methods, you can easily create objects that can be manipulated in a consistent manner. In addition, the Composite Pattern makes it easy to extend the structure by adding new components.

In this article, we explored the Composite Pattern in the context of Swift programming language. We looked at how to define the Component protocol and how to create Root and Node classes that implement the protocol. We also saw how to create a Tree structure and manipulate it using the Component protocol. With the Composite Pattern, you can easily create structures of objects in a tree-like manner.

Scroll to Top