|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
ObjectAnnotationDrivenProcessFactory
public abstract class AnnotationDrivenProcessFactory
A process factory that uses annotations to determine much of the metadata
needed to describe a Process
.
The annotations supported are:
DescribeProcess
- describes the process functionality
DescribeResult
- describes a process result
DescribeParameter
- describes a process parameter
Field Summary | |
---|---|
protected String |
namespace
|
Constructor Summary | |
---|---|
AnnotationDrivenProcessFactory(InternationalString title,
String namespace)
|
Method Summary | |
---|---|
Process |
create(Name name)
Cerate a process (for the indicated name). |
protected abstract Object |
createProcessBean(Name name)
Creates the bean upon which the process execution method will be invoked. |
InternationalString |
getDescription(Name name)
Human readable description of the specified process |
Map<RenderingHints.Key,?> |
getImplementationHints()
Map of hints (maybe unmodifiable) used by this factory to customize its use. |
Map<String,Parameter<?>> |
getParameterInfo(Name name)
Description of the Map parameter to use when executing. |
protected abstract DescribeProcess |
getProcessDescription(Name name)
|
Map<String,Parameter<?>> |
getResultInfo(Name name,
Map<String,Object> parameters)
Description of the results returned |
InternationalString |
getTitle()
Name suitable for display to end user. |
InternationalString |
getTitle(Name name)
Human readable title suitable for display for the specified process Please note that this title is *not* stable across locale; if you want to remember a ProcessFactory between runs please use getName (which is dependent on the implementor to guarantee uniqueness) or use the classname |
String |
getVersion(Name name)
Return the version of the process |
boolean |
isAvailable()
Returns true if this factory is ready for use. |
protected Method |
lookupInvertGridGeometry(Object targetObject,
String methodName)
Used to recognise RenderingProcess implementations; returns a non null
method for RenderingProcess.invertGridGeometry(Map, Query, GridGeometry) . |
protected Method |
lookupInvertQuery(Object targetObject,
String methodName)
Used to recognise RenderingProcess implementations; returns a non null
method for RenderingProcess.invertQuery(Map, Query, GridGeometry) . |
protected abstract Method |
method(String localPart)
|
boolean |
supportsProgress(Name name)
It is up to the process implementors to implement progress on the task, this method is used to see if the process has progress monitoring implemented |
Methods inherited from class Object |
---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
Methods inherited from interface ProcessFactory |
---|
getNames |
Field Detail |
---|
protected String namespace
Constructor Detail |
---|
public AnnotationDrivenProcessFactory(InternationalString title, String namespace)
Method Detail |
---|
protected abstract DescribeProcess getProcessDescription(Name name)
protected abstract Method method(String localPart)
public InternationalString getTitle()
ProcessFactory
getTitle
in interface ProcessFactory
public InternationalString getDescription(Name name)
ProcessFactory
getDescription
in interface ProcessFactory
name
- the process whose description is to be returned
public Map<String,Parameter<?>> getParameterInfo(Name name)
ProcessFactory
getParameterInfo
in interface ProcessFactory
name
- the process identifier
public Map<String,Parameter<?>> getResultInfo(Name name, Map<String,Object> parameters) throws IllegalArgumentException
ProcessFactory
getResultInfo
in interface ProcessFactory
name
- the process identifierparameters
- the parameters to be used
IllegalArgumentException
public InternationalString getTitle(Name name)
ProcessFactory
Please note that this title is *not* stable across locale; if you want to remember a ProcessFactory between runs please use getName (which is dependent on the implementor to guarantee uniqueness) or use the classname
getTitle
in interface ProcessFactory
name
- the process identifierpublic String getVersion(Name name)
ProcessFactory
getVersion
in interface ProcessFactory
name
- the process identifier
public boolean supportsProgress(Name name)
ProcessFactory
supportsProgress
in interface ProcessFactory
name
- the process identifier
public boolean isAvailable()
OptionalFactory
true
if this factory is ready for use.
An optional factory may returns false
for now but returns true
later.
However, the converse is not recommended.
isAvailable
in interface OptionalFactory
public Map<RenderingHints.Key,?> getImplementationHints()
Factory
FactoryUsingVolatileDependencies
).
The primary purpose of this method is to determine if an existing
factory instance can be reused for a set of user-supplied hints. This method is invoked by
FactoryRegistry
in order to compare this factory's hints against user's hints.
This is dependency introspection only; FactoryRegistry
never
invokes this method for creating new factories.
Keys are usually static constants from the Hints
class, while values are
instances of some key-dependent class. The key set must contains
at least all hints impacting functionality. While the key set may contains all hints
supplied by the user, it is recommended to limit the set to only the hints used by this
particular factory instance. A minimal set will helps FactoryRegistry
to compare
only hints that matter and avoid the creation of unnecessary instances of this factory.
The hint values may be different than the one supplied by the user. If a user supplied a
hint as a Class
object, this method shall replace it by the actual instance used,
if possible.
Implementations of this method are usually quite simple. For example if a datum authority factory uses an ordinary datum factory, its method could be implemented as below (note that we should not check if the datum factory is null, since key with null value is the expected behaviour in this case). Example:
Map hints = new HashMap();
hints.put(Hints.DATUM_FACTORY, datumFactory);
return hints;
getImplementationHints
in interface Factory
public Process create(Name name)
Subclasses can control the process using their implementation of:
createProcessBean(Name)
: return a bean to use; or null for static methods
create
in interface ProcessFactory
name
- the process identifier
protected Method lookupInvertGridGeometry(Object targetObject, String methodName)
RenderingProcess
implementations; returns a non null
method for RenderingProcess.invertGridGeometry(Map, Query, GridGeometry)
.
Used to look up the method to use for "invertGridGeometry"; if a specific method name is not provided "invertGridGeometry" will be used.
targetObject
- Target object; may be null for static method lookupmethodName
- method to use for "invertGridGeometry"
protected Method lookupInvertQuery(Object targetObject, String methodName)
RenderingProcess
implementations; returns a non null
method for RenderingProcess.invertQuery(Map, Query, GridGeometry)
.
Used to look up the method to use for "invertQuery"; if a specific method name is not provided "invertGridGeometry" will be used.
targetObject
- Target object; may be null for static method lookupmethodName
- method to use for "invertQuery"
null
if not a RenderingProcessprotected abstract Object createProcessBean(Name name)
Can be null in case the method is a static one
name
- Name of the process bean
|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |