Application: gvSIG desktop

package org.gvsig.expressionevaluator.impl;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.function.Predicate;

import org.gvsig.expressionevaluator.Code;

import static org.gvsig.expressionevaluator.Code.CONSTANT;

import static org.gvsig.expressionevaluator.Code.IDENTIFIER;

import static org.gvsig.expressionevaluator.Code.UNDEFINED;

import static org.gvsig.expressionevaluator.Code.CODES;

import org.gvsig.expressionevaluator.Code.Constant;

import static org.gvsig.expressionevaluator.Code.EMPTY_FORMATTER;

import org.gvsig.expressionevaluator.Code.Identifier;

import org.gvsig.expressionevaluator.Code.Method;

//import org.gvsig.expressionevaluator.Code.Method;

import org.gvsig.expressionevaluator.CodeBuilder;

import org.gvsig.expressionevaluator.Codes;

import org.gvsig.expressionevaluator.ExpressionBuilder;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.expressionevaluator.ExpressionBuilder.Value;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.expressionevaluator.Formatter;

import org.gvsig.expressionevaluator.Function;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.exception.DynMethodNotSupportedException;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.visitor.Visitor;

import static org.gvsig.expressionevaluator.Code.CALLABLE;

import org.gvsig.expressionevaluator.Code.Callable;

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

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

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

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

import org.gvsig.tools.visitor.FilteredVisitable;

@SuppressWarnings("UseSpecificCatch")

public class DefaultCodeBuilder implements CodeBuilder {

    public static abstract class BaseCode implements Code {

        @Override

        public int code() {

            return UNDEFINED;

        }

        @Override

        public Code clone() throws CloneNotSupportedException {

            BaseCode x = (BaseCode) super.clone();

            return x;

        }

        @Override

        public void accept(Visitor visitor) throws BaseException {

            visitor.visit(this);

        }

        @Override

        public void accept(Visitor visitor, Predicate<FilteredVisitable> exclude) throws BaseException {

            if( !exclude.test(this) ) {

                visitor.visit(this);

            }

        }

        @Override

        public Value toValue(ExpressionBuilder builder) {

            return null;

        }

        @Override

        public Value toValue() {

            ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

            return this.toValue(builder);

        }

        @Override

        public void link(SymbolTable symbolTable) {

            if( this.code() == Code.CALLABLE ) {

                Callable caller = (Callable) this;

                Function fn = symbolTable.function(caller.name());

                if( fn != null ) {

                    caller.function(fn);

                }

                if( caller.parameters() != null ) {

                    for( Code arg : caller.parameters() ) {

                        if( arg!=null ) {

                          arg.link(symbolTable);

                        }

                    }

                }

            }

        }

        @Override

        public void replace(Code target, Code replacement) {

        }

    }

    static class BaseConstant extends BaseCode implements Constant {

        private Object value;

        private final ExpressionEvaluatorManager manager;

        public BaseConstant(ExpressionEvaluatorManager manager, Object value) {

            this.manager = manager;

            this.value = value;

        }

        @Override

        public Code clone() throws CloneNotSupportedException {

            return (Code) super.clone();

        }

        @Override

        public int code() {

            return CONSTANT;

        }

        @Override

        public Object value() {

            return this.value;

        }

        public void value(Object v) {

            this.value = v;

        }

        @Override

        public Value toValue(ExpressionBuilder builder) {

            return builder.constant(this.value);

        }

        @Override

        public String toString() {

            return this.toString(EMPTY_FORMATTER);

        }

        @Override

        public String toString(Formatter<Code> formatter) {

            if( formatter.canApply(this) ) {

                return formatter.format(this);

            }

            Object v = this.value();

            return manager.getReprMethod(v).repr(v);

        }

    }

    public interface RecursionControlSupport {

        public boolean enterCode(int max);

        public void exitCode();

        public void resetRecursionState();

    }

    private static class RecursionSupport implements RecursionControlSupport, Cloneable {

        private int counter;

        public RecursionSupport() {

            this.counter = 0;

        }

        @Override

        public RecursionControlSupport clone() throws CloneNotSupportedException {

            RecursionControlSupport x = (RecursionControlSupport) super.clone();

            return x;

        }

        @Override

        public boolean enterCode(int max) {

            this.counter += 1;

            return this.counter < max;

        }

        @Override

        public void exitCode() {

            this.counter -= 1;

        }

        @Override

        public void resetRecursionState() {

            this.counter = 0;

        }

    }

