Interpreter Design pattern

public interface Expression {
    public boolean interpret(String context);
}

class TerminalExpression implements Expression {

    private List<String> expectedData;

    public TerminalExpression(List<String> expectedData) {
        this.expectedData = expectedData;
    }

    @Override
    public boolean interpret(String context) {
//        instead of returning the boolean you should do an actual task
        return expectedData.contains(context);
    }
}

class Test{
    public static void main(String[] args) {
        List<String> commandList = new LinkedList<>();
        commandList.add("Extra Cheese");
        commandList.add("Extra Spice");
        commandList.add("Extra Salt");
        commandList.add("Lower Salt");
        commandList.add("Medium Sauce");
        commandList.add("Less Oil");

        Expression expression = new TerminalExpression(commandList);

        System.out.println("Customer ordered Extra Cheese "+ expression.interpret("Extra Cheese"));
    }
}

public interface Expression {
    public boolean interpret(String context);
}

class TerminalExpression implements Expression {

    private List<String> expectedData;

    public TerminalExpression(List<String> expectedData) {
        this.expectedData = expectedData;
    }

    @Override
    public boolean interpret(String context) {
//        instead of returning the boolean you should do an actual task
        return expectedData.contains(context);
    }
}

class Test{
    public static void main(String[] args) {
        List<String> commandList = new LinkedList<>();
        commandList.add("Extra Cheese");
        commandList.add("Extra Spice");
        commandList.add("Extra Salt");
        commandList.add("Lower Salt");
        commandList.add("Medium Sauce");
        commandList.add("Less Oil");

        Expression expression = new TerminalExpression(commandList);

        System.out.println("Customer ordered Extra Cheese "+ expression.interpret("Extra Cheese"));
    }
}

// Step 1: Define the Expression interface
interface OrderExpression {
    void interpret(Order order);
}

// Step 2: Create terminal expressions for specific customizations
class ExtraCheeseExpression implements OrderExpression {
    @Override
    public void interpret(Order order) {
        order.addCustomization("Extra Cheese");
    }
}

class ExtraSpiceExpression implements OrderExpression {
    @Override
    public void interpret(Order order) {
        order.addCustomization("Extra Spice");
    }
}

// Step 3: Create a non-terminal expression for parsing commands
class CustomizationInterpreter {
    private OrderExpression expression;

    public CustomizationInterpreter(OrderExpression expression) {
        this.expression = expression;
    }

    public void interpret(Order order) {
        expression.interpret(order);
    }
}

// Step 4: Context class representing the order
class Order {
    private String foodItem;
    private StringBuilder customizations;

    public Order(String foodItem) {
        this.foodItem = foodItem;
        this.customizations = new StringBuilder();
    }

    public void addCustomization(String customization) {
        customizations.append(customization).append(" ");
    }

    public void printOrder() {
        System.out.println("Food Item: " + foodItem);
        System.out.println("Customizations: " + customizations.toString().trim());
    }
}

// Step 1: Define the Expression interface
interface OrderExpression {
    void interpret(Order order);
}

// Step 2: Create terminal expressions for specific customizations
class ExtraCheeseExpression implements OrderExpression {
    @Override
    public void interpret(Order order) {
        order.addCustomization("Extra Cheese");
    }
}

class ExtraSpiceExpression implements OrderExpression {
    @Override
    public void interpret(Order order) {
        order.addCustomization("Extra Spice");
    }
}

// Step 3: Create a non-terminal expression for parsing commands
class CustomizationInterpreter {
    private OrderExpression expression;

    public CustomizationInterpreter(OrderExpression expression) {
        this.expression = expression;
    }

    public void interpret(Order order) {
        expression.interpret(order);
    }
}

// Step 4: Context class representing the order
class Order {
    private String foodItem;
    private StringBuilder customizations;

    public Order(String foodItem) {
        this.foodItem = foodItem;
        this.customizations = new StringBuilder();
    }

