Java BooleanValidatingExpression类代码示例

import org.kuali.rice.krms.framework.engine.expression.BooleanValidatingExpression; //导入依赖的package包/类
/**
 * Translates the parameters on the given proposition definition to create an expression for evaluation.
 * The proposition parameters are defined in a reverse-polish notation so a stack is used for
 * evaluation purposes.
 * 
 * @param propositionDefinition the proposition definition to translate
 * 
 * @return the translated expression for the given proposition, this
 * expression, when evaluated, will return a Boolean.
 */
protected Expression<Boolean> translateToExpression(PropositionDefinition propositionDefinition) {
	LinkedList<Expression<? extends Object>> stack = new LinkedList<Expression<? extends Object>>();
	for (PropositionParameter parameter : propositionDefinition.getParameters()) {
		PropositionParameterType parameterType = PropositionParameterType.fromCode(parameter.getParameterType());
		if (parameterType == PropositionParameterType.CONSTANT) {
			// TODO - need some way to define data type on the prop parameter as well?  Not all constants will actually be String values!!!
			stack.addFirst(new ConstantExpression<String>(parameter.getValue()));
		} else if (parameterType == PropositionParameterType.FUNCTION) {
			String functionId = parameter.getValue();
			FunctionDefinition functionDefinition = functionRepositoryService.getFunction(functionId);
			if (functionDefinition == null) {
				throw new RepositoryDataException("Unable to locate function with the given id: " + functionId);
			}
			FunctionTypeService functionTypeService = typeResolver.getFunctionTypeService(functionDefinition);
			Function function = functionTypeService.loadFunction(functionDefinition);
			// TODO throw an exception if function is null?
			List<FunctionParameterDefinition> parameters = functionDefinition.getParameters();
			if (stack.size() < parameters.size()) {
				throw new RepositoryDataException("Failed to initialize custom function '" + functionDefinition.getNamespace() + " " + functionDefinition.getName() +
						"'.  There were only " + stack.size() + " values on the stack but function requires at least " + parameters.size());
			}
			List<Expression<? extends Object>> arguments = new ArrayList<Expression<? extends Object>>();
			// work backward through the list to match params to the stack
			for (int index = parameters.size() - 1; index >= 0; index--) {
				FunctionParameterDefinition parameterDefinition = parameters.get(index);
				// TODO need to check types here? expression object probably needs a getType on it so that we can confirm that the types will be compatible?
                   parameterDefinition.getParameterType();
				Expression<? extends Object> argument = stack.removeFirst();
				arguments.add(argument);
			}

               String[] parameterTypes = getFunctionParameterTypes(functionDefinition);
			stack.addFirst(new FunctionExpression(function, parameterTypes, arguments, getComparisonOperatorService()));

		} else if (parameterType == PropositionParameterType.OPERATOR) {
			ComparisonOperator operator = ComparisonOperator.fromCode(parameter.getValue());
			if (stack.size() < 2) {
				throw new RepositoryDataException("Failed to initialize expression for comparison operator " +
                           operator + " because a sufficient number of arguments was not available on the stack.  "
                           + "Current contents of stack: " + stack.toString());
			}
			Expression<? extends Object> rhs = stack.removeFirst();
			Expression<? extends Object> lhs = stack.removeFirst();
			stack.addFirst(new BinaryOperatorExpression(operator, lhs, rhs));
		} else if (parameterType == PropositionParameterType.TERM) {
			String termId = parameter.getValue();

			TermDefinition termDefinition = getTermRepositoryService().getTerm(termId);
			if (termDefinition == null) { throw new RepositoryDataException("unable to load term with id " + termId);}
			Term term = translateTermDefinition(termDefinition);
			
			stack.addFirst(new TermExpression(term));
		}
	}
	if (stack.size() != 1) {
		throw new RepositoryDataException("Final contents of expression stack are incorrect, there should only be one entry but was " + stack.size() +".  Current contents of stack: " + stack.toString());
	}
	return new BooleanValidatingExpression(stack.removeFirst());
}