../deps/icu-small/source/i18n/dtfmtsym.cpp

Bug Summary

File:	out/../deps/icu-small/source/i18n/dtfmtsym.cpp
Warning:	line 256, column 55 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name dtfmtsym.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -pic-is-pie -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/home/maurizio/node-v18.6.0/out -resource-dir /usr/local/lib/clang/16.0.0 -D V8_DEPRECATION_WARNINGS -D V8_IMMINENT_DEPRECATION_WARNINGS -D _GLIBCXX_USE_CXX11_ABI=1 -D NODE_OPENSSL_CONF_NAME=nodejs_conf -D NODE_OPENSSL_HAS_QUIC -D __STDC_FORMAT_MACROS -D OPENSSL_NO_PINSHARED -D OPENSSL_THREADS -D U_COMMON_IMPLEMENTATION=1 -D U_I18N_IMPLEMENTATION=1 -D U_IO_IMPLEMENTATION=1 -D U_TOOLUTIL_IMPLEMENTATION=1 -D U_ATTRIBUTE_DEPRECATED= -D _CRT_SECURE_NO_DEPRECATE= -D U_STATIC_IMPLEMENTATION=1 -D UCONFIG_NO_SERVICE=1 -D U_ENABLE_DYLOAD=0 -D U_HAVE_STD_STRING=1 -D UCONFIG_NO_BREAK_ITERATION=0 -I ../deps/icu-small/source/common -I ../deps/icu-small/source/i18n -I ../deps/icu-small/source/tools/toolutil -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8 -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/x86_64-redhat-linux -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/backward -internal-isystem /usr/local/lib/clang/16.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../x86_64-redhat-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O3 -Wno-unused-parameter -Wno-deprecated-declarations -Wno-strict-aliasing -std=gnu++17 -fdeprecated-macro -fdebug-compilation-dir=/home/maurizio/node-v18.6.0/out -ferror-limit 19 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-08-22-142216-507842-1 -x c++ ../deps/icu-small/source/i18n/dtfmtsym.cpp

../deps/icu-small/source/i18n/dtfmtsym.cpp

→

1// © 2016 and later: Unicode, Inc. and others.
2// License & terms of use: http://www.unicode.org/copyright.html
3/*
4*******************************************************************************
5* Copyright (C) 1997-2016, International Business Machines Corporation and    *
6* others. All Rights Reserved.                                                *
7*******************************************************************************
8*
9* File DTFMTSYM.CPP
10*
11* Modification History:
12*
13*   Date        Name        Description
14*   02/19/97    aliu        Converted from java.
15*   07/21/98    stephen     Added getZoneIndex
16*                            Changed weekdays/short weekdays to be one-based
17*   06/14/99    stephen     Removed SimpleDateFormat::fgTimeZoneDataSuffix
18*   11/16/99    weiv        Added 'Y' and 'e' to fgPatternChars
19*   03/27/00    weiv        Keeping resource bundle around!
20*   06/30/05    emmons      Added eraNames, narrow month/day, standalone context
21*   10/12/05    emmons      Added setters for eraNames, month/day by width/context
22*******************************************************************************
23*/

25#include <utility>

27#include "unicode/utypes.h"

29#if !UCONFIG_NO_FORMATTING0
30#include "unicode/ustring.h"
31#include "unicode/localpointer.h"
32#include "unicode/dtfmtsym.h"
33#include "unicode/smpdtfmt.h"
34#include "unicode/msgfmt.h"
35#include "unicode/numsys.h"
36#include "unicode/tznames.h"
37#include "cpputils.h"
38#include "umutex.h"
39#include "cmemory.h"
40#include "cstring.h"
41#include "charstr.h"
42#include "dt_impl.h"
43#include "locbased.h"
44#include "gregoimp.h"
45#include "hash.h"
46#include "uassert.h"
47#include "uresimp.h"
48#include "ureslocs.h"
49#include "uvector.h"
50#include "shareddateformatsymbols.h"
51#include "unicode/calendar.h"
52#include "unifiedcache.h"

54// *****************************************************************************
55// class DateFormatSymbols
56// *****************************************************************************

58/**
* These are static arrays we use only in the case where we have no
* resource data.
*/

63#if UDAT_HAS_PATTERN_CHAR_FOR_TIME_SEPARATOR0
64#define PATTERN_CHARS_LEN37 38
65#else
66#define PATTERN_CHARS_LEN37 37
67#endif

69/**
* Unlocalized date-time pattern characters. For example: 'y', 'd', etc. All
* locales use the same these unlocalized pattern characters.
*/
73static const UChar gPatternChars[] = {
  // if UDAT_HAS_PATTERN_CHAR_FOR_TIME_SEPARATOR:
  //   GyMdkHmsSEDFwWahKzYeugAZvcLQqVUOXxrbB:
  // else:
  //   GyMdkHmsSEDFwWahKzYeugAZvcLQqVUOXxrbB

  0x47, 0x79, 0x4D, 0x64, 0x6B, 0x48, 0x6D, 0x73, 0x53, 0x45,
  0x44, 0x46, 0x77, 0x57, 0x61, 0x68, 0x4B, 0x7A, 0x59, 0x65,
  0x75, 0x67, 0x41, 0x5A, 0x76, 0x63, 0x4c, 0x51, 0x71, 0x56,
  0x55, 0x4F, 0x58, 0x78, 0x72, 0x62, 0x42,
83#if UDAT_HAS_PATTERN_CHAR_FOR_TIME_SEPARATOR0
  0x3a,
85#endif
  0
87};

89//------------------------------------------------------
90// Strings of last resort.  These are only used if we have no resource
91// files.  They aren't designed for actual use, just for backup.

93// These are the month names and abbreviations of last resort.
94static const UChar gLastResortMonthNames[13][3] =
95{
  {0x0030, 0x0031, 0x0000}, /* "01" */
  {0x0030, 0x0032, 0x0000}, /* "02" */
  {0x0030, 0x0033, 0x0000}, /* "03" */
  {0x0030, 0x0034, 0x0000}, /* "04" */
  {0x0030, 0x0035, 0x0000}, /* "05" */
  {0x0030, 0x0036, 0x0000}, /* "06" */
  {0x0030, 0x0037, 0x0000}, /* "07" */
  {0x0030, 0x0038, 0x0000}, /* "08" */
  {0x0030, 0x0039, 0x0000}, /* "09" */
  {0x0031, 0x0030, 0x0000}, /* "10" */
  {0x0031, 0x0031, 0x0000}, /* "11" */
  {0x0031, 0x0032, 0x0000}, /* "12" */
  {0x0031, 0x0033, 0x0000}  /* "13" */
109};

111// These are the weekday names and abbreviations of last resort.
112static const UChar gLastResortDayNames[8][2] =
113{
  {0x0030, 0x0000}, /* "0" */
  {0x0031, 0x0000}, /* "1" */
  {0x0032, 0x0000}, /* "2" */
  {0x0033, 0x0000}, /* "3" */
  {0x0034, 0x0000}, /* "4" */
  {0x0035, 0x0000}, /* "5" */
  {0x0036, 0x0000}, /* "6" */
  {0x0037, 0x0000}  /* "7" */
122};

124// These are the quarter names and abbreviations of last resort.
125static const UChar gLastResortQuarters[4][2] =
126{
  {0x0031, 0x0000}, /* "1" */
  {0x0032, 0x0000}, /* "2" */
  {0x0033, 0x0000}, /* "3" */
  {0x0034, 0x0000}, /* "4" */
131};

133// These are the am/pm and BC/AD markers of last resort.
134static const UChar gLastResortAmPmMarkers[2][3] =
135{
  {0x0041, 0x004D, 0x0000}, /* "AM" */
  {0x0050, 0x004D, 0x0000}  /* "PM" */
138};

140static const UChar gLastResortEras[2][3] =
141{
  {0x0042, 0x0043, 0x0000}, /* "BC" */
  {0x0041, 0x0044, 0x0000}  /* "AD" */
144};

146/* Sizes for the last resort string arrays */
147typedef enum LastResortSize {
  kMonthNum = 13,
  kMonthLen = 3,

  kDayNum = 8,
  kDayLen = 2,

  kAmPmNum = 2,
  kAmPmLen = 3,

  kQuarterNum = 4,
  kQuarterLen = 2,

  kEraNum = 2,
  kEraLen = 3,

  kZoneNum = 5,
  kZoneLen = 4,

  kGmtHourNum = 4,
  kGmtHourLen = 10
168} LastResortSize;

170U_NAMESPACE_BEGINnamespace icu_71 {

172SharedDateFormatSymbols::~SharedDateFormatSymbols() {
173}

175template<> U_I18N_API
176const SharedDateFormatSymbols *
      LocaleCacheKey<SharedDateFormatSymbols>::createObject(
              const void * /*unusedContext*/, UErrorCode &status) const {
  char type[256];
  Calendar::getCalendarTypeFromLocale(fLoc, type, UPRV_LENGTHOF(type)(int32_t)(sizeof(type)/sizeof((type)[0])), status);
  if (U_FAILURE(status)) {
      return NULL__null;
  }
  SharedDateFormatSymbols *shared
          = new SharedDateFormatSymbols(fLoc, type, status);
  if (shared == NULL__null) {
      status = U_MEMORY_ALLOCATION_ERROR;
      return NULL__null;
  }
  if (U_FAILURE(status)) {
      delete shared;
      return NULL__null;
  }
  shared->addRef();
  return shared;
196}

198UOBJECT_DEFINE_RTTI_IMPLEMENTATION(DateFormatSymbols)UClassID DateFormatSymbols::getStaticClassID() { static char classID
 = 0; return (UClassID)&classID; } UClassID DateFormatSymbols
::getDynamicClassID() const { return DateFormatSymbols::getStaticClassID
(); }

200#define kSUPPLEMENTAL"supplementalData" "supplementalData"

202/**
* These are the tags we expect to see in normal resource bundle files associated
* with a locale and calendar
*/
206static const char gCalendarTag[]="calendar";
207static const char gGregorianTag[]="gregorian";
208static const char gErasTag[]="eras";
209static const char gCyclicNameSetsTag[]="cyclicNameSets";
210static const char gNameSetYearsTag[]="years";
211static const char gNameSetZodiacsTag[]="zodiacs";
212static const char gMonthNamesTag[]="monthNames";
213static const char gMonthPatternsTag[]="monthPatterns";
214static const char gDayNamesTag[]="dayNames";
215static const char gNamesWideTag[]="wide";
216static const char gNamesAbbrTag[]="abbreviated";
217static const char gNamesShortTag[]="short";
218static const char gNamesNarrowTag[]="narrow";
219static const char gNamesAllTag[]="all";
220static const char gNamesFormatTag[]="format";
221static const char gNamesStandaloneTag[]="stand-alone";
222static const char gNamesNumericTag[]="numeric";
223static const char gAmPmMarkersTag[]="AmPmMarkers";
224static const char gAmPmMarkersAbbrTag[]="AmPmMarkersAbbr";
225static const char gAmPmMarkersNarrowTag[]="AmPmMarkersNarrow";
226static const char gQuartersTag[]="quarters";
227static const char gNumberElementsTag[]="NumberElements";
228static const char gSymbolsTag[]="symbols";
229static const char gTimeSeparatorTag[]="timeSeparator";
230static const char gDayPeriodTag[]="dayPeriod";

232// static const char gZoneStringsTag[]="zoneStrings";

234// static const char gLocalPatternCharsTag[]="localPatternChars";

236static const char gContextTransformsTag[]="contextTransforms";

238/**
* Jitterbug 2974: MSVC has a bug whereby new X[0] behaves badly.
* Work around this.
*/
242static inline UnicodeString* newUnicodeStringArray(size_t count) {
  return new UnicodeString[count ? count : 1];
244}

246//------------------------------------------------------

248DateFormatSymbols * U_EXPORT2
249DateFormatSymbols::createForLocale(
      const Locale& locale, UErrorCode &status) {
  const SharedDateFormatSymbols *shared = NULL__null;
1
'shared' initialized to a null pointer value→
  UnifiedCache::getByLocale(locale, shared, status);
2
←
Calling 'UnifiedCache::getByLocale'→
19
←
Returning from 'UnifiedCache::getByLocale'→
  if (U_FAILURE(status)) {
20
←
Taking false branch→
      return NULL__null;
  }
  DateFormatSymbols *result = new DateFormatSymbols(shared->get());
21
←
Called C++ object pointer is null
  shared->removeRef();
  if (result == NULL__null) {
      status = U_MEMORY_ALLOCATION_ERROR;
      return NULL__null;
  }
  return result;
263}

265DateFormatSymbols::DateFormatSymbols(const Locale& locale,
                                   UErrorCode& status)
  : UObject()
268{
initializeData(locale, NULL__null,  status);
270}

272DateFormatSymbols::DateFormatSymbols(UErrorCode& status)
  : UObject()
274{
initializeData(Locale::getDefault(), NULL__null, status, TRUE1);
276}


279DateFormatSymbols::DateFormatSymbols(const Locale& locale,
                                   const char *type,
                                   UErrorCode& status)
  : UObject()
283{
initializeData(locale, type,  status);
285}

287DateFormatSymbols::DateFormatSymbols(const char *type, UErrorCode& status)
  : UObject()
289{
initializeData(Locale::getDefault(), type, status, TRUE1);
291}

293DateFormatSymbols::DateFormatSymbols(const DateFormatSymbols& other)
  : UObject(other)
295{
  copyData(other);
297}

299void
300DateFormatSymbols::assignArray(UnicodeString*& dstArray,
                             int32_t& dstCount,
                             const UnicodeString* srcArray,
                             int32_t srcCount)
304{
  // assignArray() is only called by copyData() and initializeData(), which in turn
  // implements the copy constructor and the assignment operator.
  // All strings in a DateFormatSymbols object are created in one of the following
  // three ways that all allow to safely use UnicodeString::fastCopyFrom():
  // - readonly-aliases from resource bundles
  // - readonly-aliases or allocated strings from constants
  // - safely cloned strings (with owned buffers) from setXYZ() functions
  //
  // Note that this is true for as long as DateFormatSymbols can be constructed
  // only from a locale bundle or set via the cloning API,
  // *and* for as long as all the strings are in *private* fields, preventing
  // a subclass from creating these strings in an "unsafe" way (with respect to fastCopyFrom()).
  dstCount = srcCount;
  dstArray = newUnicodeStringArray(srcCount);
  if(dstArray != NULL__null) {
      int32_t i;
      for(i=0; i<srcCount; ++i) {
          dstArray[i].fastCopyFrom(srcArray[i]);
      }
  }
325}

327/**
* Create a copy, in fZoneStrings, of the given zone strings array.  The
* member variables fZoneStringsRowCount and fZoneStringsColCount should
* be set already by the caller.
*/
332void
333DateFormatSymbols::createZoneStrings(const UnicodeString *const * otherStrings)
334{
  int32_t row, col;
  UBool failed = FALSE0;

  fZoneStrings = (UnicodeString **)uprv_mallocuprv_malloc_71(fZoneStringsRowCount * sizeof(UnicodeString *));
  if (fZoneStrings != NULL__null) {
      for (row=0; row<fZoneStringsRowCount; ++row)
      {
          fZoneStrings[row] = newUnicodeStringArray(fZoneStringsColCount);
          if (fZoneStrings[row] == NULL__null) {
              failed = TRUE1;
              break;
          }
          for (col=0; col<fZoneStringsColCount; ++col) {
              // fastCopyFrom() - see assignArray comments
              fZoneStrings[row][col].fastCopyFrom(otherStrings[row][col]);
          }
      }
  }
  // If memory allocation failed, roll back and delete fZoneStrings
  if (failed) {
      for (int i = row; i >= 0; i--) {
          delete[] fZoneStrings[i];
      }
      uprv_freeuprv_free_71(fZoneStrings);
      fZoneStrings = NULL__null;
  }
361}

363/**
* Copy all of the other's data to this.
*/
366void
367DateFormatSymbols::copyData(const DateFormatSymbols& other) {
  UErrorCode status = U_ZERO_ERROR;
  U_LOCALE_BASED(locBased, *this)LocaleBased locBased((*this).validLocale, (*this).actualLocale
);
  locBased.setLocaleIDs(
      other.getLocale(ULOC_VALID_LOCALE, status),
      other.getLocale(ULOC_ACTUAL_LOCALE, status));
  assignArray(fEras, fErasCount, other.fEras, other.fErasCount);
  assignArray(fEraNames, fEraNamesCount, other.fEraNames, other.fEraNamesCount);
  assignArray(fNarrowEras, fNarrowErasCount, other.fNarrowEras, other.fNarrowErasCount);
  assignArray(fMonths, fMonthsCount, other.fMonths, other.fMonthsCount);
  assignArray(fShortMonths, fShortMonthsCount, other.fShortMonths, other.fShortMonthsCount);
  assignArray(fNarrowMonths, fNarrowMonthsCount, other.fNarrowMonths, other.fNarrowMonthsCount);
  assignArray(fStandaloneMonths, fStandaloneMonthsCount, other.fStandaloneMonths, other.fStandaloneMonthsCount);
  assignArray(fStandaloneShortMonths, fStandaloneShortMonthsCount, other.fStandaloneShortMonths, other.fStandaloneShortMonthsCount);
  assignArray(fStandaloneNarrowMonths, fStandaloneNarrowMonthsCount, other.fStandaloneNarrowMonths, other.fStandaloneNarrowMonthsCount);
  assignArray(fWeekdays, fWeekdaysCount, other.fWeekdays, other.fWeekdaysCount);
  assignArray(fShortWeekdays, fShortWeekdaysCount, other.fShortWeekdays, other.fShortWeekdaysCount);
  assignArray(fShorterWeekdays, fShorterWeekdaysCount, other.fShorterWeekdays, other.fShorterWeekdaysCount);
  assignArray(fNarrowWeekdays, fNarrowWeekdaysCount, other.fNarrowWeekdays, other.fNarrowWeekdaysCount);
  assignArray(fStandaloneWeekdays, fStandaloneWeekdaysCount, other.fStandaloneWeekdays, other.fStandaloneWeekdaysCount);
  assignArray(fStandaloneShortWeekdays, fStandaloneShortWeekdaysCount, other.fStandaloneShortWeekdays, other.fStandaloneShortWeekdaysCount);
  assignArray(fStandaloneShorterWeekdays, fStandaloneShorterWeekdaysCount, other.fStandaloneShorterWeekdays, other.fStandaloneShorterWeekdaysCount);
  assignArray(fStandaloneNarrowWeekdays, fStandaloneNarrowWeekdaysCount, other.fStandaloneNarrowWeekdays, other.fStandaloneNarrowWeekdaysCount);
  assignArray(fAmPms, fAmPmsCount, other.fAmPms, other.fAmPmsCount);
  assignArray(fNarrowAmPms, fNarrowAmPmsCount, other.fNarrowAmPms, other.fNarrowAmPmsCount );
  fTimeSeparator.fastCopyFrom(other.fTimeSeparator);  // fastCopyFrom() - see assignArray comments
  assignArray(fQuarters, fQuartersCount, other.fQuarters, other.fQuartersCount);
  assignArray(fShortQuarters, fShortQuartersCount, other.fShortQuarters, other.fShortQuartersCount);
  assignArray(fNarrowQuarters, fNarrowQuartersCount, other.fNarrowQuarters, other.fNarrowQuartersCount);
  assignArray(fStandaloneQuarters, fStandaloneQuartersCount, other.fStandaloneQuarters, other.fStandaloneQuartersCount);
  assignArray(fStandaloneShortQuarters, fStandaloneShortQuartersCount, other.fStandaloneShortQuarters, other.fStandaloneShortQuartersCount);
  assignArray(fStandaloneNarrowQuarters, fStandaloneNarrowQuartersCount, other.fStandaloneNarrowQuarters, other.fStandaloneNarrowQuartersCount);
  assignArray(fWideDayPeriods, fWideDayPeriodsCount,
              other.fWideDayPeriods, other.fWideDayPeriodsCount);
  assignArray(fNarrowDayPeriods, fNarrowDayPeriodsCount,
              other.fNarrowDayPeriods, other.fNarrowDayPeriodsCount);
  assignArray(fAbbreviatedDayPeriods, fAbbreviatedDayPeriodsCount,
              other.fAbbreviatedDayPeriods, other.fAbbreviatedDayPeriodsCount);
  assignArray(fStandaloneWideDayPeriods, fStandaloneWideDayPeriodsCount,
              other.fStandaloneWideDayPeriods, other.fStandaloneWideDayPeriodsCount);
  assignArray(fStandaloneNarrowDayPeriods, fStandaloneNarrowDayPeriodsCount,
              other.fStandaloneNarrowDayPeriods, other.fStandaloneNarrowDayPeriodsCount);
  assignArray(fStandaloneAbbreviatedDayPeriods, fStandaloneAbbreviatedDayPeriodsCount,
              other.fStandaloneAbbreviatedDayPeriods, other.fStandaloneAbbreviatedDayPeriodsCount);
  if (other.fLeapMonthPatterns != NULL__null) {
      assignArray(fLeapMonthPatterns, fLeapMonthPatternsCount, other.fLeapMonthPatterns, other.fLeapMonthPatternsCount);
  } else {
      fLeapMonthPatterns = NULL__null;
      fLeapMonthPatternsCount = 0;
  }
  if (other.fShortYearNames != NULL__null) {
      assignArray(fShortYearNames, fShortYearNamesCount, other.fShortYearNames, other.fShortYearNamesCount);
  } else {
      fShortYearNames = NULL__null;
      fShortYearNamesCount = 0;
  }
  if (other.fShortZodiacNames != NULL__null) {
      assignArray(fShortZodiacNames, fShortZodiacNamesCount, other.fShortZodiacNames, other.fShortZodiacNamesCount);
  } else {
      fShortZodiacNames = NULL__null;
      fShortZodiacNamesCount = 0;
  }

  if (other.fZoneStrings != NULL__null) {
      fZoneStringsColCount = other.fZoneStringsColCount;
      fZoneStringsRowCount = other.fZoneStringsRowCount;
      createZoneStrings((const UnicodeString**)other.fZoneStrings);

  } else {
      fZoneStrings = NULL__null;
      fZoneStringsColCount = 0;
      fZoneStringsRowCount = 0;
  }
  fZSFLocale = other.fZSFLocale;
  // Other zone strings data is created on demand
  fLocaleZoneStrings = NULL__null;

  // fastCopyFrom() - see assignArray comments
  fLocalPatternChars.fastCopyFrom(other.fLocalPatternChars);

  uprv_memcpy(fCapitalization, other.fCapitalization, sizeof(fCapitalization))do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(fCapitalization
, other.fCapitalization, sizeof(fCapitalization)); } while (false
);
448}

