carfield.com.hk

ChainOfResponsibilityProtocol.java

2004-03-24T16:00:00Z

package ca.ubc.cs.spl.pattern.library;

/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
 *
 * This file is part of the design patterns project at UBC
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.1 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * either http://www.mozilla.org/MPL/ or http://aspectj.org/MPL/.
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is ca.ubc.cs.spl.patterns.
 *
 * Contributor(s): 
 */

import java.util.WeakHashMap;

/**
 * Defines the general behavior of the chain of responsibility design pattern.
 *
 * Each concrete sub-aspect of this aspect defines one particular instance of
 * the pattern, with an arbitrary number of Handler classes involved.
 *
 * The sub-aspect defines three things: <ol>
 *
 * <li> what types can be handlers
 *
 * <li> what triggers an event to be raised
 *
 * <li> how each Handler treats a particular event. The default
 * implementation in this aspect here makes it only necessary to code
 * those cases where an event is actually handled.
 * </ol>
 *
 * Note that in this implementation, a default behavior for Handlers is
 * defined: unless a Handler explicitly handles an event, it is passed
 * to its successor. In addition to that, the implementation allows to define
 * a default bahavior in case no Handler in the chain handles an event.
 * Here, an error message is shown. 
 *
 * Note further that this version does not define a Request role. 
 * Although that would be a more consistent approach, AspectJ does not allow
 * the mechanisms used here if the code is not accessible by <code>ajc</code>.
 * Thus, the pointcuts would not match appropriately. A solution would be to 
 * Subclass all potential Objects, but that seems to be unneccessarily
 * complex.
 *
 * @author Jan Hannemann
 * @author Gregor Kiczales
 * @version 1.0, 05/13/02
 *
 */

public abstract aspect ChainOfResponsibilityProtocol {
 
 /** 
 * true if the notification mode is on, false otherwise
 */ 
 
 protected boolean notificationOn = false;
 
 /**
 * This interface is used by extending aspects to say what types
 * handle requests. It models the Handler role.
 */

	protected interface Handler {} 


 /**
 * Stores the mapping between <code>Handler</code>s and its
 * Successor. For each handler, its Successor
 * is stored.
 */
	
	public WeakHashMap successors = new WeakHashMap();
	
 
 /**
 * Implements the abstracted CoR behavior. Assumption: If the request is
 * not handled, the last receiver handles it by default ( that is true
 * for this implementnation of the protocol). 
 *
 * The current handler gets asked if it wants to handle the request. If
 * not, the request is forwarded to its successor
 */

	protected void receiveRequest(Handler handler, Object request) { 
		note("Call received for: "+handler.getClass().getName());
		if (handler.acceptRequest(request)) {
 		 note("Class "+handler.getClass().getName()+" is accepting the request");
		 handler.handleRequest(request);
 		 note("Call handled.\n");
		} else { 
 		 note("Class "+handler.getClass().getName()+" is rejecting the request");
 		 Handler successor = getSuccessor(handler); 
		 if (successor == null) {
		 note("Request unhandled!\n");
		 } else {
 			note("Call forwarded to: "+successor.getClass().getName());
 	 	 receiveRequest(successor, request);
 	 	}
		}
	} 

 /**
 * Method attached to Handlers: returns true if a Handler wants to hanlde 
 * that request. By default, requests are rejected.
 *
 * @param request the request to be handled
 */
		
	public boolean Handler.acceptRequest(Object request) { 
	 System.out.println("Default reject: event from "+this.getClass().getName());
	 return false;
 }
	
 /**
 * Method attached to Handlers: handles a request. Default implementation
 * does nothing, only shows an error message.
 *
 * @param request the request to be handled
 */
		
	public void Handler.handleRequest(Object request) { // The Event is not handled elsewhere
	 System.out.println("No successor, request ignored");
	}


 /**
 * The join points after which a request is raised.
 * It replaces the normally scattered calls to notify(). To be
 * concretized by sub-aspects.
 */ 
 
 protected abstract pointcut eventTrigger(Handler handler, Object request); 
 

 /**
 * Call receiveRequest after a request was triggered.
 *
 * @param s the subject on which the change occured
 */

	after(Handler handler, Object request): eventTrigger(handler, request) { 
		receiveRequest(handler, request);
	}
 
 
 /**
 * Adds a successor to a handler. 
 *
 * @param handler the handler to attach a new successor to
 * @param successor the new successor to attach
 */ 
 
	public void setSuccessor(Handler handler, Handler successor) {
		successors.put(handler, successor);
	} 

	
 /**
 * Returns the successor of a handler. 
 *
 * @param handler the handler in question
 * @return the successor of the handler
 */ 
 
	public Handler getSuccessor(Handler handler) { 
	 return ((Handler) successors.get(handler));
	} 

	
 /**
 * Turns the notification mode on or off. 
 *
 * @param choice true to turn notifications on, false to turn them off 
 */ 
 
	public void setNotification(boolean choice) { 
	 this.notificationOn = choice;
	} 	

 /**
 * Returns the successor of a handler. 
 *
 * @param msg the message to print
 */ 
 
	public void note(String msg) { 
	 if (notificationOn) {
	 System.out.println(msg);
	 }
	} 
}

