Application: gvSIG desktop

package org.gvsig.expressionevaluator.spi;

import java.io.InputStream;

import java.net.URL;

import java.util.ArrayList;

import java.util.List;

import java.util.Locale;

import java.util.Objects;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.BooleanUtils;

import org.apache.commons.lang3.Range;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.math.util.MathUtils;

import org.gvsig.expressionevaluator.Code;

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

import org.gvsig.expressionevaluator.Function;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.primitive.Point;

import org.json.JSONArray;

import org.json.JSONObject;

@SuppressWarnings("UseSpecificCatch")

public abstract class AbstractFunction implements Function {

    private final String name;

    private String group;

    private Range argc;

    private String description;

    private String[] descriptionArgs;

    private List<String> alias;

    private String template;

    private String returnType;

    private boolean sqlCompatible;

    protected AbstractFunction(String group, String name, Range argc, String description, String template, String[] descriptionArgs, String returnType, boolean sqlCompatible) {

        this.name = name;

        this.group = group;

        this.argc = argc;

        this.description = description;

        this.template = template;

        this.descriptionArgs = descriptionArgs;

        this.returnType = returnType;

        this.sqlCompatible = sqlCompatible;

        load_from_resource();

    }

    protected AbstractFunction(String group, String name, Range argc, String description, String template, String[] descriptionArgs, String returnType) {

        this(group, name, argc, description, template, descriptionArgs, returnType, false);

    }

    protected AbstractFunction(String group, String name, Range argc, String description, String template, String[] descriptionArgs) {

        this(group, name, argc, description, template, null, null);

    }

    protected AbstractFunction(String group, String name, Range argc, String description, String template) {

        this(group, name, argc, description, template, null, null);

    }

    protected AbstractFunction(String group, String name, Range argc) {

        this(group, name, argc, null, null, null, null);

    }

    @Override

    public String name() {

        return this.name;

    }

    @Override

    public String returnType() {

        return this.returnType;

    }

    @Override

    public String group() {

        return this.group;

    }

    @Override

    public Range argc() {

        return argc;

    }

    @Override

    public String description() {

        return description;

    }

    @Override

    public String[] descriptionArgs() {

        return descriptionArgs;

    }

    @Override

    public void addAlias(String name) {

        if( StringUtils.isBlank(name) ) {

            return;

        }

        if( this.alias == null ) {

            this.alias = new ArrayList<>();

        }

        if( this.alias.contains(name) ) {

            return;

        }

        this.alias.add(name);

    }

    @Override

    public List<String> alias() {

        return this.alias;

    }

    @Override

    public String template() {

        return this.template;

    }

    @Override

    public boolean isOperator() {

        return false;

    }

    @Override

    public boolean useArgumentsInsteadObjects() {

        return false;

    }

    @Override

    public boolean isSQLCompatible() {

        return sqlCompatible;

    }

    @Override

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

