Interface listFW.IListAlgo

public interface IListAlgo
extends Object

Represents an abstract algorithm to be executed by a host IList. Plays the role of a "visitor" in the design pattern language.

In non OO programming paradigms, an algorithm on lists is expressed as a function or procedure that takes in a list as parameter. In our OO formulation, an alogrithm on lists is an interface that has two methods, each takes in a list as a parameter:

One method, called emptyCase, operates specifically on an empty list (IMTList) and is to be called exclusively by an MTList.
The other method, called nonEmptyCase, operates specifically on a non-empty list (INEList) and is to be called exclusively by an NEList.

When we want to perform an alogrithm (IListAlgo) on a list (IList), we asks the IList to 'execute' the algorithm with a given input. An MTList knows instrinsically that is empty and calls the emptyCase method of the IListAlgo. Analogously, a non-empty list (INEList) will correctly call the nonEmptyCase method of the IListAlgo.

One need not (and should not) check for the type of a list before applying an algorithm to it. THERE IS NO "if"!

Author:: Dung X. Nguyen, Stephen B. Wong

emptyCase (IMTList, Object): Operates on MTList, the empty list
nonEmptyCase (INEList, Object): Operates on NEList, a non-empty list

emptyCase

public abstract Object emptyCase(IMTList host, Object inp)

Operates on MTList, the empty list. Since IEmptyList has only one method, execute(), there is not much the host list can do here. So the code for the empty case usually involves:

inp, and perhaps
host.execute(..., ...).

Parameters:: host - the IMTList that is executing this algorithm.; inp - generic input parameter that can be used for any purpose.
Returns:: result from calling this method. The type of the result is problem-specific and may be null.

nonEmptyCase

public abstract Object nonEmptyCase(INEList host, Object inp)

Operates on NEList, a non-empty list. The host list now has a first and a rest. So the code here usually involves what host.getFirst() and host.getRest() can do to accomplish the task at hand.

host.getFirst() is simply a data Object that the host list holds. It is problem-specific, and thus what it can do depends on the problem the current algorithm is trying to solve.
host.getRest() in contrast is an IList! What can an IList do? execute an alogrithm IListAlgo with some input. What IListAlgo can that be? The current algorithm that is being executed is as good a candidate as any other IListAlgo. In Java, we use the key word this to reference the current receiver of the method call. Having the rest of host (recursively) execute the current algorithm is expressed in Java as: host.getRest().execute(this, ...).

To summarize, the code for the non-empty case usually involves:

host.getFirst(), and the recursive call
host.getRest().execute(this, something involving inp).

Parameters:: host - the INEList that is executing this algorithm; inp - generic input parameter that can be used for any purpose.
Returns:: result from calling this method. The type of the result is problem-specific and may be null.