Application: gvSIG desktop

Put into this folder the resources needed by your test classes.

This folder is added to the Tests classpath, so you can load any resources 

through the ClassLoader.

By default, in this folder you can find an example of log4j configuration,

prepared to log messages through the console, so logging works when you

run your tests classes.

<?xml version="1.0" encoding="ISO-8859-1" ?>

<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">

<!-- 

Log4J configuration file for unit tests execution.

 -->

<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">

	<!-- Appender configuration to show logging messages through the console -->

	<appender name="CONSOLE" class="org.apache.log4j.ConsoleAppender">

		<layout class="org.apache.log4j.PatternLayout">

			<param name="ConversionPattern" value="%d{HH:mm:ss,SSS} %-5p [%c{2}.%M()]\n  %m%n" />

		</layout>

	</appender>

	<!-- 

	Activate logging messages of DEBUG level of higher only for the

	org.gvsig.tools packages.

	You can put full classes names or packages instead, to configure

	logging for all the classes and subpackages of the package.

	-->

	<category name="org.gvsig.tools">

		<priority value="DEBUG" />

	</category>

	<category name="org.gvsig.timesupport">

		<priority value="DEBUG" />

	</category>

	<!-- 

	By default, show only logging messages of INFO level or higher, 

	through the previously configured CONSOLE appender. 

	-->

	<root>

		<priority value="INFO" />

		<appender-ref ref="CONSOLE" />

	</root>

</log4j:configuration>

org.gvsig.timesupport.impl.TimeSupportDefaultImplLibrary

/* 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.timesupport.impl;

import org.gvsig.timesupport.AbsoluteInstant;

import org.gvsig.timesupport.AbsoluteInstantType;

import org.gvsig.timesupport.AbsoluteInterval;

import org.gvsig.timesupport.AbsoluteIntervalType;

import org.gvsig.timesupport.Chronology;

import org.gvsig.timesupport.Duration;

import org.gvsig.timesupport.Instant;

import org.gvsig.timesupport.Time;

/**

 * @author gvSIG team

 * @version $Id$

 */

public class DefaultAbsoluteInstant implements AbsoluteInstant {

    private org.joda.time.Partial jodaPartial = null;

    private AbsoluteInstantType[] dateTimeFieldTypes = null;

    private Chronology chronology = null;

    private org.joda.time.DateTimeFieldType[] indexes = null;

    DefaultAbsoluteInstant(Chronology chronology) {

        super();    

        this.jodaPartial = new org.joda.time.Partial(((DefaultChronology)chronology).getJodaType());

        this.chronology = chronology;

        initializeIndexes();

    }

    DefaultAbsoluteInstant(Chronology chronology, org.joda.time.Partial jodaPartial) {

        super();    

        this.jodaPartial = jodaPartial;

        this.chronology = chronology;

        initializeIndexes();

    }

    DefaultAbsoluteInstant(DefaultAbsoluteInstantType dateTimeFieldType, int value, Chronology chronology) {

        super();	

        this.jodaPartial = new org.joda.time.Partial(dateTimeFieldType.getJodaType(), value, ((DefaultChronology)chronology).getJodaType());

        this.dateTimeFieldTypes = new DefaultAbsoluteInstantType[1];

        this.dateTimeFieldTypes[0] = dateTimeFieldType;

        this.chronology = chronology;

        initializeIndexes();

    }

    DefaultAbsoluteInstant(DefaultAbsoluteInstantType[] dateTimeFieldTypes, int[] values, Chronology chronology) {

        super();    

        org.joda.time.DateTimeFieldType[] jodaDateTimeFieldTypes = new org.joda.time.DateTimeFieldType[dateTimeFieldTypes.length];

        this.dateTimeFieldTypes = new DefaultAbsoluteInstantType[dateTimeFieldTypes.length];

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

            this.dateTimeFieldTypes[i] = dateTimeFieldTypes[i];

            jodaDateTimeFieldTypes[i] = dateTimeFieldTypes[i].getJodaType();

        }

        this.jodaPartial = new org.joda.time.Partial(jodaDateTimeFieldTypes, values, ((DefaultChronology)chronology).getJodaType());

        this.chronology = chronology;

