[4기 -유원우] 1~2주차 과제 : 계산기 구현 미션 제출합니다.

calculator/src/main/java/com/wonu606/Main.java

@@ -2,11 +2,10 @@
 
 import com.wonu606.app.App;
 import com.wonu606.calculator.CalculatorApp;
+import com.wonu606.io.ConsoleInput;
 import com.wonu606.io.ConsolePrinter;
 import com.wonu606.io.Input;
 import com.wonu606.io.Print;
-import com.wonu606.io.ConsoleInput;
-import java.io.IOException;
 
 public class Main {
 
@@ -25,7 +24,7 @@ public static void main(String[] args) {
         }
     }
 
-    private static void runApp(App app, Input input, Print printer) throws IOException {
+    private static void runApp(App app, Input input, Print printer) {
         app.execute(input, printer);
     }
 }

calculator/src/main/java/com/wonu606/app/App.java

@@ -2,9 +2,8 @@
 
 import com.wonu606.io.Input;
 import com.wonu606.io.Print;
-import java.io.IOException;
 
 public interface App {
 
-    void execute(Input input, Print printer) throws IOException;
+    void execute(Input input, Print printer);
 }

calculator/src/main/java/com/wonu606/calculator/CalculatorApp.java

@@ -1,21 +1,55 @@
 package com.wonu606.calculator;
 
 import com.wonu606.app.App;
+import com.wonu606.calculator.calculator.PostfixCalculator;
+import com.wonu606.calculator.converter.InfixToPostfixConverter;
+import com.wonu606.calculator.storage.Persistence;
+import com.wonu606.calculator.storage.ResultStore;
+import com.wonu606.calculator.strategy.CalculationStrategy;
+import com.wonu606.calculator.strategy.CalculatorStrategy;
+import com.wonu606.calculator.util.CalculatorMessage;
+import com.wonu606.calculator.validator.InfixValidator;
 import com.wonu606.io.Input;
 import com.wonu606.io.Print;