    public static class BaseIdentifier extends BaseCode implements Identifier, RecursionControlSupport {

        private final String name;

        private final RecursionSupport recursionSupport;

        public BaseIdentifier(String name) {

            this.name = name;

            this.recursionSupport = new RecursionSupport();

        }

        @Override

        public Code clone() throws CloneNotSupportedException {

            return (Code) super.clone();

        }

        @Override

        public int code() {

            return IDENTIFIER;

        }

        @Override

        public String name() {

            return this.name;

        }

        @Override

        public Value toValue(ExpressionBuilder builder) {

            return builder.variable(this.name);

        }

        @Override

        public String toString() {

            return this.toString(EMPTY_FORMATTER);

        }

        @Override

        public String toString(Formatter<Code> formatter) {

            if( formatter.canApply(this) ) {

                return formatter.format(this);

            }

            StringBuilder builder = new StringBuilder();

            builder.append("\"");

            builder.append(this.name());

            builder.append("\"");

            return builder.toString();

        }

        @Override

        public boolean enterCode(int max) {

            return this.recursionSupport.enterCode(max);

        }

        @Override

        public void exitCode() {

            this.recursionSupport.exitCode();

        }

        @Override

        public void resetRecursionState() {

            this.recursionSupport.resetRecursionState();

        }

    }

    public static class BaseCodes implements Codes {

        private List<Code> codes;

        public BaseCodes() {

            this.codes = new ArrayList<>();

        }

        @Override

        public Codes clone() throws CloneNotSupportedException {

            BaseCodes x = (BaseCodes)super.clone();

            x.codes = new ArrayList<>();

            for (int i = 0; i < this.codes.size(); i++) {

                x.add(this.codes.get(i).clone());

            }

            return x;

        }

        @Override

        public int code() {

            return CODES;

        }

        @Override

        public int size() {

            if( codes == null ) {

                return 0;

            }

            return this.codes.size();

        }

        public void add(Code arg) {

            this.codes.add(arg);

        }

        public void set(int pos, Code arg) {

            this.codes.set(pos, arg);

        }

        public void insert(int pos, Code arg) {

            this.codes.add(pos, arg);

        }

        @Override

        public Iterator<Code> iterator() {

          final Iterator<Code> it = this.codes.iterator();

          return it;

        }

        @Override

        public Code get(int n) {

            return this.codes.get(n);

        }

        @Override

        public boolean isEmpty() {

            return this.codes.isEmpty();

        }

        @Override

        public List<Code> toList() {

            return Collections.unmodifiableList(this.codes);

        }

        @Override

        public void accept(Visitor visitor) throws BaseException {

            for( Code arg : this.codes ) {

                if(arg!=null) {

                    arg.accept(visitor);

                }

            }

        }

        public void accept(Visitor visitor, Predicate<FilteredVisitable> exclude) throws BaseException {

            if( !exclude.test(this) ) {

                for( Code arg : this.codes ) {

                    if(arg!=null) {

                        arg.accept(visitor, exclude);

                    }

                }

            }

        }

        @Override

        public String toString() {

            return this.toString(EMPTY_FORMATTER);

        }

        @Override

        public Value toValue(ExpressionBuilder builder) {

            throw new UnsupportedOperationException();

        }

        @Override

        public Value toValue() {

            throw new UnsupportedOperationException();

        }

        @Override

        public String toString(Formatter<Code> formatter) {

            if( formatter.canApply(this) ) {

                return formatter.format(this);

            }

            if( codes != null ) {

                StringBuilder builder = new StringBuilder();

                boolean skipcoma = true;

                for( Code arg : codes ) {

                    if( arg == null ) {

                      continue;

                    }

                    if( skipcoma ) {

                        skipcoma = false;

                    } else {

                        builder.append(", ");

                    }

                    builder.append(arg.toString(formatter));

                }

                return builder.toString();

            }

            return "";

        }

        @Override

        public void link(SymbolTable symbolTable) {

            for (Code arg : this.codes) {

                arg.link(symbolTable);

            }

        }

        @Override

        public void replace(Code target, Code replacement) {

            for (int i = 0; i < this.codes.size(); i++) {

                Code code = this.codes.get(i);

                if( code == target ) {

                    codes.set(i, replacement);

                } else {

                    code.replace(target, replacement);

                }

            }

        }

    }

    public class BaseCaller extends BaseCode implements Callable, RecursionControlSupport {

