443 lines
20 KiB
Java
443 lines
20 KiB
Java
package o;
|
|
|
|
import java.io.InvalidObjectException;
|
|
import java.io.Serializable;
|
|
import java.util.GregorianCalendar;
|
|
import java.util.Locale;
|
|
import java.util.Map;
|
|
import java.util.concurrent.ConcurrentHashMap;
|
|
import java.util.concurrent.ConcurrentMap;
|
|
import org.threeten.bp.DateTimeException;
|
|
|
|
/* loaded from: classes6.dex */
|
|
public final class gtS implements Serializable {
|
|
private static final ConcurrentMap<String, gtS> CACHE = new ConcurrentHashMap(4, 0.75f, 2);
|
|
public static final gtS ISO = new gtS(EnumC15515gsk.MONDAY, 4);
|
|
public static final gtS SUNDAY_START = of(EnumC15515gsk.SUNDAY, 1);
|
|
private static final long serialVersionUID = -1177360819670808121L;
|
|
private final EnumC15515gsk firstDayOfWeek;
|
|
private final int minimalDays;
|
|
private final transient InterfaceC15537gtP dayOfWeek = RVV.ofDayOfWeekField(this);
|
|
private final transient InterfaceC15537gtP weekOfMonth = RVV.ofWeekOfMonthField(this);
|
|
private final transient InterfaceC15537gtP weekOfYear = RVV.ofWeekOfYearField(this);
|
|
private final transient InterfaceC15537gtP weekOfWeekBasedYear = RVV.ofWeekOfWeekBasedYearField(this);
|
|
private final transient InterfaceC15537gtP weekBasedYear = RVV.ofWeekBasedYearField(this);
|
|
|
|
public static gtS of(Locale locale) {
|
|
gtG.requireNonNull(locale, "locale");
|
|
return of(EnumC15515gsk.SUNDAY.plus(r4.getFirstDayOfWeek() - 1), new GregorianCalendar(new Locale(locale.getLanguage(), locale.getCountry())).getMinimalDaysInFirstWeek());
|
|
}
|
|
|
|
public static gtS of(EnumC15515gsk enumC15515gsk, int i) {
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.append(enumC15515gsk.toString());
|
|
sb.append(i);
|
|
String obj = sb.toString();
|
|
ConcurrentMap<String, gtS> concurrentMap = CACHE;
|
|
gtS gts = concurrentMap.get(obj);
|
|
if (gts != null) {
|
|
return gts;
|
|
}
|
|
concurrentMap.putIfAbsent(obj, new gtS(enumC15515gsk, i));
|
|
return concurrentMap.get(obj);
|
|
}
|
|
|
|
private gtS(EnumC15515gsk enumC15515gsk, int i) {
|
|
gtG.requireNonNull(enumC15515gsk, "firstDayOfWeek");
|
|
if (i <= 0 || i > 7) {
|
|
throw new IllegalArgumentException("Minimal number of days is invalid");
|
|
}
|
|
this.firstDayOfWeek = enumC15515gsk;
|
|
this.minimalDays = i;
|
|
}
|
|
|
|
private Object readResolve() throws InvalidObjectException {
|
|
try {
|
|
return of(this.firstDayOfWeek, this.minimalDays);
|
|
} catch (IllegalArgumentException e) {
|
|
StringBuilder sb = new StringBuilder("Invalid WeekFields");
|
|
sb.append(e.getMessage());
|
|
throw new InvalidObjectException(sb.toString());
|
|
}
|
|
}
|
|
|
|
public final boolean equals(Object obj) {
|
|
if (this == obj) {
|
|
return true;
|
|
}
|
|
return (obj instanceof gtS) && hashCode() == obj.hashCode();
|
|
}
|
|
|
|
public final int hashCode() {
|
|
return (this.firstDayOfWeek.ordinal() * 7) + this.minimalDays;
|
|
}
|
|
|
|
public final String toString() {
|
|
StringBuilder sb = new StringBuilder("WeekFields[");
|
|
sb.append(this.firstDayOfWeek);
|
|
sb.append(',');
|
|
sb.append(this.minimalDays);
|
|
sb.append(']');
|
|
return sb.toString();
|
|
}
|
|
|
|
/* loaded from: classes6.dex */
|
|
static class RVV implements InterfaceC15537gtP {
|
|
private final InterfaceC15539gtV baseUnit;
|
|
private final String name;
|
|
private final gtT range;
|
|
private final InterfaceC15539gtV rangeUnit;
|
|
private final gtS weekDef;
|
|
private static final gtT DAY_OF_WEEK_RANGE = gtT.of(1, 7);
|
|
private static final gtT WEEK_OF_MONTH_RANGE = gtT.of(0, 1, 4, 6);
|
|
private static final gtT WEEK_OF_YEAR_RANGE = gtT.of(0, 1, 52, 54);
|
|
private static final gtT WEEK_OF_WEEK_BASED_YEAR_RANGE = gtT.of(1, 52, 53);
|
|
private static final gtT WEEK_BASED_YEAR_RANGE = EnumC15534gtD.YEAR.range();
|
|
|
|
@Override // o.InterfaceC15537gtP
|
|
public boolean isDateBased() {
|
|
return true;
|
|
}
|
|
|
|
@Override // o.InterfaceC15537gtP
|
|
public boolean isTimeBased() {
|
|
return false;
|
|
}
|
|
|
|
static RVV ofDayOfWeekField(gtS gts) {
|
|
return new RVV("DayOfWeek", gts, gtH.DAYS, gtH.WEEKS, DAY_OF_WEEK_RANGE);
|
|
}
|
|
|
|
static RVV ofWeekOfMonthField(gtS gts) {
|
|
return new RVV("WeekOfMonth", gts, gtH.WEEKS, gtH.MONTHS, WEEK_OF_MONTH_RANGE);
|
|
}
|
|
|
|
static RVV ofWeekOfYearField(gtS gts) {
|
|
return new RVV("WeekOfYear", gts, gtH.WEEKS, gtH.YEARS, WEEK_OF_YEAR_RANGE);
|
|
}
|
|
|
|
static RVV ofWeekOfWeekBasedYearField(gtS gts) {
|
|
return new RVV("WeekOfWeekBasedYear", gts, gtH.WEEKS, gtI.WEEK_BASED_YEARS, WEEK_OF_WEEK_BASED_YEAR_RANGE);
|
|
}
|
|
|
|
static RVV ofWeekBasedYearField(gtS gts) {
|
|
return new RVV("WeekBasedYear", gts, gtI.WEEK_BASED_YEARS, gtH.FOREVER, WEEK_BASED_YEAR_RANGE);
|
|
}
|
|
|
|
private RVV(String str, gtS gts, InterfaceC15539gtV interfaceC15539gtV, InterfaceC15539gtV interfaceC15539gtV2, gtT gtt) {
|
|
this.name = str;
|
|
this.weekDef = gts;
|
|
this.baseUnit = interfaceC15539gtV;
|
|
this.rangeUnit = interfaceC15539gtV2;
|
|
this.range = gtt;
|
|
}
|
|
|
|
@Override // o.InterfaceC15537gtP
|
|
public long getFrom(gtK gtk) {
|
|
int localizedWBY;
|
|
int floorMod = gtG.floorMod(gtk.get(EnumC15534gtD.DAY_OF_WEEK) - this.weekDef.getFirstDayOfWeek().getValue(), 7) + 1;
|
|
if (this.rangeUnit == gtH.WEEKS) {
|
|
return floorMod;
|
|
}
|
|
if (this.rangeUnit == gtH.MONTHS) {
|
|
int i = gtk.get(EnumC15534gtD.DAY_OF_MONTH);
|
|
localizedWBY = computeWeek(startOfWeekOffset(i, floorMod), i);
|
|
} else if (this.rangeUnit == gtH.YEARS) {
|
|
int i2 = gtk.get(EnumC15534gtD.DAY_OF_YEAR);
|
|
localizedWBY = computeWeek(startOfWeekOffset(i2, floorMod), i2);
|
|
} else if (this.rangeUnit == gtI.WEEK_BASED_YEARS) {
|
|
localizedWBY = localizedWOWBY(gtk);
|
|
} else if (this.rangeUnit == gtH.FOREVER) {
|
|
localizedWBY = localizedWBY(gtk);
|
|
} else {
|
|
throw new IllegalStateException("unreachable");
|
|
}
|
|
return localizedWBY;
|
|
}
|
|
|
|
private int localizedDayOfWeek(gtK gtk, int i) {
|
|
return gtG.floorMod(gtk.get(EnumC15534gtD.DAY_OF_WEEK) - i, 7) + 1;
|
|
}
|
|
|
|
private long localizedWeekOfMonth(gtK gtk, int i) {
|
|
int i2 = gtk.get(EnumC15534gtD.DAY_OF_MONTH);
|
|
return computeWeek(startOfWeekOffset(i2, i), i2);
|
|
}
|
|
|
|
private long localizedWeekOfYear(gtK gtk, int i) {
|
|
int i2 = gtk.get(EnumC15534gtD.DAY_OF_YEAR);
|
|
return computeWeek(startOfWeekOffset(i2, i), i2);
|
|
}
|
|
|
|
private int localizedWOWBY(gtK gtk) {
|
|
int floorMod = gtG.floorMod(gtk.get(EnumC15534gtD.DAY_OF_WEEK) - this.weekDef.getFirstDayOfWeek().getValue(), 7) + 1;
|
|
long localizedWeekOfYear = localizedWeekOfYear(gtk, floorMod);
|
|
if (localizedWeekOfYear == 0) {
|
|
return ((int) localizedWeekOfYear(gsR.from(gtk).date(gtk).minus(1L, (InterfaceC15539gtV) gtH.WEEKS), floorMod)) + 1;
|
|
}
|
|
if (localizedWeekOfYear >= 53) {
|
|
if (localizedWeekOfYear >= computeWeek(startOfWeekOffset(gtk.get(EnumC15534gtD.DAY_OF_YEAR), floorMod), (gsF.isLeap((long) gtk.get(EnumC15534gtD.YEAR)) ? 366 : 365) + this.weekDef.getMinimalDaysInFirstWeek())) {
|
|
return (int) (localizedWeekOfYear - (r6 - 1));
|
|
}
|
|
}
|
|
return (int) localizedWeekOfYear;
|
|
}
|
|
|
|
private int localizedWBY(gtK gtk) {
|
|
int floorMod = gtG.floorMod(gtk.get(EnumC15534gtD.DAY_OF_WEEK) - this.weekDef.getFirstDayOfWeek().getValue(), 7) + 1;
|
|
int i = gtk.get(EnumC15534gtD.YEAR);
|
|
long localizedWeekOfYear = localizedWeekOfYear(gtk, floorMod);
|
|
if (localizedWeekOfYear == 0) {
|
|
return i - 1;
|
|
}
|
|
if (localizedWeekOfYear < 53) {
|
|
return i;
|
|
}
|
|
return localizedWeekOfYear >= ((long) computeWeek(startOfWeekOffset(gtk.get(EnumC15534gtD.DAY_OF_YEAR), floorMod), (gsF.isLeap((long) i) ? 366 : 365) + this.weekDef.getMinimalDaysInFirstWeek())) ? i + 1 : i;
|
|
}
|
|
|
|
private int startOfWeekOffset(int i, int i2) {
|
|
int floorMod = gtG.floorMod(i - i2, 7);
|
|
return floorMod + 1 > this.weekDef.getMinimalDaysInFirstWeek() ? 7 - floorMod : -floorMod;
|
|
}
|
|
|
|
private int computeWeek(int i, int i2) {
|
|
return ((i + 7) + (i2 - 1)) / 7;
|
|
}
|
|
|
|
@Override // o.InterfaceC15537gtP
|
|
public <R extends InterfaceC15536gtL> R adjustInto(R r, long j) {
|
|
int checkValidIntValue = this.range.checkValidIntValue(j, this);
|
|
if (checkValidIntValue == r.get(this)) {
|
|
return r;
|
|
}
|
|
if (this.rangeUnit == gtH.FOREVER) {
|
|
int i = r.get(this.weekDef.weekOfWeekBasedYear);
|
|
InterfaceC15536gtL plus = r.plus((long) ((j - r1) * 52.1775d), gtH.WEEKS);
|
|
if (plus.get(this) > checkValidIntValue) {
|
|
return (R) plus.minus(plus.get(this.weekDef.weekOfWeekBasedYear), gtH.WEEKS);
|
|
}
|
|
if (plus.get(this) < checkValidIntValue) {
|
|
plus = plus.plus(2L, gtH.WEEKS);
|
|
}
|
|
R r2 = (R) plus.plus(i - plus.get(this.weekDef.weekOfWeekBasedYear), gtH.WEEKS);
|
|
return r2.get(this) > checkValidIntValue ? (R) r2.minus(1L, gtH.WEEKS) : r2;
|
|
}
|
|
return (R) r.plus(checkValidIntValue - r1, this.baseUnit);
|
|
}
|
|
|
|
@Override // o.InterfaceC15537gtP
|
|
public gtK resolve(Map<InterfaceC15537gtP, Long> map, gtK gtk, gtA gta) {
|
|
long checkValidIntValue;
|
|
gsJ date;
|
|
long checkValidIntValue2;
|
|
gsJ date2;
|
|
long checkValidIntValue3;
|
|
int localizedDayOfWeek;
|
|
long localizedWeekOfYear;
|
|
int value = this.weekDef.getFirstDayOfWeek().getValue();
|
|
if (this.rangeUnit == gtH.WEEKS) {
|
|
map.put(EnumC15534gtD.DAY_OF_WEEK, Long.valueOf(gtG.floorMod((value - 1) + (this.range.checkValidIntValue(map.remove(this).longValue(), this) - 1), 7) + 1));
|
|
return null;
|
|
}
|
|
if (!map.containsKey(EnumC15534gtD.DAY_OF_WEEK)) {
|
|
return null;
|
|
}
|
|
if (this.rangeUnit == gtH.FOREVER) {
|
|
if (!map.containsKey(this.weekDef.weekOfWeekBasedYear)) {
|
|
return null;
|
|
}
|
|
gsR from = gsR.from(gtk);
|
|
int floorMod = gtG.floorMod(EnumC15534gtD.DAY_OF_WEEK.checkValidIntValue(map.get(EnumC15534gtD.DAY_OF_WEEK).longValue()) - value, 7);
|
|
int checkValidIntValue4 = range().checkValidIntValue(map.get(this).longValue(), this);
|
|
if (gta == gtA.LENIENT) {
|
|
date2 = from.date(checkValidIntValue4, 1, this.weekDef.getMinimalDaysInFirstWeek());
|
|
checkValidIntValue3 = map.get(this.weekDef.weekOfWeekBasedYear).longValue();
|
|
localizedDayOfWeek = localizedDayOfWeek(date2, value);
|
|
localizedWeekOfYear = localizedWeekOfYear(date2, localizedDayOfWeek);
|
|
} else {
|
|
date2 = from.date(checkValidIntValue4, 1, this.weekDef.getMinimalDaysInFirstWeek());
|
|
checkValidIntValue3 = this.weekDef.weekOfWeekBasedYear.range().checkValidIntValue(map.get(this.weekDef.weekOfWeekBasedYear).longValue(), this.weekDef.weekOfWeekBasedYear);
|
|
localizedDayOfWeek = localizedDayOfWeek(date2, value);
|
|
localizedWeekOfYear = localizedWeekOfYear(date2, localizedDayOfWeek);
|
|
}
|
|
gsJ plus = date2.plus(((checkValidIntValue3 - localizedWeekOfYear) * 7) + ((floorMod + 1) - localizedDayOfWeek), (InterfaceC15539gtV) gtH.DAYS);
|
|
if (gta == gtA.STRICT && plus.getLong(this) != map.get(this).longValue()) {
|
|
throw new DateTimeException("Strict mode rejected date parsed to a different year");
|
|
}
|
|
map.remove(this);
|
|
map.remove(this.weekDef.weekOfWeekBasedYear);
|
|
map.remove(EnumC15534gtD.DAY_OF_WEEK);
|
|
return plus;
|
|
}
|
|
if (!map.containsKey(EnumC15534gtD.YEAR)) {
|
|
return null;
|
|
}
|
|
int floorMod2 = gtG.floorMod(EnumC15534gtD.DAY_OF_WEEK.checkValidIntValue(map.get(EnumC15534gtD.DAY_OF_WEEK).longValue()) - value, 7) + 1;
|
|
int checkValidIntValue5 = EnumC15534gtD.YEAR.checkValidIntValue(map.get(EnumC15534gtD.YEAR).longValue());
|
|
gsR from2 = gsR.from(gtk);
|
|
if (this.rangeUnit == gtH.MONTHS) {
|
|
if (!map.containsKey(EnumC15534gtD.MONTH_OF_YEAR)) {
|
|
return null;
|
|
}
|
|
long longValue = map.remove(this).longValue();
|
|
if (gta == gtA.LENIENT) {
|
|
date = from2.date(checkValidIntValue5, 1, 1).plus(map.get(EnumC15534gtD.MONTH_OF_YEAR).longValue() - 1, (InterfaceC15539gtV) gtH.MONTHS);
|
|
checkValidIntValue2 = ((longValue - localizedWeekOfMonth(date, localizedDayOfWeek(date, value))) * 7) + (floorMod2 - r0);
|
|
} else {
|
|
date = from2.date(checkValidIntValue5, EnumC15534gtD.MONTH_OF_YEAR.checkValidIntValue(map.get(EnumC15534gtD.MONTH_OF_YEAR).longValue()), 8);
|
|
checkValidIntValue2 = ((this.range.checkValidIntValue(longValue, this) - localizedWeekOfMonth(date, localizedDayOfWeek(date, value))) * 7) + (floorMod2 - r0);
|
|
}
|
|
gsJ plus2 = date.plus(checkValidIntValue2, (InterfaceC15539gtV) gtH.DAYS);
|
|
if (gta == gtA.STRICT && plus2.getLong(EnumC15534gtD.MONTH_OF_YEAR) != map.get(EnumC15534gtD.MONTH_OF_YEAR).longValue()) {
|
|
throw new DateTimeException("Strict mode rejected date parsed to a different month");
|
|
}
|
|
map.remove(this);
|
|
map.remove(EnumC15534gtD.YEAR);
|
|
map.remove(EnumC15534gtD.MONTH_OF_YEAR);
|
|
map.remove(EnumC15534gtD.DAY_OF_WEEK);
|
|
return plus2;
|
|
}
|
|
if (this.rangeUnit == gtH.YEARS) {
|
|
long longValue2 = map.remove(this).longValue();
|
|
gsJ date3 = from2.date(checkValidIntValue5, 1, 1);
|
|
if (gta == gtA.LENIENT) {
|
|
checkValidIntValue = ((longValue2 - localizedWeekOfYear(date3, localizedDayOfWeek(date3, value))) * 7) + (floorMod2 - r0);
|
|
} else {
|
|
checkValidIntValue = ((this.range.checkValidIntValue(longValue2, this) - localizedWeekOfYear(date3, localizedDayOfWeek(date3, value))) * 7) + (floorMod2 - r0);
|
|
}
|
|
gsJ plus3 = date3.plus(checkValidIntValue, (InterfaceC15539gtV) gtH.DAYS);
|
|
if (gta == gtA.STRICT && plus3.getLong(EnumC15534gtD.YEAR) != map.get(EnumC15534gtD.YEAR).longValue()) {
|
|
throw new DateTimeException("Strict mode rejected date parsed to a different year");
|
|
}
|
|
map.remove(this);
|
|
map.remove(EnumC15534gtD.YEAR);
|
|
map.remove(EnumC15534gtD.DAY_OF_WEEK);
|
|
return plus3;
|
|
}
|
|
throw new IllegalStateException("unreachable");
|
|
}
|
|
|
|
@Override // o.InterfaceC15537gtP
|
|
public boolean isSupportedBy(gtK gtk) {
|
|
if (!gtk.isSupported(EnumC15534gtD.DAY_OF_WEEK)) {
|
|
return false;
|
|
}
|
|
if (this.rangeUnit == gtH.WEEKS) {
|
|
return true;
|
|
}
|
|
if (this.rangeUnit == gtH.MONTHS) {
|
|
return gtk.isSupported(EnumC15534gtD.DAY_OF_MONTH);
|
|
}
|
|
if (this.rangeUnit == gtH.YEARS) {
|
|
return gtk.isSupported(EnumC15534gtD.DAY_OF_YEAR);
|
|
}
|
|
if (this.rangeUnit == gtI.WEEK_BASED_YEARS) {
|
|
return gtk.isSupported(EnumC15534gtD.EPOCH_DAY);
|
|
}
|
|
if (this.rangeUnit == gtH.FOREVER) {
|
|
return gtk.isSupported(EnumC15534gtD.EPOCH_DAY);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override // o.InterfaceC15537gtP
|
|
public gtT rangeRefinedBy(gtK gtk) {
|
|
EnumC15534gtD enumC15534gtD;
|
|
if (this.rangeUnit == gtH.WEEKS) {
|
|
return this.range;
|
|
}
|
|
if (this.rangeUnit == gtH.MONTHS) {
|
|
enumC15534gtD = EnumC15534gtD.DAY_OF_MONTH;
|
|
} else if (this.rangeUnit == gtH.YEARS) {
|
|
enumC15534gtD = EnumC15534gtD.DAY_OF_YEAR;
|
|
} else {
|
|
if (this.rangeUnit == gtI.WEEK_BASED_YEARS) {
|
|
return rangeWOWBY(gtk);
|
|
}
|
|
if (this.rangeUnit == gtH.FOREVER) {
|
|
return gtk.range(EnumC15534gtD.YEAR);
|
|
}
|
|
throw new IllegalStateException("unreachable");
|
|
}
|
|
int startOfWeekOffset = startOfWeekOffset(gtk.get(enumC15534gtD), gtG.floorMod(gtk.get(EnumC15534gtD.DAY_OF_WEEK) - this.weekDef.getFirstDayOfWeek().getValue(), 7) + 1);
|
|
gtT range = gtk.range(enumC15534gtD);
|
|
return gtT.of(computeWeek(startOfWeekOffset, (int) range.getMinimum()), computeWeek(startOfWeekOffset, (int) range.getMaximum()));
|
|
}
|
|
|
|
private gtT rangeWOWBY(gtK gtk) {
|
|
while (true) {
|
|
int floorMod = gtG.floorMod(gtk.get(EnumC15534gtD.DAY_OF_WEEK) - this.weekDef.getFirstDayOfWeek().getValue(), 7) + 1;
|
|
long localizedWeekOfYear = localizedWeekOfYear(gtk, floorMod);
|
|
if (localizedWeekOfYear == 0) {
|
|
gtk = gsR.from(gtk).date(gtk).minus(2L, (InterfaceC15539gtV) gtH.WEEKS);
|
|
} else {
|
|
if (localizedWeekOfYear >= computeWeek(startOfWeekOffset(gtk.get(EnumC15534gtD.DAY_OF_YEAR), floorMod), (gsF.isLeap((long) gtk.get(EnumC15534gtD.YEAR)) ? 366 : 365) + this.weekDef.getMinimalDaysInFirstWeek())) {
|
|
gtk = gsR.from(gtk).date(gtk).plus(2L, (InterfaceC15539gtV) gtH.WEEKS);
|
|
} else {
|
|
return gtT.of(1L, r0 - 1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override // o.InterfaceC15537gtP
|
|
public String getDisplayName(Locale locale) {
|
|
gtG.requireNonNull(locale, "locale");
|
|
return this.rangeUnit == gtH.YEARS ? "Week" : toString();
|
|
}
|
|
|
|
public String toString() {
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.append(this.name);
|
|
sb.append("[");
|
|
sb.append(this.weekDef.toString());
|
|
sb.append("]");
|
|
return sb.toString();
|
|
}
|
|
|
|
@Override // o.InterfaceC15537gtP
|
|
public gtT range() {
|
|
return this.range;
|
|
}
|
|
|
|
@Override // o.InterfaceC15537gtP
|
|
public InterfaceC15539gtV getRangeUnit() {
|
|
return this.rangeUnit;
|
|
}
|
|
|
|
@Override // o.InterfaceC15537gtP
|
|
public InterfaceC15539gtV getBaseUnit() {
|
|
return this.baseUnit;
|
|
}
|
|
}
|
|
|
|
public final InterfaceC15537gtP weekOfYear() {
|
|
return this.weekOfYear;
|
|
}
|
|
|
|
public final InterfaceC15537gtP weekOfWeekBasedYear() {
|
|
return this.weekOfWeekBasedYear;
|
|
}
|
|
|
|
public final InterfaceC15537gtP weekOfMonth() {
|
|
return this.weekOfMonth;
|
|
}
|
|
|
|
public final InterfaceC15537gtP weekBasedYear() {
|
|
return this.weekBasedYear;
|
|
}
|
|
|
|
public final int getMinimalDaysInFirstWeek() {
|
|
return this.minimalDays;
|
|
}
|
|
|
|
public final EnumC15515gsk getFirstDayOfWeek() {
|
|
return this.firstDayOfWeek;
|
|
}
|
|
|
|
public final InterfaceC15537gtP dayOfWeek() {
|
|
return this.dayOfWeek;
|
|
}
|
|
}
|