| gvSIG desktop 1

/*

 *    GeoTools - OpenSource mapping toolkit

 *    http://geotools.org

 *    (C) 2002-2006, GeoTools Project Managment Committee (PMC)

 *        

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

 *    modify it under the terms of the GNU Lesser General Public

 *    License as published by the Free Software Foundation;

 *    version 2.1 of the License.

 *

 *    This library 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

 *    Lesser General Public License for more details.

 */

package org.gvsig.data.vectorial.filter;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import org.opengis.filter.FilterVisitor;

import org.opengis.filter.PropertyIsLike;

import org.opengis.filter.expression.Expression;

/**

 * Defines a like filter, which checks to see if an attribute matches a REGEXP.

 *

 * @author Rob Hranac, Vision for New York

 * @source $URL: http://svn.geotools.org/geotools/tags/2.4.2/modules/library/main/src/main/java/org/geotools/filter/LikeFilterImpl.java $

 * @version $Id: LikeFilterImpl.java 24805 2007-03-19 15:15:35Z aaime $

 */

public class LikeFilterImpl implements PropertyIsLike {

    /** The attribute value, which must be an attribute expression. */

    private Expression attribute = null;

    /** The (limited) REGEXP pattern. */

    private String pattern = null;

    /** The single wildcard for the REGEXP pattern. */

    private String wildcardSingle = ".?";

    /** The multiple wildcard for the REGEXP pattern. */

    private String wildcardMulti = ".*";

    /** The escape sequence for the REGEXP pattern. */

    private String escape = "\\";

    /** the pattern compiled into a java regex */

    private Pattern compPattern = null;

    /** The matcher to match patterns with. */

    private Matcher match = null;

    protected LikeFilterImpl(Expression expression, String pattern){

            this(expression, pattern,"%","_","\\");

    }

    protected LikeFilterImpl(Expression expression, String pattern, String wildchar, String singlechar, String escape){

            attribute = expression;

            this.pattern=pattern; 

            setSingleChar(singlechar);

            setWildCard(wildchar);

            setEscape(escape);

    }

    /**

         * Given OGC PropertyIsLike Filter information, construct

         * an SQL-compatible 'like' pattern.

         * 

         *   SQL   % --> match any number of characters

         *         _ --> match a single character

         * 

         *    NOTE; the SQL command is 'string LIKE pattern [ESCAPE escape-character]'

         *    We could re-define the escape character, but I'm not doing to do that in this code

         *    since some databases will not handle this case.

         * 

         *   Method:

         *     1. 

         * 

         *  Examples: ( escape ='!',  multi='*',    single='.'  )

         *    broadway*  -> 'broadway%'

         *    broad_ay   -> 'broad_ay'

         *    broadway   -> 'broadway'

         *    

         *    broadway!* -> 'broadway*'  (* has no significance and is escaped)

         *    can't      -> 'can''t'     ( ' escaped for SQL compliance)

         * 

         * 

         *  NOTE: we also handle "'" characters as special because they are

         *        end-of-string characters.  SQL will convert ' to '' (double single quote).

         * 

         *  NOTE: we dont handle "'" as a 'special' character because it would be 

         *        too confusing to have a special char as another special char.

         *        Using this will throw an error  (IllegalArgumentException).

         * 

         * @param escape

         * @param multi

         * @param single

         * @param pattern

         * 

         */

        public void setWildCard(String wildCard) {

                this.wildcardMulti = wildCard;

                match = null;

        }

        public void setSingleChar(String singleChar) {

                this.wildcardSingle = singleChar;

                match = null;

        }

        public void setEscape(String escape) {

                this.escape = escape;

                match = null;

        }

    private Matcher getMatcher(){

        if(match == null){

            // protect the vars as this is moved code

            String pattern1 = new String(this.pattern);

            String wildcardMulti1 = new String(this.wildcardMulti);

            String wildcardSingle1 = new String(this.wildcardSingle);

            String escape1 = new String(this.escape);

//          The following things happen for both wildcards:

            //  (1) If a user-defined wildcard exists, replace with Java wildcard

            //  (2) If a user-defined escape exists, Java wildcard + user-escape

            //  Then, test for matching pattern and return result.

            char esc = escape1.charAt(0);

            String escapedWildcardMulti = fixSpecials(wildcardMulti1);

            String escapedWildcardSingle = fixSpecials(wildcardSingle1);

            // escape any special chars which are not our wildcards

            StringBuffer tmp = new StringBuffer("");

            boolean escapedMode = false;

            for (int i = 0; i < pattern1.length(); i++) {

                char chr = pattern1.charAt(i);

                //LOGGER.finer("tmp = " + tmp + " looking at " + chr);

                if (pattern1.regionMatches(false, i, escape1, 0, escape1.length())) {

                    // skip the escape string

                    //LOGGER.finer("escape ");

                    escapedMode = true;

                    i += escape1.length();

                    chr = pattern1.charAt(i);

                }

                if (pattern1.regionMatches(false, i, wildcardMulti1, 0,

                            wildcardMulti1.length())) { // replace with java wildcard

                    //LOGGER.finer("multi wildcard");

                    if (escapedMode) {

                        //LOGGER.finer("escaped ");

                        tmp.append(escapedWildcardMulti);

                    } else {

                        tmp.append(".*");

                    }

                    i += (wildcardMulti1.length() - 1);

                    escapedMode = false;

                    continue;

                }

                if (pattern1.regionMatches(false, i, wildcardSingle1, 0,

                            wildcardSingle1.length())) {

                    // replace with java single wild card

                    //LOGGER.finer("single wildcard");

                    if (escapedMode) {

                        //LOGGER.finer("escaped ");

                        tmp.append(escapedWildcardSingle);

                    } else {

                        // From the OpenGIS filter encoding spec, 

                        // "the single singleChar character matches exactly one character"

                        tmp.append(".{1}");

                    }

                    i += (wildcardSingle1.length() - 1);

                    escapedMode = false;

                    continue;

                }

                if (isSpecial(chr)) {

                    //LOGGER.finer("special");

                    tmp.append(this.escape + chr);

                    escapedMode = false;

                    continue;

                }

                tmp.append(chr);

                escapedMode = false;

            }

            pattern1 = tmp.toString();

            //LOGGER.finer("final pattern " + pattern1);

            compPattern = java.util.regex.Pattern.compile(pattern1);

            match = compPattern.matcher("");

        }

        return match;

    }