Command.java

2004-03-24T16:00:00Z

CommandInvoker.java

2004-03-24T16:00:00Z

MediatorProtocol.java

2004-03-24T16:00:00Z

Memento.java

2004-03-24T16:00:00Z

MementoException.java

2004-03-24T16:00:00Z

MementoProtocol.java

2004-03-24T16:00:00Z

ObserverProtocol.java

2004-03-24T16:00:00Z

package ca.ubc.cs.spl.pattern.library;

/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
 *
 * This file is part of the design patterns project at UBC
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.1 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * either http://www.mozilla.org/MPL/ or http://aspectj.org/MPL/.
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is ca.ubc.cs.spl.patterns.
 *
 * Contributor(s): 
 */

import java.util.WeakHashMap;
import java.util.List;
import java.util.LinkedList;
import java.util.Iterator;

/**
 * Defines the general behavior of the observer design pattern.
 *
 * Each concrete sub-aspect of ObserverProtocol defines one kind of observing
 * relationship. Within that kind of relationship, there can be any number
 * of subjects, each with any number of observers.
 *
 * The sub-aspect defines three things: <ol>
 *
 * <li> what types can be subjects or observers 
 * this is done using +implements
 *
 * <li> what operations on the subject require updating the observers 
 * this is done by concretizing the changes(Subject) pointcut
 *
 * <li> how to update the observers 
 * this is done by defining a method on
 * updateObserver(Subject, Observer) 
 * </ol>
 *
 * Note that in this implementation, the work of updating is a method
 * on the sub-aspect, not a method introduced on the observer. This
 * allows one class of object to be the observer in different kinds of
 * observing relationships, each of which has a different updating
 * behavior. For observers that just have a single generic update
 * behavior, the method on updateObserver will just be a simple call
 * that generic updater.
 *
 * @author Gregor Kiczales
 * @author Jan Hannemann
 * @version 1.0, 05/13/02
 *
 */
 
public abstract aspect ObserverProtocol { 
 
 
 /**
 * This interface is used by extending aspects to say what types
 * can be subjects. It models the subject role.
 */

 protected interface Subject { } 


 /**
 * This interface is used by extending aspects to say what types
 * can be observers. It models the observer role.
 */

 protected interface Observer { }


 /**
 * Stores the mapping between <code>Subject</code>s and <code>
 * Observer</code>s. For each subject, a <code>LinkedList</code>
 * is of its observers is stored.
 */
 
 private WeakHashMap perSubjectObservers;


 /**
 * Returns a <code>Collection</code> of the observers of 
 * a particular subject. Used internally.
 *
 * @param s the subject for which to return the observers
 * @return a <code>Collection</code> of s's observers
 */

 protected List getObservers(Subject s) { 
 if (perSubjectObservers == null) {
 perSubjectObservers = new WeakHashMap();
 }
 List observers = (List)perSubjectObservers.get(s);
 if ( observers == null ) {
 observers = new LinkedList();
 perSubjectObservers.put(s, observers);
 }
 return observers;
 }

 
 /**
 * Adds an observer to a subject. This is the equivalent of 
 * attach(), but is a method on the pattern aspect, not the subject. 
 *
 * @param s the subject to attach a new observer to
 * @param o the new observer to attach
 */ 
 
 public void addObserver(Subject s, Observer o) { 
 getObservers(s).add(o); 
 }
 
 /**
 * Removes an observer from a subject. This is the equivalent of 
 * detach(), but is a method on the pattern aspect, not the subject. 
 *
 * @param s the subject to remove the observer from
 * @param o the observer to remove
 */ 
 
 public void removeObserver(Subject s, Observer o) { 
 getObservers(s).remove(o); 
 }

 /**
 * The join points after which to do the update.
 * It replaces the normally scattered calls to notify(). To be
 * concretized by sub-aspects.
 */ 
 
 protected abstract pointcut subjectChange(Subject s);

 /**
 * Call updateObserver after a change of interest to update each observer.
 *
 * @param s the subject on which the change occured
 */

 after(Subject s): subjectChange(s) {
 Iterator iter = getObservers(s).iterator();
 while ( iter.hasNext() ) {
 updateObserver(s, ((Observer)iter.next()));
 }
 } 
 
 /**
 * Defines how each <code>Observer</code> is to be updated when a change
 * to a <code>Subject</code> occurs. To be concretized by sub-aspects.
 *
 * @param s the subject on which a change of interest occured
 * @param o the observer to be notifed of the change 
 */

 protected abstract void updateObserver(Subject s, Observer o);
}

PrototypeProtocol.java

2004-03-24T16:00:00Z

ProxyProtocol.java

2004-03-24T16:00:00Z

SingletonProtocol.java

2004-03-24T16:00:00Z

StrategyProtocol.java

2004-03-24T16:00:00Z

VisitorProtocol.java

2004-03-24T16:00:00Z