Application: gvSIG desktop

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

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import org.apache.commons.lang3.Range;

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;

public class CreateFnFunction extends AbstractFunction {

    public static final String NAME = "CREATE_FUNCTION";

    public CreateFnFunction() {

        super(Function.GROUP_PROGRAMMING, 

                NAME, 

                Range.between(2, 3),

                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;

        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;

            default:

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

        }

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

        symbolTable.addFunction(fn);

        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;

        }

    }

}