Open Source Repository

Home /json/flexjson-2.1 | Repository Home


flexjson/PathExpression.java
/**
 * Copyright 2007 Charlie Hubbard
 *
 * 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 flexjson;

import java.util.Arrays;

/**
 * This is an internal class for Flexjson.  It's used to match on fields it encounters
 * while walking the object graph.  Every expression is expressed in dot notation like foo.bar.baz.  Each term
 * between the dots is a field name in that parent object.  All expressions are relative to some parent object
 * within the context in which they are used.  Typically it is the object you're serializing.  Expressions may
 * also contain wildcards like *.class.
 */
public class PathExpression {
    String[] expression;
    boolean wildcard = false;
    boolean included = true;

    public PathExpression(String expr, boolean anInclude) {
        expression = expr.split("\\.");
        wildcard = expr.indexOf('*'>= 0;
        included = anInclude;
    }

    public String toString() {
        StringBuilder builder = new StringBuilder();
        builder.append("[");
        for (int i = 0; i < expression.length; i++) {
            builder.append(expression[i]);
            if (i < expression.length - 1) {
                builder.append(",");
            }
        }
        builder.append("]");
        return builder.toString();
    }

    public boolean matches(Path path) {
        int exprCurrentIndex = 0;
        int pathCurrentIndex = 0;
        while (pathCurrentIndex < path.length()) {
            String current = path.getPath().get(pathCurrentIndex);
            if (exprCurrentIndex < expression.length && expression[exprCurrentIndex].equals("*")) {
                exprCurrentIndex++;
            else if (exprCurrentIndex < expression.length && expression[exprCurrentIndex].equals(current)) {
                pathCurrentIndex++;
                exprCurrentIndex++;
            else if (exprCurrentIndex - >= && expression[exprCurrentIndex - 1].equals("*")) {
                pathCurrentIndex++;
            else {
                return false;
            }
        }
        if (exprCurrentIndex > && expression[exprCurrentIndex - 1].equals("*")) {
            return pathCurrentIndex >= path.length() && exprCurrentIndex >= expression.length;
        else {
            return pathCurrentIndex >= path.length() && path.length() 0;
        }
    }

    public boolean isWildcard() {
        return wildcard;
    }

    public boolean isIncluded() {
        return included;
    }

    public boolean equals(Object o) {
        if (this == oreturn true;
        if (o == null || getClass() != o.getClass()) return false;

        PathExpression that = (PathExpressiono;

        if (!Arrays.equals(expression, that.expression)) return false;

        return true;
    }

    public int hashCode() {
        return (expression != null ? Arrays.hashCode(expression0);
    }
}