    /**

     * Returns the pattern.

     */

    public String getLiteral() {

            return this.pattern;

    }

    /**

     * Sets the pattern.

     */

    public void setLiteral(String literal) {

            this.pattern = literal;

            match = null;

    }

    /**

      * Determines whether or not a given feature matches this pattern.

      *

      * @param feature Specified feature to examine.

      *

      * @return Flag confirming whether or not this feature is inside the

      *         filter.

      *

      * @task REVISIT: could the pattern be null such that a null = null?

      */

    public boolean evaluate(Object feature) {

            //Checks to ensure that the attribute has been set

        if (attribute == null) {

            return false;

        }

            // Note that this converts the attribute to a string

            //  for comparison.  Unlike the math or geometry filters, which

            //  require specific types to function correctly, this filter

            //  using the mandatory string representation in Java

            // Of course, this does not guarantee a meaningful result, but it

            //  does guarantee a valid result.

            ////LOGGER.finest("pattern: " + pattern);

            ////LOGGER.finest("string: " + attribute.getValue(feature));

            //return attribute.getValue(feature).toString().matches(pattern);

            Object value = attribute.evaluate(feature);

            if (null == value) {

                return false;

            }

            Matcher matcher = getMatcher();

            matcher.reset(value.toString());

            return matcher.matches();

    }

    /**

     * Return this filter as a string.

     *

     * @return String representation of this like filter.

     */

    public String toString() {

        return "[ " + attribute.toString() + " is like " + pattern + " ]";

    }

    /**

     * Getter for property escape.

     *

     * @return Value of property escape.

     */

    public java.lang.String getEscape() {

        return escape;

    }

    /**

     * convienience method to determine if a character is special to the regex

     * system.

     *

     * @param chr the character to test

     *

     * @return is the character a special character.

     */

    private boolean isSpecial(final char chr) {

        return ((chr == '.') || (chr == '?') || (chr == '*') || (chr == '^')

        || (chr == '$') || (chr == '+') || (chr == '[') || (chr == ']')

        || (chr == '(') || (chr == ')') || (chr == '|') || (chr == '\\')

        || (chr == '&'));

    }

    /**

     * convienience method to escape any character that is special to the regex

     * system.

     *

     * @param inString the string to fix

     *

     * @return the fixed string

     */

    private String fixSpecials(final String inString) {

        StringBuffer tmp = new StringBuffer("");

        for (int i = 0; i < inString.length(); i++) {

            char chr = inString.charAt(i);

            if (isSpecial(chr)) {

                tmp.append(this.escape + chr);

            } else {

                tmp.append(chr);

            }

        }

        return tmp.toString();

    }

    /**

     * Compares this filter to the specified object.  Returns true  if the

     * passed in object is the same as this filter.  Checks  to make sure the

     * filter types, the value, and the pattern are the same. &

     *

     * @param obj - the object to compare this LikeFilter against.

     *

     * @return true if specified object is equal to this filter; false

     *         otherwise.

     */

    public boolean equals(Object obj) {

        if (obj instanceof LikeFilterImpl) {

            LikeFilterImpl lFilter = (LikeFilterImpl) obj;

            //REVISIT: check for nulls.

            return (lFilter.getLiteral().equals(this.getLiteral())

                            && lFilter.getExpression().equals(this.getExpression()));

        }

        return false;

    }

    /**

     * Override of hashCode method.

     *

     * @return the hash code for this like filter implementation.

     */

    public int hashCode() {

        int result = 17;

        result = (37 * result)

            + ((attribute == null) ? 0 : attribute.hashCode());

        result = (37 * result) + ((pattern == null) ? 0 : pattern.hashCode());

        return result;

    }

    /**

     * Used by FilterVisitors to perform some action on this filter instance.

     * Typicaly used by Filter decoders, but may also be used by any thing

     * which needs infomration from filter structure. Implementations should

     * always call: visitor.visit(this); It is importatant that this is not

     * left to a parent class unless the parents API is identical.

     *

     * @param visitor The visitor which requires access to this filter, the

     *        method must call visitor.visit(this);

     */

     public Object accept(FilterVisitor visitor, Object extraData) {

            return visitor.visit(this,extraData);

    }

        public Expression getExpression() {

                return attribute;

        }

        public String getSingleChar() {

                return wildcardSingle;

        }

        public String getWildCard() {

                return wildcardMulti;

        }

}