...
The student
field in DoCommandVisitor
will give you access to the various clothes piles, what the student is currently wearing and the laundry room. You do NOT have to code up the instantiation of the DoCommandVisitor
! The supplied simulation infrastructure already does that for you.
The Graphical User Interface (GUI)
The initialization of the GUI creates an Acker Student object and associated DoCommandVisitor. Each GUI event triggers the execution of DoCommandVisitor; in some cases, such as reading input from a file, it triggers the execution of DoCommandVisitor on a stream of Commands. In essence, the event-handling loop built-in to the Java Swing framework is used to drive the computation rather than a separate loop in the main thread such as the one in the simulate method in Student.
The GUI could also have been written as an implementation of the IOProcess interface. This approach, which conforms to the classic "model-view-controller" (MVC) pattern, is more flexible because it decouples the GUI (the view in MVC terminology) from the model, but it is also more complex because it involves the cooperative execution of
two loops in separate threads--a main program loop in the simulate method of Student and the loop driving the event-handling thread supporting the processing of GUI inputs. The SimLaundryApplication dispenses with the main program loop by absorbing the application (the model) into the GUI (the view).
Addtional Technical Information
Our supporting framework includes an input processor that reads event commands from the input stream and returns high level data representations for these commands. The input processor can also print debugging output describing the state of your simulation before each command is performed. To communicate with your code, the input processor uses four interfaces:
IOProcess
which describes the visible methods supported by the input processor;StudentEnvironment
which describes methods for inspecting the state of Acker's environment;EnumI
which describes methods for inspecting (but not mutating!) lists within Acker's environment; andReadIteratorI
which includes methods for moving a cursor through lists implementing theEnumI
interface.
The interfaces are already defined in the framework provided by the course staff.
The input processor class TerminalIO
implements the IOProcess
interface. You are welcome to inspect the code of TerminalIO
but it relies heavily on the Java I/O library, particularly the class StreamTokenizer
. To understand this code, you will need to read Chapter 11 of JLS (or similar reference). The framework also includes implementations of EnumI
and ReadIteratorI
as part of a BiList
(mutable circular doubly linked list) class implementation.
The program includes two class definitions defining unions (composites without recursion): Garment
, specifying the representation of garments that appear in the input stream, and Command
, specifying the representation of event description commands. Both classes include the hooks required to support the visitor pattern. The data definition for Garment
is important because the graphical version of the user interface included in the framework animates the state of your implementation before each command. This graphical user interface (GUI) expects the garments that appear as elements in lists (as revealed by the EnumI
and ReadIteratorI
interfaces) to be instances of the Garment
class. Hence, you must use the representation of garments that our class Garment
provides.
The IOProcess
interface includes a method PrintStream open(StudentEnvironmenta, boolean debug)
which initializes an IOProcess
object for a laundry simulation of the specified environment and returns the PrintStream
object to be used for terminal output. (Up to now you have implicitly used the PrintStream
object System.out
.) The PrintStream
method println(String s)
prints the string s
followed by a newline character to the PrintStream
. The boolean debug
argument indicates whether or not debugging output should be produced. The IOProcess
interface also includes a method nextCommand
which reads the next command from the input channel supported by the IOProcess
object.
Each call on nextCommand
returns the next command in the stream provided by the IOProcess
object, until it reaches an end-of-file (<control>-d
from the keyboard). End-of-file is reported as a null reference of type Command
.
The nextCommand
method in TerminalIO
processes character strings consisting of words separated by ``space'' characters such as ' '
and '\n'
. A word
is any sequence of printable characters other than space, '\n'
(newline), and '\r'
. (return). An adjective
must be a single word. An article
must be one the words shirt
, pants
, or socks
. The same adjective, say argyle
may be applied to garments of different types, but there are no duplicate items of clothing.
The program passes a boolean debug flag
to (TerminalIO
). The value of the flag is true iff the command line argument -d
or -debug
is passed to main
.