450/**
* Assignment operator.
*/
453DateFormatSymbols& DateFormatSymbols::operator=(const DateFormatSymbols& other)
454{
  if (this == &other) { return *this; }  // self-assignment: no-op
  dispose();
  copyData(other);

  return *this;
460}

462DateFormatSymbols::~DateFormatSymbols()
463{
  dispose();
465}

467void DateFormatSymbols::dispose()
468{
  delete[] fEras;
  delete[] fEraNames;
  delete[] fNarrowEras;
  delete[] fMonths;
  delete[] fShortMonths;
  delete[] fNarrowMonths;
  delete[] fStandaloneMonths;
  delete[] fStandaloneShortMonths;
  delete[] fStandaloneNarrowMonths;
  delete[] fWeekdays;
  delete[] fShortWeekdays;
  delete[] fShorterWeekdays;
  delete[] fNarrowWeekdays;
  delete[] fStandaloneWeekdays;
  delete[] fStandaloneShortWeekdays;
  delete[] fStandaloneShorterWeekdays;
  delete[] fStandaloneNarrowWeekdays;
  delete[] fAmPms;
  delete[] fNarrowAmPms;
  delete[] fQuarters;
  delete[] fShortQuarters;
  delete[] fNarrowQuarters;
  delete[] fStandaloneQuarters;
  delete[] fStandaloneShortQuarters;
  delete[] fStandaloneNarrowQuarters;
  delete[] fLeapMonthPatterns;
  delete[] fShortYearNames;
  delete[] fShortZodiacNames;
  delete[] fAbbreviatedDayPeriods;
  delete[] fWideDayPeriods;
  delete[] fNarrowDayPeriods;
  delete[] fStandaloneAbbreviatedDayPeriods;
  delete[] fStandaloneWideDayPeriods;
  delete[] fStandaloneNarrowDayPeriods;

  disposeZoneStrings();
505}

507void DateFormatSymbols::disposeZoneStrings()
508{
  if (fZoneStrings) {
      for (int32_t row = 0; row < fZoneStringsRowCount; ++row) {
          delete[] fZoneStrings[row];
      }
      uprv_freeuprv_free_71(fZoneStrings);
  }
  if (fLocaleZoneStrings) {
      for (int32_t row = 0; row < fZoneStringsRowCount; ++row) {
          delete[] fLocaleZoneStrings[row];
      }
      uprv_freeuprv_free_71(fLocaleZoneStrings);
  }

  fZoneStrings = NULL__null;
  fLocaleZoneStrings = NULL__null;
  fZoneStringsRowCount = 0;
  fZoneStringsColCount = 0;
526}

528UBool
529DateFormatSymbols::arrayCompare(const UnicodeString* array1,
                              const UnicodeString* array2,
                              int32_t count)
532{
  if (array1 == array2) return TRUE1;
  while (count>0)
  {
      --count;
      if (array1[count] != array2[count]) return FALSE0;
  }
  return TRUE1;
540}

542bool
543DateFormatSymbols::operator==(const DateFormatSymbols& other) const
544{
  // First do cheap comparisons
  if (this == &other) {
      return true;
  }
  if (fErasCount == other.fErasCount &&
      fEraNamesCount == other.fEraNamesCount &&
      fNarrowErasCount == other.fNarrowErasCount &&
      fMonthsCount == other.fMonthsCount &&
      fShortMonthsCount == other.fShortMonthsCount &&
      fNarrowMonthsCount == other.fNarrowMonthsCount &&
      fStandaloneMonthsCount == other.fStandaloneMonthsCount &&
      fStandaloneShortMonthsCount == other.fStandaloneShortMonthsCount &&
      fStandaloneNarrowMonthsCount == other.fStandaloneNarrowMonthsCount &&
      fWeekdaysCount == other.fWeekdaysCount &&
      fShortWeekdaysCount == other.fShortWeekdaysCount &&
      fShorterWeekdaysCount == other.fShorterWeekdaysCount &&
      fNarrowWeekdaysCount == other.fNarrowWeekdaysCount &&
      fStandaloneWeekdaysCount == other.fStandaloneWeekdaysCount &&
      fStandaloneShortWeekdaysCount == other.fStandaloneShortWeekdaysCount &&
      fStandaloneShorterWeekdaysCount == other.fStandaloneShorterWeekdaysCount &&
      fStandaloneNarrowWeekdaysCount == other.fStandaloneNarrowWeekdaysCount &&
      fAmPmsCount == other.fAmPmsCount &&
      fNarrowAmPmsCount == other.fNarrowAmPmsCount &&
      fQuartersCount == other.fQuartersCount &&
      fShortQuartersCount == other.fShortQuartersCount &&
      fNarrowQuartersCount == other.fNarrowQuartersCount &&
      fStandaloneQuartersCount == other.fStandaloneQuartersCount &&
      fStandaloneShortQuartersCount == other.fStandaloneShortQuartersCount &&
      fStandaloneNarrowQuartersCount == other.fStandaloneNarrowQuartersCount &&
      fLeapMonthPatternsCount == other.fLeapMonthPatternsCount &&
      fShortYearNamesCount == other.fShortYearNamesCount &&
      fShortZodiacNamesCount == other.fShortZodiacNamesCount &&
      fAbbreviatedDayPeriodsCount == other.fAbbreviatedDayPeriodsCount &&
      fWideDayPeriodsCount == other.fWideDayPeriodsCount &&
      fNarrowDayPeriodsCount == other.fNarrowDayPeriodsCount &&
      fStandaloneAbbreviatedDayPeriodsCount == other.fStandaloneAbbreviatedDayPeriodsCount &&
      fStandaloneWideDayPeriodsCount == other.fStandaloneWideDayPeriodsCount &&
      fStandaloneNarrowDayPeriodsCount == other.fStandaloneNarrowDayPeriodsCount &&
      (uprv_memcmp(fCapitalization, other.fCapitalization, sizeof(fCapitalization)):: memcmp(fCapitalization, other.fCapitalization,sizeof(fCapitalization
))==0))
  {
      // Now compare the arrays themselves
      if (arrayCompare(fEras, other.fEras, fErasCount) &&
          arrayCompare(fEraNames, other.fEraNames, fEraNamesCount) &&
          arrayCompare(fNarrowEras, other.fNarrowEras, fNarrowErasCount) &&
          arrayCompare(fMonths, other.fMonths, fMonthsCount) &&
          arrayCompare(fShortMonths, other.fShortMonths, fShortMonthsCount) &&
          arrayCompare(fNarrowMonths, other.fNarrowMonths, fNarrowMonthsCount) &&
          arrayCompare(fStandaloneMonths, other.fStandaloneMonths, fStandaloneMonthsCount) &&
          arrayCompare(fStandaloneShortMonths, other.fStandaloneShortMonths, fStandaloneShortMonthsCount) &&
          arrayCompare(fStandaloneNarrowMonths, other.fStandaloneNarrowMonths, fStandaloneNarrowMonthsCount) &&
          arrayCompare(fWeekdays, other.fWeekdays, fWeekdaysCount) &&
          arrayCompare(fShortWeekdays, other.fShortWeekdays, fShortWeekdaysCount) &&
          arrayCompare(fShorterWeekdays, other.fShorterWeekdays, fShorterWeekdaysCount) &&
          arrayCompare(fNarrowWeekdays, other.fNarrowWeekdays, fNarrowWeekdaysCount) &&
          arrayCompare(fStandaloneWeekdays, other.fStandaloneWeekdays, fStandaloneWeekdaysCount) &&
          arrayCompare(fStandaloneShortWeekdays, other.fStandaloneShortWeekdays, fStandaloneShortWeekdaysCount) &&
          arrayCompare(fStandaloneShorterWeekdays, other.fStandaloneShorterWeekdays, fStandaloneShorterWeekdaysCount) &&
          arrayCompare(fStandaloneNarrowWeekdays, other.fStandaloneNarrowWeekdays, fStandaloneNarrowWeekdaysCount) &&
          arrayCompare(fAmPms, other.fAmPms, fAmPmsCount) &&
          arrayCompare(fNarrowAmPms, other.fNarrowAmPms, fNarrowAmPmsCount) &&
          fTimeSeparator == other.fTimeSeparator &&
          arrayCompare(fQuarters, other.fQuarters, fQuartersCount) &&
          arrayCompare(fShortQuarters, other.fShortQuarters, fShortQuartersCount) &&
          arrayCompare(fNarrowQuarters, other.fNarrowQuarters, fNarrowQuartersCount) &&
          arrayCompare(fStandaloneQuarters, other.fStandaloneQuarters, fStandaloneQuartersCount) &&
          arrayCompare(fStandaloneShortQuarters, other.fStandaloneShortQuarters, fStandaloneShortQuartersCount) &&
          arrayCompare(fStandaloneNarrowQuarters, other.fStandaloneNarrowQuarters, fStandaloneNarrowQuartersCount) &&
          arrayCompare(fLeapMonthPatterns, other.fLeapMonthPatterns, fLeapMonthPatternsCount) &&
          arrayCompare(fShortYearNames, other.fShortYearNames, fShortYearNamesCount) &&
          arrayCompare(fShortZodiacNames, other.fShortZodiacNames, fShortZodiacNamesCount) &&
          arrayCompare(fAbbreviatedDayPeriods, other.fAbbreviatedDayPeriods, fAbbreviatedDayPeriodsCount) &&
          arrayCompare(fWideDayPeriods, other.fWideDayPeriods, fWideDayPeriodsCount) &&
          arrayCompare(fNarrowDayPeriods, other.fNarrowDayPeriods, fNarrowDayPeriodsCount) &&
          arrayCompare(fStandaloneAbbreviatedDayPeriods, other.fStandaloneAbbreviatedDayPeriods,
                       fStandaloneAbbreviatedDayPeriodsCount) &&
          arrayCompare(fStandaloneWideDayPeriods, other.fStandaloneWideDayPeriods,
                       fStandaloneWideDayPeriodsCount) &&
          arrayCompare(fStandaloneNarrowDayPeriods, other.fStandaloneNarrowDayPeriods,
                       fStandaloneWideDayPeriodsCount))
      {
          // Compare the contents of fZoneStrings
          if (fZoneStrings == NULL__null && other.fZoneStrings == NULL__null) {
              if (fZSFLocale == other.fZSFLocale) {
                  return true;
              }
          } else if (fZoneStrings != NULL__null && other.fZoneStrings != NULL__null) {
              if (fZoneStringsRowCount == other.fZoneStringsRowCount
                  && fZoneStringsColCount == other.fZoneStringsColCount) {
                  bool cmpres = true;
                  for (int32_t i = 0; (i < fZoneStringsRowCount) && cmpres; i++) {
                      cmpres = arrayCompare(fZoneStrings[i], other.fZoneStrings[i], fZoneStringsColCount);
                  }
                  return cmpres;
              }
          }
          return false;
      }
  }
  return false;
644}

646//------------------------------------------------------

648const UnicodeString*
649DateFormatSymbols::getEras(int32_t &count) const
650{
  count = fErasCount;
  return fEras;
653}

655const UnicodeString*
656DateFormatSymbols::getEraNames(int32_t &count) const
657{
  count = fEraNamesCount;
  return fEraNames;
660}

662const UnicodeString*
663DateFormatSymbols::getNarrowEras(int32_t &count) const
664{
  count = fNarrowErasCount;
  return fNarrowEras;
667}

669const UnicodeString*
670DateFormatSymbols::getMonths(int32_t &count) const
671{
  count = fMonthsCount;
  return fMonths;
674}

676const UnicodeString*
677DateFormatSymbols::getShortMonths(int32_t &count) const
678{
  count = fShortMonthsCount;
  return fShortMonths;
681}

683const UnicodeString*
684DateFormatSymbols::getMonths(int32_t &count, DtContextType context, DtWidthType width ) const
685{
  UnicodeString *returnValue = NULL__null;

  switch (context) {
  case FORMAT :
      switch(width) {
      case WIDE :
          count = fMonthsCount;
          returnValue = fMonths;
          break;
      case ABBREVIATED :
      case SHORT : // no month data for this, defaults to ABBREVIATED
          count = fShortMonthsCount;
          returnValue = fShortMonths;
          break;
      case NARROW :
          count = fNarrowMonthsCount;
          returnValue = fNarrowMonths;
          break;
      case DT_WIDTH_COUNT :
          break;
      }
      break;
  case STANDALONE :
      switch(width) {
      case WIDE :
          count = fStandaloneMonthsCount;
          returnValue = fStandaloneMonths;
          break;
      case ABBREVIATED :
      case SHORT : // no month data for this, defaults to ABBREVIATED
          count = fStandaloneShortMonthsCount;
          returnValue = fStandaloneShortMonths;
          break;
      case NARROW :
          count = fStandaloneNarrowMonthsCount;
          returnValue = fStandaloneNarrowMonths;
          break;
      case DT_WIDTH_COUNT :
          break;
      }
      break;
  case DT_CONTEXT_COUNT :
      break;
  }
  return returnValue;
731}

733const UnicodeString*
734DateFormatSymbols::getWeekdays(int32_t &count) const
735{
  count = fWeekdaysCount;
  return fWeekdays;
738}

740const UnicodeString*
741DateFormatSymbols::getShortWeekdays(int32_t &count) const
742{
  count = fShortWeekdaysCount;
  return fShortWeekdays;
745}

747const UnicodeString*
748DateFormatSymbols::getWeekdays(int32_t &count, DtContextType context, DtWidthType width) const
749{
  UnicodeString *returnValue = NULL__null;
  switch (context) {
  case FORMAT :
      switch(width) {
          case WIDE :
              count = fWeekdaysCount;
              returnValue = fWeekdays;
              break;
          case ABBREVIATED :
              count = fShortWeekdaysCount;
              returnValue = fShortWeekdays;
              break;
          case SHORT :
              count = fShorterWeekdaysCount;
              returnValue = fShorterWeekdays;
              break;
          case NARROW :
              count = fNarrowWeekdaysCount;
              returnValue = fNarrowWeekdays;
              break;
          case DT_WIDTH_COUNT :
              break;
      }
      break;
  case STANDALONE :
      switch(width) {
          case WIDE :
              count = fStandaloneWeekdaysCount;
              returnValue = fStandaloneWeekdays;
              break;
          case ABBREVIATED :
              count = fStandaloneShortWeekdaysCount;
              returnValue = fStandaloneShortWeekdays;
              break;
          case SHORT :
              count = fStandaloneShorterWeekdaysCount;
              returnValue = fStandaloneShorterWeekdays;
              break;
          case NARROW :
              count = fStandaloneNarrowWeekdaysCount;
              returnValue = fStandaloneNarrowWeekdays;
              break;
          case DT_WIDTH_COUNT :
              break;
      }
      break;
  case DT_CONTEXT_COUNT :
      break;
  }
  return returnValue;
800}

802const UnicodeString*
803DateFormatSymbols::getQuarters(int32_t &count, DtContextType context, DtWidthType width ) const
804{
  UnicodeString *returnValue = NULL__null;

  switch (context) {
  case FORMAT :
      switch(width) {
      case WIDE :
          count = fQuartersCount;
          returnValue = fQuarters;
          break;
      case ABBREVIATED :
      case SHORT : // no quarter data for this, defaults to ABBREVIATED
          count = fShortQuartersCount;
          returnValue = fShortQuarters;
          break;
      case NARROW :
          count = fNarrowQuartersCount;
          returnValue = fNarrowQuarters;
          break;
      case DT_WIDTH_COUNT :
          break;
      }
      break;
  case STANDALONE :
      switch(width) {
      case WIDE :
          count = fStandaloneQuartersCount;
          returnValue = fStandaloneQuarters;
          break;
      case ABBREVIATED :
      case SHORT : // no quarter data for this, defaults to ABBREVIATED
          count = fStandaloneShortQuartersCount;
          returnValue = fStandaloneShortQuarters;
          break;
      case NARROW :
          count = fStandaloneNarrowQuartersCount;
          returnValue = fStandaloneNarrowQuarters;
          break;
      case DT_WIDTH_COUNT :
          break;
      }
      break;
  case DT_CONTEXT_COUNT :
      break;
  }
  return returnValue;
850}

852UnicodeString&
853DateFormatSymbols::getTimeSeparatorString(UnicodeString& result) const
854{
  // fastCopyFrom() - see assignArray comments
  return result.fastCopyFrom(fTimeSeparator);
857}

859const UnicodeString*
860DateFormatSymbols::getAmPmStrings(int32_t &count) const
861{
  count = fAmPmsCount;
  return fAmPms;
864}

866const UnicodeString*
867DateFormatSymbols::getLeapMonthPatterns(int32_t &count) const
868{
  count = fLeapMonthPatternsCount;
  return fLeapMonthPatterns;
871}

873const UnicodeString*
874DateFormatSymbols::getYearNames(int32_t& count,
                              DtContextType /*ignored*/, DtWidthType /*ignored*/) const
876{
  count = fShortYearNamesCount;
  return fShortYearNames;
879}

881void
882DateFormatSymbols::setYearNames(const UnicodeString* yearNames, int32_t count,
                              DtContextType context, DtWidthType width)
884{
  if (context == FORMAT && width == ABBREVIATED) {
      if (fShortYearNames) {
          delete[] fShortYearNames;
      }
      fShortYearNames = newUnicodeStringArray(count);
      uprv_arrayCopy(yearNames, fShortYearNames, count);
      fShortYearNamesCount = count;
  }
893}

895const UnicodeString*
896DateFormatSymbols::getZodiacNames(int32_t& count,
                              DtContextType /*ignored*/, DtWidthType /*ignored*/) const
898{
  count = fShortZodiacNamesCount;
  return fShortZodiacNames;
901}

903void
904DateFormatSymbols::setZodiacNames(const UnicodeString* zodiacNames, int32_t count,
                              DtContextType context, DtWidthType width)
906{
  if (context == FORMAT && width == ABBREVIATED) {
      if (fShortZodiacNames) {
          delete[] fShortZodiacNames;
      }
      fShortZodiacNames = newUnicodeStringArray(count);
      uprv_arrayCopy(zodiacNames, fShortZodiacNames, count);
      fShortZodiacNamesCount = count;
  }
915}

917//------------------------------------------------------

919void
920DateFormatSymbols::setEras(const UnicodeString* erasArray, int32_t count)
921{
  // delete the old list if we own it
  if (fEras)
      delete[] fEras;

  // we always own the new list, which we create here (we duplicate rather
  // than adopting the list passed in)
  fEras = newUnicodeStringArray(count);
  uprv_arrayCopy(erasArray,fEras,  count);
  fErasCount = count;
931}

933void
934DateFormatSymbols::setEraNames(const UnicodeString* eraNamesArray, int32_t count)
935{
  // delete the old list if we own it
  if (fEraNames)
      delete[] fEraNames;

  // we always own the new list, which we create here (we duplicate rather
  // than adopting the list passed in)
  fEraNames = newUnicodeStringArray(count);
  uprv_arrayCopy(eraNamesArray,fEraNames,  count);
  fEraNamesCount = count;
945}

947void
948DateFormatSymbols::setNarrowEras(const UnicodeString* narrowErasArray, int32_t count)
949{
  // delete the old list if we own it
  if (fNarrowEras)
      delete[] fNarrowEras;

  // we always own the new list, which we create here (we duplicate rather
  // than adopting the list passed in)
  fNarrowEras = newUnicodeStringArray(count);
  uprv_arrayCopy(narrowErasArray,fNarrowEras,  count);
  fNarrowErasCount = count;
959}

961void
962DateFormatSymbols::setMonths(const UnicodeString* monthsArray, int32_t count)
963{
  // delete the old list if we own it
  if (fMonths)
      delete[] fMonths;

  // we always own the new list, which we create here (we duplicate rather
  // than adopting the list passed in)
  fMonths = newUnicodeStringArray(count);
  uprv_arrayCopy( monthsArray,fMonths,count);
  fMonthsCount = count;
973}

975void
976DateFormatSymbols::setShortMonths(const UnicodeString* shortMonthsArray, int32_t count)
977{
  // delete the old list if we own it
  if (fShortMonths)
      delete[] fShortMonths;

  // we always own the new list, which we create here (we duplicate rather
  // than adopting the list passed in)
  fShortMonths = newUnicodeStringArray(count);
  uprv_arrayCopy(shortMonthsArray,fShortMonths,  count);
  fShortMonthsCount = count;
987}

989void
990DateFormatSymbols::setMonths(const UnicodeString* monthsArray, int32_t count, DtContextType context, DtWidthType width)
991{
  // delete the old list if we own it
  // we always own the new list, which we create here (we duplicate rather
  // than adopting the list passed in)

  switch (context) {
  case FORMAT :
      switch (width) {
      case WIDE :
          if (fMonths)
              delete[] fMonths;
          fMonths = newUnicodeStringArray(count);
          uprv_arrayCopy( monthsArray,fMonths,count);
          fMonthsCount = count;
          break;
      case ABBREVIATED :
          if (fShortMonths)
              delete[] fShortMonths;
          fShortMonths = newUnicodeStringArray(count);
          uprv_arrayCopy( monthsArray,fShortMonths,count);
          fShortMonthsCount = count;
          break;
      case NARROW :
          if (fNarrowMonths)
              delete[] fNarrowMonths;
          fNarrowMonths = newUnicodeStringArray(count);
          uprv_arrayCopy( monthsArray,fNarrowMonths,count);
          fNarrowMonthsCount = count;
          break;
      default :
          break;
      }
      break;
  case STANDALONE :
      switch (width) {
      case WIDE :
          if (fStandaloneMonths)
              delete[] fStandaloneMonths;
          fStandaloneMonths = newUnicodeStringArray(count);
          uprv_arrayCopy( monthsArray,fStandaloneMonths,count);
          fStandaloneMonthsCount = count;
          break;
      case ABBREVIATED :
          if (fStandaloneShortMonths)
              delete[] fStandaloneShortMonths;
          fStandaloneShortMonths = newUnicodeStringArray(count);
          uprv_arrayCopy( monthsArray,fStandaloneShortMonths,count);
          fStandaloneShortMonthsCount = count;
          break;
      case NARROW :
         if (fStandaloneNarrowMonths)
              delete[] fStandaloneNarrowMonths;
          fStandaloneNarrowMonths = newUnicodeStringArray(count);
          uprv_arrayCopy( monthsArray,fStandaloneNarrowMonths,count);
          fStandaloneNarrowMonthsCount = count;
          break;
      default :
          break;
      }
      break;
  case DT_CONTEXT_COUNT :
      break;
  }
1054}

1056void DateFormatSymbols::setWeekdays(const UnicodeString* weekdaysArray, int32_t count)
1057{
  // delete the old list if we own it
  if (fWeekdays)
      delete[] fWeekdays;

  // we always own the new list, which we create here (we duplicate rather
  // than adopting the list passed in)
  fWeekdays = newUnicodeStringArray(count);
  uprv_arrayCopy(weekdaysArray,fWeekdays,count);
  fWeekdaysCount = count;
1067}

1069void
1070DateFormatSymbols::setShortWeekdays(const UnicodeString* shortWeekdaysArray, int32_t count)
1071{
  // delete the old list if we own it
  if (fShortWeekdays)
      delete[] fShortWeekdays;

  // we always own the new list, which we create here (we duplicate rather
  // than adopting the list passed in)
  fShortWeekdays = newUnicodeStringArray(count);
  uprv_arrayCopy(shortWeekdaysArray, fShortWeekdays, count);
  fShortWeekdaysCount = count;
1081}

1083void
1084DateFormatSymbols::setWeekdays(const UnicodeString* weekdaysArray, int32_t count, DtContextType context, DtWidthType width)
1085{
  // delete the old list if we own it
  // we always own the new list, which we create here (we duplicate rather
  // than adopting the list passed in)

  switch (context) {
  case FORMAT :
      switch (width) {
      case WIDE :
          if (fWeekdays)
              delete[] fWeekdays;
          fWeekdays = newUnicodeStringArray(count);
          uprv_arrayCopy(weekdaysArray, fWeekdays, count);
          fWeekdaysCount = count;
          break;
      case ABBREVIATED :
          if (fShortWeekdays)
              delete[] fShortWeekdays;
          fShortWeekdays = newUnicodeStringArray(count);
          uprv_arrayCopy(weekdaysArray, fShortWeekdays, count);
          fShortWeekdaysCount = count;
          break;
      case SHORT :
          if (fShorterWeekdays)
              delete[] fShorterWeekdays;
          fShorterWeekdays = newUnicodeStringArray(count);
          uprv_arrayCopy(weekdaysArray, fShorterWeekdays, count);
          fShorterWeekdaysCount = count;
          break;
      case NARROW :
          if (fNarrowWeekdays)
              delete[] fNarrowWeekdays;
          fNarrowWeekdays = newUnicodeStringArray(count);
          uprv_arrayCopy(weekdaysArray, fNarrowWeekdays, count);
          fNarrowWeekdaysCount = count;
          break;
      case DT_WIDTH_COUNT :
          break;
      }
      break;
  case STANDALONE :
      switch (width) {
      case WIDE :
          if (fStandaloneWeekdays)
              delete[] fStandaloneWeekdays;
          fStandaloneWeekdays = newUnicodeStringArray(count);
          uprv_arrayCopy(weekdaysArray, fStandaloneWeekdays, count);
          fStandaloneWeekdaysCount = count;
          break;
      case ABBREVIATED :
          if (fStandaloneShortWeekdays)
              delete[] fStandaloneShortWeekdays;
          fStandaloneShortWeekdays = newUnicodeStringArray(count);
          uprv_arrayCopy(weekdaysArray, fStandaloneShortWeekdays, count);
          fStandaloneShortWeekdaysCount = count;
          break;
      case SHORT :
          if (fStandaloneShorterWeekdays)
              delete[] fStandaloneShorterWeekdays;
          fStandaloneShorterWeekdays = newUnicodeStringArray(count);
          uprv_arrayCopy(weekdaysArray, fStandaloneShorterWeekdays, count);
          fStandaloneShorterWeekdaysCount = count;
          break;
      case NARROW :
          if (fStandaloneNarrowWeekdays)
              delete[] fStandaloneNarrowWeekdays;
          fStandaloneNarrowWeekdays = newUnicodeStringArray(count);
          uprv_arrayCopy(weekdaysArray, fStandaloneNarrowWeekdays, count);
          fStandaloneNarrowWeekdaysCount = count;
          break;
      case DT_WIDTH_COUNT :
          break;
      }
      break;
  case DT_CONTEXT_COUNT :
      break;
  }
1162}

1164void
1165DateFormatSymbols::setQuarters(const UnicodeString* quartersArray, int32_t count, DtContextType context, DtWidthType width)
1166{
  // delete the old list if we own it
  // we always own the new list, which we create here (we duplicate rather
  // than adopting the list passed in)

  switch (context) {
  case FORMAT :
      switch (width) {
      case WIDE :
          if (fQuarters)
              delete[] fQuarters;
          fQuarters = newUnicodeStringArray(count);
          uprv_arrayCopy( quartersArray,fQuarters,count);
          fQuartersCount = count;
          break;
      case ABBREVIATED :
          if (fShortQuarters)
              delete[] fShortQuarters;
          fShortQuarters = newUnicodeStringArray(count);
          uprv_arrayCopy( quartersArray,fShortQuarters,count);
          fShortQuartersCount = count;
          break;
      case NARROW :
          if (fNarrowQuarters)
              delete[] fNarrowQuarters;
          fNarrowQuarters = newUnicodeStringArray(count);
          uprv_arrayCopy( quartersArray,fNarrowQuarters,count);
          fNarrowQuartersCount = count;
          break;
      default :
          break;
      }
      break;
  case STANDALONE :
      switch (width) {
      case WIDE :
          if (fStandaloneQuarters)
              delete[] fStandaloneQuarters;
          fStandaloneQuarters = newUnicodeStringArray(count);
          uprv_arrayCopy( quartersArray,fStandaloneQuarters,count);
          fStandaloneQuartersCount = count;
          break;
      case ABBREVIATED :
          if (fStandaloneShortQuarters)
              delete[] fStandaloneShortQuarters;
          fStandaloneShortQuarters = newUnicodeStringArray(count);
          uprv_arrayCopy( quartersArray,fStandaloneShortQuarters,count);
          fStandaloneShortQuartersCount = count;
          break;
      case NARROW :
         if (fStandaloneNarrowQuarters)
              delete[] fStandaloneNarrowQuarters;
          fStandaloneNarrowQuarters = newUnicodeStringArray(count);
          uprv_arrayCopy( quartersArray,fStandaloneNarrowQuarters,count);
          fStandaloneNarrowQuartersCount = count;
          break;
      default :
          break;
      }
      break;
  case DT_CONTEXT_COUNT :
      break;
  }
1229}

1231void
1232DateFormatSymbols::setAmPmStrings(const UnicodeString* amPmsArray, int32_t count)
1233{
  // delete the old list if we own it
  if (fAmPms) delete[] fAmPms;

  // we always own the new list, which we create here (we duplicate rather
  // than adopting the list passed in)
  fAmPms = newUnicodeStringArray(count);
  uprv_arrayCopy(amPmsArray,fAmPms,count);
  fAmPmsCount = count;
1242}

1244void
1245DateFormatSymbols::setTimeSeparatorString(const UnicodeString& newTimeSeparator)
1246{
  fTimeSeparator = newTimeSeparator;
1248}

1250const UnicodeString**
1251DateFormatSymbols::getZoneStrings(int32_t& rowCount, int32_t& columnCount) const
1252{
  const UnicodeString **result = NULL__null;
  static UMutex LOCK;

  umtx_lockumtx_lock_71(&LOCK);
  if (fZoneStrings == NULL__null) {
      if (fLocaleZoneStrings == NULL__null) {
          ((DateFormatSymbols*)this)->initZoneStringsArray();
      }
      result = (const UnicodeString**)fLocaleZoneStrings;
  } else {
      result = (const UnicodeString**)fZoneStrings;
  }
  rowCount = fZoneStringsRowCount;
  columnCount = fZoneStringsColCount;
  umtx_unlockumtx_unlock_71(&LOCK);

  return result;
1270}

1272// For now, we include all zones
1273#define ZONE_SETUCAL_ZONE_TYPE_ANY UCAL_ZONE_TYPE_ANY

1275// This code must be called within a synchronized block
1276void
1277DateFormatSymbols::initZoneStringsArray(void) {
  if (fZoneStrings != NULL__null || fLocaleZoneStrings != NULL__null) {
      return;
  }

  UErrorCode status = U_ZERO_ERROR;

  StringEnumeration *tzids = NULL__null;
  UnicodeString ** zarray = NULL__null;
  TimeZoneNames *tzNames = NULL__null;
  int32_t rows = 0;

  static const UTimeZoneNameType TYPES[] = {
      UTZNM_LONG_STANDARD, UTZNM_SHORT_STANDARD,
      UTZNM_LONG_DAYLIGHT, UTZNM_SHORT_DAYLIGHT
  };
  static const int32_t NUM_TYPES = 4;

  do { // dummy do-while

      tzids = TimeZone::createTimeZoneIDEnumeration(ZONE_SETUCAL_ZONE_TYPE_ANY, NULL__null, NULL__null, status);
      rows = tzids->count(status);
      if (U_FAILURE(status)) {
          break;
      }

      // Allocate array
      int32_t size = rows * sizeof(UnicodeString*);
      zarray = (UnicodeString**)uprv_mallocuprv_malloc_71(size);
      if (zarray == NULL__null) {
          status = U_MEMORY_ALLOCATION_ERROR;
          break;
      }
      uprv_memset(zarray, 0, size):: memset(zarray, 0, size);

      tzNames = TimeZoneNames::createInstance(fZSFLocale, status);
      tzNames->loadAllDisplayNames(status);
      if (U_FAILURE(status)) { break; }

      const UnicodeString *tzid;
      int32_t i = 0;
      UDate now = Calendar::getNow();
      UnicodeString tzDispName;

      while ((tzid = tzids->snext(status)) != 0) {
          if (U_FAILURE(status)) {
              break;
          }

          zarray[i] = new UnicodeString[5];
          if (zarray[i] == NULL__null) {
              status = U_MEMORY_ALLOCATION_ERROR;
              break;
          }

          zarray[i][0].setTo(*tzid);
          tzNames->getDisplayNames(*tzid, TYPES, NUM_TYPES, now, zarray[i]+1, status);
          i++;
      }

  } while (FALSE0);

  if (U_FAILURE(status)) {
      if (zarray) {
          for (int32_t i = 0; i < rows; i++) {
              if (zarray[i]) {
                  delete[] zarray[i];
              }
          }
          uprv_freeuprv_free_71(zarray);
          zarray = NULL__null;
      }
  }

  if (tzNames) {
      delete tzNames;
  }
  if (tzids) {
      delete tzids;
  }

  fLocaleZoneStrings = zarray;
  fZoneStringsRowCount = rows;
  fZoneStringsColCount = 1 + NUM_TYPES;
1361}

