Jonny Reeves

<slideshow title="LolCats">
	<slide url="http://checkmybelly.com/wp-content/uploads/2007/11/lolcat-funny-picture-moderator1.jpg" caption="Moderator Kitteh" />
	<slide url="http://www.lolcats.com/images/u/07/24/lolcatsdotcom5x02srq751692std.jpg" caption="Wait... I'll fix it" />
	<slide url="http://icanhascheezburger.files.wordpress.com/2007/01/i-can-has-cheezburger.jpg" caption="Can Has Cheezburger?" />
</slideshow>

package slideshow.model
{
	public class Slide
	{
		private var url : String;
		private var caption : String;
 
		/**
		 * Creates a new Slide Model Object which represents a single image in a SlideShow.
		 * 
		 * @param url The URL of the image which makes up this Slide.
		 * @param caption Text which accompanies this Slide.
		 */
		public function Slide(url : String, caption : String) {
			// Ensure this object does not get instantiated with invalid data.
			if (url == null) throw new ArgumentError("url must not be null");
			if (caption == null) throw new ArgumentError("caption must not be null");
 
			this.url = url;
			this.caption = caption;
		}
 
		/**
		 * The URL of the image which makes up this Slide.
		 */
		public function getUrl() : String {
			return url;
		}
 
		/**
		 * Text which accompanies this Slide.
		 */
		public function getCaption() : String {
			return caption;
		}
 
		public function toString() : String {
			return "[Slide url=" + url + ", caption='" + caption + '"]';
		}
	}
}

package slideshow.model
{
	public class SlideShow
	{
		private var title : String;
		private var slides : Array;
 
		/**
		 * Represents a collection of Slide images which make up a SlideShow.
		 * 
		 * @param title Description of this SlideShow.
		 * @param slides Array of Slide model instances which make up this Slideshow. 
		 */
		public function SlideShow(title : String, slides : Array) {
			// Ensure this object does not get instantiated with invalid data.
			if (title == null) throw new ArgumentError("title must not be null");
			assertSlides(slides);
 
			this.title = title;
			this.slides = slides.concat();	// Take a defensive copy.
		}
 
		/**
		 * Custom assertion method which ensures that the supplied Slide array is in a valid state.
		 */
		private function assertSlides(slides : Array) : Array {
			if (slides == null) throw new ArgumentError("slides must not be null");
 
			// Check that the supplied Slides array contains only Slide models.
			for each (var slide : Slide in slides) {
				if (slide == null) throw new ArgumentError("slide array must only contain instances of slideshow.model.Slide."); 
			}
 
			// Everything is OK, return the supplied Slides array for convenience.
			return slides;
		}
 
		/**
		 * Description of this SlideShow.
		 */
		public function getTitle() : String {
			return title;
		}
 
		/**
		 * An Array of Slide model instances which make up this SlideShow, note that this is a copy, so any changes
		 * made will not persist.
		 */
		public function getSlides() : Array {
			return slides.concat();		// Return a defensive copy.
		}
 
		public function toString() : String {
			return "[SlideShow title='" + title + "', slides={" + slides.join(", ") + "}]";
		}
	}
}

// Create a new Array of Slide models.
const slides : Array = new Array();
slides.push(new Slide("http://img.com/cat.png", "A Cat"));
slides.push(new Slide("http://img.com/dog.png", "A Dog"));
 
// Create a new SlideShow.
const slideShow : Slideshow = new SlideShow("Animals", slides);
 
// Outputs [SlideShow title='Animals', slides={
//      [Slide url=http://img.com/cat.png, caption='A Cat'], 
//      [Slide url=http://img.com/dog.png, caption='A Dog']
// }]
trace(slideShow);
 
// Add a new slide to our slides Array - should this change the contents of the SlideShow model?
slides.push(new Slide("http://img.com/car.png", "A Car (not an animal!)"));
 
// Yes it does! Our SlideShow model object now looks like this:
// [SlideShow title='Animals', slides={
//      [Slide url=http://img.com/cat.png, caption='A Cat'], 
//      [Slide url=http://img.com/dog.png, caption='A Dog'],
//      [Slide url=http://img.com/car.png, caption='A Car (not an animal!)']
// }]
trace(slideShow);

