SE 2811, Lab 7
Commanding Calculators

This lab will give you experience with applying the Command Pattern to a new system. The file calculator.zip contains source code for a simple calculator with addition, subtraction, multiplication, and a single memory store. You will add support for the Command pattern, allowing users to undo and redo typing digits, applying operations, storing results in memory, and clearing the calculator. The provided code includes a class for each command to be implemented, but you will need to add the data and make other changes to support undo and redo.

calculator.zip contains both generic code for procesisng commands (similar to the version in myphonebook.zip). It also contains built-in tests using JUnit; if you have errors saying "package org.junit does not exist" then open CalculatorTest.java and select "Add 'JUnit4' to classpath", let IntelliJ download JUnit4 from maven, and then rebuild the project. When you are finished, you should be able to right click on CalculatorTest in the project browser and execute all of the tests. These are unit tests for just the Calculator class, not the (user actions) implemented in Main.

As distributed, the code will do simple postfix operations. Multiplying 4 by 5 can be done as

      $ java calculator.Main
      4,5*
      Display: 4
      Multiply
      Display: 20
      q
      Quit
      Final result: 20

where the bold text is entered by the user. The java command just runs the program from the console; you can certainly run it from IntelliJ in the usual way. Note the comma (,) corresponds to the "enter" command; it signals that a complete number has been entered.

To compute "(18 - 3) * 2" you would enter

      18,3-2*

Once you have implemented undo and redo, you will be able to add instead of subtract:

      $ java calculator.Main
      18,3-2*
      Display: 18
      Subtract
      Display: 15
      Multiply
      Display: 30
      u
      Undo
      Display: 2
      u
      Undo
      Display: 15
      u
      Undo
      Display: 3
      +
      Add
      Display: 21
      2
      *
      Multiply
      Display: 42
      q
      Quit
      Final result: 42

Note that undoing the multiply (after displaying 30) results in displaying a 2 in the middle of this run; that is so the user knows what number (in this case, a 2) is being applied to the accumulator. This is the behavior you would probably see on a real calculator if that calculator supported undo and redo. If you would like to see a bit more explanation of this example, you might check out a video illustrating it.

Additional Requirements

• See Main.java for the list of commands and their effects. The commands echo to the screen; on a real calculator, these would be replaced by (say) lights that show particular operations have been executed. Several of your changes will be in Main.java.
• Add 'u' to undo the previous action and 'd' to redo it. Only allow undoing actions if there is an action to undo, and only allow redoing actions if there is an action to redo. If no actions are available for either one, do nothing. Show the state of the calculator after undoing and redoing actions.
• You could support undo by storing the complete state of the calculator before each action. This would be unrealistic because the extra storage this would require would reduce battery life. On the other hand, if you try to store an absolutely minimal state, it can be difficult to ensure correctness. Work towards a middle ground between storing too much and too little.
• History.java is the History class from the phonebook example with class Command renamed to CalculatorCommand. You should not need to make any changes to History.java or CalculatorCommand.
• After undoing any operation except appendDigit, the calculator should be in the state that allows new numbers to be entered (newNumber should be true). That is, undoing most operations means that the next digit starts a new number. Undoing appendDigit should leave the next digit state as it was before the appendDigit command was executed. That is, appendDigit will need to save and restore Calculator.newNumber.
• For consistency with the other operations, the 'u' key will print "Undo" and the 'd' key will print "Redo". Other than writing "Undo" and "Redo", do not include additional output.
• Ensure your final version has no extra prompts or debug output.
• Submit your solution through esubmit as lab7calc.
  • Do not change the package structure of the code. In particular, leave the code in the same package that is in the distribution files (package calc). Changing the package will likely break esubmit.
  • Make no changes to Calculator.java. esubmit will use its own version of the file, so if you have made your own changes to the file then your solution will be unlikely to build.
  • Remember that you need to be behind the campus firewall to access esubmit.
  • Submit Main.java as the Main class. Since there are ten files, you can click the Add File button enough times to cover all of the other source files, but a faster way is to add AppendCommand.java, then click the Add File button, select CalculatorCommand.java and shift-click TimesCommand.java. Assuming the files are in sorted order, this will select all of the files but Calculator.java. Main.java will be listed twice, but that will not cause problems.
Note there are no general requirements for additional evidence documents or diagrams. Your instructor may have additional requirements, however.
• Make sure your final submission satisfies your instructor's coding standard. In particular, be sure to document any classes you write (including those we started for you). You do not need to document abstract methods when the base class already has accurate documentation. You may also need to format the code so the indentation is consistent; the distributed code may use the two-space indentation that is standard at Google.

Test Data

The data used by esubmit (inputs and outputs) is available as test_data.zip