1363void
1364DateFormatSymbols::setZoneStrings(const UnicodeString* const *strings, int32_t rowCount, int32_t columnCount)
1365{
  // since deleting a 2-d array is a pain in the butt, we offload that task to
  // a separate function
  disposeZoneStrings();
  // we always own the new list, which we create here (we duplicate rather
  // than adopting the list passed in)
  fZoneStringsRowCount = rowCount;
  fZoneStringsColCount = columnCount;
  createZoneStrings((const UnicodeString**)strings);
1374}

1376//------------------------------------------------------

1378const char16_t * U_EXPORT2
1379DateFormatSymbols::getPatternUChars(void)
1380{
  return gPatternChars;
1382}

1384UDateFormatField U_EXPORT2
1385DateFormatSymbols::getPatternCharIndex(UChar c) {
  const UChar *p = u_strchru_strchr_71(gPatternChars, c);
  if (p == NULL__null) {
      return UDAT_FIELD_COUNT;
  } else {
      return static_cast<UDateFormatField>(p - gPatternChars);
  }
1392}

1394static const uint64_t kNumericFieldsAlways =
  ((uint64_t)1 << UDAT_YEAR_FIELD) |                      // y
  ((uint64_t)1 << UDAT_DATE_FIELD) |                      // d
  ((uint64_t)1 << UDAT_HOUR_OF_DAY1_FIELD) |              // k
  ((uint64_t)1 << UDAT_HOUR_OF_DAY0_FIELD) |              // H
  ((uint64_t)1 << UDAT_MINUTE_FIELD) |                    // m
  ((uint64_t)1 << UDAT_SECOND_FIELD) |                    // s
  ((uint64_t)1 << UDAT_FRACTIONAL_SECOND_FIELD) |         // S
  ((uint64_t)1 << UDAT_DAY_OF_YEAR_FIELD) |               // D
  ((uint64_t)1 << UDAT_DAY_OF_WEEK_IN_MONTH_FIELD) |      // F
  ((uint64_t)1 << UDAT_WEEK_OF_YEAR_FIELD) |              // w
  ((uint64_t)1 << UDAT_WEEK_OF_MONTH_FIELD) |             // W
  ((uint64_t)1 << UDAT_HOUR1_FIELD) |                     // h
  ((uint64_t)1 << UDAT_HOUR0_FIELD) |                     // K
  ((uint64_t)1 << UDAT_YEAR_WOY_FIELD) |                  // Y
  ((uint64_t)1 << UDAT_EXTENDED_YEAR_FIELD) |             // u
  ((uint64_t)1 << UDAT_JULIAN_DAY_FIELD) |                // g
  ((uint64_t)1 << UDAT_MILLISECONDS_IN_DAY_FIELD) |       // A
  ((uint64_t)1 << UDAT_RELATED_YEAR_FIELD);               // r

1414static const uint64_t kNumericFieldsForCount12 =
  ((uint64_t)1 << UDAT_MONTH_FIELD) |                     // M or MM
  ((uint64_t)1 << UDAT_DOW_LOCAL_FIELD) |                 // e or ee
  ((uint64_t)1 << UDAT_STANDALONE_DAY_FIELD) |            // c or cc
  ((uint64_t)1 << UDAT_STANDALONE_MONTH_FIELD) |          // L or LL
  ((uint64_t)1 << UDAT_QUARTER_FIELD) |                   // Q or QQ
  ((uint64_t)1 << UDAT_STANDALONE_QUARTER_FIELD);         // q or qq

1422UBool U_EXPORT2
1423DateFormatSymbols::isNumericField(UDateFormatField f, int32_t count) {
  if (f == UDAT_FIELD_COUNT) {
      return FALSE0;
  }
  uint64_t flag = ((uint64_t)1 << f);
  return ((kNumericFieldsAlways & flag) != 0 || ((kNumericFieldsForCount12 & flag) != 0 && count < 3));
1429}

1431UBool U_EXPORT2
1432DateFormatSymbols::isNumericPatternChar(UChar c, int32_t count) {
  return isNumericField(getPatternCharIndex(c), count);
1434}

1436//------------------------------------------------------

1438UnicodeString&
1439DateFormatSymbols::getLocalPatternChars(UnicodeString& result) const
1440{
  // fastCopyFrom() - see assignArray comments
  return result.fastCopyFrom(fLocalPatternChars);
1443}

1445//------------------------------------------------------

1447void
1448DateFormatSymbols::setLocalPatternChars(const UnicodeString& newLocalPatternChars)
1449{
  fLocalPatternChars = newLocalPatternChars;
1451}

1453//------------------------------------------------------

1455namespace {

1457// Constants declarations
1458static const UChar kCalendarAliasPrefixUChar[] = {
  SOLIDUS((UChar)0x002F), CAP_L((UChar)0x004C), CAP_O((UChar)0x004F), CAP_C((UChar)0x0043), CAP_A((UChar)0x0041), CAP_L((UChar)0x004C), CAP_E((UChar)0x0045), SOLIDUS((UChar)0x002F),
  LOW_C((UChar)0x0063), LOW_A((UChar)0x0061), LOW_L((UChar)0x006C), LOW_E((UChar)0x0065), LOW_N((UChar)0x006E), LOW_D((UChar)0x0064), LOW_A((UChar)0x0061), LOW_R((UChar)0x0072), SOLIDUS((UChar)0x002F)
1461};
1462static const UChar kGregorianTagUChar[] = {
  LOW_G((UChar)0x0067), LOW_R((UChar)0x0072), LOW_E((UChar)0x0065), LOW_G((UChar)0x0067), LOW_O((UChar)0x006F), LOW_R((UChar)0x0072), LOW_I((UChar)0x0069), LOW_A((UChar)0x0061), LOW_N((UChar)0x006E)
1464};
1465static const UChar kVariantTagUChar[] = {
  PERCENT((UChar)0x0025), LOW_V((UChar)0x0076), LOW_A((UChar)0x0061), LOW_R((UChar)0x0072), LOW_I((UChar)0x0069), LOW_A((UChar)0x0061), LOW_N((UChar)0x006E), LOW_T((UChar)0x0074)
1467};
1468static const UChar kLeapTagUChar[] = {
  LOW_L((UChar)0x006C), LOW_E((UChar)0x0065), LOW_A((UChar)0x0061), LOW_P((UChar)0x0070)
1470};
1471static const UChar kCyclicNameSetsTagUChar[] = {
  LOW_C((UChar)0x0063), LOW_Y((UChar)0x0079), LOW_C((UChar)0x0063), LOW_L((UChar)0x006C), LOW_I((UChar)0x0069), LOW_C((UChar)0x0063), CAP_N((UChar)0x004E), LOW_A((UChar)0x0061), LOW_M((UChar)0x006D), LOW_E((UChar)0x0065), CAP_S((UChar)0x0053), LOW_E((UChar)0x0065), LOW_T((UChar)0x0074), LOW_S((UChar)0x0073)
1473};
1474static const UChar kYearsTagUChar[] = {
  SOLIDUS((UChar)0x002F), LOW_Y((UChar)0x0079), LOW_E((UChar)0x0065), LOW_A((UChar)0x0061), LOW_R((UChar)0x0072), LOW_S((UChar)0x0073)
1476};
1477static const UChar kZodiacsUChar[] = {
  SOLIDUS((UChar)0x002F), LOW_Z((UChar)0x007A), LOW_O((UChar)0x006F), LOW_D((UChar)0x0064), LOW_I((UChar)0x0069), LOW_A((UChar)0x0061), LOW_C((UChar)0x0063), LOW_S((UChar)0x0073)
1479};
1480static const UChar kDayPartsTagUChar[] = {
  SOLIDUS((UChar)0x002F), LOW_D((UChar)0x0064), LOW_A((UChar)0x0061), LOW_Y((UChar)0x0079), CAP_P((UChar)0x0050), LOW_A((UChar)0x0061), LOW_R((UChar)0x0072), LOW_T((UChar)0x0074), LOW_S((UChar)0x0073)
1482};
1483static const UChar kFormatTagUChar[] = {
  SOLIDUS((UChar)0x002F), LOW_F((UChar)0x0066), LOW_O((UChar)0x006F), LOW_R((UChar)0x0072), LOW_M((UChar)0x006D), LOW_A((UChar)0x0061), LOW_T((UChar)0x0074)
1485};
1486static const UChar kAbbrTagUChar[] = {
  SOLIDUS((UChar)0x002F), LOW_A((UChar)0x0061), LOW_B((UChar)0x0062), LOW_B((UChar)0x0062), LOW_R((UChar)0x0072), LOW_E((UChar)0x0065), LOW_V((UChar)0x0076), LOW_I((UChar)0x0069), LOW_A((UChar)0x0061), LOW_T((UChar)0x0074), LOW_E((UChar)0x0065), LOW_D((UChar)0x0064)
1488};

1490// ResourceSink to enumerate all calendar resources
1491struct CalendarDataSink : public ResourceSink {

  // Enum which specifies the type of alias received, or no alias
  enum AliasType {
      SAME_CALENDAR,
      DIFFERENT_CALENDAR,
      GREGORIAN,
      NONE
  };

  // Data structures to store resources from the current resource bundle
  Hashtable arrays;
  Hashtable arraySizes;
  Hashtable maps;
  /** 
   * Whenever there are aliases, the same object will be added twice to 'map'.
   * To avoid double deletion, 'maps' won't take ownership of the objects. Instead,
   * 'mapRefs' will own them and will delete them when CalendarDataSink is deleted.
   */
  MemoryPool<Hashtable> mapRefs;

  // Paths and the aliases they point to
  UVector aliasPathPairs;

  // Current and next calendar resource table which should be loaded
  UnicodeString currentCalendarType;
  UnicodeString nextCalendarType;

  // Resources to visit when enumerating fallback calendars
  LocalPointer<UVector> resourcesToVisit;

  // Alias' relative path populated whenever an alias is read
  UnicodeString aliasRelativePath;

  // Initializes CalendarDataSink with default values
  CalendarDataSink(UErrorCode& status)
  :   arrays(FALSE0, status), arraySizes(FALSE0, status), maps(FALSE0, status),
      mapRefs(),
      aliasPathPairs(uprv_deleteUObjectuprv_deleteUObject_71, uhash_compareUnicodeStringuhash_compareUnicodeString_71, status),
      currentCalendarType(), nextCalendarType(),
      resourcesToVisit(NULL__null), aliasRelativePath() {
      if (U_FAILURE(status)) { return; }
  }
  virtual ~CalendarDataSink();

  // Configure the CalendarSink to visit all the resources
  void visitAllResources() {
      resourcesToVisit.adoptInstead(NULL__null);
  }

  // Actions to be done before enumerating
  void preEnumerate(const UnicodeString &calendarType) {
      currentCalendarType = calendarType;
      nextCalendarType.setToBogus();
      aliasPathPairs.removeAllElements();
  }

  virtual void put(const char *key, ResourceValue &value, UBool, UErrorCode &errorCode) override {
      if (U_FAILURE(errorCode)) { return; }
      U_ASSERT(!currentCalendarType.isEmpty())(void)0;

      // Stores the resources to visit on the next calendar.
      LocalPointer<UVector> resourcesToVisitNext(NULL__null);
      ResourceTable calendarData = value.getTable(errorCode);
      if (U_FAILURE(errorCode)) { return; }

      // Enumerate all resources for this calendar
      for (int i = 0; calendarData.getKeyAndValue(i, key, value); i++) {
          UnicodeString keyUString(key, -1, US_INVicu::UnicodeString::kInvariant);

          // == Handle aliases ==
          AliasType aliasType = processAliasFromValue(keyUString, value, errorCode);
          if (U_FAILURE(errorCode)) { return; }
          if (aliasType == GREGORIAN) {
              // Ignore aliases to the gregorian calendar, all of its resources will be loaded anyway.
              continue;

          } else if (aliasType == DIFFERENT_CALENDAR) {
              // Whenever an alias to the next calendar (except gregorian) is encountered, register the
              // calendar type it's pointing to
              if (resourcesToVisitNext.isNull()) {
                  resourcesToVisitNext
                      .adoptInsteadAndCheckErrorCode(new UVector(uprv_deleteUObjectuprv_deleteUObject_71, uhash_compareUnicodeStringuhash_compareUnicodeString_71, errorCode),
                                                     errorCode);
                  if (U_FAILURE(errorCode)) { return; }
              }
              LocalPointer<UnicodeString> aliasRelativePathCopy(aliasRelativePath.clone(), errorCode);
              resourcesToVisitNext->adoptElement(aliasRelativePathCopy.orphan(), errorCode);
              if (U_FAILURE(errorCode)) { return; }
              continue;

          } else if (aliasType == SAME_CALENDAR) {
              // Register same-calendar alias
              if (arrays.get(aliasRelativePath) == NULL__null && maps.get(aliasRelativePath) == NULL__null) {
                  LocalPointer<UnicodeString> aliasRelativePathCopy(aliasRelativePath.clone(), errorCode);
                  aliasPathPairs.adoptElement(aliasRelativePathCopy.orphan(), errorCode);
                  if (U_FAILURE(errorCode)) { return; }
                  LocalPointer<UnicodeString> keyUStringCopy(keyUString.clone(), errorCode);
                  aliasPathPairs.adoptElement(keyUStringCopy.orphan(), errorCode);
                  if (U_FAILURE(errorCode)) { return; }
              }
              continue;
          }

          // Only visit the resources that were referenced by an alias on the previous calendar
          // (AmPmMarkersAbbr is an exception).
          if (!resourcesToVisit.isNull() && !resourcesToVisit->isEmpty() && !resourcesToVisit->contains(&keyUString)
              && uprv_strcmp(key, gAmPmMarkersAbbrTag):: strcmp(key, gAmPmMarkersAbbrTag) != 0) { continue; }

          // == Handle data ==
          if (uprv_strcmp(key, gAmPmMarkersTag):: strcmp(key, gAmPmMarkersTag) == 0
              || uprv_strcmp(key, gAmPmMarkersAbbrTag):: strcmp(key, gAmPmMarkersAbbrTag) == 0
              || uprv_strcmp(key, gAmPmMarkersNarrowTag):: strcmp(key, gAmPmMarkersNarrowTag) == 0) {
              if (arrays.get(keyUString) == NULL__null) {
                  ResourceArray resourceArray = value.getArray(errorCode);
                  int32_t arraySize = resourceArray.getSize();
                  LocalArray<UnicodeString> stringArray(new UnicodeString[arraySize], errorCode);
                  value.getStringArray(stringArray.getAlias(), arraySize, errorCode);
                  arrays.put(keyUString, stringArray.orphan(), errorCode);
                  arraySizes.puti(keyUString, arraySize, errorCode);
                  if (U_FAILURE(errorCode)) { return; }
              }
          } else if (uprv_strcmp(key, gErasTag):: strcmp(key, gErasTag) == 0
                     || uprv_strcmp(key, gDayNamesTag):: strcmp(key, gDayNamesTag) == 0
                     || uprv_strcmp(key, gMonthNamesTag):: strcmp(key, gMonthNamesTag) == 0
                     || uprv_strcmp(key, gQuartersTag):: strcmp(key, gQuartersTag) == 0
                     || uprv_strcmp(key, gDayPeriodTag):: strcmp(key, gDayPeriodTag) == 0
                     || uprv_strcmp(key, gMonthPatternsTag):: strcmp(key, gMonthPatternsTag) == 0
                     || uprv_strcmp(key, gCyclicNameSetsTag):: strcmp(key, gCyclicNameSetsTag) == 0) {
              processResource(keyUString, key, value, errorCode);
          }
      }

      // Apply same-calendar aliases
      UBool modified;
      do {
          modified = false;
          for (int32_t i = 0; i < aliasPathPairs.size();) {
              UBool mod = false;
              UnicodeString *alias = (UnicodeString*)aliasPathPairs[i];
              UnicodeString *aliasArray;
              Hashtable *aliasMap;
              if ((aliasArray = (UnicodeString*)arrays.get(*alias)) != NULL__null) {
                  UnicodeString *path = (UnicodeString*)aliasPathPairs[i + 1];
                  if (arrays.get(*path) == NULL__null) {
                      // Clone the array
                      int32_t aliasArraySize = arraySizes.geti(*alias);
                      LocalArray<UnicodeString> aliasArrayCopy(new UnicodeString[aliasArraySize], errorCode);
                      if (U_FAILURE(errorCode)) { return; }
                      uprv_arrayCopy(aliasArray, aliasArrayCopy.getAlias(), aliasArraySize);
                      // Put the array on the 'arrays' map
                      arrays.put(*path, aliasArrayCopy.orphan(), errorCode);
                      arraySizes.puti(*path, aliasArraySize, errorCode);
                  }
                  if (U_FAILURE(errorCode)) { return; }
                  mod = true;
              } else if ((aliasMap = (Hashtable*)maps.get(*alias)) != NULL__null) {
                  UnicodeString *path = (UnicodeString*)aliasPathPairs[i + 1];
                  if (maps.get(*path) == NULL__null) {
                      maps.put(*path, aliasMap, errorCode);
                  }
                  if (U_FAILURE(errorCode)) { return; }
                  mod = true;
              }
              if (mod) {
                  aliasPathPairs.removeElementAt(i + 1);
                  aliasPathPairs.removeElementAt(i);
                  modified = true;
              } else {
                  i += 2;
              }
          }
      } while (modified && !aliasPathPairs.isEmpty());

      // Set the resources to visit on the next calendar
      if (!resourcesToVisitNext.isNull()) {
          resourcesToVisit = std::move(resourcesToVisitNext);
      }
  }

  // Process the nested resource bundle tables
  void processResource(UnicodeString &path, const char *key, ResourceValue &value, UErrorCode &errorCode) {
      if (U_FAILURE(errorCode)) return;

      ResourceTable table = value.getTable(errorCode);
      if (U_FAILURE(errorCode)) return;
      Hashtable* stringMap = NULL__null;

      // Iterate over all the elements of the table and add them to the map
      for (int i = 0; table.getKeyAndValue(i, key, value); i++) {
          UnicodeString keyUString(key, -1, US_INVicu::UnicodeString::kInvariant);

          // Ignore '%variant' keys
          if (keyUString.endsWith(kVariantTagUChar, UPRV_LENGTHOF(kVariantTagUChar)(int32_t)(sizeof(kVariantTagUChar)/sizeof((kVariantTagUChar)[
0])))) {
              continue;
          }

          // == Handle String elements ==
          if (value.getType() == URES_STRING) {
              // We are on a leaf, store the map elements into the stringMap
              if (i == 0) {
                  // mapRefs will keep ownership of 'stringMap':
                  stringMap = mapRefs.create(FALSE0, errorCode);
                  if (stringMap == NULL__null) {
                      errorCode = U_MEMORY_ALLOCATION_ERROR;
                      return;
                  }
                  maps.put(path, stringMap, errorCode);
                  if (U_FAILURE(errorCode)) { return; }
                  stringMap->setValueDeleter(uprv_deleteUObjectuprv_deleteUObject_71);
              }
              U_ASSERT(stringMap != NULL)(void)0;
              int32_t valueStringSize;
              const UChar *valueString = value.getString(valueStringSize, errorCode);
              if (U_FAILURE(errorCode)) { return; }
              LocalPointer<UnicodeString> valueUString(new UnicodeString(TRUE1, valueString, valueStringSize), errorCode);
              stringMap->put(keyUString, valueUString.orphan(), errorCode);
              if (U_FAILURE(errorCode)) { return; }
              continue;
          }
          U_ASSERT(stringMap == NULL)(void)0;

          // Store the current path's length and append the current key to the path.
          int32_t pathLength = path.length();
          path.append(SOLIDUS((UChar)0x002F)).append(keyUString);

          // In cyclicNameSets ignore everything but years/format/abbreviated
          // and zodiacs/format/abbreviated
          if (path.startsWith(kCyclicNameSetsTagUChar, UPRV_LENGTHOF(kCyclicNameSetsTagUChar)(int32_t)(sizeof(kCyclicNameSetsTagUChar)/sizeof((kCyclicNameSetsTagUChar
)[0])))) {
              UBool skip = TRUE1;
              int32_t startIndex = UPRV_LENGTHOF(kCyclicNameSetsTagUChar)(int32_t)(sizeof(kCyclicNameSetsTagUChar)/sizeof((kCyclicNameSetsTagUChar
)[0]));
              int32_t length = 0;
              if (startIndex == path.length()
                  || path.compare(startIndex, (length = UPRV_LENGTHOF(kZodiacsUChar)(int32_t)(sizeof(kZodiacsUChar)/sizeof((kZodiacsUChar)[0]))), kZodiacsUChar, 0, UPRV_LENGTHOF(kZodiacsUChar)(int32_t)(sizeof(kZodiacsUChar)/sizeof((kZodiacsUChar)[0]))) == 0
                  || path.compare(startIndex, (length = UPRV_LENGTHOF(kYearsTagUChar)(int32_t)(sizeof(kYearsTagUChar)/sizeof((kYearsTagUChar)[0]))), kYearsTagUChar, 0, UPRV_LENGTHOF(kYearsTagUChar)(int32_t)(sizeof(kYearsTagUChar)/sizeof((kYearsTagUChar)[0]))) == 0
                  || path.compare(startIndex, (length = UPRV_LENGTHOF(kDayPartsTagUChar)(int32_t)(sizeof(kDayPartsTagUChar)/sizeof((kDayPartsTagUChar
)[0]))), kDayPartsTagUChar, 0, UPRV_LENGTHOF(kDayPartsTagUChar)(int32_t)(sizeof(kDayPartsTagUChar)/sizeof((kDayPartsTagUChar
)[0]))) == 0) {
                  startIndex += length;
                  length = 0;
                  if (startIndex == path.length()
                      || path.compare(startIndex, (length = UPRV_LENGTHOF(kFormatTagUChar)(int32_t)(sizeof(kFormatTagUChar)/sizeof((kFormatTagUChar)[0]
))), kFormatTagUChar, 0, UPRV_LENGTHOF(kFormatTagUChar)(int32_t)(sizeof(kFormatTagUChar)/sizeof((kFormatTagUChar)[0]
))) == 0) {
                      startIndex += length;
                      length = 0;
                      if (startIndex == path.length()
                          || path.compare(startIndex, (length = UPRV_LENGTHOF(kAbbrTagUChar)(int32_t)(sizeof(kAbbrTagUChar)/sizeof((kAbbrTagUChar)[0]))), kAbbrTagUChar, 0, UPRV_LENGTHOF(kAbbrTagUChar)(int32_t)(sizeof(kAbbrTagUChar)/sizeof((kAbbrTagUChar)[0]))) == 0) {
                          skip = FALSE0;
                      }
                  }
              }
              if (skip) {
                  // Drop the latest key on the path and continue
                  path.retainBetween(0, pathLength);
                  continue;
              }
          }

          // == Handle aliases ==
          if (arrays.get(path) != NULL__null || maps.get(path) != NULL__null) {
              // Drop the latest key on the path and continue
              path.retainBetween(0, pathLength);
              continue;
          }

          AliasType aliasType = processAliasFromValue(path, value, errorCode);
          if (U_FAILURE(errorCode)) { return; }
          if (aliasType == SAME_CALENDAR) {
              // Store the alias path and the current path on aliasPathPairs
              LocalPointer<UnicodeString> aliasRelativePathCopy(aliasRelativePath.clone(), errorCode);
              aliasPathPairs.adoptElement(aliasRelativePathCopy.orphan(), errorCode);
              if (U_FAILURE(errorCode)) { return; }
              LocalPointer<UnicodeString> pathCopy(path.clone(), errorCode);
              aliasPathPairs.adoptElement(pathCopy.orphan(), errorCode);
              if (U_FAILURE(errorCode)) { return; }

              // Drop the latest key on the path and continue
              path.retainBetween(0, pathLength);
              continue;
          }
          U_ASSERT(aliasType == NONE)(void)0;

          // == Handle data ==
          if (value.getType() == URES_ARRAY) {
              // We are on a leaf, store the array
              ResourceArray rDataArray = value.getArray(errorCode);
              int32_t dataArraySize = rDataArray.getSize();
              LocalArray<UnicodeString> dataArray(new UnicodeString[dataArraySize], errorCode);
              value.getStringArray(dataArray.getAlias(), dataArraySize, errorCode);
              arrays.put(path, dataArray.orphan(), errorCode);
              arraySizes.puti(path, dataArraySize, errorCode);
              if (U_FAILURE(errorCode)) { return; }
          } else if (value.getType() == URES_TABLE) {
              // We are not on a leaf, recursively process the subtable.
              processResource(path, key, value, errorCode);
              if (U_FAILURE(errorCode)) { return; }
          }

          // Drop the latest key on the path
          path.retainBetween(0, pathLength);
      }
  }

  // Populates an AliasIdentifier with the alias information contained on the UResource.Value.
  AliasType processAliasFromValue(UnicodeString &currentRelativePath, ResourceValue &value,
                                  UErrorCode &errorCode) {
      if (U_FAILURE(errorCode)) { return NONE; }

      if (value.getType() == URES_ALIAS) {
          int32_t aliasPathSize;
          const UChar* aliasPathUChar = value.getAliasString(aliasPathSize, errorCode);
          if (U_FAILURE(errorCode)) { return NONE; }
          UnicodeString aliasPath(aliasPathUChar, aliasPathSize);
          const int32_t aliasPrefixLength = UPRV_LENGTHOF(kCalendarAliasPrefixUChar)(int32_t)(sizeof(kCalendarAliasPrefixUChar)/sizeof((kCalendarAliasPrefixUChar
)[0]));
          if (aliasPath.startsWith(kCalendarAliasPrefixUChar, aliasPrefixLength)
              && aliasPath.length() > aliasPrefixLength) {
              int32_t typeLimit = aliasPath.indexOf(SOLIDUS((UChar)0x002F), aliasPrefixLength);
              if (typeLimit > aliasPrefixLength) {
                  const UnicodeString aliasCalendarType =
                      aliasPath.tempSubStringBetween(aliasPrefixLength, typeLimit);
                  aliasRelativePath.setTo(aliasPath, typeLimit + 1, aliasPath.length());

                  if (currentCalendarType == aliasCalendarType
                      && currentRelativePath != aliasRelativePath) {
                      // If we have an alias to the same calendar, the path to the resource must be different
                      return SAME_CALENDAR;

                  } else if (currentCalendarType != aliasCalendarType
                             && currentRelativePath == aliasRelativePath) {
                      // If we have an alias to a different calendar, the path to the resource must be the same
                      if (aliasCalendarType.compare(kGregorianTagUChar, UPRV_LENGTHOF(kGregorianTagUChar)(int32_t)(sizeof(kGregorianTagUChar)/sizeof((kGregorianTagUChar
)[0]))) == 0) {
                          return GREGORIAN;
                      } else if (nextCalendarType.isBogus()) {
                          nextCalendarType = aliasCalendarType;
                          return DIFFERENT_CALENDAR;
                      } else if (nextCalendarType == aliasCalendarType) {
                          return DIFFERENT_CALENDAR;
                      }
                  }
              }
          }
          errorCode = U_INTERNAL_PROGRAM_ERROR;
          return NONE;
      }
      return NONE;
  }

  // Deleter function to be used by 'arrays'
  static void U_CALLCONV deleteUnicodeStringArray(void *uArray) {
      delete[] static_cast<UnicodeString *>(uArray);
  }
1839};
1840// Virtual destructors have to be defined out of line
1841CalendarDataSink::~CalendarDataSink() {
  arrays.setValueDeleter(deleteUnicodeStringArray);
1843}
1844}

