net.sf.dynamicreports.design.transformation.AbstractExpressionTransform Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of dynamicreports-core Show documentation
Show all versions of dynamicreports-core Show documentation
DynamicReports is an open source Java reporting library based on JasperReports. It allows to create dynamic report designs and it doesn't need a visual report designer.
You can very quickly create reports and produce documents that can be displayed, printed or exported into many popular formats such as PDF, Excel, Word and others.
/**
* DynamicReports - Free Java reporting library for creating reports dynamically
*
* Copyright (C) 2010 - 2016 Ricardo Mariaca
* http://www.dynamicreports.org
*
* This file is part of DynamicReports.
*
* DynamicReports is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* DynamicReports is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with DynamicReports. If not, see fields;
private Map variables;
private Map systemExpressions;
private Map jasperExpressions;
private Map simpleExpressions;
private Map complexExpressions;
private Map, DRIDesignExpression> expressions;
private List sorts;
public AbstractExpressionTransform(DesignTransformAccessor accessor) {
this.accessor = accessor;
init();
}
private void init() {
fields = new LinkedHashMap();
variables = new LinkedHashMap();
systemExpressions = new HashMap();
jasperExpressions = new HashMap();
simpleExpressions = new HashMap();
complexExpressions = new HashMap();
expressions = new HashMap, DRIDesignExpression>();
sorts = new ArrayList();
}
public void transform() throws DRException {
for (DRIField field : transformFields()) {
transformExpression(field);
}
for (DRIVariable variable : transformVariables()) {
transformExpression(variable);
}
for (DRISort sort : transformSorts()) {
transformSort(sort);
}
}
public DRIDesignExpression transformExpression(DRIExpression expression) throws DRException {
return transformExpression(expression, null, null);
}
protected DRIDesignExpression transformExpression(DRIExpression expression, String parameterName) throws DRException {
return transformExpression(expression, null, parameterName);
}
protected DRIDesignExpression transformExpression(DRIExpression expression, DRIValueFormatter valueFormatter, String parameterName) throws DRException {
if (expression == null) {
return null;
}
if (valueFormatter != null) {
return addExpression(new DRDesignValueFormatter(valueFormatter, transformExpression(expression)));
}
if (expressions.containsKey(expression)) {
return expressions.get(expression);
}
DRIDesignExpression express;
if (expression instanceof DRISystemExpression) {
express = new DRDesignSystemExpression((DRISystemExpression) expression);
}
else if (expression instanceof DRIJasperExpression) {
express = new DRDesignJasperExpression((DRIJasperExpression) expression);
}
else if (expression instanceof DRISimpleExpression) {
express = new DRDesignSimpleExpression((DRISimpleExpression) expression, parameterName);
}
else if (expression instanceof DRIComplexExpression) {
express = transformComplexExpression((DRIComplexExpression) expression, parameterName);
}
else if (expression instanceof DRIField) {
express = transformField((DRIField) expression);
}
else if (expression instanceof DRIVariable) {
express = transformVariable((DRIVariable) expression);
}
else if (expression instanceof DRIValueColumn) {
express = transformExpression(((DRIValueColumn) expression).getComponent().getValueExpression());
}
else if (expression instanceof DRIBooleanColumn) {
express = transformExpression(((DRIBooleanColumn) expression).getComponent().getValueExpression());
}
else if (expression instanceof DRISubtotal) {
express = transformExpression(((DRISubtotal) expression).getValueField().getValueExpression());
}
else {
throw new DRDesignReportException("Expression " + expression.getClass().getName() + " not supported");
}
express = addExpression(express);
if (valueFormatter == null) {
expressions.put(expression, express);
}
return express;
}
private DRDesignField transformField(DRIField field) {
DRDesignField designField = new DRDesignField();
designField.setName(field.getName());
designField.setValueClass(field.getValueClass());
designField.setDescription(accessor.getTemplateTransform().getFieldDescription(field));
return designField;
}
private DRIDesignExpression transformComplexExpression(DRIComplexExpression complexExpression, String parameterName) throws DRException {
DRDesignComplexExpression designComplexExpression = new DRDesignComplexExpression(complexExpression, parameterName);
for (DRIExpression expression : complexExpression.getExpressions()) {
designComplexExpression.addExpression(transformExpression(expression));
}
return designComplexExpression;
}
private DRIDesignExpression transformVariable(DRIVariable variable) throws DRException {
DRDesignVariable designVariable = new DRDesignVariable(variable.getName());
designVariable.setValueExpression(transformExpression(variable.getValueExpression()));
designVariable.setInitialValueExpression(transformExpression(variable.getInitialValueExpression()));
designVariable.setCalculation(variable.getCalculation());
designVariable.setResetType(getVariableResetType(variable));
designVariable.setResetGroup(getVariableResetGroup(variable));
return designVariable;
}
protected ResetType getVariableResetType(DRIVariable variable) {
return null;
}
protected DRDesignGroup getVariableResetGroup(DRIVariable variable) throws DRException {
return null;
}
private void transformSort(DRISort sort) throws DRException {
DRIDesignExpression expression = transformExpression(sort.getExpression());
DRIDesignExpression sortExpression;
if (expression instanceof DRIDesignField || expression instanceof DRIDesignVariable) {
sortExpression = expression;
}
else {
@SuppressWarnings({ "rawtypes", "unchecked" })
DRVariable variable = new DRVariable(sort.getExpression(), Calculation.NOTHING);
variable.setResetType(Evaluation.NONE);
sortExpression = transformExpression(variable);
}
DRDesignSort designSort = new DRDesignSort();
designSort.setExpression(sortExpression);
designSort.setOrderType(sort.getOrderType());
sorts.add(designSort);
}
protected DRIDesignPropertyExpression transformPropertyExpression(DRIPropertyExpression propertyExpression) throws DRException {
DRDesignPropertyExpression designPropertyExpression = new DRDesignPropertyExpression();
designPropertyExpression.setName(propertyExpression.getName());
designPropertyExpression.setValueExpression(transformExpression(propertyExpression.getValueExpression()));
return designPropertyExpression;
}
protected DRIDesignParameterExpression transformParameterExpression(DRIParameterExpression parameterExpression) throws DRException {
DRDesignParameterExpression designParameterExpression = new DRDesignParameterExpression();
designParameterExpression.setName(parameterExpression.getName());
designParameterExpression.setValueExpression(transformExpression(parameterExpression.getValueExpression()));
return designParameterExpression;
}
private DRIDesignExpression addExpression(DRIDesignExpression expression) {
if (expression == null) {
return null;
}
if (expression instanceof DRIDesignField) {
return addField((DRIDesignField) expression);
}
else if (expression instanceof DRIDesignVariable) {
addVariable((DRDesignVariable) expression);
}
else if (expression instanceof DRIDesignSystemExpression) {
addSystemExpression((DRIDesignSystemExpression) expression);
}
else if (expression instanceof DRIDesignJasperExpression) {
addJasperExpression((DRIDesignJasperExpression) expression);
}
else if (expression instanceof DRIDesignSimpleExpression) {
addSimpleExpression((DRIDesignSimpleExpression) expression);
}
else if (expression instanceof DRIDesignComplexExpression) {
addComplexExpression((DRIDesignComplexExpression) expression);
}
else {
throw new DRDesignReportException("Expression " + expression.getClass().getName() + " not supported");
}
return expression;
}
private void addVariable(DRDesignVariable variable) {
if (variables.containsKey(variable.getName())) {
if (!variables.get(variable.getName()).equals(variable)) {
throw new DRDesignReportException("Duplicate declaration of variable \"" + variable.getName() + "\"");
}
return;
}
variables.put(variable.getName(), variable);
}
private DRIDesignField addField(DRIDesignField field) {
if (fields.containsKey(field.getName())) {
DRIDesignField fld = fields.get(field.getName());
if (!fld.getValueClass().equals(field.getValueClass())) {
throw new DRDesignReportException("Duplicate declaration of field \"" + field.getName() + "\"");
}
return fld;
}
fields.put(field.getName(), field);
return field;
}
private void addSystemExpression(DRIDesignSystemExpression systemExpression) {
if (systemExpressions.containsKey(systemExpression.getName())) {
return;
}
systemExpressions.put(systemExpression.getName(), systemExpression);
}
private void addJasperExpression(DRIDesignJasperExpression jasperExpression) {
if (jasperExpressions.containsKey(jasperExpression.getName())) {
return;
}
jasperExpressions.put(jasperExpression.getName(), jasperExpression);
}
private void addSimpleExpression(DRIDesignSimpleExpression simpleExpression) {
if (simpleExpressions.containsKey(simpleExpression.getName())) {
if (!simpleExpressions.get(simpleExpression.getName()).equals(simpleExpression)) {
throw new DRDesignReportException("Duplicate declaration of simple expression \"" + simpleExpression.getName() + "\"");
}
return;
}
simpleExpressions.put(simpleExpression.getName(), simpleExpression);
}
private void addComplexExpression(DRIDesignComplexExpression complexExpression) {
if (complexExpressions.containsKey(complexExpression.getName())) {
if (!complexExpressions.get(complexExpression.getName()).equals(complexExpression)) {
throw new DRDesignReportException("Duplicate declaration of complex expression \"" + complexExpression.getName() + "\"");
}
return;
}
complexExpressions.put(complexExpression.getName(), complexExpression);
}
public Collection getFields() {
return fields.values();
}
public Collection getVariables() {
return variables.values();
}
public Collection getSystemExpressions() {
return systemExpressions.values();
}
public Collection getJasperExpressions() {
return jasperExpressions.values();
}
public Collection getSimpleExpressions() {
return simpleExpressions.values();
}
public Collection getComplexExpressions() {
return complexExpressions.values();
}
public Collection getSorts() {
return sorts;
}
protected abstract List> transformFields();
protected abstract List> transformVariables();
protected abstract List transformSorts();
protected abstract DRIDesignDataset getDataset();
}