Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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.apache.wicket.util.parse.metapattern; import java.util.Arrays; import java.util.List; import java.util.regex.Matcher; import java.util.regex.Pattern; import org.apache.wicket.util.io.IClusterable; /** * Useful class for constructing readable and reusable regular expressions. * <p> * MetaPatterns can be constructed from a simple regular expression String, from other MetaPatterns * (copy constructor), from a list of MetaPatterns or from an array of MetaPatterns. In this way, it * is easy to build up larger patterns while transparently binding the capturing groups of each * MetaPattern for easy object oriented access to capturing group matches. * <p> * A given MetaPattern can be converted to a Matcher or Pattern. Groups within the MetaPattern can * be used to automatically reference capturing group values when a match is made with a Matcher * object. * <p> * A variety of static constants are provided for use in constructing compound MetaPatterns. Also, a * number of simple parsers have been constructed using MetaPatterns in the parsers subpackage. * * @author Jonathan Locke */ public class MetaPattern implements IClusterable { private static final long serialVersionUID = 1L; /** * Compiled regular expression pattern, or null if patterns variable is valid instead */ private Pattern pattern; /** List of patterns, or null if pattern variable is valid instead */ private List<MetaPattern> patterns; /** The compiled MetaPattern */ private Pattern compiledPattern; // Regexps that are used multiple times in defining meta patterns private static final String _DOUBLE_QUOTED_STRING = "\"[^\"]*?\""; private static final String _SINGLE_QUOTED_STRING = "'[^']*?\'"; private static final String _STRING = "(?:[\\w\\-\\.]+|" + _DOUBLE_QUOTED_STRING + "|" + _SINGLE_QUOTED_STRING + ")"; private static final String _OPTIONAL_STRING = _STRING + "?"; private static final String _VARIABLE_NAME = "[A-Za-z_][A-Za-z0-9_]*"; private static final String _XML_NAME = "[A-Za-z_][A-Za-z0-9_.-]*"; // Delimiters and punctuation /** Constant for whitespace. */ public static final MetaPattern WHITESPACE = new MetaPattern("\\s+"); /** Constant for optional whitespace. */ public static final MetaPattern OPTIONAL_WHITESPACE = new MetaPattern("\\s*"); /** Constant for non-word. */ public static final MetaPattern NON_WORD = new MetaPattern("\\W+"); /** Constant for comma. */ public static final MetaPattern COMMA = new MetaPattern(","); /** Constant for colon. */ public static final MetaPattern COLON = new MetaPattern(":"); /** Constant for semicolon. */ public static final MetaPattern SEMICOLON = new MetaPattern(";"); /** Constant for slash. */ public static final MetaPattern SLASH = new MetaPattern("/"); /** Constant for backslash. */ public static final MetaPattern BACKSLASH = new MetaPattern("\\\\"); /** Constant for dot. */ public static final MetaPattern DOT = new MetaPattern("\\."); /** Constant for plus. */ public static final MetaPattern PLUS = new MetaPattern("\\+"); /** Constant for minus. */ public static final MetaPattern MINUS = new MetaPattern("-"); /** Constant for dash. */ public static final MetaPattern DASH = new MetaPattern("-"); /** Constant for underscore. */ public static final MetaPattern UNDERSCORE = new MetaPattern("_"); /** Constant for ampersand. */ public static final MetaPattern AMPERSAND = new MetaPattern("&"); /** Constant for percent. */ public static final MetaPattern PERCENT = new MetaPattern("%"); /** Constant for dollar. */ public static final MetaPattern DOLLAR_SIGN = new MetaPattern("$"); /** Constant for pound. */ public static final MetaPattern POUND_SIGN = new MetaPattern("#"); /** Constant for at. */ public static final MetaPattern AT_SIGN = new MetaPattern("@"); /** Constant for excl. */ public static final MetaPattern EXCLAMATION_POINT = new MetaPattern("!"); /** Constant for tilde. */ public static final MetaPattern TILDE = new MetaPattern("~"); /** Constant for equals. */ public static final MetaPattern EQUALS = new MetaPattern("="); /** Constant for star. */ public static final MetaPattern STAR = new MetaPattern("\\*"); /** Constant for pipe. */ public static final MetaPattern PIPE = new MetaPattern("\\|"); /** Constant for left paren. */ public static final MetaPattern LEFT_PAREN = new MetaPattern("\\("); /** Constant for right paren. */ public static final MetaPattern RIGHT_PAREN = new MetaPattern("\\)"); /** Constant for left curly braces. */ public static final MetaPattern LEFT_CURLY = new MetaPattern("\\{"); /** Constant for right curly braces. */ public static final MetaPattern RIGHT_CURLY = new MetaPattern("\\}"); /** Constant for left square bracket. */ public static final MetaPattern LEFT_SQUARE = new MetaPattern("\\["); /** Constant for right square bracket. */ public static final MetaPattern RIGHT_SQUARE = new MetaPattern("\\]"); /** Constant for digit. */ public static final MetaPattern DIGIT = new MetaPattern("\\d"); /** Constant for digits. */ public static final MetaPattern DIGITS = new MetaPattern("\\d+"); /** Constant for an integer (of any size). */ public static final MetaPattern INTEGER = new MetaPattern("-?\\d+"); /** Constant for a floating point number. */ public static final MetaPattern FLOATING_POINT_NUMBER = new MetaPattern("-?\\d+\\.?\\d*|-?\\.\\d+"); /** Constant for a positive integer. */ public static final MetaPattern POSITIVE_INTEGER = new MetaPattern("\\d+"); /** Constant for hex digit. */ public static final MetaPattern HEXADECIMAL_DIGIT = new MetaPattern("[0-9a-fA-F]"); /** Constant for hex digits. */ public static final MetaPattern HEXADECIMAL_DIGITS = new MetaPattern("[0-9a-fA-F]+"); /** Constant for anything (string). */ public static final MetaPattern ANYTHING = new MetaPattern(".*"); /** Constant for anything non-empty (string). */ public static final MetaPattern ANYTHING_NON_EMPTY = new MetaPattern(".+"); /** Constant for a word. */ public static final MetaPattern WORD = new MetaPattern("\\w+"); /** Constant for an optional word. */ public static final MetaPattern OPTIONAL_WORD = new MetaPattern("\\w*"); /** Constant for a variable name. */ public static final MetaPattern VARIABLE_NAME = new MetaPattern(_VARIABLE_NAME); /** Constant for an XML element name. */ public static final MetaPattern XML_ELEMENT_NAME = new MetaPattern(_XML_NAME); /** Constant for an XML attribute name. */ public static final MetaPattern XML_ATTRIBUTE_NAME = new MetaPattern(_XML_NAME); /** Constant for perl interpolation. */ public static final MetaPattern PERL_INTERPOLATION = new MetaPattern("$\\{" + _VARIABLE_NAME + "\\}"); /** Constant for a double quoted string. */ public static final MetaPattern DOUBLE_QUOTED_STRING = new MetaPattern(_DOUBLE_QUOTED_STRING); /** Constant for a string. */ public static final MetaPattern STRING = new MetaPattern(_STRING); /** Constant for an optional string. */ public static final MetaPattern OPTIONAL_STRING = new MetaPattern(_OPTIONAL_STRING); /** * Constructor for a simple pattern. * * @param pattern * The regular expression pattern to compile */ public MetaPattern(final String pattern) { this.pattern = Pattern.compile(pattern); } /** * Copy constructor. * * @param pattern * The meta pattern to copy */ public MetaPattern(final MetaPattern pattern) { this.pattern = pattern.pattern; patterns = pattern.patterns; compiledPattern = pattern.compiledPattern; } /** * Constructs from an array of MetaPatterns. * * @param patterns * Array of MetaPatterns */ public MetaPattern(final MetaPattern... patterns) { this(Arrays.asList(patterns)); } /** * Constructs from a list of MetaPatterns * * @param patterns * List of MetaPatterns */ public MetaPattern(final List<MetaPattern> patterns) { this.patterns = patterns; } /** * Creates a matcher against a given input character sequence. * * @param input * The input to match against * @return The matcher */ public final Matcher matcher(final CharSequence input) { return matcher(input, 0); } /** * Creates a matcher with the given regexp compile flags. Once you call this method with a given * regexp compile flag value, the pattern will be compiled. Calling it again with a different * value for flags will not recompile the pattern. * * @param input * The input to match * @param flags * One or more of the standard Java regular expression compile flags (see * {@link Pattern#compile(String, int)}) * @return The matcher */ public final Matcher matcher(final CharSequence input, final int flags) { compile(flags); return compiledPattern.matcher(input); } /** * Gets the regular expression Pattern for this MetaPattern by compiling it. * * @return Pattern compiled with default Java regular expression compile flags */ public final Pattern pattern() { return pattern(0); } /** * Gets the regular expression Pattern for this MetaPattern by compiling it using the given * flags. * * @param flags * One or more of the standard Java regular expression compile flags (see * {@link Pattern#compile(String, int)}) * @return Equivalent Java regular expression Pattern compiled with the given flags */ public final Pattern pattern(final int flags) { compile(flags); return compiledPattern; } /** * Converts this MetaPattern to a String. * * @return A String representing this MetaPattern * @see java.lang.Object#toString() */ @Override public String toString() { if (pattern != null) { return pattern.pattern(); } else { final StringBuilder buffer = new StringBuilder(); for (MetaPattern metaPattern : patterns) { buffer.append(metaPattern); } return buffer.toString(); } } /** * Compiles this MetaPattern with the given Java regular expression flags. * * @param flags * One or more of the standard Java regular expression compile flags (see * {@link Pattern#compile(String, int)}) */ private synchronized void compile(final int flags) { if (compiledPattern == null) { bind(1); compiledPattern = Pattern.compile(toString(), flags); } } /** * Binds this MetaPattern to one or more capturing groups. Since MetaPatterns can nest, the * binding process can recurse. * * @param group * The initial capturing group number * @return The final capturing group (for use in recursion) */ private int bind(int group) { if (this instanceof Group) { ((Group) this).bind(group++); } if (patterns != null) { for (MetaPattern metaPattern : patterns) { group = metaPattern.bind(group); } } return group; } }