PropertyParser.java

Violations

Source code

/*
 * hgcommons 9
 * Hammurapi Group Common Library
 * Copyright (C) 2003  Hammurapi Group
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * URL: http://www.hammurapi.biz/hammurapi-biz/ef/xmenu/hammurapi-group/products/products/hgcommons/index.html
 * e-Mail: support@hammurapi.biz
 */
package biz.hammurapi.config;

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

/**
 * Expands property value entries like ${myProperty} to property values.
 * Nested properties are supportd, i.e. if myProperty value contains ${someOtherPropery}
 * then it will also be expanded. ${ escaping is not supported.
 * @author Pavel Vlasov
 * @version $Revision: 1.3 $
 */
public class PropertyParser {
    public static final String TOKEN_CLOSING_CHAR = "}";
	public static final String TOKEN_SECOND_OPENING_CHAR = "{";
	public static final String TOKEN_FIRST_OPENING_CHAR = "$";
	
    private String tokenClosingChar = TOKEN_CLOSING_CHAR;
	private String tokenSecondOpeningChar = TOKEN_SECOND_OPENING_CHAR;
	private String tokenFirstOpeningChar = TOKEN_FIRST_OPENING_CHAR;
	
	private Context context;
    private boolean useNameAsDefault;    
    
    /**
     * Creates a new instance of PropertyParser with system
     * properties.
     * @param useNameAsDefault If true then property name will be used
     * as property default value.
     */
    public PropertyParser(boolean useNameAsDefault) {
        context=new Context() {
			public Object get(String name) {
				return System.getProperty(name);
			}        	
        };
        
        this.useNameAsDefault=useNameAsDefault;
    }
    
    /**
     * Creates a new instance of PropertyParser
     * @param properties Properties
     * @param useNameAsDefault If true then property name will be used
     * as property default value.
     */
    public PropertyParser(Context context, boolean useNameAsDefault) {
        if (context==null) {
        	throw new NullPointerException("Context is null");
        }
        this.context=context;
        this.useNameAsDefault=useNameAsDefault;
    }    
    
    /**
     * Creates a new instance of PropertyParser with system
     * properties.
     * @param useNameAsDefault If true then property name will be used
     * as property default value.
     */
    public PropertyParser(boolean useNameAsDefault, char tokenFirstOpeningChar, char tokenSecondOpeningChar, char tokenClosingChar) {
        context=new Context() {
			public Object get(String name) {
				return System.getProperty(name);
			}        	
        };
        
        this.useNameAsDefault=useNameAsDefault;
        this.tokenClosingChar=String.valueOf(tokenClosingChar);
        this.tokenFirstOpeningChar=String.valueOf(tokenFirstOpeningChar);
        this.tokenSecondOpeningChar=String.valueOf(tokenSecondOpeningChar);
    }
    
    /**
     * Creates a new instance of PropertyParser
     * @param properties Properties
     * @param useNameAsDefault If true then property name will be used
     * as property default value.
     */
    public PropertyParser(Context context, boolean useNameAsDefault, char tokenFirstOpeningChar, char tokenSecondOpeningChar, char tokenClosingChar) {
        if (context==null) {
        	throw new NullPointerException("Context is null");
        }
        this.context=context;
        this.useNameAsDefault=useNameAsDefault;
        this.tokenClosingChar=String.valueOf(tokenClosingChar);
        this.tokenFirstOpeningChar=String.valueOf(tokenFirstOpeningChar);
        this.tokenSecondOpeningChar=String.valueOf(tokenSecondOpeningChar);
    }    
    
    
    /**
     * Property parsing.
     * Replaces string ${<property name>} with property value.
     * If property value contains ${<other property name>} it
     * will be parsed.
     */
    public String getParsedProperty(String key) {
        return getParsedProperty(key, new HashSet());
    }
    
    /**
     * Parses a string by replacing occurences of ${<property name>}
     * with property values.
     * If property value contains ${<other property name>} it
     * will be parsed.
     */
    public String parse(String str) {
        return parse(str, null);
    }
    
    private String getParsedProperty(String key, Set stack) {
    	Object o=context.get(key);
        String pr;        
        if (o==null) {
        	if (useNameAsDefault) {
        		pr=key;
        	} else {
        		return null;
        	}
        } else {
        	pr=o.toString();
        }
        
        if (stack.contains(key)) {
        	throw new RuntimeConfigurationException("Circular reference in property substitution, property: "+key);
        }
        
        stack.add(key);
        
        return parse(pr, stack);
    }
    
    private String parse(String str, Set stack) {
        if (str==null) {
        	return null;
        }
        
        StringTokenizer st=new StringTokenizer(str,tokenFirstOpeningChar+tokenSecondOpeningChar+tokenClosingChar,true);
        
        StringBuffer ret=new StringBuffer();
        /**
         * Parser state:
         * 0: Text
         * 1: $
         * 2: ${
         */
        int state=0;
        
        String propName=null;
        while (st.hasMoreTokens()) {
            String tkn=st.nextToken();
            switch (state) {
                case 0:
                    if (tokenFirstOpeningChar.equals(tkn))
                        state=1;
                    else
                        ret.append(tkn);
                    break;
                case 1:
                    if (tokenSecondOpeningChar.equals(tkn))
                        state=2;
                    else {
                        state=0;
                        ret.append(tokenFirstOpeningChar);
                        ret.append(tkn);
                    }
                    break;
                case 2:
                    if (tokenClosingChar.equals(tkn)) {
                        String propVal=getParsedProperty(propName, stack==null ? new HashSet() : stack);
                        ret.append(propVal==null ? tokenFirstOpeningChar+tokenSecondOpeningChar+propName+tokenClosingChar : propVal);
                        propName=null;
                        state=0;
                    } else {
                        if (propName==null)
                            propName=tkn;
                        else
                            propName+=tkn;
                    }
                    break;
                default:
                    throw new IllegalStateException("Illegal parser state: "+state);
            }
        }
        
        if (state==2)
            ret.append(tokenFirstOpeningChar+tokenSecondOpeningChar+propName);
        
        return ret.toString();
    }        
}