Function instances, from which
then, subsequently, function values can be acquired.See: Description
| Interface | Description |
|---|---|
| Function<R> |
A representation of a piece of functionality (a 'function').
|
| Class | Description |
|---|---|
| AbstractFunction<R> |
An abstract representation of a piece of functionality (a 'function').
|
| AutodefiningParameters |
If there is no Parameter definition array available you could try it with this specialization, which does not need one.
|
| BeanFunction |
One or more functions based on a Java-bean.
|
| BeanFunction.Producer |
A producer can instantiate beans
|
| BeanFunctionProvider | |
| ClassFunctionProvider |
Maintains all methods of a certain class as function objects (as long as they have unique names).
|
| CloneNodeFunction |
A function on nodes to clone them.
|
| CombinedFunction<R> |
A combined function combines other function objects.
|
| DescribedFunctionProvider |
A described function provider maintains a set of
Function objects, and also contains functionality to add
gui information to the provider itself. |
| ExampleBean |
A bean can be accessed through the function framework.
|
| ExampleBuilder |
Example builder implementation implementing functions.
|
| FunctionFactory |
The FunctionFactory instanciates
Function objects. |
| FunctionProvider |
A function provider maintains a set of
Function objects. |
| Functions |
This class defines static methods for defining Function and Parameters objects.
|
| FunctionSet |
The implementation of one set ('namespace') of functions.
|
| FunctionSets |
A utility class for maintaining and querying functionsets.
|
| GuiFunction |
The gui function of MMObjectBuilder
|
| IndexFunction |
The index node functions can be assigned to nodes which are connected by an 'index' relation.
|
| IndexFunction.Stack<C> | |
| MethodFunction |
A function based on an abritrary method.
|
| NodeFunction<R> |
A NodeFunction represents a function on a node instances of this builder.
|
| Parameter<C> |
Each (function) argument is specified by a Parameter object.
|
| Parameter.Wrapper |
A Parameter.Wrapper wraps one Parameter around a Parameter[] (then you can put it in a
Parameter[]).
|
| Parameters |
This class implemements the Parameters interface.
|
| Parameters.SerializableAbstractMap<K,V> | |
| PatternNodeFunctionProvider |
This Function provider creates function objects , which can create a String function based on a
pattern.
|
| PatternNodeFunctionProvider.PatternNodeFunction | |
| PatternParameter<C> |
Especially the blocks of the framework may want to allow for all parameters according to a
certain pattern.
|
| ReturnType<C> |
Description of the return type of certain function.
|
| SetFunction |
A SetFunction is a
Function which wraps precisely one method of a class. |
| Utils |
Several utility methods.
|
| WrappedFunction<R> |
A wrapped function is a base class for function objects based on an other function object.
|
| Enum | Description |
|---|---|
| SetFunction.Type |
| Annotation Type | Description |
|---|---|
| FunctionParameters |
This annotation can be used on a Bean which is to be wrapped in a
BeanFunction to
explicitely define which setters must be interpreted as function parameters. |
| Name |
The name of a parameter as a annotation interface.
|
| Required |
This annotation can be used on methods, to make the parameter of
the corresponding
BeanFunction required. |
| Type |
This annotation can be used on methods, to attribute a
DataType, e.g. |
The function framework is all about the creation of Function instances, from which
then, subsequently, function values can be acquired. To do that you need to supply the
Parameters to the function.
Functions come in several different variants. There are completely stand alone functions,
e.g. Functions (of which a limited number of instances
can exists), but they can also be associated with some object (in OO speak: they mimic
instance member functions of that object then). NodeFunction Function objects can e.g. be associated with Node objects. Such function objects can exists very many (for every
possible node, for every function on it, there can be a Function object). Other object
instance related functions may be associated with Modules and NodeManager.
Taglib users would use the function tags. Those are documented in the taglib reference
documentation (and a bit of small example code can be found in javadoc of ExampleBuilder). More taglib examples for functions can be found in
/mmexamples/taglib/functions.jsp of the distro.
A programmer needs to know several things.
FunctionProvider.addFunction(Function)
AbstractFunction is available to quickly define a function.
NodeFunction is available to quickly define a function on a Node.
ExampleBuilder.
MMBase 1.9-SNAPSHOT - ${javadoctimestamp}