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.

            return formatter(context.getLocale(), chrono).toPrinterParser(false).print(context, buf);
        }


        @Override
        public int parse(DateTimeParseContext context, CharSequence text, int position) {
            Chronology chrono = context.getEffectiveChronology();
            return formatter(context.getLocale(), chrono).toPrinterParser(false).parse(context, text, position);
        }

View Full Code Here

public class TestChronology {


    @BeforeMethod
    public void setUp() {
        // Ensure each of the classes are initialized (until initialization is fixed)
        Chronology c;
        c = HijrahChronology.INSTANCE;
        c = IsoChronology.INSTANCE;
        c = JapaneseChronology.INSTANCE;
        c = MinguoChronology.INSTANCE;
        c = ThaiBuddhistChronology.INSTANCE;
        c.toString();  // avoids variable being marked as unused
    }

View Full Code Here

                };
    }


    @Test(dataProvider = "calendars")
    public void test_getters(String chronoId, String calendarSystemType, String description) {
        Chronology chrono = Chronology.of(chronoId);
        assertNotNull(chrono, "Required calendar not found by ID: " + chronoId);
        assertEquals(chrono.getId(), chronoId);
        assertEquals(chrono.getCalendarType(), calendarSystemType);
    }

View Full Code Here

        assertEquals(chrono.getCalendarType(), calendarSystemType);
    }


    @Test(dataProvider = "calendars")
    public void test_required_calendars(String chronoId, String calendarSystemType, String description) {
        Chronology chrono = Chronology.of(chronoId);
        assertNotNull(chrono, "Required calendar not found by ID: " + chronoId);
        chrono = Chronology.of(calendarSystemType);
        assertNotNull(chrono, "Required calendar not found by type: " + chronoId);
        Set<Chronology> cals = Chronology.getAvailableChronologies();
        assertTrue(cals.contains(chrono), "Required calendar not found in set of available calendars");

View Full Code Here

    @Test
    public void test_calendar_list() {
        Set<Chronology> chronos = Chronology.getAvailableChronologies();
        assertNotNull(chronos, "Required list of calendars must be non-null");
        for (Chronology chrono : chronos) {
            Chronology lookup = Chronology.of(chrono.getId());
            assertNotNull(lookup, "Required calendar not found: " + chrono);
        }
        assertEquals(chronos.size() >= data_of_calendars().length, true, "Required list of calendars too short");
    }

View Full Code Here

    /**
     * Compute the number of days from the Epoch and compute the date from the number of days.
     */
    @Test(dataProvider = "calendars")
    public void test_epoch(String name, String alias, String description) {
        Chronology chrono = Chronology.of(name); // a chronology. In practice this is rarely hardcoded
        ChronoLocalDate date1 = chrono.dateNow();
        long epoch1 = date1.getLong(ChronoField.EPOCH_DAY);
        ChronoLocalDate date2 = date1.with(ChronoField.EPOCH_DAY, epoch1);
        assertEquals(date1, date2, "Date from epoch day is not same date: " + date1 + " != " + date2);
        long epoch2 = date1.getLong(ChronoField.EPOCH_DAY);
        assertEquals(epoch1, epoch2, "Epoch day not the same: " + epoch1 + " != " + epoch2);

View Full Code Here

//        assertEquals(Chronology.ofLocale(locale), chrono);
//    }


    @Test
    public void test_lookupLocale_jp_JP() {
        Chronology test = Chronology.ofLocale(new Locale("ja", "JP"));
        Assert.assertEquals(test.getId(), "ISO");
        Assert.assertEquals(test, IsoChronology.INSTANCE);
    }

View Full Code Here

        Assert.assertEquals(test, IsoChronology.INSTANCE);
    }


    @Test
    public void test_lookupLocale_jp_JP_JP() {
        Chronology test = Chronology.ofLocale(new Locale("ja", "JP", "JP"));
        Assert.assertEquals(test.getId(), "Japanese");
        Assert.assertEquals(test, JapaneseChronology.INSTANCE);
    }

View Full Code Here

    //-----------------------------------------------------------------------
    // serialization; serialize and check each calendar system
    //-----------------------------------------------------------------------
    @Test(dataProvider = "calendarsystemtype")
    public void test_chronoSerializationSingleton(Chronology chrono, String calendarType) throws Exception {
        Chronology orginal = chrono;
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ObjectOutputStream out = new ObjectOutputStream(baos);
        out.writeObject(orginal);
        out.close();
        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
        ObjectInputStream in = new ObjectInputStream(bais);
        Chronology ser = (Chronology) in.readObject();
        assertSame(ser, chrono, "Deserialized Chrono is not the singleton serialized");
    }

View Full Code Here

    //-----------------------------------------------------------------------
    // Chrono.ofName("ISO")  Lookup by name
    //-----------------------------------------------------------------------
    @Test
    public void test_chrono_byName() {
        Chronology c = IsoChronology.INSTANCE;
        Chronology test = Chronology.of("ISO");
        Assert.assertNotNull(test, "The ISO calendar could not be found byName");
        Assert.assertEquals(test.getId(), "ISO", "ID mismatch");
        Assert.assertEquals(test.getCalendarType(), "iso8601", "Type mismatch");
        Assert.assertEquals(test, c);
    }

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