        private final String name;

        private Codes args;

        private Function function;

        private final int type;

        private RecursionSupport recursionSupport;

        public BaseCaller(String name, int type, Codes args) {

            this.name = name;

            this.args = args;

            this.type = type;

            this.function = null;

            this.recursionSupport = new RecursionSupport();

        }

        @Override

        public Code clone() throws CloneNotSupportedException {

            BaseCaller x = (BaseCaller) super.clone();

            x.recursionSupport = (RecursionSupport) this.recursionSupport.clone();

            if (this.args!=null){

                x.args = this.args.clone();

            }

            return x;

        }

        @Override

        public int code() {

            return CALLABLE;

        }

        @Override

        public void replace(Code target, Code replacement) {

            this.args.replace(target, replacement);

        }

        @Override

        public Object call(Interpreter interpreter, Object[] args) throws Exception {

            return this.function.call(interpreter, args);

        }

        @Override

        public String name() {

            return this.name;

        }

        @Override

        public Function function() {

            return this.function;

        }

        @Override

        public Function function(Function function) {

            this.function = function;

            return this.function;

        }

        @Override

        public Codes parameters() {

            return this.args;

        }

        @Override

        public int type() {

            return this.type;

        }

        @Override

        public void accept(Visitor visitor) throws BaseException {

            visitor.visit(this);

            if(this.args!=null) {

                this.args.accept(visitor);

            }

        }

        @Override

        public void accept(Visitor visitor, Predicate<FilteredVisitable> exclude) throws BaseException {

            if( !exclude.test(this) ) {

                visitor.visit(this);

                if(this.args!=null) {

                    this.args.accept(visitor, exclude);

                }

            }

        }

        @Override

        public Value toValue(ExpressionBuilder builder) {

            switch(this.type) {

                case UNARY_OPERATOR:

                    return builder.function(

                            OPERATOR_NEGATE.equalsIgnoreCase(this.name())?

                                "-" :

                                this.name(),

                            this.parameters().get(0).toValue(builder)

                    );

                case BINARY_OPERATOR:

                    return builder.binaryOperator(

                            this.name(),

                            this.parameters().get(0).toValue(builder),

                            this.parameters().get(1).toValue(builder)

                    );

                case FUNCTION:

                default:

                    ExpressionBuilder.Function f = builder.function(this.name());

                    if( this.parameters()!=null ) {

                        for (Code parameter : this.parameters()) {

                            if (parameter==null) { 

                                f.parameter(null);

                            } else {

                                f.parameter(parameter.toValue(builder));

                            }

                        }  

                    }

                    return f;

            }

        }

        @Override

        public String toString() {

            return this.toString(EMPTY_FORMATTER);

        }

        @Override

        public String toString(Formatter<Code> formatter) {

            if( formatter.canApply(this) ) {

                return formatter.format(this);

            }

            Code code;

            StringBuilder builder = new StringBuilder();

            switch(this.type) {

                case UNARY_OPERATOR:

                    if( OPERATOR_NEGATE.equalsIgnoreCase(this.name()) ) {

                        builder.append("-");

                    } else {

                        builder.append(this.name());

                    }

                    builder.append("(");

                    builder.append(this.parameters().get(0).toString(formatter));

                    builder.append(")");

                    break;

                case BINARY_OPERATOR:

                    builder.append("(");

                    code = this.parameters().get(0);

                    if( code == null ) {                    

                        builder.append("?NULL?");

                    } else {

                        builder.append(code.toString(formatter));

                    }

                    builder.append(" ");

                    builder.append(this.name());

                    builder.append(" ");

                    code = this.parameters().get(1);

                    if( code == null ) {                    

                        builder.append("?NULL?");

                    } else {

                        builder.append(code.toString(formatter));

                    }

                    builder.append(")");

                    break;

                case FUNCTION:

                default:

                    String s = null;

                    if( this.function()!=null ) {

                        s = this.function().toString(args, formatter);

                    }

                    if( s == null ) {

                        builder.append(this.name());

                        builder.append("(");

                        if( this.parameters()!=null ) {

                            builder.append(this.parameters().toString(formatter));

                        }

                        builder.append(")");

                    } else {

                        builder.append(s);

                    }

            }

            return builder.toString();

        }

        @Override

        public boolean enterCode(int max) {

            return this.recursionSupport.enterCode(max);

        }

        @Override

        public void exitCode() {

            this.recursionSupport.exitCode();

        }

