package Evaluator;

import operators.Operator;
import java.util.*;
import operators.LeftParenthesisOperator;
import operators.RightParenthesisOperator;

public class Evaluator {

private Stack<Operand> operandStack;
private Stack<Operator> operatorStack;

private StringTokenizer tokenizer;
private static final String DELIMITERS = "+-*^/ ()";

public Evaluator() {
   operandStack = new Stack<>();
   operatorStack = new Stack<>();
}

public int eval(String expression) {
   String token;

   // The 3rd argument is true to indicate that the delimiters should be used
   // as tokens, too. But, we'll need to remember to filter out spaces.
   this.tokenizer = new StringTokenizer(expression, DELIMITERS, true);

   // clear stack
   // get ready for the new task
   operandStack.clear();
   operatorStack.clear();

   // initialize operator stack - necessary with operator priority schema
   // the priority of any operator in the operator stack other than
   // the usual mathematical operators - "+-*/" - should be less than the priority
   // of the usual operators
   // TODO Operator is abstract - this will need to be fixed:
   while (this.tokenizer.hasMoreTokens()) {
         // filter out spaces
         if (!(token = this.tokenizer.nextToken()).equals(" ")) {
            // check if token is an operand

            if (Operand.check(token)) {
               operandStack.push(new Operand(token));
            } else {
               if (!Operator.check(token)) {
                     System.out.println("*****invalid token******");
                     throw new RuntimeException("*****invalid token******");
               }

               // TODO Operator is abstract - these two lines will need to be fixed:
               // The Operator class should contain an instance of a HashMap,
               // and values will be instances of the Operators. See Operator class
               // skeleton for an example.
               //Operator newOperator = new Operator(token);
               Operator newOperator = Operator.getOperator(token);

               // left parenthesis case
               if (newOperator.getClass() == LeftParenthesisOperator.class) {
                     operatorStack.push(newOperator);
               }
               // right parenthesis case
               else if (newOperator.getClass() == RightParenthesisOperator.class) {
                     boolean isLeftPopped = false;

                     // we are workin on binary operation
                     // so we must have 2 operand
                     while (operandStack.size() >= 2) {
                        // note that when we eval the expression 1 - 2 we will
                        // push the 1 then the 2 and then do the subtraction operation
                        // This means that the first number to be popped is the
                        // second operand, not the first operand - see the following code
                        Operator oldOpr = operatorStack.pop();
                        if (oldOpr.getClass() == LeftParenthesisOperator.class) {
                           // clear left parenthesis
                           isLeftPopped = true;
                           break;
                        }

Introduction A set is an unordered collection of data that contain...