com.opensymphony.xwork2.util.TextParseUtil Maven / Gradle / Ivy

Go to download
/*
 * Copyright (c) 2002-2006 by OpenSymphony
 * All rights reserved.
 */
package com.opensymphony.xwork2.util;

import com.opensymphony.xwork2.util.TextUtils;

import java.util.HashSet;
import java.util.Set;


/**
 * Utility class for text parsing.
 *
 * @author Jason Carreira
 * @author Rainer Hermanns
 * @author tm_jee
 * 
 * @version $Date: 2006-11-23 21:33:15 +0100 (Do, 23 Nov 2006) $ $Id: TextParseUtil.java 1223 2006-11-23 20:33:15Z rainerh $
 */
public class TextParseUtil {

    /**
     * Converts all instances of ${...} in expression 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('$', expression, stack, String.class, null).toString();
    }
    
    
    /**
     * Function similarly as {@link #translateVariables(char, String, ValueStack)} 
     * except for the introduction of an additional evaluator that allows
     * the parsed value to be evaluated by the evaluator. The evaluator
     * could be null, if it is it will just be skipped as if it is just calling 
     * {@link #translateVariables(char, String, ValueStack)}.
     * 
     * 
     * 
     * 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('$', expression, stack, String.class, evaluator).toString();
    }

    /**
     * Converts all instances of ${...} in expression 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();
    }

    /**
     * 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);
    }
    
    /**
     * 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) {
        // deal with the "pure" expressions first!
        //expression = expression.trim();
        Object result = expression;

        while (true) {
            int start = expression.indexOf(open + "{");
            int length = expression.length();
            int x = start + 2;
            int end;
            char c;
            int count = 1;
            while (start != -1 && x < length && count != 0) {
                c = expression.charAt(x++);
                if (c == '{') {
                    count++;
                } else if (c == '}') {
                    count--;
                }
            }
            end = x - 1;

            if ((start != -1) && (end != -1) && (count == 0)) {
                String var = expression.substring(start + 2, end);

                Object o = stack.findValue(var, asType);
                if (evaluator != null) {
                	o = evaluator.evaluate(o);
                }
                

                String left = expression.substring(0, start);
                String right = expression.substring(end + 1);
                if (o != null) {
                    if (TextUtils.stringSet(left)) {
                        result = left + o;
                    } else {
                        result = o;
                    }

                    if (TextUtils.stringSet(right)) {
                        result = result + right;
                    }

                    expression = left + o + right;
                } else {
                    // the variable doesn't exist, so don't display anything
                    result = left + right;
                    expression = left + right;
                }
            } else {
                break;
            }
        }

        return XWorkConverter.getInstance().convertValue(stack.getContext(), result, asType);
    }

    /**
     * Returns a set from comma delimted Strings.
     * @param s The String to parse.
     * @return A set from comma delimted Strings.
     */
    public static Set commaDelimitedStringToSet(String s) {
        Set set = new HashSet();
        String[] split = s.split(",");
        for (int i = 0; i < split.length; i++) {
            String trimmed = split[i].trim();
            if (trimmed.length() > 0)
                set.add(trimmed);
        }
        return set;
    }
    
    
    /**
     * A parsed value evaluator for {@link TextParseUtil}. It could be supplied by 
     * calling {@link TextParseUtil#translateVariables(char, String, ValueStack, Class, ParsedValueEvaluator)}.
     * 
     * 

     * 
     * By supplying this ParsedValueEvaluator, the parsed value
     * (parsed against the value stack) value will be
     * given to ParsedValueEvaluator to be evaluated before the 
     * translateVariable process goes on. 
     * 
     * 
     * 
     * A typical use-case would be to have a custom ParseValueEvaluator
     * to URL Encode the parsed value.
     * 
     * @author tm_jee
     * 
     * @version $Date: 2006-11-23 21:33:15 +0100 (Do, 23 Nov 2006) $ $Id: TextParseUtil.java 1223 2006-11-23 20:33:15Z rainerh $
     */
    public static interface ParsedValueEvaluator {
    	
    	/**
    	 * Evaluated the value parsed by Ognl value stack.
    	 * 
    	 * @param parsedValue - value parsed by ognl value stack
    	 * @return return the evaluted value.
    	 */
    	Object evaluate(Object parsedValue);
    }
}