Category: Introduction

Overriding accessor body creation

To completely override the creation of the getter and setter method bodies add listeners for the AccessorBuilderEvent.BUILD_GETTER and AccessorBuilderEvent.BUILD_SETTER events.
When either of these events are handled the IAccessorBuilder will delegate the creation of the IMethodBuilder instances to the event handlers assigned to these events.
In these event handlers logic can be placed to create a valid IMethodBuilder and its method body, after creation such an instance needs to be assigned to the AccessorBuilderEvent.builder property.

accessorBuilder.addEventLister(AccessorBuilderEvent.BUILD_GETTER, buildGetterHandler);
public function buildGetterHandler(event:AccessorBuilderEvent):void {
	var methodBuilder:IMethodBuilder = new MethodBuilder():
	//logic ommitted...
	event.builder = methodBuilder;
}

Generating methods

The IMethodBuilder interface supplies the required API to start adding methods to a generated class.

To receive an instance of this interface invoke the defineMethod() on the IClassBuilder instance:

var methodBuilder:IMethodBuilder = classBuilder.defineMethod("multiplyByHundred");

Setting visibility and namespaces on the method works the same way as for properties and accessors.

To define method arguments invoke the defineArgument() method:

var argument:MethodArgument = methodBuilder.defineArgument("int");

Further properties for an argument are isOptional and defaultValue, their names are self-explanatory.

By default a generated method has a return type of void, to change this set the returnType property:

methodBuilder.returnType = "int";

methodBuilder.addOpcode(Opcode.getlocal_0)
             .addOpcode(Opcode.pushscope)
             .addOpcode(Opcode.getlocal_1)
             .addOpcode(Opcode.pushint, [100])
             .addOpcode(Opcode.multiply)
             .addOpcode(Opcode.setlocal_1)
             .addOpcode(Opcode.getlocal_1)
             .addOpcode(Opcode.returnvalue);

public function multiplyByHundred(value:int):int {
  value = (value * 100);
  return value;
}

methodBuilder.defineArgument("Boolean");

var iffalse:Op = new Op(Opcode.iffalse,[0]);
var jump:Op = new Op(Opcode.jump,[0]);

methodBuilder.addOpcode(Opcode.getlocal_0)
             .addOpcode(Opcode.pushscope)
             .addOpcode(Opcode.getlocal_2)
             .addOp(iffalse)
             .addOpcode(Opcode.getlocal_1)
             .addOpcode(Opcode.pushbyte,[100])
             .addOpcode(Opcode.multiply)
             .addOpcode(Opcode.convert_i)
             .addOpcode(Opcode.setlocal_1)
             .addOp(jump)
             .defineJump(iffalse, new Op(Opcode.getlocal_1))
             .addOpcode(Opcode.pushshort,[1000])
             .addOpcode(Opcode.multiply)
             .addOpcode(Opcode.convert_i)
             .addOpcode(Opcode.setlocal_1)
             .defineJump(jump, new Op(Opcode.getlocal_1))
             .addOpcode(Opcode.returnvalue);

public function multiplyByHundred(value:int, reallyDoIt:Boolean):int {
  if (reallyDoIt) {
    value = value * 100;
  } else {
    value = value * 1000;
  }
  return value;
}

var source:String = (<![CDATA[
		     getlocal_0
		     pushscope
		     getlocal_2
		     iffalse L0
		     getlocal_1
		     pushbyte 100
		     multiply
		     convert_i
		     setlocal_1
		     jump L1
		     L0:
		     getlocal_1
		     pushshort 1000
		     multiply
		     convert_i
		     setlocal_1
		     L1:
		     getlocal_1
		     returnvalue
	]]>).toString();

methodBuilder.addAsmSource(source);

Any exceptions referenced in the opcode collection can be added using the defineExceptionInfo() method:

var exceptionInfoBuilder:IExceptionInfoBuilder = methodBuilder.defineExceptionInfo();

Other properties that can be set on the IMethodBuilder include:

• isOverride
• isFinal
• isStatic

Generating a constructor

