Application: gvSIG desktop

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2005 IVER T.I. and Generalitat Valenciana.

 *

 * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

/* CVS MESSAGES:

*

* $Id: TimeDimension.java 3537 2006-01-05 23:15:59Z jaume $

* $Log$

* Revision 1.1.2.4  2006-01-05 23:15:53  jaume

* *** empty log message ***

*

* Revision 1.1.2.3  2006/01/04 18:09:02  jaume

* Time dimension

*

* Revision 1.1.2.2  2006/01/04 16:49:44  jaume

* Time dimensios

*

* Revision 1.1.2.1  2006/01/03 18:08:40  jaume

* *** empty log message ***

*

*

*/

/**

 * 

 */

package com.iver.cit.gvsig.fmap.layers;

import java.util.GregorianCalendar;

/**

 * @author jaume

 *

 */

public class TimeDimension implements IFMapWMSDimension {

    static private final long millisXsec    = 1000;

    static private final long millisXminute = 60 * millisXsec;

    static private final long millisXhora   = 60 * millisXminute;

    static private final long millisXdia    = 24 * millisXhora;

    static private final long millisXmes    = 30 * millisXdia;

    static private final long millisXanyo   = 365 * millisXdia;

    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 seconds = "([0-5]"+digit+"((\\.|,)"+digit+digit+")?)";

    static private final String minutes = "([0-5]"+digit+")";

    static private final String hours = "(0"+digit+"|1"+digit+"|2[0-3])";

    static private final String time = hours+":"+minutes+"(:"+seconds+")?";

    static private final String days = "(0"+nonZeroDigit+"|1"+digit+"|2"+digit+"|30|31)";

    static private final String months = "(0"+nonZeroDigit+"|10|11|12)";

    static private final String year = "("+digit+digit+")";

    static private final String century = "("+digit+digit+")";

    static private final String geologicDatasets = "(K|M|G)";

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

    static private final String regexDateExtendedForBCE1 = "B?"+century+year;

    static private final String regexDateExtendedForBCE2 = "B?"+century+year+"-"+months;

    static private final String regexDateExtendedForBCE3 = "B?"+century+year+"-"+months+"-"+days;

    static private final String regexDateExtendedForBCE4 = "B?"+century+year+"-"+months+"-"+days+"(T| )"+time+"Z";

    // Note: in WMS 1.1.0 the suffix Z is optional

    // TODO truncated values not yet allowed

    static private final String regexDateExtendedForBCE = 

        "(" +  regexDateExtendedForBCE1  + "|"

            +  regexDateExtendedForBCE2  + "|"

            +  regexDateExtendedForBCE3  + "|"

            +  regexDateExtendedForBCE4  +      ")";

    static private final String regexDateForGeologicDatasets = geologicDatasets+floatingPointNumber;

    static private final String periodMagnitude = "(Y|M|D)";

    static private final String p1 = "(("+digit+")+"+periodMagnitude+")";

    static private final String timeMagnitude = "(H|M|S)";

    static private final String p2 = "("+floatingPointNumber+timeMagnitude+")";

    static private final String regexPeriod = "P(("+p1+"+"+"(T"+p2+")*)|("+p1+"*"+"(T"+p2+")+))"; 

    static private final String regexTimeDimension =

        "("+regexDateExtendedForBCE3+")/("+regexDateExtendedForBCE3+")/("+regexPeriod+")";

    private String name = "TIME";

    private String unit;

    private String unitSymbol;

    private String dimensionExpression;

    private Object minValue;

    private Object maxValue;

    private boolean isGeologic = false;

    private Integer valueCount;

    private String period;

    private long step; // Distance between two points in milliseconds.

    /**

     * Creates a new instance of TimeDimension.

     * @param units

     * @param unitSymbol

     * @param dimensionExpression

     */

    public TimeDimension(String _units, String _unitSymbol, String _dimensionExpression) {

        this.unit = _units;

        this.unitSymbol = _unitSymbol;

        this.dimensionExpression = _dimensionExpression;

    }

    public String getName() {

        return name;

    }

    public String getUnit() {

        return unit;

    }

    public String getUnitSymbol() {

        return unitSymbol;

    }

    public String getLowLimit() {

        return dimensionExpression.split("/")[0];

    }

    public String getHighLimit() {

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

        return (s.length > 1) ? s[1] : s[0];

    }

    public String getResolution() {

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

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

    }

    public boolean isValidValue(String value) {

        return (value.matches(regexDateForGeologicDatasets) || value.matches(regexDateExtendedForBCE));

    }

