icuSources/i18n/japancal.h

   1 /*
   2  ********************************************************************************
   3  * Copyright (C) 2003-2008, International Business Machines Corporation
   4  * and others. All Rights Reserved.
   5  ********************************************************************************
   6  *
   7  * File JAPANCAL.H
   8  *
   9  * Modification History:
  10  *
  11  *   Date        Name        Description
  12  *   05/13/2003  srl         copied from gregocal.h
  13  ********************************************************************************
  14  */
  15
  16 #ifndef JAPANCAL_H
  17 #define JAPANCAL_H
  18
  19 #include "unicode/utypes.h"
  20
  21 #if !UCONFIG_NO_FORMATTING
  22
  23 #include "unicode/calendar.h"
  24 #include "unicode/gregocal.h"
  25
  26 U_NAMESPACE_BEGIN
  27
  28 /**
  29  * Concrete class which provides the Japanese calendar.
  30  * <P>
  31  * <code>JapaneseCalendar</code> is a subclass of <code>GregorianCalendar</code>
  32  * that numbers years and eras based on the reigns of the Japanese emperors.
  33  * The Japanese calendar is identical to the Gregorian calendar in all respects
  34  * except for the year and era.  The ascension of each  emperor to the throne
  35  * begins a new era, and the years of that era are numbered starting with the
  36  * year of ascension as year 1.
  37  * <p>
  38  * Note that in the year of an imperial ascension, there are two possible sets
  39  * of year and era values: that for the old era and for the new.  For example, a
  40  * new era began on January 7, 1989 AD.  Strictly speaking, the first six days
  41  * of that year were in the Showa era, e.g. "January 6, 64 Showa", while the rest
  42  * of the year was in the Heisei era, e.g. "January 7, 1 Heisei".  This class
  43  * handles this distinction correctly when computing dates.  However, in lenient
  44  * mode either form of date is acceptable as input.
  45  * <p>
  46  * In modern times, eras have started on January 8, 1868 AD, Gregorian (Meiji),
  47  * July 30, 1912 (Taisho), December 25, 1926 (Showa), and January 7, 1989 (Heisei).  Constants
  48  * for these eras, suitable for use in the <code>UCAL_ERA</code> field, are provided
  49  * in this class.  Note that the <em>number</em> used for each era is more or
  50  * less arbitrary.  Currently, the era starting in 1053 AD is era #0; however this
  51  * may change in the future as we add more historical data.  Use the predefined
  52  * constants rather than using actual, absolute numbers.
  53  * <p>
  54  * @internal
  55  */
  56 class JapaneseCalendar : public GregorianCalendar {
  57 public:
  58
  59     /**
  60      * Useful constants for JapaneseCalendar.
  61      * @internal
  62      */
  63     U_I18N_API static uint32_t U_EXPORT2 getCurrentEra(void); // the current era
  64
  65     /**
  66      * Constructs a JapaneseCalendar based on the current time in the default time zone
  67      * with the given locale.
  68      *
  69      * @param aLocale  The given locale.
  70      * @param success  Indicates the status of JapaneseCalendar object construction.
  71      *                 Returns U_ZERO_ERROR if constructed successfully.
  72      * @stable ICU 2.0
  73      */
  74     JapaneseCalendar(const Locale& aLocale, UErrorCode& success);
  75
  76
  77     /**
  78      * Destructor
  79      * @internal
  80      */
  81     virtual ~JapaneseCalendar();
  82
  83     /**
  84      * Copy constructor
  85      * @param source    the object to be copied.
  86      * @internal
  87      */
  88     JapaneseCalendar(const JapaneseCalendar& source);
  89
  90     /**
  91      * Default assignment operator
  92      * @param right    the object to be copied.
  93      * @internal
  94      */
  95     JapaneseCalendar& operator=(const JapaneseCalendar& right);
  96
  97     /**
  98      * Create and return a polymorphic copy of this calendar.
  99      * @return    return a polymorphic copy of this calendar.
 100      * @internal
 101      */
 102     virtual Calendar* clone(void) const;
 103
 104     /**
 105      * Return the extended year defined by the current fields.  In the
 106      * Japanese calendar case, this is equal to the equivalent extended Gregorian year.
 107      * @internal
 108      */
 109     virtual int32_t handleGetExtendedYear();
 110
 111     /**
 112      * Return the maximum value that this field could have, given the current date.
 113      * @internal
 114      */
 115     virtual int32_t getActualMaximum(UCalendarDateFields field, UErrorCode& status) const;
 116
 117
 118 public:
 119     /**
 120      * Override Calendar Returns a unique class ID POLYMORPHICALLY. Pure virtual
 121      * override. This method is to implement a simple version of RTTI, since not all C++
 122      * compilers support genuine RTTI. Polymorphic operator==() and clone() methods call
 123      * this method.
 124      *
 125      * @return   The class ID for this object. All objects of a given class have the
 126      *           same class ID. Objects of other classes have different class IDs.
 127      * @internal
 128      */
 129     virtual UClassID getDynamicClassID(void) const;
 130
 131     /**
 132      * Return the class ID for this class. This is useful only for comparing to a return
 133      * value from getDynamicClassID(). For example:
 134      *
 135      *      Base* polymorphic_pointer = createPolymorphicObject();
 136      *      if (polymorphic_pointer->getDynamicClassID() ==
 137      *          Derived::getStaticClassID()) ...
 138      *
 139      * @return   The class ID for all objects of this class.
 140      * @internal
 141      */
 142     U_I18N_API static UClassID U_EXPORT2 getStaticClassID(void);
 143
 144     /**
 145      * return the calendar type, "japanese".
 146      *
 147      * @return calendar type
 148      * @internal
 149      */
 150     virtual const char * getType() const;
 151
 152     /**
 153      * @return FALSE - no default century in Japanese
 154      * @internal
 155      */
 156     virtual UBool haveDefaultCentury() const;
 157
 158     /**
 159      * Not used - no default century.
 160      * @internal
 161      */
 162     virtual UDate defaultCenturyStart() const;
 163     /**
 164      * Not used - no default century.
 165      * @internal
 166      */
 167     virtual int32_t defaultCenturyStartYear() const;
 168
 169 private:
 170     JapaneseCalendar(); // default constructor not implemented
 171
 172 protected:
 173     /**
 174      * Calculate the era for internal computation
 175      * @internal
 176      */
 177     virtual int32_t internalGetEra() const;
 178
 179     /**
 180      * Compute fields from the JD
 181      * @internal
 182      */
 183     virtual void handleComputeFields(int32_t julianDay, UErrorCode& status);
 184
 185     /**
 186      * Calculate the limit for a specified type of limit and field
 187      * @internal
 188      */
 189     virtual int32_t handleGetLimit(UCalendarDateFields field, ELimitType limitType) const;
 190
 191     /***
 192      * Called by computeJulianDay.  Returns the default month (0-based) for the year,
 193      * taking year and era into account.  Will return the first month of the given era, if
 194      * the current year is an ascension year.
 195      * @param eyear the extended year
 196      * @internal
 197      */
 198     virtual int32_t getDefaultMonthInYear(int32_t eyear);
 199
 200     /***
 201      * Called by computeJulianDay.  Returns the default day (1-based) for the month,
 202      * taking currently-set year and era into account.  Will return the first day of the given
 203      * era, if the current month is an ascension year and month.
 204      * @param eyear the extended year
 205      * @param mon the month in the year
 206      * @internal
 207      */
 208     virtual int32_t getDefaultDayInMonth(int32_t eyear, int32_t month);
 209 };
 210
 211 U_NAMESPACE_END
 212
 213 #endif /* #if !UCONFIG_NO_FORMATTING */
 214
 215 #endif
 216 //eof
 217