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 org.apache.commons.lang3.StringUtils;

import org.apache.commons.lang3.tuple.ImmutablePair;

import org.apache.commons.lang3.tuple.Pair;

import org.gvsig.expressionevaluator.Code;

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

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.Caller;

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.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_MOD;

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.expressionevaluator.impl.function.programming.GetitemFunction;

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;

@SuppressWarnings("UseSpecificCatch")

public class DefaultCodeBuilder implements CodeBuilder {

    public abstract class BaseCode implements Code {

        @Override

        public int code() {

            return UNDEFINED;

        }

        @Override

        public void accept(Visitor visitor) throws BaseException {

            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.CALLER ) {

                Caller caller = (Caller) 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);

                        }

                    }

                }

            }

        }

    }

    class BaseConstant extends BaseCode implements Constant {

        private Object value;

        public BaseConstant(Object value) {

            this.value = value;

        }

        @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 class RecursionSupport implements RecursionControlSupport {

        private int counter;

        public RecursionSupport() {

            this.counter = 0;

        }

        @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 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 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 class BaseCodes implements Codes {

        private final List<Pair<String,Code>> codes;

        private boolean useNames;

        public BaseCodes() {

            this.codes = new ArrayList<>();

            this.useNames = false;

        }

        @Override

        public boolean useArgNames() {

          return this.useNames;

        }

        @Override

        public boolean useArgNames(boolean useNames) {

          this.useNames = useNames;

          return this.useNames;

        }

        @Override

        public int code() {

            return CODES;

        }

        @Override

        public int size() {

            if( codes == null ) {

                return 0;

            }

            return this.codes.size();

        }

        public void add(String name, Code parameter) {

          if( !StringUtils.isBlank(name) ) {

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

              Pair<String, Code> arg = codes.get(i);

              if( StringUtils.equalsIgnoreCase(name, arg.getKey()) ) {

                codes.set(i, new ImmutablePair<>(name, parameter));

                return;

              }

            }

          }

          this.codes.add(new ImmutablePair<>(name, parameter));

        }

        public void add(Code arg) {

            this.codes.add(new ImmutablePair<>(null, arg));

        }

        public void insert(int pos, Code arg) {

            this.codes.add(pos, new ImmutablePair<>(null, arg));

        }

        @Override

        public boolean contains(String name) {

          for (Pair<String, Code> arg : this.codes) {

            if( StringUtils.equalsIgnoreCase(arg.getKey(), name) ) {

              return true;

            }

          }

          return false;

        }

        @Override

        public boolean contains(String name, int index) {

          String argNameX = name + String.valueOf(index).trim();

          for (Pair<String, Code> arg : this.codes) {

            if( StringUtils.equalsIgnoreCase(arg.getKey(), argNameX) ) {

              return true;

            }

          }

          return false;

        }

        @Override

        public Iterator<Code> iterator() {

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

          return new Iterator<Code>() {

            @Override

            public boolean hasNext() {

              return it.hasNext();

            }

            @Override

            public Code next() {

              Pair<String, Code> arg = it.next();

              return arg.getValue();

            }

          };

        }

        @Override

        public Code get(int n) {

            return this.codes.get(n).getValue();

        }

        @Override

        public Code get(String name) {

          for (Pair<String, Code> arg : this.codes) {

            if( StringUtils.equalsIgnoreCase(name, arg.getKey()) ) {

              return arg.getValue();

            }

          }

          return null;

        }

        @Override

        public String getName(int n) {

            return this.codes.get(n).getKey();

        }

        @Override

        public boolean isEmpty() {

            return this.codes.isEmpty();

        }

        @Override

        public List<Code> toList() {

            List<Code> l = new ArrayList<>();

            for (Pair<String, Code> arg : this.codes) {

              l.add(arg.getValue());

            }

            return Collections.unmodifiableList(l);

        }

        @Override

        public void accept(Visitor visitor) throws BaseException {

            for( Pair<String,Code> arg : this.codes ) {

                arg.getValue().accept(visitor);

            }

        }

        @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( Pair<String, Code> arg : codes ) {

                    if( arg == null ) {

                      continue;

                    }

                    String name = arg.getKey();

                    Code code = arg.getValue();

                    if( code == null ) {

                        continue;

                    }

                    if( skipcoma ) {

                        skipcoma = false;

                    } else {

                        builder.append(", ");

                    }

                    if( name==null || !useNames ) {

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

                    } else {

                        builder.append(name);

                        builder.append(":");

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

                    }

                }

                return builder.toString();

            }

            return "";

        }

        @Override

        public void link(SymbolTable symbolTable) {

            for (Pair<String,Code> arg : this.codes) {

                arg.getValue().link(symbolTable);

            }

        }

    }

    public class BaseCaller extends BaseCode implements Caller, RecursionControlSupport {

        private final String name;

        private final Codes args;

        private Function function;

        private final int type;

        private final 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 int code() {

            return CALLER;

        }

        @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;

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

              this.args.useArgNames(this.function.allowArgNames());

            }

            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 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()) {

                            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:

                    if( StringUtils.equalsIgnoreCase(this.name(),ExpressionBuilder.FUNCTION_GETATTR) ) {

                      Code arg0 = this.parameters().get(0);

                      Code arg1 = this.parameters().get(1);

                      if( arg0 instanceof Code.Identifier && arg1 instanceof Code.Constant ) {

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

                        builder.append(".\"");

                        builder.append(((Code.Constant)arg1).value());

                        builder.append("\"");

                      } else {

                        builder.append(this.name());

                        builder.append("(");

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

                        builder.append(", ");

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

                        builder.append(")");

                      }

                    } else {

                      builder.append(this.name());

                      builder.append("(");

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

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

                      }

                      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 class BaseMethod extends BaseCode implements Method {

        private final Code instance;

        private final String methodname;

        private final Codes args;

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

            this.instance = instance;

            this.methodname = methodname;

            this.args = args;

        }

        @Override

        public int code() {

            return METHOD;

        }

        @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();

        }

    }

    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(value);

    }

    @Override

    public Identifier identifier(String name) {

        return new BaseIdentifier(name);

    }

    @Override

    public BaseCodes args() {

        return new BaseCodes();

    }

    @Override

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

        return new BaseCaller(name, type, args);

    }

    @Override

    public Caller function(String name, Codes args) {

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

    }

    @Override

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

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

        return m;

    }

    @Override

    public Caller operator(String name, Code arg1) {

        BaseCodes args = args();

        args.add(arg1);

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

    }

    @Override

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

        BaseCodes args = args();

        args.add(arg1);

        args.add(arg2);

        return function(name, Caller.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 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) {

        return operator(OPERATOR_MOD, op1, op2);

    }

    @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(GetitemFunction.NAME, args);

    }

}