Delegation VS Fowarding

[AizazZaidee]

Hi,
Is the following solution is correct with respect to Forwarding and Delegation?

Q: Implement forwarding and delegation semantics in the method m() in the respective classes.

Code: Alles auswählen

trait Base {
    def m();
    def f();
}

class Callee extends Base{
    override def m(): Unit = {
        m(this)
    }

    override def f(): Unit = {}

    def m(self: Base): Unit ={
        self.f()
    }
}

class OtherClassForwarding extends Base {
    var callee = new Callee

    override def m(): Unit = {
        //Forwarding
        super.m()
    }

    override def f(): Unit = {}
}

class otherClassDelegation extends Base{
    var callee = new Callee

    override def m(): Unit = {
        //Delegation
        callee.m(this)
    }

    override def f(): Unit = {}
}

[eichberg]

Hi,it goes in the right direction. But, you are only implementing the required infrastructure for m. Furthermore, the override in OtherClassForwarding is useless.

[topracer]

I guess that for forwarding semantics it is

Code: Alles auswählen

class OtherClassForwarding extends Base {
	...
	def m() {
		callee.m()
	}
}

because the object tells callee just to do something and callee does it for itself, without caring about the OtherClassForwarding object anymore.

And for delegation

Code: Alles auswählen

class OtherClassDelegation extends Base {
	...
	def m() {
		callee.m(this)
	}
}

because the object orders callee to do something (but not without attaching a "backup reference" to itself) which in return sends a "receipt" (or whatever) back to the OtherClassForwarding object.

Is that correct?