Question

I need to execute some code after the subclass already did all it’s initialization, for example:

abstract class A(a:String) {
  var sum = 0
  def add(n:Int) = { sum += n; sum }
  def verify = if (sum > 10) () else throw new Exception
  ... initialize subclass ...
  verify
}
class B extends A("In A") { 
  val smth = add(50)
  // I want to avoid calling `verify` here
}
val b = new B
println(b.smth) // 50

Is there a way to do it?

Answer 1

So it seems I found the answer. I decided to go with the DelayedInit trait approach – I just execute the delayed code (and count number of times it was executed), then execute the needed code when I think that I’ve seen enough initializations (one for each class in the extension hierarchy). I wrapped it into a trait:

trait AfterInit extends DelayedInit {
  def afterInit
  private var initCount = 0
  private def getInitNumber(clazz: Class[_]):Int =
    if (clazz.getSuperclass == classOf[java.lang.Object]) 0 else getInitNumber(clazz.getSuperclass) + 1
  final def delayedInit(x: => Unit) {
    x
    initCount += 1
    if (getInitNumber(this.getClass) + 1 == initCount) afterInit
  }
}

Usage:

abstract class A(id:String) extends AfterInit {
  var sum = 0
  def add(n:Int) = { sum += n; sum }
  def afterInit = if (sum > 10) () else throw new Exception
}

class B extends A("B") {
  val add1 = add(50)
}
new B // no exception

class C extends A("C") {
  val add2 = add(5)
}
new C // exception is thrown, since the `sum` was too small