/* * Copyright (C) 2003, International Business Machines Corporation and others. All Rights Reserved. ******************************************************************************** * * File BUDDHCAL.H * * Modification History: * * Date Name Description * 05/13/2003 srl copied from gregocal.h ******************************************************************************** */ #ifndef BUDDHCAL_H #define BUDDHCAL_H #include "unicode/utypes.h" #if !UCONFIG_NO_FORMATTING #include "unicode/calendar.h" #include "unicode/gregocal.h" U_NAMESPACE_BEGIN /** * Concrete class which provides the Buddhist calendar. * <P> * <code>BuddhistCalendar</code> is a subclass of <code>GregorianCalendar</code> * that numbers years since the birth of the Buddha. This is the civil calendar * in some predominantly Buddhist countries such as Thailand, and it is used for * religious purposes elsewhere. * <p> * The Buddhist calendar is identical to the Gregorian calendar in all respects * except for the year and era. Years are numbered since the birth of the * Buddha in 543 BC (Gregorian), so that 1 AD (Gregorian) is equivalent to 544 * BE (Buddhist Era) and 1998 AD is 2541 BE. * <p> * The Buddhist Calendar has only one allowable era: <code>BE</code>. If the * calendar is not in lenient mode (see <code>setLenient</code>), dates before * 1/1/1 BE are rejected as an illegal argument. * <p> * @internal */ class U_I18N_API BuddhistCalendar : public GregorianCalendar { public: /** * Useful constants for BuddhistCalendar. Only one Era. * @internal */ enum EEras { BE }; /** * Constructs a BuddhistCalendar 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 BuddhistCalendar object construction. * Returns U_ZERO_ERROR if constructed successfully. * @stable ICU 2.0 */ BuddhistCalendar(const Locale& aLocale, UErrorCode& success); /** * Destructor * @internal */ virtual ~BuddhistCalendar(); /** * Copy constructor * @param source the object to be copied. * @internal */ BuddhistCalendar(const BuddhistCalendar& source); /** * Default assignment operator * @param right the object to be copied. * @internal */ BuddhistCalendar& operator=(const BuddhistCalendar& right); /** * Create and return a polymorphic copy of this calendar. * @return return a polymorphic copy of this calendar. * @internal */ virtual Calendar* clone(void) const; public: /** * Override Calendar Returns a unique class ID POLYMORPHICALLY. Pure virtual * override. This method is to implement a simple version of RTTI, since not all C++ * compilers support genuine RTTI. Polymorphic operator==() and clone() methods call * this method. * * @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(void) const; /** * 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 inline UClassID getStaticClassID(void); /** * return the calendar type, "buddhist". * * @return calendar type * @internal */ virtual const char * getType() const; /** * (Overrides Calendar) UDate Arithmetic function. Adds the specified (signed) amount * of time to the given time field, based on the calendar's rules. For more * information, see the documentation for Calendar::add(). * * @param field The time field. * @param amount The amount of date or time to be added to the field. * @param status Output param set to success/failure code on exit. If any value * previously set in the time field is invalid, this will be set to * an error status. * @draft ICU 2.6. */ virtual void add(UCalendarDateFields field, int32_t amount, UErrorCode& status); /** * API overrides * @private */ int32_t getMaximum(UCalendarDateFields field) const; int32_t getLeastMaximum(UCalendarDateFields field) const; inline virtual int32_t getMaximum(EDateFields field) const { return getMaximum((UCalendarDateFields)field); } inline virtual int32_t getLeastMaximum(EDateFields field) const { return getLeastMaximum((UCalendarDateFields)field); } inline virtual void add(EDateFields field, int32_t amount, UErrorCode& status) { add((UCalendarDateFields)field, amount, status); } private: BuddhistCalendar(); // default constructor not implemented static const char fgClassID; protected: virtual int32_t monthLength(int32_t month) const; virtual int32_t monthLength(int32_t month, int32_t year) const; int32_t getGregorianYear(UErrorCode& status) const; virtual int32_t internalGetEra() const; virtual void timeToFields(UDate theTime, UBool quick, UErrorCode& status); virtual UBool haveDefaultCentury() const; virtual UDate defaultCenturyStart() const; virtual int32_t defaultCenturyStartYear() const; private: // default century stuff. /** * The system maintains a static default century start date. This is initialized * the first time it is used. Before then, it is set to SYSTEM_DEFAULT_CENTURY to * indicate an uninitialized state. Once the system default century date and year * are set, they do not change. */ static UDate fgSystemDefaultCenturyStart; /** * See documentation for systemDefaultCenturyStart. */ static int32_t fgSystemDefaultCenturyStartYear; /** * Default value that indicates the defaultCenturyStartYear is unitialized */ static const int32_t fgSystemDefaultCenturyYear; static const UDate fgSystemDefaultCentury; /** * Returns the beginning date of the 100-year window that dates with 2-digit years * are considered to fall within. * @return the beginning date of the 100-year window that dates with 2-digit years * are considered to fall within. */ UDate internalGetDefaultCenturyStart(void) const; /** * Returns the first year of the 100-year window that dates with 2-digit years * are considered to fall within. * @return the first year of the 100-year window that dates with 2-digit years * are considered to fall within. */ int32_t internalGetDefaultCenturyStartYear(void) const; /** * Initializes the 100-year window that dates with 2-digit years are considered * to fall within so that its start date is 80 years before the current time. */ static void initializeSystemDefaultCentury(void); }; inline UClassID BuddhistCalendar::getStaticClassID(void) { return (UClassID)&fgClassID; } inline UClassID BuddhistCalendar::getDynamicClassID(void) const { return BuddhistCalendar::getStaticClassID(); } U_NAMESPACE_END #endif /* #if !UCONFIG_NO_FORMATTING */ #endif // _GREGOCAL //eof