icuSources/i18n/buddhcal.cpp

   1 /*
   2 *******************************************************************************
   3 * Copyright (C) 2003-2013, International Business Machines Corporation and    *
   4 * others. All Rights Reserved.                                                *
   5 *******************************************************************************
   6 *
   7 * File BUDDHCAL.CPP
   8 *
   9 * Modification History:
  10 *  05/13/2003    srl     copied from gregocal.cpp
  11 *
  12 */
  13
  14 #include "unicode/utypes.h"
  15
  16 #if !UCONFIG_NO_FORMATTING
  17
  18 #include "buddhcal.h"
  19 #include "unicode/gregocal.h"
  20 #include "umutex.h"
  21 #include <float.h>
  22
  23 U_NAMESPACE_BEGIN
  24
  25 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(BuddhistCalendar)
  26
  27 //static const int32_t kMaxEra = 0; // only 1 era
  28
  29 static const int32_t kBuddhistEraStart = -543;  // 544 BC (Gregorian)
  30
  31 static const int32_t kGregorianEpoch = 1970;    // used as the default value of EXTENDED_YEAR
  32
  33 BuddhistCalendar::BuddhistCalendar(const Locale& aLocale, UErrorCode& success)
  34 :   GregorianCalendar(aLocale, success)
  35 {
  36     setTimeInMillis(getNow(), success); // Call this again now that the vtable is set up properly.
  37 }
  38
  39 BuddhistCalendar::~BuddhistCalendar()
  40 {
  41 }
  42
  43 BuddhistCalendar::BuddhistCalendar(const BuddhistCalendar& source)
  44 : GregorianCalendar(source)
  45 {
  46 }
  47
  48 BuddhistCalendar& BuddhistCalendar::operator= ( const BuddhistCalendar& right)
  49 {
  50     GregorianCalendar::operator=(right);
  51     return *this;
  52 }
  53
  54 Calendar* BuddhistCalendar::clone(void) const
  55 {
  56     return new BuddhistCalendar(*this);
  57 }
  58
  59 const char *BuddhistCalendar::getType() const
  60 {
  61     return "buddhist";
  62 }
  63
  64 int32_t BuddhistCalendar::handleGetExtendedYear()
  65 {
  66     // EXTENDED_YEAR in BuddhistCalendar is a Gregorian year.
  67     // The default value of EXTENDED_YEAR is 1970 (Buddhist 2513)
  68     int32_t year;
  69     if (newerField(UCAL_EXTENDED_YEAR, UCAL_YEAR) == UCAL_EXTENDED_YEAR) {
  70         year = internalGet(UCAL_EXTENDED_YEAR, kGregorianEpoch);
  71     } else {
  72         // extended year is a gregorian year, where 1 = 1AD,  0 = 1BC, -1 = 2BC, etc
  73         year = internalGet(UCAL_YEAR, kGregorianEpoch - kBuddhistEraStart)
  74                 + kBuddhistEraStart;
  75     }
  76     return year;
  77 }
  78
  79 int32_t BuddhistCalendar::handleComputeMonthStart(int32_t eyear, int32_t month,
  80
  81                                                   UBool useMonth) const
  82 {
  83     return GregorianCalendar::handleComputeMonthStart(eyear, month, useMonth);
  84 }
  85
  86 void BuddhistCalendar::handleComputeFields(int32_t julianDay, UErrorCode& status)
  87 {
  88     GregorianCalendar::handleComputeFields(julianDay, status);
  89     int32_t y = internalGet(UCAL_EXTENDED_YEAR) - kBuddhistEraStart;
  90     internalSet(UCAL_ERA, 0);
  91     internalSet(UCAL_YEAR, y);
  92 }
  93
  94 int32_t BuddhistCalendar::handleGetLimit(UCalendarDateFields field, ELimitType limitType) const
  95 {
  96     if(field == UCAL_ERA) {
  97         return BE;
  98     } else {
  99         return GregorianCalendar::handleGetLimit(field,limitType);
 100     }
 101 }
 102
 103 #if 0
 104 void BuddhistCalendar::timeToFields(UDate theTime, UBool quick, UErrorCode& status)
 105 {
 106     //Calendar::timeToFields(theTime, quick, status);
 107
 108     int32_t era = internalGet(UCAL_ERA);
 109     int32_t year = internalGet(UCAL_YEAR);
 110
 111     if(era == GregorianCalendar::BC) {
 112         year = 1-year;
 113         era = BuddhistCalendar::BE;
 114     } else if(era == GregorianCalendar::AD) {
 115         era = BuddhistCalendar::BE;
 116     } else {
 117         status = U_INTERNAL_PROGRAM_ERROR;
 118     }
 119
 120     year = year - kBuddhistEraStart;
 121
 122     internalSet(UCAL_ERA, era);
 123     internalSet(UCAL_YEAR, year);
 124 }
 125 #endif
 126
 127 /**
 128  * The system maintains a static default century start date.  This is initialized
 129  * the first time it is used. Once the system default century date and year
 130  * are set, they do not change.
 131  */
 132 static UDate     gSystemDefaultCenturyStart       = DBL_MIN;
 133 static int32_t   gSystemDefaultCenturyStartYear   = -1;
 134 static icu::UInitOnce gBCInitOnce;
 135
 136
 137 UBool BuddhistCalendar::haveDefaultCentury() const
 138 {
 139     return TRUE;
 140 }
 141
 142 static void U_CALLCONV
 143 initializeSystemDefaultCentury()
 144 {
 145     // initialize systemDefaultCentury and systemDefaultCenturyYear based
 146     // on the current time.  They'll be set to 80 years before
 147     // the current time.
 148     UErrorCode status = U_ZERO_ERROR;
 149     BuddhistCalendar calendar(Locale("@calendar=buddhist"),status);
 150     if (U_SUCCESS(status)) {
 151         calendar.setTime(Calendar::getNow(), status);
 152         calendar.add(UCAL_YEAR, -80, status);
 153         UDate    newStart =  calendar.getTime(status);
 154         int32_t  newYear  =  calendar.get(UCAL_YEAR, status);
 155         gSystemDefaultCenturyStartYear = newYear;
 156         gSystemDefaultCenturyStart = newStart;
 157     }
 158     // We have no recourse upon failure unless we want to propagate the failure
 159     // out.
 160 }
 161
 162 UDate BuddhistCalendar::defaultCenturyStart() const
 163 {
 164     // lazy-evaluate systemDefaultCenturyStart and systemDefaultCenturyStartYear
 165     umtx_initOnce(gBCInitOnce, &initializeSystemDefaultCentury);
 166     return gSystemDefaultCenturyStart;
 167 }
 168
 169 int32_t BuddhistCalendar::defaultCenturyStartYear() const
 170 {
 171     // lazy-evaluate systemDefaultCenturyStartYear and systemDefaultCenturyStart
 172     umtx_initOnce(gBCInitOnce, &initializeSystemDefaultCentury);
 173     return gSystemDefaultCenturyStartYear;
 174 }
 175
 176
 177 U_NAMESPACE_END
 178
 179 #endif