1846//------------------------------------------------------

1848static void
1849initField(UnicodeString **field, int32_t& length, const UChar *data, LastResortSize numStr, LastResortSize strLen, UErrorCode &status) {
  if (U_SUCCESS(status)) {
      length = numStr;
      *field = newUnicodeStringArray((size_t)numStr);
      if (*field) {
          for(int32_t i = 0; i<length; i++) {
              // readonly aliases - all "data" strings are constant
              // -1 as length for variable-length strings (gLastResortDayNames[0] is empty)
              (*(field)+i)->setTo(TRUE1, data+(i*((int32_t)strLen)), -1);
          }
      }
      else {
          length = 0;
          status = U_MEMORY_ALLOCATION_ERROR;
      }
  }
1865}

1867static void
1868initField(UnicodeString **field, int32_t& length, CalendarDataSink &sink, CharString &key, UErrorCode &status) {
  if (U_SUCCESS(status)) {
      UnicodeString keyUString(key.data(), -1, US_INVicu::UnicodeString::kInvariant);
      UnicodeString* array = static_cast<UnicodeString*>(sink.arrays.get(keyUString));

      if (array != NULL__null) {
          length = sink.arraySizes.geti(keyUString);
          *field = array;
          // DateFormatSymbols takes ownership of the array:
          sink.arrays.remove(keyUString);
      } else {
          length = 0;
          status = U_MISSING_RESOURCE_ERROR;
      }
  }
1883}

1885static void
1886initField(UnicodeString **field, int32_t& length, CalendarDataSink &sink, CharString &key, int32_t arrayOffset, UErrorCode &status) {
  if (U_SUCCESS(status)) {
      UnicodeString keyUString(key.data(), -1, US_INVicu::UnicodeString::kInvariant);
      UnicodeString* array = static_cast<UnicodeString*>(sink.arrays.get(keyUString));

      if (array != NULL__null) {
          int32_t arrayLength = sink.arraySizes.geti(keyUString);
          length = arrayLength + arrayOffset;
          *field = new UnicodeString[length];
          if (*field == NULL__null) {
              status = U_MEMORY_ALLOCATION_ERROR;
              return;
          }
          uprv_arrayCopy(array, 0, *field, arrayOffset, arrayLength);
      } else {
          length = 0;
          status = U_MISSING_RESOURCE_ERROR;
      }
  }
1905}

1907static void
1908initLeapMonthPattern(UnicodeString *field, int32_t index, CalendarDataSink &sink, CharString &path, UErrorCode &status) {
  field[index].remove();
  if (U_SUCCESS(status)) {
      UnicodeString pathUString(path.data(), -1, US_INVicu::UnicodeString::kInvariant);
      Hashtable *leapMonthTable = static_cast<Hashtable*>(sink.maps.get(pathUString));
      if (leapMonthTable != NULL__null) {
          UnicodeString leapLabel(FALSE0, kLeapTagUChar, UPRV_LENGTHOF(kLeapTagUChar)(int32_t)(sizeof(kLeapTagUChar)/sizeof((kLeapTagUChar)[0])));
          UnicodeString *leapMonthPattern = static_cast<UnicodeString*>(leapMonthTable->get(leapLabel));
          if (leapMonthPattern != NULL__null) {
              field[index].fastCopyFrom(*leapMonthPattern);
          } else {
              field[index].setToBogus();
          }
          return;
      }
      status = U_MISSING_RESOURCE_ERROR;
  }
1925}

1927static CharString
1928&buildResourcePath(CharString &path, const char* segment1, UErrorCode &errorCode) {
  return path.clear().append(segment1, -1, errorCode);
1930}

1932static CharString
1933&buildResourcePath(CharString &path, const char* segment1, const char* segment2,
                 UErrorCode &errorCode) {
  return buildResourcePath(path, segment1, errorCode).append('/', errorCode)
                                                     .append(segment2, -1, errorCode);
1937}

1939static CharString
1940&buildResourcePath(CharString &path, const char* segment1, const char* segment2,
                 const char* segment3, UErrorCode &errorCode) {
  return buildResourcePath(path, segment1, segment2, errorCode).append('/', errorCode)
                                                               .append(segment3, -1, errorCode);
1944}

1946static CharString
1947&buildResourcePath(CharString &path, const char* segment1, const char* segment2,
                 const char* segment3, const char* segment4, UErrorCode &errorCode) {
  return buildResourcePath(path, segment1, segment2, segment3, errorCode).append('/', errorCode)
                                                                         .append(segment4, -1, errorCode);
1951}

1953typedef struct {
  const char * usageTypeName;
  DateFormatSymbols::ECapitalizationContextUsageType usageTypeEnumValue;
1956} ContextUsageTypeNameToEnumValue;

1958static const ContextUsageTypeNameToEnumValue contextUsageTypeMap[] = {
 // Entries must be sorted by usageTypeName; entry with NULL name terminates list.
  { "day-format-except-narrow", DateFormatSymbols::kCapContextUsageDayFormat },
  { "day-narrow",     DateFormatSymbols::kCapContextUsageDayNarrow },
  { "day-standalone-except-narrow", DateFormatSymbols::kCapContextUsageDayStandalone },
  { "era-abbr",       DateFormatSymbols::kCapContextUsageEraAbbrev },
  { "era-name",       DateFormatSymbols::kCapContextUsageEraWide },
  { "era-narrow",     DateFormatSymbols::kCapContextUsageEraNarrow },
  { "metazone-long",  DateFormatSymbols::kCapContextUsageMetazoneLong },
  { "metazone-short", DateFormatSymbols::kCapContextUsageMetazoneShort },
  { "month-format-except-narrow", DateFormatSymbols::kCapContextUsageMonthFormat },
  { "month-narrow",   DateFormatSymbols::kCapContextUsageMonthNarrow },
  { "month-standalone-except-narrow", DateFormatSymbols::kCapContextUsageMonthStandalone },
  { "zone-long",      DateFormatSymbols::kCapContextUsageZoneLong },
  { "zone-short",     DateFormatSymbols::kCapContextUsageZoneShort },
  { NULL__null, (DateFormatSymbols::ECapitalizationContextUsageType)0 },
1974};

1976// Resource keys to look up localized strings for day periods.
1977// The first one must be midnight and the second must be noon, so that their indices coincide
1978// with the am/pm field. Formatting and parsing code for day periods relies on this coincidence.
1979static const char *dayPeriodKeys[] = {"midnight", "noon",
                       "morning1", "afternoon1", "evening1", "night1",
                       "morning2", "afternoon2", "evening2", "night2"};

1983UnicodeString* loadDayPeriodStrings(CalendarDataSink &sink, CharString &path,
                                  int32_t &stringCount,  UErrorCode &status) {
  if (U_FAILURE(status)) { return NULL__null; }

  UnicodeString pathUString(path.data(), -1, US_INVicu::UnicodeString::kInvariant);
  Hashtable* map = static_cast<Hashtable*>(sink.maps.get(pathUString));

  stringCount = UPRV_LENGTHOF(dayPeriodKeys)(int32_t)(sizeof(dayPeriodKeys)/sizeof((dayPeriodKeys)[0]));
  UnicodeString *strings = new UnicodeString[stringCount];
  if (strings == NULL__null) {
      status = U_MEMORY_ALLOCATION_ERROR;
      return NULL__null;
  }

  if (map != NULL__null) {
      for (int32_t i = 0; i < stringCount; ++i) {
          UnicodeString dayPeriodKey(dayPeriodKeys[i], -1, US_INVicu::UnicodeString::kInvariant);
          UnicodeString *dayPeriod = static_cast<UnicodeString*>(map->get(dayPeriodKey));
          if (dayPeriod != NULL__null) {
              strings[i].fastCopyFrom(*dayPeriod);
          } else {
              strings[i].setToBogus();
          }
      }
  } else {
      for (int32_t i = 0; i < stringCount; i++) {
          strings[i].setToBogus();
      }
  }
  return strings;
2013}


