Java tutorial
/* * Copyright 2001-2011 Stephen Colebourne * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.joda.time; import java.io.Serializable; import org.joda.convert.FromString; import org.joda.time.base.BasePeriod; import org.joda.time.field.FieldUtils; import org.joda.time.format.ISOPeriodFormat; import org.joda.time.format.PeriodFormatter; /** * Standard mutable time period implementation. * <p> * A time period is divided into a number of fields, such as hours and seconds. * Which fields are supported is defined by the PeriodType class. * The default is the standard period type, which supports years, months, weeks, days, * hours, minutes, seconds and millis. * <p> * When this time period is added to an instant, the effect is of adding each field in turn. * As a result, this takes into account daylight savings time. * Adding a time period of 1 day to the day before daylight savings starts will only add * 23 hours rather than 24 to ensure that the time remains the same. * If this is not the behaviour you want, then see {@link Duration}. * <p> * The definition of a period also affects the equals method. A period of 1 * day is not equal to a period of 24 hours, nor 1 hour equal to 60 minutes. * This is because periods represent an abstracted definition of a time period * (eg. a day may not actually be 24 hours, it might be 23 or 25 at daylight * savings boundary). To compare the actual duration of two periods, convert * both to durations using toDuration, an operation that emphasises that the * result may differ according to the date you choose. * <p> * MutablePeriod is mutable and not thread-safe, unless concurrent threads * are not invoking mutator methods. * * @author Brian S O'Neill * @author Stephen Colebourne * @since 1.0 * @see Period */ public class MutablePeriod extends BasePeriod implements ReadWritablePeriod, Cloneable, Serializable { /** Serialization version */ private static final long serialVersionUID = 3436451121567212165L; //----------------------------------------------------------------------- /** * Parses a {@code MutablePeriod} from the specified string. * <p> * This uses {@link ISOPeriodFormat#standard()}. * * @param str the string to parse, not null * @since 2.0 */ @FromString public static MutablePeriod parse(String str) { return parse(str, ISOPeriodFormat.standard()); } /** * Parses a {@code MutablePeriod} from the specified string using a formatter. * * @param str the string to parse, not null * @param formatter the formatter to use, not null * @since 2.0 */ public static MutablePeriod parse(String str, PeriodFormatter formatter) { return formatter.parsePeriod(str).toMutablePeriod(); } //----------------------------------------------------------------------- /** * Creates a zero-length period using the standard period type. */ public MutablePeriod() { super(0L, null, null); } /** * Creates a zero-length period using the specified period type. * * @param type which set of fields this period supports */ public MutablePeriod(PeriodType type) { super(0L, type, null); } /** * Create a period from a set of field values using the standard set of fields. * * @param hours amount of hours in this period * @param minutes amount of minutes in this period * @param seconds amount of seconds in this period * @param millis amount of milliseconds in this period */ public MutablePeriod(int hours, int minutes, int seconds, int millis) { super(0, 0, 0, 0, hours, minutes, seconds, millis, PeriodType.standard()); } /** * Create a period from a set of field values using the standard set of fields. * * @param years amount of years in this period * @param months amount of months in this period * @param weeks amount of weeks in this period * @param days amount of days in this period * @param hours amount of hours in this period * @param minutes amount of minutes in this period * @param seconds amount of seconds in this period * @param millis amount of milliseconds in this period */ public MutablePeriod(int years, int months, int weeks, int days, int hours, int minutes, int seconds, int millis) { super(years, months, weeks, days, hours, minutes, seconds, millis, PeriodType.standard()); } /** * Create a period from a set of field values. * * @param years amount of years in this period, which must be zero if unsupported * @param months amount of months in this period, which must be zero if unsupported * @param weeks amount of weeks in this period, which must be zero if unsupported * @param days amount of days in this period, which must be zero if unsupported * @param hours amount of hours in this period, which must be zero if unsupported * @param minutes amount of minutes in this period, which must be zero if unsupported * @param seconds amount of seconds in this period, which must be zero if unsupported * @param millis amount of milliseconds in this period, which must be zero if unsupported * @param type which set of fields this period supports, null means AllType * @throws IllegalArgumentException if an unsupported field's value is non-zero */ public MutablePeriod(int years, int months, int weeks, int days, int hours, int minutes, int seconds, int millis, PeriodType type) { super(years, months, weeks, days, hours, minutes, seconds, millis, type); } /** * Creates a period from the given millisecond duration using the standard * set of fields. * <p> * Only precise fields in the period type will be used. * For the standard period type this is the time fields only. * Thus the year, month, week and day fields will not be populated. * <p> * If the duration is small, less than one day, then this method will perform * as you might expect and split the fields evenly. * <p> * If the duration is larger than one day then all the remaining duration will * be stored in the largest available precise field, hours in this case. * <p> * For example, a duration equal to (365 + 60 + 5) days will be converted to * ((365 + 60 + 5) * 24) hours by this constructor. * <p> * For more control over the conversion process, you have two options: * <ul> * <li>convert the duration to an {@link Interval}, and from there obtain the period * <li>specify a period type that contains precise definitions of the day and larger * fields, such as the UTC or precise types. * </ul> * * @param duration the duration, in milliseconds */ public MutablePeriod(long duration) { super(duration); } /** * Creates a period from the given millisecond duration. * <p> * Only precise fields in the period type will be used. * Imprecise fields will not be populated. * <p> * If the duration is small then this method will perform * as you might expect and split the fields evenly. * <p> * If the duration is large then all the remaining duration will * be stored in the largest available precise field. * For details as to which fields are precise, review the period type javadoc. * * @param duration the duration, in milliseconds * @param type which set of fields this period supports, null means standard */ public MutablePeriod(long duration, PeriodType type) { super(duration, type, null); } /** * Creates a period from the given millisecond duration using the standard * set of fields. * <p> * Only precise fields in the period type will be used. * Imprecise fields will not be populated. * <p> * If the duration is small then this method will perform * as you might expect and split the fields evenly. * <p> * If the duration is large then all the remaining duration will * be stored in the largest available precise field. * For details as to which fields are precise, review the period type javadoc. * * @param duration the duration, in milliseconds * @param chronology the chronology to use to split the duration, null means ISO default */ public MutablePeriod(long duration, Chronology chronology) { super(duration, null, chronology); } /** * Creates a period from the given millisecond duration. * <p> * Only precise fields in the period type will be used. * Imprecise fields will not be populated. * <p> * If the duration is small then this method will perform * as you might expect and split the fields evenly. * <p> * If the duration is large then all the remaining duration will * be stored in the largest available precise field. * For details as to which fields are precise, review the period type javadoc. * * @param duration the duration, in milliseconds * @param type which set of fields this period supports, null means standard * @param chronology the chronology to use to split the duration, null means ISO default */ public MutablePeriod(long duration, PeriodType type, Chronology chronology) { super(duration, type, chronology); } /** * Creates a period from the given interval endpoints using the standard * set of fields. * * @param startInstant interval start, in milliseconds * @param endInstant interval end, in milliseconds */ public MutablePeriod(long startInstant, long endInstant) { super(startInstant, endInstant, null, null); } /** * Creates a period from the given interval endpoints. * * @param startInstant interval start, in milliseconds * @param endInstant interval end, in milliseconds * @param type which set of fields this period supports, null means standard */ public MutablePeriod(long startInstant, long endInstant, PeriodType type) { super(startInstant, endInstant, type, null); } /** * Creates a period from the given interval endpoints using the standard * set of fields. * * @param startInstant interval start, in milliseconds * @param endInstant interval end, in milliseconds * @param chrono the chronology to use, null means ISO in default zone */ public MutablePeriod(long startInstant, long endInstant, Chronology chrono) { super(startInstant, endInstant, null, chrono); } /** * Creates a period from the given interval endpoints. * * @param startInstant interval start, in milliseconds * @param endInstant interval end, in milliseconds * @param type which set of fields this period supports, null means standard * @param chrono the chronology to use, null means ISO in default zone */ public MutablePeriod(long startInstant, long endInstant, PeriodType type, Chronology chrono) { super(startInstant, endInstant, type, chrono); } /** * Creates a period from the given interval endpoints using the standard * set of fields. * <p> * The chronology of the start instant is used, unless that is null when the * chronology of the end instant is used instead. * * @param startInstant interval start, null means now * @param endInstant interval end, null means now */ public MutablePeriod(ReadableInstant startInstant, ReadableInstant endInstant) { super(startInstant, endInstant, null); } /** * Creates a period from the given interval endpoints. * <p> * The chronology of the start instant is used, unless that is null when the * chronology of the end instant is used instead. * * @param startInstant interval start, null means now * @param endInstant interval end, null means now * @param type which set of fields this period supports, null means AllType */ public MutablePeriod(ReadableInstant startInstant, ReadableInstant endInstant, PeriodType type) { super(startInstant, endInstant, type); } /** * Creates a period from the given start point and the duration. * * @param startInstant the interval start, null means now * @param duration the duration of the interval, null means zero-length */ public MutablePeriod(ReadableInstant startInstant, ReadableDuration duration) { super(startInstant, duration, null); } /** * Creates a period from the given start point and the duration. * * @param startInstant the interval start, null means now * @param duration the duration of the interval, null means zero-length * @param type which set of fields this period supports, null means standard */ public MutablePeriod(ReadableInstant startInstant, ReadableDuration duration, PeriodType type) { super(startInstant, duration, type); } /** * Creates a period from the given duration and end point. * * @param duration the duration of the interval, null means zero-length * @param endInstant the interval end, null means now */ public MutablePeriod(ReadableDuration duration, ReadableInstant endInstant) { super(duration, endInstant, null); } /** * Creates a period from the given duration and end point. * * @param duration the duration of the interval, null means zero-length * @param endInstant the interval end, null means now * @param type which set of fields this period supports, null means standard */ public MutablePeriod(ReadableDuration duration, ReadableInstant endInstant, PeriodType type) { super(duration, endInstant, type); } /** * Creates a period by converting or copying from another object. * <p> * The recognised object types are defined in * {@link org.joda.time.convert.ConverterManager ConverterManager} and * include ReadablePeriod, ReadableInterval and String. * The String formats are described by {@link ISOPeriodFormat#standard()}. * * @param period period to convert * @throws IllegalArgumentException if period is invalid * @throws UnsupportedOperationException if an unsupported field's value is non-zero */ public MutablePeriod(Object period) { super(period, null, null); } /** * Creates a period by converting or copying from another object. * <p> * The recognised object types are defined in * {@link org.joda.time.convert.ConverterManager ConverterManager} and * include ReadablePeriod, ReadableInterval and String. * The String formats are described by {@link ISOPeriodFormat#standard()}. * * @param period period to convert * @param type which set of fields this period supports, null means use converter * @throws IllegalArgumentException if period is invalid * @throws UnsupportedOperationException if an unsupported field's value is non-zero */ public MutablePeriod(Object period, PeriodType type) { super(period, type, null); } /** * Creates a period by converting or copying from another object. * <p> * The recognised object types are defined in * {@link org.joda.time.convert.ConverterManager ConverterManager} and * include ReadablePeriod, ReadableInterval and String. * The String formats are described by {@link ISOPeriodFormat#standard()}. * * @param period period to convert * @param chrono the chronology to use, null means ISO in default zone * @throws IllegalArgumentException if period is invalid * @throws UnsupportedOperationException if an unsupported field's value is non-zero */ public MutablePeriod(Object period, Chronology chrono) { super(period, null, chrono); } /** * Creates a period by converting or copying from another object. * <p> * The recognised object types are defined in * {@link org.joda.time.convert.ConverterManager ConverterManager} and * include ReadablePeriod, ReadableInterval and String. * The String formats are described by {@link ISOPeriodFormat#standard()}. * * @param period period to convert * @param type which set of fields this period supports, null means use converter * @param chrono the chronology to use, null means ISO in default zone * @throws IllegalArgumentException if period is invalid * @throws UnsupportedOperationException if an unsupported field's value is non-zero */ public MutablePeriod(Object period, PeriodType type, Chronology chrono) { super(period, type, chrono); } //----------------------------------------------------------------------- /** * Clears the period, setting all values back to zero. */ public void clear() { super.setValues(new int[size()]); } /** * Sets the value of one of the fields by index. * * @param index the field index * @param value the new value for the field * @throws IndexOutOfBoundsException if the index is invalid */ public void setValue(int index, int value) { super.setValue(index, value); } /** * Sets the value of one of the fields. * <p> * The field type specified must be one of those that is supported by the period. * * @param field a DurationFieldType instance that is supported by this period, not null * @param value the new value for the field * @throws IllegalArgumentException if the field is null or not supported */ public void set(DurationFieldType field, int value) { super.setField(field, value); } /** * Sets all the fields in one go from another ReadablePeriod. * * @param period the period to set, null means zero length period * @throws IllegalArgumentException if an unsupported field's value is non-zero */ public void setPeriod(ReadablePeriod period) { super.setPeriod(period); } /** * Sets all the fields in one go. * * @param years amount of years in this period, which must be zero if unsupported * @param months amount of months in this period, which must be zero if unsupported * @param weeks amount of weeks in this period, which must be zero if unsupported * @param days amount of days in this period, which must be zero if unsupported * @param hours amount of hours in this period, which must be zero if unsupported * @param minutes amount of minutes in this period, which must be zero if unsupported * @param seconds amount of seconds in this period, which must be zero if unsupported * @param millis amount of milliseconds in this period, which must be zero if unsupported * @throws IllegalArgumentException if an unsupported field's value is non-zero */ public void setPeriod(int years, int months, int weeks, int days, int hours, int minutes, int seconds, int millis) { super.setPeriod(years, months, weeks, days, hours, minutes, seconds, millis); } /** * Sets all the fields in one go from an interval using the ISO chronology * and dividing the fields using the period type. * * @param interval the interval to set, null means zero length * @throws ArithmeticException if the set exceeds the capacity of the period */ public void setPeriod(ReadableInterval interval) { if (interval == null) { setPeriod(0L); } else { Chronology chrono = DateTimeUtils.getChronology(interval.getChronology()); setPeriod(interval.getStartMillis(), interval.getEndMillis(), chrono); } } /** * Sets all the fields in one go from two instants representing an interval. * <p> * The chronology of the start instant is used, unless that is null when the * chronology of the end instant is used instead. * * @param start the start instant, null means now * @param end the end instant, null means now * @throws ArithmeticException if the set exceeds the capacity of the period */ public void setPeriod(ReadableInstant start, ReadableInstant end) { if (start == end) { setPeriod(0L); } else { long startMillis = DateTimeUtils.getInstantMillis(start); long endMillis = DateTimeUtils.getInstantMillis(end); Chronology chrono = DateTimeUtils.getIntervalChronology(start, end); setPeriod(startMillis, endMillis, chrono); } } /** * Sets all the fields in one go from a millisecond interval using ISOChronology * and dividing the fields using the period type. * * @param startInstant interval start, in milliseconds * @param endInstant interval end, in milliseconds * @throws ArithmeticException if the set exceeds the capacity of the period */ public void setPeriod(long startInstant, long endInstant) { setPeriod(startInstant, endInstant, null); } /** * Sets all the fields in one go from a millisecond interval. * * @param startInstant interval start, in milliseconds * @param endInstant interval end, in milliseconds * @param chrono the chronology to use, null means ISO chronology * @throws ArithmeticException if the set exceeds the capacity of the period */ public void setPeriod(long startInstant, long endInstant, Chronology chrono) { chrono = DateTimeUtils.getChronology(chrono); setValues(chrono.get(this, startInstant, endInstant)); } /** * Sets all the fields in one go from a duration dividing the * fields using the period type. * <p> * When dividing the duration, only precise fields in the period type will be used. * For large durations, all the remaining duration will be stored in the largest * available precise field. * * @param duration the duration to set, null means zero length * @throws ArithmeticException if the set exceeds the capacity of the period */ public void setPeriod(ReadableDuration duration) { setPeriod(duration, null); } /** * Sets all the fields in one go from a duration dividing the * fields using the period type. * <p> * When dividing the duration, only precise fields in the period type will be used. * For large durations, all the remaining duration will be stored in the largest * available precise field. * * @param duration the duration to set, null means zero length * @param chrono the chronology to use, null means ISO default * @throws ArithmeticException if the set exceeds the capacity of the period */ public void setPeriod(ReadableDuration duration, Chronology chrono) { long durationMillis = DateTimeUtils.getDurationMillis(duration); setPeriod(durationMillis, chrono); } /** * Sets all the fields in one go from a millisecond duration dividing the * fields using the period type. * <p> * When dividing the duration, only precise fields in the period type will be used. * For large durations, all the remaining duration will be stored in the largest * available precise field. * * @param duration the duration, in milliseconds * @throws ArithmeticException if the set exceeds the capacity of the period */ public void setPeriod(long duration) { setPeriod(duration, null); } /** * Sets all the fields in one go from a millisecond duration. * <p> * When dividing the duration, only precise fields in the period type will be used. * For large durations, all the remaining duration will be stored in the largest * available precise field. * * @param duration the duration, in milliseconds * @param chrono the chronology to use, null means ISO chronology * @throws ArithmeticException if the set exceeds the capacity of the period */ public void setPeriod(long duration, Chronology chrono) { chrono = DateTimeUtils.getChronology(chrono); setValues(chrono.get(this, duration)); } //----------------------------------------------------------------------- /** * Adds to the value of one of the fields. * <p> * The field type specified must be one of those that is supported by the period. * * @param field a DurationFieldType instance that is supported by this period, not null * @param value the value to add to the field * @throws IllegalArgumentException if the field is null or not supported */ public void add(DurationFieldType field, int value) { super.addField(field, value); } /** * Adds a period to this one by adding each field in turn. * * @param period the period to add, null means add nothing * @throws IllegalArgumentException if the period being added contains a field * not supported by this period * @throws ArithmeticException if the addition exceeds the capacity of the period */ public void add(ReadablePeriod period) { super.addPeriod(period); } /** * Adds to each field of this period. * * @param years amount of years to add to this period, which must be zero if unsupported * @param months amount of months to add to this period, which must be zero if unsupported * @param weeks amount of weeks to add to this period, which must be zero if unsupported * @param days amount of days to add to this period, which must be zero if unsupported * @param hours amount of hours to add to this period, which must be zero if unsupported * @param minutes amount of minutes to add to this period, which must be zero if unsupported * @param seconds amount of seconds to add to this period, which must be zero if unsupported * @param millis amount of milliseconds to add to this period, which must be zero if unsupported * @throws IllegalArgumentException if the period being added contains a field * not supported by this period * @throws ArithmeticException if the addition exceeds the capacity of the period */ public void add(int years, int months, int weeks, int days, int hours, int minutes, int seconds, int millis) { setPeriod(FieldUtils.safeAdd(getYears(), years), FieldUtils.safeAdd(getMonths(), months), FieldUtils.safeAdd(getWeeks(), weeks), FieldUtils.safeAdd(getDays(), days), FieldUtils.safeAdd(getHours(), hours), FieldUtils.safeAdd(getMinutes(), minutes), FieldUtils.safeAdd(getSeconds(), seconds), FieldUtils.safeAdd(getMillis(), millis)); } /** * Adds an interval to this one by dividing the interval into * fields and calling {@link #add(ReadablePeriod)}. * * @param interval the interval to add, null means add nothing * @throws ArithmeticException if the addition exceeds the capacity of the period */ public void add(ReadableInterval interval) { if (interval != null) { add(interval.toPeriod(getPeriodType())); } } /** * Adds a duration to this one by dividing the duration into * fields and calling {@link #add(ReadablePeriod)}. * * @param duration the duration to add, null means add nothing * @throws ArithmeticException if the addition exceeds the capacity of the period */ public void add(ReadableDuration duration) { if (duration != null) { add(new Period(duration.getMillis(), getPeriodType())); } } /** * Adds a millisecond duration to this one by dividing the duration into * fields and calling {@link #add(ReadablePeriod)}. * <p> * When dividing the duration, only precise fields in the period type will be used. * For large durations, all the remaining duration will be stored in the largest * available precise field. * * @param duration the duration, in milliseconds * @throws ArithmeticException if the addition exceeds the capacity of the period */ public void add(long duration) { add(new Period(duration, getPeriodType())); } /** * Adds a millisecond duration to this one by dividing the duration into * fields and calling {@link #add(ReadablePeriod)}. * <p> * When dividing the duration, only precise fields in the period type will be used. * For large durations, all the remaining duration will be stored in the largest * available precise field. * * @param duration the duration, in milliseconds * @param chrono the chronology to use, null means ISO default * @throws ArithmeticException if the addition exceeds the capacity of the period */ public void add(long duration, Chronology chrono) { add(new Period(duration, getPeriodType(), chrono)); } //----------------------------------------------------------------------- /** * Merges all the fields from the specified period into this one. * <p> * Fields that are not present in the specified period are left unaltered. * * @param period the period to set, null ignored * @throws IllegalArgumentException if an unsupported field's value is non-zero */ public void mergePeriod(ReadablePeriod period) { super.mergePeriod(period); } //----------------------------------------------------------------------- /** * Gets the years field part of the period. * * @return the number of years in the period, zero if unsupported */ public int getYears() { return getPeriodType().getIndexedField(this, PeriodType.YEAR_INDEX); } /** * Gets the months field part of the period. * * @return the number of months in the period, zero if unsupported */ public int getMonths() { return getPeriodType().getIndexedField(this, PeriodType.MONTH_INDEX); } /** * Gets the weeks field part of the period. * * @return the number of weeks in the period, zero if unsupported */ public int getWeeks() { return getPeriodType().getIndexedField(this, PeriodType.WEEK_INDEX); } /** * Gets the days field part of the period. * * @return the number of days in the period, zero if unsupported */ public int getDays() { return getPeriodType().getIndexedField(this, PeriodType.DAY_INDEX); } //----------------------------------------------------------------------- /** * Gets the hours field part of the period. * * @return the number of hours in the period, zero if unsupported */ public int getHours() { return getPeriodType().getIndexedField(this, PeriodType.HOUR_INDEX); } /** * Gets the minutes field part of the period. * * @return the number of minutes in the period, zero if unsupported */ public int getMinutes() { return getPeriodType().getIndexedField(this, PeriodType.MINUTE_INDEX); } /** * Gets the seconds field part of the period. * * @return the number of seconds in the period, zero if unsupported */ public int getSeconds() { return getPeriodType().getIndexedField(this, PeriodType.SECOND_INDEX); } /** * Gets the millis field part of the period. * * @return the number of millis in the period, zero if unsupported */ public int getMillis() { return getPeriodType().getIndexedField(this, PeriodType.MILLI_INDEX); } //----------------------------------------------------------------------- /** * Sets the number of years of the period. * * @param years the number of years * @throws IllegalArgumentException if field is not supported and the value is non-zero */ public void setYears(int years) { super.setField(DurationFieldType.years(), years); } /** * Adds the specified years to the number of years in the period. * * @param years the number of years * @throws IllegalArgumentException if field is not supported and the value is non-zero * @throws ArithmeticException if the addition exceeds the capacity of the period */ public void addYears(int years) { super.addField(DurationFieldType.years(), years); } //----------------------------------------------------------------------- /** * Sets the number of months of the period. * * @param months the number of months * @throws IllegalArgumentException if field is not supported and the value is non-zero */ public void setMonths(int months) { super.setField(DurationFieldType.months(), months); } /** * Adds the specified months to the number of months in the period. * * @param months the number of months * @throws IllegalArgumentException if field is not supported and the value is non-zero * @throws ArithmeticException if the addition exceeds the capacity of the period */ public void addMonths(int months) { super.addField(DurationFieldType.months(), months); } //----------------------------------------------------------------------- /** * Sets the number of weeks of the period. * * @param weeks the number of weeks * @throws IllegalArgumentException if field is not supported and the value is non-zero */ public void setWeeks(int weeks) { super.setField(DurationFieldType.weeks(), weeks); } /** * Adds the specified weeks to the number of weeks in the period. * * @param weeks the number of weeks * @throws IllegalArgumentException if field is not supported and the value is non-zero * @throws ArithmeticException if the addition exceeds the capacity of the period */ public void addWeeks(int weeks) { super.addField(DurationFieldType.weeks(), weeks); } //----------------------------------------------------------------------- /** * Sets the number of days of the period. * * @param days the number of days * @throws IllegalArgumentException if field is not supported and the value is non-zero */ public void setDays(int days) { super.setField(DurationFieldType.days(), days); } /** * Adds the specified days to the number of days in the period. * * @param days the number of days * @throws IllegalArgumentException if field is not supported and the value is non-zero * @throws ArithmeticException if the addition exceeds the capacity of the period */ public void addDays(int days) { super.addField(DurationFieldType.days(), days); } //----------------------------------------------------------------------- /** * Sets the number of hours of the period. * * @param hours the number of hours * @throws IllegalArgumentException if field is not supported and the value is non-zero */ public void setHours(int hours) { super.setField(DurationFieldType.hours(), hours); } /** * Adds the specified hours to the number of hours in the period. * * @param hours the number of hours * @throws IllegalArgumentException if field is not supported and the value is non-zero * @throws ArithmeticException if the addition exceeds the capacity of the period */ public void addHours(int hours) { super.addField(DurationFieldType.hours(), hours); } //----------------------------------------------------------------------- /** * Sets the number of minutes of the period. * * @param minutes the number of minutes * @throws IllegalArgumentException if field is not supported and the value is non-zero */ public void setMinutes(int minutes) { super.setField(DurationFieldType.minutes(), minutes); } /** * Adds the specified minutes to the number of minutes in the period. * * @param minutes the number of minutes * @throws IllegalArgumentException if field is not supported and the value is non-zero * @throws ArithmeticException if the addition exceeds the capacity of the period */ public void addMinutes(int minutes) { super.addField(DurationFieldType.minutes(), minutes); } //----------------------------------------------------------------------- /** * Sets the number of seconds of the period. * * @param seconds the number of seconds * @throws IllegalArgumentException if field is not supported and the value is non-zero */ public void setSeconds(int seconds) { super.setField(DurationFieldType.seconds(), seconds); } /** * Adds the specified seconds to the number of seconds in the period. * * @param seconds the number of seconds * @throws IllegalArgumentException if field is not supported and the value is non-zero * @throws ArithmeticException if the addition exceeds the capacity of the period */ public void addSeconds(int seconds) { super.addField(DurationFieldType.seconds(), seconds); } //----------------------------------------------------------------------- /** * Sets the number of millis of the period. * * @param millis the number of millis * @throws IllegalArgumentException if field is not supported and the value is non-zero */ public void setMillis(int millis) { super.setField(DurationFieldType.millis(), millis); } /** * Adds the specified millis to the number of millis in the period. * * @param millis the number of millis * @throws IllegalArgumentException if field is not supported and the value is non-zero * @throws ArithmeticException if the addition exceeds the capacity of the period */ public void addMillis(int millis) { super.addField(DurationFieldType.millis(), millis); } // Misc //----------------------------------------------------------------------- /** * Clone this object without having to cast the returned object. * * @return a clone of the this object. */ public MutablePeriod copy() { return (MutablePeriod) clone(); } /** * Clone this object. * * @return a clone of this object. */ public Object clone() { try { return super.clone(); } catch (CloneNotSupportedException ex) { throw new InternalError("Clone error"); } } }