Ashley : Delegate for SubProperty

[pylvain]

I made another property Delegate and an overload to the propertyFor function to go with it :

data class Named(var name:String) : Component

var Entity.name by propertyFor(Named::name)

val e = Entity()
e += Named("Joe") 
e.name = "John"
println(e.name) // John

Very useful on components with a single argument IMO.
I'll be happy to submit a PR is this is deemed useful.

I don't know if there is a need for an optionalPropertyFor function : It will behave the same if the value of the subproperty is null and if the component itself doesn't exit. If the subproperty is non nullable, there is no problem though.

[czyzby]

It does seem quite useful, but there are some things to consider:

• Should we differentiate between lack of a component and a null property value?
• What happens if the user assigns a value, but the component is missing?

[pylvain]

I haven't tried it yet on my projects, so i can't know for sure, here are my opinions for now :

• I think an exception should be thrown if the component is missing for the function propertyFor.
• In a function optionalPropertyFor we shouldn't differentiate between lack of component and null property value. If the property value is not nullable, there is no problem. If it is, it's just bad practice, or the user knows what he is doing.
• If the user assign a value on a missing component, we throw an Exception since that should never happen.

I won't be able to make a PR soon, by this time, maybe the answer will be obvious.

[czyzby]

I'm not a fan of APIs that throw exceptions so easily and basically do not expose any way to check for possible failures on their own. I'll play around with the implementation and see if we can add something more flexible easily.

[pylvain]

Here is the implementation for now :

class SubPropertyDelegate<T : Component, V>(
    private val mapper: ComponentMapper<T>,
    private val componentProperty: KProperty1<T,V>
) {
    operator fun getValue(thisRef: Entity, property: KProperty<*>) =
        componentProperty.get(mapper[thisRef])

    operator fun setValue(thisRef: Entity, property: KProperty<*>, value: V) {
        (componentProperty as KMutableProperty1<T,V>).set(mapper[thisRef],value)
    }
}

inline fun <reified T:Component, V> propertyFor(property: KProperty1<T,V>) =
    SubPropertyDelegate(mapperFor(),property)

In both cases (get/set without component existing), we get a nullpointer exception.
I don't know if it's obvious enough, maybe it can be modified to be more obvious. I'll see what I can do.

[czyzby]

I'm not sure if this utility is needed. Extracting a component from an entity is one thing, but getting into nested properties is a slippery slope. I know it makes for a nice one-liner, but what you've posted could be easily handled by a regular extension property that would be much more efficient (no reliance on reflection) and easier to customize in terms of null handling. A quick example:

data class Named(var name: String): Component
private var Entity.named by optionalPropertyFor<Named>()
var Entity.name: String?
  get() = named?.name
  set(value) {
    if (value == null) { named = null }
    else if (named != null) { named?.name = value }
    else { named = Named(value) }
  }

It might be more verbose, but it allows the user to fully specify how the missing values are handled. Perhaps if we added more customization to the property (such as a NullHandlingStrategy parameter?) it would be a bit better, but I'm not sure if it's that's worth the effort.

[pylvain]

Ran some benchmarks, it's 3 times slower with reflection. I think i'll drop the idea.