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;

@SuppressWarnings("UseSpecificCatch")

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 parseInt(value) AS 'java.lang.Integer', 'parseInt' LANGUAGE 'java'\n" +

                  "</pre>\n" +

                  "\n" +

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

                  "static 'parseInt' of the class 'java.lang.Integer',\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 'crs.py', 'getCRS' LANGUAGE 'script'\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'.",

                "CREATE FUNCTION {{name}}(param1, param2) AS\nBEGIN\n  PASS\nEND FUNCTION\n",

                null,

                "Object",

                false

        );

    }

    @Override

    public boolean isHidden() {

      return 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.

    }

    private static final int FUNCTION_NAME = 0;

    private static final int PARAMETERS = 1;

    private static final int BODY = 2;

    private static final int SCRIPT_PATH = 3;

    private static final int SCRIPT_FUNCTION = 4;

    private static final int LANGUAGE = 5;

    private static final int TYPE_USER_FUNCTION = 0;

    private static final int TYPE_JAVA_FUNCTION = 1;

    private static final int TYPE_SCRIPT_FUNCTION = 2;

    @Override

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

        if( args.size()==2 ) {

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

            Code body = args.get(1);

            Function fn = new UserFunction("", argNames, body);

            return fn;

        }

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

        if( StringUtils.isBlank(language) ) {

            language = "script";

        }

        int type = TYPE_USER_FUNCTION;

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

          switch(language.toLowerCase()) {

              case "script":

                type = TYPE_SCRIPT_FUNCTION;

                break;

              case "java":

                type = TYPE_JAVA_FUNCTION;

                break;

              default:

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

          }

        }

        Function fn = null;

        switch(type) {

          case TYPE_USER_FUNCTION:

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

            symbolTable.addFunction(fn);

            break;

          case TYPE_JAVA_FUNCTION:

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

                throw new ExpressionRuntimeException("Requiered classname and methodname.");

            }

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

            symbolTable.addFunction(fn);

            break;

          case TYPE_SCRIPT_FUNCTION:

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

                throw new ExpressionRuntimeException("Requiered module and function name.");

            }

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

            symbolTable.addFunction(fn);

            break;

        }

        return fn;

    }

    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 {

            List<ClassLoader> loaders = ExpressionEvaluatorLocator.getManager().getClassLoaders();

            Class<?> theClass = null;

            for (ClassLoader loader : loaders) {

              try {

                theClass = loader.loadClass(this.fullClassName);

                if( theClass!=null ) {

                  break;

                }

              } catch(Throwable th) {

                // Do nothing skip

              }

            }

            if( theClass == null ) {

              throw new ExpressionRuntimeException("Can't localte the class '"+this.fullClassName+"'.");

            }

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

                }

            }

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

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

            return value;

        }

    }

}