277294.ijbsn.asia

AbstractionImplementation.java

2004-03-24T16:00:00Z

package examples.bridge.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.patterns.
 *
 * Contributor(s): 
 */


/**
 * Represents the Abstraction in the scenario. <code>Screen</code>
 * provides two methods to draw/print: <code>drawText(String)</code> and
 * <code>drawTextBox(String)</code>. The method implementations are provided
 * by an aspect.
 *
 * @author Jan Hannemann
 * @author Gregor Kiczales
 * @version 1.0, 05/13/02
 *
 */

public aspect AbstractionImplementation { 

 /**
 * stores the actual Implementor to use 
 */

 private ScreenImplementation Screen.implementor; 
 
 /**
 * Draws or prints a text to an output device determined by the 
 * current Implementor.
 *
 * @param text The text to be drawn/printed
 */
 
 public void Screen.drawText(String text) {
 implementor.printText(text);
 implementor.printLine();
 }
 
 /**
 * Draws or prints a text in a box to an output device determined 
 * by the current Implementor.
 *
 * @param text The text to be drawn/printed
 */
 
 public void Screen.drawTextBox(String text) {

 int length = text.length();

 for(int i=0; i<length+4; i++) {
 implementor.printDecor();
 }

 implementor.printLine();
 implementor.printDecor();
 implementor.printText(" "+text+" ");
 implementor.printDecor();
 implementor.printLine();
 
 for(int i=0; i<length+4; i++) {
 implementor.printDecor();
 }

 implementor.printLine(); 
 }
 
 /**
 * Sets the current Implementor.
 *
 * @param implementor The new implementor
 */
 
 public void Screen.setImplementor(ScreenImplementation implementor) {
 this.implementor = implementor;
 }

}

CrossCapitalImplementation.java

2004-03-24T16:00:00Z

GreetingScreen.java

2004-03-24T16:00:00Z

InformationScreen.java

2004-03-24T16:00:00Z

Main.java

2004-03-24T16:00:00Z

package examples.bridge.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.patterns.
 *
 * Contributor(s): 
 */

/**
 * Implements the driver for the Bridge design pattern example. 
 *
 * Intent: Decouple an abstraction from its implementation so that the 
 * two can vary independently.
 *
 * Scenario: Have seperate hierarchies for Abstractions (here: Screens)
 * and Implementors (here: ScreenImplementation), so that both 
 * can change independently of each other 
 *
 * Participants: <UL>
 *
 * <LI> <code>Screen</code> - Abstract Abstraction that defines 
 * an interface for printing text and boxedText to stdout. 
 * <LI> <code>GreetingScreen</code> - RefinedAbstraction that prints
 * a boxed greeting message
 * <LI> <code>InformationScreen</code> - RefinedAbstraction that prints
 * the system time (boxed)
 * <LI> <code>ScreenImplementation</code> - Implementor interface, 
 * defines basic operations to output formatted strings
 * <LI> <code>StarImplementation</code> - ConcreteImplementation that 
 * creates textBoxes of stars
 * <LI> <code>CrossCapitalImplementation</code> - ConcreteImplementation
 * that creates textBoxes of double crosses (hashes) and prints all
 * text capitalized
 * </UL>
 *
 * This is the Java implementation.
 *
 * Note that Abstraction cannot be an interface in Java, as we need to
 * specify how operation() is performed using the interface of 
 * Implementor. As Abstraction is not necessarily a defining 
 * role, this is a limitation. With multiple inheritance, this would not be
 * the case.
 *
 * @author Jan Hannemann
 * @author Gregor Kiczales
 * @version 1.0, 05/13/02
 *
 * @see Screen
 * @see InformationScreen
 * @see GreetingScreen
 * @see ScreenImplementation
 * @see StarImplementation
 * @see CrossCapitalImplementation
 */
 
 
public class Main {

 /**
 * Implements the driver for this example. The two different screens
 * and screen implementations are tested in all possible combinations.
 *
 * @param args required by Java, but ignored
 */
 
 public static void main(String[] args) { 
 
 System.out.println("Creating implementations...");
 
 ScreenImplementation i1 = new StarImplementation();
 ScreenImplementation i2 = new CrossCapitalImplementation();
 
 System.out.println("Creating abstraction (screens) / implementation combinations...");
 
 GreetingScreen gs1 = new GreetingScreen(i1);
 GreetingScreen gs2 = new GreetingScreen(i2);
 InformationScreen is1 = new InformationScreen(i1);
 InformationScreen is2 = new InformationScreen(i2); 
 
 System.out.println("Starting test:\n");
 
 gs1.drawText("\nScreen 1 (Refined Abstraction 1, Implementation 1):");
 gs1.drawGreeting();
 
 gs2.drawText("\nScreen 2 (Refined Abstraction 1, Implementation 2):");
 gs2.drawGreeting();
 
 is1.drawText("\nScreen 3 (Refined Abstraction 2, Implementation 1):");
 is1.drawInfo();

 is2.drawText("\nScreen 4 (Refined Abstraction 2, Implementation 2):");
 is2.drawInfo();
 }
}

Screen.java

2004-03-24T16:00:00Z

ScreenImplementation.java

2004-03-24T16:00:00Z

StarImplementation.java

2004-03-24T16:00:00Z

files.lst

2004-03-24T16:00:00Z