public void setExcludeMethods(String excludeMethods) { this.excludeMethods = TextParseUtil.commaDelimitedStringToSet(excludeMethods); }
/** * Converted object from variable translation. * * @param open * @param expression * @param stack * @param asType * @return Converted object from variable translation. */ public static Object translateVariables(char open, String expression, ValueStack stack, Class asType) { return translateVariables(open, expression, stack, asType, null); }
/** * @see #translateVariablesCollection(char[], String, ValueStack, boolean, ParsedValueEvaluator, int) * * @param expression * @param stack * @param excludeEmptyElements * @param evaluator * @return */ public static Collection<String> translateVariablesCollection(String expression, ValueStack stack, boolean excludeEmptyElements, ParsedValueEvaluator evaluator) { return translateVariablesCollection(new char[]{'$', '%'}, expression, stack, excludeEmptyElements, evaluator, MAX_RECURSION); }
private boolean isInChainHistory(String namespace, String actionName, String methodName) { LinkedList<? extends String> chainHistory = ActionChainResult.getChainHistory(); if (chainHistory == null) { return false; } else { // Actions to skip Set<String> skipActionsList = new HashSet<String>(); if (skipActions != null && skipActions.length() > 0) { ValueStack stack = ActionContext.getContext().getValueStack(); String finalSkipActions = TextParseUtil.translateVariables(this.skipActions, stack); skipActionsList.addAll(TextParseUtil.commaDelimitedStringToSet(finalSkipActions)); } if (!skipActionsList.contains(actionName)) { // Get if key is in the chain history return chainHistory.contains(makeKey(namespace, actionName, methodName)); } return false; } }
if (shallBeIncluded(stringElement, excludeEmptyElements)) { if (evaluator != null) { stringElement = evaluator.evaluate(stringElement).toString(); String resultStr = translateVariables(expression, stack, evaluator); if (shallBeIncluded(resultStr, excludeEmptyElements)) { resultCol.add(resultStr);
/** * Allows <code>paramValues</code> attribute to be set as a comma-separated-values (csv). * * @param paramValues the paramValues to set */ public void setParamValues(String paramValues) { this.paramValues = TextParseUtil.commaDelimitedStringToSet(paramValues); } }
/** * Parse <code>expression</code> passed in against value stack. * * @param expression an OGNL expression * @param type type to return * @return Object */ protected Object parse(String expression, Class type) { if (expression == null) { return null; } return TextParseUtil.translateVariables('$', expression, stack, type); }
/** * Allows <code>paramNames</code> attribute to be set as comma-separated-values (csv). * * @param paramNames the paramNames to set */ public void setParamNames(String paramNames) { this.paramNames = TextParseUtil.commaDelimitedStringToSet(paramNames); }
/** * Converted object from variable translation. * * @param open * @param expression * @param stack * @param asType * @param evaluator * @return Converted object from variable translation. */ public static Object translateVariables(char open, String expression, ValueStack stack, Class asType, ParsedValueEvaluator evaluator) { return translateVariables(new char[]{open} , expression, stack, asType, evaluator, MAX_RECURSION); }
public void setIncludeMethods(String includeMethods) { this.includeMethods = TextParseUtil.commaDelimitedStringToSet(includeMethods); }
/** * Converted object from variable translation. * * @param open * @param expression * @param stack * @param asType * @param evaluator * @return Converted object from variable translation. */ public static Object translateVariables(char open, String expression, ValueStack stack, Class asType, ParsedValueEvaluator evaluator, int maxLoopCount) { return translateVariables(new char[]{open}, expression, stack, asType, evaluator, maxLoopCount); }
public void setIncludeParameters(String parametersToInclude) { this.includes = TextParseUtil.commaDelimitedStringToSet(parametersToInclude); }
/** * Converted object from variable translation. * * @param open * @param expression * @param stack * @param asType * @param evaluator * @return Converted object from variable translation. */ public static Object translateVariables(char[] openChars, String expression, ValueStack stack, Class asType, ParsedValueEvaluator evaluator) { return translateVariables(openChars, expression, stack, asType, evaluator, MAX_RECURSION); }
private Set<String> parseExcludedPackageNames(String commaDelimitedPackageNames) { return TextParseUtil.commaDelimitedStringToSet(commaDelimitedPackageNames); }
/** * Converts all instances of ${...}, and %{...} in <code>expression</code> to the value returned * by a call to {@link ValueStack#findValue(java.lang.String)}. If an item cannot * be found on the stack (null is returned), then the entire variable ${...} is not * displayed, just as if the item was on the stack but returned an empty string. * * @param expression an expression that hasn't yet been translated * @return the parsed expression */ public static String translateVariables(String expression, ValueStack stack) { return translateVariables(new char[]{'$', '%'}, expression, stack, String.class, null).toString(); }
public void setExcludeParameters(String parametersToExclude) { this.excludes = TextParseUtil.commaDelimitedStringToSet(parametersToExclude); }
/** * Converts all instances of ${...} in <code>expression</code> to the value returned * by a call to {@link ValueStack#findValue(java.lang.String)}. If an item cannot * be found on the stack (null is returned), then the entire variable ${...} is not * displayed, just as if the item was on the stack but returned an empty string. * * @param open * @param expression * @param stack * @return Translated variable String */ public static String translateVariables(char open, String expression, ValueStack stack) { return translateVariables(open, expression, stack, String.class, null).toString(); }
public void setExcludeMethods(String excludeMethods) { this.excludeMethods = TextParseUtil.commaDelimitedStringToSet(excludeMethods); }
/** * Function similarly as {@link #translateVariables(char, String, ValueStack)} * except for the introduction of an additional <code>evaluator</code> that allows * the parsed value to be evaluated by the <code>evaluator</code>. The <code>evaluator</code> * could be null, if it is it will just be skipped as if it is just calling * {@link #translateVariables(char, String, ValueStack)}. * * <p/> * * A typical use-case would be when we need to URL Encode the parsed value. To do so * we could just supply a URLEncodingEvaluator for example. * * @param expression * @param stack * @param evaluator The parsed Value evaluator (could be null). * @return the parsed (and possibly evaluated) variable String. */ public static String translateVariables(String expression, ValueStack stack, ParsedValueEvaluator evaluator) { return translateVariables(new char[]{'$', '%'}, expression, stack, String.class, evaluator).toString(); }
protected Set<String> getTilesDefinitions(Map<String, String> params) { if (params.containsKey(DefinitionsFactory.DEFINITIONS_CONFIG)) { return TextParseUtil.commaDelimitedStringToSet(params.get(DefinitionsFactory.DEFINITIONS_CONFIG)); } return TextParseUtil.commaDelimitedStringToSet(TILES_DEFAULT_PATTERN); }