puremvc-as3 2.0.4

data/2.0.4/src/org/puremvc/as3/interfaces/INotifier.as

@@ -0,0 +1,46 @@
+/*
+ PureMVC - Copyright(c) 2006-08 Futurescale, Inc., Some rights reserved.
+ Your reuse is governed by the Creative Commons Attribution 3.0 United States License
+*/
+package org.puremvc.as3.interfaces
+{
+	/**
+	 * The interface definition for a PureMVC Notifier.
+	 * 
+	 * <P>
+	 * <code>MacroCommand, Command, Mediator</code> and <code>Proxy</code>
+	 * all have a need to send <code>Notifications</code>. </P>
+	 * 
+	 * <P>
+	 * The <code>INotifier</code> interface provides a common method called
+	 * <code>sendNotification</code> that relieves implementation code of 
+	 * the necessity to actually construct <code>Notifications</code>.</P>
+	 * 
+	 * <P>
+	 * The <code>Notifier</code> class, which all of the above mentioned classes
+	 * extend, also provides an initialized reference to the <code>Facade</code>
+	 * Singleton, which is required for the convienience method
+	 * for sending <code>Notifications</code>, but also eases implementation as these
+	 * classes have frequent <code>Facade</code> interactions and usually require
+	 * access to the facade anyway.</P>
+	 * 
+	 * @see org.puremvc.as3.interfaces.IFacade IFacade
+	 * @see org.puremvc.as3.interfaces.INotification INotification
+	 */
+	public interface INotifier
+	{
+		/**
+		 * Send a <code>INotification</code>.
+		 * 
+		 * <P>
+		 * Convenience method to prevent having to construct new 
+		 * notification instances in our implementation code.</P>
+		 * 
+		 * @param notificationName the name of the notification to send
+		 * @param body the body of the notification (optional)
+		 * @param type the type of the notification (optional)
+		 */ 
+		function sendNotification( notificationName:String, body:Object=null, type:String=null ):void; 
+		
+	}
+}

data/2.0.4/src/org/puremvc/as3/interfaces/IObserver.as

@@ -0,0 +1,81 @@
+/*
+ PureMVC - Copyright(c) 2006-08 Futurescale, Inc., Some rights reserved.
+ Your reuse is governed by the Creative Commons Attribution 3.0 United States License
+*/
+package org.puremvc.as3.interfaces
+{
+	
+	/**
+	 * The interface definition for a PureMVC Observer.
+	 *
+	 * <P>
+	 * In PureMVC, <code>IObserver</code> implementors assume these responsibilities:
+	 * <UL>
+	 * <LI>Encapsulate the notification (callback) method of the interested object.</LI>
+	 * <LI>Encapsulate the notification context (this) of the interested object.</LI>
+	 * <LI>Provide methods for setting the interested object' notification method and context.</LI>
+	 * <LI>Provide a method for notifying the interested object.</LI>
+	 * </UL>
+	 * 
+	 * <P>
+	 * PureMVC does not rely upon underlying event
+	 * models such as the one provided with Flash,
+	 * and ActionScript 3 does not have an inherent
+	 * event model.</P>
+	 * 
+	 * <P>
+	 * The Observer Pattern as implemented within
+	 * PureMVC exists to support event driven communication
+	 * between the application and the actors of the
+	 * MVC triad.</P>
+	 * 
+	 * <P> 
+	 * An Observer is an object that encapsulates information
+	 * about an interested object with a notification method that
+	 * should be called when an </code>INotification</code> is broadcast. The Observer then
+	 * acts as a proxy for notifying the interested object.
+	 * 
+	 * <P>
+	 * Observers can receive <code>Notification</code>s by having their
+	 * <code>notifyObserver</code> method invoked, passing
+	 * in an object implementing the <code>INotification</code> interface, such
+	 * as a subclass of <code>Notification</code>.</P>
+	 * 
+	 * @see org.puremvc.as3.interfaces.IView IView
+	 * @see org.puremvc.as3.interfaces.INotification INotification
+	 */
+	public interface IObserver
+	{
+		/**
+		 * Set the notification method.
+		 * 
+		 * <P>
+		 * The notification method should take one parameter of type <code>INotification</code></P>
+		 * 
+		 * @param notifyMethod the notification (callback) method of the interested object
+		 */
+		function setNotifyMethod( notifyMethod:Function ):void;
+		
+		/**
+		 * Set the notification context.
+		 * 
+		 * @param notifyContext the notification context (this) of the interested object
+		 */
+		function setNotifyContext( notifyContext:Object ):void;
+		
+		/**
+		 * Notify the interested object.
+		 * 
+		 * @param notification the <code>INotification</code> to pass to the interested object's notification method
+		 */
+		function notifyObserver( notification:INotification ):void;
+		
+		/**
+		 * Compare the given object to the notificaiton context object.
+		 * 
+		 * @param object the object to compare.
+		 * @return boolean indicating if the notification context and the object are the same.
+		 */
+		function compareNotifyContext( object:Object ):Boolean;
+	}
+}