        initializeIndexes();

    }

    private void initializeIndexes(){

        indexes = new org.joda.time.DateTimeFieldType[8];

        org.joda.time.DateTimeFieldType[] dateTimeFieldTypes = jodaPartial.getFieldTypes();    

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

            if (dateTimeFieldTypes[i].equals(org.joda.time.DateTimeFieldType.year())){

                indexes[AbsoluteIntervalType.YEARS] = dateTimeFieldTypes[i];

            } else if (dateTimeFieldTypes[i].equals(org.joda.time.DateTimeFieldType.monthOfYear())){

                indexes[AbsoluteIntervalType.MONTHS] = dateTimeFieldTypes[i];

            } else if (dateTimeFieldTypes[i].equals(org.joda.time.DateTimeFieldType.weekOfWeekyear())){

                indexes[AbsoluteIntervalType.WEEKS] = dateTimeFieldTypes[i];

            } else if (dateTimeFieldTypes[i].equals(org.joda.time.DateTimeFieldType.dayOfMonth())){

                indexes[AbsoluteIntervalType.DAYS] = dateTimeFieldTypes[i];

            } else if (dateTimeFieldTypes[i].equals(org.joda.time.DateTimeFieldType.hourOfDay())){

                indexes[AbsoluteIntervalType.HOURS] = dateTimeFieldTypes[i];

            } else if (dateTimeFieldTypes[i].equals(org.joda.time.DateTimeFieldType.minuteOfHour())){

                indexes[AbsoluteIntervalType.MINUTES] = dateTimeFieldTypes[i];

            } else if (dateTimeFieldTypes[i].equals(org.joda.time.DateTimeFieldType.secondOfMinute())){

                indexes[AbsoluteIntervalType.SECONDS] = dateTimeFieldTypes[i];

            } else if (dateTimeFieldTypes[i].equals(org.joda.time.DateTimeFieldType.millisOfSecond())){

                indexes[AbsoluteIntervalType.MILLIS] = dateTimeFieldTypes[i];

            } 

        }         

    }

    public int size() {

        return jodaPartial.size();

    }

    public AbsoluteInstantType getFieldType(int index) {        

        return dateTimeFieldTypes[index];

    }

    public int getValue(int index) {       

        return jodaPartial.getValue(index);

    }

    public String toString() {      

        return jodaPartial.toString();

    } 

    public boolean equals(Object obj) {      

        if (((Time)obj).isRelative() || ((Time)obj).isInterval()){

            return false;

        }    

        return ((DefaultAbsoluteInstant)obj).getJodaType().equals(jodaPartial);

    }

    org.joda.time.Partial getJodaType() {

        return jodaPartial;

    }

    public boolean isAfter(Instant partial) {

        return jodaPartial.isAfter(((DefaultAbsoluteInstant)partial).getJodaType());

    }

    public boolean isBefore(Instant partial) {

        return jodaPartial.isBefore(((DefaultAbsoluteInstant)partial).getJodaType());

    }

    public boolean isEqual(Instant partial) {

        return jodaPartial.isEqual(((DefaultAbsoluteInstant)partial).getJodaType());

    }    

    public Chronology getChronology() {      

        return chronology;

    }

    public Object clone() throws CloneNotSupportedException {

        return new DefaultAbsoluteInstant(chronology, new org.joda.time.Partial(jodaPartial));

    }  

    public int getYears(){

        if (indexes[AbsoluteIntervalType.YEARS] == null){

            return 0;

        }

        return ((Integer)jodaPartial.get(indexes[AbsoluteIntervalType.YEARS])).intValue();

    }    

    public int getMonths(){

        if (indexes[AbsoluteIntervalType.MONTHS] == null){

            return 1;

        }

        return ((Integer)jodaPartial.get(indexes[AbsoluteIntervalType.MONTHS])).intValue();

    }

    public int getWeeks(){

        if (indexes[AbsoluteIntervalType.WEEKS] == null){

            return 0;

        }

        return ((Integer)jodaPartial.get(indexes[AbsoluteIntervalType.WEEKS])).intValue();

    }

    public int getDays(){

        if (indexes[AbsoluteIntervalType.DAYS] == null){

            return 1;

        }

        return ((Integer)jodaPartial.get(indexes[AbsoluteIntervalType.DAYS])).intValue();

    }

    public int getHours(){

        if (indexes[AbsoluteIntervalType.HOURS] == null){

            return 0;

        }

        return ((Integer)jodaPartial.get(indexes[AbsoluteIntervalType.HOURS])).intValue();

    }

    public int getMinutes(){

        if (indexes[AbsoluteIntervalType.MINUTES] == null){

            return 0;

        }

        return ((Integer)jodaPartial.get(indexes[AbsoluteIntervalType.MINUTES])).intValue();

    }

    public int getSeconds(){

        if (indexes[AbsoluteIntervalType.SECONDS] == null){

            return 0;

        }

        return ((Integer)jodaPartial.get(indexes[AbsoluteIntervalType.SECONDS])).intValue();

    }

    public int getMillis(){

        if (indexes[AbsoluteIntervalType.MILLIS] == null){

            return 0;

        }

        return ((Integer)jodaPartial.get(indexes[AbsoluteIntervalType.MILLIS])).intValue();

    }

    public boolean isRelative() {

        return false;

    }

    public boolean isAbsolute() {

        return true;

    }

    public boolean isInterval() {

        return false;

    }

    public boolean isInstant() { 

        return true;

    }

    public boolean intersects(Time time) {

        if (time.isAbsolute()){

            if (time.isInterval()){

                return (((AbsoluteInterval)time).getMillis() == 0) && ((AbsoluteInterval)time).getStart().equals(this);

            }else{

                return this.equals(time);

            }

        }

        return true;

    }

    public AbsoluteInstant minus(AbsoluteInterval interval) {

        return new DefaultAbsoluteInstant(chronology, jodaPartial.minus(((DefaultAbsoluteInterval)interval).getJodaType()));

    }

    public AbsoluteInstant plus(AbsoluteInterval interval) {

        return new DefaultAbsoluteInstant(chronology, jodaPartial.plus(((DefaultAbsoluteInterval)interval).getJodaType()));

    }

    public Duration toStandardDuration() {

        long millis = 0;                  

        millis += getYears() * DefaultAbsoluteInterval.MILLIS_BY_YEAR;

        millis += (getMonths() - 1) * DefaultAbsoluteInterval.MILLIS_BY_MONTH;

        millis += (getDays() - 1) * DefaultAbsoluteInterval.MILLIS_BY_YEAR;

        millis += getHours() * DefaultAbsoluteInterval.MILLIS_BY_HOUR;

        millis += getMinutes() * DefaultAbsoluteInterval.MILLIS_BY_MINUTE;

        millis += getSeconds() * DefaultAbsoluteInterval.MILLIS_BY_SECOND;       

        millis += getMillis();

        return new DefaultDuration(millis);    

    }    

}

/* 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.timesupport.impl;

import org.gvsig.timesupport.Chronology;

import org.gvsig.timesupport.Duration;

import org.gvsig.timesupport.Instant;

import org.gvsig.timesupport.RelativeInstant;

import org.gvsig.timesupport.RelativeInterval;

import org.gvsig.timesupport.Time;

/**

 * @author gvSIG team

 * @version $Id$

 */

public class DefaultRelativeInterval implements RelativeInterval {

    private org.joda.time.Interval jodaInterval = null;

    private Chronology chronology = null;

    DefaultRelativeInterval(long startInstant, long endInstant, Chronology chronology) {

        super();	

        this.jodaInterval = new org.joda.time.Interval(startInstant, endInstant, ((DefaultChronology)chronology).getJodaType());

        this.chronology = chronology;

    }

    DefaultRelativeInterval(RelativeInstant startInstant, RelativeInstant endInstant, Chronology chronology) {

        this(startInstant.toMillis(), endInstant.toMillis(), chronology);    

    }

    DefaultRelativeInterval(Chronology chronology, org.joda.time.Interval interval) {

        super();    

        this.jodaInterval = interval;

        this.chronology = chronology; 

    }

    public long toDurationMillis() {     

        return jodaInterval.toDurationMillis();

    }

    public boolean contains(RelativeInstant instant) {       

        return jodaInterval.contains(((DefaultRelativeInstant)instant).getJodaType());

    }

    public boolean isAfter(RelativeInstant instant) {

        return jodaInterval.isAfter(((DefaultRelativeInstant)instant).getJodaType());

    }

    public boolean isAfter(RelativeInterval interval) {

        return jodaInterval.isAfter(((DefaultRelativeInterval)interval).getJodaType());

    }

    public boolean isBefore(RelativeInstant instant) {

        return jodaInterval.isBefore(((DefaultRelativeInstant)instant).getJodaType());

    }

    public boolean isBefore(RelativeInterval interval) {

        return jodaInterval.isBefore(((DefaultRelativeInterval)interval).getJodaType());

    }

