Application: gvSIG desktop

package org.gvsig.expressionevaluator.impl;

import java.util.ArrayList;

import java.util.Comparator;

import java.util.Date;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

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

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.Code.Constant;

import org.gvsig.expressionevaluator.Code.Identifier;

import org.gvsig.expressionevaluator.Code.Caller;

import org.gvsig.expressionevaluator.Code.Caller.Arguments;

import org.gvsig.expressionevaluator.Code.Method;

import org.gvsig.expressionevaluator.Function;

import org.gvsig.expressionevaluator.Optimizer;

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

import org.gvsig.expressionevaluator.impl.function.obj.InvokeMethodFunction;

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

public class DefaultInterpreter implements Interpreter {

    private class DefaultCache implements Cache {

        private Map<Pair<Object,Object>,Pair<Object,Long>> data;

        public DefaultCache() {

            this.data = new  HashMap<>();

        }

        @Override

        public Object get(Object context, Object key) {

            Pair<Object, Long> v = this.data.get( Pair.of(context, key) );

            return v.getLeft();

        }

        @Override

        public void put(Object context, Object key, Object value) {

            if( this.data.size()>this.getMaxElements() ) {

                this.reduce();

            }

            this.data.put(Pair.of(context, key), Pair.of(value, new Date().getTime()));

        }

        @Override

        public void remove(Object context, Object key) {

            this.data.remove(Pair.of(context, key));

        }

        @Override

        public void removeAll() {

            this.data = new  HashMap<>();

        }

        private int getMaxElements() {

            return 100;

        }

        private void reduce() {

            List<Map.Entry<Pair<Object, Object>, Pair<Object, Long>>> entries = 

                new ArrayList<>(this.data.entrySet());

            entries.sort(new Comparator<Map.Entry<Pair<Object, Object>, Pair<Object, Long>>>() {

                @Override

                public int compare(Map.Entry<Pair<Object, Object>, Pair<Object, Long>> o1, Map.Entry<Pair<Object, Object>, Pair<Object, Long>> o2) {

                    return o1.getValue().getRight().compareTo(o2.getValue().getRight());

                }

            });

            for( int i=0; i<this.getMaxElements()/2; i++ ) {

                this.data.remove(entries.get(i).getKey());

            }

        }

    }

    private SymbolTable symbolTable = null;

    private Double accuracy;

    private Code currentCode;

    private Cache cache;

    public DefaultInterpreter() {

        this.cache = new DefaultCache();

    }

    @Override

    public Interpreter clone() throws CloneNotSupportedException {

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

        other.cache = new DefaultCache();

        if( this.symbolTable!=null ) {

            other.symbolTable = this.symbolTable.clone();

        }

        return other;

    }

    @Override

    public Cache getCache() {

        return this.cache;

    }

    @Override

    public void setSymbolTable(SymbolTable symbolTable) {

        this.symbolTable = symbolTable;

    }

    @Override

    public SymbolTable getSymbolTable() {

        if( this.symbolTable==null ) {

            this.symbolTable = new DefaultSymbolTable();

        }

        return this.symbolTable;

    }

    @Override

    public Double getAccuracy() {

        return this.accuracy;

    }

    @Override

    public void setAccuracy(Double accuracy) {

        this.accuracy = accuracy;

    }

    @Override

    public Object run(Code code) {

        try {

            return this.runCode(code);

        } catch (Exception ex) {

            throw new RuntimeException(ex);

        }

    }

    @Override

    public void link(Code code) {

        linkCode(code);

    }

    private void linkCode(Code code) {

        if( code.code() == Code.CALLER ) {

            Caller caller = (Caller) code;

            if( caller.function() == null ) {

                caller.function(this.getSymbolTable().function(caller.name()));

            }

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

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

                    linkCode(arg);

                }

            }

        }

    }

    private Object runCode(Code code) throws Exception {

        this.currentCode = code;

        Object value = null;

        switch( code.code() ) {

        case Code.CONSTANT:

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

            break;

        case Code.IDENTIFIER:

            String name = ((Identifier) code).name();

            if( !this.getSymbolTable().exists(name) ) {

                throw new RuntimeException("Variable '" + name + "' not found.");

            }

            value = this.getSymbolTable().value(name);

            break;

        case Code.METHOD: {

                Method method = (Method) code;

                Function function = method.function();

                if( function == null ) {

                    Object obj = this.runCode(method.obj());

                    if( obj == null ) {

                        throw new NullPointerException("An object pointer was expected to invoke method "+method.methodname()+" and a null was received");

                    }

                    method.function(new InvokeMethodFunction(obj, method.methodname()));

                }

            }

        case Code.CALLER:

            Caller caller = (Caller) code;

            Function function = caller.function();

            if( function == null ) {

                function = this.getSymbolTable().function(caller.name());

                if( function == null ) {

                    throw new RuntimeException("Function '" + caller.name() + "' not found.");

                }

                caller.function(function);

            }

            Arguments args = caller.args();

            try {

                switch( caller.type() ) {

                case Caller.UNARY_OPERATOR:

                    if( args == null || args.count() != 1 ) {

                        throw new RuntimeException("Number of argument mistmatch in operator '"+function.name()+"', expected 1 got " + args.count() + ".");

                    }

                    value = ((UnaryOperator) function).call(this, runCode(args.get(0)));

                    break;

                case Caller.BINARY_OPERATOR:

                    if( args == null || args.count() != 2 ) {

                        throw new RuntimeException("Number of argument mistmatch in operator '"+function.name()+"', expected 2 got " + args.count() + ".");

                    }

                    value = ((BinaryOperator) function).call(this, runCode(args.get(0)), runCode(args.get(1)));

                    break;

                case Caller.FUNCTION:

                    int argc = (args == null) ? 0 : args.count();

                    if( !function.argc().contains(argc) ) {

                        throw new RuntimeException("Number of argument mistmatch in function '"+function.name()+"', expected " + function.argc() + " got " + argc + ".");

                    }

                    if( function.useArgumentsInsteadObjects() ) {

                        value = function.call(this, args);

                    } else {

                        Object[] argvalues = new Object[argc];

                        if( args != null ) {

                            int i = 0;

                            for( Code arg : args ) {

                                argvalues[i++] = runCode(arg);

                            }

                        }

                        value = function.call(this, argvalues);

                    }

                }

            } catch (Exception ex) {

                String argsstr = "???";

                try {

                    argsstr = args.toString();

                } catch(Exception ex2) {

                    // Ignore.

                }

                throw new RuntimeException("Problems calling function '"+function.name()+"' with args ("+argsstr+").", ex);

            }

            break;

        }

        this.currentCode = null;

        return value;

    }

    @Override

    public Code getCurrentCode() {

        return this.currentCode;

    }

}