carfield.com.hk

CompositeA.java

2004-03-24T16:00:00Z

LeafB.java

2004-03-24T16:00:00Z

Main.java

2004-03-24T16:00:00Z

package examples.composite.aspectj;


/* -*- 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.pattern.
 *
 * Contributor(s): 
 */
 
import java.util.Enumeration;

/**
 * Implements the driver for the composite design pattern example. 
 *
 * Intent: Compose objects into tree structures torepresent part-whole 
 * hierarchies. Composite lets clients treat individual objects and 
 * compositions of objects uniformly.
 *
 * Participatng classes are <code>CompositeA</code>s as Composites,
 * and a <code>LeafB</code> as Leaf. Both implement the 
 * Component interface.
 *
 * This example creates a simple structure as follows: Composite c1 has 
 * three children: l1, c2, and l3. c2 has l2 as a child.
 * Compact notation: c1(l1, c2(l2), l3)
 *
 * This is the AspectJ version. 
 *
 * Composites and Leafs do not need to know about their role in the pattern.
 * This example also illustrates how to define methods that collect 
 * information from the whole aggreagate structure (using visitors).
 * One of them prints the compiste structure, the other one collects the
 * sum of the values of all leaves in the structure.
 *
 * @author Jan Hannemann
 * @author Gregor Kiczales
 * @version 1.0, 05/13/02
 * 
 * @see Component
 * @see CompositeA 
 * @see LeafB
 */
 
 public class Main { 
 
	/**
	 * helper variable to store recursion depth for pretty printing
	 */
	 
 static int indent = 0; 
 
 /**
 * Print a number of spaces according to the current recursion depth
 */
 	
 private static void indent() {
 for (int i=0; i<indent; i++)
 System.out.print(" ");
 }
 
 /** 
 * Pretty-prints a recursive composite structure 
 *
 * @param comp the component denoting the entry point into the structure
 */
 
 private static void printStructure(SampleComposite.Component comp) { 
 indent();
 System.out.println("Showing: "+comp);
 indent +=4; 
 for (Enumeration enum = SampleComposite.aspectOf().getAllChildren(comp); enum.hasMoreElements();) {
 printStructure((SampleComposite.Component) enum.nextElement());
 }
 indent -= 4;
 }


 /**
 * This example creates a simple structure as follows: Composite c1 has 
 * three children: l1, c2, and l3. c2 has l2 as a child.
 * Compact notation: c1(l1, c2(l2), l3) 
 *
 * Also, this example illustrates how to define methods that collect 
 * information from the whole aggreagate structure (using visitors).
 * One of them prints the compiste structure, the other one collects the
 * sum of the values of all leaves in the structure. 
 */

 public static void main(String[] args) { 
 
 System.out.println("\n<<< Testing implementation AOP3 of Composite pattern >>>\n");
 System.out.print ("Creating Composite structure ...");

 CompositeA composite1 = new CompositeA(1);
 CompositeA composite2 = new CompositeA(2);

 LeafB leaf1 = new LeafB(1);
 LeafB leaf2 = new LeafB(2);
 LeafB leaf3 = new LeafB(3); 
 
 SampleComposite.aspectOf().addChild(composite1, leaf1);
 SampleComposite.aspectOf().addChild(composite1, composite2);
 SampleComposite.aspectOf().addChild(composite2, leaf2);
 SampleComposite.aspectOf().addChild(composite1, leaf3);
 
 System.out.println("done."); 
 System.out.println("This is the Structure:");
 
 printStructure(composite1);
 
 System.out.println("\nCalling printStructure(PrintStream) on Composition.Components ...");
 composite1.printStructure(System.out); 
 System.out.println("... done.");

 System.out.println("\nCalling subSum():int on the structure ...");
 System.out.println("The leaf id sum is: "+composite1.subSum()); 
 System.out.println("... done.");

 System.out.println("\n<<< Test completed >>>\n");
 }
}

SampleComposite.java

2004-03-24T16:00:00Z

package examples.composite.aspectj;

/* -*- 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.pattern.
 *
 * Contributor(s): 
 */
 
import java.io.PrintStream; 
import java.util.Enumeration; 
import ca.ubc.cs.spl.pattern.library.CompositeProtocol;

/**
 * Implements a concrete instance of the composite design pattern. 
 * 
 * It maintains the mapping between composites and their children, defines the
 * component, composite, and leaf roles, and implements facilities to
 * implements methods that work on the whole aggregate structure.
 *
 * This is the AspectJ version. 
 *
 * Each concrete subaspect does the following things: <UL>
 * <LI> Define which classes are Components and Leafs
 * <LI> (optional) Define methods that operate on the whole aggregate
 * structure (using visitors)
 * </UL>
 *
 * @author Jan Hannemann
 * @author Gregor Kiczales
 * @version 1.1, 11/25/02
 * 
 * @see Component
 * @see CompositeA 
 * @see LeafB
 */

public aspect SampleComposite extends CompositeProtocol {

 /** 
 * Assigns the Composite role to <code>CompositeA</code>
 */
 
 declare parents: CompositeA implements Composite; // Role Pattern: Assigning Roles

 /** 
 * Assigns the Leaf role to <code>LeafB</code>
 */

 declare parents: LeafB implements Leaf; // Role Pattern: Assigning Roles 
 


 // Test1: Attaching an operation with arguments
 
	/**
	 * helper variable to store recursion depth for pretty printing
	 */

 private static int indent = 0;

 /**
 * Print a number of spaces according to the current recursion depth
 */

 private static void indent() {
		for (int i=0; i<indent; i++)
			System.out.print(" ");
	}

 /**
 * Provides a client-accessible method that pretty-prints the 
 * structure of the aggregate structure using a Visitor
 *
 * @param s the PrintStram to print to
 */

 public void Component.printStructure(PrintStream s) {
 indent();
 s.println("<Component>"+this);
 } 
 
 /**
 * Implements <code>printStructure</code> for Composites: The indent 
 * is appropriately updated and the method call is forwarded to all 
 * children.
 *
 * @param s the PrintStram to print to
 */

 public void Composite.printStructure(final PrintStream s) {
 indent();
 s.println("<Composite>"+this);
 indent +=4;
 SampleComposite.aspectOf().recurseOperation(this, new Visitor() { 
 public void doOperation(Component c) { c.printStructure(s); } 
 } );
 indent -=4;
 }

 /**
 * Implements <code>printStructure</code> for Leafs.
 *
 * @param s the PrintStram to print to
 */

 public void Leaf.printStructure(PrintStream s) {
 indent();
 s.println("<Leaf>"+this);
 }
 
 
 
 
 
 // Test2: Collecting statistics on the structure (aggregation)
 
 /**
 * Provides a client-accessible method that pretty-prints the 
 * structure of the aggregate structure using a FunctionVisitor. 
 * Calculates the sum of all Leaf IDs in the structure 
 *
 * @returns the sum of leaf ids of all elements in this structure
 */ 
 
 public int Component.subSum() {
 return 0;
 }

 /**
 * Implements <code>subSum()</code> for Composites: The method call 
 * is forwarded to all children, then the results are summed up.
 *
 * @returns the sum of leaf ids of all elements in this structure
 */

 public int Composite.subSum() { // Collects the sum of all Leaves in the structure
 Enumeration enum = SampleComposite.aspectOf().recurseFunction(this, new FunctionVisitor() { 
 public Object doFunction(Component c) { 
 return new Integer(c.subSum()); 
 }
 }); 
 
 int sum = 0;
 while (enum.hasMoreElements()) {
 sum += ((Integer) enum.nextElement()).intValue();
 }
 return sum;
 }
 
 /**
 * Implements <code>subSum()</code> for Leafs: Simply returns
 * the Leaf's ID.
 *
 * @returns the leaf id
 */

 public int LeafB.subSum() {
 return id;
 }
}

files.lst

2004-03-24T16:00:00Z