package com.ora.jsp.beans.calc;
import java.io.*;
import java.math.*;
/**
* This class implements a simple calculator for a JSP page.
* It's a stateless bean, so all state must be carried by hidden
* fields in the JSP page, and set before the first getter
* method is called. In order to set all properties with the
* <jsp:setProperty name="foo" property="*" /> syntax (i.e. no
* control over the order of setter calls), all processing to figure
* out the new values of all properties is performed in the
* getCurrentNumber() method.
* <p>
* Basically, the bean accumulates digits and the decimal dot
* in currentNumber until an operation is requested. The accumulated
* number is then saved as previousNumber, and the next number
* starts to accumulate in currentNumber. When an operation is
* requested the second time, it's carried out based on the
* previousNumber and currentNumber, and the result becomes the
* new previousNumber.
* <p>
* Note! This bean is just used as an example of how to use a JSP
* error page to handle exceptions. Even though it appear to work
* as a typical calculator, it's not been heavily tested so I make
* no guarantees that it handles error cases gracefully. Besides,
* I'm not so sure a web based calculator is such a good idea. An
* applet would probably be a better choice.
*
* @author Hans Bergsten, Gefion software <hans@gefionsoftware.com>
* @version 1.0
*/
public class CalcBean implements Serializable {
private static final int NO_OPER = -1;
private static final int ADD_OPER = 1;
private static final int SUB_OPER = 2;
private static final int DIV_OPER = 3;
private static final int MULT_OPER = 4;
private String newDigit = "";
private String currentNumber = "";
private String previousNumber = "";
private int newOper = NO_OPER;
private int currentOperation = NO_OPER;
private boolean reset = false;
private boolean operClicked = false;
private boolean clearClicked = false;
private boolean dotClicked = false;
/**
* Sets the new digit entered by the user.
*/
public void setDigit(String value) {
newDigit = value.trim();
}
/**
* Sets the decimal separator entered by the user.
*/
public void setDot(String value) {
dotClicked = true;
}
/**
* Sets the operation (+, -, *, / or =) entered by the user.
*/
public void setOper(String value) {
newOper = toOperValue(value.trim());
operClicked = true;
}
/**
* Sets the "cleared" flag, indicating that the
* user clicked Clear.
*/
public void setClear(String value) {
clearClicked = true;
}
/**
* Sets the current number, i.e. the number as it
* looks before applying the latest digit, dot, etc.
*/
public void setCurrentNumber(String value) {
currentNumber = value;
}
/**
* Returns the current number resulting from applying the
* current user input (new digit, dot or operation).
*/
public String getCurrentNumber() {
calcNewNumbers();
return currentNumber + newDigit;
}
/**
* Sets the current operation, i.e. the operation that
* will be applied the next time an operation is requested.
*/
public void setCurrentOperation(String value) {
currentOperation = toOperValue(value);
}
/**
* Returns the current operation.
*/
public String getCurrentOperation() {
return toOperName(currentOperation);
}
/**
* Sets the previous number, i.e. the number accumulated
* until the an operation was requested.
*/
public void setPreviousNumber(String value) {
previousNumber = value;
}
/**
* Returns the previous number.
*/
public String getPreviousNumber() {
return previousNumber;
}
/**
* Sets the "reset flag" to clear the current number on
* the next submit (e.g. after performing an operation).
*/
public void setReset(boolean value) {
reset = value;
}
/**
* Returns the "reset flag".
*/
public boolean getReset() {
return reset;
}
/**
* Processes the current input, i.e. adds digits, performs
* the requested operation, and saves the accumulated
* the number, as described in the class comment.
*/
private void calcNewNumbers() {
if (dotClicked) {
if (currentNumber.length() == 0) {
currentNumber = "0.";
}
else if (currentNumber.indexOf(".") == -1) {
currentNumber += ".";
}
dotClicked = false;
reset = false;
}
else if (operClicked) {
if (previousNumber.length() > 0 && currentNumber.length() > 0) {
BigDecimal firstNumber = null;
if (previousNumber.indexOf(".") == -1) {
// Make it decimal to get real division
firstNumber = new BigDecimal(previousNumber + ".0");
}
else {
firstNumber = new BigDecimal(previousNumber);
}
BigDecimal secondNumber = new BigDecimal(currentNumber);
BigDecimal result = null;
switch (currentOperation) {
case ADD_OPER:
result = firstNumber.add(secondNumber);
break;
case SUB_OPER:
result = firstNumber.subtract(secondNumber);
break;
case DIV_OPER:
result = firstNumber.divide(secondNumber,
BigDecimal.ROUND_HALF_UP);
break;
case MULT_OPER:
result = firstNumber.multiply(secondNumber);
break;
}
if (result != null) {
currentNumber = result.toString();
}
}
previousNumber = currentNumber;
currentOperation = newOper;
reset = true;
}
else if (clearClicked) {
currentNumber = "";
previousNumber = currentNumber;
currentOperation = NO_OPER;
}
else if (reset) {
currentNumber = "";
reset = false;
}
}
/**
* Converts an operation int value to the corresponding
* String representation.
*/
private String toOperName(int value) {
String name = "";
switch (value) {
case ADD_OPER:
name = "+";
break;
case SUB_OPER:
name = "-";
break;
case DIV_OPER:
name = "/";
break;
case MULT_OPER:
name = "*";
}
return name;
}
/**
* Converts an operation String value to the corresponding
* int representation.
*/
private int toOperValue(String name) {
int value = NO_OPER;
if ("+".equals(name)) {
value = ADD_OPER;
}
else if ("-".equals(name)) {
value = SUB_OPER;
}
else if ("/".equals(name)) {
value = DIV_OPER;
}
else if ("*".equals(name)) {
value = MULT_OPER;
}
return value;
}
} |
