util.java

一个java写的business process management系统

/*
 * Copyright (c) 2003, Alexander Greif
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 * 
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the Flow4J-Eclipse project nor the names of its
 *       contributors may be used to endorse or promote products derived from
 *       this software without specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

package net.orthanc.flow4j.base;

import java.util.Enumeration;
import java.util.Map;
import java.util.Vector;

import net.orthanc.flow4j.Flow4JException;

/**
 * @author agreif
 *
 * TODO
 * 
 * To change the template for this generated type comment go to
 * Window>Preferences>Java>Code Generation>Code and Comments
 */
public class Util {



	/**
	 * Returns the index of the object in the array.
	 * If the array does not contain the object, then -1 is returned
	 * @param array the array in which the test is done
	 * @param obj the object to test for existence
	 * @return the objects index if the array contains the object, -1 otherwise
	 */
	public static int getIndexInArray(Object obj, Object[] array) {
		for (int i = 0; i < array.length; i++)
			if (obj == array[i])
				return i;
		return -1;
	}



	public final static String escapeXml(String s) {
		if (s == null)
			return "";
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < s.length(); i++) {
			char c = s.charAt(i);
			if (c == '<') {
				sb.append("&lt;");
			} else if (c == '>') {
				sb.append("&gt;");
			} else if (c == '\'') {
				sb.append("&apos;");
			} else if (c == '&') {
				sb.append("&amp;");
			} else if (c == '"') {
				sb.append("&quot;");
			} else {
				sb.append(c);
			}
		}
		return sb.toString();
	}







	/**
	 * Replaces <code>${xxx}</code> style constructions in the given value 
	 * with the string value of the corresponding data types.
	 *
	 * @param value The string to be scanned for property references.
	 *              May be <code>null</code>, in which case this
	 *              method returns immediately with no effect.
	 * @param keys  Mapping (String to String) of property names to their 
	 *              values. Must not be <code>null</code>.
	 * 
	 * @exception Flow4JException if the string contains an opening 
	 *                           <code>${</code> without a closing 
	 *                           <code>}</code>
	 * @return the original string with the properties replaced, or
	 *         <code>null</code> if the original string is <code>null</code>.
	 */
	 public static String replaceProperties(String value, Map keys) throws Flow4JException {
		if (value == null)
			return null;

		if (keys == null  || keys.isEmpty())
			return value;

		Vector fragments = new Vector();
		Vector propertyRefs = new Vector();
		parsePropertyString(value, fragments, propertyRefs);

		StringBuffer sb = new StringBuffer();
		Enumeration i = fragments.elements();
		Enumeration j = propertyRefs.elements();
		while (i.hasMoreElements()) {
			String fragment = (String) i.nextElement();
			if (fragment == null) {
				String propertyName = (String) j.nextElement();
				fragment = (keys.containsKey(propertyName)) 
					? (String) keys.get(propertyName) 
					: "${" + propertyName + "}"; 
			}
			sb.append(fragment);
		}                        
        
		return sb.toString();
	}

	/**
	 * Parses a string containing <code>${xxx}</code> style property
	 * references into two lists. The first list is a collection
	 * of text fragments, while the other is a set of string property names.
	 * <code>null</code> entries in the first list indicate a property 
	 * reference from the second list.
	 * 
	 * @param value     Text to parse. Must not be <code>null</code>.
	 * @param fragments List to add text fragments to. 
	 *                  Must not be <code>null</code>.
	 * @param propertyRefs List to add property names to.
	 *                     Must not be <code>null</code>.
	 * 
	 * @exception BuildException if the string contains an opening 
	 *                           <code>${</code> without a closing 
	 *                           <code>}</code>
	 */
	public static void parsePropertyString(String value, Vector fragments, 
										   Vector propertyRefs)
		throws Flow4JException {
		int prev = 0;
		int pos;
		//search for the next instance of $ from the 'prev' position
		while ((pos = value.indexOf("$", prev)) >= 0) {

			//if there was any text before this, add it as a fragment
			//TODO, this check could be modified to go if pos>prev;
			//seems like this current version could stick empty strings
			//into the list
			if (pos > 0) {
				fragments.addElement(value.substring(prev, pos));
			}
			//if we are at the end of the string, we tack on a $
			//then move past it
			if (pos == (value.length() - 1)) {
				fragments.addElement("$");
				prev = pos + 1;
			} else if (value.charAt(pos + 1) != '{') {
				//peek ahead to see if the next char is a property or not
				//not a property: insert the char as a literal
				/*
				fragments.addElement(value.substring(pos + 1, pos + 2));
				prev = pos + 2;
				*/
				if (value.charAt(pos + 1) == '$') {
					//backwards compatibility two $ map to one mode
					fragments.addElement("$");
					prev = pos + 2;
				} else {
					//new behaviour: $X maps to $X for all values of X!='$'
					fragments.addElement(value.substring(pos, pos + 2));
					prev = pos + 2;
				}
                
			} else {
				//property found, extract its name or bail on a typo
				int endName = value.indexOf('}', pos);
				if (endName < 0) {
					throw new Flow4JException("Syntax error in property: "
												 + value);
				}
				String propertyName = value.substring(pos + 2, endName);
				fragments.addElement(null);
				propertyRefs.addElement(propertyName);
				prev = endName + 1;
			}
		}
		//no more $ signs found
		//if there is any tail to the file, append it
		if (prev < value.length()) {
			fragments.addElement(value.substring(prev));
		}
	}



}