Java JRExpression类代码示例

import net.sf.jasperreports.engine.JRExpression; //导入依赖的package包/类
private BucketDefinition createServiceBucket(JRCrosstabGroup group, int groupIndex, byte evaluation) throws JRException
{
	JRCrosstabBucket bucket = group.getBucket();

	Comparator<Object> comparator = null;
	JRExpression comparatorExpression = bucket.getComparatorExpression();
	if (comparatorExpression != null)
	{
		comparator = (Comparator<Object>) evaluateExpression(comparatorExpression, evaluation);
	}
	
	BucketOrderer orderer = createOrderer(group, groupIndex, comparator);
	BucketDefinition bucketDefinition = new BucketDefinition(bucket.getValueClass(),
			orderer, comparator, bucket.getOrder(), 
			group.getTotalPositionValue());
	
	Boolean mergeHeaderCells = group.getMergeHeaderCells();
	// by default the header cells are merged
	bucketDefinition.setMergeHeaderCells(mergeHeaderCells == null || mergeHeaderCells);
	
	return bucketDefinition;
}
 

import net.sf.jasperreports.engine.JRExpression; //导入依赖的package包/类
protected JRExpression getColumnHeaderLabelExpression(Cell header)
{
	List<JRChild> detailElements = header == null ? null : header.getChildren();
	// only consider cells with a single text fields
	if (detailElements == null || detailElements.size() != 1)
	{
		return null;
	}

	JRChild detailElement = detailElements.get(0);
	if (detailElement instanceof JRTextField)
	{
		return ((JRTextField) detailElement).getExpression();
	}

	if (detailElement instanceof JRStaticText)
	{
		return builtinEvaluatorFactory.createConstantExpression(((JRStaticText)detailElement).getText());
	}
	
	return null;
}
 

import net.sf.jasperreports.engine.JRExpression; //导入依赖的package包/类
public void writeExpression(
		JRExpression expression, String parentName, String expressionSuffix, String defaultClassName)
{
	if (expression != null)
	{
		String expressionName = parentName +  expressionSuffix;
		write( "JRDesignExpression " + expressionName + " = new JRDesignExpression();\n");
		write( expressionName + ".setId({0, number, #});\n", expression.getId());
		write( expressionName + ".setType({0});\n", expression.getType());
		write( expressionName + ".setText(\"{0}\");\n", JRStringUtil.escapeJavaStringLiteral(expression.getText()));

		write( parentName + ".set" + expressionSuffix + "(" + expressionName + ");\n");
		
		flush();
	}
}
 

import net.sf.jasperreports.engine.JRExpression; //导入依赖的package包/类
protected BucketOrderer createOrderer(JRCrosstabGroup group, int groupIndex, Comparator<Object> bucketComparator)
{
	BucketOrderer orderer = null;
	
	if (group instanceof JRCrosstabRowGroup
			&& orderByColumnInfo != null && orderByColumnInfo.getOrder() != null
			// ordering by column only applies to nesting groups is they are not already ordered
			&& (groupIndex == rowGroups.length - 1 || group.getBucket().getOrder() == BucketOrder.NONE))
	{
		orderer = new OrderByColumnOrderer(orderByColumnInfo);
	}
	
	if (orderer == null)
	{
		JRCrosstabBucket bucket = group.getBucket();
		JRExpression orderByExpression = bucket.getOrderByExpression();
		if (orderByExpression != null && bucket.getOrder() != BucketOrder.NONE)
		{
			if (log.isDebugEnabled())
			{
				log.debug("using order by expression to order group " + group.getName());
			}
			
			// when we have an order by expression, the comparator is applied to order values
			Comparator<Object> orderValueComparator = BucketDefinition.createOrderComparator(bucketComparator, bucket.getOrder());
			orderer = new BucketExpressionOrderer(orderByExpression, orderValueComparator);
		}
	}
	
	return orderer;
}
 

import net.sf.jasperreports.engine.JRExpression; //导入依赖的package包/类
protected void writeExpression(StringBuilder expressionBuffer, JRExpression expression, byte evaluationType)
{
	expressionBuffer.append("if (id == ");
	expressionBuffer.append(sourceTask.getExpressionId(expression));
	expressionBuffer.append(")\n");
	expressionBuffer.append("        {\n");
	expressionBuffer.append("            value = (");
	expressionBuffer.append(this.generateExpression(expression, evaluationType));
	expressionBuffer.append(");\n");
	expressionBuffer.append("        }\n");
}
 

