ICU 56 update step 1

source/i18n/calendar.cpp

 /*
 *******************************************************************************
-* Copyright (C) 1997-2014, International Business Machines Corporation and    *
+* Copyright (C) 1997-2015, International Business Machines Corporation and    *
 * others. All Rights Reserved.                                                *
 *******************************************************************************
 *
 * File CALENDAR.CPP
 *
 * Modification History: 
 *
 *   Date        Name        Description
 *   02/03/97    clhuang     Creation.
 *   04/22/97    aliu        Cleaned up, fixed memory leak, made 
@@ skipping 36 matching lines @@
 #include "unicode/calendar.h"
 #include "cpputils.h"
 #include "servloc.h"
 #include "ucln_in.h"
 #include "cstring.h"
 #include "locbased.h"
 #include "uresimp.h"
 #include "ustrenum.h"
 #include "uassert.h"
 #include "olsontz.h"
+#include "sharedcalendar.h"
+#include "unifiedcache.h"
 
 #if !UCONFIG_NO_SERVICE
 static icu::ICULocaleService* gService = NULL;
 static icu::UInitOnce gServiceInitOnce = U_INITONCE_INITIALIZER;
 #endif
 
 // INTERNAL - for cleanup
 
 U_CDECL_BEGIN
 static UBool calendar_cleanup(void) {
@@ skipping 122 matching lines @@
     CALTYPE_ETHIOPIC_AMETE_ALEM,
     CALTYPE_ISO8601,
     CALTYPE_DANGI,
     CALTYPE_ISLAMIC_UMALQURA,
     CALTYPE_ISLAMIC_TBLA,
     CALTYPE_ISLAMIC_RGSA
 } ECalType;
 
 U_NAMESPACE_BEGIN
 
+SharedCalendar::~SharedCalendar() {
+    delete ptr;
+}
+
+template<> U_I18N_API
+const SharedCalendar *LocaleCacheKey<SharedCalendar>::createObject(
+        const void * /*unusedCreationContext*/, UErrorCode &status) const {
+    Calendar *calendar = Calendar::makeInstance(fLoc, status);
+    if (U_FAILURE(status)) {
+        return NULL; 
+    }
+    SharedCalendar *shared = new SharedCalendar(calendar);
+    if (shared == NULL) {
+        delete calendar;
+        status = U_MEMORY_ALLOCATION_ERROR;
+        return NULL;
+    }
+    shared->addRef();
+    return shared;
+}
+
 static ECalType getCalendarType(const char *s) {
     for (int i = 0; gCalTypes[i] != NULL; i++) {
         if (uprv_stricmp(s, gCalTypes[i]) == 0) {
             return (ECalType)i;
         }
     }
     return CALTYPE_UNKNOWN;
 }
 
 static UBool isStandardSupportedKeyword(const char *keyword, UErrorCode& status) { 
@@ skipping 393 matching lines @@
     {           0,            0,            23,            23  }, // HOUR_OF_DAY
     {           0,            0,            59,            59  }, // MINUTE
     {           0,            0,            59,            59  }, // SECOND
     {           0,            0,           999,           999  }, // MILLISECOND
     {-12*kOneHour, -12*kOneHour,   12*kOneHour,   15*kOneHour  }, // ZONE_OFFSET
     {           0,            0,    1*kOneHour,    1*kOneHour  }, // DST_OFFSET
     {/*N/A*/-1,       /*N/A*/-1,     /*N/A*/-1,       /*N/A*/-1}, // YEAR_WOY
     {           1,            1,             7,             7  }, // DOW_LOCAL
     {/*N/A*/-1,       /*N/A*/-1,     /*N/A*/-1,       /*N/A*/-1}, // EXTENDED_YEAR
     { -0x7F000000,  -0x7F000000,    0x7F000000,    0x7F000000  }, // JULIAN_DAY
-    {           0,            0, 24*kOneHour-1, 24*kOneHour-1  },  // MILLISECONDS_IN_DAY
-    {           0,            0,             1,             1  },  // IS_LEAP_MONTH
+    {           0,            0, 24*kOneHour-1, 24*kOneHour-1  }, // MILLISECONDS_IN_DAY
+    {           0,            0,             1,             1  }, // IS_LEAP_MONTH
 };
 
 // Resource bundle tags read by this class
 static const char gMonthNames[] = "monthNames";
 
 // Data flow in Calendar
 // ---------------------
 
 // The current time is represented in two ways by Calendar: as UTC
 // milliseconds from the epoch start (1 January 1970 0:00 UTC), and as local
@@ skipping 199 matching lines @@
 Calendar* U_EXPORT2
 Calendar::createInstance(const Locale& aLocale, UErrorCode& success)
 {
     return createInstance(TimeZone::createDefault(), aLocale, success);
 }
 
 // ------------------------------------- Adopting 
 
 // Note: this is the bottleneck that actually calls the service routines.
 
