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.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 org.gvsig.expressionevaluator.Code.Caller;

import org.gvsig.expressionevaluator.Code.Constant;

import org.gvsig.expressionevaluator.Code.Identifier;

import org.gvsig.expressionevaluator.Code.Method;

import org.gvsig.expressionevaluator.CodeBuilder;

import org.gvsig.expressionevaluator.Codes;

import org.gvsig.expressionevaluator.Function;

import org.gvsig.expressionevaluator.Interpreter;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.expressionevaluator.impl.function.predicate.IlikeOperator;

import org.gvsig.expressionevaluator.impl.function.predicate.LikeOperator;

import org.gvsig.expressionevaluator.impl.function.programming.GetattrFunction;

import org.gvsig.expressionevaluator.impl.function.programming.GetitemFunction;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.visitor.Visitor;

@SuppressWarnings("UseSpecificCatch")

    public class DefaultCodeBuilder implements CodeBuilder {

    public class BaseCode implements Code {

        @Override

        public int code() {

            return UNDEFINED;

        }

        @Override

        public void accept(Visitor visitor) throws BaseException {

            visitor.visit(this);

        }

    }

    class BaseConstant extends BaseCode implements Constant {

        private final Object value;

        public BaseConstant(Object value) {

            this.value = value;

        }

        @Override

        public int code() {

            return CONSTANT;

        }

        @Override

        public Object value() {

            return this.value;

        }

        @Override

        public String toString() {

            StringBuilder builder = new StringBuilder();

            Object v = this.value();

            if( v == null ) {

                builder.append("NULL");

            } else if( v instanceof CharSequence ) {

                if( StringUtils.isEmpty((CharSequence)v) ) {

                    builder.append("''");

                } else {

                    v = StringUtils.wrap(v.toString(), "'");

                    builder.append(v);

                }

            } else if( v instanceof Boolean ) {

                builder.append(((Boolean)v).toString().toUpperCase());

            } else if( v instanceof Geometry ) {

                try {

                    builder.append("'");

                    builder.append(((Geometry) v).convertToWKT());

                    builder.append("'::geometry");

                } catch (Exception ex) {

                    builder.append("'UNKNOW'::geometry");

                }

            } else {

                builder.append(v);

            }

            return builder.toString();

        }

    }

    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 String name;

        private 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 String toString() {

            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<Code> codes;

        public BaseCodes() {

            this.codes = new ArrayList<>();

        }

        @Override

        public int size() {

            if( codes == null ) {

                return 0;

            }

            return this.codes.size();

        }

        public void add(Code arg) {

            this.codes.add(arg);

        }

        @Override

        public Iterator<Code> iterator() {

            return this.codes.iterator();

        }

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

                visitor.visit(arg);

            }

        }

        @Override

        public String toString() {

            if( codes != null ) {

                StringBuilder builder = new StringBuilder();

                boolean skipcoma = true;

                for( Code code : codes ) {

                    if( code == null ) {

                        continue;

                    }

                    if( skipcoma ) {

                        skipcoma = false;

                    } else {

                        builder.append(", ");

                    }

                    builder.append(code.toString());

                }

                return builder.toString();

            }

            return "";

        }

    }

    public class BaseCaller extends BaseCode implements Caller, RecursionControlSupport {

        private final String name;

        private final 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 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;

            return this.function;

        }

        @Override

        public Codes args() {

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

            StringBuilder builder = new StringBuilder();

            builder.append(this.name());

            builder.append("(");

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

                builder.append(this.args().toString());

            }

            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 BaseCaller implements Method {

        private final Code obj;

        private final String methodname;

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

            super(methodname, FUNCTION, args);

            this.obj = obj;

            this.methodname = methodname;

        }

        @Override

        public int code() {

            return METHOD;

        }

        @Override

        public String methodname() {

            return this.methodname;

        }

        @Override

        public Code obj() {

            return this.obj;

        }

        @Override

        public String toString() {

            StringBuilder builder = new StringBuilder();

            builder.append(this.obj.toString());

            builder.append("->");

            builder.append(this.methodname());

            builder.append("(");

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

                builder.append(this.args().toString());

            }

            builder.append(")");

            return builder.toString();

        }

    }    

    @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 obj, String methodname, Codes methodargs) {

        Method m = new BaseMethod(obj, 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(NotOperator.NAME, op1);

    }

    @Override

    public Code negate(Code op1) {

        return operator(NegOperator.NAME, op1);

    }

    @Override

    public Code concat(Code op1, Code op2) {

        return operator(ConcatOperator.NAME, op1, op2);

    }

    @Override

    public Code add(Code op1, Code op2) {

        return operator(AddOperator.NAME, op1, op2);

    }

    @Override

    public Code subst(Code op1, Code op2) {

        return operator(SubstOperator.NAME, op1, op2);

    }

    @Override

    public Code mult(Code op1, Code op2) {

        return operator(MulOperator.NAME, op1, op2);

    }

    @Override

    public Code div(Code op1, Code op2) {

        return operator(DivOperator.NAME, op1, op2);

    }

    @Override

    public Code mod(Code op1, Code op2) {

        return operator(ModOperator.NAME, op1, op2);

    }

    @Override

    public Code or(Code op1, Code op2) {

        return operator(OrOperator.NAME, op1, op2);

    }

    @Override

    public Code and(Code op1, Code op2) {

        return operator(AndOperator.NAME, op1, op2);

    }

    @Override

    public Code like(Code op1, Code op2) {

        return operator(LikeOperator.NAME, op1, op2);

    }

    @Override

    public Code ilike(Code op1, Code op2) {

        return operator(IlikeOperator.NAME, op1, op2);

    }

    @Override

    public Code regexp(Code op1, Code op2) {

        return operator(RegExpOperator.NAME, op1, op2);

    }

    @Override

    public Code lt(Code op1, Code op2) {

        return operator(LtOperator.NAME, op1, op2);

    }

    @Override

    public Code gt(Code op1, Code op2) {

        return operator(GtOperator.NAME, op1, op2);

    }

    @Override

    public Code le(Code op1, Code op2) {

        return operator(LeOperator.NAME, op1, op2);

    }

    @Override

    public Code ge(Code op1, Code op2) {

        return operator(GeOperator.NAME, op1, op2);

    }

    @Override

    public Code eq(Code op1, Code op2) {

        return operator(EqOperator.NAME, op1, op2);

    }

    @Override

    public Code ne(Code op1, Code op2) {

        return operator(NeOperator.NAME, op1, op2);

    }

    @Override

    public Code is(Code op1, Code op2) {

        return operator(IsOperator.NAME, op1, op2);

    }

    @Override

    public Code getattr(Code obj, String attrname) {

        BaseCodes args = args();

        args.add(obj);

        args.add(constant(attrname));

        return function(GetattrFunction.NAME, args);

    }    

    @Override

    public Code getitem(Code obj, Code index) {

        BaseCodes args = args();

        args.add(obj);

        args.add(index);

        return function(GetitemFunction.NAME, args);

    }

}