dpdk Open Source

package nl.dpdk.demo.AsynchronousQueueDemo {
	import nl.dpdk.collections.core.IQueue;
	import nl.dpdk.collections.lists.LinkedList;
 
	import flash.display.Loader;
	import flash.display.MovieClip;
	import flash.events.Event;
	import flash.events.HTTPStatusEvent;
	import flash.events.IOErrorEvent;
	import flash.events.SecurityErrorEvent;
	import flash.net.URLLoader;
	import flash.net.URLRequest;	
 
	public class AsynchronousQueueDemo extends MovieClip {
		//queue to hold some data, of datatype IQueue
		private var list : IQueue = new LinkedList();
		public function AsynchronousQueueDemo() {
			loadData();
		}
 
		/**
		 * loads some xml configuration data
		 */
		private function loadData() : void {
			XML.ignoreWhitespace = true;
			var loader : URLLoader = new URLLoader();
			loader.addEventListener(Event.COMPLETE, onXMLLoaded);
			loader.load(new URLRequest("./xml/data.xml"));
		}
 
		/**
		 * xml data loaded, now process it and start doing the asynchronous loading operation via a queue
		 */
		private function onXMLLoaded(event : Event) : void {
			var loader : URLLoader = event.target as URLLoader;
			var xml : XML = new XML(loader.data);
			processXML(xml);
			//all things are ready to be loaded
			loadNext();
		}
 
		private function processXML(xml : XML) : void {
			/**
			 * xml structure is:
			 *
 
			 *
 
			 *
 
			 *
 
			 * 
			 */
			 //thing stores data we want to use later
			var thing : Thing;
			for each(var xmlElement: XML in xml.*) {
				thing = new Thing(xmlElement.@file, xmlElement.@id);
				//put things in the queue
				list.enqueue(thing);
			}
		}
 
		/**
		 * method gets called each time a new thing needs to be loaded.
		 * It also handles the last item after it has been loaded
		 */
		private function loadNext() : void {
			//look at the next thing in the list, but DO NOT remove, so we can retrieve the data in the thing instance later
			var thing : Thing = list.peek() as Thing;
			//if there is something to be done...
			if(thing != null) {
				//load the thing
				loadThing(thing);
			}else {
				//nothing to load, loading finished, end the asynchronous queue here...
				doYourThing();
			}
		}
 
		/**
		 * loads a specific thing.
		 * also adds all loading related event handlers
		 */
		private function loadThing(thing : Thing) : void {
			try {
				var loader: Loader = new Loader();
				loader.contentLoaderInfo.addEventListener(Event.COMPLETE, onLoadComplete);
				loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, onThingError);
				loader.contentLoaderInfo.addEventListener(SecurityErrorEvent.SECURITY_ERROR, onThingError);
				loader.contentLoaderInfo.addEventListener(HTTPStatusEvent.HTTP_STATUS, onThingError);
				loader.load(new URLRequest(thing.file));
			}catch(e : Error) {
				//allow processing to continue in case something happened
				onThingError(null);
			}
		}
 
		/**
		 * loading errors.
		 * The loading should continue after this, so the flow will not stop
		 */
		private function onThingError(event : IOErrorEvent) : void {
			//remove bad thing
			list.dequeue();
			//load next thing
			loadNext();
		}
 
		/**
		 * loading succes.
		 */
		private function onLoadComplete(event : Event) : void {
			//remove a thing from the list as it has been loaded
			var thing : Thing = list.dequeue() as Thing;
			//do stuff with the thing!
			trace("thing loaded: " + thing.id);
			//load next thing
			loadNext();
		}
 
		private function doYourThing() : void {
			//do your thing here.... everything is loaded
		}
	}
}