    public void addCustomization(String customization) {
        customizations.append(customization).append(" ");
    }

    public void printOrder() {
        System.out.println("Food Item: " + foodItem);
        System.out.println("Customizations: " + customizations.toString().trim());
    }
}

// Step 5: Client code that uses the interpreter for customizations
public class Client {
    public static void main(String[] args) {
        // Creating an order for a burger
        Order burgerOrder = new Order("Burger");

        // Creating customizations using interpreter
        CustomizationInterpreter extraCheeseInterpreter = new CustomizationInterpreter(new ExtraCheeseExpression());
        extraCheeseInterpreter.interpret(burgerOrder);

        CustomizationInterpreter extraSpiceInterpreter = new CustomizationInterpreter(new ExtraSpiceExpression());
        extraSpiceInterpreter.interpret(burgerOrder);

        // Printing the final order
        burgerOrder.printOrder();
    }
}

// Step 5: Client code that uses the interpreter for customizations
public class Client {
    public static void main(String[] args) {
        // Creating an order for a burger
        Order burgerOrder = new Order("Burger");

        // Creating customizations using interpreter
        CustomizationInterpreter extraCheeseInterpreter = new CustomizationInterpreter(new ExtraCheeseExpression());
        extraCheeseInterpreter.interpret(burgerOrder);

        CustomizationInterpreter extraSpiceInterpreter = new CustomizationInterpreter(new ExtraSpiceExpression());
        extraSpiceInterpreter.interpret(burgerOrder);

        // Printing the final order
        burgerOrder.printOrder();
    }
}

package patterns;

import ingredient.BBQChicken;
import ingredient.MayonnaiseCheese;
import java.util.ArrayList;
import java.util.HashMap;

interface Expression {

    public String interpret();
}

class TerminalExpression implements Expression {

    ArrayList<String> commandlist = new ArrayList();
    int count;
    String command;

    TerminalExpression(String[] split) {

        for (int i = 0; i < split.length; i++) {
            commandlist.add(split[i]);
            if (commandlist.get(i).contains("extra")) {
                count++;
            }
        }
    }

    @Override
    public String interpret() {
        for (String value : commandlist) {

            if (value.contains("cheese")) {
                command = count + " " + new MayonnaiseCheese().getName();
            }

            if (value.contains("chicken")) {
                command = count + " " + new BBQChicken().getName();
            }

        }
        return command;
    }

}
//+

public class CommandInterpretor {

    public static String expression = "extra extra cheese";

    public static void main(String[] args) {

        String[] split = expression.split(" ");

        TerminalExpression terminalCommand = new TerminalExpression(split);
        String interpret = terminalCommand.interpret();
        System.out.println(interpret);

    }
}

package patterns;

import ingredient.BBQChicken;
import ingredient.MayonnaiseCheese;
import java.util.ArrayList;
import java.util.HashMap;

interface Expression {

    public String interpret();
}

class TerminalExpression implements Expression {

    ArrayList<String> commandlist = new ArrayList();
    int count;
    String command;

    TerminalExpression(String[] split) {

        for (int i = 0; i < split.length; i++) {
            commandlist.add(split[i]);
            if (commandlist.get(i).contains("extra")) {
                count++;
            }
        }
    }

    @Override
    public String interpret() {
        for (String value : commandlist) {

            if (value.contains("cheese")) {
                command = count + " " + new MayonnaiseCheese().getName();
            }

            if (value.contains("chicken")) {
                command = count + " " + new BBQChicken().getName();
            }

        }
        return command;
    }

}
//+

public class CommandInterpretor {

    public static String expression = "extra extra cheese";

    public static void main(String[] args) {

        String[] split = expression.split(" ");

        TerminalExpression terminalCommand = new TerminalExpression(split);
        String interpret = terminalCommand.interpret();
        System.out.println(interpret);

    }
}