data/2.0.4/src/org/puremvc/as3/interfaces/IProxy.as

@@ -0,0 +1,61 @@
+/*
+ PureMVC - Copyright(c) 2006-08 Futurescale, Inc., Some rights reserved.
+ Your reuse is governed by the Creative Commons Attribution 3.0 United States License
+*/
+package org.puremvc.as3.interfaces
+{
+	
+	/**
+	 * The interface definition for a PureMVC Proxy.
+	 *
+	 * <P>
+	 * In PureMVC, <code>IProxy</code> implementors assume these responsibilities:</P>
+	 * <UL>
+	 * <LI>Implement a common method which returns the name of the Proxy.</LI>
+	 * <LI>Provide methods for setting and getting the data object.</LI>
+	 * </UL>
+	 * <P>
+	 * Additionally, <code>IProxy</code>s typically:</P>
+	 * <UL>
+	 * <LI>Maintain references to one or more pieces of model data.</LI>
+	 * <LI>Provide methods for manipulating that data.</LI>
+	 * <LI>Generate <code>INotifications</code> when their model data changes.</LI>
+	 * <LI>Expose their name as a <code>public static const</code> called <code>NAME</code>, if they are not instantiated multiple times.</LI>
+	 * <LI>Encapsulate interaction with local or remote services used to fetch and persist model data.</LI>
+	 * </UL>
+	 */
+	public interface IProxy
+	{
+		
+		/**
+		 * Get the Proxy name
+		 * 
+		 * @return the Proxy instance name
+		 */
+		function getProxyName():String;
+		
+		/**
+		 * Set the data object
+		 * 
+		 * @param data the data object
+		 */
+		function setData( data:Object ):void;
+		
+		/**
+		 * Get the data object
+		 * 
+		 * @return the data as type Object
+		 */
+		function getData():Object; 
+		
+		/**
+		 * Called by the Model when the Proxy is registered
+		 */ 
+		function onRegister( ):void;
+
+		/**
+		 * Called by the Model when the Proxy is removed
+		 */ 
+		function onRemove( ):void;
+	}
+}

data/2.0.4/src/org/puremvc/as3/interfaces/IView.as

