Application: gvSIG desktop

package org.gvsig.expressionevaluator.impl;

import java.util.ArrayList;

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

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

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.visitor.Visitor;

public class DefaultCodeBuilder implements CodeBuilder {

    public class BaseCode implements Code {

        @Override

        public int code() {

            return UNDEFINED;

        }

//        @Override

//        public String toString() {

//            return this.toString(this);

//        }

//

//        private String toString(Code code) {

//            StringBuilder builder = new StringBuilder();

//            switch( code.code() ) {

//            case CONSTANT: {

//                Object value = ((Constant) code).value();

//                if( value instanceof CharSequence ) {

//                    value = StringUtils.wrap(value.toString(), "'");

//                }

//                builder.append(value);

//            }

//            break;

//

//            case IDENTIFIER:

//                builder.append(((Identifier) code).name());

//                break;

//

//            case CALLER:

//                Caller caller = (Caller) code;

//                builder.append(caller.name());

//                builder.append("(");

//                if( caller.args() != null ) {

//                    boolean skipcoma = true;

//                    for( Code arg : caller.args() ) {

//                        if( skipcoma ) {

//                            skipcoma = false;

//                        } else {

//                            builder.append(", ");

//                        }

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

//                    }

//                }

//                builder.append(")");

//                break;

//            }

//            return builder.toString();

//        }

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

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

            }

            builder.append(v);

            return builder.toString();

        }

    }

    public class BaseIdentifier extends BaseCode implements Identifier {

        String name;

        public BaseIdentifier(String name) {

            this.name = name;

        }

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

        }

    }

    public class BaseArguments implements Arguments {

        private final List<Code> args;

        public BaseArguments() {

            this.args = new ArrayList<>();

        }

        @Override

        public int count() {

            if( args == null ) {

                return 0;

            }

            return this.args.size();

        }

        public void add(Code arg) {

            this.args.add(arg);

        }

        @Override

        public Iterator<Code> iterator() {

            return this.args.iterator();

        }

        @Override

        public Code get(int n) {

            return this.args.get(n);

        }

        @Override

        public void accept(Visitor visitor) throws BaseException {

            for( Code arg : this.args ) {

                visitor.visit(arg);

            }

        }

        @Override

        public String toString() {

            if( args != null ) {

                StringBuilder builder = new StringBuilder();

                boolean skipcoma = true;

                for( Code arg : args ) {

                    if( skipcoma ) {

                        skipcoma = false;

                    } else {

                        builder.append(", ");

                    }

                    builder.append(arg.toString());

                }

                return builder.toString();

            }

            return "";

        }

    }

    public class BaseCaller extends BaseCode implements Caller {

        private final String name;

        private final Arguments args;

        private Function function;

        private final int type;

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

            this.name = name;

            this.args = args;

            this.type = type;

            this.function = null;

        }

        @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 Code.Caller.Arguments args() {

            return this.args;

        }

        @Override

        public int type() {

            return this.type;

        }

        @Override

        public void accept(Visitor visitor) throws BaseException {

            visitor.visit(this);

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

        }

    }

    public class BaseMethod extends BaseCaller implements Method {

        private final Code obj;

        private final String methodname;

        public BaseMethod(Code obj, String methodname, Arguments 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 Caller.Arguments args() {

        return new BaseArguments();

    }

    @Override

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

        return new BaseCaller(name, type, args);

    }

    @Override

    public Caller function(String name, Arguments args) {

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

    }

    @Override

    public Code method(Code obj, String methodname, Arguments methodargs) {

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

        return m;

    }

    @Override

    public Caller operator(String name, Code arg1) {

        Arguments args = args();

        ((BaseArguments)args).add(arg1);

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

    }

    @Override

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

        Arguments args = args();

        ((BaseArguments)args).add(arg1);

        ((BaseArguments)args).add(arg2);

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

    }

    @Override

    public Code not(Code op1) {

        return operator("not", op1);

    }

    @Override

    public Code add(Code op1, Code op2) {

        return operator("+", op1, op2);

    }

    @Override

    public Code subst(Code op1, Code op2) {

        return operator("-", op1, op2);

    }

    @Override

    public Code mult(Code op1, Code op2) {

        return operator("*", op1, op2);

    }

    @Override

    public Code div(Code op1, Code op2) {

        return operator("/", op1, op2);

    }

    @Override

    public Code mod(Code op1, Code op2) {

        return operator("%", op1, op2);

    }

    @Override

    public Code or(Code op1, Code op2) {

        return operator("or", op1, op2);

    }

    @Override

    public Code and(Code op1, Code op2) {

        return operator("and", op1, op2);

    }

    @Override

    public Code like(Code op1, Code op2) {

        return operator("like", op1, op2);

    }

    @Override

    public Code ilike(Code op1, Code op2) {

        return operator("ilike", op1, op2);

    }

    @Override

    public Code regexp(Code op1, Code op2) {

        return operator("~", op1, op2);

    }

    @Override

    public Code lt(Code op1, Code op2) {

        return operator("<", op1, op2);

    }

    @Override

    public Code gt(Code op1, Code op2) {

        return operator(">", op1, op2);

    }

    @Override

    public Code le(Code op1, Code op2) {

        return operator("<=", op1, op2);

    }

    @Override

    public Code ge(Code op1, Code op2) {

        return operator(">=", op1, op2);

    }

    @Override

    public Code eq(Code op1, Code op2) {

        return operator("=", op1, op2);

    }

    @Override

    public Code ne(Code op1, Code op2) {

        return operator("<>", op1, op2);

    }

    @Override

    public Code is(Code op1, Code op2) {

        return operator("is", op1, op2);

    }

    @Override

    public Code getattr(Code obj, String attrname) {

        Arguments args = args();

        ((BaseArguments)args).add(obj);

        ((BaseArguments)args).add(constant(attrname));

        return function("getattr", args);

    }    

}