• Ender KaShae <astrothayne gmail.com> Aug 19 2007

Ender KaShae <astrothayne gmail.com> writes:

Christopher Wright Wrote:

 


 when read the property will actually return a special wrapper that sends
itself to the writer whenever it is assigned to 
 the address of the property cannot be used as a function or delegate, but can
be used as the address of the type 


 The address of the property should be an address to a property struct, 
 whose getters and setters would work as usual.
 
 Hm...
 
 ---
 class Property(T) {
     T* value;
     public void opIncrement() { *value++; }
     public void opDecrement() { *value--; }
     public T opAdd(U) (U addend) { return *value + addend; }
     // ...
 }
 
 class MyClass {
 private:
     int _x;
 public:
     Property!(int) X;
     this() {
        // slightly ugly...
        X = new Property!(int)(&_x);
     }
 }
 ---
 
 If you could overload the dot operator as well, then this and some 
 template magic with __traits would give you everything you want.
 
 Without the dot operator, you get everything you need anyway for basic 
 types. And classes are already taken care of. Structs are left out, though.


The problem with that approach is it would be difficult to specify any special
behavior for the properties (which is an important feature of properties), or
am I just missing something.

Actually something more like:
----
struct Property(Type){
    Type delegate() getter;
    void delegate(Type) setter;
    Type opPostIncrement(){
        scope temp = getter();
        setter(getter() + 1);
       return temp;
    }
etc...
}

would work pretty well