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 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),

                "This function allows you to define functions within the expression evaluator.\n" +

                  "We can define three types of functions:\n" +

                  "\n<ul>" +

                  "<li>Functions defined in the evaluator itself.</li>\n" +

                  "<li>Functions implemented as a static method of a java class.</li>\n" +

                  "<li>Functions defined in an external script.</li>\n" +

                  "\n</ul>" +

                  "<b> Functions defined in the evaluator itself. </b>\n" +

                  "\n" +

                  "They have the form:\n" +

                  "\n" +

                  "<pre>\n" +

                  "CREATE PROCEDURE myfun param1 AS\n" +

                  "BEGIN\n" +

                  "  RETURN 'Hello' || param1;\n" +

                  "END PROCEDURE\n" +

                  "</pre>\n" +

                  "\n" +

                  "<b> Functions implemented as a static method </b>\n" +

                  "\n" +

                  "They allow defining a function that will invoke a static method of a java class.\n" +

                  "\n" +

                  "They have the form:\n" +

                  "\n" +

                  "<pre>\n" +

                  "CREATE FUNCTION getCRS (crs) AS 'org.gvsig.fmap.crs.CRSFactory', 'getCRS' LANGUAGE 'java'\n" +

                  "</pre>\n" +

                  "\n" +

                  "Defines the \"getCRS\" function that receives a single parameter, and links it to the method\n" +

                  "static 'getCRS' of class 'org.gvsig.fmap.crs.CRSFactory',\n" +

                  "\n" +

                  "<b> Functions defined in an external script. </b>\n" +

                  "\n" +

                  "It allows defining functions that are implemented in an external script module.\n" +

                  "\n" +

                  "They have the form:\n" +

                  "\n" +

                  "<pre>\n" +

                  "CREATE FUNCTION getCRS (crs) AS 'scripts / crs.py', 'getCRS' LANGUAGE 'python'\n" +

                  "</pre>\n" +

                  "\n" +

                  "What defines a \"getCRS\" function that is implemented in the python module\n" +

                  "located in \"Users / crs\" with the name 'getCRS'.",

                null,

                null,

                "Object",

                false

        );

    }

    @Override

    public boolean isHidden() {

      return false;

    }

    @Override

    public boolean useArgumentsInsteadObjects() {

        return true;

    }

    @Override

    public boolean allowConstantFolding() {

        return false;

    }

    @Override

    public boolean allowArgNames() {

      return true;

    }

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

        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 = (String) getObject(interpreter, args, "FUNCTION_NAME");

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

        Code body = args.get("BODY");

        String script_path = (String) getObject(interpreter, args, "SCRIPT_PATH");

        String script_function = (String) getObject(interpreter, args, "SCRIPT_FUNCTION");

        String language = (String) getObject(interpreter, args, "LANGUAGE");

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

          return true;

        }

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

        }

    }

}