        @Override

        public void resetRecursionState() {

            this.recursionSupport.resetRecursionState();

        }

    }

    public static class BaseMethod extends BaseCode implements Method {

        private Code instance;

        private final String methodname;

        private Codes args;

        public BaseMethod(Code instance, String methodname, Codes args) {

            this.instance = instance;

            this.methodname = methodname;

            this.args = args;

        }

        @Override

        public void accept(Visitor visitor) throws BaseException {

            visitor.visit(this);

            if(this.instance!=null) {

                this.instance.accept(visitor);

            }            

            if(this.args!=null) {

                this.args.accept(visitor);

            }            

        }

        @Override

        public void accept(Visitor visitor, Predicate<FilteredVisitable> exclude) throws BaseException {

            if( !exclude.test(this) ) {

                visitor.visit(this);

                if(this.instance!=null) {

                    this.instance.accept(visitor, exclude);

                }            

                if(this.args!=null) {

                    this.args.accept(visitor, exclude);

                }            

            }

        }

        @Override

        public Code clone() throws CloneNotSupportedException {

            BaseMethod x = (BaseMethod) super.clone();

            x.args = this.args.clone();

            return x;

        }

        @Override

        public int code() {

            return METHOD;

        }

        @Override

        public void replace(Code target, Code replacement) {

            if( target == this.instance ) {

              this.instance = replacement;

            }

            this.args.replace(target, replacement);

        }

        @Override

        public String methodname() {

            return this.methodname;

        }

        @Override

        public Code instance() {

            return this.instance;

        }

        @Override

        public Codes parameters() {

            return this.args;

        }

        @Override

        public Object call(Interpreter interpreter, Object[] args) throws Exception {

            Object theInstance = interpreter.run(instance);

            if( theInstance instanceof SimpleScript ) {

                try {

                    return ((SimpleScript)theInstance).invokeFunction(methodname, args);

                } catch(NoSuchMethodException ex) {

                    // Ignore... continue calling instance method

                }                

            } else if( theInstance instanceof DynObject ) {

                DynObject dynobj = (DynObject) theInstance;

                try {

                    return dynobj.invokeDynMethod(methodname, args);

                } catch(DynMethodNotSupportedException ex) {

                    // Ignore... continue calling instance method

                }

            }

            return InstanceUtils.callmethod(theInstance, methodname, args);

        }

        @Override

        public String toString() {

            return this.toString(EMPTY_FORMATTER);

        }

        @Override

        public Value toValue(ExpressionBuilder builder) {

            ExpressionBuilder.Method m = builder.method(this.instance.toValue(builder), this.methodname);

            if( this.parameters()!=null ) {

                for (Code parameter : this.parameters()) {

                    m.parameter(parameter.toValue(builder));

                }

            }

            return m;

        }

        @Override

        public String toString(Formatter<Code> formatter) {

            if( formatter.canApply(this) ) {

                return formatter.format(this);

            }

            StringBuilder builder = new StringBuilder();

            builder.append(this.instance.toString(formatter));

            builder.append(".");

            builder.append(this.methodname());

            builder.append("(");

            if( this.parameters()!=null ) {

                builder.append(this.parameters().toString(formatter));

            }

            builder.append(")");

            return builder.toString();

        }

        @Override

        public String name() {

            return this.methodname();

        }

        @Override

        public Function function() {

            return null;

        }

        @Override

        public Function function(Function function) {

            return null;

        }

        @Override

        public int type() {

            return Code.METHOD;

        }

    }    

    protected ExpressionEvaluatorManager manager;

    public DefaultCodeBuilder(ExpressionEvaluatorManager manager) {

        this.manager = manager;

    }

    @Override

    public CodeBuilder clone() throws CloneNotSupportedException {

        // This implementation of CodeBuilder does not maintain state, so 

        // we only call the super class.

        DefaultCodeBuilder other = (DefaultCodeBuilder) super.clone();

        return other;

    }

    @Override

    public Constant constant(Object value) {

        return new BaseConstant(this.manager, value);

    }

    @Override

    public Identifier identifier(String name) {

        return new BaseIdentifier(name);

    }

    @Override

    public BaseCodes args() {

        return new BaseCodes();

    }

    @Override

    public Callable tuple() {

      BaseCodes args = this.args();

      return function(FUNCTION_TUPLE, args);

    }

    @Override

