Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /*
    *  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.util.Date;
  import java.util.Locale;
  
YearMonthDay is an immutable partial supporting the year, monthOfYear and dayOfMonth fields.

NOTE: This class only supports the three fields listed above. Thus, you cannot query the dayOfWeek or centuryOfEra fields for example. The new LocalDate class removes this restriction.

Calculations on YearMonthDay are performed using a Chronology. This chronology is set to be in the UTC time zone for all calculations.

Each individual field can be queried in two ways:

  • getMonthOfYear()
  • monthOfYear().get()
The second technique also provides access to other useful methods on the field:
  • numeric value - monthOfYear().get()
  • text value - monthOfYear().getAsText()
  • short text value - monthOfYear().getAsShortText()
  • maximum/minimum values - monthOfYear().getMaximumValue()
  • add/subtract - monthOfYear().addToCopy()
  • set - monthOfYear().setCopy()

YearMonthDay is thread-safe and immutable, provided that the Chronology is as well. All standard Chronology classes supplied are thread-safe and immutable.

Deprecated:
Use LocalDate which has a much better internal implementation and has been available since 1.3
Author(s):
Stephen Colebourne
Since:
1.0
  
  public final class YearMonthDay
          extends BasePartial
          implements ReadablePartialSerializable {

    
Serialization version
  
      private static final long serialVersionUID = 797544782896179L;
    
The singleton set of field types
  
      private static final DateTimeFieldType[] FIELD_TYPES = new DateTimeFieldType[] {
          DateTimeFieldType.year(),
          DateTimeFieldType.monthOfYear(),
          DateTimeFieldType.dayOfMonth(),
      };

    
The index of the year field in the field array
  
      public static final int YEAR = 0;
    
The index of the monthOfYear field in the field array
  
      public static final int MONTH_OF_YEAR = 1;
    
The index of the dayOfMonth field in the field array
  
      public static final int DAY_OF_MONTH = 2;
  
      //-----------------------------------------------------------------------
      
Constructs a YearMonthDay from a java.util.Calendar using exactly the same field values avoiding any time zone effects.

Each field is queried from the Calendar and assigned to the YearMonthDay. This is useful if you have been using the Calendar as a local date, ignoing the zone.

This factory method ignores the type of the calendar and always creates a YearMonthDay with ISO chronology. It is expected that you will only pass in instances of GregorianCalendar however this is not validated.

Parameters:
calendar the Calendar to extract fields from
Returns:
the created YearMonthDay
Throws:
java.lang.IllegalArgumentException if the calendar is null
java.lang.IllegalArgumentException if the date is invalid for the ISO chronology
Since:
1.2
 
     public static YearMonthDay fromCalendarFields(Calendar calendar) {
         if (calendar == null) {
             throw new IllegalArgumentException("The calendar must not be null");
         }
         return new YearMonthDay(
             calendar.get(.),
             calendar.get(.) + 1,
             calendar.get(.)
         );
     }

    
Constructs a YearMonthDay from a java.util.Date using exactly the same field values avoiding any time zone effects.

Each field is queried from the Date and assigned to the YearMonthDay. This is useful if you have been using the Date as a local date, ignoing the zone.

This factory method always creates a YearMonthDay with ISO chronology.

Parameters:
date the Date to extract fields from
Returns:
the created YearMonthDay
Throws:
java.lang.IllegalArgumentException if the calendar is null
java.lang.IllegalArgumentException if the date is invalid for the ISO chronology
Since:
1.2
 
     public static YearMonthDay fromDateFields(Date date) {
         if (date == null) {
             throw new IllegalArgumentException("The date must not be null");
         }
         return new YearMonthDay(
             date.getYear() + 1900,
             date.getMonth() + 1,
             date.getDate()
         );
     }
 
     //-----------------------------------------------------------------------
     
Constructs a YearMonthDay with the current date, using ISOChronology in the default zone to extract the fields.

The constructor uses the default time zone, resulting in the local time being initialised. Once the constructor is complete, all further calculations are performed without reference to a timezone (by switching to UTC).

 
     public YearMonthDay() {
         super();
     }

    
Constructs a YearMonthDay with the current date, using ISOChronology in the specified zone to extract the fields.

The constructor uses the specified time zone to obtain the current date. Once the constructor is complete, all further calculations are performed without reference to a timezone (by switching to UTC).

Parameters:
zone the zone to use, null means default zone
Since:
1.1
 
     public YearMonthDay(DateTimeZone zone) {
         super(ISOChronology.getInstance(zone));
     }

    
Constructs a YearMonthDay with the current date, using the specified chronology and zone to extract the fields.

The constructor uses the time zone of the chronology specified. Once the constructor is complete, all further calculations are performed without reference to a timezone (by switching to UTC).

Parameters:
chronology the chronology, null means ISOChronology in the default zone
 
     public YearMonthDay(Chronology chronology) {
         super(chronology);
     }

    
Constructs a YearMonthDay extracting the partial fields from the specified milliseconds using the ISOChronology in the default zone.

The constructor uses the default time zone, resulting in the local time being initialised. Once the constructor is complete, all further calculations are performed without reference to a timezone (by switching to UTC).

Parameters:
instant the milliseconds from 1970-01-01T00:00:00Z
 
     public YearMonthDay(long instant) {
         super(instant);
     }

    
Constructs a YearMonthDay extracting the partial fields from the specified milliseconds using the chronology provided.

The constructor uses the time zone of the chronology specified. Once the constructor is complete, all further calculations are performed without reference to a timezone (by switching to UTC).

Parameters:
instant the milliseconds from 1970-01-01T00:00:00Z
chronology the chronology, null means ISOChronology in the default zone
 
     public YearMonthDay(long instantChronology chronology) {
         super(instantchronology);
     }

    
Constructs a YearMonthDay from an Object that represents a time.

The recognised object types are defined in ConverterManager and include ReadableInstant, String, Calendar and Date. The String formats are described by org.joda.time.format.ISODateTimeFormat.dateOptionalTimeParser().

The chronology used will be derived from the object, defaulting to ISO.

NOTE: Prior to v1.3 the string format was described by org.joda.time.format.ISODateTimeFormat.dateTimeParser(). Time ony strings are now rejected.

Parameters:
instant the datetime object, null means now
Throws:
java.lang.IllegalArgumentException if the instant is invalid
 
     public YearMonthDay(Object instant) {
         super(instantnull, ISODateTimeFormat.dateOptionalTimeParser());
     }

    
Constructs a YearMonthDay from an Object that represents a time, using the specified chronology.

The recognised object types are defined in ConverterManager and include ReadableInstant, String, Calendar and Date. The String formats are described by org.joda.time.format.ISODateTimeFormat.dateOptionalTimeParser().

The constructor uses the time zone of the chronology specified. Once the constructor is complete, all further calculations are performed without reference to a timezone (by switching to UTC). The specified chronology overrides that of the object.

NOTE: Prior to v1.3 the string format was described by org.joda.time.format.ISODateTimeFormat.dateTimeParser(). Time only strings are now rejected.

Parameters:
instant the datetime object, null means now
chronology the chronology, null means ISO default
Throws:
java.lang.IllegalArgumentException if the instant is invalid
 
     public YearMonthDay(Object instantChronology chronology) {
         super(instant, DateTimeUtils.getChronology(chronology), ISODateTimeFormat.dateOptionalTimeParser());
     }

    
Constructs a YearMonthDay with specified time field values using ISOChronology in the default zone.

The constructor uses the no time zone initialising the fields as provided. Once the constructor is complete, all further calculations are performed without reference to a timezone (by switching to UTC).

Parameters:
year the year
monthOfYear the month of the year
dayOfMonth the day of the month
 
     public YearMonthDay(int yearint monthOfYearint dayOfMonth) {
         this(yearmonthOfYeardayOfMonthnull);
     }

    
Constructs a YearMonthDay with specified time field values.

The constructor uses the time zone of the chronology specified. Once the constructor is complete, all further calculations are performed without reference to a timezone (by switching to UTC).

Parameters:
year the year
monthOfYear the month of the year
dayOfMonth the day of the month
chronology the chronology, null means ISOChronology in the default zone
 
     public YearMonthDay(int yearint monthOfYearint dayOfMonthChronology chronology) {
         super(new int[] {yearmonthOfYeardayOfMonth}, chronology);
     }

    
Constructs a YearMonthDay with chronology from this instance and new values.

Parameters:
partial the partial to base this new instance on
values the new set of values
 
     YearMonthDay(YearMonthDay partialint[] values) {
         super(partialvalues);
     }

    
Constructs a YearMonthDay with values from this instance and a new chronology.

Parameters:
partial the partial to base this new instance on
chrono the new chronology
 
     YearMonthDay(YearMonthDay partialChronology chrono) {
         super(partialchrono);
     }
 
     //-----------------------------------------------------------------------
     
Gets the number of fields in this partial.

Returns:
the field count
 
     public int size() {
         return 3;
     }

    
Gets the field for a specific index in the chronology specified.

This method must not use any instance variables.

Parameters:
index the index to retrieve
chrono the chronology to use
Returns:
the field
 
     protected DateTimeField getField(int indexChronology chrono) {
         switch (index) {
             case :
                 return chrono.year();
             case :
                 return chrono.monthOfYear();
             case :
                 return chrono.dayOfMonth();
             default:
                 throw new IndexOutOfBoundsException("Invalid index: " + index);
         }
     }

    
Gets the field type at the specified index.

Parameters:
index the index to retrieve
Returns:
the field at the specified index
Throws:
java.lang.IndexOutOfBoundsException if the index is invalid
 
     public DateTimeFieldType getFieldType(int index) {
         return [index];
     }

    
Gets an array of the field type of each of the fields that this partial supports.

The fields are returned largest to smallest, Year, Month, Day

Returns:
the array of field types (cloned), largest to smallest
 
     public DateTimeFieldType[] getFieldTypes() {
         return (DateTimeFieldType[]) .clone();
     }
 
     //-----------------------------------------------------------------------
     
Returns a copy of this date with the specified chronology. This instance is immutable and unaffected by this method call.

This method retains the values of the fields, thus the result will typically refer to a different instant.

The time zone of the specified chronology is ignored, as YearMonthDay operates without a time zone.

Parameters:
newChronology the new chronology, null means ISO
Returns:
a copy of this datetime with a different chronology
Throws:
java.lang.IllegalArgumentException if the values are invalid for the new chronology
 
     public YearMonthDay withChronologyRetainFields(Chronology newChronology) {
         newChronology = DateTimeUtils.getChronology(newChronology);
         newChronology = newChronology.withUTC();
         if (newChronology == getChronology()) {
             return this;
         } else {
             YearMonthDay newYearMonthDay = new YearMonthDay(thisnewChronology);
             newChronology.validate(newYearMonthDaygetValues());
             return newYearMonthDay;
         }
     }

    
Returns a copy of this date with the specified field set to a new value.

For example, if the field type is dayOfMonth then the day would be changed in the returned instance.

These three lines are equivalent:

 YearMonthDay updated = ymd.withField(DateTimeFieldType.dayOfMonth(), 6);
 YearMonthDay updated = ymd.dayOfMonth().setCopy(6);
 YearMonthDay updated = ymd.property(DateTimeFieldType.dayOfMonth()).setCopy(6);
 

Parameters:
fieldType the field type to set, not null
value the value to set
Returns:
a copy of this instance with the field set
Throws:
java.lang.IllegalArgumentException if the value is null or invalid
 
     public YearMonthDay withField(DateTimeFieldType fieldTypeint value) {
         int index = indexOfSupported(fieldType);
         if (value == getValue(index)) {
             return this;
         }
         int[] newValues = getValues();
         newValues = getField(index).set(thisindexnewValuesvalue);
         return new YearMonthDay(thisnewValues);
     }

    
Returns a copy of this date with the value of the specified field increased.

If the addition is zero, then this is returned.

These three lines are equivalent:

 YearMonthDay added = ymd.withFieldAdded(DurationFieldType.days(), 6);
 YearMonthDay added = ymd.plusDays(6);
 YearMonthDay added = ymd.dayOfMonth().addToCopy(6);
 

Parameters:
fieldType the field type to add to, not null
amount the amount to add
Returns:
a copy of this instance with the field updated
Throws:
java.lang.IllegalArgumentException if the value is null or invalid
java.lang.ArithmeticException if the new datetime exceeds the capacity
 
     public YearMonthDay withFieldAdded(DurationFieldType fieldTypeint amount) {
         int index = indexOfSupported(fieldType);
         if (amount == 0) {
             return this;
         }
         int[] newValues = getValues();
         newValues = getField(index).add(thisindexnewValuesamount);
         return new YearMonthDay(thisnewValues);
     }

    
Returns a copy of this date with the specified period added.

If the addition is zero, then this is returned. Fields in the period that aren't present in the partial are ignored.

This method is typically used to add multiple copies of complex period instances. Adding one field is best achieved using methods like withFieldAdded(org.joda.time.DurationFieldType,int) or plusYears(int).

Parameters:
period the period to add to this one, null means zero
scalar the amount of times to add, such as -1 to subtract once
Returns:
a copy of this instance with the period added
Throws:
java.lang.ArithmeticException if the new datetime exceeds the capacity
 
     public YearMonthDay withPeriodAdded(ReadablePeriod periodint scalar) {
         if (period == null || scalar == 0) {
             return this;
         }
         int[] newValues = getValues();
         for (int i = 0; i < period.size(); i++) {
             DurationFieldType fieldType = period.getFieldType(i);
             int index = indexOf(fieldType);
             if (index >= 0) {
                 newValues = getField(index).add(thisindexnewValues,
                         FieldUtils.safeMultiply(period.getValue(i), scalar));
             }
         }
         return new YearMonthDay(thisnewValues);
     }
 
     //-----------------------------------------------------------------------
     
Returns a copy of this date with the specified period added.

If the amount is zero or null, then this is returned.

This method is typically used to add complex period instances. Adding one field is best achieved using methods like plusYears(int).

Parameters:
period the duration to add to this one, null means zero
Returns:
a copy of this instance with the period added
Throws:
java.lang.ArithmeticException if the new datetime exceeds the capacity of a long
 
     public YearMonthDay plus(ReadablePeriod period) {
         return withPeriodAdded(period, 1);
     }
 
     //-----------------------------------------------------------------------
     
Returns a copy of this date plus the specified number of years.

This date instance is immutable and unaffected by this method call.

The following three lines are identical in effect:

 YearMonthDay added = dt.plusYears(6);
 YearMonthDay added = dt.plus(Period.years(6));
 YearMonthDay added = dt.withFieldAdded(DurationFieldType.years(), 6);
 

Parameters:
years the amount of years to add, may be negative
Returns:
the new date plus the increased years
Since:
1.1
 
     public YearMonthDay plusYears(int years) {
         return withFieldAdded(DurationFieldType.years(), years);
     }

    
Returns a copy of this date plus the specified number of months.

This date instance is immutable and unaffected by this method call.

The following three lines are identical in effect:

 YearMonthDay added = dt.plusMonths(6);
 YearMonthDay added = dt.plus(Period.months(6));
 YearMonthDay added = dt.withFieldAdded(DurationFieldType.months(), 6);
 

Parameters:
months the amount of months to add, may be negative
Returns:
the new date plus the increased months
Since:
1.1
 
     public YearMonthDay plusMonths(int months) {
         return withFieldAdded(DurationFieldType.months(), months);
     }

    
Returns a copy of this date plus the specified number of days.

This date instance is immutable and unaffected by this method call.

The following three lines are identical in effect:

 YearMonthDay added = dt.plusDays(6);
 YearMonthDay added = dt.plus(Period.days(6));
 YearMonthDay added = dt.withFieldAdded(DurationFieldType.days(), 6);
 

Parameters:
days the amount of days to add, may be negative
Returns:
the new date plus the increased days
Since:
1.1
 
     public YearMonthDay plusDays(int days) {
         return withFieldAdded(DurationFieldType.days(), days);
     }
 
     //-----------------------------------------------------------------------
     
Returns a copy of this date with the specified period taken away.

If the amount is zero or null, then this is returned.

This method is typically used to subtract complex period instances. Subtracting one field is best achieved using methods like minusYears(int).

Parameters:
period the period to reduce this instant by
Returns:
a copy of this instance with the period taken away
Throws:
java.lang.ArithmeticException if the new datetime exceeds the capacity of a long
 
     public YearMonthDay minus(ReadablePeriod period) {
         return withPeriodAdded(period, -1);
     }
 
     //-----------------------------------------------------------------------
     
Returns a copy of this date minus the specified number of years.

This datetime instance is immutable and unaffected by this method call.

The following three lines are identical in effect:

 YearMonthDay subtracted = dt.minusYears(6);
 YearMonthDay subtracted = dt.minus(Period.years(6));
 YearMonthDay subtracted = dt.withFieldAdded(DurationFieldType.years(), -6);
 

Parameters:
years the amount of years to subtract, may be negative
Returns:
the new datetime minus the increased years
Since:
1.1
 
     public YearMonthDay minusYears(int years) {
         return withFieldAdded(DurationFieldType.years(), FieldUtils.safeNegate(years));
     }

    
Returns a copy of this date minus the specified number of months.

This datetime instance is immutable and unaffected by this method call.

The following three lines are identical in effect:

 YearMonthDay subtracted = dt.minusMonths(6);
 YearMonthDay subtracted = dt.minus(Period.months(6));
 YearMonthDay subtracted = dt.withFieldAdded(DurationFieldType.months(), -6);
 

Parameters:
months the amount of months to subtract, may be negative
Returns:
the new datetime minus the increased months
Since:
1.1
 
     public YearMonthDay minusMonths(int months) {
         return withFieldAdded(DurationFieldType.months(), FieldUtils.safeNegate(months));
     }

    
Returns a copy of this date minus the specified number of days.

This datetime instance is immutable and unaffected by this method call.

The following three lines are identical in effect:

 YearMonthDay subtracted = dt.minusDays(6);
 YearMonthDay subtracted = dt.minus(Period.days(6));
 YearMonthDay subtracted = dt.withFieldAdded(DurationFieldType.days(), -6);
 

Parameters:
days the amount of days to subtract, may be negative
Returns:
the new datetime minus the increased days
Since:
1.1
 
     public YearMonthDay minusDays(int days) {
         return withFieldAdded(DurationFieldType.days(), FieldUtils.safeNegate(days));
     }
 
     //-----------------------------------------------------------------------
     
Gets the property object for the specified type, which contains many useful methods.

Parameters:
type the field type to get the property for
Returns:
the property object
Throws:
java.lang.IllegalArgumentException if the field is null or unsupported
 
     public Property property(DateTimeFieldType type) {
         return new Property(thisindexOfSupported(type));
     }
 
     //-----------------------------------------------------------------------
     
Converts this object to a LocalDate with the same date and chronology.

Returns:
a LocalDate with the same date and chronology
Since:
1.3
 
     public LocalDate toLocalDate() {
         return new LocalDate(getYear(), getMonthOfYear(), getDayOfMonth(), getChronology());
     }
 
     //-----------------------------------------------------------------------
     
Converts this YearMonthDay to a full datetime at midnight using the default time zone.

Returns:
this date as a datetime at midnight
 
     public DateTime toDateTimeAtMidnight() {
         return toDateTimeAtMidnight(null);
     }

    
Converts this YearMonthDay to a full datetime at midnight using the specified time zone.

This method uses the chronology from this instance plus the time zone specified.

Parameters:
zone the zone to use, null means default
Returns:
this date as a datetime at midnight
 
     public DateTime toDateTimeAtMidnight(DateTimeZone zone) {
         Chronology chrono = getChronology().withZone(zone);
         return new DateTime(getYear(), getMonthOfYear(), getDayOfMonth(), 0, 0, 0, 0, chrono);
     }
 
     //-----------------------------------------------------------------------
     
Converts this partial to a full datetime using the default time zone setting the date fields from this instance and the time fields from the current time.

Returns:
this date as a datetime with the time as the current time
 
     public DateTime toDateTimeAtCurrentTime() {
         return toDateTimeAtCurrentTime(null);
     }

    
Converts this partial to a full datetime using the specified time zone setting the date fields from this instance and the time fields from the current time.

This method uses the chronology from this instance plus the time zone specified.

Parameters:
zone the zone to use, null means default
Returns:
this date as a datetime with the time as the current time
 
     public DateTime toDateTimeAtCurrentTime(DateTimeZone zone) {
         Chronology chrono = getChronology().withZone(zone);
         long instantMillis = DateTimeUtils.currentTimeMillis();
         long resolved = chrono.set(thisinstantMillis);
         return new DateTime(resolvedchrono);
     }
 
     //-----------------------------------------------------------------------
     
Converts this object to a DateMidnight in the default time zone.

Returns:
the DateMidnight instance in the default zone
 
     public DateMidnight toDateMidnight() {
         return toDateMidnight(null);
     }

    
Converts this object to a DateMidnight.

Parameters:
zone the zone to get the DateMidnight in, null means default
Returns:
the DateMidnight instance
 
     public DateMidnight toDateMidnight(DateTimeZone zone) {
         Chronology chrono = getChronology().withZone(zone);
         return new DateMidnight(getYear(), getMonthOfYear(), getDayOfMonth(), chrono);
     }
 
     //-----------------------------------------------------------------------
     
Converts this object to a DateTime using a TimeOfDay to fill in the missing fields and using the default time zone. This instance is immutable and unaffected by this method call.

The resulting chronology is determined by the chronology of this YearMonthDay plus the time zone. The chronology of the time is ignored - only the field values are used.

Parameters:
time the time of day to use, null means current time
Returns:
the DateTime instance
 
     public DateTime toDateTime(TimeOfDay time) {
         return toDateTime(timenull);
     }

    
Converts this object to a DateTime using a TimeOfDay to fill in the missing fields. This instance is immutable and unaffected by this method call.

The resulting chronology is determined by the chronology of this YearMonthDay plus the time zone. The chronology of the time is ignored - only the field values are used.

Parameters:
time the time of day to use, null means current time
zone the zone to get the DateTime in, null means default
Returns:
the DateTime instance
 
     public DateTime toDateTime(TimeOfDay timeDateTimeZone zone) {
         Chronology chrono = getChronology().withZone(zone);
         long instant = DateTimeUtils.currentTimeMillis();
         instant = chrono.set(thisinstant);
         if (time != null) {
             instant = chrono.set(timeinstant);
         }
         return new DateTime(instantchrono);
     }
 
     //-----------------------------------------------------------------------
     
Converts this object to an Interval representing the whole day in the default time zone.

Returns:
a interval over the day
 
     public Interval toInterval() {
         return toInterval(null);
     }

    
Converts this object to an Interval representing the whole day.

Parameters:
zone the zone to get the Interval in, null means default
Returns:
a interval over the day
 
     public Interval toInterval(DateTimeZone zone) {
         zone = DateTimeUtils.getZone(zone);
         return toDateMidnight(zone).toInterval();
     }
 
     //-----------------------------------------------------------------------
     
Get the year field value.

Returns:
the year
 
     public int getYear() {
         return getValue();
     }

    
Get the month of year field value.

Returns:
the month of year
 
     public int getMonthOfYear() {
         return getValue();
     }

    
Get the day of month field value.

Returns:
the day of month
 
     public int getDayOfMonth() {
         return getValue();
     }
 
     //-----------------------------------------------------------------------
     
Returns a copy of this date with the year field updated.

YearMonthDay is immutable, so there are no set methods. Instead, this method returns a new instance with the value of year changed.

Parameters:
year the year to set
Returns:
a copy of this object with the field set
Throws:
java.lang.IllegalArgumentException if the value is invalid
Since:
1.3
 
     public YearMonthDay withYear(int year) {
         int[] newValues = getValues();
         newValues = getChronology().year().set(thisnewValuesyear);
         return new YearMonthDay(thisnewValues);
     }

    
Returns a copy of this date with the month of year field updated.

YearMonthDay is immutable, so there are no set methods. Instead, this method returns a new instance with the value of month of year changed.

Parameters:
monthOfYear the month of year to set
Returns:
a copy of this object with the field set
Throws:
java.lang.IllegalArgumentException if the value is invalid
Since:
1.3
 
     public YearMonthDay withMonthOfYear(int monthOfYear) {
         int[] newValues = getValues();
         newValues = getChronology().monthOfYear().set(thisnewValuesmonthOfYear);
         return new YearMonthDay(thisnewValues);
     }

    
Returns a copy of this date with the day of month field updated.

YearMonthDay is immutable, so there are no set methods. Instead, this method returns a new instance with the value of day of month changed.

Parameters:
dayOfMonth the day of month to set
Returns:
a copy of this object with the field set
Throws:
java.lang.IllegalArgumentException if the value is invalid
Since:
1.3
 
     public YearMonthDay withDayOfMonth(int dayOfMonth) {
         int[] newValues = getValues();
         newValues = getChronology().dayOfMonth().set(thisnewValuesdayOfMonth);
         return new YearMonthDay(thisnewValues);
     }
 
     //-----------------------------------------------------------------------
     
Get the year field property which provides access to advanced functionality.

Returns:
the year property
 
     public Property year() {
         return new Property(this);
     }

    
Get the month of year field property which provides access to advanced functionality.

Returns:
the month of year property
 
     public Property monthOfYear() {
         return new Property(this);
     }

    
Get the day of month field property which provides access to advanced functionality.

Returns:
the day of month property
 
     public Property dayOfMonth() {
         return new Property(this);
     }
 
     //-----------------------------------------------------------------------
     
Output the date in the ISO8601 format YYYY-MM-DD.

Returns:
ISO8601 formatted string
 
     public String toString() {
         return ISODateTimeFormat.yearMonthDay().print(this);
     }
 
     //-----------------------------------------------------------------------
     
The property class for YearMonthDay.

This class binds a YearMonthDay to a DateTimeField.

Deprecated:
Use LocalDate which has a much better internal implementation
Author(s):
Stephen Colebourne
Since:
1.0
 
     @Deprecated
     public static class Property extends AbstractPartialFieldProperty implements Serializable {

        
Serialization version
 
         private static final long serialVersionUID = 5727734012190224363L;

        
The partial
 
         private final YearMonthDay iYearMonthDay;
        
The field index
 
         private final int iFieldIndex;

        
Constructs a property.

Parameters:
partial the partial instance
fieldIndex the index in the partial
 
         Property(YearMonthDay partialint fieldIndex) {
             super();
              = partial;
              = fieldIndex;
         }

        
Gets the field that this property uses.

Returns:
the field
 
         public DateTimeField getField() {
             return .getField();
         }

        
Gets the partial that this property belongs to.

Returns:
the partial
 
         protected ReadablePartial getReadablePartial() {
             return ;
         }

        
Gets the partial that this property belongs to.

Returns:
the partial
 
         public YearMonthDay getYearMonthDay() {
             return ;
         }

        
Gets the value of this field.

Returns:
the field value
 
         public int get() {
             return .getValue();
         }
 
         //-----------------------------------------------------------------------
         
Adds to the value of this field in a copy of this YearMonthDay.

The value will be added to this field. If the value is too large to be added solely to this field then it will affect larger fields. Smaller fields are unaffected.

If the result would be too large, beyond the maximum year, then an IllegalArgumentException is thrown.

The YearMonthDay attached to this property is unchanged by this call. Instead, a new instance is returned.

Parameters:
valueToAdd the value to add to the field in the copy
Returns:
a copy of the YearMonthDay with the field value changed
Throws:
java.lang.IllegalArgumentException if the value isn't valid
        public YearMonthDay addToCopy(int valueToAdd) {
            int[] newValues = .getValues();
            newValues = getField().add(newValuesvalueToAdd);
            return new YearMonthDay(newValues);
        }

        
Adds to the value of this field in a copy of this YearMonthDay wrapping within this field if the maximum value is reached.

The value will be added to this field. If the value is too large to be added solely to this field then it wraps within this field. Other fields are unaffected.

For example, 2004-12-20 addWrapField one month returns 2004-01-20.

The YearMonthDay attached to this property is unchanged by this call. Instead, a new instance is returned.

Parameters:
valueToAdd the value to add to the field in the copy
Returns:
a copy of the YearMonthDay with the field value changed
Throws:
java.lang.IllegalArgumentException if the value isn't valid
        public YearMonthDay addWrapFieldToCopy(int valueToAdd) {
            int[] newValues = .getValues();
            newValues = getField().addWrapField(newValuesvalueToAdd);
            return new YearMonthDay(newValues);
        }
        //-----------------------------------------------------------------------
        
Sets this field in a copy of the YearMonthDay.

The YearMonthDay attached to this property is unchanged by this call. Instead, a new instance is returned.

Parameters:
value the value to set the field in the copy to
Returns:
a copy of the YearMonthDay with the field value changed
Throws:
java.lang.IllegalArgumentException if the value isn't valid
        public YearMonthDay setCopy(int value) {
            int[] newValues = .getValues();
            newValues = getField().set(newValuesvalue);
            return new YearMonthDay(newValues);
        }

        
Sets this field in a copy of the YearMonthDay to a parsed text value.

The YearMonthDay attached to this property is unchanged by this call. Instead, a new instance is returned.

Parameters:
text the text value to set
locale optional locale to use for selecting a text symbol
Returns:
a copy of the YearMonthDay with the field value changed
Throws:
java.lang.IllegalArgumentException if the text value isn't valid
        public YearMonthDay setCopy(String textLocale locale) {
            int[] newValues = .getValues();
            newValues = getField().set(newValuestextlocale);
            return new YearMonthDay(newValues);
        }

        
Sets this field in a copy of the YearMonthDay to a parsed text value.

The YearMonthDay attached to this property is unchanged by this call. Instead, a new instance is returned.

Parameters:
text the text value to set
Returns:
a copy of the YearMonthDay with the field value changed
Throws:
java.lang.IllegalArgumentException if the text value isn't valid
        public YearMonthDay setCopy(String text) {
            return setCopy(textnull);
        }
        //-----------------------------------------------------------------------
        
Returns a new YearMonthDay with this field set to the maximum value for this field.

This operation is useful for obtaining a DateTime on the last day of the month, as month lengths vary.

 YearMonthDay lastDayOfMonth = dt.dayOfMonth().withMaximumValue();
 

The YearMonthDay attached to this property is unchanged by this call.

Returns:
a copy of the YearMonthDay with this field set to its maximum
Since:
1.2
        public YearMonthDay withMaximumValue() {
            return setCopy(getMaximumValue());
        }

        
Returns a new YearMonthDay with this field set to the minimum value for this field.

The YearMonthDay attached to this property is unchanged by this call.

Returns:
a copy of the YearMonthDay with this field set to its minimum
Since:
1.2
        public YearMonthDay withMinimumValue() {
            return setCopy(getMinimumValue());
        }
    }
New to GrepCode? Check out our FAQ X