/*

 * Copyright (c) 1999, 2008, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package javax.management;

/**

 * This class is used by the query-building mechanism to represent binary

 * relations.

 * @serial include

 *

 * @since 1.5

 */

class MatchQueryExp extends QueryEval implements QueryExp {

    /* Serial version */

    private static final long serialVersionUID = -7156603696948215014L;

    /**

     * @serial The attribute value to be matched

     */

    private AttributeValueExp exp;

    /**

     * @serial The pattern to be matched

     */

    private String pattern;

    /**

     * Basic Constructor.

     */

    public MatchQueryExp() {

    }

    /**

     * Creates a new MatchQueryExp where the specified AttributeValueExp matches

     * the specified pattern StringValueExp.

     */

    public MatchQueryExp(AttributeValueExp a, StringValueExp s) {

        exp     = a;

        pattern = s.getValue();

    }

    /**

     * Returns the attribute of the query.

     */

    public AttributeValueExp getAttribute()  {

        return exp;

    }

    /**

     * Returns the pattern of the query.

     */

    public String getPattern()  {

        return pattern;

    }

    /**

     * Applies the MatchQueryExp on a MBean.

     *

     * @param name The name of the MBean on which the MatchQueryExp will be applied.

     *

     * @return  True if the query was successfully applied to the MBean, false otherwise.

     *

     * @exception BadStringOperationException

     * @exception BadBinaryOpValueExpException

     * @exception BadAttributeValueExpException

     * @exception InvalidApplicationException

     */

    public boolean apply(ObjectName name) throws

        BadStringOperationException,

        BadBinaryOpValueExpException,

        BadAttributeValueExpException,

        InvalidApplicationException {

        ValueExp val = exp.apply(name);

        if (!(val instanceof StringValueExp)) {

            return false;

        }

        return wildmatch(((StringValueExp)val).getValue(), pattern);

    }

    /**

     * Returns the string representing the object

     */

    public String toString()  {

        return exp + " like " + new StringValueExp(pattern);

    }

    /*

     * Tests whether string s is matched by pattern p.

     * Supports "?", "*", "[", each of which may be escaped with "\";

     * character classes may use "!" for negation and "-" for range.

     * Not yet supported: internationalization; "\" inside brackets.<P>

     * Wildcard matching routine by Karl Heuer.  Public Domain.<P>

     */

    private static boolean wildmatch(String s, String p) {

        char c;

        int si = 0, pi = 0;

        int slen = s.length();

        int plen = p.length();

        while (pi < plen) { // While still string

            c = p.charAt(pi++);

            if (c == '?') {

                if (++si > slen)

                    return false;

            } else if (c == '[') { // Start of choice

                if (si >= slen)

                    return false;

                boolean wantit = true;

                boolean seenit = false;

                if (p.charAt(pi) == '!') {

                    wantit = false;

                    ++pi;

                }

                while ((c = p.charAt(pi)) != ']' && ++pi < plen) {

                    if (p.charAt(pi) == '-' &&

                        pi+1 < plen &&

                        p.charAt(pi+1) != ']') {

                        if (s.charAt(si) >= p.charAt(pi-1) &&

                            s.charAt(si) <= p.charAt(pi+1)) {

                            seenit = true;

                        }

                        ++pi;

                    } else {

                        if (c == s.charAt(si)) {

                            seenit = true;

                        }

                    }

                }

                if ((pi >= plen) || (wantit != seenit)) {

                    return false;

                }

                ++pi;

                ++si;

            } else if (c == '*') { // Wildcard

                if (pi >= plen)

                    return true;

                do {

                    if (wildmatch(s.substring(si), p.substring(pi)))

                        return true;

                } while (++si < slen);

                return false;

            } else if (c == '\\') {

                if (pi >= plen || si >= slen ||

                    p.charAt(pi++) != s.charAt(si++))

                    return false;

            } else {

                if (si >= slen || c != s.charAt(si++)) {

                    return false;

                }

            }

        }

        return (si == slen);

    }

 }