Flex Strongly Typed Proxy Classes for Lazy Instantiation

Question

Does anyone know of a framework, preferably some way to have the Flex compiler run an extension or perhaps just a build step that we could generate strongly typed proxy classes of our application's data models.

There are 2 main things we want to do with the proxy's:

1. At runtime we want to lazily parse and instantiate the instance as accessed (similiar to how Java's Hibernate has Lazy proxy objects)
2. In an editor application we want to implement setter calls so we can track which objects have been modified
   • The Proxy is really necessary in this situation beyond things like programatically setting up ChangeWatcther's because we need to track Array adds/remove and possibly track "reference" objects so that when a "reference key" is changed we know to save those objects that are referencing it by key

In the first case we want the proxy to basically abstract when that object is loaded from serialized data, but still pass around references of it with the same public properties and data access pattern if it were the real object.

Basically the proxy would instantiate the object the first time a method is called on it.

I know we could use some AS3 byte-code libraries like as3-commons-bytecode.

Or possibly repurposing the GraniteDS Code Generation.

I'd prefer to generate code because it is a deterministic thing and it'd be nice if we could have a way to debug it at runtime easier.

Does anyone know if I could do something like MXMLC does when it generates AS3 code from MXML files.

Also is there anyway to control "when" in the compilation pipeline I can generate code, because we have a lot of data objects using public fields instead of getter/setters, but that are [Bindable] and so if I could generate the proxy based on the generated getter/setter methods that would work.

Here's an example application data object and proxy classes:

[Bindable]
public class PersonDTO implements Serializable {
    private var _name:String;

    private var _age:Number


    public function get age():Number {
        return _age;
    }

    public function set age(a:Number):void {
        _age = a;
    }

    public function get name():String {
        return _name;
    }

    public function set name(n:String):void {
        _name = n;
    }

    public void readObject(data:*) {
        //...
    }

}

// GENERATED CLASS BASED ON PersonDTO
public class LazyProxy_PersonDTO extends PersonDTO {

    private var _instance:PersonDTO = null;
    private var _instanceData:*;

    private function getInstance():void {
        if (_instance == null) {
            _instance = new PersonDTO();
            _instance.readObject(_instanceData);
        }
    }

    override public function get age():Number {
        //Ensure object is instantiated
        return getInstance().age;
    }

    override public function get name():String {
        //Ensure object is instantiated
        return getInstance().name;
    }

}

// GENERATED CLASS BASED ON PersonDTO
public class LogChangeProxy_PersonDTO extends PersonDTO {

    //This will be set in the application
    public var instance:PersonDTO;

    //set by application
    public var dirtyWatcher:DirtyWatcherManager;

    override public function set age(a:Number):void {
        dirtyWatcher.markAsDirty(instance);
        instance.age = a;
    }

}

Answer 1

Digging a little deeper into AS3-Commons byte code library it looks like they support generating proxy classes and interceptors.

• http://www.as3commons.org/as3-commons-bytecode/proxy.html

  public class DirtyUpdateInterceptor implements IInterceptor {
  
  public function DirtyUpdateInterceptor() {
      super();
  }
  
  public function intercept(invocation:IMethodInvocation):void {
      if (invocation.kind === MethodInvocationKind.SETTER) {
          if (invocation.arguments[0] != invocation.instance[invocation.targetMember]) {
              invocation.instance.isDirty = true;
          }
      }
  }
  }