// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
*****************************************************************************
* Copyright (C) 2007-2013, International Business Machines Corporation
* and others. All Rights Reserved.
*****************************************************************************
*
* File CHNSECAL.H
*
* Modification History:
*
* Date Name Description
* 9/18/2007 ajmacher ported from java ChineseCalendar
*****************************************************************************
*/
#ifndef CHNSECAL_H
#define CHNSECAL_H
#include "unicode/utypes.h"
#if !UCONFIG_NO_FORMATTING
#include "unicode/calendar.h"
#include "unicode/timezone.h"
U_NAMESPACE_BEGIN
/**
* ChineseCalendar is a concrete subclass of {@link Calendar}
* that implements a traditional Chinese calendar. The traditional Chinese
* calendar is a lunisolar calendar: Each month starts on a new moon, and
* the months are numbered according to solar events, specifically, to
* guarantee that month 11 always contains the winter solstice. In order
* to accomplish this, leap months are inserted in certain years. Leap
* months are numbered the same as the month they follow. The decision of
* which month is a leap month depends on the relative movements of the sun
* and moon.
*
* This class defines one addition field beyond those defined by
* Calendar: The IS_LEAP_MONTH field takes the
* value of 0 for normal months, or 1 for leap months.
*
*
All astronomical computations are performed with respect to a time
* zone of GMT+8:00 and a longitude of 120 degrees east. Although some
* calendars implement a historically more accurate convention of using
* Beijing's local longitude (116 degrees 25 minutes east) and time zone
* (GMT+7:45:40) for dates before 1929, we do not implement this here.
*
*
Years are counted in two different ways in the Chinese calendar. The
* first method is by sequential numbering from the 61st year of the reign
* of Huang Di, 2637 BCE, which is designated year 1 on the Chinese
* calendar. The second method uses 60-year cycles from the same starting
* point, which is designated year 1 of cycle 1. In this class, the
* EXTENDED_YEAR field contains the sequential year count.
* The ERA field contains the cycle number, and the
* YEAR field contains the year of the cycle, a value between
* 1 and 60.
*
*
There is some variation in what is considered the starting point of
* the calendar, with some sources starting in the first year of the reign
* of Huang Di, rather than the 61st. This gives continuous year numbers
* 60 years greater and cycle numbers one greater than what this class
* implements.
*
*
Because ChineseCalendar defines an additional field and
* redefines the way the ERA field is used, it requires a new
* format class, ChineseDateFormat. As always, use the
* methods DateFormat.getXxxInstance(Calendar cal,...) to
* obtain a formatter for this calendar.
*
*
References:
*
*
* This class should only be subclassed to implement variants of the Chinese lunar calendar.
*
* ChineseCalendar usually should be instantiated using
* {@link com.ibm.icu.util.Calendar#getInstance(ULocale)} passing in a ULocale
* with the tag "@calendar=chinese".
*
* @see com.ibm.icu.text.ChineseDateFormat
* @see com.ibm.icu.util.Calendar
* @author Alan Liu
* @internal
*/
class U_I18N_API ChineseCalendar : public Calendar {
public:
//-------------------------------------------------------------------------
// Constructors...
//-------------------------------------------------------------------------
/**
* Constructs a ChineseCalendar based on the current time in the default time zone
* with the given locale.
*
* @param aLocale The given locale.
* @param success Indicates the status of ChineseCalendar object construction.
* Returns U_ZERO_ERROR if constructed successfully.
* @internal
*/
ChineseCalendar(const Locale& aLocale, UErrorCode &success);
/**
* Returns true if the date is in a leap year.
*
* @param status ICU Error Code
* @return True if the date in the fields is in a Temporal proposal
* defined leap year. False otherwise.
*/
virtual bool inTemporalLeapYear(UErrorCode &status) const override;
/**
* Gets The Temporal monthCode value corresponding to the month for the date.
* The value is a string identifier that starts with the literal grapheme
* "M" followed by two graphemes representing the zero-padded month number
* of the current month in a normal (non-leap) year and suffixed by an
* optional literal grapheme "L" if this is a leap month in a lunisolar
* calendar. For Chinese calendars (including Dangi), the values are
* "M01" .. "M12" for non-leap year, and "M01" .. "M12" with one of
* "M01L" .. "M12L" for leap year.
*
* @param status ICU Error Code
* @return One of 24 possible strings in
* {"M01" .. "M12", "M01L" .. "M12L"}.
* @draft ICU 73
*/
virtual const char* getTemporalMonthCode(UErrorCode &status) const override;
/**
* Sets The Temporal monthCode which is a string identifier that starts
* with the literal grapheme "M" followed by two graphemes representing
* the zero-padded month number of the current month in a normal
* (non-leap) year and suffixed by an optional literal grapheme "L" if this
* is a leap month in a lunisolar calendar. For Chinese calendars, the values
* are "M01" .. "M12" for non-leap years, and "M01" .. "M12" plus one in
* "M01L" .. "M12L" for leap year.
*
* @param temporalMonth The value to be set for temporal monthCode. One of
* 24 possible strings in {"M01" .. "M12", "M01L" .. "M12L"}.
* @param status ICU Error Code
*
* @draft ICU 73
*/
virtual void setTemporalMonthCode(const char* code, UErrorCode& status) override;
protected:
/**
* Constructs a ChineseCalendar based on the current time in the default time zone
* with the given locale, using the specified epoch year and time zone for
* astronomical calculations.
*
* @param aLocale The given locale.
* @param epochYear The epoch year to use for calculation.
* @param zoneAstroCalc The TimeZone to use for astronomical calculations. If null,
* will be set appropriately for Chinese calendar (UTC + 8:00).
* @param success Indicates the status of ChineseCalendar object construction;
* if successful, will not be changed to an error value.
* @internal
*/
ChineseCalendar(const Locale& aLocale, int32_t epochYear, const TimeZone* zoneAstroCalc, UErrorCode &success);
public:
/**
* Copy Constructor
* @internal
*/
ChineseCalendar(const ChineseCalendar& other);
/**
* Destructor.
* @internal
*/
virtual ~ChineseCalendar();
// clone
virtual ChineseCalendar* clone() const override;
private:
//-------------------------------------------------------------------------
// Internal data....
//-------------------------------------------------------------------------
// There is a leap month between the Winter Solstice before and after the
// current date.This is different from leap year because in some year, such as
// 1813 and 2033, the leap month is after the Winter Solstice of that year. So
// this value could be false for a date prior to the Winter Solstice of that
// year but that year still has a leap month and therefor is a leap year.
UBool hasLeapMonthBetweenWinterSolstices;
int32_t fEpochYear; // Start year of this Chinese calendar instance.
const TimeZone* fZoneAstroCalc; // Zone used for the astronomical calculation
// of this Chinese calendar instance.
//----------------------------------------------------------------------
// Calendar framework
//----------------------------------------------------------------------
protected:
virtual int32_t handleGetLimit(UCalendarDateFields field, ELimitType limitType) const override;
virtual int32_t handleGetMonthLength(int32_t extendedYear, int32_t month) const override;
virtual int32_t handleComputeMonthStart(int32_t eyear, int32_t month, UBool useMonth) const override;
virtual int32_t handleGetExtendedYear() override;
virtual void handleComputeFields(int32_t julianDay, UErrorCode &status) override;
virtual const UFieldResolutionTable* getFieldResolutionTable() const override;
public:
virtual void add(UCalendarDateFields field, int32_t amount, UErrorCode &status) override;
virtual void add(EDateFields field, int32_t amount, UErrorCode &status) override;
virtual void roll(UCalendarDateFields field, int32_t amount, UErrorCode &status) override;
virtual void roll(EDateFields field, int32_t amount, UErrorCode &status) override;
/**
* @return The related Gregorian year; will be obtained by modifying the value
* obtained by get from UCAL_EXTENDED_YEAR field
* @internal
*/
virtual int32_t getRelatedYear(UErrorCode &status) const override;
/**
* @param year The related Gregorian year to set; will be modified as necessary then
* set in UCAL_EXTENDED_YEAR field
* @internal
*/
virtual void setRelatedYear(int32_t year) override;
//----------------------------------------------------------------------
// Internal methods & astronomical calculations
//----------------------------------------------------------------------
private:
static const UFieldResolutionTable CHINESE_DATE_PRECEDENCE[];
double daysToMillis(double days) const;
double millisToDays(double millis) const;
virtual int32_t winterSolstice(int32_t gyear) const;
virtual int32_t newMoonNear(double days, UBool after) const;
virtual int32_t synodicMonthsBetween(int32_t day1, int32_t day2) const;
virtual int32_t majorSolarTerm(int32_t days) const;
virtual UBool hasNoMajorSolarTerm(int32_t newMoon) const;
virtual UBool isLeapMonthBetween(int32_t newMoon1, int32_t newMoon2) const;
virtual void computeChineseFields(int32_t days, int32_t gyear,
int32_t gmonth, UBool setAllFields);
virtual int32_t newYear(int32_t gyear) const;
virtual void offsetMonth(int32_t newMoon, int32_t dom, int32_t delta);
const TimeZone* getChineseCalZoneAstroCalc() const;
// UObject stuff
public:
/**
* @return The class ID for this object. All objects of a given class have the
* same class ID. Objects of other classes have different class IDs.
* @internal
*/
virtual UClassID getDynamicClassID() const override;
/**
* Return the class ID for this class. This is useful only for comparing to a return
* value from getDynamicClassID(). For example:
*
* Base* polymorphic_pointer = createPolymorphicObject();
* if (polymorphic_pointer->getDynamicClassID() ==
* Derived::getStaticClassID()) ...
*
* @return The class ID for all objects of this class.
* @internal
*/
static UClassID U_EXPORT2 getStaticClassID();
/**
* return the calendar type, "chinese".
*
* @return calendar type
* @internal
*/
virtual const char * getType() const override;
protected:
virtual int32_t internalGetMonth(int32_t defaultValue) const override;
virtual int32_t internalGetMonth() const override;
protected:
/**
* Returns true because the Islamic Calendar does have a default century
* @internal
*/
virtual UBool haveDefaultCentury() const override;
/**
* Returns the date of the start of the default century
* @return start of century - in milliseconds since epoch, 1970
* @internal
*/
virtual UDate defaultCenturyStart() const override;
/**
* Returns the year in which the default century begins
* @internal
*/
virtual int32_t defaultCenturyStartYear() const override;
private: // default century stuff.
/**
* Returns the beginning date of the 100-year window that dates
* with 2-digit years are considered to fall within.
*/
UDate internalGetDefaultCenturyStart() const;
/**
* Returns the first year of the 100-year window that dates with
* 2-digit years are considered to fall within.
*/
int32_t internalGetDefaultCenturyStartYear() const;
ChineseCalendar() = delete; // default constructor not implemented
};
U_NAMESPACE_END
#endif
#endif