2016void
2017DateFormatSymbols::initializeData(const Locale& locale, const char *type, UErrorCode& status, UBool useLastResortData)
2018{
  int32_t len = 0;
  /* In case something goes wrong, initialize all of the data to NULL. */
  fEras = NULL__null;
  fErasCount = 0;
  fEraNames = NULL__null;
  fEraNamesCount = 0;
  fNarrowEras = NULL__null;
  fNarrowErasCount = 0;
  fMonths = NULL__null;
  fMonthsCount=0;
  fShortMonths = NULL__null;
  fShortMonthsCount=0;
  fNarrowMonths = NULL__null;
  fNarrowMonthsCount=0;
  fStandaloneMonths = NULL__null;
  fStandaloneMonthsCount=0;
  fStandaloneShortMonths = NULL__null;
  fStandaloneShortMonthsCount=0;
  fStandaloneNarrowMonths = NULL__null;
  fStandaloneNarrowMonthsCount=0;
  fWeekdays = NULL__null;
  fWeekdaysCount=0;
  fShortWeekdays = NULL__null;
  fShortWeekdaysCount=0;
  fShorterWeekdays = NULL__null;
  fShorterWeekdaysCount=0;
  fNarrowWeekdays = NULL__null;
  fNarrowWeekdaysCount=0;
  fStandaloneWeekdays = NULL__null;
  fStandaloneWeekdaysCount=0;
  fStandaloneShortWeekdays = NULL__null;
  fStandaloneShortWeekdaysCount=0;
  fStandaloneShorterWeekdays = NULL__null;
  fStandaloneShorterWeekdaysCount=0;
  fStandaloneNarrowWeekdays = NULL__null;
  fStandaloneNarrowWeekdaysCount=0;
  fAmPms = NULL__null;
  fAmPmsCount=0;
  fNarrowAmPms = NULL__null;
  fNarrowAmPmsCount=0;
  fTimeSeparator.setToBogus();
  fQuarters = NULL__null;
  fQuartersCount = 0;
  fShortQuarters = NULL__null;
  fShortQuartersCount = 0;
  fNarrowQuarters = NULL__null;
  fNarrowQuartersCount = 0;
  fStandaloneQuarters = NULL__null;
  fStandaloneQuartersCount = 0;
  fStandaloneShortQuarters = NULL__null;
  fStandaloneShortQuartersCount = 0;
  fStandaloneNarrowQuarters = NULL__null;
  fStandaloneNarrowQuartersCount = 0;
  fLeapMonthPatterns = NULL__null;
  fLeapMonthPatternsCount = 0;
  fShortYearNames = NULL__null;
  fShortYearNamesCount = 0;
  fShortZodiacNames = NULL__null;
  fShortZodiacNamesCount = 0;
  fZoneStringsRowCount = 0;
  fZoneStringsColCount = 0;
  fZoneStrings = NULL__null;
  fLocaleZoneStrings = NULL__null;
  fAbbreviatedDayPeriods = NULL__null;
  fAbbreviatedDayPeriodsCount = 0;
  fWideDayPeriods = NULL__null;
  fWideDayPeriodsCount = 0;
  fNarrowDayPeriods = NULL__null;
  fNarrowDayPeriodsCount = 0;
  fStandaloneAbbreviatedDayPeriods = NULL__null;
  fStandaloneAbbreviatedDayPeriodsCount = 0;
  fStandaloneWideDayPeriods = NULL__null;
  fStandaloneWideDayPeriodsCount = 0;
  fStandaloneNarrowDayPeriods = NULL__null;
  fStandaloneNarrowDayPeriodsCount = 0;
  uprv_memset(fCapitalization, 0, sizeof(fCapitalization)):: memset(fCapitalization, 0, sizeof(fCapitalization));

  // We need to preserve the requested locale for
  // lazy ZoneStringFormat instantiation.  ZoneStringFormat
  // is region sensitive, thus, bundle locale bundle's locale
  // is not sufficient.
  fZSFLocale = locale;

  if (U_FAILURE(status)) return;

  // Create a CalendarDataSink to process this data and the resource bundles
  CalendarDataSink calendarSink(status);
  UResourceBundle *rb = ures_openures_open_71(NULL__null, locale.getBaseName(), &status);
  UResourceBundle *cb = ures_getByKeyures_getByKey_71(rb, gCalendarTag, NULL__null, &status);

  if (U_FAILURE(status)) return;

  // Iterate over the resource bundle data following the fallbacks through different calendar types
  UnicodeString calendarType((type != NULL__null && *type != '\0')? type : gGregorianTag, -1, US_INVicu::UnicodeString::kInvariant);
  while (!calendarType.isBogus()) {
      CharString calendarTypeBuffer;
      calendarTypeBuffer.appendInvariantChars(calendarType, status);
      if (U_FAILURE(status)) { return; }
      const char *calendarTypeCArray = calendarTypeBuffer.data();

      // Enumerate this calendar type. If the calendar is not found fallback to gregorian
      UErrorCode oldStatus = status;
      UResourceBundle *ctb = ures_getByKeyWithFallbackures_getByKeyWithFallback_71(cb, calendarTypeCArray, NULL__null, &status);
      if (status == U_MISSING_RESOURCE_ERROR) {
          ures_closeures_close_71(ctb);
          if (uprv_strcmp(calendarTypeCArray, gGregorianTag):: strcmp(calendarTypeCArray, gGregorianTag) != 0) {
              calendarType.setTo(FALSE0, kGregorianTagUChar, UPRV_LENGTHOF(kGregorianTagUChar)(int32_t)(sizeof(kGregorianTagUChar)/sizeof((kGregorianTagUChar
)[0])));
              calendarSink.visitAllResources();
              status = oldStatus;
              continue;
          }
          return;
      }

      calendarSink.preEnumerate(calendarType);
      ures_getAllItemsWithFallbackures_getAllItemsWithFallback_71(ctb, "", calendarSink, status);
      ures_closeures_close_71(ctb);
      if (U_FAILURE(status)) break;

      // Stop loading when gregorian was loaded
      if (uprv_strcmp(calendarTypeCArray, gGregorianTag):: strcmp(calendarTypeCArray, gGregorianTag) == 0) {
          break;
      }

      // Get the next calendar type to process from the sink
      calendarType = calendarSink.nextCalendarType;

      // Gregorian is always the last fallback
      if (calendarType.isBogus()) {
          calendarType.setTo(FALSE0, kGregorianTagUChar, UPRV_LENGTHOF(kGregorianTagUChar)(int32_t)(sizeof(kGregorianTagUChar)/sizeof((kGregorianTagUChar
)[0])));
          calendarSink.visitAllResources();
      }
  }

  // CharString object to build paths
  CharString path;

  // Load Leap Month Patterns
  UErrorCode tempStatus = status;
  fLeapMonthPatterns = newUnicodeStringArray(kMonthPatternsCount);
  if (fLeapMonthPatterns) {
      initLeapMonthPattern(fLeapMonthPatterns, kLeapMonthPatternFormatWide, calendarSink,
                           buildResourcePath(path, gMonthPatternsTag, gNamesFormatTag, gNamesWideTag, tempStatus), tempStatus);
      initLeapMonthPattern(fLeapMonthPatterns, kLeapMonthPatternFormatAbbrev, calendarSink,
                           buildResourcePath(path, gMonthPatternsTag, gNamesFormatTag, gNamesAbbrTag, tempStatus), tempStatus);
      initLeapMonthPattern(fLeapMonthPatterns, kLeapMonthPatternFormatNarrow, calendarSink,
                           buildResourcePath(path, gMonthPatternsTag, gNamesFormatTag, gNamesNarrowTag, tempStatus), tempStatus);
      initLeapMonthPattern(fLeapMonthPatterns, kLeapMonthPatternStandaloneWide, calendarSink,
                           buildResourcePath(path, gMonthPatternsTag, gNamesStandaloneTag, gNamesWideTag, tempStatus), tempStatus);
      initLeapMonthPattern(fLeapMonthPatterns, kLeapMonthPatternStandaloneAbbrev, calendarSink,
                           buildResourcePath(path, gMonthPatternsTag, gNamesStandaloneTag, gNamesAbbrTag, tempStatus), tempStatus);
      initLeapMonthPattern(fLeapMonthPatterns, kLeapMonthPatternStandaloneNarrow, calendarSink,
                           buildResourcePath(path, gMonthPatternsTag, gNamesStandaloneTag, gNamesNarrowTag, tempStatus), tempStatus);
      initLeapMonthPattern(fLeapMonthPatterns, kLeapMonthPatternNumeric, calendarSink,
                           buildResourcePath(path, gMonthPatternsTag, gNamesNumericTag, gNamesAllTag, tempStatus), tempStatus);
      if (U_SUCCESS(tempStatus)) {
          // Hack to fix bad C inheritance for dangi monthPatterns (OK in J); this should be handled by aliases in root, but isn't.
          // The ordering of the following statements is important.
          if (fLeapMonthPatterns[kLeapMonthPatternFormatAbbrev].isEmpty()) {
              fLeapMonthPatterns[kLeapMonthPatternFormatAbbrev].setTo(fLeapMonthPatterns[kLeapMonthPatternFormatWide]);
          }
          if (fLeapMonthPatterns[kLeapMonthPatternFormatNarrow].isEmpty()) {
              fLeapMonthPatterns[kLeapMonthPatternFormatNarrow].setTo(fLeapMonthPatterns[kLeapMonthPatternStandaloneNarrow]);
          }
          if (fLeapMonthPatterns[kLeapMonthPatternStandaloneWide].isEmpty()) {
              fLeapMonthPatterns[kLeapMonthPatternStandaloneWide].setTo(fLeapMonthPatterns[kLeapMonthPatternFormatWide]);
          }
          if (fLeapMonthPatterns[kLeapMonthPatternStandaloneAbbrev].isEmpty()) {
              fLeapMonthPatterns[kLeapMonthPatternStandaloneAbbrev].setTo(fLeapMonthPatterns[kLeapMonthPatternFormatAbbrev]);
          }
          // end of hack
          fLeapMonthPatternsCount = kMonthPatternsCount;
      } else {
          delete[] fLeapMonthPatterns;
          fLeapMonthPatterns = NULL__null;
      }
  }

  // Load cyclic names sets
  tempStatus = status;
  initField(&fShortYearNames, fShortYearNamesCount, calendarSink,
            buildResourcePath(path, gCyclicNameSetsTag, gNameSetYearsTag, gNamesFormatTag, gNamesAbbrTag, tempStatus), tempStatus);
  initField(&fShortZodiacNames, fShortZodiacNamesCount, calendarSink,
            buildResourcePath(path, gCyclicNameSetsTag, gNameSetZodiacsTag, gNamesFormatTag, gNamesAbbrTag, tempStatus), tempStatus);

  // Load context transforms and capitalization
  tempStatus = U_ZERO_ERROR;
  UResourceBundle *localeBundle = ures_openures_open_71(NULL__null, locale.getName(), &tempStatus);
  if (U_SUCCESS(tempStatus)) {
      UResourceBundle *contextTransforms = ures_getByKeyWithFallbackures_getByKeyWithFallback_71(localeBundle, gContextTransformsTag, NULL__null, &tempStatus);
      if (U_SUCCESS(tempStatus)) {
          UResourceBundle *contextTransformUsage;
          while ( (contextTransformUsage = ures_getNextResourceures_getNextResource_71(contextTransforms, NULL__null, &tempStatus)) != NULL__null ) {
              const int32_t * intVector = ures_getIntVectorures_getIntVector_71(contextTransformUsage, &len, &status);
              if (U_SUCCESS(tempStatus) && intVector != NULL__null && len >= 2) {
                  const char* usageType = ures_getKeyures_getKey_71(contextTransformUsage);
                  if (usageType != NULL__null) {
                      const ContextUsageTypeNameToEnumValue * typeMapPtr = contextUsageTypeMap;
                      int32_t compResult = 0;
                      // linear search; list is short and we cannot be sure that bsearch is available
                      while ( typeMapPtr->usageTypeName != NULL__null && (compResult = uprv_strcmp(usageType, typeMapPtr->usageTypeName):: strcmp(usageType, typeMapPtr->usageTypeName)) > 0 ) {
                          ++typeMapPtr;
                      }
                      if (typeMapPtr->usageTypeName != NULL__null && compResult == 0) {
                          fCapitalization[typeMapPtr->usageTypeEnumValue][0] = static_cast<UBool>(intVector[0]);
                          fCapitalization[typeMapPtr->usageTypeEnumValue][1] = static_cast<UBool>(intVector[1]);
                      }
                  }
              }
              tempStatus = U_ZERO_ERROR;
              ures_closeures_close_71(contextTransformUsage);
          }
          ures_closeures_close_71(contextTransforms);
      }

      tempStatus = U_ZERO_ERROR;
      const LocalPointer<NumberingSystem> numberingSystem(
              NumberingSystem::createInstance(locale, tempStatus), tempStatus);
      if (U_SUCCESS(tempStatus)) {
          // These functions all fail gracefully if passed NULL pointers and
          // do nothing unless U_SUCCESS(tempStatus), so it's only necessary
          // to check for errors once after all calls are made.
          const LocalUResourceBundlePointer numberElementsData(ures_getByKeyWithFallbackures_getByKeyWithFallback_71(
                  localeBundle, gNumberElementsTag, NULL__null, &tempStatus));
          const LocalUResourceBundlePointer nsNameData(ures_getByKeyWithFallbackures_getByKeyWithFallback_71(
                  numberElementsData.getAlias(), numberingSystem->getName(), NULL__null, &tempStatus));
          const LocalUResourceBundlePointer symbolsData(ures_getByKeyWithFallbackures_getByKeyWithFallback_71(
                  nsNameData.getAlias(), gSymbolsTag, NULL__null, &tempStatus));
          fTimeSeparator = ures_getUnicodeStringByKey(
                  symbolsData.getAlias(), gTimeSeparatorTag, &tempStatus);
          if (U_FAILURE(tempStatus)) {
              fTimeSeparator.setToBogus();
          }
      }

      ures_closeures_close_71(localeBundle);
  }

  if (fTimeSeparator.isBogus()) {
      fTimeSeparator.setTo(DateFormatSymbols::DEFAULT_TIME_SEPARATOR);
  }

  // Load day periods
  fWideDayPeriods = loadDayPeriodStrings(calendarSink,
                          buildResourcePath(path, gDayPeriodTag, gNamesFormatTag, gNamesWideTag, status),
                          fWideDayPeriodsCount, status);
  fNarrowDayPeriods = loadDayPeriodStrings(calendarSink,
                          buildResourcePath(path, gDayPeriodTag, gNamesFormatTag, gNamesNarrowTag, status),
                          fNarrowDayPeriodsCount, status);
  fAbbreviatedDayPeriods = loadDayPeriodStrings(calendarSink,
                          buildResourcePath(path, gDayPeriodTag, gNamesFormatTag, gNamesAbbrTag, status),
                          fAbbreviatedDayPeriodsCount, status);
  fStandaloneWideDayPeriods = loadDayPeriodStrings(calendarSink,
                          buildResourcePath(path, gDayPeriodTag, gNamesStandaloneTag, gNamesWideTag, status),
                          fStandaloneWideDayPeriodsCount, status);
  fStandaloneNarrowDayPeriods = loadDayPeriodStrings(calendarSink,
                          buildResourcePath(path, gDayPeriodTag, gNamesStandaloneTag, gNamesNarrowTag, status),
                          fStandaloneNarrowDayPeriodsCount, status);
  fStandaloneAbbreviatedDayPeriods = loadDayPeriodStrings(calendarSink,
                          buildResourcePath(path, gDayPeriodTag, gNamesStandaloneTag, gNamesAbbrTag, status),
                          fStandaloneAbbreviatedDayPeriodsCount, status);

  U_LOCALE_BASED(locBased, *this)LocaleBased locBased((*this).validLocale, (*this).actualLocale
);
  // if we make it to here, the resource data is cool, and we can get everything out
  // of it that we need except for the time-zone and localized-pattern data, which
  // are stored in a separate file
  locBased.setLocaleIDs(ures_getLocaleByTypeures_getLocaleByType_71(cb, ULOC_VALID_LOCALE, &status),
                        ures_getLocaleByTypeures_getLocaleByType_71(cb, ULOC_ACTUAL_LOCALE, &status));

  // Load eras
  initField(&fEras, fErasCount, calendarSink, buildResourcePath(path, gErasTag, gNamesAbbrTag, status), status);
  UErrorCode oldStatus = status;
  initField(&fEraNames, fEraNamesCount, calendarSink, buildResourcePath(path, gErasTag, gNamesWideTag, status), status);
  if (status == U_MISSING_RESOURCE_ERROR) { // Workaround because eras/wide was omitted from CLDR 1.3
      status = oldStatus;
      assignArray(fEraNames, fEraNamesCount, fEras, fErasCount);
  }
  // current ICU4J falls back to abbreviated if narrow eras are missing, so we will too
  oldStatus = status;
  initField(&fNarrowEras, fNarrowErasCount, calendarSink, buildResourcePath(path, gErasTag, gNamesNarrowTag, status), status);
  if (status == U_MISSING_RESOURCE_ERROR) { // Workaround because eras/wide was omitted from CLDR 1.3
      status = oldStatus;
      assignArray(fNarrowEras, fNarrowErasCount, fEras, fErasCount);
  }

  // Load month names
  initField(&fMonths, fMonthsCount, calendarSink,
            buildResourcePath(path, gMonthNamesTag, gNamesFormatTag, gNamesWideTag, status), status);
  initField(&fShortMonths, fShortMonthsCount, calendarSink,
            buildResourcePath(path, gMonthNamesTag, gNamesFormatTag, gNamesAbbrTag, status), status);
  initField(&fStandaloneMonths, fStandaloneMonthsCount, calendarSink,
            buildResourcePath(path, gMonthNamesTag, gNamesStandaloneTag, gNamesWideTag, status), status);
  if (status == U_MISSING_RESOURCE_ERROR) { /* If standalone/wide not available, use format/wide */
      status = U_ZERO_ERROR;
      assignArray(fStandaloneMonths, fStandaloneMonthsCount, fMonths, fMonthsCount);
  }
  initField(&fStandaloneShortMonths, fStandaloneShortMonthsCount, calendarSink,
            buildResourcePath(path, gMonthNamesTag, gNamesStandaloneTag, gNamesAbbrTag, status), status);
  if (status == U_MISSING_RESOURCE_ERROR) { /* If standalone/abbreviated not available, use format/abbreviated */
      status = U_ZERO_ERROR;
      assignArray(fStandaloneShortMonths, fStandaloneShortMonthsCount, fShortMonths, fShortMonthsCount);
  }

  UErrorCode narrowMonthsEC = status;
  UErrorCode standaloneNarrowMonthsEC = status;
  initField(&fNarrowMonths, fNarrowMonthsCount, calendarSink,
            buildResourcePath(path, gMonthNamesTag, gNamesFormatTag, gNamesNarrowTag, narrowMonthsEC), narrowMonthsEC);
  initField(&fStandaloneNarrowMonths, fStandaloneNarrowMonthsCount, calendarSink,
            buildResourcePath(path, gMonthNamesTag, gNamesStandaloneTag, gNamesNarrowTag, narrowMonthsEC), standaloneNarrowMonthsEC);
  if (narrowMonthsEC == U_MISSING_RESOURCE_ERROR && standaloneNarrowMonthsEC != U_MISSING_RESOURCE_ERROR) {
      // If format/narrow not available, use standalone/narrow
      assignArray(fNarrowMonths, fNarrowMonthsCount, fStandaloneNarrowMonths, fStandaloneNarrowMonthsCount);
  } else if (narrowMonthsEC != U_MISSING_RESOURCE_ERROR && standaloneNarrowMonthsEC == U_MISSING_RESOURCE_ERROR) {
      // If standalone/narrow not available, use format/narrow
      assignArray(fStandaloneNarrowMonths, fStandaloneNarrowMonthsCount, fNarrowMonths, fNarrowMonthsCount);
  } else if (narrowMonthsEC == U_MISSING_RESOURCE_ERROR && standaloneNarrowMonthsEC == U_MISSING_RESOURCE_ERROR) {
      // If neither is available, use format/abbreviated
      assignArray(fNarrowMonths, fNarrowMonthsCount, fShortMonths, fShortMonthsCount);
      assignArray(fStandaloneNarrowMonths, fStandaloneNarrowMonthsCount, fShortMonths, fShortMonthsCount);
  }

  // Load AM/PM markers; if wide or narrow not available, use short
  UErrorCode ampmStatus = U_ZERO_ERROR;
  initField(&fAmPms, fAmPmsCount, calendarSink,
            buildResourcePath(path, gAmPmMarkersTag, ampmStatus), ampmStatus);
  if (U_FAILURE(ampmStatus)) {
      initField(&fAmPms, fAmPmsCount, calendarSink,
                buildResourcePath(path, gAmPmMarkersAbbrTag, status), status);
  }
  ampmStatus = U_ZERO_ERROR;
  initField(&fNarrowAmPms, fNarrowAmPmsCount, calendarSink,
            buildResourcePath(path, gAmPmMarkersNarrowTag, ampmStatus), ampmStatus);
  if (U_FAILURE(ampmStatus)) {
      initField(&fNarrowAmPms, fNarrowAmPmsCount, calendarSink,
                buildResourcePath(path, gAmPmMarkersAbbrTag, status), status);
  }

  // Load quarters
  initField(&fQuarters, fQuartersCount, calendarSink,
            buildResourcePath(path, gQuartersTag, gNamesFormatTag, gNamesWideTag, status), status);
  initField(&fShortQuarters, fShortQuartersCount, calendarSink,
            buildResourcePath(path, gQuartersTag, gNamesFormatTag, gNamesAbbrTag, status), status);

  initField(&fStandaloneQuarters, fStandaloneQuartersCount, calendarSink,
            buildResourcePath(path, gQuartersTag, gNamesStandaloneTag, gNamesWideTag, status), status);
  if(status == U_MISSING_RESOURCE_ERROR) {
      status = U_ZERO_ERROR;
      assignArray(fStandaloneQuarters, fStandaloneQuartersCount, fQuarters, fQuartersCount);
  }
  initField(&fStandaloneShortQuarters, fStandaloneShortQuartersCount, calendarSink,
            buildResourcePath(path, gQuartersTag, gNamesStandaloneTag, gNamesAbbrTag, status), status);
  if(status == U_MISSING_RESOURCE_ERROR) {
      status = U_ZERO_ERROR;
      assignArray(fStandaloneShortQuarters, fStandaloneShortQuartersCount, fShortQuarters, fShortQuartersCount);
  }

  // unlike the fields above, narrow format quarters fall back on narrow standalone quarters
  initField(&fStandaloneNarrowQuarters, fStandaloneNarrowQuartersCount, calendarSink,
            buildResourcePath(path, gQuartersTag, gNamesStandaloneTag, gNamesNarrowTag, status), status);
  initField(&fNarrowQuarters, fNarrowQuartersCount, calendarSink,
            buildResourcePath(path, gQuartersTag, gNamesFormatTag, gNamesNarrowTag, status), status);
  if(status == U_MISSING_RESOURCE_ERROR) {
      status = U_ZERO_ERROR;
      assignArray(fNarrowQuarters, fNarrowQuartersCount, fStandaloneNarrowQuarters, fStandaloneNarrowQuartersCount);
  }
  
  // ICU 3.8 or later version no longer uses localized date-time pattern characters by default (ticket#5597)
  /*
  // fastCopyFrom()/setTo() - see assignArray comments
  resStr = ures_getStringByKey(fResourceBundle, gLocalPatternCharsTag, &len, &status);
  fLocalPatternChars.setTo(TRUE, resStr, len);
  // If the locale data does not include new pattern chars, use the defaults
  // TODO: Consider making this an error, since this may add conflicting characters.
  if (len < PATTERN_CHARS_LEN) {
      fLocalPatternChars.append(UnicodeString(TRUE, &gPatternChars[len], PATTERN_CHARS_LEN-len));
  }
  */
  fLocalPatternChars.setTo(TRUE1, gPatternChars, PATTERN_CHARS_LEN37);

  // Format wide weekdays -> fWeekdays
  // {sfb} fixed to handle 1-based weekdays
  initField(&fWeekdays, fWeekdaysCount, calendarSink,
            buildResourcePath(path, gDayNamesTag, gNamesFormatTag, gNamesWideTag, status), 1, status);

  // Format abbreviated weekdays -> fShortWeekdays
  initField(&fShortWeekdays, fShortWeekdaysCount, calendarSink,
            buildResourcePath(path, gDayNamesTag, gNamesFormatTag, gNamesAbbrTag, status), 1, status);

  // Format short weekdays -> fShorterWeekdays (fall back to abbreviated)
  initField(&fShorterWeekdays, fShorterWeekdaysCount, calendarSink,
            buildResourcePath(path, gDayNamesTag, gNamesFormatTag, gNamesShortTag, status), 1, status);
  if (status == U_MISSING_RESOURCE_ERROR) {
      status = U_ZERO_ERROR;
      assignArray(fShorterWeekdays, fShorterWeekdaysCount, fShortWeekdays, fShortWeekdaysCount);
  }

  // Stand-alone wide weekdays -> fStandaloneWeekdays
  initField(&fStandaloneWeekdays, fStandaloneWeekdaysCount, calendarSink,
            buildResourcePath(path, gDayNamesTag, gNamesStandaloneTag, gNamesWideTag, status), 1, status);
  if (status == U_MISSING_RESOURCE_ERROR) { /* If standalone/wide is not available, use format/wide */
      status = U_ZERO_ERROR;
      assignArray(fStandaloneWeekdays, fStandaloneWeekdaysCount, fWeekdays, fWeekdaysCount);
  }

  // Stand-alone abbreviated weekdays -> fStandaloneShortWeekdays
  initField(&fStandaloneShortWeekdays, fStandaloneShortWeekdaysCount, calendarSink,
            buildResourcePath(path, gDayNamesTag, gNamesStandaloneTag, gNamesAbbrTag, status), 1, status);
  if (status == U_MISSING_RESOURCE_ERROR) { /* If standalone/abbreviated is not available, use format/abbreviated */
      status = U_ZERO_ERROR;
      assignArray(fStandaloneShortWeekdays, fStandaloneShortWeekdaysCount, fShortWeekdays, fShortWeekdaysCount);
  }

  // Stand-alone short weekdays -> fStandaloneShorterWeekdays (fall back to format abbreviated)
  initField(&fStandaloneShorterWeekdays, fStandaloneShorterWeekdaysCount, calendarSink,
            buildResourcePath(path, gDayNamesTag, gNamesStandaloneTag, gNamesShortTag, status), 1, status);
  if (status == U_MISSING_RESOURCE_ERROR) { /* If standalone/short is not available, use format/short */
      status = U_ZERO_ERROR;
      assignArray(fStandaloneShorterWeekdays, fStandaloneShorterWeekdaysCount, fShorterWeekdays, fShorterWeekdaysCount);
  }

  // Format narrow weekdays -> fNarrowWeekdays
  UErrorCode narrowWeeksEC = status;
  initField(&fNarrowWeekdays, fNarrowWeekdaysCount, calendarSink,
            buildResourcePath(path, gDayNamesTag, gNamesFormatTag, gNamesNarrowTag, status), 1, narrowWeeksEC);
  // Stand-alone narrow weekdays -> fStandaloneNarrowWeekdays
  UErrorCode standaloneNarrowWeeksEC = status;
  initField(&fStandaloneNarrowWeekdays, fStandaloneNarrowWeekdaysCount, calendarSink,
            buildResourcePath(path, gDayNamesTag, gNamesStandaloneTag, gNamesNarrowTag, status), 1, standaloneNarrowWeeksEC);

  if (narrowWeeksEC == U_MISSING_RESOURCE_ERROR && standaloneNarrowWeeksEC != U_MISSING_RESOURCE_ERROR) {
      // If format/narrow not available, use standalone/narrow
      assignArray(fNarrowWeekdays, fNarrowWeekdaysCount, fStandaloneNarrowWeekdays, fStandaloneNarrowWeekdaysCount);
  } else if (narrowWeeksEC != U_MISSING_RESOURCE_ERROR && standaloneNarrowWeeksEC == U_MISSING_RESOURCE_ERROR) {
      // If standalone/narrow not available, use format/narrow
      assignArray(fStandaloneNarrowWeekdays, fStandaloneNarrowWeekdaysCount, fNarrowWeekdays, fNarrowWeekdaysCount);
  } else if (narrowWeeksEC == U_MISSING_RESOURCE_ERROR && standaloneNarrowWeeksEC == U_MISSING_RESOURCE_ERROR ) {
      // If neither is available, use format/abbreviated
      assignArray(fNarrowWeekdays, fNarrowWeekdaysCount, fShortWeekdays, fShortWeekdaysCount);
      assignArray(fStandaloneNarrowWeekdays, fStandaloneNarrowWeekdaysCount, fShortWeekdays, fShortWeekdaysCount);
  }

  // Last resort fallback in case previous data wasn't loaded
  if (U_FAILURE(status))
  {
      if (useLastResortData)
      {
          // Handle the case in which there is no resource data present.
          // We don't have to generate usable patterns in this situation;
          // we just need to produce something that will be semi-intelligible
          // in most locales.

          status = U_USING_FALLBACK_WARNING;
          //TODO(fabalbon): make sure we are storing las resort data for all fields in here.
          initField(&fEras, fErasCount, (const UChar *)gLastResortEras, kEraNum, kEraLen, status);
          initField(&fEraNames, fEraNamesCount, (const UChar *)gLastResortEras, kEraNum, kEraLen, status);
          initField(&fNarrowEras, fNarrowErasCount, (const UChar *)gLastResortEras, kEraNum, kEraLen, status);
          initField(&fMonths, fMonthsCount, (const UChar *)gLastResortMonthNames, kMonthNum, kMonthLen,  status);
          initField(&fShortMonths, fShortMonthsCount, (const UChar *)gLastResortMonthNames, kMonthNum, kMonthLen, status);
          initField(&fNarrowMonths, fNarrowMonthsCount, (const UChar *)gLastResortMonthNames, kMonthNum, kMonthLen, status);
          initField(&fStandaloneMonths, fStandaloneMonthsCount, (const UChar *)gLastResortMonthNames, kMonthNum, kMonthLen,  status);
          initField(&fStandaloneShortMonths, fStandaloneShortMonthsCount, (const UChar *)gLastResortMonthNames, kMonthNum, kMonthLen, status);
          initField(&fStandaloneNarrowMonths, fStandaloneNarrowMonthsCount, (const UChar *)gLastResortMonthNames, kMonthNum, kMonthLen, status);
          initField(&fWeekdays, fWeekdaysCount, (const UChar *)gLastResortDayNames, kDayNum, kDayLen, status);
          initField(&fShortWeekdays, fShortWeekdaysCount, (const UChar *)gLastResortDayNames, kDayNum, kDayLen, status);
          initField(&fShorterWeekdays, fShorterWeekdaysCount, (const UChar *)gLastResortDayNames, kDayNum, kDayLen, status);
          initField(&fNarrowWeekdays, fNarrowWeekdaysCount, (const UChar *)gLastResortDayNames, kDayNum, kDayLen, status);
          initField(&fStandaloneWeekdays, fStandaloneWeekdaysCount, (const UChar *)gLastResortDayNames, kDayNum, kDayLen, status);
          initField(&fStandaloneShortWeekdays, fStandaloneShortWeekdaysCount, (const UChar *)gLastResortDayNames, kDayNum, kDayLen, status);
          initField(&fStandaloneShorterWeekdays, fStandaloneShorterWeekdaysCount, (const UChar *)gLastResortDayNames, kDayNum, kDayLen, status);
          initField(&fStandaloneNarrowWeekdays, fStandaloneNarrowWeekdaysCount, (const UChar *)gLastResortDayNames, kDayNum, kDayLen, status);
          initField(&fAmPms, fAmPmsCount, (const UChar *)gLastResortAmPmMarkers, kAmPmNum, kAmPmLen, status);
          initField(&fNarrowAmPms, fNarrowAmPmsCount, (const UChar *)gLastResortAmPmMarkers, kAmPmNum, kAmPmLen, status);
          initField(&fQuarters, fQuartersCount, (const UChar *)gLastResortQuarters, kQuarterNum, kQuarterLen, status);
          initField(&fShortQuarters, fShortQuartersCount, (const UChar *)gLastResortQuarters, kQuarterNum, kQuarterLen, status);
          initField(&fNarrowQuarters, fNarrowQuartersCount, (const UChar *)gLastResortQuarters, kQuarterNum, kQuarterLen, status);
          initField(&fStandaloneQuarters, fStandaloneQuartersCount, (const UChar *)gLastResortQuarters, kQuarterNum, kQuarterLen, status);
          initField(&fStandaloneShortQuarters, fStandaloneShortQuartersCount, (const UChar *)gLastResortQuarters, kQuarterNum, kQuarterLen, status);
          initField(&fStandaloneNarrowQuarters, fStandaloneNarrowQuartersCount, (const UChar *)gLastResortQuarters, kQuarterNum, kQuarterLen, status);
          fLocalPatternChars.setTo(TRUE1, gPatternChars, PATTERN_CHARS_LEN37);
      }
  }

  // Close resources
  ures_closeures_close_71(cb);
  ures_closeures_close_71(rb);
2504}

