| << Chapter < Page | Chapter >> Page > |
The manufacturing of specific restricted access containers with specific insertion strategy will be done by concrete implementations of the following abstract factory interface.
package rac;
/*** Abstract Factory to manufacture RACs.
*/public interface IRACFactory {
/*** Returns an empty IRAContainer.
*/public IRAContainer makeRAC();
}
The following is an (abstract) implementation of
IRACFactory using
LRStruct as the underlining data structure. By varying the insertion strategy, which is an IAlgo on the internal
LRStruct , we obtain different types of RAC: stack, queue, random, etc.
The source code for the following examples can be downloaded at this link .
package rac;
import listFW.*;import listFW.factory.*;
import lrs.*;/**
* Implements a factory for restricted access containers. These* restricted access containers are implemented using an LRStruct to
* hold the data objects.*/
public abstract class ALRSRACFactory implements IRACFactory {/**
* Implements a general-purpose restricted access container using* an LRStruct. How?
** The next item to remove is always at the front of the list of
* contained objects. This is invariant!*
* Insertion is, however, delegated to a strategy routine; and* this strategy is provided to the container. This strategy
* varies to implement the desired kind of container, e.g., queue
* vs. stack.*
* This nested static class is protected so that classes derived from its* factory can reuse it to create other kinds of restricted access
* container.*/
protected static class LRSRAContainer implements IRAContainer {private IAlgo _insertStrategy;
private LRStruct _lrs;public LRSRAContainer(IAlgo strategy) {
_insertStrategy = strategy;_lrs = new LRStruct();
}/**
* Empty the container.*/
public void clear() {_lrs = new LRStruct();
}/*** Return TRUE if the container is empty; otherwise, return
* FALSE.*/
public boolean isEmpty() {return (Boolean)_lrs.execute(CheckEmpty.Singleton);
}/**
* Return TRUE if the container is full; otherwise, return* FALSE.
** This implementation can hold an arbitrary number of
* objects. Thus, always return false.*/
public boolean isFull() {return false;
}/**
* Return an immutable list of all elements in the container.*/
public IList elements(final IListFactory fact) {return (IList)_lrs.execute(new IAlgo() {
public Object emptyCase(LRStruct host, Object... nu) {return fact.makeEmptyList();
}public Object nonEmptyCase(LRStruct host, Object... nu) {
return fact.makeNEList(host.getFirst(),(IList)host.getRest().execute(this));
}});
}/**
* Remove the next item from the container and return it.*/
public Object get() {return _lrs.removeFront();
}/**
* Add an item to the container.*/
public void put(Object input) {_lrs.execute(_insertStrategy, input);
}public Object peek() {
return _lrs.getFirst();}
}}
/*** Package private class used by ALRSRACFactory to check for emptiness of its internal LRStruct.
*/class CheckEmpty implements IAlgo {
public static final CheckEmpty Singleton= new CheckEmpty();private CheckEmpty() {
}public Object emptyCase(LRStruct host, Object... input) {
return Boolean.TRUE;}
public Object nonEmptyCase(LRStruct host, Object... input) {return Boolean.FALSE;
}}
package rac;
import lrs.*;public class LRSStackFactory extends ALRSRACFactory {
/*** Create a ``last-in, first-out'' (LIFO) container.
*/public IRAContainer makeRAC() {
return new LRSRAContainer(new IAlgo() {public Object emptyCase(LRStruct host, Object... input) {
return host.insertFront(input[0]);
}public Object nonEmptyCase(LRStruct host, Object... input) {
return host.insertFront(input[0]);
}});
}}
package rac;
import lrs.*;public class LRSQueueFactory extends ALRSRACFactory {
/*** Create a ``first-in, first-out'' (FIFO) container.
*/public IRAContainer makeRAC() {
return new LRSRAContainer(new IAlgo() {public Object emptyCase(LRStruct host, Object... input) {
return host.insertFront(input[0]);
}public Object nonEmptyCase(LRStruct host, Object... input) {
return host.getRest().execute(this, input);}
});}
}
package rac;
import lrs.*;/*
* Implements a factory for restricted access containers, including a* container that returns a random item.
*/public class RandomRACFactory extends ALRSRACFactory {
/*** Create a container that returns a random item.
*/public IRAContainer makeRAC() {
return new LRSRAContainer(new IAlgo() {public Object emptyCase(LRStruct host, Object... input) {
return host.insertFront(input[0]);
}public Object nonEmptyCase(LRStruct host, Object input) {
/** Math.Random returns a value between 0.0 and 1.0.
*/if (0.5>Math.random())
return host.insertFront(input[0]);
elsereturn host.getRest().execute(this, input);
}});
}}
But can we push the abstraction further? Is the difference between a stack and a queue really anything more than how the data is ordered?
Now, let's go on an look at the ordering object and priority queues...
Notification Switch
Would you like to follow the 'Principles of object-oriented programming' conversation and receive update notifications?
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|