Swift : Create a multi-function multicast delegate

Question

I'm wanting to use a multicast delegate to inform multiple objects when things change. The tutorials I've read that explain this, have a protocol that only has one function that is called directly on the array of delegates. That works fine when there is only one function defined. My Protocol has 6 functions. I want to avoid creating 6 separate functions and reuse a single function that can be applied to my array of delegates.

Quick example: (I understand this is none working, but I just want to get my idea across.

protocol MyProtocol {
 func method1()
 func method2()
 func method3()
}


class TestClass {
  var delegates = [MyProtocol]()

  func invokeDelegates(delegateMethod: () -> ()) {
    for delegate in delegates {
      delegate.delegateMethod()
    }
  }
}

The obvious problem is the compiler complains that "delegateMethod" isn't defined in the original protocol. Is there a way that I cast the method as being part of MyProtocol and the compiler will trust me?

Is this even possible?

Answer 1

Here is a gist of an Multicast Delegate pattern that I use in my projects. It also prevents from having strong reference cycles (memory leaks). WeakWrapper handles this.

Ok. In some of the solutions I see mistakes (strong retain cycles, race conditions, ...)

Here is what I combine based on 1 day research. For the stack of delegates I used NSHashTable, so all the delegates are having weak reference.

class MulticastDelegate <T> {
  private let delegates: NSHashTable<AnyObject> = NSHashTable.weakObjects()

  func add(delegate: T) {
    delegates.add(delegate as AnyObject)
  }

  func remove(delegate: T) {
    for oneDelegate in delegates.allObjects.reversed() {
      if oneDelegate === delegate as AnyObject {
        delegates.remove(oneDelegate)
      }
    }
  }

  func invoke(invocation: (T) -> ()) {
    for delegate in delegates.allObjects.reversed() {
      invocation(delegate as! T)
    }
  }
}

func += <T: AnyObject> (left: MulticastDelegate<T>, right: T) {
  left.add(delegate: right)
}

func -= <T: AnyObject> (left: MulticastDelegate<T>, right: T) {
  left.remove(delegate: right)
}

How to set delegate:

object.delegates.add(delegate: self)

How to execute function on the delegates: instead of

delegate?.delegateFunction

you use

delegates.invoke(invocation: { $0.delegateFunction })

Answer 2

You need to change the signature of invokeDelegates to take a closure of type (MyProtocol) -> (), and then you need to pass each delegate to the closure.

protocol MyProtocol {
    func method1()
    func method2()
    func method3()
}

class TestClass {
    var delegates = [MyProtocol]()

    func invokeDelegates(delegateMethod: (MyProtocol) -> ()) {
        for delegate in delegates {
            delegateMethod(delegate)
        }
    }
}

The closure should just invoke the appropriate delegate method on its argument. Swift can infer the argument and return types of the closure, and you can use the shorthand $0 to refer to the argument, so the closure can be quite short:

let tester = TestClass()
tester.invokeDelegates(delegateMethod: { $0.method1() })

On the other hand, you could just use Collection.forEach directly on the delegates array (if it's accessible) and skip the invokeDelegates method:

tester.delegates.forEach { $0.method1() }