2506Locale
2507DateFormatSymbols::getLocale(ULocDataLocaleType type, UErrorCode& status) const {
  U_LOCALE_BASED(locBased, *this)LocaleBased locBased((*this).validLocale, (*this).actualLocale
);
  return locBased.getLocale(type, status);
2510}

2512U_NAMESPACE_END}

2514#endif /* #if !UCONFIG_NO_FORMATTING */

2516//eof

←

../deps/icu-small/source/common/unifiedcache.h

→

1// © 2016 and later: Unicode, Inc. and others.
2// License & terms of use: http://www.unicode.org/copyright.html
3/*
4******************************************************************************
5* Copyright (C) 2015, International Business Machines Corporation and
6* others. All Rights Reserved.
7******************************************************************************
8*
9* File UNIFIEDCACHE.H - The ICU Unified cache.
10******************************************************************************
11*/

13#ifndef __UNIFIED_CACHE_H__
14#define __UNIFIED_CACHE_H__

16#include "utypeinfo.h"  // for 'typeid' to work

18#include "unicode/uobject.h"
19#include "unicode/locid.h"
20#include "sharedobject.h"
21#include "unicode/unistr.h"
22#include "cstring.h"
23#include "ustr_imp.h"

25struct UHashtable;
26struct UHashElement;

