Refine search
@Override public YearMonth parse(String text, Locale locale) throws ParseException { return YearMonth.parse(text); }
/** * Returns a copy of this year-month with the month of year field updated. * <p> * YearMonth is immutable, so there are no set methods. * Instead, this method returns a new instance with the value of * month of year changed. * * @param monthOfYear the month of year to set * @return a copy of this object with the field set, never null * @throws IllegalArgumentException if the value is invalid */ public YearMonth withMonthOfYear(int monthOfYear) { int[] newValues = getValues(); newValues = getChronology().monthOfYear().set(this, MONTH_OF_YEAR, newValues, monthOfYear); return new YearMonth(this, newValues); }
@Override public String print(YearMonth object, Locale locale) { return object.toString(); }
/** * Converts this object to a LocalDate with the same year-month and chronology. * * @param dayOfMonth the day of month to use, valid for chronology, such as 1-31 for ISO * @return a LocalDate with the same year-month and chronology, never null */ public LocalDate toLocalDate(int dayOfMonth) { return new LocalDate(getYear(), getMonthOfYear(), dayOfMonth, getChronology()); }
/** * Returns a copy of this year-month with the year field updated. * <p> * YearMonth is immutable, so there are no set methods. * Instead, this method returns a new instance with the value of * year changed. * * @param year the year to set * @return a copy of this object with the field set, never null * @throws IllegalArgumentException if the value is invalid */ public YearMonth withYear(int year) { int[] newValues = getValues(); newValues = getChronology().year().set(this, YEAR, newValues, year); return new YearMonth(this, newValues); }
/** * Returns a copy of this year-month with the specified field set to a new value. * <p> * For example, if the field type is <code>monthOfYear</code> then the month * would be changed in the returned instance. * <p> * These three lines are equivalent: * <pre> * YearMonth updated = ym.withField(DateTimeFieldType.monthOfYear(), 6); * YearMonth updated = ym.monthOfYear().setCopy(6); * YearMonth updated = ym.property(DateTimeFieldType.monthOfYear()).setCopy(6); * </pre> * * @param fieldType the field type to set, not null * @param value the value to set * @return a copy of this instance with the field set, never null * @throws IllegalArgumentException if the value is null or invalid */ public YearMonth withField(DateTimeFieldType fieldType, int value) { int index = indexOfSupported(fieldType); if (value == getValue(index)) { return this; } int[] newValues = getValues(); newValues = getField(index).set(this, index, newValues, value); return new YearMonth(this, newValues); }
/** * Handle broken serialization from other tools. * @return the resolved object, not null */ private Object readResolve() { if (DateTimeZone.UTC.equals(getChronology().getZone()) == false) { return new YearMonth(this, getChronology().withUTC()); } return this; }
/** * Returns a copy of this year-month with the value of the specified field increased. * <p> * If the addition is zero, then <code>this</code> is returned. * <p> * These three lines are equivalent: * <pre> * YearMonth added = ym.withFieldAdded(DurationFieldType.months(), 6); * YearMonth added = ym.plusMonths(6); * YearMonth added = ym.monthOfYear().addToCopy(6); * </pre> * * @param fieldType the field type to add to, not null * @param amount the amount to add * @return a copy of this instance with the field updated, never null * @throws IllegalArgumentException if the value is null or invalid * @throws ArithmeticException if the new date-time exceeds the capacity */ public YearMonth withFieldAdded(DurationFieldType fieldType, int amount) { int index = indexOfSupported(fieldType); if (amount == 0) { return this; } int[] newValues = getValues(); newValues = getField(index).add(this, index, newValues, amount); return new YearMonth(this, newValues); }
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(this, index, newValues, FieldUtils.safeMultiply(period.getValue(i), scalar)); return new YearMonth(this, newValues);
/** * Returns a copy of this year-month with the specified chronology. * This instance is immutable and unaffected by this method call. * <p> * This method retains the values of the fields, thus the result will * typically refer to a different instant. * <p> * The time zone of the specified chronology is ignored, as YearMonth * operates without a time zone. * * @param newChronology the new chronology, null means ISO * @return a copy of this year-month with a different chronology, never null * @throws IllegalArgumentException if the values are invalid for the new chronology */ public YearMonth withChronologyRetainFields(Chronology newChronology) { newChronology = DateTimeUtils.getChronology(newChronology); newChronology = newChronology.withUTC(); if (newChronology == getChronology()) { return this; } else { YearMonth newYearMonth = new YearMonth(this, newChronology); newChronology.validate(newYearMonth, getValues()); return newYearMonth; } }
/** * Sets this field in a copy of the YearMonth. * <p> * The YearMonth attached to this property is unchanged by this call. * Instead, a new instance is returned. * * @param value the value to set the field in the copy to * @return a copy of the YearMonth with the field value changed * @throws IllegalArgumentException if the value isn't valid */ public YearMonth setCopy(int value) { int[] newValues = iBase.getValues(); newValues = getField().set(iBase, iFieldIndex, newValues, value); return new YearMonth(iBase, newValues); }
/** * Adds to the value of this field in a copy of this YearMonth. * <p> * 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. * <p> * If the result would be too large, beyond the maximum year, then an * IllegalArgumentException is thrown. * <p> * The YearMonth attached to this property is unchanged by this call. * Instead, a new instance is returned. * * @param valueToAdd the value to add to the field in the copy * @return a copy of the YearMonth with the field value changed * @throws IllegalArgumentException if the value isn't valid */ public YearMonth addToCopy(int valueToAdd) { int[] newValues = iBase.getValues(); newValues = getField().add(iBase, iFieldIndex, newValues, valueToAdd); return new YearMonth(iBase, newValues); }
/** * Converts this object to an Interval representing the whole month. * <p> * The interval will use the chronology of the year-month in the specified zone. * <p> * This instance is immutable and unaffected by this method call. * * @param zone the zone to get the Interval in, null means default * @return an interval over the month, never null */ public Interval toInterval(DateTimeZone zone) { zone = DateTimeUtils.getZone(zone); DateTime start = toLocalDate(1).toDateTimeAtStartOfDay(zone); DateTime end = plusMonths(1).toLocalDate(1).toDateTimeAtStartOfDay(zone); return new Interval(start, end); }
/** * Adds to the value of this field in a copy of this YearMonth wrapping * within this field if the maximum value is reached. * <p> * 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. * <p> * For example, * <code>2004-12</code> addWrapField one month returns <code>2004-01</code>. * <p> * The YearMonth attached to this property is unchanged by this call. * Instead, a new instance is returned. * * @param valueToAdd the value to add to the field in the copy * @return a copy of the YearMonth with the field value changed * @throws IllegalArgumentException if the value isn't valid */ public YearMonth addWrapFieldToCopy(int valueToAdd) { int[] newValues = iBase.getValues(); newValues = getField().addWrapField(iBase, iFieldIndex, newValues, valueToAdd); return new YearMonth(iBase, newValues); }
private PersistableMonthItem getMonthItem(PersistablePublicationDownload download, PersistableAbstractReportItem<?> item) { YearMonth yearMonth = new YearMonth(download.getDownloadDate()); for (PersistableMonthItem monthItem : item.getMonthCounts()) { YearMonth itemYearMonth = new YearMonth(monthItem.getYear(), monthItem.getMonth()); if (itemYearMonth.equals(yearMonth)) { return monthItem; } } PersistableMonthItem monthItem = new PersistableMonthItem(); monthItem.setReportItem(item); monthItem.setMonth(yearMonth.getMonthOfYear()); monthItem.setYear(yearMonth.getYear()); item.getMonthCounts().add(monthItem); return monthItem; }
private int getIntervalColumnsCount(Date intervalFrom, Date intervalTo) { YearMonth yearMonthStart = new YearMonth(intervalFrom.getTime()); YearMonth yearMonthEnd = new YearMonth(intervalTo.getTime()); int yearsDifference = yearMonthEnd.getYear() - yearMonthStart.getYear(); int monthsDifference = yearMonthEnd.getMonthOfYear() - yearMonthStart.getMonthOfYear(); return 1 + yearsDifference * 12 + monthsDifference; }
/** * Obtains a {@code YearMonth} set to the current system millisecond time * using <code>ISOChronology</code> in the default time zone. * The resulting object does not use the zone. * * @return the current year-month, not null * @since 2.0 */ public static YearMonth now() { return new YearMonth(); }
/** * Get the year field value. * * @return the year */ public int getYear() { return getValue(YEAR); }
@Test(dataProvider = "string2ym") public void testString2Java8YearMonth(String s, YearMonth ym) throws Exception { String2Java8YearMonth convertor = new String2Java8YearMonth(); Assert.assertEquals(convertor.convert(s), java.time.YearMonth.of(ym.getYear(), ym.getMonthOfYear())); } }
private List<YearMonth> getMonths(Date intervalFrom, Date intervalTo) { int intervalColumnsCount = getIntervalColumnsCount(intervalFrom, intervalTo); List<YearMonth> months = new ArrayList<>(); YearMonth yearMonth = new YearMonth(intervalFrom); for (int i = 0; i < intervalColumnsCount; i++) { months.add(yearMonth); yearMonth = yearMonth.plusMonths(1); } return months; }