277294.ijbsn.asia

Builder.java

2004-03-24T16:00:00Z

BuilderInstance.java

2004-03-24T16:00:00Z

package examples.builder.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): 
 */

/**
 * Implements a concrete builder design pattern instance. This aspect allows
 * to have the <code>Builder</code> abstract class to become an interface,
 * without losing the possibility to attach default implementations and even
 * variables.
 *
 * This also illiustrates the tradeoffs: The current version of AspectJ 
 * (1.0.4) does not allow protected introduction. To achieve the same result
 * as in the OO case, the result variable has to be introduced as public
 * (to be inherited). To make sure that no other classes can access that
 * variable, we define an error here that the compiler reports when other
 * classes try to access the result variable.
 *
 * @author Jan Hannemann
 * @author Gregor Kiczales
 * @version 1.0, 07/13/02
 * 
 * @see Builder
 * @see TextBuilder
 * @see StructureBuilder
 */

public aspect BuilderInstance {
 
 /**
 * Attaches the result variable to the <code>Builder</code> interface.
 */
 
 public String Builder.result;

 /**
 * Attaches the method with a default implementation to the 
 * <code>Builder</code> interface.
 *
 * @returns the result string for the builder.
 */

 public String Builder.getResult() {
 return result;
 }
 
 /**
 * Declares a compiler error that gets reported if other classes 
 * (except Builders or this aspect) try to access the result variable.
 */
 
 declare error: (set(public String Builder+.result) 
 || get(public String Builder+.result)) 
 && ! (within(Builder+) 
 || within(BuilderInstance)): 
 "variable result is aspect protected. "
 +"use getResult() to access it";
}

Main.java

2004-03-24T16:00:00Z

package examples.builder.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 Builder design pattern example. 
 *
 * Intent: Separate the construction of a complex object from its 
 * representation so that the same construction process can create different 
 * representations
 *
 * Participatng objects are <code>TextBuilder</code> and 
 * <code>StructureBuilder</code> as Builders that implement the
 * <code>Builder</code> interface.
 *
 * In this example, <code>Main</code> acts as the Director that
 * uses two different builders to build string representations of a
 * person. <code>TextBuilder</code> creates a text-like representation,
 * <code>StructureBuilder</code> a XML-like one.
 *
 * This is the Java version.
 *
 * In Java, the Builder has to be an abstract class (as opposed to
 * an interface) to allow to define variables or default implementations
 * there. Consequently, all ConcreteBuilders have to have that
 * class as their superclass, making it impossible to be part of another
 * class hierarchy.
 *
 * @author Jan Hannemann
 * @author Gregor Kiczales
 * @version 1.0, 05/13/02
 * 
 * @see Builder
 * @see TextBuilder
 * @see StructureBuilder
 */

public class Main {

 /** 
 * Builds a string representation of a person using a given builder.
 *
 * @param the builder to use.
 */

 protected static void build(Builder builder) {
 builder.processType("Person");
 builder.processAttribute("Name");
 builder.processValue("James Brick");
 builder.processAttribute("Age");
 builder.processValue("33");
 builder.processAttribute("Occupation");
 builder.processValue("Builder"); 
 }

 /**
 * Implements the driver for the Builder design pattern example. 
 *
 * In this example, <code>Main</code> acts as the Director that
 * uses two different builders to build string representations of a
 * person. <code>TextBuilder</code> creates a text-like representation,
 * <code>StructureBuilder</code> a XML-like one.
 * 
 * @param args the command-line parameters, unused.
 *
 */

 public static void main(String[] args) {
 
 Builder builder1 = new TextBuilder();
 Builder builder2 = new StructureBuilder();
 
 build(builder1);
 build(builder2);
 
 System.out.println(builder1.getResult());
 System.out.println(builder2.getResult());
 }
}

StructureBuilder.java

2004-03-24T16:00:00Z

package examples.builder.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 a ConcreteBuilder that builds XML descriptions
 * of complex objects consisting of type, attributes and values.
 *
 * @author Jan Hannemann
 * @author Gregor Kiczales
 * @version 1.0, 05/13/02
 */

public class StructureBuilder extends Builder {

 protected String type = null;
 protected String attribute = null;

 /** 
 * Defines the buildPart() operation for type parts.
 *
 * @param type the type to process
 */ 

 public void processType(String newType) {
 result = "<"+newType+">\n";
 type = newType;
 }
 
 /** 
 * Defines the buildPart() operation for attribute parts.
 *
 * @param type the type to process
 */ 

 public void processAttribute(String newAttribute) {
 if (attribute != null) {
 result += ("</" + attribute + ">\n");
 }
 result += ("\t<" + newAttribute + ">");
 this.attribute = newAttribute;
 }
 
 /** 
 * Defines the buildPart() operation for value parts.
 *
 * @param type the type to process
 */ 

 public void processValue(String type) {
 result += (type);
 }
 
 /** 
 * Defines the getResult() operation for Builders. Includes
 * a default implementation.
 *
 * @param type the type to process
 */ 

 public String getResult() {
 if (attribute != null) {
 result += ("</" + attribute + ">\n");
 attribute = null;
 }
 if (type != null) {
 result += ("</" + type + ">\n");
 type = null;
 }
 return result;
 }
}

TextBuilder.java

2004-03-24T16:00:00Z

files.lst

2004-03-24T16:00:00Z