import net.sf.jasperreports.engine.JRExpression; //导入依赖的package包/类
/**
 *
 */
public <T> void verify(Collection<T> expressions) throws JRException
{
	try
	{
		interpreter.eval("bshEvaluator = createBshEvaluator()");
		
		if (expressions != null)
		{
			for(Iterator<T> it = expressions.iterator(); it.hasNext();)
			{
				JRExpression expression = (JRExpression)it.next();
				interpreter.eval("bshEvaluator.evaluateOld(" + expression.getId() + ")");
			}
		}
	}
	catch(TargetError te)
	{
		//ignore
	}
	catch(EvalError e)
	{
		throw 
			new JRException(
				EXCEPTION_MESSAGE_KEY_EXPRESSIONS_TESTING_ERROR,
				new Object[]{e.getMessage(), e.getErrorLineNumber(), extractLineContent(e)});
	}
}
 

import net.sf.jasperreports.engine.JRExpression; //导入依赖的package包/类
/**
 * Sets the expression which will be used to generate the hyperlink tooltip.
 * 
 * @param hyperlinkTooltipExpression the expression which will be used to generate the hyperlink tooltip
 * @see #getHyperlinkTooltipExpression()
 */
public void setHyperlinkTooltipExpression(JRExpression hyperlinkTooltipExpression)
{
	Object old = this.hyperlinkTooltipExpression;
	this.hyperlinkTooltipExpression = hyperlinkTooltipExpression;
	getEventSupport().firePropertyChange(JRDesignHyperlink.PROPERTY_HYPERLINK_TOOLTIP_EXPRESSION, old, this.hyperlinkTooltipExpression);
}
 

import net.sf.jasperreports.engine.JRExpression; //导入依赖的package包/类
/**
 *
 */
public void setRangeAxisMaxValueExpression(JRExpression rangeAxisMaxValueExpression)
{
	Object old = this.rangeAxisMaxValueExpression;
	this.rangeAxisMaxValueExpression = rangeAxisMaxValueExpression;
	getEventSupport().firePropertyChange(PROPERTY_RANGE_AXIS_MAXVALUE_EXPRESSION, old, this.rangeAxisMaxValueExpression);
}
 

import net.sf.jasperreports.engine.JRExpression; //导入依赖的package包/类
protected static void addGenericElementRules(Digester digester)
{
	String genericElementPattern = "*/" + JRXmlConstants.ELEMENT_genericElement;
	digester.addFactoryCreate(genericElementPattern, 
			JRGenericElementFactory.class);
	digester.addSetNext(genericElementPattern, "addElement", 
			JRDesignElement.class.getName());
	
	String genericElementTypePattern = genericElementPattern + "/" 
		+ JRXmlConstants.ELEMENT_genericElementType;
	digester.addFactoryCreate(genericElementTypePattern, 
			JRGenericElementTypeFactory.class);
	digester.addSetNext(genericElementTypePattern, "setGenericType", 
			JRGenericElementType.class.getName());
	
	String genericElementParameterPattern = genericElementPattern + "/"
		+ JRXmlConstants.ELEMENT_genericElementParameter;
	digester.addFactoryCreate(genericElementParameterPattern, 
			JRGenericElementParameterFactory.class);
	digester.addSetNext(genericElementParameterPattern, "addParameter", 
			JRGenericElementParameter.class.getName());
	
	String genericElementParameterExpressionPattern = genericElementParameterPattern + "/"
		+ JRXmlConstants.ELEMENT_genericElementParameter_valueExpression;
	@SuppressWarnings("deprecation")
	Class<?> depArbitraryExprFactory = JRExpressionFactory.ArbitraryExpressionFactory.class;
	digester.addFactoryCreate(genericElementParameterExpressionPattern, depArbitraryExprFactory);
	digester.addSetNext(genericElementParameterExpressionPattern, 
			"setValueExpression", JRExpression.class.getName());
	digester.addCallMethod(genericElementParameterExpressionPattern, "setText", 0);
}
 

import net.sf.jasperreports.engine.JRExpression; //导入依赖的package包/类
/**
 *
 */
