Application: gvSIG desktop

package org.gvsig.expressionevaluator.spi;

import java.util.ArrayList;

import java.util.List;

import java.util.Objects;

import org.apache.commons.lang3.BooleanUtils;

import org.apache.commons.lang3.Range;

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;

public abstract class AbstractFunction implements Function {

    private final String name;

    private final String group;

    private final Range argc;

    private final String description;

    private final String[] descriptionArgs;

    private List<String> alias;

    private String template;

    private String returnType;

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

        this.name = name;

        this.group = group;

        this.argc = argc;

        this.description = description;

        this.template = template;

        this.descriptionArgs = descriptionArgs;

        this.returnType = returnType;

    }

    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( this.alias == null ) {

            this.alias = new ArrayList<>();

        }

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

    } 

}