-import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
 
 public class CalculatorApp implements App {
 
-    Input input;
-    Print printer;
+    private final Map<String, CalculatorStrategy> strategies = new HashMap();
+    private final Persistence store = new ResultStore();
 
-    public void execute(Input input, Print printer) throws IOException {
-        this.input = input;
-        this.printer = printer;
+    public CalculatorApp() {
+        initStrategies();
+    }
+
+    private void initStrategies() {
+        strategies.put("1", new CalculationStrategy(
+                new InfixValidator(), new InfixToPostfixConverter(), new PostfixCalculator()));
+    }
+
+    public void execute(Input input, Print printer) {
 
         while (true) {
-            String selection = input.getInput();
+            String selection = inputMenuSelection(input);
+            CalculatorStrategy selectedStrategy = getStrategyOrThrow(selection);
+            performStrategy(input, printer, selectedStrategy);
         }
     }
+
+    private void performStrategy(Input input, Print printer, CalculatorStrategy selectedStrategy) {
+        selectedStrategy.execute(input, printer, store);
+    }
+
+    private CalculatorStrategy getStrategyOrThrow(String selection) {
+        CalculatorStrategy selectedStrategy = strategies.get(selection);
+        if (selectedStrategy == null) {
+            throw new IllegalArgumentException(CalculatorMessage.INVALID_INPUT.message);
+        }
+        return selectedStrategy;
+    }
+
+    private String inputMenuSelection(Input input) {
+        return input.getInput();
+    }
 }

calculator/src/main/java/com/wonu606/calculator/calculator/Calculator.java

@@ -0,0 +1,8 @@
+package com.wonu606.calculator.calculator;
+
+import java.util.List;
+
+public interface Calculator {
+
+    double calculate(List<String> expression);
+}

calculator/src/main/java/com/wonu606/calculator/calculator/PostfixCalculator.java

@@ -0,0 +1,42 @@
+package com.wonu606.calculator.calculator;
+
+import com.wonu606.calculator.model.Operator;
+import java.util.ArrayDeque;
+import java.util.Deque;
+import java.util.List;
+import java.util.Objects;
+
+public class PostfixCalculator implements Calculator {
+
+    @Override
+    public double calculate(List<String> postfixExpression) {
+        Deque<Double> operandStack = new ArrayDeque<>();
+
+        for (String token : postfixExpression) {
+            handleToken(operandStack, token);
+        }
+
+        return operandStack.pop();
+    }
+
+    private void handleToken(Deque<Double> operandStack, String token) {
+        if (isOperator(token)) {
+            Operator operator = Objects.requireNonNull(Operator.get(token));
+            performOperation(operandStack, operator);
+            return;
+        }
+        operandStack.push(Double.valueOf(token));
+    }
+
+    private void performOperation(Deque<Double> operandStack, Operator operator) {
+        double secondOperand = operandStack.pop();
+        double firstOperand = operandStack.pop();
+
+        double result = operator.apply(firstOperand, secondOperand);
+        operandStack.push(result);
+    }
+
+    private boolean isOperator(String token) {
+        return Operator.get(token) != null;
+    }
+}

calculator/src/main/java/com/wonu606/calculator/converter/Converter.java

@@ -0,0 +1,6 @@
+package com.wonu606.calculator.converter;
+
+public interface Converter<T, R> {
+
+    R convert(T input);
+}

calculator/src/main/java/com/wonu606/calculator/converter/InfixToPostfixConverter.java

@@ -0,0 +1,56 @@
+package com.wonu606.calculator.converter;
+
+import com.wonu606.calculator.model.Operator;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Deque;
+import java.util.List;
+import java.util.Objects;
+
+public class InfixToPostfixConverter implements Converter<String, List<String>> {
+
+    @Override
+    public List<String> convert(String infixExpression) {
+        Deque<String> operatorStack = new ArrayDeque<>();
+        List<String> postfixExpression = new ArrayList<>();
+
+        String[] tokens = infixExpression.split("\\s");
+
+        for (String token : tokens) {
+            processTokenIntoPostfix(operatorStack, postfixExpression, token);
+        }
+
+        while (!operatorStack.isEmpty()) {
+            postfixExpression.add(operatorStack.pop());
+        }
+        return postfixExpression;
+    }
+
+    private void processTokenIntoPostfix(
+            Deque<String> operatorStack, List<String> postfixExpression, String token) {
+        if (isOperator(token)) {
+            popWhileHigherPrecedence(operatorStack, postfixExpression, token);
+            operatorStack.push(token);
+            return;
+        }
+        postfixExpression.add(token);
+    }
+
+    private void popWhileHigherPrecedence(
+            Deque<String> operatorStack, List<String> postfixExpression, String tokenOperator) {
+        while (!operatorStack.isEmpty()
+                && isHigherOrEqualPrecedence(operatorStack.peek(), tokenOperator)) {
+            postfixExpression.add(operatorStack.pop());
+        }
+    }
+
+    private boolean isHigherOrEqualPrecedence(String peekOperator, String tokenOperator) {
+        int peekPrecedence = Objects.requireNonNull(Operator.get(peekOperator)).precedence;
+        int tokenPrecedence = Objects.requireNonNull(Operator.get(tokenOperator)).precedence;
+        return peekPrecedence <= tokenPrecedence;
+    }
+
+    private boolean isOperator(String token) {
+        return Operator.get(token) != null;
+    }
+}

calculator/src/main/java/com/wonu606/calculator/model/CalculationResult.java

@@ -0,0 +1,40 @@
+package com.wonu606.calculator.model;
+
+import java.util.Objects;
+
+public class CalculationResult {
+
+    private final String expression;
+    private final double result;
+
+    public CalculationResult(String expression, double result) {
+        this.expression = expression;
+        this.result = result;
+    }
+
+    public String getExpression() {
+        return expression;
+    }
+
+    public double getResult() {
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        CalculationResult that = (CalculationResult) o;
+        return Double.compare(that.getResult(), getResult()) == 0 && Objects.equals(
+                getExpression(), that.getExpression());
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(getExpression(), getResult());
+    }
+}

calculator/src/main/java/com/wonu606/calculator/model/Operator.java

@@ -0,0 +1,52 @@
+package com.wonu606.calculator.model;
+
+import com.wonu606.calculator.util.CalculatorMessage;
+
+public enum Operator {
+    ADD("+", 2) {
+        @Override
+        public double apply(double a, double b) {
+            return a + b;
+        }
+    },
+    SUBTRACT("-", 2) {
+        @Override
+        public double apply(double a, double b) {
+            return a - b;
+        }
+    },
+    MULTIPLY("*", 1) {
+        @Override
+        public double apply(double a, double b) {
+            return a * b;
+        }
+    },
+    DIVIDE("/", 1) {
+        @Override
+        public double apply(double a, double b) {
+            if (b == 0) {
+                throw new ArithmeticException(CalculatorMessage.NOT_DIVISIBLE_BY_ZERO.message);
+            }
+            return a / b;
+        }
+    };
+
+    public final String symbol;
+    public final int precedence;
+
+    Operator(String symbol, int precedence) {
+        this.symbol = symbol;
+        this.precedence = precedence;
+    }
+
+    public static Operator get(String symbol) {
+        for (Operator operator : values()) {
+            if (operator.symbol.equals(symbol)) {
+                return operator;
+            }
+        }
+        return null;
+    }
+
+    public abstract double apply(double a, double b);
+}

calculator/src/main/java/com/wonu606/calculator/storage/Persistence.java

@@ -0,0 +1,15 @@
+package com.wonu606.calculator.storage;
+
+import com.wonu606.calculator.model.CalculationResult;
+import java.util.List;
+
+public interface Persistence {
+
+    void saveResult(CalculationResult calculationResult);
+
+    CalculationResult findResult(int sequence);
+
+    List<CalculationResult> findAllResult();
+
+    void clear();
+}

calculator/src/main/java/com/wonu606/calculator/storage/ResultStore.java

@@ -0,0 +1,35 @@
+package com.wonu606.calculator.storage;
+
+import com.wonu606.calculator.model.CalculationResult;
+import com.wonu606.calculator.util.CalculatorMessage;
+import java.util.ArrayList;
+import java.util.List;
+
+public class ResultStore implements Persistence {
+
+    private final List<CalculationResult> store = new ArrayList<>();
+
+    @Override
+    public void saveResult(CalculationResult calculationResult) {
+        store.add(calculationResult);
+    }
+
+    @Override
+    public CalculationResult findResult(int sequence) {
+        try {
+            return store.get(sequence - 1);
+        } catch (IndexOutOfBoundsException exception) {
+            throw new IllegalArgumentException(CalculatorMessage.INVALID_ORDER.message);
+        }
+    }
+
+    @Override
+    public List<CalculationResult> findAllResult() {
+        return new ArrayList<>(store);
+    }
+
+    @Override
+    public void clear() {
+        store.clear();
+    }
+}