Application: gvSIG desktop » Library: org.gvsig.tools

package org.gvsig.tools.arguments;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Date;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Objects;

import org.apache.commons.lang3.BooleanUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.tools.dataTypes.DataTypeUtils;

import static org.gvsig.tools.dataTypes.DataTypeUtils.coerce;

import org.gvsig.tools.dataTypes.DataTypes;

public class DefaultArguments implements Arguments {

    private final Object[] args;

    protected Map<String, Object> flags;

    protected List<Object> parameters;

    public DefaultArguments(Object args[]) {

        this.args = args;

        this.flags = new HashMap<>();

        this.parameters = new ArrayList<>();

        this.parse();

    }

    private void parse() {

        String name;

        Object value;

        boolean acceptFlags = true;

        String currentName = null;

        for( Object arg : args ) {

            if(currentName != null){

                this.flags.put(currentName.toLowerCase(), arg);

                currentName = null;

                continue;

            }

            if( acceptFlags ) {

                if( arg.equals("--") || !(arg instanceof String) ) {

                    acceptFlags = false;

                    continue;

                }

                String strArg = Objects.toString(arg);

                if( strArg.startsWith("--") ) {

                    int n = strArg.indexOf("=");

                    if( n < 0 ) {

                        name = strArg.substring(2);

                        value = true;

                        this.flags.put(name.toLowerCase(), value);

                    } else {

                        name = strArg.substring(2, n);

                        if(strArg.length()-1==n){

                            currentName = name;

                        } else {

                            value = strArg.substring(n + 1);

                            this.flags.put(name.toLowerCase(), value);

                        }

                    }

                } else {

                    this.parameters.add(arg);

                }

            } else {

                this.parameters.add(arg);

            }

        }

    }

    @Override

    public Object get(String name) {

        if(StringUtils.isBlank(name)){

            return null;

        }

        return this.flags.get(name.toLowerCase());

    }

    @Override

    public Object get(String name, Object defaultValue) {

        Object value = this.get(name);

        if( defaultValue == null ) {

            return value;

        }

        if( value == null || StringUtils.isBlank(Objects.toString(value, null)) ) {

            return defaultValue;

        }

        if( defaultValue instanceof CharSequence ) {

            return value;

        }

        if( defaultValue instanceof Integer ) {

            return DataTypeUtils.toInteger(value, (Integer) defaultValue);

        }

        if( defaultValue instanceof Long ) {

            return DataTypeUtils.toLong(value, (Long) defaultValue);

        }

        if( defaultValue instanceof Boolean ) {

            try {

                return DataTypeUtils.toBoolean(value, (Boolean) defaultValue);

            } catch(Throwable th) {

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

            }

        }

        if( defaultValue instanceof Double ) {

            return DataTypeUtils.toDouble(value, (Double) defaultValue);

        }

        if( defaultValue instanceof Float ) {

            return DataTypeUtils.toDouble(value, (Float) defaultValue);

        }

        if( defaultValue instanceof Date ) {

            return DataTypeUtils.toDate(value, (Date) defaultValue);

        }

        return value;

    }

    @Override

    public boolean contains(String name) {

        if(StringUtils.isBlank(name)){

            return false;

        }

        return this.flags.containsKey(name.toLowerCase());

    }

    @Override

    public boolean contains(String name, Object value) {

        if(StringUtils.isBlank(name)){

            return false;

        }

        Object x = this.flags.get(name.toLowerCase());

        if( x==null ) {

            return false;

        }

        if(value instanceof String && x instanceof String){

            return StringUtils.equalsIgnoreCase((String)value, (String)x);

        } 

        if(value instanceof Boolean){

            return value == DataTypeUtils.coerce(DataTypes.BOOLEAN, x, null);

        } 

        return Objects.equals(value, x);

    } 

    @Override

    public List<Object> parameters() {

        return Collections.unmodifiableList(parameters);

    }

    @Override

    public Map<String, Object> flags() {

        return Collections.unmodifiableMap(flags);

    }

    @Override

    public int size() {

        return this.parameters.size();

    }

    @Override

    public Object get(int n) {

        return this.parameters.get(n);

    }

    @Override

    public Iterator<Object> iterator() {

        return this.parameters.iterator();

    }

    @Override

    public Object get(int n, Class elementClass, Object defaultValue) {

        if(n >= this.parameters.size() || n < 0){

            return defaultValue;

        }

        Object o = this.parameters.get(n);

        if (elementClass.isInstance(o)) {

            return o;

        }

        return defaultValue;

    }

    @Override

    public List getListOf(int n, Class elementClass) {

        List list = (List) get(n, List.class, null);

        if (list == null) {

            return null;

        }

        if (list.isEmpty()) {

            return null;

        }

        if (elementClass.isInstance(list.get(0))) {

            return list;

        }

        return null;

    }

    @Override

    public Object get(String name, Class elementClass, Object defaultValue) {

        Object o = this.flags.get(name.toLowerCase());

        if (elementClass.isInstance(o)) {

            return o;

        }

        return defaultValue;

    }

    @Override

    public List getListOf(String name, Class elementClass) {

        List list = (List) get(name, List.class, null);

        if (list == null) {

            return null;

        }

        if (list.isEmpty()) {

            return null;

        }

        if (elementClass.isInstance(list.get(0))) {

            return list;

        }

        return null;

    }

}

package org.gvsig.tools.arguments;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

public interface Arguments extends Iterable<Object> {

    public static Arguments create(Object[] args) {

        return new DefaultArguments(args);

    }

    public Object get(String name);

    public Object get(String name, Object defaultValue);

    public boolean contains(String name);

    public boolean contains(String name, Object value);

    public Map<String,Object> flags();

    public List<Object> parameters();

    public int size();

    public Object get(int n);

    public Iterator<Object> iterator();

    /**

     * Return the element of the parameters if exists and if is of the type

     * indicated.If parameters is null, don't have the element indicated, or the

 element is not of the type required return null.

     *

     * @param n

     * @param elementClass

     * @param defaultValue

     * @return

     */

    public Object get(int n, Class elementClass, Object defaultValue);

    /**

     * Return the element of the parameters if this is a list of the indiqued

     * type. 

     * If parameters don't have elements, is null, not is a list, or the

     * elements of the list don't arent of the required type, return null.

     *

     * @param n

     * @param elementClass

     * @return

     */

    public List getListOf(int n, Class elementClass);

    /**

     * Return the element of the flags if exists and if is of the type

     * indicated. If flags is null, don't have the element indicated, or the

     * element is not of the type required return null.

     *

     * @param name

     * @param elementClass

     * @param defaultValue

     * @return

     */

    public Object get(String name, Class elementClass, Object defaultValue);

    /**

     * Return the element of the flags if this is a list of the indiqued

     * type. 

     * If flags don't have elements, is null, not is a list, or the

     * elements of the list don't arent of the required type, return null.

     *

     * @param name

     * @param elementClass

     * @return

     */

    public List getListOf(String name, Class elementClass);

}