public interface Expression {
   public boolean interpret(String context);
}

public class TerminalExpression implements Expression {
    
   private String data;

   public TerminalExpression(String data){
      this.data = data; 
   }

   @Override
   public boolean interpret(String context) {
   
      if(context.contains(data)){
         return true;
      }
      return false;
   }
}
public class OrExpression implements Expression {
     
   private Expression expr1 = null;
   private Expression expr2 = null;

   public OrExpression(Expression expr1, Expression expr2) { 
      this.expr1 = expr1;
      this.expr2 = expr2;
   }

   @Override
   public boolean interpret(String context) {        
      return expr1.interpret(context) || expr2.interpret(context);
   }
}
public class AndExpression implements Expression {
     
   private Expression expr1 = null;
   private Expression expr2 = null;

   public AndExpression(Expression expr1, Expression expr2) { 
      this.expr1 = expr1;
      this.expr2 = expr2;
   }

   @Override
   public boolean interpret(String context) {        
      return expr1.interpret(context) && expr2.interpret(context);
   }
}

public interface Expression {
   public boolean interpret(String context);
}

public class TerminalExpression implements Expression {
    
   private String data;

   public TerminalExpression(String data){
      this.data = data; 
   }

   @Override
   public boolean interpret(String context) {
   
      if(context.contains(data)){
         return true;
      }
      return false;
   }
}
public class OrExpression implements Expression {
     
   private Expression expr1 = null;
   private Expression expr2 = null;

   public OrExpression(Expression expr1, Expression expr2) { 
      this.expr1 = expr1;
      this.expr2 = expr2;
   }

   @Override
   public boolean interpret(String context) {        
      return expr1.interpret(context) || expr2.interpret(context);
   }
}
public class AndExpression implements Expression {
     
   private Expression expr1 = null;
   private Expression expr2 = null;

   public AndExpression(Expression expr1, Expression expr2) { 
      this.expr1 = expr1;
      this.expr2 = expr2;
   }

   @Override
   public boolean interpret(String context) {        
      return expr1.interpret(context) && expr2.interpret(context);
   }
}

public class InterpreterPatternDemo {

   //Rule: Robert and John are male
   public static Expression getMaleExpression(){
      Expression robert = new TerminalExpression("Robert");
      Expression john = new TerminalExpression("John");
      return new OrExpression(robert, john);        
   }

   //Rule: Julie is a married women
   public static Expression getMarriedWomanExpression(){
      Expression julie = new TerminalExpression("Julie");
      Expression married = new TerminalExpression("Married");
      return new AndExpression(julie, married);        
   }

   public static void main(String[] args) {
      Expression isMale = getMaleExpression();
      Expression isMarriedWoman = getMarriedWomanExpression();

      System.out.println("John is male? " + isMale.interpret("John"));
      System.out.println("Julie is a married women? " + isMarriedWoman.interpret("Married Julie"));
   }
}

public class InterpreterPatternDemo {

   //Rule: Robert and John are male
   public static Expression getMaleExpression(){
      Expression robert = new TerminalExpression("Robert");
      Expression john = new TerminalExpression("John");
      return new OrExpression(robert, john);        
   }

   //Rule: Julie is a married women
   public static Expression getMarriedWomanExpression(){
      Expression julie = new TerminalExpression("Julie");
      Expression married = new TerminalExpression("Married");
      return new AndExpression(julie, married);        
   }

