public AssignationSequence parseAssignationSequence( final IExpressionContext context, final String input, final boolean allowParametersWithoutValue) { Validate.notNull(context, "Context cannot be null"); Validate.notNull(input, "Input cannot be null"); return AssignationUtils.parseAssignationSequence(context, input, allowParametersWithoutValue); }
final Assignation assignation = composeAssignation(state, nodeIndex, allowParametersWithoutValue); if (assignation == null) { return null; return composeSequence(state, pointer, allowParametersWithoutValue); for (int i = startIndex; i < endIndex; i++) { final Assignation assignation = composeAssignation(state, i, allowParametersWithoutValue); if (assignation == null) { return null;
AssignationUtils.internalParseAssignationSequence( parameters, true /* allow parameters without value or equals sign */); if (parametersAssigSeq == null) {
static AssignationSequence internalParseAssignationSequence(final String input, final boolean allowParametersWithoutValue) { if (StringUtils.isEmptyOrWhitespace(input)) { return null; } final ExpressionParsingState decomposition = ExpressionParsingUtil.decompose(input); if (decomposition == null) { return null; } return composeSequence(decomposition, 0, allowParametersWithoutValue); }
return composeAssignation(state, pointer, allowParametersWithoutValue);
static AssignationSequence internalParseAssignationSequence(final String input, final boolean allowParametersWithoutValue) { if (StringUtils.isEmptyOrWhitespace(input)) { return null; } final ExpressionParsingState decomposition = ExpressionParsingUtil.decompose(input,ExpressionParsingDecompositionConfig.DECOMPOSE_ALL_AND_UNNEST); if (decomposition == null) { return null; } return composeSequence(decomposition, 0, allowParametersWithoutValue); }
return composeAssignation(state, pointer, allowParametersWithoutValue);
AssignationUtils.parseAssignationSequence( context, attributeValue, false /* no parameters without value */); if (assignations == null) {
final Assignation assignation = composeAssignation(state, nodeIndex, allowParametersWithoutValue); if (assignation == null) { return null; return composeSequence(state, pointer, allowParametersWithoutValue); for (int i = startIndex; i < endIndex; i++) { final Assignation assignation = composeAssignation(state, i, allowParametersWithoutValue); if (assignation == null) { return null;
AssignationUtils.internalParseAssignationSequence(parametersStr, false);
AssignationUtils.parseAssignationSequence( context, attributeValue, false /* no parameters without value */); if (assignations == null) {
public static AssignationSequence parseAssignationSequence( final IExpressionContext context, final String input, final boolean allowParametersWithoutValue) { Validate.notNull(context, "Context cannot be null"); Validate.notNull(input, "Input cannot be null"); final String preprocessedInput = StandardExpressionPreprocessor.preprocess(context, input); final IEngineConfiguration configuration = context.getConfiguration(); if (configuration != null) { final AssignationSequence cachedAssignationSequence = ExpressionCache.getAssignationSequenceFromCache(configuration, preprocessedInput); if (cachedAssignationSequence != null) { return cachedAssignationSequence; } } final AssignationSequence assignationSequence = internalParseAssignationSequence(preprocessedInput.trim(), allowParametersWithoutValue); if (assignationSequence == null) { throw new TemplateProcessingException("Could not parse as assignation sequence: \"" + input + "\""); } if (configuration != null) { ExpressionCache.putAssignationSequenceIntoCache(configuration, preprocessedInput, assignationSequence); } return assignationSequence; }
/** * @since 2.0.9 */ public AssignationSequence parseAssignationSequence(final Configuration configuration, final IProcessingContext processingContext, final String input, final boolean allowParametersWithoutValue) { return AssignationUtils.parseAssignationSequence(configuration, processingContext, input, allowParametersWithoutValue); }
AssignationUtils.internalParseAssignationSequence( parameters, true /* allow parameters without value or equals sign */); if (parametersAssigSeq == null) {
/** * * @param configuration * configuration * @param processingContext * processingContext * @param input * input * @param allowParametersWithoutValue * allowParametersWithoutValue * @return the result * @since 2.0.9 */ public AssignationSequence parseAssignationSequence(final Configuration configuration, final IProcessingContext processingContext, final String input, final boolean allowParametersWithoutValue) { return AssignationUtils.parseAssignationSequence(configuration, processingContext, input, allowParametersWithoutValue); }
AssignationUtils.internalParseAssignationSequence(parametersStr, false);
/** * @since 2.0.9 * @deprecated the StandardExpressionProcessor class was deprecated in 2.1.0 for semantic and refactoring reasons. * Should use the equivalent {@link StandardExpressions} instead if you want to obtain * parser instances registered by the standard dialects, or instance your * parser instances using their constructors directly if you are building your own dialect * including these parserss. As for expression execution, this is no longer managed by executor * objects (also deprecated) but by the expressions themselves. Will be removed in 3.0. */ @Deprecated public static AssignationSequence parseAssignationSequence(final Configuration configuration, final IProcessingContext processingContext, final String input, final boolean allowParametersWithoutValue) { return AssignationUtils.parseAssignationSequence(configuration, processingContext, input, allowParametersWithoutValue); }
public static AssignationSequence parseAssignationSequence( final Configuration configuration, final IProcessingContext processingContext, final String input, final boolean allowParametersWithoutValue) { Validate.notNull(configuration, "Configuration cannot be null"); Validate.notNull(processingContext, "Processing Context cannot be null"); Validate.notNull(input, "Input cannot be null"); final String preprocessedInput = StandardExpressionPreprocessor.preprocess(configuration, processingContext, input); if (configuration != null) { final AssignationSequence cachedAssignationSequence = ExpressionCache.getAssignationSequenceFromCache(configuration, preprocessedInput); if (cachedAssignationSequence != null) { return cachedAssignationSequence; } } final AssignationSequence assignationSequence = internalParseAssignationSequence(preprocessedInput.trim(), allowParametersWithoutValue); if (assignationSequence == null) { throw new TemplateProcessingException("Could not parse as assignation sequence: \"" + input + "\""); } if (configuration != null) { ExpressionCache.putAssignationSequenceIntoCache(configuration, preprocessedInput, assignationSequence); } return assignationSequence; }
/** * @deprecated the StandardExpressionProcessor class was deprecated in 2.1.0 for semantic and refactoring reasons. * Should use the equivalent {@link StandardExpressions} instead if you want to obtain * parser instances registered by the standard dialects, or instance your * parser instances using their constructors directly if you are building your own dialect * including these parserss. As for expression execution, this is no longer managed by executor * objects (also deprecated) but by the expressions themselves. Will be removed in 3.0. */ @Deprecated public static AssignationSequence parseAssignationSequence(final Arguments arguments, final String input, final boolean allowParametersWithoutValue) { return AssignationUtils.parseAssignationSequence(arguments.getConfiguration(), arguments, input, allowParametersWithoutValue); }
AssignationUtils.parseAssignationSequence( configuration, arguments, attributeValue, false /* no parameters without value */); if (assignations == null) {