@@ -0,0 +1,106 @@
+/*
+ PureMVC - Copyright(c) 2006-08 Futurescale, Inc., Some rights reserved.
+ Your reuse is governed by the Creative Commons Attribution 3.0 United States License
+*/
+package org.puremvc.as3.interfaces
+{
+	
+	/**
+	 * The interface definition for a PureMVC View.
+	 * 
+	 * <P>
+	 * In PureMVC, <code>IView</code> implementors assume these responsibilities:</P>
+	 * 
+	 * <P>
+	 * In PureMVC, the <code>View</code> class assumes these responsibilities:
+	 * <UL>
+	 * <LI>Maintain a cache of <code>IMediator</code> instances.</LI>
+	 * <LI>Provide methods for registering, retrieving, and removing <code>IMediators</code>.</LI>
+	 * <LI>Managing the observer lists for each <code>INotification</code> in the application.</LI>
+	 * <LI>Providing a method for attaching <code>IObservers</code> to an <code>INotification</code>'s observer list.</LI>
+	 * <LI>Providing a method for broadcasting an <code>INotification</code>.</LI>
+	 * <LI>Notifying the <code>IObservers</code> of a given <code>INotification</code> when it broadcast.</LI>
+	 * </UL>
+	 * 
+	 * @see org.puremvc.as3.interfaces.IMediator IMediator
+	 * @see org.puremvc.as3.interfaces.IObserver IObserver
+	 * @see org.puremvc.as3.interfaces.INotification INotification
+	 */
+	public interface IView 
+	{
+		
+		/**
+		 * Register an <code>IObserver</code> to be notified
+		 * of <code>INotifications</code> with a given name.
+		 * 
+		 * @param notificationName the name of the <code>INotifications</code> to notify this <code>IObserver</code> of
+		 * @param observer the <code>IObserver</code> to register
+		 */
+		function registerObserver( notificationName:String, observer:IObserver ) : void;
+
+		/**
+		 * Remove a group of observers from the observer list for a given Notification name.
+		 * <P>
+		 * @param notificationName which observer list to remove from 
+		 * @param notifyContext removed the observers with this object as their notifyContext
+		 */
+		function removeObserver( notificationName:String, notifyContext:Object ):void;
+
+		/**
+		 * Notify the <code>IObservers</code> for a particular <code>INotification</code>.
+		 * 
+		 * <P>
+		 * All previously attached <code>IObservers</code> for this <code>INotification</code>'s
+		 * list are notified and are passed a reference to the <code>INotification</code> in 
+		 * the order in which they were registered.</P>
+		 * 
+		 * @param notification the <code>INotification</code> to notify <code>IObservers</code> of.
+		 */
+		function notifyObservers( note:INotification ) : void;
+
+		/**
+		 * Register an <code>IMediator</code> instance with the <code>View</code>.
+		 * 
+		 * <P>
+		 * Registers the <code>IMediator</code> so that it can be retrieved by name,
+		 * and further interrogates the <code>IMediator</code> for its 
+		 * <code>INotification</code> interests.</P>
+		 * <P>
+		 * If the <code>IMediator</code> returns any <code>INotification</code> 
+		 * names to be notified about, an <code>Observer</code> is created encapsulating 
+		 * the <code>IMediator</code> instance's <code>handleNotification</code> method 
+		 * and registering it as an <code>Observer</code> for all <code>INotifications</code> the 
+		 * <code>IMediator</code> is interested in.</p>
+		 * 
+		 * @param mediatorName the name to associate with this <code>IMediator</code> instance
+		 * @param mediator a reference to the <code>IMediator</code> instance
+		 */
+		function registerMediator( mediator:IMediator ) : void;
+
+		/**
+		 * Retrieve an <code>IMediator</code> from the <code>View</code>.
+		 * 
+		 * @param mediatorName the name of the <code>IMediator</code> instance to retrieve.
+		 * @return the <code>IMediator</code> instance previously registered with the given <code>mediatorName</code>.
+		 */
+		function retrieveMediator( mediatorName:String ) : IMediator;
+
+		/**
+		 * Remove an <code>IMediator</code> from the <code>View</code>.
+		 * 
+		 * @param mediatorName name of the <code>IMediator</code> instance to be removed.
+		 * @return the <code>IMediator</code> that was removed from the <code>View</code>
+		 */
+		function removeMediator( mediatorName:String ) : IMediator;
+		
+		/**
+		 * Check if a Mediator is registered or not
+		 * 
+		 * @param mediatorName
+		 * @return whether a Mediator is registered with the given <code>mediatorName</code>.
+		 */
+		function hasMediator( mediatorName:String ) : Boolean;
+		
+	}
+	
+}

data/2.0.4/src/org/puremvc/as3/patterns/command/MacroCommand.as

