Operations which can be used
* to perform different functions in the program. Each op is associated with a
* String, which represents its name. The associations are
* currently mantained in a hash table.
*
* Both this class and Operation are abstract and must be
* extended. The op should be similar in some way, like
* ImportFilter which extends Operation and
* is an abstract class for filtering in input files. The
* ImportMgr is a subclass of this class and checks to see
* that all of the Operations are of type
* ImportFilter. Therefore, the only method that needs to
* be implemented by a subclass is the classTypeOk, which
* checks to make sure that the operation is a valid one.
*
*
Classes that extend this class should call this classes constructor * to set up the hashtable. * *
The ops can be retrieved based on their name, and a lists of * names can be obtained from the Manager. The Op will contain * addtional information. * *
Currently, ops can be added with methods, but ideally the
* Manager would be able to analyze something like a directory and add
* all of the ops it found there. This would mean that different operations
* could be add by simply dropping a class that extended the appropriate
* Operation subclass into the appropriate directory.
*
* @see Operation
* @see java.util.Hashtable
* @see ImportMgr
* @see ImportFilter
*
* @author James J. Benham
* @version 1.0.0
* @date August 10, 1998
*/
public abstract class Manager
{
private Hashtable ops; // maintains the table of String/Operations
// values and used to access the Operations
private String defaultName; // the name of the op to use by default
/**
* Creates a new Manager, with a default capacity of 4 and a
* loadFactor of 1.0. Sets up the Hashtable for the String/Operation
* pairs.
*/
public Manager()
{
defaultName = null;
try
{
ops = new Hashtable(4, (float)1.0);
}
catch (IllegalArgumentException e)
{
// both the arguments are fine, so we won't ever get here.
}
}
/**
* Creates a new Manager with the specified values.
*
* @param capacity the initial number of operations that can be stored.
* @param loadFactor controls memory efficiency vs. lookup speed, it
* must be between 0.0 and 1.0, where 1.0 has the greatest memory efficiency
*
* @exception IllegalArgumentException when capacitly is less
* than zero or the loadFactor is out of bounds.
*/
public Manager(int capacity, float loadFactor)
throws IllegalArgumentException
{
defaultName = null;
try
{
// Make the hashtable
ops = new Hashtable(capacity, loadFactor);
}
catch (IllegalArgumentException e)
{
// pass along the error
throw e;
}
}
/**
* Gets the names of all of the Operations known to the Manager. It
* works be creating an Enumeration from the hash table.
* The Enumeration is turned into an array be simply
* retrieveing the next element and storing it in an array. The size of
* the hashtable becomes the size of the array.
*
* @returns an array of Strings, with each entry representing an operation in
* the Manager.
*
* @see java.util.Enumeration
*/
public String[] getNames()
{
String names[]; // the names in an array
// Get the names from the Hashtable
Enumeration namesEnum = ops.keys();
// Create an array of the approriate size
names = new String[ops.size()];
// Copy the names from the Enumeration into the array
for(int i=0; i < ops.size(); i++)
{
names[i] = (String) namesEnum.nextElement();
}
return names;
}
/**
* Retrieves the operation associated with the given name. This can be used
* to analyze an operation and to retrieve specific information about it.
*
* @param filterName the name of a filter known to this Manager
*
* @returns the operation associated with opName
*
* @exception NoSuchElementException the specified operation does not exist
* In other words, opName does not have an associated
* value.
*/
public Operation get(String opName) throws NoSuchElementException
{
Operation op = (Operation) ops.get(opName);
if(op == null)
throw new NoSuchElementException();
return op;
}
/**
* Adds the specified operation with the given name
* to the Manager. The operation must be compatible with the type
* of operation that this class handles.
*
* @param name the name of the operation to be associated with it
* @param operation the operation object
*
* @exception IllegalArgumentException occurs when the given
* operation is not compatible with the Manager.
*/
public void add(String name, Operation operation)
throws IllegalArgumentException
{
if( !classTypeOk(operation) )
{
throw new IllegalArgumentException("Given operation is not" +
"compatible with this Manger");
}
else
{
ops.put(name, operation);
}
}
/**
* Checks to see if the specified operation is compatible with the manager.
* For example, here is the implementation used by ImportMgr.
*
* return (op instanceof ImportFilter); ** * @return
true if it is compatible, false if
* it is not.
*/
public abstract boolean classTypeOk(Operation op);
/**
* Sets the default operation to the one specified.
*
* @param name the name of the operation to use as the default. If it is
* null, then no default method will be set and an
* exception will be thrown when getDefault is called.
*
* @exception NoSuchElementException when the specified name is not
* null and does not match any filter known to the ImportMgr,
* this will be thrown.
*/
public void setDefault(String name) throws NoSuchElementException
{
if(name == null)
defaultName = null;
else if(ops.containsKey(name))
defaultName = name;
else
throw new NoSuchElementException();
}
/**
* Gives the default operation for this manager.
*
* @return the operation, or null if the default is not set.
*/
public Operation getDefault()
{
return (Operation) ops.get(defaultName);
}
/**
* Gives the name of the default operation for this manager.
*
* @return the name of the operation, or null if the default
* is not set.
*/
public String getDefaultName()
{
return defaultName;
}
}