Interpreter Pattern 2 : Interpretor Pattern « Design Pattern « Java

1. Java
2. Design Pattern
3. Interpretor Pattern

Interpreter Pattern 2

//[C] 2002 Sun Microsystems, Inc.---

import java.io.Serializable;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;

public class RunInterpreterPattern {
  public static void main(String[] arguments) {
    System.out.println("Example for the Interpreter pattern");
    System.out.println("In this demonstration, the syntax defined");
    System.out.println(" by the Interpreter can be used to search");
    System.out.println(" among a collection of Contacts, returning");
    System.out.println(" the subset that match the given search criteria.");

    ContactList candidates = makeContactList();
    Context ctx = new Context();

    System.out.println("Contents of the ContactList:");
    System.out.println(candidates);
    System.out.println();

    Contact testContact = new ContactImpl();
    VariableExpression varLName = new VariableExpression(testContact,
        "getLastName");
    ConstantExpression constLName = new ConstantExpression("u");
    ContainsExpression eqLName = new ContainsExpression(varLName,
        constLName);

    System.out.println("Contents of the search on ContactList:");
    System.out.println("(search was contains 'u' in Lase Name)");
    Object result = candidates.getContactsMatchingExpression(eqLName, ctx,
        testContact);
    System.out.println(result);

    VariableExpression varTitle = new VariableExpression(testContact,
        "getTitle");
    ConstantExpression constTitle = new ConstantExpression("LT");
    EqualsExpression eqTitle = new EqualsExpression(varTitle, constTitle);

    System.out.println("Contents of the search on ContactList:");
    System.out.println("(search was all LT personnel)");
    result = candidates.getContactsMatchingExpression(eqTitle, ctx,
        testContact);
    System.out.println(result);
    System.out.println();

    VariableExpression varLastName = new VariableExpression(testContact,
        "getLastName");
    ConstantExpression constLastName = new ConstantExpression("S");
    ContainsExpression cLName = new ContainsExpression(varLastName,
        constLastName);

    AndExpression andExpr = new AndExpression(eqTitle, cLName);

    System.out.println("Contents of the search on ContactList:");
    System.out
        .println("(search was all LT personnel with 'S' in Last Name)");
    result = candidates.getContactsMatchingExpression(andExpr, ctx,
        testContact);
    System.out.println(result);
  }

  private static ContactList makeContactList() {
    ContactList returnList = new ContactList();
    returnList.addContact(new ContactImpl("James", "Kirk", "Captain",
        "USS Enterprise"));
    returnList.addContact(new ContactImpl("Mr.", "Spock",
        "Science Officer", "USS Enterprise"));
    returnList.addContact(new ContactImpl("LT", "Uhura", "LT",
        "USS Enterprise"));
    returnList.addContact(new ContactImpl("LT", "Sulu", "LT",
        "USS Enterprise"));
    returnList.addContact(new ContactImpl("Ensign", "Checkov", "Ensign",
        "USS Enterprise"));
    returnList.addContact(new ContactImpl("Dr.", "McCoy", "Ship's Doctor",
        "USS Enterprise"));
    returnList.addContact(new ContactImpl("Montgomery", "Scott", "LT",
        "USS Enterprise"));
    return returnList;
  }
}

interface Contact extends Serializable {
  public static final String SPACE = " ";

  public String getFirstName();

  public String getLastName();

  public String getTitle();

  public String getOrganization();

  public void setFirstName(String newFirstName);

  public void setLastName(String newLastName);

  public void setTitle(String newTitle);

  public void setOrganization(String newOrganization);
}

class ContactImpl implements Contact {
  private String firstName;

  private String lastName;

  private String title;

  private String organization;

  public ContactImpl() {
  }

  public ContactImpl(String newFirstName, String newLastName,
      String newTitle, String newOrganization) {
    firstName = newFirstName;
    lastName = newLastName;
    title = newTitle;
    organization = newOrganization;
  }

  public String getFirstName() {
    return firstName;
  }

  public String getLastName() {
    return lastName;
  }

  public String getTitle() {
    return title;
  }

  public String getOrganization() {
    return organization;
  }

  public void setFirstName(String newFirstName) {
    firstName = newFirstName;
  }

  public void setLastName(String newLastName) {
    lastName = newLastName;
  }

  public void setTitle(String newTitle) {
    title = newTitle;
  }

  public void setOrganization(String newOrganization) {
    organization = newOrganization;
  }

  public String toString() {
    return firstName + SPACE + lastName;
  }
}

class ContactList implements Serializable {
  private ArrayList contacts = new ArrayList();

  public ArrayList getContacts() {
    return contacts;
  }

  public Contact[] getContactsAsArray() {
    return (Contact[]) (contacts.toArray(new Contact[1]));
  }

