Application: gvSIG desktop

package org.gvsig.expressionevaluator.impl.function.predicate;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Map;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import static org.gvsig.expressionevaluator.ExpressionBuilder.OPERATOR_LIKE;

import org.gvsig.expressionevaluator.Function;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.impl.function.operator.AbstractBinaryOperator;

/*

 * Based on portions of code from org.medfoster.sqljep.function.Like of the

 * SQLJEP project ((c) Copyright 2006, Alexey Gaidukov)

 * http://sqljep.sourceforge.net/

 */

public class LikeOperator extends AbstractBinaryOperator {

        protected static final Integer ZERO_OR_MORE_CHARS = 0; 

        protected static final Integer ONE_CHAR = 1; 

        protected static Map<String,Pattern> patterns = new HashMap<>();

    public LikeOperator() {

        super(Function.GROUP_STRING, OPERATOR_LIKE, true);

    }

    @Override

    public boolean allowConstantFolding() {

        return true;

    }

    @Override

    public Object call(Interpreter interpreter, Object op1, Object op2) {       

        if( op1 instanceof CharSequence && op2 instanceof CharSequence ) {

            boolean value = like(((CharSequence) op1).toString(), ((CharSequence) op2).toString());

            return value;

        }

        throw new IllegalArgumentException("Types not allowed in '"+name()+"' operand.");

    }

    public static boolean like(String source, String match) {

                Pattern pattern = patterns.get(match);

                if (pattern == null) {

            if( patterns.size()>20 ) {

                patterns = new HashMap<>();

            }

                        ArrayList<Object> p = compile(match);

                        String regexp = toRegExp(p);

                        pattern = Pattern.compile(regexp);

                        patterns.put(match, pattern);

                }

                Matcher m = pattern.matcher(source);

                return m.find();

        }

        protected static ArrayList<Object> compile(String pattern) {

                ArrayList<Object> format = new ArrayList<>();

                StringBuilder fill = new StringBuilder();

                final int plen = pattern.length();

                Character lastSymbol = null;

                if (pattern.length() > 2 && pattern.charAt(0) == '/' && pattern.charAt(pattern.length()-1) == '/') {

                        format.add(pattern.substring(1, pattern.length()-2));

                } else {

                        for (int i = 0; i < plen; i++) {

                                boolean f = false;

                                char c = pattern.charAt(i);

                                if (lastSymbol != null && lastSymbol == '\\') {

                                        lastSymbol = null;

                                        fill.append(c);

                                } else {

                                        if (c == '%') {

                                                if (fill.length() > 0) {

                                                        format.add(fill.toString());

                                                        fill.setLength(0);

                                                }

                                                format.add(ZERO_OR_MORE_CHARS); 

                                        }

                                        else if (c == '_') {

                                                if (fill.length() > 0) {

                                                        format.add(fill.toString());

                                                        fill.setLength(0);

                                                }

                                                format.add(ONE_CHAR); 

                                        } else {

                                                fill.append(c);

                                        }

                                        lastSymbol = c;

                                }

                        }

                        if (fill.length() > 0) {

                                format.add(fill.toString());

                        }

                }

                return format;

        }

        public static String toRegExp(ArrayList<Object> pattern) {

                if (pattern != null) {

                        StringBuilder str = new StringBuilder("^");

                        for (Object o : pattern) {

                                if (o == ZERO_OR_MORE_CHARS) {

                                        str.append(".*?");

                                }

                                else if (o == ONE_CHAR) {

                                        str.append(".?");

                                } else {

                                        str.append((String)o);

                                }

                        }

                        return str.toString();

                } else {

                        return null;

                }

        }    

}