28U_NAMESPACE_BEGINnamespace icu_71 {

30class UnifiedCache;

32/**
* A base class for all cache keys.
*/
35class U_COMMON_API CacheKeyBase : public UObject {
public:
 CacheKeyBase() : fCreationStatus(U_ZERO_ERROR), fIsPrimary(false) {}

 /**
  * Copy constructor. Needed to support cloning.
  */
 CacheKeyBase(const CacheKeyBase &other) 
         : UObject(other), fCreationStatus(other.fCreationStatus), fIsPrimary(false) { }
 virtual ~CacheKeyBase();

 /**
  * Returns the hash code for this object.
  */
 virtual int32_t hashCode() const = 0;

 /**
  * Clones this object polymorphically. Caller owns returned value.
  */
 virtual CacheKeyBase *clone() const = 0;

 /**
  * Create a new object for this key. Called by cache on cache miss.
  * createObject must add a reference to the object it returns. Note
  * that getting an object from the cache and returning it without calling
  * removeRef on it satisfies this requirement. It can also return NULL
  * and set status to an error.
  *
  * @param creationContext the context in which the object is being
  *                        created. May be NULL.
  * @param status          Implementations can return a failure here.
  *                        In addition, implementations may return a
  *                        non NULL object and set a warning status.
  */
 virtual const SharedObject *createObject(
         const void *creationContext, UErrorCode &status) const = 0;

 /**
  * Writes a description of this key to buffer and returns buffer. Written
  * description is NULL terminated.
  */
 virtual char *writeDescription(char *buffer, int32_t bufSize) const = 0;

 friend inline bool operator==(const CacheKeyBase& lhs,
                               const CacheKeyBase& rhs) {
     return lhs.equals(rhs);
 }

 friend inline bool operator!=(const CacheKeyBase& lhs,
                               const CacheKeyBase& rhs) {
     return !lhs.equals(rhs);
 }

protected:
 virtual bool equals(const CacheKeyBase& other) const = 0;

private:
 mutable UErrorCode fCreationStatus;
 mutable UBool fIsPrimary;
 friend class UnifiedCache;
95};



99/**
* Templated version of CacheKeyBase. 
* A key of type LocaleCacheKey<T> maps to a value of type T.
*/
103template<typename T>
104class CacheKey : public CacheKeyBase {
public:
 virtual ~CacheKey() { }
 /**
  * The template parameter, T, determines the hash code returned.
  */
 virtual int32_t hashCode() const override {
     const char *s = typeid(T).name();
     return ustr_hashCharsNustr_hashCharsN_71(s, static_cast<int32_t>(uprv_strlen(s):: strlen(s)));
 }

 /**
  * Use the value type, T,  as the description.
  */
 virtual char *writeDescription(char *buffer, int32_t bufLen) const override {
     const char *s = typeid(T).name();
     uprv_strncpy(buffer, s, bufLen):: strncpy(buffer, s, bufLen);
     buffer[bufLen - 1] = 0;
     return buffer;
 }

protected:
 /**
  * Two objects are equal if they are of the same type.
  */
 virtual bool equals(const CacheKeyBase &other) const override {
     return this == &other || typeid(*this) == typeid(other);
 }
132};

134/**
* Cache key based on locale.
* A key of type LocaleCacheKey<T> maps to a value of type T.
*/
138template<typename T>
139class LocaleCacheKey : public CacheKey<T> {
protected:
 Locale   fLoc;
 virtual bool equals(const CacheKeyBase &other) const override {
     if (!CacheKey<T>::equals(other)) {
         return false;
     }
     // We know this and other are of same class because equals() on
     // CacheKey returned true.
     return operator==(static_cast<const LocaleCacheKey<T> &>(other));
 }
public:
 LocaleCacheKey(const Locale &loc) : fLoc(loc) {}
 LocaleCacheKey(const LocaleCacheKey<T> &other)
         : CacheKey<T>(other), fLoc(other.fLoc) { }
 virtual ~LocaleCacheKey() { }
 virtual int32_t hashCode() const override {
     return (int32_t)(37u * (uint32_t)CacheKey<T>::hashCode() + (uint32_t)fLoc.hashCode());
 }
 inline bool operator == (const LocaleCacheKey<T> &other) const {
     return fLoc == other.fLoc;
 }
 virtual CacheKeyBase *clone() const override {
     return new LocaleCacheKey<T>(*this);
 }
 virtual const T *createObject(
         const void *creationContext, UErrorCode &status) const override;
 /**
  * Use the locale id as the description.
  */
 virtual char *writeDescription(char *buffer, int32_t bufLen) const override {
     const char *s = fLoc.getName();
     uprv_strncpy(buffer, s, bufLen):: strncpy(buffer, s, bufLen);
     buffer[bufLen - 1] = 0;
     return buffer;
 }

176};

178/**
* The unified cache. A singleton type.
* Design doc here:
* https://docs.google.com/document/d/1RwGQJs4N4tawNbf809iYDRCvXoMKqDJihxzYt1ysmd8/edit?usp=sharing
*/
183class U_COMMON_API UnifiedCache : public UnifiedCacheBase {
public:
 /**
  * @internal
  * Do not call directly. Instead use UnifiedCache::getInstance() as
  * there should be only one UnifiedCache in an application.
  */
 UnifiedCache(UErrorCode &status);

 /**
  * Return a pointer to the global cache instance.
  */
 static UnifiedCache *getInstance(UErrorCode &status);

 /**
  * Fetches a value from the cache by key. Equivalent to
  * get(key, NULL, ptr, status);
  */
 template<typename T>
 void get(
         const CacheKey<T>& key,
         const T *&ptr,
         UErrorCode &status) const {
     get(key, NULL__null, ptr, status);
5
←
Calling 'UnifiedCache::get'→
15
←
Returning from 'UnifiedCache::get'→
 }
16
←
Returning without writing to 'ptr'→

 /**
  * Fetches value from the cache by key.
  *
  * @param key             the cache key.
  * @param creationContext passed verbatim to createObject method of key
  * @param ptr             On entry, ptr must be NULL or be included if
  *                        the reference count of the object it points
  *                        to. On exit, ptr points to the fetched object
  *                        from the cache or is left unchanged on
  *                        failure. Caller must call removeRef on ptr
  *                        if set to a non NULL value.
  * @param status          Any error returned here. May be set to a
  *                        warning value even if ptr is set.
  */
 template<typename T>
 void get(
         const CacheKey<T>& key,
         const void *creationContext,
         const T *&ptr,
         UErrorCode &status) const {
     if (U_FAILURE(status)) {
6
←
Taking false branch→
         return;
     }
     UErrorCode creationStatus = U_ZERO_ERROR;
     const SharedObject *value = NULL__null;
     _get(key, value, creationContext, creationStatus);
     const T *tvalue = (const T *) value;
     if (U_SUCCESS(creationStatus)) {
7
←
Taking true branch→
         SharedObject::copyPtr(tvalue, ptr);
8
←
Calling 'SharedObject::copyPtr'→
12
←
Returning from 'SharedObject::copyPtr'→
     }
     SharedObject::clearPtr(tvalue);
     // Take care not to overwrite a warning status passed in with
     // another warning or U_ZERO_ERROR.
     if (status == U_ZERO_ERROR || U_FAILURE(creationStatus)) {
13
←
Assuming 'status' is equal to U_ZERO_ERROR→
         status = creationStatus;
     }
 }
14
←
Returning without writing to 'ptr'→

247#ifdef UNIFIED_CACHE_DEBUG
 /**
  * Dumps the contents of this cache to standard error. Used for testing of
  * cache only.
  */
 void dumpContents() const;
253#endif

 /**
  * Convenience method to get a value of type T from cache for a
  * particular locale with creationContext == NULL.
  * @param loc    the locale
  * @param ptr    On entry, must be NULL or included in the ref count
  *               of the object to which it points.
  *               On exit, fetched value stored here or is left
  *               unchanged on failure. Caller must call removeRef on
  *               ptr if set to a non NULL value.
  * @param status Any error returned here. May be set to a
  *               warning value even if ptr is set.
  */
 template<typename T>
 static void getByLocale(
         const Locale &loc, const T *&ptr, UErrorCode &status) {
     const UnifiedCache *cache = getInstance(status);
     if (U_FAILURE(status)) {
3
←
Taking false branch→
         return;
     }
     cache->get(LocaleCacheKey<T>(loc), ptr, status);
4
←
Calling 'UnifiedCache::get'→
17
←
Returning from 'UnifiedCache::get'→
 }
18
←
Returning without writing to 'ptr'→

277#ifdef UNIFIED_CACHE_DEBUG
 /**
  * Dumps the cache contents to stderr. For testing only.
  */
 static void dump();
282#endif

 /**
  * Returns the number of keys in this cache. For testing only.
  */
 int32_t keyCount() const;

 /**
  * Removes any values from cache that are not referenced outside
  * the cache.
  */
 void flush() const;

 /**
  * Configures at what point eviction of unused entries will begin.
  * Eviction is triggered whenever the number of evictable keys exceeds
  * BOTH count AND (number of in-use items) * (percentageOfInUseItems / 100).
  * Once the number of unused entries drops below one of these,
  * eviction ceases. Because eviction happens incrementally,
  * the actual unused entry count may exceed both these numbers
  * from time to time.
  *
  * A cache entry is defined as unused if it is not essential to guarantee
  * that for a given key X, the cache returns the same reference to the
  * same value as long as the client already holds a reference to that
  * value.
  *
  * If this method is never called, the default settings are 1000 and 100%.
  *
  * Although this method is thread-safe, it is designed to be called at
  * application startup. If it is called in the middle of execution, it
  * will have no immediate effect on the cache. However over time, the
  * cache will perform eviction slices in an attempt to honor the new
  * settings.
  *
  * If a client already holds references to many different unique values
  * in the cache such that the number of those unique values far exceeds
  * "count" then the cache may not be able to maintain this maximum.
  * However, if this happens, the cache still guarantees that the number of
  * unused entries will remain only a small percentage of the total cache
  * size.
  *
  * If the parameters passed are negative, setEvctionPolicy sets status to
  * U_ILLEGAL_ARGUMENT_ERROR.
  */
 void setEvictionPolicy(
         int32_t count, int32_t percentageOfInUseItems, UErrorCode &status);


 /**
  * Returns how many entries have been auto evicted during the lifetime
  * of this cache. This only includes auto evicted entries, not
  * entries evicted because of a call to flush().
  */
 int64_t autoEvictedCount() const;

 /**
  * Returns the unused entry count in this cache. For testing only,
  * Regular clients will not need this.
  */
 int32_t unusedCount() const;

 virtual void handleUnreferencedObject() const override;
 virtual ~UnifiedCache();
 
private:
 UHashtable *fHashtable;
 mutable int32_t fEvictPos;
 mutable int32_t fNumValuesTotal;
 mutable int32_t fNumValuesInUse;
 int32_t fMaxUnused;
 int32_t fMaxPercentageOfInUse;
 mutable int64_t fAutoEvictedCount;
 SharedObject *fNoValue;
 
 UnifiedCache(const UnifiedCache &other);
 UnifiedCache &operator=(const UnifiedCache &other);
 
 /**
  * Flushes the contents of the cache. If cache values hold references to other
  * cache values then _flush should be called in a loop until it returns false.
  * 
  * On entry, gCacheMutex must be held.
  * On exit, those values with are evictable are flushed.
  * 
  *  @param all if false flush evictable items only, which are those with no external
  *                    references, plus those that can be safely recreated.<br>
  *            if true, flush all elements. Any values (sharedObjects) with remaining
  *                     hard (external) references are not deleted, but are detached from
  *                     the cache, so that a subsequent removeRefs can delete them.
  *                     _flush is not thread safe when all is true.
  *   @return true if any value in cache was flushed or false otherwise.
  */
 UBool _flush(UBool all) const;
 
 /**
  * Gets value out of cache.
  * On entry. gCacheMutex must not be held. value must be NULL. status
  * must be U_ZERO_ERROR.
  * On exit. value and status set to what is in cache at key or on cache
  * miss the key's createObject() is called and value and status are set to
  * the result of that. In this latter case, best effort is made to add the
  * value and status to the cache. If createObject() fails to create a value,
  * fNoValue is stored in cache, and value is set to NULL. Caller must call
  * removeRef on value if non NULL.
  */
 void _get(
         const CacheKeyBase &key,
         const SharedObject *&value,
         const void *creationContext,
         UErrorCode &status) const;

  /**
   * Attempts to fetch value and status for key from cache.
   * On entry, gCacheMutex must not be held value must be NULL and status must
   * be U_ZERO_ERROR.
   * On exit, either returns false (In this
   * case caller should try to create the object) or returns true with value
   * pointing to the fetched value and status set to fetched status. When
   * false is returned status may be set to failure if an in progress hash
   * entry could not be made but value will remain unchanged. When true is
   * returned, caller must call removeRef() on value.
   */
  UBool _poll(
          const CacheKeyBase &key,
          const SharedObject *&value,
          UErrorCode &status) const;
  
  /**
   * Places a new value and creationStatus in the cache for the given key.
   * On entry, gCacheMutex must be held. key must not exist in the cache. 
   * On exit, value and creation status placed under key. Soft reference added
   * to value on successful add. On error sets status.
   */
  void _putNew(
      const CacheKeyBase &key,
      const SharedObject *value,
      const UErrorCode creationStatus,
      UErrorCode &status) const;
         
  /**
   * Places value and status at key if there is no value at key or if cache
   * entry for key is in progress. Otherwise, it leaves the current value and
   * status there.
   * 
   * On entry. gCacheMutex must not be held. Value must be
   * included in the reference count of the object to which it points.
   * 
   * On exit, value and status are changed to what was already in the cache if
   * something was there and not in progress. Otherwise, value and status are left
   * unchanged in which case they are placed in the cache on a best-effort basis.
   * Caller must call removeRef() on value.
   */
 void _putIfAbsentAndGet(
         const CacheKeyBase &key,
         const SharedObject *&value,
         UErrorCode &status) const;

  /**
   * Returns the next element in the cache round robin style.
   * Returns nullptr if the cache is empty.
   * On entry, gCacheMutex must be held.
   */
  const UHashElement *_nextElement() const;
 
 /**
  * Return the number of cache items that would need to be evicted
  * to bring usage into conformance with eviction policy.
  * 
  * An item corresponds to an entry in the hash table, a hash table element.
  * 
  * On entry, gCacheMutex must be held.
  */
 int32_t _computeCountOfItemsToEvict() const;
 
 /**
  * Run an eviction slice.
  * On entry, gCacheMutex must be held.
  * _runEvictionSlice runs a slice of the evict pipeline by examining the next
  * 10 entries in the cache round robin style evicting them if they are eligible.
  */
 void _runEvictionSlice() const;

 /**
  * Register a primary cache entry. A primary key is the first key to create
  * a given  SharedObject value. Subsequent keys whose create function
  * produce references to an already existing SharedObject are not primary -
  * they can be evicted and subsequently recreated.
  * 
  * On entry, gCacheMutex must be held.
  * On exit, items in use count incremented, entry is marked as a primary
  * entry, and value registered with cache so that subsequent calls to
  * addRef() and removeRef() on it correctly interact with the cache.
  */
 void _registerPrimary(const CacheKeyBase *theKey, const SharedObject *value) const;
      
 /**
  * Store a value and creation error status in given hash entry.
  * On entry, gCacheMutex must be held. Hash entry element must be in progress.
  * value must be non NULL.
  * On Exit, soft reference added to value. value and status stored in hash
  * entry. Soft reference removed from previous stored value. Waiting
  * threads notified.
  */
 void _put(
         const UHashElement *element,
         const SharedObject *value,
         const UErrorCode status) const;
  /**
   * Remove a soft reference, and delete the SharedObject if no references remain.
   * To be used from within the UnifiedCache implementation only.
   * gCacheMutex must be held by caller.
   * @param value the SharedObject to be acted on.
   */
 void removeSoftRef(const SharedObject *value) const;
 
 /**
  * Increment the hard reference count of the given SharedObject.
  * gCacheMutex must be held by the caller.
  * Update numValuesEvictable on transitions between zero and one reference.
  * 
  * @param value The SharedObject to be referenced.
  * @return the hard reference count after the addition.
  */
 int32_t addHardRef(const SharedObject *value) const;
 
/**
  * Decrement the hard reference count of the given SharedObject.
  * gCacheMutex must be held by the caller.
  * Update numValuesEvictable on transitions between one and zero reference.
  * 
  * @param value The SharedObject to be referenced.
  * @return the hard reference count after the removal.
  */
 int32_t removeHardRef(const SharedObject *value) const;

 
519#ifdef UNIFIED_CACHE_DEBUG
 void _dumpContents() const;
521#endif
 
 /**
  *  Fetch value and error code from a particular hash entry.
  *  On entry, gCacheMutex must be held. value must be either NULL or must be
  *  included in the ref count of the object to which it points.
  *  On exit, value and status set to what is in the hash entry. Caller must
  *  eventually call removeRef on value.
  *  If hash entry is in progress, value will be set to gNoValue and status will
  *  be set to U_ZERO_ERROR.
  */
 void _fetch(const UHashElement *element, const SharedObject *&value,
                     UErrorCode &status) const;
                     
  /**
   * Determine if given hash entry is in progress.
   * On entry, gCacheMutex must be held.
   */
 UBool _inProgress(const UHashElement *element) const;
 
 /**
  * Determine if given hash entry is in progress.
  * On entry, gCacheMutex must be held.
  */
 UBool _inProgress(const SharedObject *theValue, UErrorCode creationStatus) const;
 
 /**
  * Determine if given hash entry is eligible for eviction.
  * On entry, gCacheMutex must be held.
  */
 UBool _isEvictable(const UHashElement *element) const;
552};

554U_NAMESPACE_END}

556#endif

←

../deps/icu-small/source/common/sharedobject.h

1// © 2016 and later: Unicode, Inc. and others.
2// License & terms of use: http://www.unicode.org/copyright.html
3/*
4******************************************************************************
5* Copyright (C) 2015-2016, International Business Machines
6* Corporation and others.  All Rights Reserved.
7******************************************************************************
8* sharedobject.h
9*/

11#ifndef __SHAREDOBJECT_H__
12#define __SHAREDOBJECT_H__


15#include "unicode/uobject.h"
16#include "umutex.h"

18U_NAMESPACE_BEGINnamespace icu_71 {

20class SharedObject;

22/**
* Base class for unified cache exposing enough methods to SharedObject
* instances to allow their addRef() and removeRef() methods to
* update cache metrics. No other part of ICU, except for SharedObject,
* should directly call the methods of this base class.
*/
28class U_COMMON_API UnifiedCacheBase : public UObject {
29public:
  UnifiedCacheBase() { }

  /**
   * Notify the cache implementation that an object was seen transitioning to
   * zero hard references. The cache may use this to keep track the number of
   * unreferenced SharedObjects, and to trigger evictions.
   */
  virtual void handleUnreferencedObject() const = 0;

  virtual ~UnifiedCacheBase();
40private:
  UnifiedCacheBase(const UnifiedCacheBase &);
  UnifiedCacheBase &operator=(const UnifiedCacheBase &);
43};

45/**
* Base class for shared, reference-counted, auto-deleted objects.
* Subclasses can be immutable.
* If they are mutable, then they must implement their copy constructor
* so that copyOnWrite() works.
*
* Either stack-allocate, use LocalPointer, or use addRef()/removeRef().
* Sharing requires reference-counting.
*/
54class U_COMMON_API SharedObject : public UObject {
55public:
  /** Initializes totalRefCount, softRefCount to 0. */
  SharedObject() :
          softRefCount(0),
          hardRefCount(0),
          cachePtr(NULL__null) {}

  /** Initializes totalRefCount, softRefCount to 0. */
  SharedObject(const SharedObject &other) :
          UObject(other),
          softRefCount(0),
          hardRefCount(0),
          cachePtr(NULL__null) {}

  virtual ~SharedObject();

  /**
   * Increments the number of hard references to this object. Thread-safe.
   * Not for use from within the Unified Cache implementation.
   */
  void addRef() const;

  /**
   * Decrements the number of hard references to this object, and
   * arrange for possible cache-eviction and/or deletion if ref
   * count goes to zero. Thread-safe.
   * 
   * Not for use from within the UnifiedCache implementation.
   */
  void removeRef() const;

  /**
   * Returns the number of hard references for this object.
   * Uses a memory barrier.
   */
  int32_t getRefCount() const;

  /**
   * If noHardReferences() == true then this object has no hard references.
   * Must be called only from within the internals of UnifiedCache.
   */
  inline UBool noHardReferences() const { return getRefCount() == 0; }

  /**
   * If hasHardReferences() == true then this object has hard references.
   * Must be called only from within the internals of UnifiedCache.
   */
  inline UBool hasHardReferences() const { return getRefCount() != 0; }

  /**
   * Deletes this object if it has no references.
   * Available for non-cached SharedObjects only. Ownership of cached objects
   * is with the UnifiedCache, which is solely responsible for eviction and deletion.
   */
  void deleteIfZeroRefCount() const;

      
  /**
   * Returns a writable version of ptr.
   * If there is exactly one owner, then ptr itself is returned as a
   *  non-const pointer.
   * If there are multiple owners, then ptr is replaced with a 
   * copy-constructed clone,
   * and that is returned.
   * Returns NULL if cloning failed.
   *
   * T must be a subclass of SharedObject.
   */
  template<typename T>
  static T *copyOnWrite(const T *&ptr) {
      const T *p = ptr;
      if(p->getRefCount() <= 1) { return const_cast<T *>(p); }
      T *p2 = new T(*p);
      if(p2 == NULL__null) { return NULL__null; }
      p->removeRef();
      ptr = p2;
      p2->addRef();
      return p2;
  }

  /**
   * Makes dest an owner of the object pointed to by src while adjusting
   * reference counts and deleting the previous object dest pointed to
   * if necessary. Before this call is made, dest must either be NULL or
   * be included in the reference count of the object it points to. 
   *
   * T must be a subclass of SharedObject.
   */
  template<typename T>
  static void copyPtr(const T *src, const T *&dest) {
      if(src != dest) {
9
←
Assuming 'src' is equal to 'dest'→
10
←
Taking false branch→
          if(dest != NULL__null) { dest->removeRef(); }
          dest = src;
          if(src != NULL__null) { src->addRef(); }
      }
  }
11
←
Returning without writing to 'dest'→

  /**
   * Equivalent to copyPtr(NULL, dest).
   */
  template<typename T>
  static void clearPtr(const T *&ptr) {
      if (ptr != NULL__null) {
          ptr->removeRef();
          ptr = NULL__null;
      }
  }

163private:
  /**
   * The number of references from the UnifiedCache, which is
   * the number of times that the sharedObject is stored as a hash table value.
   * For use by UnifiedCache implementation code only.
   * All access is synchronized by UnifiedCache's gCacheMutex
   */
  mutable int32_t softRefCount;
  friend class UnifiedCache;

  /**
   * Reference count, excluding references from within the UnifiedCache implementation.
   */
  mutable u_atomic_int32_t hardRefCount;
  
  mutable const UnifiedCacheBase *cachePtr;

180};

182U_NAMESPACE_END}

184#endif