Page Comparison

public interface IChain extends IEventDispatcher
{
	function get position():int;
	function set position( value:int ):void;
	
	function get isComplete():Boolean;
	
	function get stopOnError():Boolean;
	function set stopOnError( value:Boolean ):void;
	
	function hasNext():Boolean;
	function stepComplete():void;
	function stepError():void;
	
	function addStep( step:IChainStep ):IChain;
	
	function start():void;
	function doProceed():void;
}

public interface IChainStep
{
	function get chain():IChain;
	function set chain( value:IChain ):void;
	
	function get isComplete():Boolean;
	
	function complete():void;
	function error():void;
}

public interface IAutonomousChainStep extends IChainStep
{
	function doProceed():void;
}

public function doEventChain() : void
{
	var eventChain : EventChain = new EventChain( dispatcher );
	eventChain.addEventListener( ChainEvent.CHAIN_COMPLETE, handleChainComplete, false, 0, true );
	eventChain.addStep( new EventChainStep( new UserEvent( UserEvent.USER_SCREEN_ACTIVE ) ) );
	eventChain.addStep( new EventChainStep( new UserEvent( UserEvent.USER_PROCESSING_COMPLETE ) ) );
	eventChain.start();
}

[EventHandler( event="UserEvent.USER_SCREEN_ACTIVE" )]
public function logUserScreenActive() : void
{
	// perform logic or dispatch events when the user screen is active
}

[EventHandler( event="UserEvent.USER_PROCESSING_COMPLETE" )]
public function logUserProcessingComplete() : void
{
	// perform logic or dispatch events when the processing finishes
}

public function handleChainComplete( event : Event ) : void
{
	// perform logic or dispatch events when the chain is complete
}

package chains
{
	import org.swizframework.utils.chain.AbstractChain;
	import org.swizframework.utils.chain.IAutonomousChainStep;
	import org.swizframework.utils.chain.IChain;
	
	public class CompositeChain extends AbstractChain implements IChain
	{
		public function doProceed():void
		{
			IAutonomousChainStep( steps[ position ] ).doProceed();
		}
	}
}

package steps
{
	import org.swizframework.utils.chain.BaseChainStep;
	import org.swizframework.utils.chain.IAutonomousChainStep;
	
	public class PropertySetterStep extends BaseChainStep implements IAutonomousChainStep
	{
		public var target:Object;
		public var props:Object;
		
		public function PropertySetterStep( target:Object, props:Object )
		{
			this.target = target;
			this.props = props;
		}
		
		public function doProceed():void
		{
			for( var prop:String in props )
			{
				target[ prop ] = props[ prop ];
			}
			complete();
		}
	}
}

As noted earlier, [EventHandler] methods can simply return an AsyncToken. The [EventHandler] metadata processor will automatically adapt the AsyncToken via AsyncTokenOperation.

import org.swizframework.utils.async.AsynchronousEvent;
    
/**
 * By extending AsynchronousEvent (or implementing IAsynchronousEvent), the event can keep track
 * of the chain step it is associated with:

\\
{html}<script src="https://gist.github.com/659216.js?file=UserEvent_extending_AsynchronousEvent.as"></script>{html}
\\

And then the code that actually builds up the chain and starts the processing:

\\
{html}<script src="http://gist.github.com/659216.js?file=EventHandler_asynchronous_operation.as"></script>{html}
\\

As another example, a URL request is adapted via AsynchronousIOOperation to allow Swiz to wait for completion before the chain proceeds:

\\
{html}<script src="http://gist.github.com/659216.js?file=EventHandler_asynchronousIOoperation.as"></script>{html}
\\

An {{\[EventHandler\]}} method can also construct an asynchronous chain and return that chain as an operation (adapting it via AsynchronousChainOperation).  In that case, the original EventChainStep will not proceed until the entire child chain is complete.

h4. Go forth and chain stuff!
Hopefully this page has shown you the ease, power and extensibility of the Swiz chaining API. If you have questions or comments about the API or any of the built in implementations, or even just ideas you'd like to discuss, please head over to the [mailing list|http://groups.google.com/group/swiz-framework] and we'll be happy to help!

. This allows the event to participate in asynchronous 
 * event chains.
 */ 
public class UserEvent extends AsynchronousEvent
{
    public static const LOAD_USER : String = "UserEvent.LOAD_USER";
    public static const LOAD_USER_IMAGE : String = "UserEvent.LOAD_USER_IMAGE";
    public static const USER_PROCESSING_COMPLETE : String = "UserEvent.USER_PROCESSING_COMPLETE";

    public function UserEvent( type : String )
    {
        super( type, true, false );
    }
}

public function doAsyncChain() : void
{
	var eventChain : EventChain = new EventChain( dispatcher );
	eventChain.addStep( new EventChainStep( new UserEvent( UserEvent.LOAD_USER ) ) );
	eventChain.addStep( new EventChainStep( new UserEvent( UserEvent.USER_PROCESSING_COMPLETE ) ) );
	eventChain.start();
}

[EventHandler( event="UserEvent.LOAD_USER" )]
/**
 * Since this event handler method returns an AsyncToken, Swiz automatically knows that
 * if the method runs as part of an event chain, it should wait until the asyncronous call 
 * completes before proceeding to the next chain step.
 */ 
public function loadUser() : AsyncToken
{
	return serviceHelper.executeServiceCall( service.loadUser(), handleUserLoadResult );
}

private function handleUserLoadResult( event : ResultEvent ) : void
{
	// process the result
}

[EventHandler( event="UserEvent.USER_PROCESSING_COMPLETE " )
public function userProcessingComplete() : void
{
	// perform logic or dispatch events when the processing finishes
}

public function doURLRequestChain() : void
{
	var eventChain : EventChain = new EventChain( dispatcher );
	eventChain.addStep( new EventChainStep( new UserEvent( UserEvent.LOAD_USER_IMAGE ) ) );
	eventChain.addStep( new EventChainStep( new UserEvent( UserEvent.USER_PROCESSING_COMPLETE ) ) );
	eventChain.start();
}

[EventHandler( event="UserEvent.LOAD_USER_IMAGE" )]
/**
 * Load an image. Since this event handler method returns an IAsynchronousOperation, 
 * Swiz automatically knows that if the method runs as part of an event chain, it should wait 
 * until the operation completes before proceeding to the next chain step.
 */ 
public function loadUserImage( event : UserEvent ) : IAsynchronousOperation
{
	var request : URLRequest = new URLRequest( targetImagePath );
	var loader : URLLoader = urlRequestHelper.executeURLRequest( request, handleUserImageResult );
	return new AsynchronousIOOperation( loader );
}

private function handleUserImageResult( event : Event ) : void
{
	// process the result
}

[EventHandler( event="UserEvent.USER_PROCESSING_COMPLETE " )
public function userProcessingComplete() : void
{
	// perform logic or dispatch events when the processing finishes
}