/* * 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);    } }