Calling (base) delegated function when using class delegation from within override

Question

When overriding an interface method implemented by class delegation, is it possible to call the class which is normally delegated to from within an overriding function? Similar to how you would call super when using inheritance.

From the documentation:

interface Base {
    fun print()
}

class BaseImpl(val x: Int) : Base {
    override fun print() { print(x) }
}

class Derived(b: Base) : Base by b

fun main(args: Array<String>) {
    val b = BaseImpl(10)
    Derived(b).print() // prints 10
}

Note that overrides work as you might expect: The compiler will use your override implementations instead of those in the delegate object.

override fun print() { ... }

How to call the BaseImpl print() function from within this overridden function?

The use case is I want to add additional logic to this function, while reusing the existing implementation.

Answer 1

Since Base is an interface, you can't really call super on it (similar to Java).

Instead, you need to declare b as a field and use it directly:

class Derived(val b: Base) : Base by b {
    override fun print() {
        b.print()
        // ...
    }
}

Answer 2

@Egor's answer works and should be suitable when the class delegated to is passed as a paremeter (dependency injection).

However, in my more specific use case (apologies for not having made this clear in my question) the implementation is directly defined in the delegation definition.

class Derived(b: Base) : Base by BaseImpl()

In this case Egor's answer does not work and a more elaborate approach is needed. The following implementation can be used in case you want to keep the implementation hidden so that callers can not modify it. For example, in my specific use case I am creating an aggregate root and want to protect internal invariants.

open class HiddenBaseImpl internal constructor( protected val _b: Base ) : Base by _b

class Derived() : HiddenBaseImpl( BaseImpl() )
{
    override fun print()
    {
        _b.print()

        ... do something extra
    }
}

Since HiddenBaseImpl's primary constructor can only be used internally, callers of the library are unable to instantiate this class and are thus forced to use Derived. Derived can now call the class delegated to internally and add additional behavior without allowing callers to pass different implementations of Base.

Answer 3

You can only use super in Kotlin to access the superclass, no interfaces or other strange things (remember - Kotlin is running on the JVM). However, it is absolutely fine if you store the derivate instance in a variable, like Egor suggested in his answer.

To avoid that anybody can set or retrieve the variable, you can use a private (or protected, whatever suits your use case) primary constructor and add a second public constructor:

interface Base {
    fun print()
}

class BaseImpl() : Base {
    override fun print() { print(x) }
}

class Derived private constructor(private val b : Base) : Base by b {
    constructor() : this(BaseImpl())

    override fun print() = b.print()
}

fun main(args: Array<String>) {
    val d = Derived()
    d.b // does not work, compiler error
    d.print() // prints 10
}

Answer 4

I think I have a better solution for this. It is more elegant in sense of that there is no extra class needed and it does exactly the same as the approved one.

interface Base {
    fun print()
}

class Derived private constructor (private val delegate: Base): Base by delegate {
constructor(): this(BaseImpl())

    override fun print{
      delegate.print()
    }
}

Answer 5

I just want to add on to the solution for this case when using Dependency Injection.

You may use a secondary constructor to receive your injections, then use the primary constructor to construct your delegated object.

class BaseImpl(injectedObject: Object)

class Derived(
  private val baseImpl: BaseImpl,
): Base by baseImpl {
  
  // Used to construct your object by Dagger or any other DI Framework
  @Inject constructor(injectedObject: Object): this(BaseImpl(injectedObject))

  override fun print() {
    baseImpl.print()
    // Do your own thing
  } 
}

Answer 6

You could call directly function print() from property b, but for this purpose you need to change from simple constructor parameter b: Base to saving parameter as property private val b: Base

Hope this will help you.