    public Duration toDuration() {    

        return new DefaultDuration(toDurationMillis());

    }

    org.joda.time.Interval getJodaType() {

        return jodaInterval;

    }    

    public String toString() {      

        return jodaInterval.toString();

    }     

    public boolean equals(Object obj) {      

        if ((obj == null) || ((Time)obj).isAbsolute() || ((Time)obj).isInstant()){

            return false;

        }

        return ((DefaultRelativeInterval)obj).getJodaType().equals(jodaInterval);

    }

    public boolean contains(RelativeInterval interval) {       

        return jodaInterval.contains(((DefaultRelativeInterval)interval).getJodaType());

    }

    public boolean overlaps(RelativeInterval interval) {

        return jodaInterval.overlaps(((DefaultRelativeInterval)interval).getJodaType());

    }     

    public Chronology getChronology() {      

        return chronology;

    }

    public Object clone() throws CloneNotSupportedException {

        return new DefaultRelativeInterval(chronology, new org.joda.time.Interval(jodaInterval));

    } 

    public RelativeInstant getStart(){

        return new DefaultRelativeInstant(chronology, jodaInterval.getStart());

    }

    public RelativeInstant getEnd(){

        return new DefaultRelativeInstant(chronology, jodaInterval.getEnd());

    }

    public boolean isRelative() {

        return true;

    }

    public boolean isAbsolute() {

        return false;

    }    

    public boolean isInterval() {

        return true;

    }

    public boolean isInstant() { 

        return false;

    }

    public boolean contains(Instant instant) {

        if (instant.isRelative()){

            return contains((RelativeInstant)instant);

        }

        return false;  

    }

    public boolean intersects(Time time) {

        if (time.isRelative()){

            if (time.isInterval()){

                return intersects((RelativeInterval)time);

            }else{

                return contains((RelativeInstant)time);

            }

        }

        return false;

    }

    public boolean intersects(RelativeInterval relativeInterval){

        return (this.getStart().isAfter((RelativeInstant)relativeInterval.getStart()) && this.getEnd().isBefore((RelativeInstant)relativeInterval.getStart())) ||

        (this.getEnd().isBefore((RelativeInstant)relativeInterval.getEnd()) && this.getEnd().isAfter((RelativeInstant)relativeInterval.getEnd()));

    }

    public Duration toStandardDuration() {

        return new DefaultDuration(jodaInterval.toDuration());

    }

}

/* 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.timesupport.impl;

import org.gvsig.timesupport.AbsoluteInstantType;

/**

 * @author <a href="mailto:jpiera@gvsig.org">Jorge Piera Llodr&aacute;</a>

 */

public class DefaultAbsoluteInstantType implements AbsoluteInstantType{

	private org.joda.time.DateTimeFieldType jodaDateTimeFieldType = null;

	private int type = 0;

	DefaultAbsoluteInstantType(int type, org.joda.time.DateTimeFieldType dateTimeFieldType) {

		super();	

		this.type = type;

		this.jodaDateTimeFieldType = dateTimeFieldType;

	}

	org.joda.time.DateTimeFieldType getJodaType() {

		return jodaDateTimeFieldType;

	}

    public int getType() {      

        return type;

    }

    public String getName() {      

        return jodaDateTimeFieldType.getName();

    }    

    public String toString() {      

        return jodaDateTimeFieldType.toString();

    }    

}

/* 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.timesupport.impl;

import org.gvsig.timesupport.AbsoluteInstantType;

import org.gvsig.timesupport.AbsoluteIntervalType;

import org.gvsig.timesupport.Chronology;

import org.gvsig.timesupport.DataTypes;

import org.gvsig.timesupport.TimeSupportLocator;

import org.gvsig.timesupport.TimeSupportManager;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataTypesManager;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

/**

 * Library for default implementation initialization and configuration.

 * 

 * @author gvSIG team

 * @version $Id$

 */

public class TimeSupportDefaultImplLibrary extends AbstractLibrary {

    @Override

    protected void doInitialize() throws LibraryException {

        TimeSupportLocator.registerManager(DefaultTimeSupportManager.class);

    }

    @Override

    protected void doPostInitialize() throws LibraryException {

        //Register the types

        DataTypesManager dataTypesManager = ToolsLocator.getDataTypesManager();

        dataTypesManager.addtype(DataTypes.INSTANT, "Instant", "Instant", DefaultRelativeInstant.class, null);

        dataTypesManager.addtype(DataTypes.INTERVAL, "Interval","Interval", DefaultRelativeInterval.class, null);

        // Do nothing

        TimeSupportManager timeSupportManager = TimeSupportLocator.getManager();

        //register AbsoluteInstantType 

        timeSupportManager.registerAbsoluteInstantType(new DefaultAbsoluteInstantType(AbsoluteInstantType.ERA, org.joda.time.DateTimeFieldType.era()));

        timeSupportManager.registerAbsoluteInstantType(new DefaultAbsoluteInstantType(AbsoluteInstantType.YEAR_OF_ERA, org.joda.time.DateTimeFieldType.yearOfEra()));

        timeSupportManager.registerAbsoluteInstantType(new DefaultAbsoluteInstantType(AbsoluteInstantType.CENTURY_OF_ERA, org.joda.time.DateTimeFieldType.centuryOfEra()));

        timeSupportManager.registerAbsoluteInstantType(new DefaultAbsoluteInstantType(AbsoluteInstantType.YEAR_OF_CENTURY, org.joda.time.DateTimeFieldType.yearOfCentury()));

        timeSupportManager.registerAbsoluteInstantType(new DefaultAbsoluteInstantType(AbsoluteInstantType.YEAR, org.joda.time.DateTimeFieldType.year()));

        timeSupportManager.registerAbsoluteInstantType(new DefaultAbsoluteInstantType(AbsoluteInstantType.DAY_OF_YEAR, org.joda.time.DateTimeFieldType.dayOfYear()));

        timeSupportManager.registerAbsoluteInstantType(new DefaultAbsoluteInstantType(AbsoluteInstantType.MONTH_OF_YEAR, org.joda.time.DateTimeFieldType.monthOfYear()));

        timeSupportManager.registerAbsoluteInstantType(new DefaultAbsoluteInstantType(AbsoluteInstantType.DAY_OF_MONTH, org.joda.time.DateTimeFieldType.dayOfMonth()));

        timeSupportManager.registerAbsoluteInstantType(new DefaultAbsoluteInstantType(AbsoluteInstantType.WEEKYEAR_OF_CENTURY, org.joda.time.DateTimeFieldType.weekyearOfCentury()));

        timeSupportManager.registerAbsoluteInstantType(new DefaultAbsoluteInstantType(AbsoluteInstantType.WEEKYEAR, org.joda.time.DateTimeFieldType.weekyear()));

        timeSupportManager.registerAbsoluteInstantType(new DefaultAbsoluteInstantType(AbsoluteInstantType.WEEK_OF_WEEKYEAR, org.joda.time.DateTimeFieldType.weekOfWeekyear()));

        timeSupportManager.registerAbsoluteInstantType(new DefaultAbsoluteInstantType(AbsoluteInstantType.DAY_OF_WEEK, org.joda.time.DateTimeFieldType.dayOfWeek()));

        timeSupportManager.registerAbsoluteInstantType(new DefaultAbsoluteInstantType(AbsoluteInstantType.HALFDAY_OF_DAY, org.joda.time.DateTimeFieldType.halfdayOfDay()));

        timeSupportManager.registerAbsoluteInstantType(new DefaultAbsoluteInstantType(AbsoluteInstantType.HOUR_OF_HALFDAY, org.joda.time.DateTimeFieldType.hourOfHalfday()));

        timeSupportManager.registerAbsoluteInstantType(new DefaultAbsoluteInstantType(AbsoluteInstantType.CLOCKHOUR_OF_HALFDAY, org.joda.time.DateTimeFieldType.clockhourOfHalfday()));

        timeSupportManager.registerAbsoluteInstantType(new DefaultAbsoluteInstantType(AbsoluteInstantType.CLOCKHOUR_OF_DAY, org.joda.time.DateTimeFieldType.clockhourOfDay()));

        timeSupportManager.registerAbsoluteInstantType(new DefaultAbsoluteInstantType(AbsoluteInstantType.HOUR_OF_DAY, org.joda.time.DateTimeFieldType.hourOfDay()));

        timeSupportManager.registerAbsoluteInstantType(new DefaultAbsoluteInstantType(AbsoluteInstantType.MINUTE_OF_DAY, org.joda.time.DateTimeFieldType.minuteOfDay()));

        timeSupportManager.registerAbsoluteInstantType(new DefaultAbsoluteInstantType(AbsoluteInstantType.MINUTE_OF_HOUR, org.joda.time.DateTimeFieldType.minuteOfHour()));

        timeSupportManager.registerAbsoluteInstantType(new DefaultAbsoluteInstantType(AbsoluteInstantType.SECOND_OF_DAY, org.joda.time.DateTimeFieldType.secondOfDay()));

        timeSupportManager.registerAbsoluteInstantType(new DefaultAbsoluteInstantType(AbsoluteInstantType.SECOND_OF_MINUTE, org.joda.time.DateTimeFieldType.secondOfMinute()));

        timeSupportManager.registerAbsoluteInstantType(new DefaultAbsoluteInstantType(AbsoluteInstantType.MILLIS_OF_DAY, org.joda.time.DateTimeFieldType.millisOfDay()));

        timeSupportManager.registerAbsoluteInstantType(new DefaultAbsoluteInstantType(AbsoluteInstantType.MILLIS_OF_SECOND, org.joda.time.DateTimeFieldType.millisOfSecond()));

        //Register period types

        timeSupportManager.registerAbsoluteIntervalType(new DefaultAbsoluteIntervalType(AbsoluteIntervalType.YEARS, org.joda.time.PeriodType.years()));

        timeSupportManager.registerAbsoluteIntervalType(new DefaultAbsoluteIntervalType(AbsoluteIntervalType.MONTHS, org.joda.time.PeriodType.months()));

        timeSupportManager.registerAbsoluteIntervalType(new DefaultAbsoluteIntervalType(AbsoluteIntervalType.WEEKS, org.joda.time.PeriodType.weeks()));

        timeSupportManager.registerAbsoluteIntervalType(new DefaultAbsoluteIntervalType(AbsoluteIntervalType.DAYS, org.joda.time.PeriodType.days()));

        timeSupportManager.registerAbsoluteIntervalType(new DefaultAbsoluteIntervalType(AbsoluteIntervalType.HOURS, org.joda.time.PeriodType.hours()));

        timeSupportManager.registerAbsoluteIntervalType(new DefaultAbsoluteIntervalType(AbsoluteIntervalType.MINUTES, org.joda.time.PeriodType.minutes()));

        timeSupportManager.registerAbsoluteIntervalType(new DefaultAbsoluteIntervalType(AbsoluteIntervalType.SECONDS, org.joda.time.PeriodType.seconds()));

        timeSupportManager.registerAbsoluteIntervalType(new DefaultAbsoluteIntervalType(AbsoluteIntervalType.MILLIS, org.joda.time.PeriodType.millis()));

        //register Chronologies

        timeSupportManager.registerChronology(new DefaultChronology(Chronology.BUDDHIST, org.joda.time.chrono.BuddhistChronology.getInstance()));

        timeSupportManager.registerChronology(new DefaultChronology(Chronology.COPTIC, org.joda.time.chrono.CopticChronology.getInstance()));

        timeSupportManager.registerChronology(new DefaultChronology(Chronology.GJ, org.joda.time.chrono.GJChronology.getInstance()));

        timeSupportManager.registerChronology(new DefaultChronology(Chronology.GREGORIAN, org.joda.time.chrono.GregorianChronology.getInstance()));

        timeSupportManager.registerChronology(new DefaultChronology(Chronology.ISO, org.joda.time.chrono.ISOChronology.getInstance()));

        timeSupportManager.registerChronology(new DefaultChronology(Chronology.JULIAN, org.joda.time.chrono.JulianChronology.getInstance()));

        //Sets the default chronology

        timeSupportManager.setDefaultChronology(Chronology.GREGORIAN);     

        //Add some string patterns to parse relative instants

        timeSupportManager.addRelativeInstantPattern("yyyy:MM:dd HH:mm:ss");

        timeSupportManager.addRelativeInstantPattern("yyyy:MM:dd");

        timeSupportManager.addRelativeInstantPattern("yyyy/MM/dd HH:mm:ss");

        timeSupportManager.addRelativeInstantPattern("yyyy/MM/dd");

        timeSupportManager.addRelativeInstantPattern("yyyy-MM-dd'T'HH:mm:ss.SSSZ");

        timeSupportManager.addRelativeInstantPattern("yyyy-MM-dd HH:mm:ss"); 

        timeSupportManager.addRelativeInstantPattern("yyyy-MM-dd");   

    }

}

/* 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.timesupport.impl;

import java.util.ArrayList;

import java.util.List;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.timesupport.AbsoluteInstant;

import org.gvsig.timesupport.AbsoluteInstantType;

import org.gvsig.timesupport.AbsoluteInstantTypeNotRegisteredException;

import org.gvsig.timesupport.AbsoluteInterval;

import org.gvsig.timesupport.AbsoluteIntervalType;

import org.gvsig.timesupport.AbsoluteIntervalTypeNotRegisteredException;

import org.gvsig.timesupport.Chronology;

import org.gvsig.timesupport.Duration;

import org.gvsig.timesupport.Instant;

import org.gvsig.timesupport.RelativeInstant;

import org.gvsig.timesupport.Time;

import org.gvsig.timesupport.TimeSupportLocator;

import org.gvsig.timesupport.TimeSupportManager;

/**

 * @author gvSIG team

 * @version $Id$

 */

public class DefaultAbsoluteInterval implements AbsoluteInterval{

    static final long MILLIS_BY_SECOND = 1000;

    static final long MILLIS_BY_MINUTE = MILLIS_BY_SECOND * 60;

    static final long MILLIS_BY_HOUR = MILLIS_BY_MINUTE * 60;

    static final long MILLIS_BY_DAY = MILLIS_BY_HOUR * 24;

    static final long MILLIS_BY_MONTH = MILLIS_BY_DAY * 30;

    static final long MILLIS_BY_YEAR = MILLIS_BY_MONTH * 365;

    private static Logger LOG = LoggerFactory.getLogger(DefaultAbsoluteInterval.class);

    private org.joda.time.Period jodaPeriod = null;

    private AbsoluteInstant startAbsoluteInstant = null;

    private AbsoluteInstant endAbsoluteInstant = null;

    private AbsoluteIntervalType[] absoluteIntervalTypes = null; 

    private Chronology chronology = null;

    private static final TimeSupportManager timeSupportManager = TimeSupportLocator.getManager(); 

    DefaultAbsoluteInterval(AbsoluteInstant startPartial, int years, int months, int weeks, int days,

        int hours, int minutes, int seconds, int millis, Chronology chronology) throws AbsoluteIntervalTypeNotRegisteredException{

        this(years, months, weeks, days, hours, minutes, seconds, millis, chronology);

        initilizePartials(((DefaultAbsoluteInstant)startPartial).getJodaType());

    }

    DefaultAbsoluteInterval(int years, int months, int weeks, int days,

        int hours, int minutes, int seconds, int millis, Chronology chronology) throws AbsoluteIntervalTypeNotRegisteredException{

        super();	

        this.jodaPeriod = new org.joda.time.Period(years, months, weeks, days, hours, minutes, seconds, millis);

        this.absoluteIntervalTypes = new AbsoluteIntervalType[8];

        this.absoluteIntervalTypes[0] = timeSupportManager.getAbsoluteIntervalType(AbsoluteIntervalType.YEARS);

        this.absoluteIntervalTypes[1] = timeSupportManager.getAbsoluteIntervalType(AbsoluteIntervalType.MONTHS);

        this.absoluteIntervalTypes[2] = timeSupportManager.getAbsoluteIntervalType(AbsoluteIntervalType.WEEKS);

        this.absoluteIntervalTypes[3] = timeSupportManager.getAbsoluteIntervalType(AbsoluteIntervalType.DAYS);

        this.absoluteIntervalTypes[4] = timeSupportManager.getAbsoluteIntervalType(AbsoluteIntervalType.HOURS);

        this.absoluteIntervalTypes[5] = timeSupportManager.getAbsoluteIntervalType(AbsoluteIntervalType.MINUTES);

        this.absoluteIntervalTypes[6] = timeSupportManager.getAbsoluteIntervalType(AbsoluteIntervalType.SECONDS);

        this.absoluteIntervalTypes[7] = timeSupportManager.getAbsoluteIntervalType(AbsoluteIntervalType.MILLIS); 

        this.chronology = chronology;

        initilizePartials();

    }    

    DefaultAbsoluteInterval(AbsoluteInstant startAbsoluteInstant, AbsoluteInstant endAbsoluteInstant, Chronology chronology) {

        super(); 

        this.jodaPeriod = new org.joda.time.Period(startAbsoluteInstant.toStandardDuration().getMillis(),

            endAbsoluteInstant.toStandardDuration().getMillis());         

            this.chronology = chronology;

            this.startAbsoluteInstant = startAbsoluteInstant;

            this.endAbsoluteInstant = endAbsoluteInstant;

//        int[] mergedTypes = mergeTypes(startAbsoluteInstant, endAbsoluteInstant);

//        try {

//            AbsoluteInstant startAbsoluteInstantAux = mergeTypes(mergedTypes, startAbsoluteInstant);

//            AbsoluteInstant endAbsoluteInstantAux = mergeTypes(mergedTypes, endAbsoluteInstant);

//            this.jodaPeriod = new org.joda.time.Period(((DefaultAbsoluteInstant)startAbsoluteInstantAux).getJodaType(), 

//                ((DefaultAbsoluteInstant)endAbsoluteInstantAux).getJodaType());

//            this.chronology = chronology;

//            this.startAbsoluteInstant = startAbsoluteInstantAux;

//            this.endAbsoluteInstant = endAbsoluteInstantAux;

//        } catch (AbsoluteInstantTypeNotRegisteredException e) {

//           LOG.error("Error creating the interval");

//        }        

    }

//    private AbsoluteInstant mergeTypes(int[] mergedTypes,

//        AbsoluteInstant absoluteInstant) throws AbsoluteInstantTypeNotRegisteredException{

//        int[] values = new int[mergedTypes.length];

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

//            if (mergedTypes[i] == AbsoluteInstantType.YEAR){

//                values[i] = absoluteInstant.getYears();

//            }else if (mergedTypes[i] == AbsoluteInstantType.MONTH_OF_YEAR){

//                values[i] = absoluteInstant.getMonths();

//                if (values[i] == 0){

//                    values[i] = 1;

//                }

//            }else if (mergedTypes[i] == AbsoluteInstantType.DAY_OF_MONTH){

//                values[i] = absoluteInstant.getDays();

//                if (values[i] == 0){

//                    values[i] = 1;

//                }

//            }else if (mergedTypes[i] == AbsoluteInstantType.HOUR_OF_DAY){

//                values[i] = absoluteInstant.getHours();

//            }else if (mergedTypes[i] == AbsoluteInstantType.MINUTE_OF_HOUR){

//                values[i] = absoluteInstant.getMinutes();

//            }else if (mergedTypes[i] == AbsoluteInstantType.SECOND_OF_MINUTE){

//                values[i] = absoluteInstant.getSeconds();

//            }else if (mergedTypes[i] == AbsoluteInstantType.MILLIS_OF_SECOND){

//                values[i] = absoluteInstant.getMillis();

//            }else{

//                values[i] = 0;

//            }                  

//        }

//        return timeSupportManager.createAbsoluteInstant(mergedTypes, values, absoluteInstant.getChronology());

//    }

//

//    private int[] mergeTypes(AbsoluteInstant startAbsoluteInstant,

//        AbsoluteInstant endAbsoluteInstant) {

//        ArrayList types = new ArrayList();

//        for (int i=0 ; i<startAbsoluteInstant.size() ; i++){

//            types.add(startAbsoluteInstant.getFieldType(i).getType());

//        }

//        

//        for (int i=0 ; i<endAbsoluteInstant.size() ; i++){

//            int type = endAbsoluteInstant.getFieldType(i).getType();

//            int position = -1;

//            for (int j=0 ; j<types.size() ; j++){

//                int addedType = (Integer)types.get(j);

//                if (type < addedType){

//                    position = j;

//                    break;

//                }else if (type == addedType){

//                    position = -2;

//                }                

//            }

//            if (position > -1){

//                types.add(position, type);

//            }else if (position == -1){

//                types.add(type);

//            }

//        }        

//        

//        int[] mergedTypes = new int[types.size()];     

//        for (int i=0 ; i<types.size() ; i++){

//            mergedTypes[i] = (Integer)types.get(i);          

//        }

//        return mergedTypes;

//    }

    DefaultAbsoluteInterval(RelativeInstant startPeriod, RelativeInstant endPeriod, Chronology chronology) {

        super();    

        this.jodaPeriod = new org.joda.time.Period(((DefaultRelativeInstant)startPeriod).getJodaType(), 

            ((DefaultRelativeInstant)endPeriod).getJodaType());

        this.chronology = chronology;

        initilizePartials();

    }

    DefaultAbsoluteInterval(Chronology chronology, org.joda.time.Period period) {

        super();    

        this.jodaPeriod = period;

        this.chronology = chronology; 

        initilizePartials();

    }    

    DefaultAbsoluteInterval(AbsoluteInstant startPartial, AbsoluteInstant endPartial) {

        super(); 

        this.startAbsoluteInstant = startPartial;

        this.endAbsoluteInstant = endPartial;

        this.jodaPeriod = new org.joda.time.Period(endPartial.getYears() - startPartial.getYears(),

            0,

            endPartial.getMonths() - startPartial.getMonths(),

            endPartial.getDays() - startPartial.getDays(),

            endPartial.getHours() - startPartial.getHours(),

            endPartial.getMinutes() - startPartial.getMinutes(),

            endPartial.getSeconds() - startPartial.getSeconds(),

            endPartial.getMillis() - startPartial.getMillis());            

    }

    @SuppressWarnings({"unchecked" })

    private void initilizePartials(){

        this.startAbsoluteInstant = new DefaultAbsoluteInstant(chronology);        

        ArrayList types = new ArrayList();

        ArrayList values = new ArrayList();

        if (jodaPeriod.getYears() > 0){

            types.add(AbsoluteInstantType.YEAR);

            values.add(jodaPeriod.getYears());

        }

        if (jodaPeriod.getMonths() > 0){

            types.add(AbsoluteInstantType.MONTH_OF_YEAR);

            values.add(jodaPeriod.getMonths());

        }

        if (jodaPeriod.getWeeks() > 0){

            types.add(AbsoluteInstantType.WEEK_OF_WEEKYEAR);

            values.add(jodaPeriod.getWeeks());

        }

        if (jodaPeriod.getDays() > 0){

            types.add(AbsoluteInstantType.DAY_OF_MONTH);

            values.add(jodaPeriod.getDays());

        }

        if (jodaPeriod.getHours() > 0){

            types.add(AbsoluteInstantType.HOUR_OF_DAY);

            values.add(jodaPeriod.getHours());

        }

        if (jodaPeriod.getMinutes() > 0){

            types.add(AbsoluteInstantType.MINUTE_OF_HOUR);

            values.add(jodaPeriod.getMinutes());

        }

        if (jodaPeriod.getSeconds() > 0){

            types.add(AbsoluteInstantType.SECOND_OF_MINUTE);

            values.add(jodaPeriod.getSeconds());

        }

        if (jodaPeriod.getMillis() > 0){

            types.add(AbsoluteInstantType.MILLIS_OF_SECOND);

            values.add(jodaPeriod.getMillis());

        }        

        int[] nativeTypes = new int[types.size()];

        int[] nativeValues = new int[values.size()];

        for (int i=0 ; i<types.size() ; i++){

            nativeTypes[i] = (Integer)types.get(i);

            nativeValues[i] = (Integer)values.get(i);

        }

        try {

            this.endAbsoluteInstant = timeSupportManager.createAbsoluteInstant(nativeTypes, nativeValues, chronology);

        } catch (AbsoluteInstantTypeNotRegisteredException e) {

            LOG.error("Impossible to create the endPartial for a period", e);

        }  

    }

    @SuppressWarnings({ "unchecked" })

    private void initilizePartials(org.joda.time.Partial jodaPartial){

        this.startAbsoluteInstant = new DefaultAbsoluteInstant(chronology, jodaPartial);

        org.joda.time.DateTimeFieldType[] dateTimeFieldTypes = jodaPartial.getFieldTypes();

        int[] jodaValues = jodaPartial.getValues();

        ArrayList types = new ArrayList();

        ArrayList values = new ArrayList();

        if (jodaPeriod.getYears() > 0){

            types.add(AbsoluteInstantType.YEAR);

            values.add(jodaPeriod.getYears());

        }

        if (jodaPeriod.getMonths() > 0){

            types.add(AbsoluteInstantType.MONTH_OF_YEAR);

            values.add(jodaPeriod.getMonths());

        }

        if (jodaPeriod.getDays() > 0){

            types.add(AbsoluteInstantType.DAY_OF_MONTH);

            values.add(jodaPeriod.getDays());

        }

        if (jodaPeriod.getHours() > 0){

            types.add(AbsoluteInstantType.HOUR_OF_DAY);

            values.add(jodaPeriod.getHours());

        }

        if (jodaPeriod.getMinutes() > 0){

            types.add(AbsoluteInstantType.MINUTE_OF_HOUR);

            values.add(jodaPeriod.getMinutes());

        }

        if (jodaPeriod.getSeconds() > 0){

            types.add(AbsoluteInstantType.SECOND_OF_MINUTE);

            values.add(jodaPeriod.getSeconds());

        }

        if (jodaPeriod.getMillis() > 0){

            types.add(AbsoluteInstantType.MILLIS_OF_SECOND);

            values.add(jodaPeriod.getMillis());

        }    

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

            if (dateTimeFieldTypes[i].equals(org.joda.time.DateTimeFieldType.year())){

                initializePartialsIteration(types, values, jodaValues[i], AbsoluteInstantType.YEAR);

            } else if (dateTimeFieldTypes[i].equals(org.joda.time.DateTimeFieldType.monthOfYear())){

                initializePartialsIteration(types, values, jodaValues[i], AbsoluteInstantType.MONTH_OF_YEAR);

            } else if (dateTimeFieldTypes[i].equals(org.joda.time.DateTimeFieldType.dayOfMonth())){

                initializePartialsIteration(types, values, jodaValues[i], AbsoluteInstantType.DAY_OF_MONTH);

            } else if (dateTimeFieldTypes[i].equals(org.joda.time.DateTimeFieldType.hourOfDay())){

                initializePartialsIteration(types, values, jodaValues[i], AbsoluteInstantType.HOUR_OF_DAY);

            } else if (dateTimeFieldTypes[i].equals(org.joda.time.DateTimeFieldType.minuteOfHour())){

                initializePartialsIteration(types, values, jodaValues[i], AbsoluteInstantType.MINUTE_OF_HOUR);

            } else if (dateTimeFieldTypes[i].equals(org.joda.time.DateTimeFieldType.secondOfMinute())){

                initializePartialsIteration(types, values, jodaValues[i], AbsoluteInstantType.SECOND_OF_MINUTE);

            } else if (dateTimeFieldTypes[i].equals(org.joda.time.DateTimeFieldType.millisOfSecond())){

                initializePartialsIteration(types, values, jodaValues[i], AbsoluteInstantType.MILLIS_OF_SECOND);

            } 

        } 

        int[] nativeTypes = new int[types.size()];

        int[] nativeValues = new int[values.size()];

        for (int i=0 ; i<types.size() ; i++){

            nativeTypes[i] = (Integer)types.get(i);

            nativeValues[i] = (Integer)values.get(i);

        }

        try {

            this.endAbsoluteInstant = timeSupportManager.createAbsoluteInstant(nativeTypes, nativeValues, chronology);

        } catch (AbsoluteInstantTypeNotRegisteredException e) {

            LOG.error("Impossible to create the endPartial for a period", e);

        }  

    }

    @SuppressWarnings({ "unchecked" })

    private void initializePartialsIteration(List types, List values, int jodaValue, int dateTimefieldtype){

        boolean found = false;

        for (int j=0 ; j<types.size() ; j++){

            if (types.get(j).equals(dateTimefieldtype)){

                int value = (Integer)values.get(j);

                values.remove(j);

                values.add(j, value + jodaValue);

                found = true;

                break;

            }

        }

        if (!found){

            types.add(dateTimefieldtype);

            values.add(jodaValue);

        }

    }

    public int size() {       

        return jodaPeriod.size();

    }

    public AbsoluteIntervalType getFieldType(int index) {       

        return absoluteIntervalTypes[index];

    }

    public int getValue(int index) {      

        return jodaPeriod.getValue(index);

    } 

    public String toString() {      

        return jodaPeriod.toString();

    } 

    public boolean equals(Object obj) {      

        if (((Time)obj).isRelative() || ((Time)obj).isInstant()){

            return false;

        }          

        return ((DefaultAbsoluteInterval)obj).getJodaType().equals(jodaPeriod);

    }

    org.joda.time.Period getJodaType() {

        return jodaPeriod;

    }   

    public Chronology getChronology() {      

        return chronology;

    }

    public int getYears() {

        return jodaPeriod.getYears();

    }

    public int getMonths() {

        return jodaPeriod.getMonths();

    }

    public int getWeeks() {

        return jodaPeriod.getWeeks();

    }

    public int getDays() {

        return jodaPeriod.getDays();

    }

    public int getHours() {

        return jodaPeriod.getHours();

    }

    public int getMinutes() {

        return jodaPeriod.getMinutes();

    }

    public int getSeconds() {

        return jodaPeriod.getSeconds();

    }

    public int getMillis() {

        return jodaPeriod.getMillis();

    }

    public boolean isAfter(AbsoluteInterval period) {

        return jodaPeriod.getMillis() > period.getMillis();

    }

    public boolean isBefore(AbsoluteInterval period) {

        return jodaPeriod.getMillis() < period.getMillis();

    }    

    public Object clone() throws CloneNotSupportedException {

        return new DefaultAbsoluteInterval(chronology, new org.joda.time.Period(jodaPeriod));

    }

    public AbsoluteInstant getStart(){

        return startAbsoluteInstant;

    }

    public AbsoluteInstant getEnd(){

        return endAbsoluteInstant;

    }

    public boolean isRelative() {

        return false;

    }

    public boolean isAbsolute() {

        return true;

    }    

    public boolean isInterval() {

        return true;

    }

    public boolean isInstant() { 

        return false;

    }

    public boolean intersects(Time time) {

        if (time.isAbsolute()){

            if (time.isInterval()){

                return intersects((AbsoluteInterval)time);

            }else{

                return contains((AbsoluteInstant)time);

            }

        }

        return true;

    }

    public boolean intersects(AbsoluteInterval absoluteInsterInterval){

        return (this.getStart().isAfter(absoluteInsterInterval.getStart()) && this.getEnd().isBefore(absoluteInsterInterval.getStart())) ||

        (this.getEnd().isBefore(absoluteInsterInterval.getEnd()) && this.getEnd().isAfter(absoluteInsterInterval.getEnd()));

    }

    public boolean contains(Instant instant) {

        if (instant.isAbsolute()){

            return this.getMillis() >= ((AbsoluteInstant)instant).getMillis();

        }

        return false;  

    }

    public Duration toStandardDuration() {

        long millis = 0;                  

        millis += getYears() * MILLIS_BY_YEAR;

        millis += getMonths() * MILLIS_BY_MONTH;

        millis += getDays() * MILLIS_BY_YEAR;

        millis += getHours() * MILLIS_BY_HOUR;

        millis += getMinutes() * MILLIS_BY_MINUTE;

        millis += getSeconds() * MILLIS_BY_SECOND;       

        millis += getMillis();

        return new DefaultDuration(millis);

    }

}