@@ -0,0 +1,121 @@
+/*
+ PureMVC - Copyright(c) 2006-08 Futurescale, Inc., Some rights reserved.
+ Your reuse is governed by the Creative Commons Attribution 3.0 United States License
+*/
+package org.puremvc.as3.patterns.command 
+{
+
+	import org.puremvc.as3.interfaces.*;
+	import org.puremvc.as3.patterns.observer.*;
+	
+	/**
+	 * A base <code>ICommand</code> implementation that executes other <code>ICommand</code>s.
+	 *  
+	 * <P>
+	 * A <code>MacroCommand</code> maintains an list of
+	 * <code>ICommand</code> Class references called <i>SubCommands</i>.</P>
+	 * 
+	 * <P>
+	 * When <code>execute</code> is called, the <code>MacroCommand</code> 
+	 * instantiates and calls <code>execute</code> on each of its <i>SubCommands</i> turn.
+	 * Each <i>SubCommand</i> will be passed a reference to the original
+	 * <code>INotification</code> that was passed to the <code>MacroCommand</code>'s 
+	 * <code>execute</code> method.</P>
+	 * 
+	 * <P>
+	 * Unlike <code>SimpleCommand</code>, your subclass
+	 * should not override <code>execute</code>, but instead, should 
+	 * override the <code>initializeMacroCommand</code> method, 
+	 * calling <code>addSubCommand</code> once for each <i>SubCommand</i>
+	 * to be executed.</P>
+	 * 
+	 * <P>
+	 * 
+	 * @see org.puremvc.as3.core.controller.Controller Controller
+	 * @see org.puremvc.as3.patterns.observer.Notification Notification
+	 * @see org.puremvc.as3.patterns.command.SimpleCommand SimpleCommand
+	 */
+	public class MacroCommand extends Notifier implements ICommand, INotifier
+	{
+		
+		private var subCommands:Array;
+		
+		/**
+		 * Constructor. 
+		 * 
+		 * <P>
+		 * You should not need to define a constructor, 
+		 * instead, override the <code>initializeMacroCommand</code>
+		 * method.</P>
+		 * 
+		 * <P>
+		 * If your subclass does define a constructor, be 
+		 * sure to call <code>super()</code>.</P>
+		 */
+		public function MacroCommand()
+		{
+			subCommands = new Array();
+			initializeMacroCommand();			
+		}
+		
+		/**
+		 * Initialize the <code>MacroCommand</code>.
+		 * 
+		 * <P>
+		 * In your subclass, override this method to 
+		 * initialize the <code>MacroCommand</code>'s <i>SubCommand</i>  
+		 * list with <code>ICommand</code> class references like 
+		 * this:</P>
+		 * 
+		 * <listing>
+		 *		// Initialize MyMacroCommand
+		 *		override protected function initializeMacroCommand( ) : void
+		 *		{
+		 *			addSubCommand( com.me.myapp.controller.FirstCommand );
+		 *			addSubCommand( com.me.myapp.controller.SecondCommand );
+		 *			addSubCommand( com.me.myapp.controller.ThirdCommand );
+		 *		}
+		 * </listing>
+		 * 
+		 * <P>
+		 * Note that <i>SubCommand</i>s may be any <code>ICommand</code> implementor,
+		 * <code>MacroCommand</code>s or <code>SimpleCommands</code> are both acceptable.
+		 */
+		protected function initializeMacroCommand():void
+		{
+		}
+		
+		/**
+		 * Add a <i>SubCommand</i>.
+		 * 
+		 * <P>
+		 * The <i>SubCommands</i> will be called in First In/First Out (FIFO)
+		 * order.</P>
+		 * 
+		 * @param commandClassRef a reference to the <code>Class</code> of the <code>ICommand</code>.
+		 */
+		protected function addSubCommand( commandClassRef:Class ): void
+		{
+			subCommands.push(commandClassRef);
+		}
+		
+		/** 
+		 * Execute this <code>MacroCommand</code>'s <i>SubCommands</i>.
+		 * 
+		 * <P>
+		 * The <i>SubCommands</i> will be called in First In/First Out (FIFO)
+		 * order. 
+		 * 
+		 * @param notification the <code>INotification</code> object to be passsed to each <i>SubCommand</i>.
+		 */
+		public final function execute( notification:INotification ) : void
+		{
+			while ( subCommands.length > 0) {
+				var commandClassRef : Class = subCommands.shift();
+				var commandInstance : ICommand = new commandClassRef();
+				commandInstance.execute( notification );
+			}
+		}
+								
+	}
+}

data/2.0.4/src/org/puremvc/as3/patterns/command/SimpleCommand.as

@@ -0,0 +1,42 @@
+/*
+ PureMVC - Copyright(c) 2006-08 Futurescale, Inc., Some rights reserved.
+ Your reuse is governed by the Creative Commons Attribution 3.0 United States License
+*/
+package org.puremvc.as3.patterns.command 
+{
+
+	import org.puremvc.as3.interfaces.*;
+	import org.puremvc.as3.patterns.observer.Notifier;
+	
+	/**
+	 * A base <code>ICommand</code> implementation.
+	 * 
+	 * <P>
+	 * Your subclass should override the <code>execute</code> 
+	 * method where your business logic will handle the <code>INotification</code>. </P>
+	 * 
+	 * @see org.puremvc.as3.core.controller.Controller Controller
+	 * @see org.puremvc.as3.patterns.observer.Notification Notification
+	 * @see org.puremvc.as3.patterns.command.MacroCommand MacroCommand
+	 */
+	public class SimpleCommand extends Notifier implements ICommand, INotifier 
+	{
+		
+		/**
+		 * Fulfill the use-case initiated by the given <code>INotification</code>.
+		 * 
+		 * <P>
+		 * In the Command Pattern, an application use-case typically
+		 * begins with some user action, which results in an <code>INotification</code> being broadcast, which 
+		 * is handled by business logic in the <code>execute</code> method of an
+		 * <code>ICommand</code>.</P>
+		 * 
+		 * @param notification the <code>INotification</code> to handle.
+		 */
+		public function execute( notification:INotification ) : void
+		{
+			
+		}
+								
+	}
+}