By default a parameterless constructor is generated for the class, if a different constructor is needed invoke the defineConstructor() method and use the resulting ICtorBuilder instance to define it:

var ctorBuilder:ICtorBuilder = classBuilder.defineConstructor();

The ICtorBuilder instance works the same as an IMethodBuilder instance with the exception that any returnType or visibility assignments will be ignored.

Multiple calls to defineConstructor() will yield the same ICtorBuilder instance.

Generating metadata

Methods, properties, accessors and classes themselves can be annotated with metadata using an IMetadataBuilder instance:

var metadataBuilder:IMetadataBuilder = methodBuilder.defineMetadata("Inject");

To add arguments to the metadata definition invoke the defineArgument() method:

var metadataArgument:MetadataArgument = metadataBuilder.defineArgument();
metadataArgument.name = "name";
metadataArgument.value = "objectName";

The actionscript source equivalent of this statement would look like this:

[Inject(name="objectName")]

Generating interfaces

Generating interfaces is mostly the same as generating classes, with the exception that constructors and properties cannot be defined and any method or accessor that is added will automatically receive public visibility.

var interfaceBuilder:IInterfaceBuilder = packageBuilder.defineInterface("RuntimeInterface");

If the interface needs to extend other interfaces pass a list of their fully qualified names to the constructor like this:

var interfaceBuilder:IInterfaceBuilder = packageBuilder.defineInterface("RuntimeInterface",["flash.events.IEventDispatcher"]);

The actionscript source equivalent of this statement would look like this:

package com.classes.generated {
  public interface RuntimeInterface extends IEventDispatcher {
  }
}

Generating namespaces

To generate a new namespace use the defineNamespace() method on the IPackageBuilder.

abcBuilder.addPackage("com.myclasses.namespaces").addNamespace('my_custom_namespace','http://www.mynamespaces.com/custom');

The actionscript source equivalent of this statement would look like this:

package com.myclasses.namespaces {
  public namespace my_custom_namespace = "http://www.mynamespaces.com/custom";
}

Loading the generated classes into the AVM

Finally, after defining the necessary classes and interfaces they need to be loaded into the AVM so they can be instantiated.
There are two ways of doing this, the shortest way is using the buildAndLoad() method on the IAbcBuilder instance.

The process of loading class definitions is asynchronous so first these event listeners need to be added:

abcBuilder.addEventListener(Event.COMPLETE, loadedHandler);
abcBuilder.addEventListener(IOErrorEvent.IO_ERROR, errorHandler);
abcBuilder.addEventListener(IOErrorEvent.VERIFY_ERROR, errorHandler);

After that invoke the buildAndLoad() method:

abcBuilder.buildAndLoad();

In the loadedHandler method a reference to a generated class can be retrieved and instantiated like this:

function loadedHandler(event:Event):void {
  var clazz:Class = ApplicationDomain.currentDomain.getDefinition("com.classes.generated.RuntimeClass") as Class;
  var instance:Object = new clazz();
  var i:int = instance.multiplyByHundred(10);
  // i == 1000
}

The buildAndLoad() method has two optional arguments:

The first ApplicationDomain argument will be the domain that contains any class definitions that are used as superclasses in the generated classes. This domain will be used to retrieve reflection information about the superclasses needed by the class generation process. If no ApplicationDomainis passed then ApplicationDomain.currentDomain will be used.

The second ApplicationDomain argument will be used to load the generated classes into. Again, when no ApplicationDomain is passed then ApplicationDomain.currentDomain will be used.

The second way to load the generated classes is like this:

var abcFile:AbcFile = abcBuilder.build();
var abcLoader:AbcClassLoader = new AbcClassLoader();

abcLoader.addEventListener(Event.COMPLETE, loadedHandler);
abcLoader.addEventListener(IOErrorEvent.IO_ERROR, errorHandler);
abcLoader.addEventListener(IOErrorEvent.VERIFY_ERROR, errorHandler);

abcLoader.loadAbcFile(abcFile);

Exporting the generated classes to file

If there is a need to persist the generated classes to disk, follow these steps: