277294.ijbsn.asia

Directory.java

2004-03-24T16:00:00Z

File.java

2004-03-24T16:00:00Z

Leaf.java

2004-03-24T16:00:00Z

Main.java

2004-03-24T16:00:00Z

package examples.visitor.java;

/* -*- 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): 
 */

/**
 * Implements the driver for the Visitor design pattern example. 
 *
 * Intent: Represents an operation to be performed on the elements of an 
 * object structure. Visitor lets you define a new operation without changing
 * the classes of the elements on which it operates
 *
 * Participating classes are <code>SumVisitor</code> and 
 * <code>TraversalVisitor</code> as ConcreteVisitors, implementing the 
 * <code>NodeVisitor</code> interface. 
 * <code>RegularNode</code> and <code>Leaf</code> are ConcreteElements, 
 * implementing the <code>Node</code> interface. 
 *
 * In this example, Node, RegularNode and Leaf build up a binary tree that has 
 * int values as leafs. SumVisitor is a NodeVisitor that collects the sum of 
 * elements in the leafs (should be 6). TraversalVisitor is a visitor that 
 * collects a description of the tree like {{1,2},3}
 *
 * This is the Java version.
 *
 * Note that <UL>
 * <LI> Every visitor (even the inteface) has to know of each possible element 
 * type in the object structure. 
 * <LI> Nodes need to know of the visitor interface; they have to implement the 
 * accept(NodeVisitor) method.
 * </UL>
 *
 * @author Jan Hannemann
 * @author Gregor Kiczales
 * @version 1.0, 06/13/02
 * 
 * @see Node
 * @see RegularNode
 * @see Leaf
 * @see NodeVisitor
 * @see SumVisitor
 * @see TraversalVisitor
 */

public class Main { 
	
 /**
 * Implements the driver for the Visitor design pattern example. 
 *
 * In this example, Node, RegularNode and Leaf build up a binary tree that has 
 * int values as leafs. SumVisitor is a NodeVisitor that collects the sum of 
 * elements in the leafs (should be 6). TraversalVisitor is a visitor that 
 * collects a description of the tree like {{1,2},3} 
 *
 * @param args the command-line parameters, unused
 */


	public static void main(String[] args) { 
	 
	 System.out.println("Building the tree (1): leaves");
		
		Leaf one = new Leaf(1);
		Leaf two = new Leaf(2);
		Leaf three = new Leaf(3);
		
	 System.out.println("Building the tree (1): regular nodes");
		
		RegularNode regN = new RegularNode(one, two);
		RegularNode root = new RegularNode(regN, three);
		
 System.out.println("The tree now looks like this: ");
 System.out.println(" regN ");
 System.out.println(" / \\ ");
 System.out.println(" regN 3 ");
 System.out.println(" / \\ ");
 System.out.println(" 1 2 ");
		 
 System.out.println("Visitor 1: SumVisitor, collects the sum of leaf");
 System.out.println("values. Result should be 6.");
				 
		SumVisitor sumVisitor = new SumVisitor(); 
		root.accept(sumVisitor);
		System.out.println(sumVisitor.report()); 
		
 System.out.println("Visitor 2: TraversalVisitor, collects a tree");
 System.out.println("representation. Result should be {{1,2},3}.");
		
		TraversalVisitor traversalVisitor = new TraversalVisitor(); 
		root.accept(traversalVisitor);
		System.out.println(traversalVisitor.report()); 
	}
}

MyVisitor.java

2004-03-24T16:00:00Z

package examples.visitor.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 ca.ubc.cs.spl.pattern.library.VisitorProtocol;

/**
 * Implements a concrete visitor pattern instance. This aspect assings
 * the roles to the participants.
 *
 * @author Jan Hannemann
 * @author Gregor Kiczales
 * @version 1.0, 06/13/02
 */

public aspect MyVisitor extends VisitorProtocol { 
 
 /** 
 * Assigns the <code>VisitorNode</code> role to <code>Node</code>
 */

 declare parents: Node implements VisitorNode;

 /** 
 * Assigns the <code>VRegularNode</code> role to <code>RegularNode</code>
 */

 declare parents: RegularNode implements VRegularNode;

 /** 
 * Assigns the <code>VLeaf</code> role to <code>Leaf</code>
 */

 declare parents: Leaf implements VLeaf;
}

Node.java

2004-03-24T16:00:00Z

NodeVisitor.java

2004-03-24T16:00:00Z

RegularNode.java

2004-03-24T16:00:00Z

SampleComposite.java

2004-03-24T16:00:00Z

package examples.testcomposite.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.0, 05/13/02
 * 
 * @see Component
 * @see CompositeA 
 * @see LeafB
 */

public aspect SampleComposite extends CompositeProtocol {

 /** 
 * Assigns the Composite role to <code>CompositeA</code>
 */
 
 declare parents: Directory implements Composite; // Role Pattern: Assigning Roles

 /** 
 * Assigns the Leaf role to <code>LeafB</code>
 */

 declare parents: File 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(" ");
	} 
	
/*
	public int sizeOnDisk(Component c) {
	 return c.sizeOnDisk();
	}
	
	private int Component.sizeOnDisk() {
	 Enumeration e = SampleComposite.aspectOf().recurseFunction(this, new FunctionVisitor() {
	 public Object doFunction(Component c) {
	 return new Integer(c.sizeOnDisk());
	 }
	 });
	 
	 int sum =0;
	 while (e.hasMoreElements()) {
	 sum += ((Integer)e.nextElement()).intValue();
	 }
	 return sum;
	
 }

 private int File.sizeOnDisk() {return id;}
*/

 public int sizeOnDisk(Component c) { // Does not work
 return c.sizeOnDisk();
 }

 private int Component.sizeOnDisk() {return 0;}
 
 private int Directory.sizeOnDisk() { 
 int sum = 0; 
 java.util.Enumeration children;
 for (children = SampleComposite.aspectOf().getAllChildren(this); children.hasMoreElements(); ) {
 sum += ((Component)children.nextElement()).sizeOnDisk();
 }
 return sum;
 }
 
 private int File.sizeOnDisk() { return id; }


/* public int sizeOnDisk(Component c) { // Works
 int sum = 0;
 if (c instanceof File) {
 sum = ((File)c).id;
 } else if (c instanceof Directory) {
 java.util.Enumeration children;
 for (children = SampleComposite.aspectOf().getAllChildren(c); children.hasMoreElements(); ) {
 sum += sizeOnDisk((Component)children.nextElement());
 } 
 }
 return sum;
 }
*/

 /**
 * 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();
 System.out.println("Sum = "+sum);
 }
 return sum;
 }
 
 /**
 * Implements <code>subSum()</code> for Leafs: Simply returns
 * the Leaf's ID.
 *
 * @returns the leaf id
 */

 public int File.subSum() {
 return id;
 }
}

SumVisitor.java

2004-03-24T16:00:00Z

TraversalVisitor.java

2004-03-24T16:00:00Z

Visitor.java

2004-03-24T16:00:00Z

files.lst

2004-03-24T16:00:00Z