-Calendar* U_EXPORT2
-Calendar::createInstance(TimeZone* zone, const Locale& aLocale, UErrorCode& success)
-{
+Calendar * U_EXPORT2
+Calendar::makeInstance(const Locale& aLocale, UErrorCode& success) {
     if (U_FAILURE(success)) {
         return NULL;
     }
 
     Locale actualLoc;
     UObject* u = NULL;
 
 #if !UCONFIG_NO_SERVICE
     if (isCalendarServiceUsed()) {
         u = getCalendarService(success)->get(aLocale, LocaleKey::KIND_ANY, &actualLoc, success);
     }
     else
 #endif
     {
         u = createStandardCalendar(getCalendarTypeForLocale(aLocale.getName()), aLocale, success);
     }
     Calendar* c = NULL;
 
     if(U_FAILURE(success) || !u) {
-        delete zone;
         if(U_SUCCESS(success)) { // Propagate some kind of err
             success = U_INTERNAL_PROGRAM_ERROR;
         }
         return NULL;
     }
 
 #if !UCONFIG_NO_SERVICE
     const UnicodeString* str = dynamic_cast<const UnicodeString*>(u);
     if(str != NULL) {
         // It's a unicode string telling us what type of calendar to load ("gregorian", etc)
         // Create a Locale over this string
         Locale l("");
         LocaleUtility::initLocaleFromName(*str, l);
 
 #ifdef U_DEBUG_CALSVC
         fprintf(stderr, "Calendar::createInstance(%s), looking up [%s]\n", aLocale.getName(), l.getName());
 #endif
 
         Locale actualLoc2;
         delete u;
         u = NULL;
 
         // Don't overwrite actualLoc, since the actual loc from this call
         // may be something like "@calendar=gregorian" -- TODO investigate
         // further...
         c = (Calendar*)getCalendarService(success)->get(l, LocaleKey::KIND_ANY, &actualLoc2, success);
 
         if(U_FAILURE(success) || !c) {
-            delete zone;
             if(U_SUCCESS(success)) { 
                 success = U_INTERNAL_PROGRAM_ERROR; // Propagate some err
             }
             return NULL;
         }
 
         str = dynamic_cast<const UnicodeString*>(c);
         if(str != NULL) {
             // recursed! Second lookup returned a UnicodeString. 
             // Perhaps DefaultCalendar{} was set to another locale.
 #ifdef U_DEBUG_CALSVC
             char tmp[200];
             // Extract a char* out of it..
             int32_t len = str->length();
             int32_t actLen = sizeof(tmp)-1;
             if(len > actLen) {
                 len = actLen;
             }
             str->extract(0,len,tmp);
             tmp[len]=0;
 
             fprintf(stderr, "err - recursed, 2nd lookup was unistring %s\n", tmp);
 #endif
             success = U_MISSING_RESOURCE_ERROR;  // requested a calendar type which could NOT be found.
             delete c;
-            delete zone;
             return NULL;
         }
 #ifdef U_DEBUG_CALSVC
         fprintf(stderr, "%p: setting week count data to locale %s, actual locale %s\n", c, (const char*)aLocale.getName(), (const char *)actualLoc.getName());
 #endif
         c->setWeekData(aLocale, c->getType(), success);  // set the correct locale (this was an indirected calendar)
 
         char keyword[ULOC_FULLNAME_CAPACITY];
         UErrorCode tmpStatus = U_ZERO_ERROR;
         l.getKeywordValue("calendar", keyword, ULOC_FULLNAME_CAPACITY, tmpStatus);
         if (U_SUCCESS(tmpStatus) && uprv_strcmp(keyword, "iso8601") == 0) {
             c->setFirstDayOfWeek(UCAL_MONDAY);
             c->setMinimalDaysInFirstWeek(4);
         }
     }
     else
 #endif /* UCONFIG_NO_SERVICE */
     {
         // a calendar was returned - we assume the factory did the right thing.
         c = (Calendar*)u;
     }
 
+    return c;
+}
+
+Calendar* U_EXPORT2
+Calendar::createInstance(TimeZone* zone, const Locale& aLocale, UErrorCode& success)
+{
+    LocalPointer<TimeZone> zonePtr(zone);
+    const SharedCalendar *shared = NULL;
+    UnifiedCache::getByLocale(aLocale, shared, success);
+    if (U_FAILURE(success)) {
+        return NULL;
+    }
+    Calendar *c = (*shared)->clone();
+    shared->removeRef();
+    if (c == NULL) {
+        success = U_MEMORY_ALLOCATION_ERROR;
+        return NULL;
+    }
+
     // Now, reset calendar to default state:
-    c->adoptTimeZone(zone); //  Set the correct time zone
+    c->adoptTimeZone(zonePtr.orphan()); //  Set the correct time zone
     c->setTimeInMillis(getNow(), success); // let the new calendar have the current time.
 
     return c;
 }
 
 // -------------------------------------
 
 Calendar* U_EXPORT2
 Calendar::createInstance(const TimeZone& zone, const Locale& aLocale, UErrorCode& success)
 {
     Calendar* c = createInstance(aLocale, success);
     if(U_SUCCESS(success) && c) {
         c->setTimeZone(zone);
     }
     return c; 
 }
 
 // -------------------------------------
 
+void U_EXPORT2
+Calendar::getCalendarTypeFromLocale(
+        const Locale &aLocale,
+        char *typeBuffer,
+        int32_t typeBufferSize,
+        UErrorCode &success) {
+    const SharedCalendar *shared = NULL;
+    UnifiedCache::getByLocale(aLocale, shared, success);
+    if (U_FAILURE(success)) {
+        return;
+    }
+    uprv_strncpy(typeBuffer, (*shared)->getType(), typeBufferSize);
+    shared->removeRef();
+    if (typeBuffer[typeBufferSize - 1]) {
+        success = U_BUFFER_OVERFLOW_ERROR;
+    }
+}
+
 UBool
 Calendar::operator==(const Calendar& that) const
 {
     UErrorCode status = U_ZERO_ERROR;
     return isEquivalentTo(that) &&
         getTimeInMillis(status) == that.getTimeInMillis(status) &&
         U_SUCCESS(status);
 }
 
 UBool 
@@ skipping 2899 matching lines @@
     return NULL;
 }
 
 U_NAMESPACE_END
 
 #endif /* #if !UCONFIG_NO_FORMATTING */
 
 
 //eof