The Tor Browser: intl/icu/source/i18n/buddhcal.cpp@fc2d59ddac77

     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 */

    14 #include "unicode/utypes.h"

    16 #if !UCONFIG_NO_FORMATTING

    18 #include "buddhcal.h"

    19 #include "unicode/gregocal.h"

    20 #include "umutex.h"

    21 #include <float.h>

    23 U_NAMESPACE_BEGIN

    25 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(BuddhistCalendar)

    27 //static const int32_t kMaxEra = 0; // only 1 era

    29 static const int32_t kBuddhistEraStart = -543;  // 544 BC (Gregorian)

    31 static const int32_t kGregorianEpoch = 1970;    // used as the default value of EXTENDED_YEAR

    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 }

    39 BuddhistCalendar::~BuddhistCalendar()

    40 {

    41 }

    43 BuddhistCalendar::BuddhistCalendar(const BuddhistCalendar& source)

    44 : GregorianCalendar(source)

    45 {

    46 }

    48 BuddhistCalendar& BuddhistCalendar::operator= ( const BuddhistCalendar& right)

    49 {

    50     GregorianCalendar::operator=(right);

    51     return *this;

    52 }

    54 Calendar* BuddhistCalendar::clone(void) const

    55 {

    56     return new BuddhistCalendar(*this);

    57 }

    59 const char *BuddhistCalendar::getType() const

    60 {

    61     return "buddhist";

    62 }

    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 }

    79 int32_t BuddhistCalendar::handleComputeMonthStart(int32_t eyear, int32_t month,

    81                                                   UBool useMonth) const

    82 {

    83     return GregorianCalendar::handleComputeMonthStart(eyear, month, useMonth);

    84 }

    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 }

    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 }

   103 #if 0

   104 void BuddhistCalendar::timeToFields(UDate theTime, UBool quick, UErrorCode& status)

   105 {

   106     //Calendar::timeToFields(theTime, quick, status);

   108     int32_t era = internalGet(UCAL_ERA);

   109     int32_t year = internalGet(UCAL_YEAR);

   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     }

   120     year = year - kBuddhistEraStart;

   122     internalSet(UCAL_ERA, era);

   123     internalSet(UCAL_YEAR, year);

   124 }

   125 #endif

   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;

   137 UBool BuddhistCalendar::haveDefaultCentury() const

   138 {

   139     return TRUE;

   140 }

   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 }

   162 UDate BuddhistCalendar::defaultCenturyStart() const

   163 {

   164     // lazy-evaluate systemDefaultCenturyStart and systemDefaultCenturyStartYear

   165     umtx_initOnce(gBCInitOnce, &initializeSystemDefaultCentury);

   166     return gSystemDefaultCenturyStart;

   167 }

   169 int32_t BuddhistCalendar::defaultCenturyStartYear() const

   170 {

   171     // lazy-evaluate systemDefaultCenturyStartYear and systemDefaultCenturyStart

   172     umtx_initOnce(gBCInitOnce, &initializeSystemDefaultCentury);

   173     return gSystemDefaultCenturyStartYear;

   174 }

   177 U_NAMESPACE_END

   179 #endif

The Tor Browser / file revision