So what can you use delayedInit for safely? - scala

Question

Having read various posts on delayedInit, I was surprised to learn that it's actually called each time by the various subclasses during construction. I wasn't sure I believed this but then I made the test below. Anyhow, my question is that delayedInit sounded like a useful mechanism to drive some kind of final action from an abstract class (for example, perhaps notifying another object of creation complete). And this would make sense, if it were only called once.
But how can any kind of useful construct be made from a function if you risk it being called repeatedly without any other useful information being passed in it's parameters? How could I program it to only fire at the last level of construction, without necessarily knowing how deeply class A has been extended?
object LearnDelayedInit extends App {
class A extends DelayedInit {
def delayedInit(x: => Unit) {
x // call constructor code
println("delayed init called")
}
}
class B extends A {
println("Hello from B")
}
class C extends B {
println("hello from C")
}
val c = new C
}
Output:
Hello from B
delayed init called
hello from C
delayed init called

Answer 1

If you make the hierarchy out of traits and only the leaf type a class you will get the behavior you want:
object LearnDelayedInit extends App {
trait A extends DelayedInit {
def delayedInit(x: => Unit) {
x //call constructor code
println("delayed init called")
}
}
trait B extends A {
println("Hello from B")
}
class C extends B {
println("hello from C")
}
val c = new C
}
Only the initialization code for classes is wrapped and passed to delayedInit, traits have their initialization code run in the constructor as usual.

Answer 2

Here you go.
The future stuff is just for flair.
The basic idea is that the val done is initialized exactly once, in the initializer of C or whatever the bottom class is.
You have read the one question in The One Question FAQ, I suppose.
object Test extends App {
import java.util.concurrent.{ CountDownLatch => Latch }
trait FutureInit {
import concurrent._
import ExecutionContext.Implicits._
private var fs = future(())
def done: Boolean
val latch = new Latch(1)
def delayedInit(x: => Unit) {
fs = fs andThen {
case _ =>
x
if (done) { println("All done!") ; latch.countDown() }
}
}
}
class A extends DelayedInit with FutureInit {
println("Hello from A")
Thread sleep 500L
override val done = true
}
class B extends A {
println("Hello from B")
Thread sleep 500L
override val done = true
}
class C extends B {
println("hello from C")
Thread sleep 500L
override val done = true
}
val c = new C
c.latch.await()
println("Good bye.")
val b = new B
b.latch.await()
println("That's all, folks. Go home.")
}