Template Method Pattern

Using Swift
12

OK. Asking the question has stimulated the brain cells. Here goes with a stab at something :

internal protocol InternalMethods
{
  static func beforeExecute(sender: Base)
  
  static func doExecute(sender: Base)
  
  static func afterExecute(sender: Base)
}


public class Base
{
  internal var beforeExecute: ((Base) -> ())?
  
  internal var doExecute: ((Base) -> ())?
  
  internal var afterExecute: ((Base) -> ())?
  
  func execute()
  {
    beforeExecute?(self)
    
    doExecute?(self)
    
    afterExecute?(self)
  }
}


public class Derived : Base, InternalMethods
{
  internal class func beforeExecute(sender: Base)
  {
    print("Derived beforeExecute")
  }
  
  internal class func doExecute(sender: Base)
  {
    
    print("Derived doExecute")
  }
  
  internal class func afterExecute(sender: Base)
  {
    print("Derived afterExecute")
  }
  
  override init()
  {
    super.init()
    
    beforeExecute = type(of: self).beforeExecute
    
    doExecute = type(of: self).doExecute
    
    afterExecute = type(of: self).afterExecute
  }
}


public class FurtherDerived : Derived
{
  override class func beforeExecute(sender: Base)
  {
    super.beforeExecute(sender: sender as! FurtherDerived)
    
    print("FurtherDerived beforeExecute")
  }
  
  override class func doExecute(sender: Base)
  {
    super.doExecute(sender: sender as! FurtherDerived)
    
    print("FurtherDerived doExecute")
  }
  
  override class func afterExecute(sender: Base)
  {
    super.afterExecute(sender: sender as! FurtherDerived)
    
    print("FurtherDerived afterExecute")
  }
}