Application: gvSIG desktop

package org.gvsig.expressionevaluator.impl.function.programming;

import java.lang.reflect.Method;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.Objects;

import org.apache.commons.lang3.Range;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.Codes;

import org.gvsig.expressionevaluator.Function;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.ExpressionRuntimeException;

import org.gvsig.expressionevaluator.MutableSymbolTable;

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

import org.gvsig.tools.script.Script;

import org.gvsig.tools.script.ScriptManager;

public class CreateFnFunction extends AbstractFunction {

    public static final String NAME = "CREATE_FUNCTION";

    public CreateFnFunction() {

        super(Function.GROUP_PROGRAMMING, 

                NAME, 

                Range.between(2, 6),

                null,

                null,

                null,

                "Object",

                false

        );

    }

    @Override

    public boolean useArgumentsInsteadObjects() {

        return true;

    }

    @Override

    public boolean allowConstantFolding() {

        return false;

    }

    @Override

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

        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

    }

    @Override

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

        // FNAME, PARAM-NAMES, BODY

        if( !(interpreter.getSymbolTable() instanceof MutableSymbolTable) ) {

            throw new ExpressionRuntimeException("The use of user functions require a mutable symbol table.");

        }

        MutableSymbolTable symbolTable = (MutableSymbolTable) interpreter.getSymbolTable();

        String name;

        List<String> argNames;

        Code body = null;

        String script_path = null;

        String script_function = null;

        String language = null;

        // name, body

        // name, args, body

        // name, script_name, script_func, lang

        // name, args, script_name, script_func, lang

        switch(args.size()) {

            case 2:

                name = (String) getObject(interpreter, args, 0);

                argNames = null;

                body = args.get(1);

                break;

            case 3:

                name = (String) getObject(interpreter, args, 0);

                if( args.get(1)==null ) {

                    argNames = null;

                } else {

                    argNames = (List<String>) getObject(interpreter, args, 1);

                }

                body = args.get(2);

                break;

            case 6:

                name = (String) getObject(interpreter, args, 0);

                if( args.get(1)==null ) {

                    argNames = null;

                } else {

                    argNames = (List<String>) getObject(interpreter, args, 1);

                }

                body = args.get(2);

                script_path = (args.get(3)==null)? null:((String)((Code.Constant)args.get(3)).value());

                script_function = (args.get(4)==null)? null:((String)((Code.Constant)args.get(4)).value());

                language = (args.get(5)==null)? null:((String)((Code.Constant)args.get(5)).value()).toLowerCase();

                break;

            default:

                throw new ExpressionRuntimeException("Incorrect number of arguments");

        }

        Function fn;

        if( body!=null ) {

            fn = new UserFunction(name, argNames, body);

            symbolTable.addFunction(fn);

            return fn;

        }

        if( StringUtils.isBlank(script_path) || StringUtils.isBlank(script_function) ) {

            throw new ExpressionRuntimeException("boydy and, script path or script function, are empty.");

        }

        if( StringUtils.isBlank(language) ) {

            language = "script";

        }

        switch(language.toLowerCase()) {

            case "script":

                fn = new ExternalFunction(name, script_path, script_function);

                symbolTable.addFunction(fn);

                return fn;

            case "java":

                fn = new JavaFunction(name, script_path, script_function);

                symbolTable.addFunction(fn);

                return fn;

        }

        throw new ExpressionRuntimeException("Unsupported language '"+language+".");

    }

    private static class UserFunction extends AbstractFunction {

        private final Code body;

        private final List<String> argNames;

        public UserFunction(String name, List<String> argNames, Code body) {

            super(GROUP_OTHER, name, Range.between(0, Integer.MAX_VALUE));

            this.argNames = argNames;

            this.body = body;

        }

        @Override

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

            Object value;

            ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

            MutableSymbolTable localSymbolTable = manager.createSymbolTable();

            List $args = new ArrayList();

            if( args != null ) {

                $args.addAll(Arrays.asList(args));

            }

            localSymbolTable.setVar("$ARGS", $args);

            int max;

            if( this.argNames==null ) {

                max = 0;

            } else {

                max = Math.min(this.argNames.size(), args.length);

            }

            for (int i = 0; i < max; i++) {

                localSymbolTable.setVar(this.argNames.get(i), args[i]);

            }

            SymbolTable savedSymbolTable = interpreter.getSymbolTable();

            localSymbolTable.addSymbolTable(savedSymbolTable);

            try {

                interpreter.setSymbolTable(localSymbolTable);

                value = interpreter.run(this.body);

            } finally {

                interpreter.setSymbolTable(savedSymbolTable);

            }

            return value;

        }

    }

    private static class ExternalFunction extends AbstractFunction {

        private final String script_path;

        private final String script_function;

        private final Script script;

        public ExternalFunction(String name, String script_path, String script_function) {

            super(GROUP_OTHER, name, Range.between(0, Integer.MAX_VALUE));

            this.script_path = script_path;

            this.script_function = script_function;

            ScriptManager scriptManager = ToolsLocator.getScriptManager();

            ExpressionEvaluatorManager expressionManager = ExpressionEvaluatorLocator.getExpressionEvaluatorManager();

            ResourcesStorage resourcesStorage = expressionManager.getScriptsResourcesStorage();

            this.script = scriptManager.loadScript(resourcesStorage, script_path);

            if( this.script == null ) {

                throw new ExpressionRuntimeException("Can't locate '"+this.script_path+"'.");

            }

        }

        @Override

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

            Object r = this.script.invokeFunction(this.script_function, args);

            return r;

        }

    }

    private static class JavaFunction extends AbstractFunction {

        private final String fullClassName;

        private final String methodName;

        public JavaFunction(String name, String fullClassName, String methodName) {

            super(GROUP_OTHER, name, Range.between(0, Integer.MAX_VALUE));

            this.fullClassName = fullClassName;

            this.methodName = methodName;

        }

        @Override

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

            Class[] parameterTypes = new Class[args.length];

            for (int i = 0; i < args.length; i++) {

                if( args[i]==null ) {

                    parameterTypes[i] = null;

                } else {

                    parameterTypes[i] = args[i].getClass();

                }

            }

            Class<?> theClass = Class.forName(this.fullClassName);

            Method method = theClass.getMethod(this.methodName, parameterTypes);

            Object value = method.invoke(null, args);

            return value;

        }

    }

}