    public Callable tuple(Codes args) {

      if( args == null ) {

        args = this.args();

      }

      return function(FUNCTION_TUPLE, args);

    }

    @Override

    public Callable function(String name, int type, Codes args) {

        return new BaseCaller(name, type, args);

    }

    @Override

    public Callable function(String name, Codes args) {

        return function(name, Callable.FUNCTION, args);

    }

    @Override

    public Code method(Code instance, String methodname, Codes methodargs) {

        Method m = new BaseMethod(instance, methodname, methodargs);

        return m;

    }

    @Override

    public Callable operator(String name, Code arg1) {

        BaseCodes args = args();

        args.add(arg1);

        return function(name, Callable.UNARY_OPERATOR, args);

    }

    @Override

    public Callable operator(String name, Code arg1, Code arg2) {

        BaseCodes args = args();

        args.add(arg1);

        args.add(arg2);

        return function(name, Callable.BINARY_OPERATOR, args);

    }

    @Override

    public Code not(Code op1) {

        return operator(OPERATOR_NOT, op1);

    }

    @Override

    public Code negate(Code op1) {

        return operator(OPERATOR_NEGATE, op1);

    }

    @Override

    public Code concat(Code op1, Code op2) {

        return operator(OPERATOR_CONCAT, op1, op2);

    }

    @Override

    public Code let(String identifier, Code value) {

        BaseCodes args = args();

        args.add(this.constant(identifier));

        args.add(value);

        return function(FUNCTION_LET, Callable.FUNCTION, args);

    }

    @Override

    public Code add(Code op1, Code op2) {

        return operator(OPERATOR_ADD, op1, op2);

    }

    @Override

    public Code subst(Code op1, Code op2) {

        return operator(OPERATOR_SUBST, op1, op2);

    }

    @Override

    public Code mult(Code op1, Code op2) {

        return operator(OPERATOR_MULT, op1, op2);

    }

    @Override

    public Code div(Code op1, Code op2) {

        return operator(OPERATOR_DIV, op1, op2);

    }

    @Override

    public Code mod(Code op1, Code op2) {

        BaseCodes args = args();

        args.add(op1);

        args.add(op2);

        return function(FUNCTION_MOD, args);

    }

    @Override

    public Code or(Code op1, Code op2) {

        return operator(OPERATOR_OR, op1, op2);

    }

    @Override

    public Code and(Code op1, Code op2) {

        return operator(OPERATOR_AND, op1, op2);

    }

    @Override

    public Code like(Code op1, Code op2) {

        return operator(OPERATOR_LIKE, op1, op2);

    }

    @Override

    public Code ilike(Code op1, Code op2) {

        return operator(OPERATOR_ILIKE, op1, op2);

    }

    @Override

    public Code regexp(Code op1, Code op2) {

        return operator(OPERATOR_REGEXP, op1, op2);

    }

    @Override

    public Code lt(Code op1, Code op2) {

        return operator(OPERATOR_LT, op1, op2);

    }

    @Override

    public Code gt(Code op1, Code op2) {

        return operator(OPERATOR_GT, op1, op2);

    }

    @Override

    public Code le(Code op1, Code op2) {

        return operator(OPERATOR_LE, op1, op2);

    }

    @Override

    public Code ge(Code op1, Code op2) {

        return operator(OPERATOR_GE, op1, op2);

    }

    @Override

    public Code eq(Code op1, Code op2) {

        return operator(OPERATOR_EQ, op1, op2);

    }

    @Override

    public Code ne(Code op1, Code op2) {

        return operator(OPERATOR_NE, op1, op2);

    }

    @Override

    public Code is(Code op1, Code op2) {

        return operator(OPERATOR_IS, op1, op2);

    }

    @Override

    public Code getattr(Code obj, String attrname) {

        BaseCodes args = args();

        args.add(obj);

        args.add(constant(attrname));

        return function(ExpressionBuilder.FUNCTION_GETATTR, args);

    }    

    @Override

    public Code getitem(Code obj, Code index) {

        BaseCodes args = args();

        args.add(obj);

        args.add(index);

        return function(FUNCTION_GETITEM, args);

    }

    @Override

    public Code dict(Map<String,Code>map ) {

        BaseCodes args = args();

        for (Map.Entry<String, Code> entry : map.entrySet()) {

            String key = entry.getKey();

            Code value = entry.getValue();

            args.add(constant(key));

            args.add(value);

        }

        return function(FUNCTION_DICT, args);

    }

}