public void setPrintWhenExpression(JRExpression expression)
{
	Object old = this.printWhenExpression;
	this.printWhenExpression = expression;
	getEventSupport().firePropertyChange(PROPERTY_PRINT_WHEN_EXPRESSION, old, this.printWhenExpression);
}
 

import net.sf.jasperreports.engine.JRExpression; //导入依赖的package包/类
/**
 *
 */
public void setExpression(JRExpression expression)
{
	Object old = this.expression;
	this.expression = expression;
	getEventSupport().firePropertyChange(PROPERTY_EXPRESSION, old, this.expression);
}
 

import net.sf.jasperreports.engine.JRExpression; //导入依赖的package包/类
@Override
public Object evaluate(JRExpression expression, byte evaluationType) throws JRException
{
	if (evaluationType != JRExpression.EVALUATION_DEFAULT)
	{
		throw 
			new JRException(
				EXCEPTION_MESSAGE_KEY_EVALUATION_TYPE_NOT_SUPPORTED,  
				(Object[])null
				);
	}
	return evaluator.evaluate(expression);
}
 

import net.sf.jasperreports.engine.JRExpression; //导入依赖的package包/类
protected Object evaluateBucketValue(JRCalculator calculator,
		DataAxisLevel level) throws JRExpressionEvalException
{
	DataLevelBucket bucket = level.getBucket();
	Object mainValue = calculator.evaluate(bucket.getExpression());
	
	JRExpression labelExpression = bucket.getLabelExpression();
	List<DataLevelBucketProperty> bucketProperties = bucket.getBucketProperties();
	Object bucketValue;
	if (labelExpression == null && (bucketProperties == null || bucketProperties.isEmpty()))
	{
		bucketValue = mainValue;
	}
	else
	{
		String label = labelExpression == null ? null : (String) calculator.evaluate(labelExpression);
		
		Object[] propertyValues;
		if (bucketProperties == null || bucketProperties.isEmpty())
		{
			propertyValues = null;
		}
		else
		{
			// evaluate property values
			//FIXME avoid evaluating these for each record
			propertyValues = new Object[bucketProperties.size()];
			for (ListIterator<DataLevelBucketProperty> it = bucketProperties.listIterator(); it.hasNext();)
			{
				DataLevelBucketProperty bucketProperty = it.next();
				propertyValues[it.previousIndex()] = calculator.evaluate(bucketProperty.getExpression());
			}
		}
		
		// wrap the main value and property values together
		bucketValue = new ValuePropertiesWrapper(mainValue, label, propertyValues);
	}
	
	return bucketValue;
}
 

import net.sf.jasperreports.engine.JRExpression; //导入依赖的package包/类
/**
 * Sets the parameter values from the values map.
 * 
 * @param parameterValues the values map
 * @throws JRException
 */
private void evaluateParameterValues(ParameterEvaluationTimeEnum evaluationTime, Map<String,Object> parameterValues) throws JRException
{
	if (parameters != null && parameters.length > 0)
	{
		ParameterEvaluationTimeEnum defaultEvaluationTime = getDefaultParameterEvaluationTime();
		for (int i = 0; i < parameters.length; i++)
		{
			JRFillParameter parameter = parameters[i];
			String paramName = parameter.getName();
			ParameterEvaluationTimeEnum paramEvalTime = parameter.getEvaluationTime() == null ? defaultEvaluationTime : parameter.getEvaluationTime();
			
			if (
				!parameterValues.containsKey(paramName) //cheaper to test this first
				&& !parameter.isSystemDefined() //cheaper to test this first
				&& evaluationTime == paramEvalTime
				&& (!isIncludedInDataCache(parameter) || cachedDataset == null)
				)
			{
				Object value = calculator.evaluate(parameter.getDefaultValueExpression(), JRExpression.EVALUATION_DEFAULT);
				if (value != null)
				{
					parameterValues.put(paramName, value);
				}
				setParameter(parameter, value);
			}
		}
	}
}
 

import net.sf.jasperreports.engine.JRExpression; //导入依赖的package包/类
/**
 *
 */
public void setAnchorNameExpression(JRExpression anchorNameExpression)
{
	Object old = this.anchorNameExpression;
	this.anchorNameExpression = anchorNameExpression;
	getEventSupport().firePropertyChange(PROPERTY_ANCHOR_NAME_EXPRESSION, old, this.anchorNameExpression);
}