   public static void main(String[] args) {
      Expression isMale = getMaleExpression();
      Expression isMarriedWoman = getMarriedWomanExpression();

      System.out.println("John is male? " + isMale.interpret("John"));
      System.out.println("Julie is a married women? " + isMarriedWoman.interpret("Married Julie"));
   }
}

   Expression ragbag = new TerminalExpression("RagBag");
   Expression rag = new TerminalExpression("Rag");
   Expression combination1 = new OrExpression(ragbag, rag)
   Expression robert = new TerminalExpression("Robert");
   Expression john = new TerminalExpression("John");
   Expression combination2 = new OrExpression(robert, john)
   return new OrExpression(combination1, combination2); 

   Expression ragbag = new TerminalExpression("RagBag");
   Expression rag = new TerminalExpression("Rag");
   Expression combination1 = new OrExpression(ragbag, rag)
   Expression robert = new TerminalExpression("Robert");
   Expression john = new TerminalExpression("John");
   Expression combination2 = new OrExpression(robert, john)
   return new OrExpression(combination1, combination2); 

public interface Expression {
    void interpret();
}

public interface Expression {
    void interpret();
}

class TerminalExpression implements Expression{
     
    private int value;

    public TerminalExpression(int value) {
        this.value = value;
    }

    @Override
    public int interpret() {
        return value;
    }
}

class TerminalExpression implements Expression{
     
    private int value;

    public TerminalExpression(int value) {
        this.value = value;
    }

    @Override
    public int interpret() {
        return value;
    }
}

class AdditionExpression implements Expression{
    private Expression firstExpression, secondExpression;

    public AdditionExpression(Expression firstExpression, Expression secondExpression) {
        this.firstExpression = firstExpression;
        this.secondExpression = secondExpression;
    }

    @Override
    public int interpret() {
        return firstExpression.interpret()+secondExpression.interpret();
    }
}
class SubstractionExpression implements Expression{
    private Expression firstExpression, secondExpression;

    public SubstractionExpression(Expression firstExpression, Expression secondExpression) {
        this.firstExpression = firstExpression;
        this.secondExpression = secondExpression;
    }

    @Override
    public int interpret() {
        return firstExpression.interpret() - secondExpression.interpret();
    }
}
class MultiplyExpression implements Expression{
    private Expression firstExpression, secondExpression;

    public MultiplyExpression(Expression firstExpression, Expression secondExpression) {
        this.firstExpression = firstExpression;
        this.secondExpression = secondExpression;
    }

    @Override
    public int interpret() {
        return firstExpression.interpret() * secondExpression.interpret();
    }
}
class DivisionExpression implements Expression{
    private Expression firstExpression, secondExpression;

    public DivisionExpression(Expression firstExpression, Expression secondExpression) {
        this.firstExpression = firstExpression;
        this.secondExpression = secondExpression;
    }

    @Override
    public int interpret() {
        return firstExpression.interpret() / secondExpression.interpret();
    }
}

class AdditionExpression implements Expression{
    private Expression firstExpression, secondExpression;

    public AdditionExpression(Expression firstExpression, Expression secondExpression) {
        this.firstExpression = firstExpression;
        this.secondExpression = secondExpression;
    }

    @Override
    public int interpret() {
        return firstExpression.interpret()+secondExpression.interpret();
    }
}
class SubstractionExpression implements Expression{
    private Expression firstExpression, secondExpression;

    public SubstractionExpression(Expression firstExpression, Expression secondExpression) {
        this.firstExpression = firstExpression;
        this.secondExpression = secondExpression;
    }

    @Override
    public int interpret() {
        return firstExpression.interpret() - secondExpression.interpret();
    }
}
class MultiplyExpression implements Expression{
    private Expression firstExpression, secondExpression;

    public MultiplyExpression(Expression firstExpression, Expression secondExpression) {
        this.firstExpression = firstExpression;
        this.secondExpression = secondExpression;
    }

    @Override
    public int interpret() {
        return firstExpression.interpret() * secondExpression.interpret();
    }
}
class DivisionExpression implements Expression{
    private Expression firstExpression, secondExpression;

    public DivisionExpression(Expression firstExpression, Expression secondExpression) {
        this.firstExpression = firstExpression;
        this.secondExpression = secondExpression;
    }

    @Override
    public int interpret() {
        return firstExpression.interpret() / secondExpression.interpret();
    }
}