openjpa-lib/src/main/java/org/apache/openjpa/lib/util/SimpleRegex.java

/*
 * 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.openjpa.lib.util;

/**
 * Allows for simple regex style testing of strings. The wildcard '.'
 * is used to represent any single character, while '.*' is used to represent
 * any series of 0 or more characters. Examples:<br />
 * <code> SimpleRegex re = new SimpleRegex("the qu.ck .* dog", true);
 * boolean matches = re.matches("The quick fox jumped over the lazy dog");
 * </code>
 *
 */
public class SimpleRegex {

    private final String expr;
    private final boolean caseInsensitive;

    public SimpleRegex(String expr, boolean caseInsensitive) {
        this.caseInsensitive = caseInsensitive;

        // If we're case insensitive, toLowerCase the expr.  We'll toLowerCase
        // each target, too, in the matches call.
        if (caseInsensitive)
            this.expr = expr.toLowerCase();
        else
            this.expr = expr;
    }

    public boolean matches(String target) {
        // If we're case insensitive, toLowerCase the target
        if (caseInsensitive)
            target = target.toLowerCase();

        // By default, we are not position independent("mobile"). We only
        // become position independent once we hit our first ".*".
        boolean mobile = false;

        // Find occurrences of ".*" in the expression.
        int exprPos = 0;
        int targetPos = 0;
        while (true) {
            // Find the next occurrence of ".*"
            int star = expr.indexOf(".*", exprPos);

            // If we're at a ".*" now, simply skip it and become position
            // independent
            if (star == exprPos) {
                mobile = true;
                exprPos += 2;
                continue;
            }
            // If there are no more ".*"s, then we're effectively no longer
            // position independent(assuming we even were before), since
            // we must match the end of the string
            else if (star == -1) {
                int len = expr.length() - exprPos;

                // If we're not mobile, then the remainder of the expr and
                // target must be the same length.  If not, then it's not a
                // match.  If we're mobile, then the length doesn't have to
                // be the same as long as the remainder of the expression
                // is equal to the end of the target
                if (!mobile && targetPos != target.length() - len)
                    return false;

                // In anycase, the remaining length of the target must be
                // at least as long as the remaining length of the expression.
                // (We check now to avoid sending a negative start pos to
                // indexOf)
                if (target.length() < len)
                    return false;

                // Match the end of the target to the remainder of the
                // expression
                int match = indexOf(target, target.length() - len, exprPos,
                    len, true);
                if (match != -1)
                    return true;
                return false;
            }

            // Match the fragment of the expression to the target
            int match = indexOf(target, targetPos, exprPos,
                star - exprPos, !mobile);
            if (match == -1)
                return false;
            targetPos = match + star - exprPos;
            exprPos = star + 2;
            mobile = true;
        }
    }

    /**
     * Match a section of target to a fragment of the expression.
     * If we're only to match the beginning of the target, beginOnly
     * will be true, otherwise we can match anymore in the target(starting
     * at the targetStart position). A "." in the expression matches any
     * character.
     */
    private int indexOf(String target, int targetStart,
        int exprStart, int exprLength, boolean beginOnly) {
        // Run through the target seeing if there is a match
        while (target.length() - targetStart >= exprLength) {
            // Assume success.  If there isn't a match we'll break out
            boolean found = true;
            for (int i = 0; i < exprLength; i++) {
                // "." in the expr matches any character in the target
                if (expr.charAt(exprStart + i) != '.' &&
                    expr.charAt(exprStart + i) !=
                        target.charAt(targetStart + i)) {
                    found = false;
                    break;
                }
            }
            if (found)
                return targetStart;

            // If we're position dependent(beginOnly == true), then don't
            // continue the search
            if (beginOnly)
                return -1;

            targetStart++;
        }
        return -1;
    }
}