ICU 56 update step 1

source/i18n/dtptngen.cpp

 /*
 *******************************************************************************
-* Copyright (C) 2007-2014, International Business Machines Corporation and
+* Copyright (C) 2007-2015, International Business Machines Corporation and
 * others. All Rights Reserved.
 *******************************************************************************
 *
 * File DTPTNGEN.CPP
 *
 *******************************************************************************
 */
 
 #include "unicode/utypes.h"
 #if !UCONFIG_NO_FORMATTING
@@ skipping 103 matching lines @@
     return ret;
 #endif
 }
 
 
 #endif
 
 
 U_NAMESPACE_BEGIN
 
-
 // *****************************************************************************
 // class DateTimePatternGenerator
 // *****************************************************************************
 static const UChar Canonical_Items[] = {
     // GyQMwWEdDFHmsSv
     CAP_G, LOW_Y, CAP_Q, CAP_M, LOW_W, CAP_W, CAP_E, LOW_D, CAP_D, CAP_F,
     CAP_H, LOW_M, LOW_S, CAP_S, LOW_V, 0
 };
 
 static const dtTypeElem dtTypes[] = {
@@ skipping 100 matching lines @@
 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(DTSkeletonEnumeration)
 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(DTRedundantEnumeration)
 
 DateTimePatternGenerator*  U_EXPORT2
 DateTimePatternGenerator::createInstance(UErrorCode& status) {
     return createInstance(Locale::getDefault(), status);
 }
 
 DateTimePatternGenerator* U_EXPORT2
 DateTimePatternGenerator::createInstance(const Locale& locale, UErrorCode& status) {
-    DateTimePatternGenerator *result = new DateTimePatternGenerator(locale, status);
-    if (result == NULL) {
-        status = U_MEMORY_ALLOCATION_ERROR;
+    if (U_FAILURE(status)) {
+        return NULL;
     }
-    if (U_FAILURE(status)) {
-        delete result;
-        result = NULL;
-    }
-    return result;
+    LocalPointer<DateTimePatternGenerator> result(
+            new DateTimePatternGenerator(locale, status), status);
+    return U_SUCCESS(status) ? result.orphan() : NULL;
 }
 
 DateTimePatternGenerator*  U_EXPORT2
 DateTimePatternGenerator::createEmptyInstance(UErrorCode& status) {
     DateTimePatternGenerator *result = new DateTimePatternGenerator(status);
     if (result == NULL) {
         status = U_MEMORY_ALLOCATION_ERROR;
     }
     if (U_FAILURE(status)) {
         delete result;
@@ skipping 38 matching lines @@
 {
     fp = new FormatParser();
     dtMatcher = new DateTimeMatcher();
     distanceInfo = new DistanceInfo();
     patternMap = new PatternMap();
     *this=other;
 }
 
 DateTimePatternGenerator&
 DateTimePatternGenerator::operator=(const DateTimePatternGenerator& other) {
+    // reflexive case
+    if (&other == this) {
+        return *this;
+    }
     pLocale = other.pLocale;
     fDefaultHourFormatChar = other.fDefaultHourFormatChar;
     *fp = *(other.fp);
     dtMatcher->copyFrom(other.dtMatcher->skeleton);
     *distanceInfo = *(other.distanceInfo);
     dateTimeFormat = other.dateTimeFormat;
     decimal = other.decimal;
     // NUL-terminate for the C API.
     dateTimeFormat.getTerminatedBuffer();
     decimal.getTerminatedBuffer();
@@ skipping 65 matching lines @@
     addICUPatterns(locale, status);
     if (U_FAILURE(status)) {
         return;
     }
     addCLDRData(locale, status);
     setDateTimeFromCalendar(locale, status);
     setDecimalSymbols(locale, status);
 } // DateTimePatternGenerator::initData
 
 UnicodeString
-DateTimePatternGenerator::getSkeleton(const UnicodeString& pattern, UErrorCode&
-/*status*/) {
-    dtMatcher->set(pattern, fp);
-    return dtMatcher->getSkeletonPtr()->getSkeleton();
+DateTimePatternGenerator::staticGetSkeleton(
+        const UnicodeString& pattern, UErrorCode& /*status*/) {
+    FormatParser fp;
+    DateTimeMatcher matcher;
+    PtnSkeleton localSkeleton;
+    matcher.set(pattern, &fp, localSkeleton);
+    return localSkeleton.getSkeleton();
 }
 
 UnicodeString
-DateTimePatternGenerator::getBaseSkeleton(const UnicodeString& pattern, UErrorCode& /*status*/) {
-    dtMatcher->set(pattern, fp);
-    return dtMatcher->getSkeletonPtr()->getBaseSkeleton();
+DateTimePatternGenerator::staticGetBaseSkeleton(
+        const UnicodeString& pattern, UErrorCode& /*status*/) {
+    FormatParser fp;
+    DateTimeMatcher matcher;
+    PtnSkeleton localSkeleton;
+    matcher.set(pattern, &fp, localSkeleton);
+    return localSkeleton.getBaseSkeleton();
 }
 
 void
 DateTimePatternGenerator::addICUPatterns(const Locale& locale, UErrorCode& status) {
     UnicodeString dfPattern;
     UnicodeString conflictingString;
     DateFormat* df;
 
     if (U_FAILURE(status)) {
         return;
@@ skipping 790 matching lines @@
         return;
     }
     if (fAvailableFormatKeyHash != NULL) {
         delete fAvailableFormatKeyHash;
         fAvailableFormatKeyHash = NULL;
     }
     initHashtable(status);
     if(U_FAILURE(status)){
         return;
     }
-    int32_t pos = -1;
+    int32_t pos = UHASH_FIRST;
     const UHashElement* elem = NULL;
     // walk through the hash table and create a deep clone
     while((elem = other->nextElement(pos))!= NULL){
         const UHashTok otherKeyTok = elem->key;
         UnicodeString* otherKey = (UnicodeString*)otherKeyTok.pointer;
         fAvailableFormatKeyHash->puti(*otherKey, 1, status);
         if(U_FAILURE(status)){
             return;
         }
     }
@@ skipping 95 matching lines @@
                 return;
             }
             if ( this->boot[bootIndex]== NULL ) {
                 this->boot[bootIndex] = curElem;
             }
             if ((curElem->skeleton=new PtnSkeleton(*(otherElem->skeleton))) == NULL ) {
                 // out of memory
                 status = U_MEMORY_ALLOCATION_ERROR;
                 return;
             }
-
+            curElem->skeletonWasSpecified = otherElem->skeletonWasSpecified;
             if (prevElem!=NULL) {
                 prevElem->next=curElem;
             }
             curElem->next=NULL;
             prevElem = curElem;
             otherElem = otherElem->next;
         }
 
     }
 }
@@ skipping 486 matching lines @@
         if (dtTypes[i+1].minLen <= len) {
             ++i;
             continue;
         }
         return i;
     }
     return strict ? -1 : bestRow;
 }
 
 UBool
-FormatParser::isQuoteLiteral(const UnicodeString& s) const {
+FormatParser::isQuoteLiteral(const UnicodeString& s) {
     return (UBool)(s.charAt(0)==SINGLE_QUOTE);
 }
 
 // This function aussumes the current itemIndex points to the quote literal.
 // Please call isQuoteLiteral prior to this function.
 void
 FormatParser::getQuoteLiteral(UnicodeString& quote, int32_t *itemIndex) {
     int32_t i=*itemIndex;
 
     quote.remove();
@@ skipping 354 matching lines @@
     }
     delete fPatterns;
 }
 
 U_NAMESPACE_END
 
 
 #endif /* #if !UCONFIG_NO_FORMATTING */
 
 //eof