package slideshow.model
{
	public class XMLSlideShowMarshaller implements SlideShowMarshaller
	{
		/**
		 * Converts the supplied SlideShow transmission format document into a SlideShow Model object.
		 */
		public function unmarshall(transmissionFormat : *) : SlideShow {
			// First we need to convert the incoming transmission format data to an XML Object so we can parse it.
			const slideShowXML : XML = new XML(transmissionFormat);
 
			// Now we can parse the data...
			const title : String = slideShowXML.@title;
			const slides : Array = parseSlides(slideShowXML..slide);
 
			// Ensure that the require attributes have been set.
			if (title == "") throw new Error("SlideShow XML was missing @title attribute");
 
			// And finally return the new SlideShow model object.
			return new SlideShow(title, slides);
		}
 
		/**
		 * Parses an Array of Slide model objects from the supplied XMLList, if there are no slides in the supplied
		 * XMLList, an empty Array will be returned.
		 */
		private function parseSlides(slidesXML : XMLList) : Array {
			const slides : Array = [];
			for each (var slideNode : XML in slidesXML) {
				// As the Slide model will throw an error if supplied with invalid data, we need to wrap it in a 
				// try/catch block and log that an error occured - note that we do not consider this to be "fatal"
				// to the Unmarshalling operation as we can recover from it (skip over the offending slide).
				try {
					slides.push(new Slide(slideNode.@url, slideNode.@caption));
				}
				catch (e : Error) {
					trace("Failed to parse Slide node: " + slideNode.toXMLString());
				}
			}
			return slides;
		}
	}
}

