|
||||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES | |||||||||
See:
Description
| Interface Summary | |
|---|---|
| AggregationFunction | Todo: Document Me |
| Expression | An expression is a lightweight function that does not maintain a state. |
| ExpressionRuntime | The expression runtime encapsulates all properties of the current report processing run that might be needed to successfully evaluate an expression. |
| FieldAggregationFunction | Todo: Document Me |
| Function | The interface for report functions. |
| LayoutProcessorFunction | A tagging interface that allows the system to differentiate between functions that compute values and functions that modify the report-definiton. |
| OutputFunction | A simple tagging interface for the transition from function-based layouting back to explicit layouting. |
| ProcessingContext | The processing context hold information about the progress of the report processing and contains global properties used during the report processing. |
| StructureFunction | A structure function is a annonymous function that modifes the structure of the report or computes changes to the report definition on the current report. |
| ValidateableExpression | A decorator interface that allows an expression to validate it's parameters. |
| Class Summary | |
|---|---|
| AbstractCompareExpression | Deprecated. This can be better handled in a formula. |
| AbstractElementFormatFunction | The AbstractElementFormatFunction provides a common base implementation for all functions that need to modify the report definition or the style of an report element or band during the report processing. |
| AbstractExpression | An abstract base class for implementing new report expressions. |
| AbstractFunction | Base class for implementing new report functions. |
| AverageExpression | Deprecated. this has been replaced by the ColumnAverageExpression. |
| ColumnAggregationExpression | The base-class for all expressions that aggregate values from multiple columns. |
| ColumnAverageExpression | Deprecated. the same can be achived with a formula "AVG([column1], [column2], [column3])" |
| ColumnDifferenceExpression | Deprecated. This can be done easier with a formula. |
| ColumnDivisionExpression | Deprecated. Use a formula |
| ColumnMaximumExpression | Deprecated. Use a formula |
| ColumnMinimumExpression | Deprecated. Use a formula |
| ColumnMultiplyExpression | Deprecated. Use a formula |
| ColumnSumExpression | Deprecated. Use a formula |
| CompareFieldsExpression | Deprecated. Use a formula instead. |
| ConditionalItemSumFunction | Deprecated. Filter the values by using a plain formula. |
| ConvertToDateExpression | Parses a string into a date using the given date-format. |
| ConvertToNumberExpression | Parses a string into a number using the given decimal-format. |
| CountDistinctFunction | Counts the distinct occurences of an certain value of an column. |
| CreateGroupAnchorsFunction | Deprecated. It is easier to create anchors using a Style-expression. |
| CreateHyperLinksFunction | Deprecated. add style expressions to the 'href-target' and 'href-window' instead. |
| DateCutExpression | Deprecated. The VariableDateExpression is much better suited for this purpose. |
| ElementColorFunction | Deprecated. add a style expression for the 'paint' style instead |
| ElementTrafficLightFunction | Deprecated. This function can be safely replaced by a formula. |
| ElementVisibilityFunction | Deprecated. add a style-expression for the visible style-key instead. |
| ElementVisibilitySwitchFunction | Deprecated. Use the RowBandingFunction to modify the band's background color directly. |
| EventMonitorFunction | A function that logs each event that it receives. |
| ExpressionCollection | Collects all expressions used in the report. |
| ExpressionUtilities | A collection of utility methods which may be useful for expression-implementors. |
| FormulaExpression | The formula expression is used to evaluate a LibFormula/OpenFormula expression. |
| FormulaFunction | The formula function is a stateful version of the FormulaExpression and is used to evaluate a LibFormula/OpenFormula expression. |
| FunctionUtilities | A collection of utility methods relating to functions. |
| GenericExpressionRuntime | Todo: Document me! Date: 13.05.2010 Time: 16:53:49 |
| GroupCountFunction | A report function that counts groups in a report. |
| HideElementByNameFunction | Deprecated. Use a formula |
| HideElementIfDataAvailableExpression | Deprecated. Use a Style-Expression or make proper use of the No-Data-Band |
| HideNullValuesFunction | Deprecated. This should be done using Style-Expressions. |
| HidePageBandForTableExportFunction | Hides the page header and footer if the export type is not pageable. |
| IsEmptyExpression | Deprecated. Use a Formula Instead |
| IsNullExpression | Deprecated. Use a Formula Instead |
| ItemAvgFunction | A report function that calculates the average of one field (column) from the TableModel. |
| ItemColumnQuotientExpression | Deprecated. Use PercentageExpression instead, it's name is much clearer |
| ItemCountFunction | A report function that counts items in a report. |
| ItemHideFunction | The ItemHideFunction hides equal values in a group. |
| ItemMaxFunction | A report function that calculates the maximum value of one field (column) from the data-row. |
| ItemMinFunction | A report function that calculates the minimum value of one field (column) from the data-row. |
| ItemPercentageFunction | Calculates the percentage value of a numeric field. |
| ItemSumFunction | A report function that calculates the sum of one field (column) from the data-row. |
| NegativeNumberPaintChangeFunction | Deprecated. The same thing can be achieved using a simple StyleExpression on the element's PAINT stylekey. |
| PageFunction | A report function that counts pages. |
| PageItemCountFunction | An ItemCount function, that is reset to zero on every new page. |
| PageItemSumFunction | An ItemSum function, that is reset to zero on every new page. |
| PageOfPagesFunction | A report function that combines PageFunctionand PageTotalFunction. |
| PageTotalFunction | Prints the total number of pages of an report. |
| PaintComponentFunction | Deprecated. Use the new Component-Element instead. |
| PaintDynamicComponentFunction | Deprecated. Use the new Component-Element instead. |
| PercentageExpression | Deprecated. The same can be achieved using a simple ValueExpression. |
| ReportFormulaContext | The report formula context is a FormulaContext implementation that connects the formula evaluator with the current data-row of the report process. |
| RowBandingFunction | A function that alternates the background-color for each item-band within a group. |
| ShowElementByNameFunction | Deprecated. This can be done easier using style-expressions |
| ShowElementIfDataAvailableExpression | Deprecated. Use a formula instead. |
| TextFormatExpression | Deprecated. Use the MessageFormatExpression instead. |
| TotalCalculationFunction | A report function that stores the result of a calculation for a group or the complete report. |
| TotalGroupCountFunction | A report function that counts the total of groups in a report. |
| TotalGroupSumFunction | A report function that calculates the sum of one field (column) from the Data-Row. |
| TotalGroupSumQuotientFunction | A report function that calculates the quotient of two summed fields (columns) from the report's data row. |
| TotalGroupSumQuotientPercentFunction | A report function that calculates the quotient of two summed fields (columns) from the data-row. |
| TotalItemCountFunction | A report function that counts the total number of items contained in groups in a report. |
| TotalItemMaxFunction | A report function that pre-computes the largest item in a group. |
| TotalItemMinFunction | A report function that pre-computes the smallest item in a group. |
| TotalPageItemCountFunction | A report function that counts the total number of items contained in groups in a report. |
| TriggerPageFooterFunction | This function enables a "PageFooter only on last page" functionality. |
| WrapperExpressionRuntime | |
| Exception Summary | |
|---|---|
| FunctionProcessingException | An exception that indicates that a function has not been correctly initialised. |
The function package contains statefull functions and stateless expression for JFreeReport.
The following lines apply to both functions and expressions.
JFreeReport supports 2 kinds of user defined calculations: Functions are statefull calculations, when the report proceedes they change their state, they sum up, calculate averages, count etc. Statefull means in that case, given you feed the same event multiple times into the function,you are not guaranteed to get the same result.
Expressions in contrast do not maintain a state, they calculate a value or change the report-elements depending on the current Event feed to them. If you feed the same Event into the Expression multiple times, you will always get the same result.
Common to both variants is: Data is fed into the function/expression by using a DataRow object. This object provides the (among others) these methods
Object get(String name);
Object get(int columnName);
Expressions are simple and easily explained: Expression have the method
Object getValue() which is called when the expression is queried.
All expression have to override this method to perform the calculation and to return
the value.
Functions are more complex:
Functions have several notification methods, where the system informs the function
that a new event is processed.
public void pageStarted (ReportEvent event);
public void reportStarted (ReportEvent event);
public void groupStarted (ReportEvent event);
public void itemsStarted (ReportEvent event);
public void itemsAdvanced (ReportEvent event);
public void itemsFinished (ReportEvent event);
public void groupFinished (ReportEvent event);
public void reportFinished (ReportEvent event);
public void pageFinished (ReportEvent event);
Functions live in an own environment, separated from the outside world. Changing the original JFreeReport object does not affect the inner JFreeReport-Object. You are also unable to add new Functions or expressions to the report from inside, so all functions and expression have to be set before the report processing has begun.
All Functions have to be cloneable. It is not guaranteed that the report is processed in an linear order, but it is guaranteed that a single instance of a function does pass a reportstate only once.
That means: When processing the report, the system clones the functions on certain save-points (for instance whenever a page is finished). This saved copy can later be used to restart the report processing on that saved point. The copy-state made will never return to a previous save point, but it can (and certainly will occur) that this copy is used to process the report from that saved point on.
So when saving a state after page 2, it will never happen, that this page-2-copy gets used to process page 2 a second time, but it could happen that copies of this page-2-state process the page 3 again and again.
The best way to avoid cloning problems is to use Unmodifiable objects or primitive
datatypes when storing a state. Using java.lang.String, one of the java.lang.Number
implementers or any other unmodifiable object type is always save. If you use complex
objects, lists or hashtables and you get weird results, try to implement a
deep-object-copy in the clone() method of the function for these objects.
Using the functions
The function implementation is loaded via its default constructor by the report parser, all function implementations which should be used from within the xml-definitions must define a public default constructor. The functions implementation is defined by specifiying the "class" attribute of the "function" tag and is loaded by using the default class loader. Your function implementation must be in the classloaders classpath.
As with every function, a single function can return one value, something mathematicans express like y = f(x) where x is the data from your report processing.
A function is called several times, for every state change (whenever the report advances) one of the ReportListener methods are called (reportStarted, groupStarted etc). Expressions do not receive events, they just perform their computations based on the current state.
The functions value is returned by the "getValue()" function. You can return any Object, but make sure, that this object does not get modified anymore after it was returned to the caller. (A simple way to obey to this rule is to create a new object whenever the computed object changes).
Functions may reuse results from other functions by using and querying the DataRow object supplied in the report state or the function.
The order of the functions and the order for receiving events is undefined for functions of the same dependency level. So if you define a function which reads values from an other function, it is wise to define the dependencies for these functions.
Defining dependencies is easy: A function with an higher dependency is called before any function with a lower dependency. By default all user functions have the dependency of "0", the lowest possible level. The dependency is defined by specifying the "deplevel" attribute of the function or expression tag.
When using the API, the dependency level is read by "getDependencyLevel()" and can be set with "setDependencyLevel(int)".
For the example above, the caller function would have the dependency level of '0' and the called function the level of '1' or higher.
|
||||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES | |||||||||