Examples of org.threeten.bp.chrono.Chronology

org.threeten.bp.chrono.Chronology
A calendar system, used to organize and identify dates.
The main date and time API is built on the ISO calendar system. This class operates behind the scenes to represent the general concept of a calendar system. For example, the Japanese, Minguo, Thai Buddhist and others.
Most other calendar systems also operate on the shared concepts of year, month and day, linked to the cycles of the Earth around the Sun, and the Moon around the Earth. These shared concepts are defined by {@link ChronoField} and are availalbefor use by any {@code Chronology} implementation:
```
 LocalDate isoDate = ... ChronoLocalDate<ThaiBuddhistChrono> minguoDate = ... int isoYear = isoDate.get(ChronoField.YEAR); int thaiYear = thaiDate.get(ChronoField.YEAR); 
```
As shown, although the date objects are in different calendar systems, represented by different {@code Chronology} instances, both can be queried using the same constant on {@code ChronoField}. For a full discussion of the implications of this, see {@link ChronoLocalDate}. In general, the advice is to use the known ISO-based {@code LocalDate}, rather than {@code ChronoLocalDate}.
While a {@code Chronology} object typically uses {@code ChronoField} and is based onan era, year-of-era, month-of-year, day-of-month model of a date, this is not required. A {@code Chronology} instance may represent a totally different kind of calendar system,such as the Mayan.
In practical terms, the {@code Chronology} instance also acts as a factory.The {@link #of(String)} method allows an instance to be looked up by identifier,while the {@link #ofLocale(Locale)} method allows lookup by locale.
The {@code Chronology} instance provides a set of methods to create {@code ChronoLocalDate} instances.The date classes are used to manipulate specific dates.
- {@link #dateNow() dateNow()}
- {@link #dateNow(Clock) dateNow(clock)}
- {@link #dateNow(ZoneId) dateNow(zone)}
- {@link #date(int,int,int) date(yearProleptic, month, day)}
- {@link #date(Era,int,int,int) date(era, yearOfEra, month, day)}
- {@link #dateYearDay(int,int) dateYearDay(yearProleptic, dayOfYear)}
- {@link #dateYearDay(Era,int,int) dateYearDay(era, yearOfEra, dayOfYear)}
- {@link #date(TemporalAccessor) date(TemporalAccessor)}
Adding New Calendars
The set of available chronologies can be extended by applications. Adding a new calendar system requires the writing of an implementation of {@code Chronology}, {@code ChronoLocalDate} and {@code Era}. The majority of the logic specific to the calendar system will be in {@code ChronoLocalDate}. The {@code Chronology} subclass acts as a factory.
To permit the discovery of additional chronologies, the {@link java.util.ServiceLoader ServiceLoader}is used. A file must be added to the {@code META-INF/services} directory with thename 'org.threeten.bp.chrono.Chrono' listing the implementation classes. See the ServiceLoader for more details on service loading. For lookup by id or calendarType, the system provided calendars are found first followed by application provided calendars.
Each chronology must define a chronology ID that is unique within the system. If the chronology represents a calendar system defined by the Unicode Locale Data Markup Language (LDML) specification then that calendar type should also be specified.
Specification for implementors
This class must be implemented with care to ensure other classes operate correctly. All implementations that can be instantiated must be final, immutable and thread-safe. Subclasses should be Serializable wherever possible.
In JDK 8, this is an interface with default methods. Since there are no default methods in JDK 7, an abstract class is used.

            // week-based-year
            if (rangeUnit == ChronoUnit.FOREVER) {
                if (fieldValues.containsKey(weekDef.weekOfWeekBasedYear) == false) {
                    return null;
                }
                Chronology chrono = Chronology.from(partialTemporal);  // defaults to ISO
                int isoDow = DAY_OF_WEEK.checkValidIntValue(fieldValues.get(DAY_OF_WEEK));
                int dow = Jdk8Methods.floorMod(isoDow - sow, 7) + 1;
                final int wby = range().checkValidIntValue(fieldValues.get(this), this);
                ChronoLocalDate date;
                long days;
                if (resolverStyle == ResolverStyle.LENIENT) {
                    date = chrono.date(wby, 1, weekDef.getMinimalDaysInFirstWeek());
                    long wowby = fieldValues.get(weekDef.weekOfWeekBasedYear);
                    int dateDow = localizedDayOfWeek(date, sow);
                    long weeks = wowby - localizedWeekOfYear(date, dateDow);
                    days = weeks * 7 + (dow - dateDow);
                } else {
                    date = chrono.date(wby, 1, weekDef.getMinimalDaysInFirstWeek());
                    long wowby = weekDef.weekOfWeekBasedYear.range().checkValidIntValue(
                                    fieldValues.get(weekDef.weekOfWeekBasedYear), weekDef.weekOfWeekBasedYear);
                    int dateDow = localizedDayOfWeek(date, sow);
                    long weeks = wowby - localizedWeekOfYear(date, dateDow);
                    days = weeks * 7 + (dow - dateDow);
                }
                date = date.plus(days, DAYS);
                if (resolverStyle == ResolverStyle.STRICT) {
                    if (date.getLong(this) != fieldValues.get(this)) {
                        throw new DateTimeException("Strict mode rejected date parsed to a different year");
                    }
                }
                fieldValues.remove(this);
                fieldValues.remove(weekDef.weekOfWeekBasedYear);
                fieldValues.remove(DAY_OF_WEEK);
                return date;
            }
            
            if (fieldValues.containsKey(YEAR) == false) {
                return null;
            }
            int isoDow = DAY_OF_WEEK.checkValidIntValue(fieldValues.get(DAY_OF_WEEK));
            int dow = Jdk8Methods.floorMod(isoDow - sow, 7) + 1;
            int year = YEAR.checkValidIntValue(fieldValues.get(YEAR));
            Chronology chrono = Chronology.from(partialTemporal);  // defaults to ISO
            if (rangeUnit == MONTHS) {  // week-of-month
                if (fieldValues.containsKey(MONTH_OF_YEAR) == false) {
                    return null;
                }
                final long value = fieldValues.remove(this);
                ChronoLocalDate date;
                long days;
                if (resolverStyle == ResolverStyle.LENIENT) {
                    long month = fieldValues.get(MONTH_OF_YEAR);
                    date = chrono.date(year, 1, 1);
                    date = date.plus(month - 1, MONTHS);
                    int dateDow = localizedDayOfWeek(date, sow);
                    long weeks = value - localizedWeekOfMonth(date, dateDow);
                    days = weeks * 7 + (dow - dateDow);
                } else {
                    int month = MONTH_OF_YEAR.checkValidIntValue(fieldValues.get(MONTH_OF_YEAR));
                    date = chrono.date(year, month, 8);
                    int dateDow = localizedDayOfWeek(date, sow);
                    int wom = range.checkValidIntValue(value, this);
                    long weeks = wom - localizedWeekOfMonth(date, dateDow);
                    days = weeks * 7 + (dow - dateDow);
                }
                date = date.plus(days, DAYS);
                if (resolverStyle == ResolverStyle.STRICT) {
                    if (date.getLong(MONTH_OF_YEAR) != fieldValues.get(MONTH_OF_YEAR)) {
                        throw new DateTimeException("Strict mode rejected date parsed to a different month");
                    }
                }
                fieldValues.remove(this);
                fieldValues.remove(YEAR);
                fieldValues.remove(MONTH_OF_YEAR);
                fieldValues.remove(DAY_OF_WEEK);
                return date;
            } else if (rangeUnit == YEARS) {  // week-of-year
                final long value = fieldValues.remove(this);
                ChronoLocalDate date = chrono.date(year, 1, 1);
                long days;
                if (resolverStyle == ResolverStyle.LENIENT) {
                    int dateDow = localizedDayOfWeek(date, sow);
                    long weeks = value - localizedWeekOfYear(date, dateDow);
                    days = weeks * 7 + (dow - dateDow);

View Full Code Here

     * Gets the effective chronology during parsing.
     *
     * @return the effective parsing chronology, not null
     */
    Chronology getEffectiveChronology() {
        Chronology chrono = currentParsed().chrono;
        if (chrono == null) {
            chrono = overrideChronology;
            if (chrono == null) {
                chrono = IsoChronology.INSTANCE;
            }

View Full Code Here

        c = IsoChronology.INSTANCE;
        c.toString();
    }


    private static void newPackagePluggable() {
        Chronology chrono = MinguoChronology.INSTANCE;


        ChronoLocalDate date = chrono.dateNow();
        System.out.printf("now: %s%n", date);


        date = date.with(DAY_OF_MONTH, 1);
        System.out.printf("first of month: %s%n", date);

View Full Code Here

    /**
     * Prints a Minguo calendar for the current month.
     */
    private static void printMinguoCal() {
        String chronoName = "Minguo";
        Chronology chrono = Chronology.of(chronoName);
        ChronoLocalDate today = chrono.dateNow();
        printMonthCal(today, System.out);
    }

View Full Code Here

        this.symbols = symbols;
    }


    private static TemporalAccessor adjust(final TemporalAccessor temporal, DateTimeFormatter formatter) {
        // normal case first
        Chronology overrideChrono = formatter.getChronology();
        ZoneId overrideZone = formatter.getZone();
        if (overrideChrono == null && overrideZone == null) {
            return temporal;
        }


        // ensure minimal change
        Chronology temporalChrono = temporal.query(TemporalQueries.chronology());
        ZoneId temporalZone = temporal.query(TemporalQueries.zoneId());
        if (Jdk8Methods.equals(temporalChrono, overrideChrono)) {
            overrideChrono = null;
        }
        if (Jdk8Methods.equals(temporalZone, overrideZone)) {
            overrideZone = null;
        }
        if (overrideChrono == null && overrideZone == null) {
            return temporal;
        }
        final Chronology effectiveChrono = (overrideChrono != null ? overrideChrono : temporalChrono);
        final ZoneId effectiveZone = (overrideZone != null ? overrideZone : temporalZone);
        
        // use overrides
        if (overrideZone != null) {
            // handle instant
            if (temporal.isSupported(INSTANT_SECONDS)) {
                Chronology chrono = (effectiveChrono != null ? effectiveChrono : IsoChronology.INSTANCE);
                return chrono.zonedDateTime(Instant.from(temporal), overrideZone);
            }
            // block changing zone on OffsetTime, and similar problem cases
            ZoneId normalizedOffset = overrideZone.normalized();
            ZoneOffset temporalOffset = temporal.query(TemporalQueries.offset());
            if (normalizedOffset instanceof ZoneOffset && temporalOffset != null && normalizedOffset.equals(temporalOffset) == false) {

View Full Code Here

        @Override
        long getValue(DateTimePrintContext context, long value) {
            long absValue = Math.abs(value);
            int baseValue = this.baseValue;
            if (baseDate != null) {
                Chronology chrono = Chronology.from(context.getTemporal());
                baseValue = chrono.date(baseDate).get(field);
            }
            if (value >= baseValue && value < baseValue + EXCEED_POINTS[minWidth]) {
                return absValue % EXCEED_POINTS[minWidth];
            }
            return absValue % EXCEED_POINTS[maxWidth];

View Full Code Here


        @Override
        int setValue(DateTimeParseContext context, long value, int errorPos, int successPos) {
            int baseValue = this.baseValue;
            if (baseDate != null) {
                Chronology chrono = context.getEffectiveChronology();
                baseValue = chrono.date(baseDate).get(field);
                context.addChronologyChangedParser(this, value, errorPos, successPos);
            }
            int parseLen = successPos - errorPos;
            if (parseLen == minWidth && value >= 0) {
                long range = EXCEED_POINTS[minWidth];

View Full Code Here

            this.textStyle = textStyle;
        }


        @Override
        public boolean print(DateTimePrintContext context, StringBuilder buf) {
            Chronology chrono = context.getValue(TemporalQueries.chronology());
            if (chrono == null) {
                return false;
            }
            if (textStyle == null) {
                buf.append(chrono.getId());
            } else {
                ResourceBundle bundle = ResourceBundle.getBundle(
                        "org.threeten.bp.format.ChronologyText", context.getLocale(), DateTimeFormatterBuilder.class.getClassLoader());
                try {
                    String text = bundle.getString(chrono.getId());
                    buf.append(text);
                } catch (MissingResourceException ex) {
                    buf.append(chrono.getId());
                }
            }
            return true;
        }

View Full Code Here

            // simple looping parser to find the chronology
            if (position < 0 || position > text.length()) {
                throw new IndexOutOfBoundsException();
            }
            Set<Chronology> chronos = Chronology.getAvailableChronologies();
            Chronology bestMatch = null;
            int matchLen = -1;
            for (Chronology chrono : chronos) {
                String id = chrono.getId();
                int idLen = id.length();
                if (idLen > matchLen && context.subSequenceEquals(text, position, id, 0, idLen)) {

View Full Code Here

            this.timeStyle = timeStyle;
        }


        @Override
        public boolean print(DateTimePrintContext context, StringBuilder buf) {
            Chronology chrono = Chronology.from(context.getTemporal());
            return formatter(context.getLocale(), chrono).toPrinterParser(false).print(context, buf);
        }

View Full Code Here

0 1

TOP

Related Classes of org.threeten.bp.chrono.Chronology

org.threeten.bp.chrono.TestChronology

org.threeten.bp.chrono.TestIsoChronology

org.threeten.bp.format.DateTimeFormatterBuilder

org.threeten.bp.format.DateTimeFormatterBuilder$ChronoPrinterParser

org.threeten.bp.format.DateTimeFormatterBuilder$LocalizedPrinterParser

org.threeten.bp.format.DateTimeFormatterBuilder$ReducedPrinterParser

org.threeten.bp.format.DateTimeParseContext

org.threeten.bp.format.DateTimePrintContext

org.threeten.bp.Instant

org.threeten.bp.jdk8.DefaultInterfaceTemporalAccessor

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.

Examples of org.threeten.bp.chrono.Chronology

Specification for implementors

Related Classes of org.threeten.bp.chrono.Chronology