/* 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.timesupport.impl;

import org.gvsig.timesupport.Chronology;

/**

 * @author gvSIG Team

 * @version $Id$

 *

 */

public class DefaultChronology implements Chronology {

    private org.joda.time.Chronology jodaChronology = null;

    private Chronology withUTC= null;

    private int type = 0;

    DefaultChronology(int type, org.joda.time.Chronology dateTimeFieldType) {

        super();    

        this.type = type;

        this.jodaChronology = dateTimeFieldType;        

    }

    org.joda.time.Chronology getJodaType() {      

        return jodaChronology;

    } 

    public int getType() {

        return type;

    }

    public Chronology withUTC() {       

        if (withUTC == null){

            withUTC = new DefaultChronology(type, jodaChronology.withUTC());

        }

        return withUTC;

    }    

}

/* 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.timesupport.impl;

import org.gvsig.timesupport.AbsoluteIntervalType;

/**

 * @author <a href="mailto:jpiera@gvsig.org">Jorge Piera Llodr&aacute;</a>

 */

public class DefaultAbsoluteIntervalType implements AbsoluteIntervalType{

	private org.joda.time.PeriodType jodaPeriodType = null;

	private int type = 0;

	DefaultAbsoluteIntervalType(int type, org.joda.time.PeriodType jodaPeriodType) {

		super();	

		this.type = type;

		this.jodaPeriodType = jodaPeriodType;

	}

	org.joda.time.PeriodType getJodaType() {

		return jodaPeriodType;

	}

    public int getType() {      

        return type;

    }

    public String getName() {      

        return jodaPeriodType.getName();

    }    

    public String toString() {      

        return jodaPeriodType.toString();

    }    

}

/* 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.timesupport.impl;

import org.gvsig.timesupport.Duration;

/**

 * @author gvSIG team

 * @version $Id$

 */

public class DefaultDuration implements Duration {

	private org.joda.time.Duration jodaDuration = null;

	DefaultDuration(long duration) {

		super();	

		this.jodaDuration = new org.joda.time.Duration(duration);

	}	

	DefaultDuration(org.joda.time.Duration jodaDuration) {

        super();    

        this.jodaDuration = jodaDuration;

    }   

	DefaultDuration(long startInstant, long endInstant) {

		super();	

		this.jodaDuration = new org.joda.time.Duration(startInstant, endInstant);

	}

    public long getMillis() {

        return jodaDuration.getMillis();

    }

    public String toString() {      

        return jodaDuration.toString();

    }  

    public boolean equals(Object obj) {      

        return ((DefaultDuration)obj).getJodaType().equals(jodaDuration);

    }

    org.joda.time.Duration getJodaType() {      

        return jodaDuration;

    } 

}

/* 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.timesupport.impl;

import org.joda.time.MutableDateTime;

import org.gvsig.timesupport.Chronology;

import org.gvsig.timesupport.EditableRelativeInstant;

/**

 * @author gvSIG Team

 * @version $Id$

 *

 */

public class DefaultEditableRelativeInstant extends DefaultRelativeInstant implements EditableRelativeInstant{

    private org.joda.time.MutableDateTime jodaMutableDateTime;

    DefaultEditableRelativeInstant(MutableDateTime jodaMutableDateTime, Chronology chronology) {

        super(jodaMutableDateTime.getMillis(), chronology);

        this.jodaMutableDateTime = jodaMutableDateTime;       

    }

    public void setTime(int hour, int minuteOfHour, int secondOfMinute,

        int millisOfSecond) {

        jodaMutableDateTime.setTime(hour, minuteOfHour, secondOfMinute, millisOfSecond); 

    }

    public void setDate(int year, int monthOfYear, int dayOfMonth) {

        jodaMutableDateTime.setDate(year, monthOfYear, dayOfMonth);        

    }

    public void addYears(int years) {

        jodaMutableDateTime.addYears(years);

    }

    public void addDays(int days) {

        jodaMutableDateTime.addDays(days);        

    }

    public void addHours(int hours) {

        jodaMutableDateTime.addHours(hours);        

    }

    public void addMinutes(int minutes) {

        jodaMutableDateTime.addMinutes(minutes);        

    }

    public void addSeconds(int seconds) {

        jodaMutableDateTime.addSeconds(seconds);        

    }

    public void addMillis(int millis) {

        jodaMutableDateTime.addMillis(millis);        

    }  

    public String toString() {      

        return jodaMutableDateTime.toString();

    }  

}

/* 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.timesupport.impl;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.Date;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.timesupport.AbsoluteInstant;

import org.gvsig.timesupport.AbsoluteInstantType;

import org.gvsig.timesupport.AbsoluteInstantTypeNotRegisteredException;

import org.gvsig.timesupport.AbsoluteInterval;

import org.gvsig.timesupport.AbsoluteIntervalType;

import org.gvsig.timesupport.AbsoluteIntervalTypeNotRegisteredException;

import org.gvsig.timesupport.Chronology;

import org.gvsig.timesupport.RelativeInstant;

import org.gvsig.timesupport.RelativeInterval;

import org.gvsig.timesupport.TimeSupportManager;

import org.gvsig.timesupport.animation.TimeAnimation;

import org.gvsig.timesupport.impl.animation.TimeAnimationImpl;

/**

 * Default {@link TimeSupportManager} implementation.

 * 

 * @author gvSIG Team

 * @version $Id$

 */

@SuppressWarnings("unchecked")

public class DefaultTimeSupportManager implements TimeSupportManager {

    private Logger LOG = LoggerFactory.getLogger(DefaultTimeSupportManager.class);

	private Map absoluteInstantTypes = new HashMap();

    private Map chronologyes = new HashMap();

    private Map absoluteIntervalTypes = new HashMap();

    private Chronology defaultChronology = null;

    private List relativeInstantPatterns = null;

    public DefaultTimeSupportManager(){

        relativeInstantPatterns = new ArrayList();

    }

    public void registerAbsoluteInstantType(AbsoluteInstantType absoluteInstantType) {

        absoluteInstantTypes.put(absoluteInstantType.getType(), absoluteInstantType);   

    }

    public AbsoluteInstantType getAbsoluteInstantType(int type) throws AbsoluteInstantTypeNotRegisteredException {

        if (absoluteInstantTypes.containsKey(type)){