Application: gvSIG desktop » gvSIG raster

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

package org.gvsig.raster.wms.io.time;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

/**

 * This class instances a regular WMS dimension. It handles single, multiple and

 * interval values and uses them as they were a point, a list or a regularly

 * split line, respectivelly.<br>

 * <p>

 * As far as it implements RemoteTimeDimension it uses the same interface and

 * documentation.

 * </p>

 * @author jaume dominguez faus (jaume.dominguez@iver.es)

 *

 */

public class DefaultDimension implements RemoteTimeDimension {

        static private final String digit = "[0-9]";

    static private final String nonZeroDigit = "[1-9]";

    static private final String letter = "[_$%a-zA-Z]";

    static private final String word = letter+"("+letter+"|"+digit+")+"; // TODO Should be * instead of + ??

    static private final String floatingPointNumber = "("+digit+"+(\\."+digit+"+)?)";

    static private final String integerNumber = nonZeroDigit+digit+"+";

    static private final String dimensionItem = "("+floatingPointNumber+"|"+word+")";

    /**

     * regular expression for matching dimensions.

     */

    static private final String regexpDefaultDimensionExpression =

            "("+floatingPointNumber+"/"+floatingPointNumber+"/"+floatingPointNumber+"|"+

                dimensionItem+"(,"+dimensionItem+")*)";

        private String name;

    private String unit;

    private String unitSymbol;

    private String expression;

    private String period;

    private Object minValue;

    private Object maxValue;

        private int type;

        private boolean compiled = false;

        public void loadFromState(PersistentState state) throws PersistenceException {

                this.name = state.getString("name");

                this.unit = state.getString("unit");

                this.unitSymbol = state.getString("unitSymbol");

                this.expression = state.getString("expression");

                this.period = state.getString("period");

                this.minValue = state.getString("minValue");

                this.maxValue = state.getString("maxValue");

                this.type = state.getInt("type");

                this.compiled = state.getBoolean("compiled");

        }

        public void saveToState(PersistentState state) throws PersistenceException {

                state.set("name", name);

                state.set("unit", unit);

                state.set("unitSymbol", unitSymbol);

                state.set("expression", expression);

                state.set("period", period);

                state.set("minValue", minValue);

                state.set("maxValue", maxValue);

                state.set("type", type);

                state.set("compiled", compiled);

        }        

        public static void registerPersistent() {

                PersistenceManager manager = ToolsLocator.getPersistenceManager();

                DynStruct definition = manager.getDefinition("DefaultDimension_Persistent");

                if( definition == null ) {

                        definition = manager.addDefinition(

                                        DefaultDimension.class,

                                        "DefaultDimension_Persistent",

                                        "DefaultDimension Persistence",

                                        null, 

                                        null

                        );

                }

                definition.addDynFieldString("name").setMandatory(false);

                definition.addDynFieldString("unit").setMandatory(false);

                definition.addDynFieldString("unitSymbol").setMandatory(false);

                definition.addDynFieldString("expression").setMandatory(false);

                definition.addDynFieldString("period").setMandatory(false);

                definition.addDynFieldString("minValue").setMandatory(false);

                definition.addDynFieldString("maxValue").setMandatory(false);

                definition.addDynFieldInt("type").setMandatory(false);

                definition.addDynFieldBoolean("compiled").setMandatory(false);

        }

        public DefaultDimension() {}

    /**

     * Creates a new instance of DefaultDimension.

     * @param _name

     * @param _units

     * @param _unitSymbol

     * @param _dimensionExpression

     */

    public DefaultDimension(String _name, String _units, String _unitSymbol, String _dimensionExpression) {

            this.name = _name;

            this.unit = _units;

            this.unitSymbol = _unitSymbol;

            setExpression(_dimensionExpression);

    }

    public String getName() {

                return name;

        }

        public String getUnit() {

                return unit;

        }

        public String getUnitSymbol() {

                return unitSymbol;

        }

        public String getLowLimit() {

                return (String) minValue;

        }

        public String getHighLimit() {

                return (String) maxValue;

        }

        public String getResolution() {

                if (type == INTERVAL) {

                    String[] s = expression.split("/");

                    return (s.length == 1) ? s[3] : null;

            } else return null;

        }

        public boolean isValidValue(String value) {

                return value.matches(word) || value.matches(floatingPointNumber);

        }

        public Object valueOf(String value) throws IllegalArgumentException {

                if (compiled) {

                        if (value.matches(word)) {

                                return (String) value;

                        } else if (value.matches(integerNumber)){

                                return new Integer(value);

                        }

                        else if (value.matches(floatingPointNumber)) {

                                return new Float(value);

                        }

                }

                return null;

        }

        public String valueAt(int pos) throws ArrayIndexOutOfBoundsException {

                if (compiled) {

                        if (pos<0 || pos>valueCount())

                                throw new ArrayIndexOutOfBoundsException(pos+"(must be >= 0 and <="+valueCount()+")");

                        if (type == SINGLE_VALUE)

                                return expression;

                        if (type == MULTIPLE_VALUE)

                                return expression.split(",")[pos];

                        if (type == INTERVAL) {

                                double minPos = Double.parseDouble((String) minValue);

                                double maxPos = Double.parseDouble((String) maxValue);

                                double step = Double.parseDouble(period);

                                double newPos = minPos + (step*pos);

                                if (newPos < minPos)

                                        return minPos+"";

                                if (newPos > maxPos)

                                        return maxPos+"";

                                return newPos+"";

                        }

                }

        return null;

        }

        public int valueCount() {

                if (compiled) {

                        if (type == MULTIPLE_VALUE) {

                                return expression.split(",").length;

                        } else if (type == INTERVAL) {

                                int count;

                                double min = Double.parseDouble((String) minValue);

                                double max = Double.parseDouble((String) maxValue);

                                double step = Double.parseDouble(period);

                                double distance = max - min;

                                count = (int) (distance/step);

                                return count;

                        } else {

                                return 1;

                        }

                }

                return -1;

        }

        public String getExpression() {

                return expression;

        }

        public void setExpression(String expr) {

                expression = expr.toUpperCase();

        }

        public int getType() {

                return type;

        }

        public void compile() throws IllegalArgumentException {

                if (expression.matches(regexpDefaultDimensionExpression)){

        } else {

            //System.err.println("Invalid dimension expression: "+expr+" (for "+this.getName()+")");

            throw new IllegalArgumentException();

        }

        String separator;

        if (expression.indexOf("/")!=-1) {

                separator = "/";

                type = INTERVAL;

        } else if (expression.indexOf(",")!=-1) {

                separator = ",";

                type = MULTIPLE_VALUE;

        } else {

                separator = ",";

                type = SINGLE_VALUE;

        }

        compiled = true;

        String[] s = expression.split(separator);

        minValue = valueOf(s[0]);

        if (type == INTERVAL) {

                maxValue = (s.length>1) ? valueOf(s[1]) : valueOf(s[0]);

                period = (s.length>2) ? s[2] : null;

        } else if (type == MULTIPLE_VALUE) {

                maxValue = valueOf(s[s.length-1]);

        } else {

                maxValue = valueOf(s[0]);

        }

        }

}