Pattern.java

/*
 * Copyright 2006 Robert Hanson <iamroberthanson AT gmail.com>
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *    http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.daxplore.presenter.chart;

import java.util.ArrayList;
import java.util.List;

import com.google.gwt.core.client.JavaScriptObject;

/**
 * <p> Implementation of the {@link java.util.regex.Pattern} class with a
 * wrapper aroung the Javascript <a href=
 * "http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Guide:Regular_Expressions"
 * >RegExp</a> object. As most of the methods delegate to the JavaScript RegExp
 * object, certain differences in the declaration and behaviour of regular
 * expressions must be expected. </p> <p> Please note that neither the
 * {@link java.util.regex.Pattern#compile(String)} method nor {@link Matcher}
 * instances are supported. For the later, consider using
 * {@link Pattern#match(String)}. </p>
 * 
 * @author George Georgovassilis
 * 
 */
public class Pattern {

	/**
	 * Declares that regular expressions should be matched across line borders.
	 */
	public final static int MULTILINE = 1;

	/**
	 * Declares that characters are matched reglardless of case.
	 */
	public final static int CASE_INSENSITIVE = 2;

	private JavaScriptObject regExp;

	private static JavaScriptObject createExpression(String pattern, int flags) {
		String sFlags = "";
		if ((flags & MULTILINE) != 0) {
			sFlags += "m";
		}
		if ((flags & CASE_INSENSITIVE) != 0) {
			sFlags += "i";
		}
		return _createExpression(pattern, sFlags);
	}

	private static native JavaScriptObject _createExpression(String pattern, String flags)/*-{
		return new RegExp(pattern, flags);
	}-*/;

	private native void _match(String text, List<?> matches)/*-{
		var regExp = this.@org.daxplore.presenter.chart.Pattern::regExp;
		var result = text.match(regExp);
		if (result == null)
			return;
		for ( var i = 0; i < result.length; i++)
			matches.@java.util.ArrayList::add(Ljava/lang/Object;)(result[i]);
	}-*/;

	/**
	 * Determines wether the specified regular expression is validated by the
	 * provided input.
	 * 
	 * @param regex
	 *            Regular expression
	 * @param input
	 *            String to validate
	 * @return <code>true</code> if matched.
	 */
	public static boolean matches(String regex, String input) {
		return new Pattern(regex).matches(input);
	}

	/**
	 * Escape a provided string so that it will be interpreted as a literal in
	 * regular expressions. The current implementation does escape each
	 * character even if not neccessary, generating verbose literals.
	 * 
	 * @param input
	 * @return
	 */
	public static String quote(String input) {
		StringBuilder output = new StringBuilder("");
		for (int i = 0; i < input.length(); i++) {
			output.append("\\").append(input.charAt(i));
		}
		return output.toString();
	}

	/**
	 * Construct a new pattern to match against.
	 * 
	 * @param pattern
	 *            Regular expression
	 */
	public Pattern(String pattern) {
		this(pattern, 0);
	}

	/**
	 * Construct a new pattern to match against.
	 * 
	 * @param pattern
	 *            Regular expression
	 * @param flags
	 */
	public Pattern(String pattern, int flags) {
		regExp = createExpression(pattern, flags);
	}

	/**
	 * This method is borrowed from the JavaScript RegExp object. It parses a
	 * string and returns as an array any assignments to parenthesis groups in
	 * the pattern's regular expression
	 * 
	 * @param text
	 * @return Array of strings following java's Pattern convention for groups:
	 *         Group 0 is the entire input string and the remaining groups are
	 *         the matched parenthesis. In case nothing was matched an empty
	 *         array is returned.
	 */
	public String[] match(String text) {
		List<?> matches = new ArrayList<>();
		_match(text, matches);
		String arr[] = new String[matches.size()];
		for (int i = 0; i < matches.size(); i++) {
			arr[i] = matches.get(i).toString();
		}
		return arr;
	}

	/**
	 * Determines wether a provided text matches the regular expression.
	 * 
	 * @param text
	 * @return
	 */
	public native boolean matches(String text)/*-{
		var regExp = this.@org.daxplore.presenter.chart.Pattern::regExp;
		return regExp.test(text);
	}-*/;

	/**
	 * Returns the regular expression for this pattern.
	 * 
	 * @return
	 */
	public native String pattern()/*-{
		var regExp = this.@org.daxplore.presenter.chart.Pattern::regExp;
		return regExp.source;
	}-*/;

	private native void _split(String input, List<?> results)/*-{
		var regExp = this.@org.daxplore.presenter.chart.Pattern::regExp;
		var parts = input.split(regExp);
		for ( var i = 0; i < parts.length; i++)
			results.@java.util.ArrayList::add(Ljava/lang/Object;)(parts[i]  );
	}-*/;

	/**
	 * Split an input string by the pattern's regular expression.
	 * 
	 * @param input
	 * @return Array of strings
	 */
	public String[] split(String input) {
		List<?> results = new ArrayList<>();
		_split(input, results);
		String[] parts = new String[results.size()];
		for (int i = 0; i < results.size(); i++) {
			parts[i] = (String) results.get(i);
		}
		return parts;
	}

}