        return null;

    }

    protected int getInt(Object args[], int n) {

        if( args.length < n  ) {

            throw new IllegalArgumentException("Required argument "+n+" and only found " + args.length +" arguments in call to '"+name()+"'.");

        }

        if( !(args[n] instanceof Number) ) {

            String type = (args[n]==null)? "null" : args[n].getClass().getCanonicalName();

            throw new IllegalArgumentException("Type not allowed for argument " + n + " in '" + name() + "' function, expected Number and got " + type + ".");

        }

        return ((Number)args[n]).intValue();

    }

    protected long getLong(Object args[], int n) {

        if( args.length < n  ) {

            throw new IllegalArgumentException("Required argument "+n+" and only found " + args.length +" arguments in call to '"+name()+"'.");

        }

        if( !(args[n] instanceof Number) ) {

            String type = (args[n]==null)? "null" : args[n].getClass().getCanonicalName();

            throw new IllegalArgumentException("Type not allowed for argument " + n + " in '" + name() + "' function, expected Number and got " + type + ".");

        }

        return ((Number)args[n]).longValue();

    }

    protected double getDouble(Object args[], int n) {

        if( args.length < n  ) {

            throw new IllegalArgumentException("Required argument "+n+" and only found " + args.length +" arguments in call to '"+name()+"'.");

        }

        if( !(args[n] instanceof Number) ) {

            String type = (args[n]==null)? "null" : args[n].getClass().getCanonicalName();

            throw new IllegalArgumentException("Type not allowed for argument " + n + " in '" + name() + "' function, expected Number and got " + type + ".");

        }

        return ((Number)args[n]).doubleValue();

    }

    protected String getStr(Object args[], int n) {

        if( args.length < n  ) {

            throw new IllegalArgumentException("Required argument "+n+" and only found " + args.length +" arguments in call to '"+name()+"'.");

        }

        return Objects.toString(args[n], "");

    }

    protected Object getObject(Object args[], int n) {

        if( args.length < n  ) {

            throw new IllegalArgumentException("Required argument "+n+" and only found " + args.length +" arguments in call to '"+name()+"'.");

        }

        return args[n];

    }

    protected Object getObject(Interpreter interpreter, Arguments args, int n) {

        if( args.count() < n  ) {

            throw new IllegalArgumentException("Required argument "+n+" and only found " + args.count() +" arguments in call to '"+name()+"'.");

        }

        Code arg = args.get(n);

        Object value = interpreter.run(arg);

        return value;

    }

    protected Geometry getGeom(Object[] args, int n) {

        if( args.length < n  ) {

            throw new IllegalArgumentException("Required argument "+n+" and only found " + args.length +" arguments in call to '"+name()+"'.");

        }

        if( !(args[n] instanceof Geometry) ) {

            String type = (args[n]==null)? "null" : args[n].getClass().getCanonicalName();

            throw new IllegalArgumentException("Type not allowed for argument " + n + " in '" + name() + "' function, expected Geometry and got " + type + ".");

        }

        return (Geometry)args[n];

    }

    protected Point getPoint(Object[] args, int n) {

        if( args.length < n  ) {

            throw new IllegalArgumentException("Required argument "+n+" and only found " + args.length +" arguments in call to '"+name()+"'.");

        }

        if( !(args[n] instanceof Point) ) {

            String type = (args[n]==null)? "null" : args[n].getClass().getCanonicalName();

            throw new IllegalArgumentException("Type not allowed for argument " + n + " in '" + name() + "' function, expected Point and got " + type + ".");

        }

        return (Point)args[n];

    }

    protected boolean getBoolean(Object args[], int n, Double accuracy) {

        if( args.length < n  ) {

            throw new IllegalArgumentException("Required argument "+n+" and only found " + args.length +" arguments in call to '"+name()+"'.");

        }

        Object value = args[n];

        return toBoolean(value, accuracy);

    }

    protected boolean getBoolean(Interpreter interpreter, Arguments args, int n) {

        Object value = getObject(interpreter, args, n);

        return toBoolean(value, interpreter.getAccuracy());

    }

    protected boolean toBoolean(Object value, Double accuracy) {

        if( value == null ) {

            return false;

        }

        if( value instanceof Boolean ) {

            return (Boolean)value;

        }        

        if( value instanceof Number ) {

            return MathUtils.compareTo(

                ((Number) value).doubleValue(), 

                0,

                accuracy==null? MathUtils.EPSILON:accuracy

            ) == 0;

        }

        return BooleanUtils.toBoolean(value.toString());

    } 

    private void load_from_resource() {

        String lang = Locale.getDefault().getLanguage();

        URL url = this.getClass().getResource("/org/gvsig/expressionevaluator/functions/"+lang+"/"+this.name()+".json");

        if( url == null ) {

            url = this.getClass().getResource("/org/gvsig/expressionevaluator/functions/en/"+this.name()+".json");

            if( url == null ) {

                return;

            }

        }

        InputStream is = null;

        JSONObject json;

        try {

            is = url.openStream();

            List<String> lines = IOUtils.readLines(is);

            json = new JSONObject(StringUtils.join(lines,  "\n"));

        } catch (Exception ex) {

            return;

        } finally {

            IOUtils.closeQuietly(is);

        }

        if( json.has("group") ) {

            this.group = json.getString("group");

        }

        if( json.has("description") ) {

            Object x = json.get("description");

            if( x instanceof String ) {

                this.description = (String) x;

            } else if( x instanceof JSONArray ) {

                StringBuilder builder = new StringBuilder();

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

                    if( i>0 ) {

                        builder.append(" ");

                    }

                    builder.append(((JSONArray)x).getString(i));

                }

                this.description = builder.toString();

            } else {

                this.description = x.toString();

            }

            this.description = StringUtils.replace(

                    this.description, 

                    "@@@", 

                    url.toString()

            );

        }

        if( json.has("template") ) {

            this.template = json.getString("template");

        }

        if( json.has("returnType") ) {

            this.returnType = json.getString("returnType");

        }

        if( json.has("sqlCompatible") ) {

            this.sqlCompatible = json.getBoolean("sqlCompatible");

        }

        if( json.has("args") ) {

            JSONArray x = json.getJSONArray("args");

            String[] args = new String[x.length()];

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

                args[i] = x.getString(i);

            }

            this.descriptionArgs = args;

        }

        if( json.has("alias") ) {

            JSONArray x = json.getJSONArray("alias");

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

                this.addAlias(x.getString(i));

            }

        }

    }

}