    public Object valueOf(String value) throws IllegalArgumentException {

//      TODO Missing geological dates

        String myValue = value.toUpperCase();

        if (isValidValue(myValue)) {

            Object val = null;

            if (myValue.matches(regexDateExtendedForBCE)){

                // This is a normal date

                int myYear;

                int myMonth;

                int myDay;

                int myHour;

                int myMinute;

                float mySecond;

                String[] s = myValue.split("-");

                myYear = (s[0].charAt(0)=='B')? -Integer.parseInt(s[0].substring(1, 5)) : Integer.parseInt(s[0].substring(0, 4));

                myMonth = (s.length>1) ? Integer.parseInt(s[1])-1 : 0; 

                if (myValue.matches(regexDateExtendedForBCE4)){

                    s = (s[2].indexOf('T')!=-1) ? s[2].split("T") : s[2].split(" ");

                    myDay = Integer.parseInt(s[0]);

                    // Go with the time

                    s = s[1].split(":");

                    myHour = Integer.parseInt(s[0]);

                    myMinute = (s.length>1) ? Integer.parseInt(s[1]) : 0;

                    mySecond = (s.length>2) ? Float.parseFloat(s[2].substring(0, s[2].length()-2)) : 0;

                } else {

                    myDay = (s.length>2) ? Integer.parseInt(s[2]) : 1;

                    myHour = 0;

                    myMinute = 0;

                    mySecond = 0;

                }

                GregorianCalendar cal = new GregorianCalendar(myYear, myMonth, myDay, myHour, myMinute, (int)mySecond);

                val = cal;

            } else{

                // this is a geological date >:-(

            }

            return val;    

        } else throw new IllegalArgumentException(myValue);

    }

    public String valueAt(int pos) throws ArrayIndexOutOfBoundsException {

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

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

        if (!isGeologic){

            long newTime = ((GregorianCalendar) minValue).getTimeInMillis();

            newTime += (step*pos);

            GregorianCalendar cal = new GregorianCalendar();

            cal.setTimeInMillis(newTime);

            if (cal.after(maxValue))

                return toString((GregorianCalendar) maxValue);

            else if (cal.before(minValue))

                return toString((GregorianCalendar) minValue);

            else

                return toString(cal);

        }

        return null;

    }

    /**

     * Prints a GregorianCalendar value in WMS1.1.1 format.

     * @param cal

     * @return

     */

    private String toString(GregorianCalendar cal) {

        int iYear   = cal.get(cal.YEAR);

        int iMonth  = cal.get(cal.MONTH) + 1;

        int iDay    = cal.get(cal.DAY_OF_MONTH);

        int iHour   = cal.get(cal.HOUR_OF_DAY);

        int iMinute = cal.get(cal.MINUTE);

        int iSecond = cal.get(cal.SECOND);

        String myYear;

        if (iYear<10)

            myYear = "200"+iYear;

        else if (iYear<100)

            myYear = "20"+iYear;

        else if (iYear<1000)

            myYear = "2"+iYear;

        else

            myYear = ""+iYear;

        String myMonth       = (iMonth<10) ? "0"+iMonth  : ""+iMonth;

        String myDay         = (iDay<10)   ? "0"+iDay    : ""+iDay;

        String myHour        = (iHour<10)  ? "0"+iHour   : ""+iHour;

        String myMinute      = (iMinute<10)? "0"+iMinute : ""+iMinute;

        String mySecond      = (iSecond<10)? "0"+iSecond : ""+iSecond;

        int myMilliSecond = cal.get(cal.MILLISECOND);

        String s = myYear+"-"+myMonth+"-"+myDay+"T"+myHour+":"+myMinute+":"+mySecond+"."+(myMilliSecond/10)+"Z";

        if (iYear<0)

            s = "B"+s;

        return s;

    }

    public int valueCount() {

        if (valueCount==null){

            if (period == null) return 0;

            if (!isGeologic){

                long x1 = ((GregorianCalendar) maxValue).getTimeInMillis();

                long x0 = ((GregorianCalendar) minValue).getTimeInMillis();

                long distance = x1-x0;

                step = 0;

                boolean isTimeField = false;

                String val = "";

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

                    if (period.charAt(i) == 'P')

                        continue;

                    if (period.charAt(i) == 'T'){

                        isTimeField = true;

                        continue;

                    }

                    switch (period.charAt(i)){

                        case 'Y':

                            step += Integer.parseInt(val) * millisXanyo;

                            val = "";

                            break;

                        case 'M':

                            if (isTimeField)

                                step += Integer.parseInt(val) * millisXminute;

                            else

                                step += Integer.parseInt(val) * millisXmes;

                            val = "";

                            break;

                        case 'D':

                            step += Integer.parseInt(val) * millisXdia;

                            val = "";

                            break;

                        case 'H':

                            step += Integer.parseInt(val) * millisXhora;

                            val = "";

                            break;

                        case 'S':

                            step += Integer.parseInt(val) * 1000;

                            val = "";

                            break;

                        default:

                            val += period.charAt(i);

                            break;

                    }                       

                }

                valueCount = new Integer((int)(distance/step));

            }

        }

        return valueCount.intValue();

    }

//    public Object nextValueTo(String value) throws IllegalArgumentException {

//        if (isValidValue(value)){

//            

//            return null;

//        } else throw new IllegalArgumentException(value);

//    }

//

//    public Object previousValueTo(String value) throws IllegalArgumentException {

//        if (isValidValue(value)){

//            

//            return null;

//        } else throw new IllegalArgumentException(value);

//    }

    public void setExpression(String expr) throws IllegalArgumentException {

        dimensionExpression = expr.toUpperCase();

        if (dimensionExpression.matches(regexDateForGeologicDatasets)){

            isGeologic = true;

        } else if (dimensionExpression.matches(regexTimeDimension)){

            isGeologic = false;

        } else if (dimensionExpression.matches(regexDateExtendedForBCE)) {

        } else throw new IllegalArgumentException(dimensionExpression);

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

        minValue = valueOf(s[0]);

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

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

    }

        public String getExpression() {

                return dimensionExpression;

        }

}