Kotlin 惯用的方式来转发来自不同类的属性

Question

如示例：

class A {    
    var value: String
    get() = "value"
    set(value) { println(value) }
}

class B {
    val a = A()
    var value = a.value
}

fun main(args: Array<String>) {
    B().value = "new value"
}

B.value 只用A.value.get 初始化，所以A.value.set 在main 函数的赋值过程中当然不会被调用，因此不会将消息打印到控制台。

我寻找的是允许将get 和set 函数转发到基于相同类型的不同对象属性的新变量的语法。

我设法实现了这样的委托，但它依赖于 kotlin-reflect 库（调用 getter 和 setter），我想避免这种情况：

import kotlin.reflect.KProperty
import kotlin.reflect.KMutableProperty

class Forward<T> (private val originalProperty: KProperty<T>){
    operator fun getValue(thisRef: Any?, property: KProperty<*>): T {
        return originalProperty.getter.call()
    }
}

class ForwardMutable<T> (private val originalProperty: KMutableProperty<T>){
    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
        originalProperty.setter.call(value)
    }

    operator fun getValue(thisRef: Any?, property: KProperty<*>): T {
        return originalProperty.getter.call()
    }
}

fun <T> forward(originalProperty: KProperty<T>) = Forward(originalProperty)
fun <T> forward(originalProperty: KMutableProperty<T>) = ForwardMutable(originalProperty)

class A {
    var value: String
        get() = "value"
        set(value) { println(value) }
}

class B {
    val a = A()
    var value by forward(a::value)
}

fun main(args: Array<String>) {
    B().value = "new value" // calls A.value.setter
}

没有为此目的的内置委托吗？如果没有，如何避免kotlin-reflect 依赖？

Answer 1

也许我误解了一些东西，但是，如果您能够提取要委托给内部实例的变量的接口，那么为什么不直接使用委托呢？

interface SomethingWithValues{
    var value: String
    var value2: String
    var value3: String
}

class A : SomethingWithValues{
    override var value: String = "value"
        set(value) {print(value)}
    override var value2: String = "value2"
        set(value) {print(value)}
    override var value3: String = "value3"
        set(value) {print(value)}
}

class B(val a:A = A()): SomethingWithValues by a

fun main(args: Array<String>) {
    val b = B()
    b.value = "new value"
    b.value2 = "new value2"
    b.value3 = "new value3"
}

Answer 2

如果thisRef 必须与Any 一样通用，那么我认为您无法在没有反射的情况下访问其属性。

如果您愿意引入额外的接口，您可能可以按照以下方式做一些事情：（仍然存在对 kotlin.reflect 的导入依赖，但这是 Delegate API 所要求的）

import kotlin.reflect.KProperty

interface HasA<T> {
    val a: ValueAccessor<T>
}

interface ValueAccessor<T> {
    var value: T
}

class ForwardMutable<T> {
    operator fun setValue(thisRef: HasA<T>, property: KProperty<*>, value: T) {
        thisRef.a.value = value
    }

    operator fun getValue(thisRef: HasA<T>, property: KProperty<*>): T {
        return thisRef.a.value
    }
}

class A : ValueAccessor<String> {
    override var value: String = "value"
}

class B : HasA<String> {
    override val a = A()
    var value by ForwardMutable<String>()
}

fun main(args: Array<String>) {
    val b = B()
    b.value = "new value" // calls A.value.setter
    print(b.value)
}