First, we create our abstract class, which both VODItem and VODCategory will inherit form. This class will provide the interface for the leaf nodes and composite nodes. Swift doesn't support an abstract class; nevertheless, nothing should prevent us from implementing the default behavior onto our methods, such as informing that a method is not supported using an assert. An assert will just inform us that if it is used in an inappropriate class, then the method will not be supported. We could write our "fake" abstract class like this:

// Abstract Class

class VODComponent {
  
  func add(vodComponent: VODComponent) {
    assert(false, "This method is not supported")
  }
  
  func remove(vodComponent: VODComponent) {
    assert(false, "This method is not supported")
  }
  
  func getName() -> String {
    assert(false, "This method is not supported")
  }
  
  func getDescription() -> String {
    assert(false, "This method is not supported")
  }
  
  func getPrice() -> Double {
    assert(false, "This method is not supported")
  }
  
  func getChild(i:Int) -> VODComponent {
    assert(false, "This method is not supported")
  }
  
  func display() {
    assert(false, "This method is not supported")
  }
}

Our component class is ready; a default behavior is available for each method. We can now implement our VODItem class. It is a leaf class in the composite diagram and implements the behavior of the elements of the composite:

class VODItem: VODComponent {
  private var name: String!
  Private var description: String!
  private var price: Double!
  
  init(name:String!, description:String!, price:Double!){
    self.name = name
    self.description = description
    self.price = price
  }
  
  override func getName() -> String {
    return name!
  }
  
  override func getDescription() -> String {
    return description!
  }
  
  override func getPrice() -> Double {
    return price!
  }
  
  override func display() {
    print(" (name!), (price!),  ----  (description!)")
  }
}

See how I have defined the private variables with !. This means that the values of these variables cannot be nil after initialization. This is true because we added a constructor (the init method) where all our arguments must be passed to initialize our private fields.

Then, we override only methods that interest us. The Add/Remove and GetChild methods don't need to be overridden here; this will be done in the composite class.

To ensure that each name, description, and price has a value, we added an exclamation mark to unwrap it.

It is now time to implement our composite category class. We will call this composite class: VODCategory. It will hold VODItems or VODCategory. You'll see that again we will override only methods that interest us in this class. The getPrice() method will not interest us as it doesn't make sense.

The first shot of the VodCategory class could be written as follow:

class VODCategory: VODComponent{
  var vodComponents = [VODComponent]()
  private var name: String!
  private var description: String!
  
  init(name:String!, description:String!) {
    self.name = name
    self.description = description
  }
  
  override func add(vodComponent: VODComponent) {
    vodComponents.append(vodComponent)
  }
  
  override func remove(vodComponent: VODComponent) {
    vodComponents.remove(vodComponent)
  }
  
  override func getChild(i:Int) -> VODComponent {
    return vodComponents[i]
  }

  override func getName() -> String {
    return name!
  }
  
  override func getDescription() -> String {
    return description!
  }

  override func display() {
    print(" (name!),  (description!) 
 ----------------")
  }
}

Well, as with VODComponent, we override the methods that interest us. As we can have any number of VODComponent, we add an array of type VODComponent to hold them.

We added the Add, Remove, and GetChild methods. The Add method will allow us to add an item, category, or subcategory. We can also remove it and return a VODComponent class based on its index.

Again, we can add a name and description to our composite that will be displayed when the display() method will be invoked.

Let's take a look at the following code:

  override func remove(vodComponent: VODComponent) {
    vodComponents.remove(vodComponent)
  }

If you write it like the preceding code, you'll get an error because Swift doesn't provide a remove method for the Array type.

It's time to make some modifications in our implementation and introduce you to the use of extensions.

Our problem is that we want to be able to remove an object of the type VODComponent to our vodComponents array using a method called remove (or anything else), where we pass an object that represents the object we want to remove from the list.

If we check the available method when the auto-completion is displayed, we do not see any method that can help us in this purpose, as shown in the following screenshot:

In Chapter 2, Structural Patterns – Decorator, Proxy, and Bridge, you could have used the decorator pattern to add such methods to the Array type; you can also propose to simply add a method to the class that will test all the elements in the array by comparing them one by one, and if they are identical, remove them from the list.

What we want is something that can be reused and generic. For this, Swift has extension. This permits you to add a behavior to a class very easily. Let's do it by adding a remove method to the type Array.

The extension must not be added to a class. Indeed, extensions are global. If you add extensions to an OS X or iOS project, you'll generally add them to a dedicated Swift file.

Here is our extension:

extension Array {
  mutating func remove <T: Equatable> (object: T) {
    for i in (self.count-1).stride(through: 0, by: -1) {
      if let element = self[i] as? T {
        if element == object {
          self.removeAtIndex(i)
        }
      }
    }
  }
}

As this function modifies the instance of the Array type and its properties, we mark this function as mutating. Then, we start from the end of the list and compare the elements that we want to find in the current elements of the list:

      if let element = self[i] as? T {
        if element == object {
          self.removeAtIndex(i)
        }
      }

Again, here there are some tricky things to do to make this code without any error. This function tells that we want that Array of type T must implement Equatable (is said with remove <T: Equatable> ) to be able to make the comparison:

        if element == object {

Therefore, we need to modify our abstract class, telling that our class implements the Equatable protocol:

class VODComponent : Equatable {
  
  func add(vodComponent:VODComponent){
    assert(false, "This method is not supported")
  }

Of course, adding this protocol modifies our class diagram a little, but no matter. By implementing this protocol we are telling that elements of type VODComponent can be compared using == and !=.

If this is not completed, then we need to implement this protocol, so the best way to do this is by making a global function outside any class:

// GLOBAL Func
func ==(left: VODComponent, right: VODComponent) -> Bool {
  return left === right
}

So, now, all the code required for this class is written; the remove method is available and works perfectly.

Some improvements need to be added to our class to fully complete the implementation of the composite.

Have you seen how we implemented the display method in our composite (VODCategory) ? Indeed, the display() method of the composite only displays the information about itself, but it must invoke the display() method of each element that is contained in the composite. To do this, we will simply add a small part of the code that will iterate all elements that the composite contains in its array by adding a call to their respective display() methods.

Let's change the display() method of the VODCategory class to add an iteration to all our elements:

//VODCategory
class VODCategory:VODComponent{
  
…
  override func display() {
    print(" (name!),  (description!) 
 ----------------")
    for e in vodComponents{
        e.display()
    }
  }
}

So, we iterate over each element of the array using for … in and call the display() method of each element.