icuSources/i18n/buddhcal.cpp

   1 /*
   2 *******************************************************************************
   3 * Copyright (C) 2003-2007, 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 // default century
 128 const UDate     BuddhistCalendar::fgSystemDefaultCentury        = DBL_MIN;
 129 const int32_t   BuddhistCalendar::fgSystemDefaultCenturyYear    = -1;
 130
 131 UDate           BuddhistCalendar::fgSystemDefaultCenturyStart       = DBL_MIN;
 132 int32_t         BuddhistCalendar::fgSystemDefaultCenturyStartYear   = -1;
 133
 134
 135 UBool BuddhistCalendar::haveDefaultCentury() const
 136 {
 137     return TRUE;
 138 }
 139
 140 UDate BuddhistCalendar::defaultCenturyStart() const
 141 {
 142     return internalGetDefaultCenturyStart();
 143 }
 144
 145 int32_t BuddhistCalendar::defaultCenturyStartYear() const
 146 {
 147     return internalGetDefaultCenturyStartYear();
 148 }
 149
 150 UDate
 151 BuddhistCalendar::internalGetDefaultCenturyStart() const
 152 {
 153     // lazy-evaluate systemDefaultCenturyStart
 154     UBool needsUpdate;
 155     UMTX_CHECK(NULL, (fgSystemDefaultCenturyStart == fgSystemDefaultCentury), needsUpdate);
 156
 157     if (needsUpdate) {
 158         initializeSystemDefaultCentury();
 159     }
 160
 161     // use defaultCenturyStart unless it's the flag value;
 162     // then use systemDefaultCenturyStart
 163
 164     return fgSystemDefaultCenturyStart;
 165 }
 166
 167 int32_t
 168 BuddhistCalendar::internalGetDefaultCenturyStartYear() const
 169 {
 170     // lazy-evaluate systemDefaultCenturyStartYear
 171     UBool needsUpdate;
 172     UMTX_CHECK(NULL, (fgSystemDefaultCenturyStart == fgSystemDefaultCentury), needsUpdate);
 173
 174     if (needsUpdate) {
 175         initializeSystemDefaultCentury();
 176     }
 177
 178     // use defaultCenturyStart unless it's the flag value;
 179     // then use systemDefaultCenturyStartYear
 180
 181     return    fgSystemDefaultCenturyStartYear;
 182 }
 183
 184 void
 185 BuddhistCalendar::initializeSystemDefaultCentury()
 186 {
 187     // initialize systemDefaultCentury and systemDefaultCenturyYear based
 188     // on the current time.  They'll be set to 80 years before
 189     // the current time.
 190     // No point in locking as it should be idempotent.
 191     if (fgSystemDefaultCenturyStart == fgSystemDefaultCentury)
 192     {
 193         UErrorCode status = U_ZERO_ERROR;
 194         BuddhistCalendar calendar(Locale("@calendar=buddhist"),status);
 195         if (U_SUCCESS(status))
 196         {
 197             calendar.setTime(Calendar::getNow(), status);
 198             calendar.add(UCAL_YEAR, -80, status);
 199             UDate    newStart =  calendar.getTime(status);
 200             int32_t  newYear  =  calendar.get(UCAL_YEAR, status);
 201             {
 202                 umtx_lock(NULL);
 203                 fgSystemDefaultCenturyStart = newStart;
 204                 fgSystemDefaultCenturyStartYear = newYear;
 205                 umtx_unlock(NULL);
 206             }
 207         }
 208         // We have no recourse upon failure unless we want to propagate the failure
 209         // out.
 210     }
 211 }
 212
 213
 214 U_NAMESPACE_END
 215
 216 #endif