  public ArrayList getContactsMatchingExpression(Expression expr,
      Context ctx, Object key) {
    ArrayList results = new ArrayList();
    Iterator elements = contacts.iterator();
    while (elements.hasNext()) {
      Object currentElement = elements.next();
      ctx.addVariable(key, currentElement);
      expr.interpret(ctx);
      Object interpretResult = ctx.get(expr);
      if ((interpretResult != null)
          && (interpretResult.equals(Boolean.TRUE))) {
        results.add(currentElement);
      }
    }
    return results;
  }

  public void setContacts(ArrayList newContacts) {
    contacts = newContacts;
  }

  public void addContact(Contact element) {
    if (!contacts.contains(element)) {
      contacts.add(element);
    }
  }

  public void removeContact(Contact element) {
    contacts.remove(element);
  }

  public String toString() {
    return contacts.toString();
  }
}

class Context {
  private HashMap map = new HashMap();

  public Object get(Object name) {
    return map.get(name);
  }

  public void addVariable(Object name, Object value) {
    map.put(name, value);
  }
}

interface Expression {
  void interpret(Context c);
}

class OrExpression extends CompoundExpression {
  public OrExpression(ComparisonExpression expressionA,
      ComparisonExpression expressionB) {
    super(expressionA, expressionB);
  }

  public void interpret(Context c) {
    expressionA.interpret(c);
    expressionB.interpret(c);
    Boolean result = new Boolean(((Boolean) c.get(expressionA))
        .booleanValue()
        || ((Boolean) c.get(expressionB)).booleanValue());
    c.addVariable(this, result);
  }
}

abstract class CompoundExpression implements Expression {
  protected ComparisonExpression expressionA;

  protected ComparisonExpression expressionB;

  public CompoundExpression(ComparisonExpression expressionA,
      ComparisonExpression expressionB) {
    this.expressionA = expressionA;
    this.expressionB = expressionB;
  }
}

class ConstantExpression implements Expression {
  private Object value;

  public ConstantExpression(Object newValue) {
    value = newValue;
  }

  public void interpret(Context c) {
    c.addVariable(this, value);
  }
}

abstract class ComparisonExpression implements Expression {
  protected Expression expressionA;

  protected Expression expressionB;

  public ComparisonExpression(Expression expressionA, Expression expressionB) {
    this.expressionA = expressionA;
    this.expressionB = expressionB;
  }
}

class AndExpression extends CompoundExpression {
  public AndExpression(ComparisonExpression expressionA,
      ComparisonExpression expressionB) {
    super(expressionA, expressionB);
  }

  public void interpret(Context c) {
    expressionA.interpret(c);
    expressionB.interpret(c);
    Boolean result = new Boolean(((Boolean) c.get(expressionA))
        .booleanValue()
        && ((Boolean) c.get(expressionB)).booleanValue());
    c.addVariable(this, result);
  }
}

class VariableExpression implements Expression {
  private Object lookup;

  private String methodName;

  public VariableExpression(Object newLookup, String newMethodName) {
    lookup = newLookup;
    methodName = newMethodName;
  }

  public void interpret(Context c) {
    try {
      Object source = c.get(lookup);
      if (source != null) {
        Method method = source.getClass().getMethod(methodName, null);
        Object result = method.invoke(source, null);
        c.addVariable(this, result);
      }
    } catch (NoSuchMethodException exc) {
    } catch (IllegalAccessException exc) {
    } catch (InvocationTargetException exc) {
    }
  }
}

class EqualsExpression extends ComparisonExpression {
  public EqualsExpression(Expression expressionA, Expression expressionB) {
    super(expressionA, expressionB);
  }

  public void interpret(Context c) {
    expressionA.interpret(c);
    expressionB.interpret(c);
    Boolean result = new Boolean(c.get(expressionA).equals(
        c.get(expressionB)));
    c.addVariable(this, result);
  }
}

class ContainsExpression extends ComparisonExpression {
  public ContainsExpression(Expression expressionA, Expression expressionB) {
    super(expressionA, expressionB);
  }

  public void interpret(Context c) {
    expressionA.interpret(c);
    expressionB.interpret(c);
    Object exprAResult = c.get(expressionA);
    Object exprBResult = c.get(expressionB);
    if ((exprAResult instanceof String) && (exprBResult instanceof String)) {
      if (((String) exprAResult).indexOf((String) exprBResult) != -1) {
        c.addVariable(this, Boolean.TRUE);
        return;
      }
    }
    c.addVariable(this, Boolean.FALSE);
    return;
  }
}

           
       

Related examples in the same category

1.	Interpreter pattern in Java
2.	Interpreter Pattern: Calculator