package slideshow.service
{
	// imports omitted...
 
	public class SlideShowLoaderService extends EventDispatcher
	{
		private var loader : URLLoader;
		private var slideShow : SlideShow;
		private var slideShowMarhsaller : SlideShowMarshaller;
 
		/**
		 * Static factory method which should be used to load XML SlideShow Data.
		 */
		public static function createXMLLoader() : SlideShowLoader {
			return new SlideShowLoader(new XMLSlideShowMarshaller());
		}
 
		/**
		 * Creates a new SlideShowLoaderService which will use the supplied SlideShowMarshaller object to convert the
		 * loaded data into a SlideShow model.
		 * 
		 * @param slideShowMarhsaller Converts the raw data at the service endpoint into a SlideShow model object.
		 */
		public function SlideShowLoader(slideShowMarhsaller : SlideShowMarshaller) {
			this.slideShowMarhsaller = slideShowMarhsaller;
		}
 
		/**
		 * Begins the load operation; if the load operation is successful Event.COMPLETE will be dispatched, should it
		 * fail, ErrorEvent.ERROR will be dispatched.
		 * 
		 * @param endpointUrl URL which returns the SlideShow transmission data which will be converted into a 
		 * SlideShow Model object.
		 */
		public function load(endpointUrl : String) : void {
			// Clear out any pre-existing state.
			slideShow = null;
 
			loader = new URLLoader();
			loader.addEventListener(Event.COMPLETE, onLoaderComplete);
			loader.addEventListener(IOErrorEvent.IO_ERROR, onLoaderError);
			loader.addEventListener(SecurityErrorEvent.SECURITY_ERROR, onLoaderError);
 
			try {
				loader.load(new URLRequest(endpointUrl));
			}
			catch (e : Error) {			{
				handleError(e.message);
			}
		}
 
		private function onLoaderComplete(event : Event) : void {
			removeLoaderListeners();
 
			// Use our marshaller to create the SlideShow model instance from the loaded data.
			try {
				slideShow = slideShowMarhsaller.unmarshall(loader.data);
				handleComplete();
			}
			catch (e : Error) {
				handleError("Marshalling error: " + e.message);
			}
		}
 
		private function removeLoaderListeners() : void {
			loader.removeEventListener(Event.COMPLETE, onLoaderComplete);
			loader.removeEventListener(IOErrorEvent.IO_ERROR, onLoaderError);
			loader.removeEventListener(SecurityErrorEvent.SECURITY_ERROR, onLoaderError);
		}
 
		private function onLoaderError(event : ErrorEvent) : void {
			removeLoaderListeners();
			handleError("Loading error: " + event.text);
		}
 
		private function handleError(message : String) : void {
			dispatchEvent(new ErrorEvent(ErrorEvent.ERROR, false, false, message));
		}
 
		private function handleComplete() : void {
			dispatchEvent(new Event(Event.COMPLETE));
		}
 
		/**
		 * Returns a SlideShow model object which was parsed from the service endpoint; note that this method will 
		 * always return null unless a succesful call to load() was made.
		 */
		public function getSlideShow() : SlideShow {
			return slideShow;
		}
	}
}

const slideShowLoader : SlideShowLoaderService = new SlideShowLoaderService(new XMLSlideShowMarhshaller());
slideShowLoader.addEventListener(Event.COMPLETE, onSlideShowLoaderComplete);
slideShowLoader.addEventListener(ErrorEvent.ERROR, onSlideShowLoaderError);
slideShowLoader.load("slideshow.xml");

const slideShowLoader : SlideShowLoaderService = new SlideShowLoaderService(new JSONSlideShowMarhshaller());
slideShowLoader.addEventListener(Event.COMPLETE, onSlideShowLoaderComplete);
slideShowLoader.addEventListener(ErrorEvent.ERROR, onSlideShowLoaderError);
slideShowLoader.load("slideshow.json");

const slideShowLoader : SlideShowLoaderService = SlideShowLoaderService.createXMLLoader();
slideShowLoader.addEventListener(Event.COMPLETE, onSlideShowLoaderComplete);
slideShowLoader.addEventListener(ErrorEvent.ERROR, onSlideShowLoaderError);
slideShowLoader.load("slideshow.xml");

// ... rest of class omitted for brevity
 
/**
 * Converts the supplied SlideShow model object into an XML representation.
 */
public function marshall(slideShow : SlideShow) : * {
	const result : XML = <slideshow title={slideShow.getTitle()} />;
	for each (var slide : Slide in slideShow.getSlides()) {
		result.* += <slide url={slide.getUrl()} caption={slide.getCaption()} />;
	};
	return result;
}

// Create a SlideShow Model object instance.
const slideShow : SlideShow = new SlideShow("LolCats", [
	new Slide("http://checkmybelly.com/wp-content/uploads/2007/11/lolcat-funny-picture-moderator1.jpg", "Moderator Kitteh"),
	new Slide("http://www.lolcats.com/images/u/07/24/lolcatsdotcom5×02srq751692std.jpg", "Wait… I'll fix it"),
	new Slide("http://icanhascheezburger.files.wordpress.com/2007/01/i-can-has-cheezburger.jpg", "Can Has Cheezburger?")
]);
 
// Convert the SlideShow Model object to our transmission format.
const xml : XML = new XMLSlideShowMarshaller().marshall(slideShow);
 
// Outputs:
// <slideshow title="LolCats">
//    <slide url="http://checkmybelly.com/wp-content/uploads/2007/11/lolcat-funny-picture-moderator1.jpg" caption="Moderator Kitteh"/>
//    <slide url="http://www.lolcats.com/images/u/07/24/lolcatsdotcom5×02srq751692std.jpg" caption="Wait… I'll fix it"/>
//    <slide url="http://icanhascheezburger.files.wordpress.com/2007/01/i-can-has-cheezburger.jpg" caption="Can Has Cheezburger?"/>
//</slideshow>
trace(xml.toXMLString());

package slideshow.service
{
	// imports omitted...
 
	public class SlideShowSaverService extends EventDispatcher
	{
		private var loader : URLLoader;
		private var slideShow : SlideShow;
		private var slideShowMarshaller : SlideShowMarshaller;
 
		/**
		 * Static factory method which will transmit the SlideShow to the service endpoint as XML.
		 */
		public static function createXMLSaver(slideShow : SlideShow) : SlideShowSaverService {
			return new SlideShowSaverService(slideShow, new XMLSlideShowMarshaller());
		}
 
		/**
		 * Creates a new SlideShowSaverService which will send the supplied slideShow Model Object to a service endpoint
		 * in the transmission format dictated by the supplied SlideshowMarshaller.
		 *
		 * @param slideShow The SlideShow instance to transmit to the service endpoint. 
		 * @param slideShowMarhsaller Converts the SlideShow model object into a transmission format.
		 */
		public function SlideShowSaverService(slideShow : SlideShow, slideShowMarshaller : SlideShowMarshaller) {
			this.slideShow = slideShow;
			this.slideShowMarshaller = slideShowMarshaller;
		}
 
		/**
		 * Contacts the Service Endpoint; if the operation is succesful Event.COMPLETE will be dispatched, should the
		 * operation fail, ErrorEvent.ERROR will be dispatched.
		 * 
		 * @param endpointUrl URL to transmit the marhshalled SlideShow Model object to.
		 */
		public function save(endpointURL : String) : void {
			const request : URLRequest = createURLRequest(endpointURL, slideShowMarshaller.marshall(slideShow));
 
			loader.addEventListener(Event.COMPLETE, onLoaderComplete);
			loader.addEventListener(IOErrorEvent.IO_ERROR, onLoaderErrror);
			loader.addEventListener(SecurityErrorEvent.SECURITY_ERROR, onLoaderErrror);
			loader.load(request);
		}
 
		/**
		 * Creates a URLRequest object which will be used by the URLLoader instance, this default implementation
		 * will make use of a POST request, the body of which will be the transmission data format. 
		 */
		protected function createURLRequest(endpointURL : String, data : *) : URLRequest {
			const request : URLRequest = new URLRequest(endpointURL);
			request.method = URLRequestMethod.POST;
			request.data = data;
			return request;
		}		
 
		private function onLoaderComplete(event : Event) : void {
			removeLoaderListeners();
			dispatchEvent(new Event(Event.COMPLETE));
		}
 
		private function removeLoaderListeners() : void {
			loader.removeEventListener(Event.COMPLETE, onLoaderComplete);
			loader.removeEventListener(IOErrorEvent.IO_ERROR, onLoaderErrror);
			loader.removeEventListener(SecurityErrorEvent.SECURITY_ERROR, onLoaderErrror);
		}
 
		private function onLoaderErrror(event : ErrorEvent) : void {
			removeLoaderListeners();
			handleError("Loader error: " + event.text);
		}
 
		private function handleError(message : String) : void {
			dispatchEvent(new ErrorEvent(ErrorEvent.ERROR, false, false, message));
		}
	}
}