Half the time Bindgen does not understand generics and just leaves the building…

The JPA2 solution doesnt chain properties :( so you cant say new PersonBinding().address().state().code(), instead you woul dhave to do something like:
new EntityBinding(Person_.address, Address_.state, State_.code) which is more error prone. And as you said, it only works for Entities.

I’ve just been glancing at it so I don’t know if this can be a complete solution. If it can just be used directly with the PropertyModel, or even if you can get complex property strings out of it (or even if you’d want to).

It is possible with a PropertyModel. BindingModel is exactly the same as the PropertyModel, the only exception being that it uses a type-safe expression instead of a string to specify the property.

In that case I would just do:

object personModel extends IModel[Person] {
var p = Person(Address(“first”))
def getObject = p
def setObject(p: Person) = { this.p = p }
}

model.getObject
// here i would obtain first

personModel.setObject(Person(Address(“second”)))

model.getObject
// here i would obtain second

But most probably I can’t see in which cases I would benefit from that (a “generic safe street model” :). And afaik that is not possible with PropertyModel, or is it?

Anyways, in general I tend to avoid setters whenever possible… they’re evil =)

Person bob=new Person("bob");
Person john=new Person("bob");

IModel model=new BindingModel(person, new
PersonBinding().address().street());

model.getObject() <== bob.getAddress().getStreet();
model.setObject(john);
model.getObject() <== john.getAddress().getStreet();

Sure. I haven’t really thought about that, but I guess it could be solved with an implicit conversion?

So instead of:

val model = new SafePropertyModel(p.address.street)

by introducing the following (or mixing-in a trait with it):

implicit def m2o[A](model: IModel[A]): A = model.getObject

we can now invoke the expression on a model:

// this is a concrete instance of a person model
object personModel extends IModel[Person] {
def getObject = Person(Address(“My model’s street”))
}

val model = new SafePropertyModel(personModel.address.street)

Now,

assert(model.getObject == “My model’s street”)
println(model.getObject)

All it does is convert under the hood a model to an object when needed. Is this what you meant?

Francisco

your code says p.address.street which, with my non-existant knowledge of all things Scala, creates a lambda expression to be avaluated later? but, the expression is tied to a specific instance of the root object “p”. can you show an easy way to achieve the same but with interchangeable “p”? so in other words:

new BindingModel(personModel, new PersonBinding().address.street())

the above creates a “address.street” expression that is evaluated against which ever “p” is provided by the personModel…