AuroraMiddleware/scuffed-code
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
1ccc7d153f
scuffed-code/icu4c/source/i18n/timezone.cpp
Unknown User aa0b0a88e8 Initial revision 
X-SVN-Rev: 2
1999-08-16 21:50:52 +00:00

2260 lines
118 KiB
C++
Raw Blame History

/*
********************************************************************************
* *
* COPYRIGHT: *
* (C) Copyright Taligent, Inc., 1997 *
* (C) Copyright International Business Machines Corporation, 1997-1998 *
* Licensed Material - Program-Property of IBM - All Rights Reserved. *
* US Government Users Restricted Rights - Use, duplication, or disclosure *
* restricted by GSA ADP Schedule Contract with IBM Corp. *
* *
********************************************************************************
*
* File TIMEZONE.CPP
*
* Modification History:
*
* Date Name Description
* 12/05/96 clhuang Creation.
* 04/21/97 aliu General clean-up and bug fixing.
* 05/08/97 aliu Fixed Hashtable code per code review.
* 07/09/97 helena Changed createInstance to createDefault.
* 07/29/97 aliu Updated with all-new list of 96 UNIX-derived
* TimeZones. Changed mechanism to load from static
* array rather than resource bundle.
* 07/07/1998 srl Bugfixes from the Java side: UTC GMT CAT NST
* Added getDisplayName API
* going to add custom parsing.
*
* ISSUES:
* - should getDisplayName cache something?
* - should custom time zones be cached? [probably]
* 08/10/98 stephen Brought getDisplayName() API in-line w/ conventions
* 08/19/98 stephen Changed createTimeZone() to never return 0
* 09/02/98 stephen Added getOffset(monthLen) and hasSameRules()
* 09/15/98 stephen Added getStaticClassID()
* 02/22/99 stephen Removed character literals for EBCDIC safety
* 05/04/99 stephen Changed initDefault() for Mutex issues
* 07/12/99 helena HPUX 11 CC Port.
*********************************************************************************/
#include "uhash.h"
#include "simpletz.h"
#include "smpdtfmt.h"
#include "calendar.h"
#include "mutex.h"
#ifdef _DEBUG
#include "unistrm.h"
#endif
// static initialization
char TimeZone::fgClassID = 0; // Value is irrelevant
TimeZone* TimeZone::fgDefaultZone = NULL;
UHashtable* TimeZone::fgHashtable = NULL;
/**
* Delete the given object, assuming it is a TimeZone. Used by Hashtable.
*/
void
TimeZone::deleteTimeZone(void* obj)
{
delete (TimeZone*)obj;
}
// ResourceBundle file, locale, and resource name
//const char* TimeZone::kTimeZoneResource = "timezone";
// There MUST be a TimeZone with this ID within kSystemTimeZones
UnicodeString TimeZone::kLastResortID("Africa/Casablanca"); // GMT
//const int32_t TimeZone::kLastResortOffset = 0;
// Array of UnicodeString objects for available IDs
UnicodeString* TimeZone::fgAvailableIDs = 0;
int32_t TimeZone::fgAvailableIDsCount = 0;
const int32_t TimeZone::millisPerHour = kMillisPerHour;
const UnicodeString TimeZone::GMT_ID = "GMT";
const int32_t TimeZone::GMT_ID_LENGTH = 3;
const UnicodeString TimeZone::CUSTOM_ID = "Custom";
const TimeZone* TimeZone::GMT = new SimpleTimeZone(0, GMT_ID);
UErrorCode TimeZone::fgStatus = ZERO_ERROR;
/* Lazy evaluated. HPUX CC compiler can't handle array initialization
with complex objects */
/*const int32_t TimeZone::kSystemTimeZonesCount = 320;*/
/* {sfb} illegal to have non-const array dimension */
#define kSystemTimeZonesCount 320
bool_t TimeZone::kSystemInited = FALSE;
SimpleTimeZone* TimeZone::kSystemTimeZones[kSystemTimeZonesCount];
void
TimeZone::initSystemTimeZones(void)
{
if (kSystemInited == FALSE) {
kSystemInited = TRUE;
// Migration from Java:
// - replace ONE_HOUR with kMillisPerHour
// - replace (int) with (int32_t)
// The following data is current as of 1998.
// Total Unix zones: 343
// Total Java zones: 289
// Not all Unix zones become Java zones due to duplication and overlap.
//----------------------------------------------------------
kSystemTimeZones[0] =
new SimpleTimeZone(-11*kMillisPerHour, "Pacific/Niue" /*NUT*/);
// Pacific/Niue Niue(NU) -11:00 - NUT
//----------------------------------------------------------
kSystemTimeZones[1] =
new SimpleTimeZone(-11*kMillisPerHour, "Pacific/Apia" /*WST*/);
// Pacific/Apia W Samoa(WS) -11:00 - WST # W Samoa Time
kSystemTimeZones[2] =
new SimpleTimeZone(-11*kMillisPerHour, "MIT" /*alias for Pacific/Apia*/);
//----------------------------------------------------------
kSystemTimeZones[3] =
new SimpleTimeZone(-11*kMillisPerHour, "Pacific/Pago_Pago" /*SST*/);
// Pacific/Pago_Pago American Samoa(US) -11:00 - SST # S=Samoa
//----------------------------------------------------------
kSystemTimeZones[4] =
new SimpleTimeZone(-10*kMillisPerHour, "Pacific/Tahiti" /*TAHT*/);
// Pacific/Tahiti French Polynesia(PF) -10:00 - TAHT # Tahiti Time
//----------------------------------------------------------
kSystemTimeZones[5] =
new SimpleTimeZone(-10*kMillisPerHour, "Pacific/Fakaofo" /*TKT*/);
// Pacific/Fakaofo Tokelau Is(TK) -10:00 - TKT # Tokelau Time
//----------------------------------------------------------
kSystemTimeZones[6] =
new SimpleTimeZone(-10*kMillisPerHour, "Pacific/Honolulu" /*HST*/);
// Pacific/Honolulu Hawaii(US) -10:00 - HST
kSystemTimeZones[7] =
new SimpleTimeZone(-10*kMillisPerHour, "HST" /*alias for Pacific/Honolulu*/);
//----------------------------------------------------------
kSystemTimeZones[8] =
new SimpleTimeZone(-10*kMillisPerHour, "America/Adak" /*HA%sT*/,
Calendar::APRIL, 1, -Calendar::SUNDAY /*DOW>=DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour, fgStatus);
// Rule US 1967 max - Oct lastSun 2:00 0 S
// Rule US 1987 max - Apr Sun>=1 2:00 1:00 D
// America/Adak Alaska(US) -10:00 US HA%sT
//----------------------------------------------------------
kSystemTimeZones[9] =
new SimpleTimeZone(-10*kMillisPerHour, "Pacific/Rarotonga" /*CK%sT*/,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 0*kMillisPerHour,
Calendar::MARCH, 1, -Calendar::SUNDAY /*DOW>=DOM*/, 0*kMillisPerHour, (int32_t)(0.5*kMillisPerHour), fgStatus);
// Rule Cook 1979 max - Mar Sun>=1 0:00 0 -
// Rule Cook 1979 max - Oct lastSun 0:00 0:30 HS
// Pacific/Rarotonga Cook Is(CK) -10:00 Cook CK%sT
//----------------------------------------------------------
kSystemTimeZones[10] =
new SimpleTimeZone((int32_t)(-9.5*kMillisPerHour), "Pacific/Marquesas" /*MART*/);
// Pacific/Marquesas French Polynesia(PF) -9:30 - MART # Marquesas Time
//----------------------------------------------------------
kSystemTimeZones[11] =
new SimpleTimeZone(-9*kMillisPerHour, "Pacific/Gambier" /*GAMT*/);
// Pacific/Gambier French Polynesia(PF) -9:00 - GAMT # Gambier Time
//----------------------------------------------------------
kSystemTimeZones[12] =
new SimpleTimeZone(-9*kMillisPerHour, "America/Anchorage" /*AK%sT*/,
Calendar::APRIL, 1, -Calendar::SUNDAY /*DOW>=DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule US 1967 max - Oct lastSun 2:00 0 S
// Rule US 1987 max - Apr Sun>=1 2:00 1:00 D
// America/Anchorage Alaska(US) -9:00 US AK%sT
kSystemTimeZones[13] =
new SimpleTimeZone(-9*kMillisPerHour, "AST" /*alias for America/Anchorage*/,
Calendar::APRIL, 1, -Calendar::SUNDAY /*DOW>=DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
//----------------------------------------------------------
kSystemTimeZones[14] =
new SimpleTimeZone((int32_t)(-8.5*kMillisPerHour), "Pacific/Pitcairn" /*PNT*/);
// Pacific/Pitcairn Pitcairn(PN) -8:30 - PNT # Pitcairn Time
//----------------------------------------------------------
kSystemTimeZones[15] =
new SimpleTimeZone(-8*kMillisPerHour, "America/Vancouver" /*P%sT*/,
Calendar::APRIL, 1, -Calendar::SUNDAY /*DOW>=DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Vanc 1962 max - Oct lastSun 2:00 0 S
// Rule Vanc 1987 max - Apr Sun>=1 2:00 1:00 D
// America/Vancouver British Columbia(CA) -8:00 Vanc P%sT
//----------------------------------------------------------
kSystemTimeZones[16] =
new SimpleTimeZone(-8*kMillisPerHour, "America/Tijuana" /*P%sT*/,
Calendar::APRIL, 1, -Calendar::SUNDAY /*DOW>=DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Mexico 1996 max - Apr Sun>=1 2:00 1:00 D
// Rule Mexico 1996 max - Oct lastSun 2:00 0 S
// America/Tijuana Mexico(MX) -8:00 Mexico P%sT
//----------------------------------------------------------
kSystemTimeZones[17] =
new SimpleTimeZone(-8*kMillisPerHour, "America/Los_Angeles" /*P%sT*/,
Calendar::APRIL, 1, -Calendar::SUNDAY /*DOW>=DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule US 1967 max - Oct lastSun 2:00 0 S
// Rule US 1987 max - Apr Sun>=1 2:00 1:00 D
// America/Los_Angeles US Pacific time, represented by Los Angeles(US) -8:00 US P%sT
kSystemTimeZones[18] =
new SimpleTimeZone(-8*kMillisPerHour, "PST" /*alias for America/Los_Angeles*/,
Calendar::APRIL, 1, -Calendar::SUNDAY /*DOW>=DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
//----------------------------------------------------------
kSystemTimeZones[19] =
new SimpleTimeZone(-7*kMillisPerHour, "America/Dawson_Creek" /*MST*/);
// America/Dawson_Creek British Columbia(CA) -7:00 - MST
//----------------------------------------------------------
kSystemTimeZones[20] =
new SimpleTimeZone(-7*kMillisPerHour, "America/Phoenix" /*MST*/);
// America/Phoenix ?(US) -7:00 - MST
kSystemTimeZones[21] =
new SimpleTimeZone(-7*kMillisPerHour, "America/Edmonton" /*M%sT*/,
Calendar::APRIL, 1, -Calendar::SUNDAY /*DOW>=DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Edm 1972 max - Oct lastSun 2:00 0 S
// Rule Edm 1987 max - Apr Sun>=1 2:00 1:00 D
// America/Edmonton Alberta(CA) -7:00 Edm M%sT
//----------------------------------------------------------
kSystemTimeZones[22] =
new SimpleTimeZone(-7*kMillisPerHour, "America/Mazatlan" /*M%sT*/,
Calendar::APRIL, 1, -Calendar::SUNDAY /*DOW>=DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Mexico 1996 max - Apr Sun>=1 2:00 1:00 D
// Rule Mexico 1996 max - Oct lastSun 2:00 0 S
// America/Mazatlan Mexico(MX) -7:00 Mexico M%sT
//----------------------------------------------------------
kSystemTimeZones[23] =
new SimpleTimeZone(-7*kMillisPerHour, "America/Denver" /*M%sT*/,
Calendar::APRIL, 1, -Calendar::SUNDAY /*DOW>=DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule US 1967 max - Oct lastSun 2:00 0 S
// Rule US 1987 max - Apr Sun>=1 2:00 1:00 D
// America/Denver US Mountain time, represented by Denver(US) -7:00 US M%sT
kSystemTimeZones[24] =
new SimpleTimeZone(-7*kMillisPerHour, "MST" /*alias for America/Denver*/,
Calendar::APRIL, 1, -Calendar::SUNDAY /*DOW>=DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
//----------------------------------------------------------
kSystemTimeZones[25] =
new SimpleTimeZone(-6*kMillisPerHour, "America/Belize" /*C%sT*/);
// America/Belize Belize(BZ) -6:00 - C%sT
//----------------------------------------------------------
kSystemTimeZones[26] =
new SimpleTimeZone(-6*kMillisPerHour, "America/Regina" /*CST*/);
// America/Regina Saskatchewan(CA) -6:00 - CST
//----------------------------------------------------------
kSystemTimeZones[27] =
new SimpleTimeZone(-6*kMillisPerHour, "Pacific/Galapagos" /*GALT*/);
// Pacific/Galapagos Ecuador(EC) -6:00 - GALT # Galapagos Time
//----------------------------------------------------------
kSystemTimeZones[28] =
new SimpleTimeZone(-6*kMillisPerHour, "America/Guatemala" /*C%sT*/);
// America/Guatemala Guatemala(GT) -6:00 - C%sT
//----------------------------------------------------------
kSystemTimeZones[29] =
new SimpleTimeZone(-6*kMillisPerHour, "America/Tegucigalpa" /*C%sT*/);
// America/Tegucigalpa Honduras(HN) -6:00 - C%sT
//----------------------------------------------------------
kSystemTimeZones[30] =
new SimpleTimeZone(-6*kMillisPerHour, "America/El_Salvador" /*C%sT*/);
// America/El_Salvador El Salvador(SV) -6:00 - C%sT
//----------------------------------------------------------
kSystemTimeZones[31] =
new SimpleTimeZone(-6*kMillisPerHour, "America/Costa_Rica" /*C%sT*/);
// America/Costa_Rica Costa Rica(CR) -6:00 - C%sT
//----------------------------------------------------------
kSystemTimeZones[32] =
new SimpleTimeZone(-6*kMillisPerHour, "America/Winnipeg" /*C%sT*/,
Calendar::APRIL, 1, -Calendar::SUNDAY /*DOW>=DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Winn 1966 max - Oct lastSun 2:00 0 S
// Rule Winn 1987 max - Apr Sun>=1 2:00 1:00 D
// America/Winnipeg Manitoba(CA) -6:00 Winn C%sT
//----------------------------------------------------------
kSystemTimeZones[33] =
new SimpleTimeZone(-6*kMillisPerHour, "Pacific/Easter" /*EAS%sT*/,
Calendar::OCTOBER, 9, -Calendar::SUNDAY /*DOW>=DOM*/, 0*kMillisPerHour,
Calendar::MARCH, 9, -Calendar::SUNDAY /*DOW>=DOM*/, 0*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Chile 1969 max - Oct Sun>=9 0:00 1:00 S
// Rule Chile 1970 max - Mar Sun>=9 0:00 0 -
// Pacific/Easter Chile(CL) -6:00 Chile EAS%sT
//----------------------------------------------------------
kSystemTimeZones[34] =
new SimpleTimeZone(-6*kMillisPerHour, "America/Mexico_City" /*C%sT*/,
Calendar::APRIL, 1, -Calendar::SUNDAY /*DOW>=DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Mexico 1996 max - Apr Sun>=1 2:00 1:00 D
// Rule Mexico 1996 max - Oct lastSun 2:00 0 S
// America/Mexico_City Mexico(MX) -6:00 Mexico C%sT
//----------------------------------------------------------
kSystemTimeZones[35] =
new SimpleTimeZone(-6*kMillisPerHour, "America/Chicago" /*C%sT*/,
Calendar::APRIL, 1, -Calendar::SUNDAY /*DOW>=DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule US 1967 max - Oct lastSun 2:00 0 S
// Rule US 1987 max - Apr Sun>=1 2:00 1:00 D
// America/Chicago US Central time, represented by Chicago(US) -6:00 US C%sT
kSystemTimeZones[36] =
new SimpleTimeZone(-6*kMillisPerHour, "CST" /*alias for America/Chicago*/,
Calendar::APRIL, 1, -Calendar::SUNDAY /*DOW>=DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
//----------------------------------------------------------
kSystemTimeZones[37] =
new SimpleTimeZone(-5*kMillisPerHour, "America/Porto_Acre" /*AST*/);
// America/Porto_Acre Brazil(BR) -5:00 - AST
//----------------------------------------------------------
kSystemTimeZones[38] =
new SimpleTimeZone(-5*kMillisPerHour, "America/Bogota" /*CO%sT*/);
// America/Bogota Colombia(CO) -5:00 - CO%sT # Colombia Time
//----------------------------------------------------------
kSystemTimeZones[39] =
new SimpleTimeZone(-5*kMillisPerHour, "America/Guayaquil" /*ECT*/);
// America/Guayaquil Ecuador(EC) -5:00 - ECT # Ecuador Time
//----------------------------------------------------------
kSystemTimeZones[40] =
new SimpleTimeZone(-5*kMillisPerHour, "America/Jamaica" /*EST*/);
// America/Jamaica Jamaica(JM) -5:00 - EST
//----------------------------------------------------------
kSystemTimeZones[41] =
new SimpleTimeZone(-5*kMillisPerHour, "America/Cayman" /*EST*/);
// America/Cayman Cayman Is(KY) -5:00 - EST
//----------------------------------------------------------
kSystemTimeZones[42] =
new SimpleTimeZone(-5*kMillisPerHour, "America/Managua" /*EST*/);
// America/Managua Nicaragua(NI) -5:00 - EST
//----------------------------------------------------------
kSystemTimeZones[43] =
new SimpleTimeZone(-5*kMillisPerHour, "America/Panama" /*EST*/);
// America/Panama Panama(PA) -5:00 - EST
//----------------------------------------------------------
kSystemTimeZones[44] =
new SimpleTimeZone(-5*kMillisPerHour, "America/Lima" /*PE%sT*/);
// America/Lima Peru(PE) -5:00 - PE%sT # Peru Time
//----------------------------------------------------------
kSystemTimeZones[45] =
new SimpleTimeZone(-5*kMillisPerHour, "America/Indianapolis" /*EST*/);
// America/Indianapolis Indiana(US) -5:00 - EST
kSystemTimeZones[46] =
new SimpleTimeZone(-5*kMillisPerHour, "IET" /*alias for America/Indianapolis*/);
//----------------------------------------------------------
kSystemTimeZones[47] =
new SimpleTimeZone(-5*kMillisPerHour, "America/Nassau" /*E%sT*/,
Calendar::APRIL, 1, -Calendar::SUNDAY /*DOW>=DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Bahamas 1964 max - Oct lastSun 2:00 0 S
// Rule Bahamas 1987 max - Apr Sun>=1 2:00 1:00 D
// America/Nassau Bahamas(BS) -5:00 Bahamas E%sT
//----------------------------------------------------------
kSystemTimeZones[48] =
new SimpleTimeZone(-5*kMillisPerHour, "America/Montreal" /*E%sT*/,
Calendar::APRIL, 1, -Calendar::SUNDAY /*DOW>=DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Mont 1957 max - Oct lastSun 2:00 0 S
// Rule Mont 1987 max - Apr Sun>=1 2:00 1:00 D
// America/Montreal Ontario, Quebec(CA) -5:00 Mont E%sT
//----------------------------------------------------------
kSystemTimeZones[49] =
new SimpleTimeZone(-5*kMillisPerHour, "America/Havana" /*C%sT*/,
Calendar::APRIL, 1, -Calendar::SUNDAY /*DOW>=DOM*/, 0*kMillisPerHour,
Calendar::OCTOBER, 8, -Calendar::SUNDAY /*DOW>=DOM*/, 1*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Cuba 1990 max - Apr Sun>=1 0:00 1:00 D
// Rule Cuba 1997 max - Oct Sun>=8 0:00s 0 S
// America/Havana Cuba(CU) -5:00 Cuba C%sT
//----------------------------------------------------------
kSystemTimeZones[50] =
new SimpleTimeZone(-5*kMillisPerHour, "America/Port-au-Prince" /*E%sT*/,
Calendar::APRIL, 1, -Calendar::SUNDAY /*DOW>=DOM*/, 1*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Haiti 1988 max - Apr Sun>=1 1:00s 1:00 D
// Rule Haiti 1988 max - Oct lastSun 1:00s 0 S
// America/Port-au-Prince Haiti(HT) -5:00 Haiti E%sT
//----------------------------------------------------------
kSystemTimeZones[51] =
new SimpleTimeZone(-5*kMillisPerHour, "America/Grand_Turk" /*E%sT*/,
Calendar::APRIL, 1, -Calendar::SUNDAY /*DOW>=DOM*/, 0*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 0*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule TC 1979 max - Oct lastSun 0:00 0 S
// Rule TC 1987 max - Apr Sun>=1 0:00 1:00 D
// America/Grand_Turk Turks and Caicos(TC) -5:00 TC E%sT
//----------------------------------------------------------
kSystemTimeZones[52] =
new SimpleTimeZone(-5*kMillisPerHour, "America/New_York" /*E%sT*/,
Calendar::APRIL, 1, -Calendar::SUNDAY /*DOW>=DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule US 1967 max - Oct lastSun 2:00 0 S
// Rule US 1987 max - Apr Sun>=1 2:00 1:00 D
// America/New_York US Eastern time, represented by New York(US) -5:00 US E%sT
kSystemTimeZones[53] =
new SimpleTimeZone(-5*kMillisPerHour, "EST" /*alias for America/New_York*/,
Calendar::APRIL, 1, -Calendar::SUNDAY /*DOW>=DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
//----------------------------------------------------------
kSystemTimeZones[54] =
new SimpleTimeZone(-4*kMillisPerHour, "America/Antigua" /*AST*/);
// America/Antigua Antigua and Barbuda(AG) -4:00 - AST
//----------------------------------------------------------
kSystemTimeZones[55] =
new SimpleTimeZone(-4*kMillisPerHour, "America/Anguilla" /*AST*/);
// America/Anguilla Anguilla(AI) -4:00 - AST
//----------------------------------------------------------
kSystemTimeZones[56] =
new SimpleTimeZone(-4*kMillisPerHour, "America/Curacao" /*AST*/);
// America/Curacao Curacao(AN) -4:00 - AST
//----------------------------------------------------------
kSystemTimeZones[57] =
new SimpleTimeZone(-4*kMillisPerHour, "America/Aruba" /*AST*/);
// America/Aruba Aruba(AW) -4:00 - AST
//----------------------------------------------------------
kSystemTimeZones[58] =
new SimpleTimeZone(-4*kMillisPerHour, "America/Barbados" /*A%sT*/);
// America/Barbados Barbados(BB) -4:00 - A%sT
//----------------------------------------------------------
kSystemTimeZones[59] =
new SimpleTimeZone(-4*kMillisPerHour, "America/La_Paz" /*BOT*/);
// America/La_Paz Bolivia(BO) -4:00 - BOT # Bolivia Time
//----------------------------------------------------------
kSystemTimeZones[60] =
new SimpleTimeZone(-4*kMillisPerHour, "America/Manaus" /*WST*/);
// America/Manaus Brazil(BR) -4:00 - WST
//----------------------------------------------------------
kSystemTimeZones[61] =
new SimpleTimeZone(-4*kMillisPerHour, "America/Dominica" /*AST*/);
// America/Dominica Dominica(DM) -4:00 - AST
//----------------------------------------------------------
kSystemTimeZones[62] =
new SimpleTimeZone(-4*kMillisPerHour, "America/Santo_Domingo" /*AST*/);
// America/Santo_Domingo Dominican Republic(DO) -4:00 - AST
//----------------------------------------------------------
kSystemTimeZones[63] =
new SimpleTimeZone(-4*kMillisPerHour, "America/Grenada" /*AST*/);
// America/Grenada Grenada(GD) -4:00 - AST
//----------------------------------------------------------
kSystemTimeZones[64] =
new SimpleTimeZone(-4*kMillisPerHour, "America/Guadeloupe" /*AST*/);
// America/Guadeloupe Guadeloupe(GP) -4:00 - AST
//----------------------------------------------------------
kSystemTimeZones[65] =
new SimpleTimeZone(-4*kMillisPerHour, "America/Guyana" /*GYT*/);
// America/Guyana Guyana(GY) -4:00 - GYT
//----------------------------------------------------------
kSystemTimeZones[66] =
new SimpleTimeZone(-4*kMillisPerHour, "America/St_Kitts" /*AST*/);
// America/St_Kitts St Kitts-Nevis(KN) -4:00 - AST
//----------------------------------------------------------
kSystemTimeZones[67] =
new SimpleTimeZone(-4*kMillisPerHour, "America/St_Lucia" /*AST*/);
// America/St_Lucia St Lucia(LC) -4:00 - AST
//----------------------------------------------------------
kSystemTimeZones[68] =
new SimpleTimeZone(-4*kMillisPerHour, "America/Martinique" /*AST*/);
// America/Martinique Martinique(MQ) -4:00 - AST
//----------------------------------------------------------
kSystemTimeZones[69] =
new SimpleTimeZone(-4*kMillisPerHour, "America/Montserrat" /*AST*/);
// America/Montserrat Montserrat(MS) -4:00 - AST
//----------------------------------------------------------
kSystemTimeZones[70] =
new SimpleTimeZone(-4*kMillisPerHour, "America/Puerto_Rico" /*AST*/);
// America/Puerto_Rico Puerto Rico(PR) -4:00 - AST
kSystemTimeZones[71] =
new SimpleTimeZone(-4*kMillisPerHour, "PRT" /*alias for America/Puerto_Rico*/);
//----------------------------------------------------------
kSystemTimeZones[72] =
new SimpleTimeZone(-4*kMillisPerHour, "America/Port_of_Spain" /*AST*/);
// America/Port_of_Spain Trinidad and Tobago(TT) -4:00 - AST
//----------------------------------------------------------
kSystemTimeZones[73] =
new SimpleTimeZone(-4*kMillisPerHour, "America/St_Vincent" /*AST*/);
// America/St_Vincent St Vincent and the Grenadines(VC) -4:00 - AST
//----------------------------------------------------------
kSystemTimeZones[74] =
new SimpleTimeZone(-4*kMillisPerHour, "America/Tortola" /*AST*/);
// America/Tortola British Virgin Is(VG) -4:00 - AST
//----------------------------------------------------------
kSystemTimeZones[75] =
new SimpleTimeZone(-4*kMillisPerHour, "America/St_Thomas" /*AST*/);
// America/St_Thomas Virgin Is(VI) -4:00 - AST
//----------------------------------------------------------
kSystemTimeZones[76] =
new SimpleTimeZone(-4*kMillisPerHour, "America/Caracas" /*VET*/);
// America/Caracas Venezuela(VE) -4:00 - VET
//----------------------------------------------------------
kSystemTimeZones[77] =
new SimpleTimeZone(-4*kMillisPerHour, "Antarctica/Palmer" /*CL%sT*/,
Calendar::OCTOBER, 9, -Calendar::SUNDAY /*DOW>=DOM*/, 0*kMillisPerHour,
Calendar::MARCH, 9, -Calendar::SUNDAY /*DOW>=DOM*/, 0*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule ChileAQ 1969 max - Oct Sun>=9 0:00 1:00 S
// Rule ChileAQ 1970 max - Mar Sun>=9 0:00 0 -
// Antarctica/Palmer USA - year-round bases(AQ) -4:00 ChileAQ CL%sT
//----------------------------------------------------------
kSystemTimeZones[78] =
new SimpleTimeZone(-4*kMillisPerHour, "Atlantic/Bermuda" /*A%sT*/,
Calendar::APRIL, 1, -Calendar::SUNDAY /*DOW>=DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Bahamas 1964 max - Oct lastSun 2:00 0 S
// Rule Bahamas 1987 max - Apr Sun>=1 2:00 1:00 D
// Atlantic/Bermuda Bermuda(BM) -4:00 Bahamas A%sT
//----------------------------------------------------------
kSystemTimeZones[79] =
new SimpleTimeZone(-4*kMillisPerHour, "America/Cuiaba" /*W%sT*/,
Calendar::OCTOBER, 1, -Calendar::SUNDAY /*DOW>=DOM*/, 0*kMillisPerHour,
Calendar::FEBRUARY, 11, -Calendar::SUNDAY /*DOW>=DOM*/, 0*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Brazil 1998 max - Oct Sun>=1 0:00 1:00 D
// Rule Brazil 1999 max - Feb Sun>=11 0:00 0 S
// America/Cuiaba Brazil(BR) -4:00 Brazil W%sT
//----------------------------------------------------------
kSystemTimeZones[80] =
new SimpleTimeZone(-4*kMillisPerHour, "America/Halifax" /*A%sT*/,
Calendar::APRIL, 1, -Calendar::SUNDAY /*DOW>=DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Halifax 1962 max - Oct lastSun 2:00 0 S
// Rule Halifax 1987 max - Apr Sun>=1 2:00 1:00 D
// America/Halifax ?(CA) -4:00 Halifax A%sT
//----------------------------------------------------------
kSystemTimeZones[81] =
new SimpleTimeZone(-4*kMillisPerHour, "Atlantic/Stanley" /*FK%sT*/,
Calendar::SEPTEMBER, 8, -Calendar::SUNDAY /*DOW>=DOM*/, 0*kMillisPerHour,
Calendar::APRIL, 16, -Calendar::SUNDAY /*DOW>=DOM*/, 0*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Falk 1986 max - Apr Sun>=16 0:00 0 -
// Rule Falk 1996 max - Sep Sun>=8 0:00 1:00 S
// Atlantic/Stanley Falklands(FK) -4:00 Falk FK%sT
//----------------------------------------------------------
kSystemTimeZones[82] =
new SimpleTimeZone(-4*kMillisPerHour, "America/Thule" /*A%sT*/,
Calendar::APRIL, 1, -Calendar::SUNDAY /*DOW>=DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Thule 1993 max - Apr Sun>=1 2:00 1:00 D
// Rule Thule 1993 max - Oct lastSun 2:00 0 S
// America/Thule ?(GL) -4:00 Thule A%sT
//----------------------------------------------------------
kSystemTimeZones[83] =
new SimpleTimeZone(-4*kMillisPerHour, "America/Asuncion" /*PY%sT*/,
Calendar::OCTOBER, 1, 0 /*DOM*/, 0*kMillisPerHour,
Calendar::MARCH, 1, 0 /*DOM*/, 0*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Para 1996 max - Mar 1 0:00 0 -
// Rule Para 1997 max - Oct 1 0:00 1:00 S
// America/Asuncion Paraguay(PY) -4:00 Para PY%sT
//----------------------------------------------------------
kSystemTimeZones[84] =
new SimpleTimeZone(-4*kMillisPerHour, "America/Santiago" /*CL%sT*/,
Calendar::OCTOBER, 9, -Calendar::SUNDAY /*DOW>=DOM*/, 0*kMillisPerHour,
Calendar::MARCH, 9, -Calendar::SUNDAY /*DOW>=DOM*/, 0*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Chile 1969 max - Oct Sun>=9 0:00 1:00 S
// Rule Chile 1970 max - Mar Sun>=9 0:00 0 -
// America/Santiago Chile(CL) -4:00 Chile CL%sT
//----------------------------------------------------------
kSystemTimeZones[85] =
new SimpleTimeZone((int32_t)(-3.5*kMillisPerHour), "America/St_Johns" /*N%sT*/,
Calendar::APRIL, 1, -Calendar::SUNDAY /*DOW>=DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule StJohns 1960 max - Oct lastSun 2:00 0 S
// Rule StJohns 1989 max - Apr Sun>=1 2:00 1:00 D
// America/St_Johns Canada(CA) -3:30 StJohns N%sT
kSystemTimeZones[86] =
new SimpleTimeZone(-3*kMillisPerHour, "America/Fortaleza" /*EST*/);
// America/Fortaleza Brazil(BR) -3:00 - EST
//----------------------------------------------------------
kSystemTimeZones[87] =
new SimpleTimeZone(-3*kMillisPerHour, "America/Cayenne" /*GFT*/);
// America/Cayenne French Guiana(GF) -3:00 - GFT
//----------------------------------------------------------
kSystemTimeZones[88] =
new SimpleTimeZone(-3*kMillisPerHour, "America/Paramaribo" /*SRT*/);
// America/Paramaribo Suriname(SR) -3:00 - SRT
//----------------------------------------------------------
kSystemTimeZones[89] =
new SimpleTimeZone(-3*kMillisPerHour, "America/Montevideo" /*UY%sT*/);
// America/Montevideo Uruguay(UY) -3:00 - UY%sT
//----------------------------------------------------------
kSystemTimeZones[90] =
new SimpleTimeZone(-3*kMillisPerHour, "America/Buenos_Aires" /*AR%sT*/);
// America/Buenos_Aires Argentina(AR) -3:00 - AR%sT
kSystemTimeZones[91] =
new SimpleTimeZone(-3*kMillisPerHour, "AGT" /*alias for America/Buenos_Aires*/);
//----------------------------------------------------------
kSystemTimeZones[92] =
new SimpleTimeZone(-3*kMillisPerHour, "America/Godthab" /*WG%sT*/,
Calendar::MARCH, -1, Calendar::SATURDAY /*DOW_IN_DOM*/, 22*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SATURDAY /*DOW_IN_DOM*/, 22*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
// Rule EU 1996 max - Oct lastSun 1:00u 0 -
// America/Godthab ?(GL) -3:00 EU WG%sT
//----------------------------------------------------------
kSystemTimeZones[93] =
new SimpleTimeZone(-3*kMillisPerHour, "America/Miquelon" /*PM%sT*/,
Calendar::APRIL, 1, -Calendar::SUNDAY /*DOW>=DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Mont 1957 max - Oct lastSun 2:00 0 S
// Rule Mont 1987 max - Apr Sun>=1 2:00 1:00 D
// America/Miquelon St Pierre and Miquelon(PM) -3:00 Mont PM%sT # Pierre & Miquelon Time
//----------------------------------------------------------
kSystemTimeZones[94] =
new SimpleTimeZone(-3*kMillisPerHour, "America/Sao_Paulo" /*E%sT*/,
Calendar::OCTOBER, 1, -Calendar::SUNDAY /*DOW>=DOM*/, 0*kMillisPerHour,
Calendar::FEBRUARY, 11, -Calendar::SUNDAY /*DOW>=DOM*/, 0*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Brazil 1998 max - Oct Sun>=1 0:00 1:00 D
// Rule Brazil 1999 max - Feb Sun>=11 0:00 0 S
// America/Sao_Paulo Brazil(BR) -3:00 Brazil E%sT
kSystemTimeZones[95] =
new SimpleTimeZone(-3*kMillisPerHour, "BET" /*alias for America/Sao_Paulo*/,
Calendar::OCTOBER, 1, -Calendar::SUNDAY /*DOW>=DOM*/, 0*kMillisPerHour,
Calendar::FEBRUARY, 11, -Calendar::SUNDAY /*DOW>=DOM*/, 0*kMillisPerHour, 1*kMillisPerHour,fgStatus);
//----------------------------------------------------------
kSystemTimeZones[96] =
new SimpleTimeZone(-2*kMillisPerHour, "America/Noronha" /*FST*/);
// America/Noronha Brazil(BR) -2:00 - FST
//----------------------------------------------------------
kSystemTimeZones[97] =
new SimpleTimeZone(-2*kMillisPerHour, "Atlantic/South_Georgia" /*GST*/);
// Atlantic/South_Georgia South Georgia(GS) -2:00 - GST # South Georgia Time
//----------------------------------------------------------
kSystemTimeZones[98] =
new SimpleTimeZone(-1*kMillisPerHour, "Atlantic/Jan_Mayen" /*EGT*/);
// Atlantic/Jan_Mayen ?(NO) -1:00 - EGT
//----------------------------------------------------------
kSystemTimeZones[99] =
new SimpleTimeZone(-1*kMillisPerHour, "Atlantic/Cape_Verde" /*CVT*/);
// Atlantic/Cape_Verde Cape Verde(CV) -1:00 - CVT
//----------------------------------------------------------
kSystemTimeZones[100] =
new SimpleTimeZone(-1*kMillisPerHour, "America/Scoresbysund" /*EG%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 0*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 0*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
// Rule EU 1996 max - Oct lastSun 1:00u 0 -
// America/Scoresbysund ?(GL) -1:00 EU EG%sT
//----------------------------------------------------------
kSystemTimeZones[101] =
new SimpleTimeZone(-1*kMillisPerHour, "Atlantic/Azores" /*AZO%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 0*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 0*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
// Rule EU 1996 max - Oct lastSun 1:00u 0 -
// Atlantic/Azores Portugal(PT) -1:00 EU AZO%sT
//----------------------------------------------------------
kSystemTimeZones[102] =
new SimpleTimeZone(0*kMillisPerHour, "Africa/Ouagadougou" /*GMT*/);
// Africa/Ouagadougou Burkina Faso(BF) 0:00 - GMT
//----------------------------------------------------------
kSystemTimeZones[103] =
new SimpleTimeZone(0*kMillisPerHour, "Africa/Abidjan" /*GMT*/);
// Africa/Abidjan Cote D'Ivoire(CI) 0:00 - GMT
//----------------------------------------------------------
kSystemTimeZones[104] =
new SimpleTimeZone(0*kMillisPerHour, "Africa/Accra" /*%s*/);
// Africa/Accra Ghana(GH) 0:00 - %s
//----------------------------------------------------------
kSystemTimeZones[105] =
new SimpleTimeZone(0*kMillisPerHour, "Africa/Banjul" /*GMT*/);
// Africa/Banjul Gambia(GM) 0:00 - GMT
//----------------------------------------------------------
kSystemTimeZones[106] =
new SimpleTimeZone(0*kMillisPerHour, "Africa/Conakry" /*GMT*/);
// Africa/Conakry Guinea(GN) 0:00 - GMT
//----------------------------------------------------------
kSystemTimeZones[107] =
new SimpleTimeZone(0*kMillisPerHour, "Africa/Bissau" /*GMT*/);
// Africa/Bissau Guinea-Bissau(GW) 0:00 - GMT
//----------------------------------------------------------
kSystemTimeZones[108] =
new SimpleTimeZone(0*kMillisPerHour, "Atlantic/Reykjavik" /*GMT*/);
// Atlantic/Reykjavik Iceland(IS) 0:00 - GMT
//----------------------------------------------------------
kSystemTimeZones[109] =
new SimpleTimeZone(0*kMillisPerHour, "Africa/Monrovia" /*GMT*/);
// Africa/Monrovia Liberia(LR) 0:00 - GMT
//----------------------------------------------------------
kSystemTimeZones[110] =
new SimpleTimeZone(0*kMillisPerHour, "Africa/Casablanca" /*WET*/);
// Africa/Casablanca Morocco(MA) 0:00 - WET
//----------------------------------------------------------
kSystemTimeZones[111] =
new SimpleTimeZone(0*kMillisPerHour, "Africa/Timbuktu" /*GMT*/);
// Africa/Timbuktu Mali(ML) 0:00 - GMT
//----------------------------------------------------------
kSystemTimeZones[112] =
new SimpleTimeZone(0*kMillisPerHour, "Africa/Nouakchott" /*GMT*/);
// Africa/Nouakchott Mauritania(MR) 0:00 - GMT
//----------------------------------------------------------
kSystemTimeZones[113] =
new SimpleTimeZone(0*kMillisPerHour, "Atlantic/St_Helena" /*GMT*/);
// Atlantic/St_Helena St Helena(SH) 0:00 - GMT
//----------------------------------------------------------
kSystemTimeZones[114] =
new SimpleTimeZone(0*kMillisPerHour, "Africa/Freetown" /*%s*/);
// Africa/Freetown Sierra Leone(SL) 0:00 - %s
//----------------------------------------------------------
kSystemTimeZones[115] =
new SimpleTimeZone(0*kMillisPerHour, "Africa/Dakar" /*GMT*/);
// Africa/Dakar Senegal(SN) 0:00 - GMT
//----------------------------------------------------------
kSystemTimeZones[116] =
new SimpleTimeZone(0*kMillisPerHour, "Africa/Sao_Tome" /*GMT*/);
// Africa/Sao_Tome Sao Tome and Principe(ST) 0:00 - GMT
//----------------------------------------------------------
kSystemTimeZones[117] =
new SimpleTimeZone(0*kMillisPerHour, "Africa/Lome" /*GMT*/);
// Africa/Lome Togo(TG) 0:00 - GMT
//----------------------------------------------------------
kSystemTimeZones[118] =
new SimpleTimeZone(0*kMillisPerHour, "GMT" /*GMT*/);
// GMT -(-) 0:00 - GMT
kSystemTimeZones[119] =
new SimpleTimeZone(0*kMillisPerHour, "UTC" /*alias for GMT*/);
//----------------------------------------------------------
kSystemTimeZones[120] =
new SimpleTimeZone(0*kMillisPerHour, "Atlantic/Faeroe" /*WE%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 1*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 1*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
// Rule EU 1996 max - Oct lastSun 1:00u 0 -
// Atlantic/Faeroe Denmark, Faeroe Islands, and Greenland(DK) 0:00 EU WE%sT
//----------------------------------------------------------
kSystemTimeZones[121] =
new SimpleTimeZone(0*kMillisPerHour, "Atlantic/Canary" /*WE%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 1*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 1*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
// Rule EU 1996 max - Oct lastSun 1:00u 0 -
// Atlantic/Canary Spain(ES) 0:00 EU WE%sT
//----------------------------------------------------------
kSystemTimeZones[122] =
new SimpleTimeZone(0*kMillisPerHour, "Europe/Dublin" /*GMT/IST*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 1*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 1*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
// Rule EU 1996 max - Oct lastSun 1:00u 0 -
// Europe/Dublin ---(IE) 0:00 EU GMT/IST
//----------------------------------------------------------
kSystemTimeZones[123] =
new SimpleTimeZone(0*kMillisPerHour, "Europe/Lisbon" /*WE%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 1*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 1*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
// Rule EU 1996 max - Oct lastSun 1:00u 0 -
// Europe/Lisbon Portugal(PT) 0:00 EU WE%sT
//----------------------------------------------------------
kSystemTimeZones[124] =
new SimpleTimeZone(0*kMillisPerHour, "Europe/London" /*GMT/BST*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 1*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 1*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
// Rule EU 1996 max - Oct lastSun 1:00u 0 -
// Europe/London ---(GB) 0:00 EU GMT/BST
//----------------------------------------------------------
kSystemTimeZones[125] =
new SimpleTimeZone(1*kMillisPerHour, "Africa/Luanda" /*WAT*/);
// Africa/Luanda Angola(AO) 1:00 - WAT
//----------------------------------------------------------
kSystemTimeZones[126] =
new SimpleTimeZone(1*kMillisPerHour, "Africa/Porto-Novo" /*WAT*/);
// Africa/Porto-Novo Benin(BJ) 1:00 - WAT
//----------------------------------------------------------
kSystemTimeZones[127] =
new SimpleTimeZone(1*kMillisPerHour, "Africa/Bangui" /*WAT*/);
// Africa/Bangui Central African Republic(CF) 1:00 - WAT
//----------------------------------------------------------
kSystemTimeZones[128] =
new SimpleTimeZone(1*kMillisPerHour, "Africa/Kinshasa" /*WAT*/);
// Africa/Kinshasa Democratic Republic of Congo(CG) 1:00 - WAT
//----------------------------------------------------------
kSystemTimeZones[129] =
new SimpleTimeZone(1*kMillisPerHour, "Africa/Douala" /*WAT*/);
// Africa/Douala Cameroon(CM) 1:00 - WAT
//----------------------------------------------------------
kSystemTimeZones[130] =
new SimpleTimeZone(1*kMillisPerHour, "Africa/Libreville" /*WAT*/);
// Africa/Libreville Gabon(GA) 1:00 - WAT
//----------------------------------------------------------
kSystemTimeZones[131] =
new SimpleTimeZone(1*kMillisPerHour, "Africa/Malabo" /*WAT*/);
// Africa/Malabo Equatorial Guinea(GQ) 1:00 - WAT
//----------------------------------------------------------
kSystemTimeZones[132] =
new SimpleTimeZone(1*kMillisPerHour, "Africa/Niamey" /*WAT*/);
// Africa/Niamey Niger(NE) 1:00 - WAT
//----------------------------------------------------------
kSystemTimeZones[133] =
new SimpleTimeZone(1*kMillisPerHour, "Africa/Lagos" /*WAT*/);
// Africa/Lagos Nigeria(NG) 1:00 - WAT
//----------------------------------------------------------
kSystemTimeZones[134] =
new SimpleTimeZone(1*kMillisPerHour, "Africa/Ndjamena" /*WAT*/);
// Africa/Ndjamena Chad(TD) 1:00 - WAT
//----------------------------------------------------------
kSystemTimeZones[135] =
new SimpleTimeZone(1*kMillisPerHour, "Africa/Tunis" /*CE%sT*/);
// Africa/Tunis Tunisia(TN) 1:00 - CE%sT
//----------------------------------------------------------
kSystemTimeZones[136] =
new SimpleTimeZone(1*kMillisPerHour, "Africa/Algiers" /*CET*/);
// Africa/Algiers Algeria(DZ) 1:00 - CET
//----------------------------------------------------------
kSystemTimeZones[137] =
new SimpleTimeZone(1*kMillisPerHour, "Europe/Andorra" /*CE%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
// Rule EU 1996 max - Oct lastSun 1:00u 0 -
// Europe/Andorra Andorra(AD) 1:00 EU CE%sT
//----------------------------------------------------------
kSystemTimeZones[138] =
new SimpleTimeZone(1*kMillisPerHour, "Europe/Tirane" /*CE%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
// Rule EU 1996 max - Oct lastSun 1:00u 0 -
// Europe/Tirane Albania(AL) 1:00 EU CE%sT
//----------------------------------------------------------
kSystemTimeZones[139] =
new SimpleTimeZone(1*kMillisPerHour, "Europe/Vienna" /*CE%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
// Rule EU 1996 max - Oct lastSun 1:00u 0 -
// Europe/Vienna Austria(AT) 1:00 EU CE%sT
//----------------------------------------------------------
kSystemTimeZones[140] =
new SimpleTimeZone(1*kMillisPerHour, "Europe/Brussels" /*CE%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
// Rule EU 1996 max - Oct lastSun 1:00u 0 -
// Europe/Brussels Belgium(BE) 1:00 EU CE%sT
//----------------------------------------------------------
kSystemTimeZones[141] =
new SimpleTimeZone(1*kMillisPerHour, "Europe/Zurich" /*CE%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
// Rule EU 1996 max - Oct lastSun 1:00u 0 -
// Europe/Zurich Switzerland(CH) 1:00 EU CE%sT
//----------------------------------------------------------
kSystemTimeZones[142] =
new SimpleTimeZone(1*kMillisPerHour, "Europe/Prague" /*CE%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
// Rule EU 1996 max - Oct lastSun 1:00u 0 -
// Europe/Prague Czech Republic(CZ) 1:00 EU CE%sT
//----------------------------------------------------------
kSystemTimeZones[143] =
new SimpleTimeZone(1*kMillisPerHour, "Europe/Berlin" /*CE%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
// Rule EU 1996 max - Oct lastSun 1:00u 0 -
// Europe/Berlin Germany(DE) 1:00 EU CE%sT
//----------------------------------------------------------
kSystemTimeZones[144] =
new SimpleTimeZone(1*kMillisPerHour, "Europe/Copenhagen" /*CE%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
// Rule EU 1996 max - Oct lastSun 1:00u 0 -
// Europe/Copenhagen Denmark, Faeroe Islands, and Greenland(DK) 1:00 EU CE%sT
//----------------------------------------------------------
kSystemTimeZones[145] =
new SimpleTimeZone(1*kMillisPerHour, "Europe/Madrid" /*CE%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
// Rule EU 1996 max - Oct lastSun 1:00u 0 -
// Europe/Madrid Spain(ES) 1:00 EU CE%sT
//----------------------------------------------------------
kSystemTimeZones[146] =
new SimpleTimeZone(1*kMillisPerHour, "Europe/Gibraltar" /*CE%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
// Rule EU 1996 max - Oct lastSun 1:00u 0 -
// Europe/Gibraltar Gibraltar(GI) 1:00 EU CE%sT
//----------------------------------------------------------
kSystemTimeZones[147] =
new SimpleTimeZone(1*kMillisPerHour, "Europe/Budapest" /*CE%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
// Rule EU 1996 max - Oct lastSun 1:00u 0 -
// Europe/Budapest Hungary(HU) 1:00 EU CE%sT
//----------------------------------------------------------
kSystemTimeZones[148] =
new SimpleTimeZone(1*kMillisPerHour, "Europe/Rome" /*CE%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
// Rule EU 1996 max - Oct lastSun 1:00u 0 -
// Europe/Rome Italy(IT) 1:00 EU CE%sT
//----------------------------------------------------------
kSystemTimeZones[149] =
new SimpleTimeZone(1*kMillisPerHour, "Europe/Vaduz" /*CE%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
// Rule EU 1996 max - Oct lastSun 1:00u 0 -
// Europe/Vaduz Liechtenstein(LI) 1:00 EU CE%sT
//----------------------------------------------------------
kSystemTimeZones[150] =
new SimpleTimeZone(1*kMillisPerHour, "Europe/Luxembourg" /*CE%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
// Rule EU 1996 max - Oct lastSun 1:00u 0 -
// Europe/Luxembourg Luxembourg(LU) 1:00 EU CE%sT
//----------------------------------------------------------
kSystemTimeZones[151] =
new SimpleTimeZone(1*kMillisPerHour, "Africa/Tripoli" /*CE%sT*/,
Calendar::MARCH, -1, Calendar::THURSDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, 1, -Calendar::THURSDAY /*DOW>=DOM*/, 3*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Libya 1997 max - Mar lastThu 2:00s 1:00 S
// Rule Libya 1997 max - Oct Thu>=1 2:00s 0 -
// Africa/Tripoli Libya(LY) 1:00 Libya CE%sT
//----------------------------------------------------------
kSystemTimeZones[152] =
new SimpleTimeZone(1*kMillisPerHour, "Europe/Monaco" /*CE%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
// Rule EU 1996 max - Oct lastSun 1:00u 0 -
// Europe/Monaco Monaco(MC) 1:00 EU CE%sT
//----------------------------------------------------------
kSystemTimeZones[153] =
new SimpleTimeZone(1*kMillisPerHour, "Europe/Malta" /*CE%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
// Rule EU 1996 max - Oct lastSun 1:00u 0 -
// Europe/Malta Malta(MT) 1:00 EU CE%sT
//----------------------------------------------------------
kSystemTimeZones[154] =
new SimpleTimeZone(1*kMillisPerHour, "Africa/Windhoek" /*WA%sT*/,
Calendar::SEPTEMBER, 1, -Calendar::SUNDAY /*DOW>=DOM*/, 2*kMillisPerHour,
Calendar::APRIL, 1, -Calendar::SUNDAY /*DOW>=DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Namibia 1994 max - Sep Sun>=1 2:00 1:00 S
// Rule Namibia 1995 max - Apr Sun>=1 2:00 0 -
// Africa/Windhoek Namibia(NA) 1:00 Namibia WA%sT
//----------------------------------------------------------
kSystemTimeZones[155] =
new SimpleTimeZone(1*kMillisPerHour, "Europe/Amsterdam" /*CE%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
// Rule EU 1996 max - Oct lastSun 1:00u 0 -
// Europe/Amsterdam Netherlands(NL) 1:00 EU CE%sT
//----------------------------------------------------------
kSystemTimeZones[156] =
new SimpleTimeZone(1*kMillisPerHour, "Europe/Oslo" /*CE%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
// Rule EU 1996 max - Oct lastSun 1:00u 0 -
// Europe/Oslo Norway(NO) 1:00 EU CE%sT
//----------------------------------------------------------
kSystemTimeZones[157] =
new SimpleTimeZone(1*kMillisPerHour, "Europe/Warsaw" /*CE%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 1*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule W-Eur 1981 max - Mar lastSun 1:00s 1:00 S
// Rule W-Eur 1996 max - Oct lastSun 1:00s 0 -
// Europe/Warsaw Poland(PL) 1:00 W-Eur CE%sT
//----------------------------------------------------------
kSystemTimeZones[158] =
new SimpleTimeZone(1*kMillisPerHour, "Europe/Stockholm" /*CE%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
// Rule EU 1996 max - Oct lastSun 1:00u 0 -
// Europe/Stockholm Sweden(SE) 1:00 EU CE%sT
//----------------------------------------------------------
kSystemTimeZones[159] =
new SimpleTimeZone(1*kMillisPerHour, "Europe/Belgrade" /*CE%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
// Rule EU 1996 max - Oct lastSun 1:00u 0 -
// Europe/Belgrade Yugoslavia(YU) 1:00 EU CE%sT
//----------------------------------------------------------
kSystemTimeZones[160] =
new SimpleTimeZone(1*kMillisPerHour, "Europe/Paris" /*CE%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
// Rule EU 1996 max - Oct lastSun 1:00u 0 -
// Europe/Paris France(FR) 1:00 EU CE%sT
kSystemTimeZones[161] =
new SimpleTimeZone(1*kMillisPerHour, "ECT" /*alias for Europe/Paris*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
//----------------------------------------------------------
kSystemTimeZones[162] =
new SimpleTimeZone(2*kMillisPerHour, "Africa/Bujumbura" /*CAT*/);
// Africa/Bujumbura Burundi(BI) 2:00 - CAT
//----------------------------------------------------------
kSystemTimeZones[163] =
new SimpleTimeZone(2*kMillisPerHour, "Africa/Gaborone" /*CAT*/);
// Africa/Gaborone Botswana(BW) 2:00 - CAT
//----------------------------------------------------------
kSystemTimeZones[164] =
new SimpleTimeZone(2*kMillisPerHour, "Africa/Lubumbashi" /*CAT*/);
// Africa/Lubumbashi Democratic Republic of Congo(CG) 2:00 - CAT
//----------------------------------------------------------
kSystemTimeZones[165] =
new SimpleTimeZone(2*kMillisPerHour, "Africa/Maseru" /*SAST*/);
// Africa/Maseru Lesotho(LS) 2:00 - SAST
//----------------------------------------------------------
kSystemTimeZones[166] =
new SimpleTimeZone(2*kMillisPerHour, "Africa/Blantyre" /*CAT*/);
// Africa/Blantyre Malawi(ML) 2:00 - CAT
//----------------------------------------------------------
kSystemTimeZones[167] =
new SimpleTimeZone(2*kMillisPerHour, "Africa/Maputo" /*CAT*/);
// Africa/Maputo Mozambique(MZ) 2:00 - CAT
//----------------------------------------------------------
kSystemTimeZones[168] =
new SimpleTimeZone(2*kMillisPerHour, "Africa/Kigali" /*CAT*/);
// Africa/Kigali Rwanda(RW) 2:00 - CAT
//----------------------------------------------------------
kSystemTimeZones[169] =
new SimpleTimeZone(2*kMillisPerHour, "Africa/Khartoum" /*CA%sT*/);
// Africa/Khartoum Sudan(SD) 2:00 - CA%sT
//----------------------------------------------------------
kSystemTimeZones[170] =
new SimpleTimeZone(2*kMillisPerHour, "Africa/Mbabane" /*SAST*/);
// Africa/Mbabane Swaziland(SZ) 2:00 - SAST
//----------------------------------------------------------
kSystemTimeZones[171] =
new SimpleTimeZone(2*kMillisPerHour, "Africa/Lusaka" /*CAT*/);
// Africa/Lusaka Zambia(ZM) 2:00 - CAT
//----------------------------------------------------------
kSystemTimeZones[172] =
new SimpleTimeZone(2*kMillisPerHour, "Africa/Harare" /*CAT*/);
// Africa/Harare Zimbabwe(ZW) 2:00 - CAT
kSystemTimeZones[173] =
new SimpleTimeZone(2*kMillisPerHour, "CAT" /*alias for Africa/Harare*/);
//----------------------------------------------------------
kSystemTimeZones[174] =
new SimpleTimeZone(2*kMillisPerHour, "Africa/Johannesburg" /*SAST*/);
// Africa/Johannesburg South Africa(ZA) 2:00 - SAST
//----------------------------------------------------------
kSystemTimeZones[175] =
new SimpleTimeZone(2*kMillisPerHour, "Europe/Sofia" /*EE%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 0*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 0*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule E-Eur 1981 max - Mar lastSun 0:00 1:00 S
// Rule E-Eur 1996 max - Oct lastSun 0:00 0 -
// Europe/Sofia Bulgaria(BG) 2:00 E-Eur EE%sT
//----------------------------------------------------------
kSystemTimeZones[176] =
new SimpleTimeZone(2*kMillisPerHour, "Europe/Minsk" /*EE%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 3*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Russia 1993 max - Mar lastSun 2:00s 1:00 S
// Rule Russia 1996 max - Oct lastSun 2:00s 0 -
// Europe/Minsk Belarus(BY) 2:00 Russia EE%sT
//----------------------------------------------------------
kSystemTimeZones[177] =
new SimpleTimeZone(2*kMillisPerHour, "Asia/Nicosia" /*EE%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 0*kMillisPerHour,
Calendar::SEPTEMBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 0*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Cyprus 1979 max - Sep lastSun 0:00 0 -
// Rule Cyprus 1981 max - Mar lastSun 0:00 1:00 S
// Asia/Nicosia Cyprus(CY) 2:00 Cyprus EE%sT
//----------------------------------------------------------
kSystemTimeZones[178] =
new SimpleTimeZone(2*kMillisPerHour, "Europe/Tallinn" /*EE%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 3*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule C-Eur 1981 max - Mar lastSun 2:00s 1:00 S
// Rule C-Eur 1996 max - Oct lastSun 2:00s 0 -
// Europe/Tallinn Estonia(EE) 2:00 C-Eur EE%sT
//----------------------------------------------------------
kSystemTimeZones[179] =
new SimpleTimeZone(2*kMillisPerHour, "Africa/Cairo" /*EE%sT*/,
Calendar::APRIL, -1, Calendar::FRIDAY /*DOW_IN_DOM*/, 1*kMillisPerHour,
Calendar::SEPTEMBER, -1, Calendar::FRIDAY /*DOW_IN_DOM*/, 3*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Egypt 1995 max - Apr lastFri 1:00 1:00 S
// Rule Egypt 1995 max - Sep lastFri 3:00 0 -
// Africa/Cairo Egypt(EG) 2:00 Egypt EE%sT
kSystemTimeZones[180] =
new SimpleTimeZone(2*kMillisPerHour, "ART" /*alias for Africa/Cairo*/,
Calendar::APRIL, -1, Calendar::FRIDAY /*DOW_IN_DOM*/, 1*kMillisPerHour,
Calendar::SEPTEMBER, -1, Calendar::FRIDAY /*DOW_IN_DOM*/, 3*kMillisPerHour, 1*kMillisPerHour,fgStatus);
//----------------------------------------------------------
kSystemTimeZones[181] =
new SimpleTimeZone(2*kMillisPerHour, "Europe/Helsinki" /*EE%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 3*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 3*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
// Rule EU 1996 max - Oct lastSun 1:00u 0 -
// Europe/Helsinki Finland(FI) 2:00 EU EE%sT
//----------------------------------------------------------
kSystemTimeZones[182] =
new SimpleTimeZone(2*kMillisPerHour, "Europe/Athens" /*EE%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 3*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 3*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
// Rule EU 1996 max - Oct lastSun 1:00u 0 -
// Europe/Athens Greece(GR) 2:00 EU EE%sT
//----------------------------------------------------------
kSystemTimeZones[183] =
new SimpleTimeZone(2*kMillisPerHour, "Asia/Jerusalem" /*I%sT*/,
Calendar::MARCH, 15, -Calendar::FRIDAY /*DOW>=DOM*/, 0*kMillisPerHour,
Calendar::SEPTEMBER, 1, -Calendar::SUNDAY /*DOW>=DOM*/, 0*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Zion 1999 max - Mar Fri>=15 0:00 1:00 D
// Rule Zion 1999 max - Sep Sun>=1 0:00 0 S
// Asia/Jerusalem Israel(IL) 2:00 Zion I%sT
//----------------------------------------------------------
kSystemTimeZones[184] =
new SimpleTimeZone(2*kMillisPerHour, "Asia/Amman" /*EE%sT*/,
Calendar::APRIL, 1, -Calendar::FRIDAY /*DOW>=DOM*/, 0*kMillisPerHour,
Calendar::SEPTEMBER, 15, -Calendar::FRIDAY /*DOW>=DOM*/, 1*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Jordan 1993 max - Apr Fri>=1 0:00 1:00 S
// Rule Jordan 1995 max - Sep Fri>=15 0:00s 0 -
// Asia/Amman Jordan(JO) 2:00 Jordan EE%sT
//----------------------------------------------------------
kSystemTimeZones[185] =
new SimpleTimeZone(2*kMillisPerHour, "Asia/Beirut" /*EE%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 0*kMillisPerHour,
Calendar::SEPTEMBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 0*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Lebanon 1993 max - Mar lastSun 0:00 1:00 S
// Rule Lebanon 1993 max - Sep lastSun 0:00 0 -
// Asia/Beirut Lebanon(LB) 2:00 Lebanon EE%sT
//----------------------------------------------------------
kSystemTimeZones[186] =
new SimpleTimeZone(2*kMillisPerHour, "Europe/Vilnius" /*EE%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 3*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule C-Eur 1981 max - Mar lastSun 2:00s 1:00 S
// Rule C-Eur 1996 max - Oct lastSun 2:00s 0 -
// Europe/Vilnius Lithuania(LT) 2:00 C-Eur EE%sT
//----------------------------------------------------------
kSystemTimeZones[187] =
new SimpleTimeZone(2*kMillisPerHour, "Europe/Riga" /*EE%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::SEPTEMBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 3*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Latvia 1992 max - Mar lastSun 2:00s 1:00 S
// Rule Latvia 1992 max - Sep lastSun 2:00s 0 -
// Europe/Riga Latvia(LV) 2:00 Latvia EE%sT
//----------------------------------------------------------
kSystemTimeZones[188] =
new SimpleTimeZone(2*kMillisPerHour, "Europe/Chisinau" /*EE%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 0*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 0*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule E-Eur 1981 max - Mar lastSun 0:00 1:00 S
// Rule E-Eur 1996 max - Oct lastSun 0:00 0 -
// Europe/Chisinau Moldova(MD) 2:00 E-Eur EE%sT
//----------------------------------------------------------
kSystemTimeZones[189] =
new SimpleTimeZone(2*kMillisPerHour, "Europe/Bucharest" /*EE%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 0*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 0*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule E-Eur 1981 max - Mar lastSun 0:00 1:00 S
// Rule E-Eur 1996 max - Oct lastSun 0:00 0 -
// Europe/Bucharest Romania(RO) 2:00 E-Eur EE%sT
//----------------------------------------------------------
kSystemTimeZones[190] =
new SimpleTimeZone(2*kMillisPerHour, "Asia/Damascus" /*EE%sT*/,
Calendar::APRIL, 1, 0 /*DOM*/, 0*kMillisPerHour,
Calendar::OCTOBER, 1, 0 /*DOM*/, 0*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Syria 1994 max - Apr 1 0:00 1:00 S
// Rule Syria 1994 max - Oct 1 0:00 0 -
// Asia/Damascus Syria(SY) 2:00 Syria EE%sT
//----------------------------------------------------------
kSystemTimeZones[191] =
new SimpleTimeZone(2*kMillisPerHour, "Europe/Kiev" /*EE%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 3*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 3*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
// Rule EU 1996 max - Oct lastSun 1:00u 0 -
// Europe/Kiev Ukraine(UA) 2:00 EU EE%sT
//----------------------------------------------------------
kSystemTimeZones[192] =
new SimpleTimeZone(2*kMillisPerHour, "Europe/Istanbul" /*EE%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 3*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 3*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
// Rule EU 1996 max - Oct lastSun 1:00u 0 -
// Europe/Istanbul Turkey(TR) 2:00 EU EE%sT
kSystemTimeZones[193] =
new SimpleTimeZone(2*kMillisPerHour, "EET" /*alias for Europe/Istanbul*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 3*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 3*kMillisPerHour, 1*kMillisPerHour,fgStatus);
//----------------------------------------------------------
kSystemTimeZones[194] =
new SimpleTimeZone(3*kMillisPerHour, "Asia/Bahrain" /*AST*/);
// Asia/Bahrain Bahrain(BH) 3:00 - AST
//----------------------------------------------------------
kSystemTimeZones[195] =
new SimpleTimeZone(3*kMillisPerHour, "Africa/Djibouti" /*EAT*/);
// Africa/Djibouti Djibouti(DJ) 3:00 - EAT
//----------------------------------------------------------
kSystemTimeZones[196] =
new SimpleTimeZone(3*kMillisPerHour, "Africa/Asmera" /*EAT*/);
// Africa/Asmera Eritrea(ER) 3:00 - EAT
//----------------------------------------------------------
kSystemTimeZones[197] =
new SimpleTimeZone(3*kMillisPerHour, "Africa/Addis_Ababa" /*EAT*/);
// Africa/Addis_Ababa Ethiopia(ET) 3:00 - EAT
kSystemTimeZones[198] =
new SimpleTimeZone(3*kMillisPerHour, "EAT" /*alias for Africa/Addis_Ababa*/);
//----------------------------------------------------------
kSystemTimeZones[199] =
new SimpleTimeZone(3*kMillisPerHour, "Africa/Nairobi" /*EAT*/);
// Africa/Nairobi Kenya(KE) 3:00 - EAT
//----------------------------------------------------------
kSystemTimeZones[200] =
new SimpleTimeZone(3*kMillisPerHour, "Indian/Comoro" /*EAT*/);
// Indian/Comoro Comoros(KM) 3:00 - EAT
//----------------------------------------------------------
kSystemTimeZones[201] =
new SimpleTimeZone(3*kMillisPerHour, "Asia/Kuwait" /*AST*/);
// Asia/Kuwait Kuwait(KW) 3:00 - AST
//----------------------------------------------------------
kSystemTimeZones[202] =
new SimpleTimeZone(3*kMillisPerHour, "Indian/Antananarivo" /*EAT*/);
// Indian/Antananarivo Madagascar(MK) 3:00 - EAT
//----------------------------------------------------------
kSystemTimeZones[203] =
new SimpleTimeZone(3*kMillisPerHour, "Asia/Qatar" /*AST*/);
// Asia/Qatar Qatar(QA) 3:00 - AST
//----------------------------------------------------------
kSystemTimeZones[204] =
new SimpleTimeZone(3*kMillisPerHour, "Africa/Mogadishu" /*EAT*/);
// Africa/Mogadishu Somalia(SO) 3:00 - EAT
//----------------------------------------------------------
kSystemTimeZones[205] =
new SimpleTimeZone(3*kMillisPerHour, "Africa/Dar_es_Salaam" /*EAT*/);
// Africa/Dar_es_Salaam Tanzania(TZ) 3:00 - EAT
//----------------------------------------------------------
kSystemTimeZones[206] =
new SimpleTimeZone(3*kMillisPerHour, "Africa/Kampala" /*EAT*/);
// Africa/Kampala Uganda(UG) 3:00 - EAT
//----------------------------------------------------------
kSystemTimeZones[207] =
new SimpleTimeZone(3*kMillisPerHour, "Asia/Aden" /*AST*/);
// Asia/Aden Yemen(YE) 3:00 - AST
//----------------------------------------------------------
kSystemTimeZones[208] =
new SimpleTimeZone(3*kMillisPerHour, "Indian/Mayotte" /*EAT*/);
// Indian/Mayotte Mayotte(YT) 3:00 - EAT
//----------------------------------------------------------
kSystemTimeZones[209] =
new SimpleTimeZone(3*kMillisPerHour, "Asia/Riyadh" /*AST*/);
// Asia/Riyadh Saudi Arabia(SA) 3:00 - AST
//----------------------------------------------------------
kSystemTimeZones[210] =
new SimpleTimeZone(3*kMillisPerHour, "Asia/Baghdad" /*A%sT*/,
Calendar::APRIL, 1, 0 /*DOM*/, 3*kMillisPerHour,
Calendar::OCTOBER, 1, 0 /*DOM*/, 4*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Iraq 1991 max - Apr 1 3:00s 1:00 D
// Rule Iraq 1991 max - Oct 1 3:00s 0 D
// Asia/Baghdad Iraq(IQ) 3:00 Iraq A%sT
//----------------------------------------------------------
kSystemTimeZones[211] =
new SimpleTimeZone(3*kMillisPerHour, "Europe/Simferopol" /*MSK/MSD*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 3*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 3*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Crimea 1996 max - Mar lastSun 0:00u 1:00 -
// Rule Crimea 1996 max - Oct lastSun 0:00u 0 -
// Europe/Simferopol Ukraine(UA) 3:00 Crimea MSK/MSD
//----------------------------------------------------------
kSystemTimeZones[212] =
new SimpleTimeZone(3*kMillisPerHour, "Europe/Moscow" /*MSK/MSD*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 3*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Russia 1993 max - Mar lastSun 2:00s 1:00 S
// Rule Russia 1996 max - Oct lastSun 2:00s 0 -
// Europe/Moscow Russia(RU) 3:00 Russia MSK/MSD
//----------------------------------------------------------
kSystemTimeZones[213] =
new SimpleTimeZone((int32_t)(3.5*kMillisPerHour), "Asia/Tehran" /*IR%sT*/,
Calendar::MARCH, 21, 0 /*DOM*/, 0*kMillisPerHour,
Calendar::SEPTEMBER, 23, 0 /*DOM*/, 0*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Iran 1997 1999 - Mar 21 0:00 1:00 S
// Rule Iran 1997 1999 - Sep 23 0:00 0 -
// Asia/Tehran Iran(IR) 3:30 Iran IR%sT
kSystemTimeZones[214] =
new SimpleTimeZone((int32_t)(3.5*kMillisPerHour), "MET" /*alias for Asia/Tehran*/,
Calendar::MARCH, 21, 0 /*DOM*/, 0*kMillisPerHour,
Calendar::SEPTEMBER, 23, 0 /*DOM*/, 0*kMillisPerHour, 1*kMillisPerHour,fgStatus);
//----------------------------------------------------------
kSystemTimeZones[215] =
new SimpleTimeZone(4*kMillisPerHour, "Asia/Dubai" /*GST*/);
// Asia/Dubai United Arab Emirates(AE) 4:00 - GST
//----------------------------------------------------------
kSystemTimeZones[216] =
new SimpleTimeZone(4*kMillisPerHour, "Indian/Mauritius" /*MUT*/);
// Indian/Mauritius Mauritius(MU) 4:00 - MUT # Mauritius Time
//----------------------------------------------------------
kSystemTimeZones[217] =
new SimpleTimeZone(4*kMillisPerHour, "Asia/Muscat" /*GST*/);
// Asia/Muscat Oman(OM) 4:00 - GST
//----------------------------------------------------------
kSystemTimeZones[218] =
new SimpleTimeZone(4*kMillisPerHour, "Indian/Reunion" /*RET*/);
// Indian/Reunion Reunion(RE) 4:00 - RET # Reunion Time
//----------------------------------------------------------
kSystemTimeZones[219] =
new SimpleTimeZone(4*kMillisPerHour, "Indian/Mahe" /*SCT*/);
// Indian/Mahe Seychelles(SC) 4:00 - SCT # Seychelles Time
//----------------------------------------------------------
kSystemTimeZones[220] =
new SimpleTimeZone(4*kMillisPerHour, "Asia/Yerevan" /*AM%sT*/);
// Asia/Yerevan Armenia(AM) 4:00 - AM%sT
kSystemTimeZones[221] =
new SimpleTimeZone(4*kMillisPerHour, "NET" /*alias for Asia/Yerevan*/);
//----------------------------------------------------------
kSystemTimeZones[222] =
new SimpleTimeZone(4*kMillisPerHour, "Asia/Baku" /*AZ%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 5*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 5*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule EUAsia 1981 max - Mar lastSun 1:00u 1:00 S
// Rule EUAsia 1996 max - Oct lastSun 1:00u 0 -
// Asia/Baku Azerbaijan(AZ) 4:00 EUAsia AZ%sT
//----------------------------------------------------------
kSystemTimeZones[223] =
new SimpleTimeZone(4*kMillisPerHour, "Asia/Aqtau" /*AQT%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 0*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 0*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule E-EurAsia 1981 max - Mar lastSun 0:00 1:00 S
// Rule E-EurAsia 1996 max - Oct lastSun 0:00 0 -
// Asia/Aqtau Kazakhstan(KZ) 4:00 E-EurAsia AQT%sT
//----------------------------------------------------------
kSystemTimeZones[224] =
new SimpleTimeZone(4*kMillisPerHour, "Europe/Samara" /*SAM%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 3*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Russia 1993 max - Mar lastSun 2:00s 1:00 S
// Rule Russia 1996 max - Oct lastSun 2:00s 0 -
// Europe/Samara Russia(RU) 4:00 Russia SAM%sT
//----------------------------------------------------------
kSystemTimeZones[225] =
new SimpleTimeZone((int32_t)(4.5*kMillisPerHour), "Asia/Kabul" /*AFT*/);
// Asia/Kabul Afghanistan(AF) 4:30 - AFT
//----------------------------------------------------------
kSystemTimeZones[226] =
new SimpleTimeZone(5*kMillisPerHour, "Indian/Kerguelen" /*TFT*/);
// Indian/Kerguelen France - year-round bases(FR) 5:00 - TFT # ISO code TF Time
//----------------------------------------------------------
kSystemTimeZones[227] =
new SimpleTimeZone(5*kMillisPerHour, "Asia/Tbilisi" /*GET*/);
// Asia/Tbilisi Georgia(GE) 5:00 - GET
//----------------------------------------------------------
kSystemTimeZones[228] =
new SimpleTimeZone(5*kMillisPerHour, "Indian/Chagos" /*IOT*/);
// Indian/Chagos British Indian Ocean Territory(IO) 5:00 - IOT # BIOT Time
//----------------------------------------------------------
kSystemTimeZones[229] =
new SimpleTimeZone(5*kMillisPerHour, "Indian/Maldives" /*MVT*/);
// Indian/Maldives Maldives(MV) 5:00 - MVT # Maldives Time
//----------------------------------------------------------
kSystemTimeZones[230] =
new SimpleTimeZone(5*kMillisPerHour, "Asia/Dushanbe" /*TJT*/);
// Asia/Dushanbe Tajikistan(TJ) 5:00 - TJT # Tajikistan Time
//----------------------------------------------------------
kSystemTimeZones[231] =
new SimpleTimeZone(5*kMillisPerHour, "Asia/Ashkhabad" /*TMT*/);
// Asia/Ashkhabad Turkmenistan(TM) 5:00 - TMT # Turkmenistan Time
//----------------------------------------------------------
kSystemTimeZones[232] =
new SimpleTimeZone(5*kMillisPerHour, "Asia/Tashkent" /*UZT*/);
// Asia/Tashkent Uzbekistan(UZ) 5:00 - UZT # Uzbekistan Time
//----------------------------------------------------------
kSystemTimeZones[233] =
new SimpleTimeZone(5*kMillisPerHour, "Asia/Karachi" /*PKT*/);
// Asia/Karachi Pakistan(PK) 5:00 - PKT # Pakistan Time
kSystemTimeZones[234] =
new SimpleTimeZone(5*kMillisPerHour, "PLT" /*alias for Asia/Karachi*/);
//----------------------------------------------------------
kSystemTimeZones[235] =
new SimpleTimeZone(5*kMillisPerHour, "Asia/Bishkek" /*KG%sT*/,
Calendar::APRIL, 7, -Calendar::SUNDAY /*DOW>=DOM*/, 0*kMillisPerHour,
Calendar::SEPTEMBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 0*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Kirgiz 1992 max - Apr Sun>=7 0:00 1:00 S
// Rule Kirgiz 1991 max - Sep lastSun 0:00 0 -
// Asia/Bishkek Kirgizstan(KG) 5:00 Kirgiz KG%sT # Kirgizstan Time
//----------------------------------------------------------
kSystemTimeZones[236] =
new SimpleTimeZone(5*kMillisPerHour, "Asia/Aqtobe" /*AQT%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 0*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 0*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule E-EurAsia 1981 max - Mar lastSun 0:00 1:00 S
// Rule E-EurAsia 1996 max - Oct lastSun 0:00 0 -
// Asia/Aqtobe Kazakhstan(KZ) 5:00 E-EurAsia AQT%sT
//----------------------------------------------------------
kSystemTimeZones[237] =
new SimpleTimeZone(5*kMillisPerHour, "Asia/Yekaterinburg" /*YEK%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 3*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Russia 1993 max - Mar lastSun 2:00s 1:00 S
// Rule Russia 1996 max - Oct lastSun 2:00s 0 -
// Asia/Yekaterinburg Russia(RU) 5:00 Russia YEK%sT # Yekaterinburg Time
//----------------------------------------------------------
kSystemTimeZones[238] =
new SimpleTimeZone((int32_t)(5.5*kMillisPerHour), "Asia/Calcutta" /*IST*/);
// Asia/Calcutta India(IN) 5:30 - IST
kSystemTimeZones[239] =
new SimpleTimeZone((int32_t)(5.5*kMillisPerHour), "IST" /*alias for Asia/Calcutta*/);
//----------------------------------------------------------
kSystemTimeZones[240] =
new SimpleTimeZone((int32_t)(5.75*kMillisPerHour), "Asia/Katmandu" /*NPT*/);
// Asia/Katmandu Nepal(NP) 5:45 - NPT # Nepal Time
//----------------------------------------------------------
kSystemTimeZones[241] =
new SimpleTimeZone(6*kMillisPerHour, "Antarctica/Mawson" /*MAWT*/);
// Antarctica/Mawson Australia - territories(AQ) 6:00 - MAWT # Mawson Time
//----------------------------------------------------------
kSystemTimeZones[242] =
new SimpleTimeZone(6*kMillisPerHour, "Asia/Colombo" /*LKT*/);
// Asia/Colombo Sri Lanka(LK) 6:00 - LKT
//----------------------------------------------------------
kSystemTimeZones[243] =
new SimpleTimeZone(6*kMillisPerHour, "Asia/Dacca" /*BDT*/);
// Asia/Dacca Bangladesh(BD) 6:00 - BDT # Bangladesh Time
kSystemTimeZones[244] =
new SimpleTimeZone(6*kMillisPerHour, "BST" /*alias for Asia/Dacca*/);
//----------------------------------------------------------
kSystemTimeZones[245] =
new SimpleTimeZone(6*kMillisPerHour, "Asia/Alma-Ata" /*ALM%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 0*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 0*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule E-EurAsia 1981 max - Mar lastSun 0:00 1:00 S
// Rule E-EurAsia 1996 max - Oct lastSun 0:00 0 -
// Asia/Alma-Ata Kazakhstan(KZ) 6:00 E-EurAsia ALM%sT
//----------------------------------------------------------
kSystemTimeZones[246] =
new SimpleTimeZone(6*kMillisPerHour, "Asia/Novosibirsk" /*NOV%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 3*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Russia 1993 max - Mar lastSun 2:00s 1:00 S
// Rule Russia 1996 max - Oct lastSun 2:00s 0 -
// Asia/Novosibirsk Russia(RU) 6:00 Russia NOV%sT
//----------------------------------------------------------
kSystemTimeZones[247] =
new SimpleTimeZone((int32_t)(6.5*kMillisPerHour), "Indian/Cocos" /*CCT*/);
// Indian/Cocos Cocos(CC) 6:30 - CCT # Cocos Islands Time
//----------------------------------------------------------
kSystemTimeZones[248] =
new SimpleTimeZone((int32_t)(6.5*kMillisPerHour), "Asia/Rangoon" /*MMT*/);
// Asia/Rangoon Burma / Myanmar(MM) 6:30 - MMT # Myanmar Time
//----------------------------------------------------------
kSystemTimeZones[249] =
new SimpleTimeZone(7*kMillisPerHour, "Indian/Christmas" /*CXT*/);
// Indian/Christmas Australian miscellany(AU) 7:00 - CXT # Christmas Island Time
//----------------------------------------------------------
kSystemTimeZones[250] =
new SimpleTimeZone(7*kMillisPerHour, "Asia/Jakarta" /*JAVT*/);
// Asia/Jakarta Indonesia(ID) 7:00 - JAVT
//----------------------------------------------------------
kSystemTimeZones[251] =
new SimpleTimeZone(7*kMillisPerHour, "Asia/Phnom_Penh" /*ICT*/);
// Asia/Phnom_Penh Cambodia(KH) 7:00 - ICT
//----------------------------------------------------------
kSystemTimeZones[252] =
new SimpleTimeZone(7*kMillisPerHour, "Asia/Vientiane" /*ICT*/);
// Asia/Vientiane Laos(LA) 7:00 - ICT
//----------------------------------------------------------
kSystemTimeZones[253] =
new SimpleTimeZone(7*kMillisPerHour, "Asia/Saigon" /*ICT*/);
// Asia/Saigon Vietnam(VN) 7:00 - ICT
kSystemTimeZones[254] =
new SimpleTimeZone(7*kMillisPerHour, "VST" /*alias for Asia/Saigon*/);
//----------------------------------------------------------
kSystemTimeZones[255] =
new SimpleTimeZone(7*kMillisPerHour, "Asia/Bangkok" /*ICT*/);
// Asia/Bangkok Thailand(TH) 7:00 - ICT
//----------------------------------------------------------
kSystemTimeZones[256] =
new SimpleTimeZone(7*kMillisPerHour, "Asia/Krasnoyarsk" /*KRA%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 3*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Russia 1993 max - Mar lastSun 2:00s 1:00 S
// Rule Russia 1996 max - Oct lastSun 2:00s 0 -
// Asia/Krasnoyarsk Russia(RU) 7:00 Russia KRA%sT
//----------------------------------------------------------
kSystemTimeZones[257] =
new SimpleTimeZone(8*kMillisPerHour, "Antarctica/Casey" /*WST*/);
// Antarctica/Casey Australia - territories(AQ) 8:00 - WST # Western (Aus) Standard Time
//----------------------------------------------------------
kSystemTimeZones[258] =
new SimpleTimeZone(8*kMillisPerHour, "Australia/Perth" /*WST*/);
// Australia/Perth Australia(AU) 8:00 - WST
//----------------------------------------------------------
kSystemTimeZones[259] =
new SimpleTimeZone(8*kMillisPerHour, "Asia/Brunei" /*BNT*/);
// Asia/Brunei Brunei(BN) 8:00 - BNT
//----------------------------------------------------------
kSystemTimeZones[260] =
new SimpleTimeZone(8*kMillisPerHour, "Asia/Hong_Kong" /*C%sT*/);
// Asia/Hong_Kong China(HK) 8:00 - C%sT
//----------------------------------------------------------
kSystemTimeZones[261] =
new SimpleTimeZone(8*kMillisPerHour, "Asia/Ujung_Pandang" /*BORT*/);
// Asia/Ujung_Pandang Indonesia(ID) 8:00 - BORT
//----------------------------------------------------------
kSystemTimeZones[262] =
new SimpleTimeZone(8*kMillisPerHour, "Asia/Ishigaki" /*CST*/);
// Asia/Ishigaki Japan(JP) 8:00 - CST
//----------------------------------------------------------
kSystemTimeZones[263] =
new SimpleTimeZone(8*kMillisPerHour, "Asia/Macao" /*C%sT*/);
// Asia/Macao Macao(MO) 8:00 - C%sT
//----------------------------------------------------------
kSystemTimeZones[264] =
new SimpleTimeZone(8*kMillisPerHour, "Asia/Kuala_Lumpur" /*MYT*/);
// Asia/Kuala_Lumpur Malaysia(MY) 8:00 - MYT # Malaysia Time
//----------------------------------------------------------
kSystemTimeZones[265] =
new SimpleTimeZone(8*kMillisPerHour, "Asia/Manila" /*PH%sT*/);
// Asia/Manila Philippines(PH) 8:00 - PH%sT
//----------------------------------------------------------
kSystemTimeZones[266] =
new SimpleTimeZone(8*kMillisPerHour, "Asia/Singapore" /*SGT*/);
// Asia/Singapore Singapore(SG) 8:00 - SGT
//----------------------------------------------------------
kSystemTimeZones[267] =
new SimpleTimeZone(8*kMillisPerHour, "Asia/Taipei" /*C%sT*/);
// Asia/Taipei Taiwan(TW) 8:00 - C%sT
//----------------------------------------------------------
kSystemTimeZones[268] =
new SimpleTimeZone(8*kMillisPerHour, "Asia/Shanghai" /*C%sT*/);
// Asia/Shanghai China(CN) 8:00 - C%sT
kSystemTimeZones[269] =
new SimpleTimeZone(8*kMillisPerHour, "CTT" /*alias for Asia/Shanghai*/);
//----------------------------------------------------------
kSystemTimeZones[270] =
new SimpleTimeZone(8*kMillisPerHour, "Asia/Ulan_Bator" /*ULA%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 0*kMillisPerHour,
Calendar::SEPTEMBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 0*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Mongol 1991 max - Mar lastSun 0:00 1:00 S
// Rule Mongol 1997 max - Sep lastSun 0:00 0 -
// Asia/Ulan_Bator Mongolia(MN) 8:00 Mongol ULA%sT
//----------------------------------------------------------
kSystemTimeZones[271] =
new SimpleTimeZone(8*kMillisPerHour, "Asia/Irkutsk" /*IRK%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 3*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Russia 1993 max - Mar lastSun 2:00s 1:00 S
// Rule Russia 1996 max - Oct lastSun 2:00s 0 -
// Asia/Irkutsk Russia(RU) 8:00 Russia IRK%sT
//----------------------------------------------------------
kSystemTimeZones[272] =
new SimpleTimeZone(9*kMillisPerHour, "Asia/Jayapura" /*JAYT*/);
// Asia/Jayapura Indonesia(ID) 9:00 - JAYT
//----------------------------------------------------------
kSystemTimeZones[273] =
new SimpleTimeZone(9*kMillisPerHour, "Asia/Pyongyang" /*KST*/);
// Asia/Pyongyang ?(KP) 9:00 - KST
//----------------------------------------------------------
kSystemTimeZones[274] =
new SimpleTimeZone(9*kMillisPerHour, "Asia/Seoul" /*K%sT*/);
// Asia/Seoul ?(KR) 9:00 - K%sT
//----------------------------------------------------------
kSystemTimeZones[275] =
new SimpleTimeZone(9*kMillisPerHour, "Pacific/Palau" /*PWT*/);
// Pacific/Palau Palau(PW) 9:00 - PWT # Palau Time
//----------------------------------------------------------
kSystemTimeZones[276] =
new SimpleTimeZone(9*kMillisPerHour, "Asia/Tokyo" /*JST*/);
// Asia/Tokyo Japan(JP) 9:00 - JST
kSystemTimeZones[277] =
new SimpleTimeZone(9*kMillisPerHour, "JST" /*alias for Asia/Tokyo*/);
//----------------------------------------------------------
kSystemTimeZones[278] =
new SimpleTimeZone(9*kMillisPerHour, "Asia/Yakutsk" /*YAK%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 3*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Russia 1993 max - Mar lastSun 2:00s 1:00 S
// Rule Russia 1996 max - Oct lastSun 2:00s 0 -
// Asia/Yakutsk Russia(RU) 9:00 Russia YAK%sT
//----------------------------------------------------------
kSystemTimeZones[279] =
new SimpleTimeZone((int32_t)(9.5*kMillisPerHour), "Australia/Darwin" /*CST*/);
// Australia/Darwin Australia(AU) 9:30 - CST
kSystemTimeZones[280] =
new SimpleTimeZone((int32_t)(9.5*kMillisPerHour), "ACT" /*alias for Australia/Darwin*/);
//----------------------------------------------------------
kSystemTimeZones[281] =
new SimpleTimeZone((int32_t)(9.5*kMillisPerHour), "Australia/Adelaide" /*CST*/,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 3*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule AS 1987 max - Oct lastSun 2:00s 1:00 -
// Rule AS 1995 max - Mar lastSun 2:00s 0 -
// Australia/Adelaide South Australia(AU) 9:30 AS CST
//----------------------------------------------------------
kSystemTimeZones[282] =
new SimpleTimeZone(10*kMillisPerHour, "Pacific/Truk" /*TRUT*/);
// Pacific/Truk Micronesia(FM) 10:00 - TRUT # Truk Time
//----------------------------------------------------------
kSystemTimeZones[283] =
new SimpleTimeZone(10*kMillisPerHour, "Pacific/Guam" /*GST*/);
// Pacific/Guam Guam(GU) 10:00 - GST
//----------------------------------------------------------
kSystemTimeZones[284] =
new SimpleTimeZone(10*kMillisPerHour, "Pacific/Saipan" /*MPT*/);
// Pacific/Saipan N Mariana Is(MP) 10:00 - MPT
//----------------------------------------------------------
kSystemTimeZones[285] =
new SimpleTimeZone(10*kMillisPerHour, "Pacific/Port_Moresby" /*PGT*/);
// Pacific/Port_Moresby Papua New Guinea(PG) 10:00 - PGT # Papua New Guinea Time
//----------------------------------------------------------
kSystemTimeZones[286] =
new SimpleTimeZone(10*kMillisPerHour, "Australia/Brisbane" /*EST*/);
// Australia/Brisbane Australia(AU) 10:00 - EST
//----------------------------------------------------------
kSystemTimeZones[287] =
new SimpleTimeZone(10*kMillisPerHour, "Asia/Vladivostok" /*VLA%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 3*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Russia 1993 max - Mar lastSun 2:00s 1:00 S
// Rule Russia 1996 max - Oct lastSun 2:00s 0 -
// Asia/Vladivostok Russia(RU) 10:00 Russia VLA%sT
//----------------------------------------------------------
kSystemTimeZones[288] =
new SimpleTimeZone(10*kMillisPerHour, "Australia/Sydney" /*EST*/,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 3*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule AN 1987 max - Oct lastSun 2:00s 1:00 -
// Rule AN 1996 max - Mar lastSun 2:00s 0 -
// Australia/Sydney New South Wales(AU) 10:00 AN EST
kSystemTimeZones[289] =
new SimpleTimeZone(10*kMillisPerHour, "AET" /*alias for Australia/Sydney*/,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 3*kMillisPerHour, 1*kMillisPerHour,fgStatus);
//----------------------------------------------------------
kSystemTimeZones[290] =
new SimpleTimeZone((int32_t)(10.5*kMillisPerHour), "Australia/Lord_Howe" /*LHST*/,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 3*kMillisPerHour, (int32_t)(0.5*kMillisPerHour),fgStatus);
// Rule LH 1987 max - Oct lastSun 2:00s 0:30 -
// Rule LH 1996 max - Mar lastSun 2:00s 0 -
// Australia/Lord_Howe Lord Howe Island(AU) 10:30 LH LHST
//----------------------------------------------------------
kSystemTimeZones[291] =
new SimpleTimeZone(11*kMillisPerHour, "Pacific/Ponape" /*PONT*/);
// Pacific/Ponape Micronesia(FM) 11:00 - PONT # Ponape Time
//----------------------------------------------------------
kSystemTimeZones[292] =
new SimpleTimeZone(11*kMillisPerHour, "Pacific/Efate" /*VU%sT*/);
// Pacific/Efate Vanuatu(VU) 11:00 - VU%sT # Vanuatu Time
//----------------------------------------------------------
kSystemTimeZones[293] =
new SimpleTimeZone(11*kMillisPerHour, "Pacific/Guadalcanal" /*SBT*/);
// Pacific/Guadalcanal Solomon Is(SB) 11:00 - SBT # Solomon Is Time
kSystemTimeZones[294] =
new SimpleTimeZone(11*kMillisPerHour, "SST" /*alias for Pacific/Guadalcanal*/);
//----------------------------------------------------------
kSystemTimeZones[295] =
new SimpleTimeZone(11*kMillisPerHour, "Pacific/Noumea" /*NC%sT*/,
Calendar::NOVEMBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::MARCH, 1, -Calendar::SUNDAY /*DOW>=DOM*/, 3*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule NC 1997 max - Mar Sun>=1 2:00s 0 -
// Rule NC 1997 max - Nov lastSun 2:00s 1:00 S
// Pacific/Noumea New Caledonia(NC) 11:00 NC NC%sT
//----------------------------------------------------------
kSystemTimeZones[296] =
new SimpleTimeZone(11*kMillisPerHour, "Asia/Magadan" /*MAG%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 3*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Russia 1993 max - Mar lastSun 2:00s 1:00 S
// Rule Russia 1996 max - Oct lastSun 2:00s 0 -
// Asia/Magadan Russia(RU) 11:00 Russia MAG%sT
//----------------------------------------------------------
kSystemTimeZones[297] =
new SimpleTimeZone((int32_t)(11.5*kMillisPerHour), "Pacific/Norfolk" /*NFT*/);
// Pacific/Norfolk Norfolk(NF) 11:30 - NFT # Norfolk Time
//----------------------------------------------------------
kSystemTimeZones[298] =
new SimpleTimeZone(12*kMillisPerHour, "Pacific/Kosrae" /*KOST*/);
// Pacific/Kosrae Micronesia(FM) 12:00 - KOST # Kosrae Time
//----------------------------------------------------------
kSystemTimeZones[299] =
new SimpleTimeZone(12*kMillisPerHour, "Pacific/Tarawa" /*GILT*/);
// Pacific/Tarawa Kiribati(KI) 12:00 - GILT # Gilbert Is Time
//----------------------------------------------------------
kSystemTimeZones[300] =
new SimpleTimeZone(12*kMillisPerHour, "Pacific/Majuro" /*MHT*/);
// Pacific/Majuro Marshall Is(MH) 12:00 - MHT
//----------------------------------------------------------
kSystemTimeZones[301] =
new SimpleTimeZone(12*kMillisPerHour, "Pacific/Nauru" /*NRT*/);
// Pacific/Nauru Nauru(NR) 12:00 - NRT
//----------------------------------------------------------
kSystemTimeZones[302] =
new SimpleTimeZone(12*kMillisPerHour, "Pacific/Funafuti" /*TVT*/);
// Pacific/Funafuti Tuvalu(TV) 12:00 - TVT # Tuvalu Time
//----------------------------------------------------------
kSystemTimeZones[303] =
new SimpleTimeZone(12*kMillisPerHour, "Pacific/Wake" /*WAKT*/);
// Pacific/Wake Wake(US) 12:00 - WAKT # Wake Time
//----------------------------------------------------------
kSystemTimeZones[304] =
new SimpleTimeZone(12*kMillisPerHour, "Pacific/Wallis" /*WFT*/);
// Pacific/Wallis Wallis and Futuna(WF) 12:00 - WFT # Wallis & Futuna Time
//----------------------------------------------------------
kSystemTimeZones[305] =
new SimpleTimeZone(12*kMillisPerHour, "Pacific/Fiji" /*FJT*/);
// Pacific/Fiji Fiji(FJ) 12:00 - FJT # Fiji Time
//----------------------------------------------------------
kSystemTimeZones[306] =
new SimpleTimeZone(12*kMillisPerHour, "Antarctica/McMurdo" /*NZ%sT*/,
Calendar::OCTOBER, 1, -Calendar::SUNDAY /*DOW>=DOM*/, 2*kMillisPerHour,
Calendar::MARCH, 15, -Calendar::SUNDAY /*DOW>=DOM*/, 3*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule NZAQ 1990 max - Oct Sun>=1 2:00s 1:00 D
// Rule NZAQ 1990 max - Mar Sun>=15 2:00s 0 S
// Antarctica/McMurdo USA - year-round bases(AQ) 12:00 NZAQ NZ%sT
//----------------------------------------------------------
kSystemTimeZones[307] =
new SimpleTimeZone(12*kMillisPerHour, "Asia/Kamchatka" /*PET%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 3*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Russia 1993 max - Mar lastSun 2:00s 1:00 S
// Rule Russia 1996 max - Oct lastSun 2:00s 0 -
// Asia/Kamchatka Russia(RU) 12:00 Russia PET%sT
//----------------------------------------------------------
kSystemTimeZones[308] =
new SimpleTimeZone(12*kMillisPerHour, "Pacific/Auckland" /*NZ%sT*/,
Calendar::OCTOBER, 1, -Calendar::SUNDAY /*DOW>=DOM*/, 2*kMillisPerHour,
Calendar::MARCH, 15, -Calendar::SUNDAY /*DOW>=DOM*/, 3*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule NZ 1990 max - Oct Sun>=1 2:00s 1:00 D
// Rule NZ 1990 max - Mar Sun>=15 2:00s 0 S
// Pacific/Auckland New Zealand(NZ) 12:00 NZ NZ%sT
kSystemTimeZones[309] =
new SimpleTimeZone(12*kMillisPerHour, "NST" /*alias for Pacific/Auckland*/,
Calendar::OCTOBER, 1, -Calendar::SUNDAY /*DOW>=DOM*/, 2*kMillisPerHour,
Calendar::MARCH, 15, -Calendar::SUNDAY /*DOW>=DOM*/, 3*kMillisPerHour, 1*kMillisPerHour,fgStatus);
//----------------------------------------------------------
kSystemTimeZones[310] =
new SimpleTimeZone((int32_t)(12.75*kMillisPerHour), "Pacific/Chatham" /*CHA%sT*/,
Calendar::OCTOBER, 1, -Calendar::SUNDAY /*DOW>=DOM*/, (int32_t)(2.75*kMillisPerHour),
Calendar::MARCH, 15, -Calendar::SUNDAY /*DOW>=DOM*/, (int32_t)(3.75*kMillisPerHour), 1*kMillisPerHour,fgStatus);
// Rule Chatham 1990 max - Oct Sun>=1 2:45s 1:00 D
// Rule Chatham 1991 max - Mar Sun>=15 2:45s 0 S
// Pacific/Chatham New Zealand(NZ) 12:45 Chatham CHA%sT
//----------------------------------------------------------
kSystemTimeZones[311] =
new SimpleTimeZone(13*kMillisPerHour, "Pacific/Enderbury" /*PHOT*/);
// Pacific/Enderbury Kiribati(KI) 13:00 - PHOT
//----------------------------------------------------------
kSystemTimeZones[312] =
new SimpleTimeZone(13*kMillisPerHour, "Pacific/Tongatapu" /*TOT*/);
// Pacific/Tongatapu Tonga(TO) 13:00 - TOT
//----------------------------------------------------------
kSystemTimeZones[313] =
new SimpleTimeZone(13*kMillisPerHour, "Asia/Anadyr" /*ANA%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 3*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Russia 1993 max - Mar lastSun 2:00s 1:00 S
// Rule Russia 1996 max - Oct lastSun 2:00s 0 -
// Asia/Anadyr Russia(RU) 13:00 Russia ANA%sT
//----------------------------------------------------------
kSystemTimeZones[314] =
new SimpleTimeZone(14*kMillisPerHour, "Pacific/Kiritimati" /*LINT*/);
// Pacific/Kiritimati Kiribati(KI) 14:00 - LINT
kSystemTimeZones[315] =
new SimpleTimeZone(-7*kMillisPerHour, "PNT" /*alias for America/Phoenix*/);
//----------------------------------------------------------
kSystemTimeZones[316] =
new SimpleTimeZone((int32_t)(-3.5*kMillisPerHour), "CNT" /*alias for America/St_Johns*/,
Calendar::APRIL, 1, -Calendar::SUNDAY /*DOW>=DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour, 1*kMillisPerHour,fgStatus);
//----------------------------------------------------------
kSystemTimeZones[317] =
new SimpleTimeZone(10*kMillisPerHour, "Antarctica/DumontDUrville" /*DDUT*/);
// Antarctica/DumontDUrville France - year-round bases(AQ) 10:00 - DDUT # Dumont-d'Urville Time
//----------------------------------------------------------
kSystemTimeZones[318] =
new SimpleTimeZone(2*kMillisPerHour, "Europe/Kaliningrad" /*EE%sT*/,
Calendar::MARCH, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 2*kMillisPerHour,
Calendar::OCTOBER, -1, Calendar::SUNDAY /*DOW_IN_DOM*/, 3*kMillisPerHour, 1*kMillisPerHour,fgStatus);
// Rule Russia 1993 max - Mar lastSun 2:00s 1:00 S
// Rule Russia 1996 max - Oct lastSun 2:00s 0 -
// Europe/Kaliningrad Russia(RU) 2:00 Russia EE%sT
//----------------------------------------------------------
kSystemTimeZones[319] =
new SimpleTimeZone(6*kMillisPerHour, "Asia/Thimbu" /*BTT*/);
// Asia/Thimbu Bhutan(BT) 6:00 - BTT # Bhutan Time
//----------------------------------------------------------
}
}
// ---------------- END GENERATED DATA ----------------
// *** clean up from definitions
#undef int
#undef kMillisPerHour
// *****************************************************************************
// class TimeZone
// *****************************************************************************
TimeZone::TimeZone()
{
}
// -------------------------------------
TimeZone::~TimeZone()
{
}
// -------------------------------------
TimeZone::TimeZone(const TimeZone &source)
: fID(source.fID)
{
}
// -------------------------------------
TimeZone &
TimeZone::operator=(const TimeZone &right)
{
if (this != &right) fID = right.fID;
return *this;
}
// -------------------------------------
bool_t
TimeZone::operator==(const TimeZone& that) const
{
return getDynamicClassID() == that.getDynamicClassID() &&
fID == that.fID;
}
// -------------------------------------
/**
* Return a reference to the static Hashtable of registered TimeZone
* objects. Performs initialization if necessary.
*
* This method is also responsible for initializing the array
* fgAvailableIDs and fgAvailableIDsCount.
*/
const UHashtable&
TimeZone::getHashtable()
{
if (kSystemInited == FALSE) {
initSystemTimeZones();
}
if (fgAvailableIDs == 0)
{
UHashtable *newHashtable;
int32_t newTimeZonesCount;
UnicodeString *newAvailableIds;
// build a hashtable that contains all the TimeZone objects in kSystemTimeZones
// and maps their IDs to the actual TimeZone objects (gives us fast lookup)
UErrorCode err = ZERO_ERROR;
newHashtable = uhash_open((UHashFunction) uhash_hashUString, &err);
uhash_setValueDeleter(newHashtable, TimeZone::deleteTimeZone);
newTimeZonesCount = kSystemTimeZonesCount;
newAvailableIds = new UnicodeString[newTimeZonesCount];
int32_t i;
for (i=0; i<kSystemTimeZonesCount; ++i)
{
SimpleTimeZone *tz = kSystemTimeZones[i];
uhash_putKey(newHashtable, (tz->getID(newAvailableIds[i])).hashCode() & 0x7FFFFFFF, tz , &err);
}
Mutex lock;
// We must recheck fgHashtable for correct locking
if (fgHashtable == 0)
{
fgHashtable = newHashtable;
fgAvailableIDsCount = newTimeZonesCount;
fgAvailableIDs = newAvailableIds;
}
else
{
uhash_close(newHashtable);
delete [] newAvailableIds;
}
}
return *fgHashtable;
}
// -------------------------------------
/**
* Convert a non-localized string to an integer using a system function.
* Return a failing UErrorCode status if all characters are not parsed.
*/
/*int32_t
TimeZone::stringToInteger(const UnicodeString& string, UErrorCode& status)
{
if (FAILURE(status)) return 0;
int32_t len = string.size();
char *number = new char[1 + len];
if (number == 0) { status = MEMORY_ALLOCATION_ERROR; return 0; }
char *end;
string.extract(0, len, number);
number[len] = 0;
int32_t value = strtol(number, &end, 10); // Radix 10
delete[] number;
if (end-number != len || len == 0)
status = INVALID_FORMAT_ERROR;
return value;
}*/
// -------------------------------------
TimeZone*
TimeZone::createTimeZone(const UnicodeString& ID)
{
if (kSystemInited == FALSE) {
initSystemTimeZones();
}
/* We first try to lookup the zone ID in our hashtable. If this fails,
* we try to parse it as a custom string GMT[+-]hh:mm. This allows us
* to recognize zones in user.timezone that otherwise cannot be
* identified. We do the recognition here, rather than in getDefault(),
* so that the default zone is always the result of calling
* getTimeZone() with the property user.timezone.
*
* If all else fails, we return GMT, which is probably not what the user
* wants, but at least is a functioning TimeZone object. */
TimeZone* result = NULL;
UHashtable h = getHashtable();
result = (TimeZone*)uhash_get(&h, ID.hashCode() & 0x7FFFFFFF);
if(result != NULL)
return result->clone();
// result == NULL
result = createCustomTimeZone(ID);
if(result == NULL)
result = GMT->clone();
return result;
}
// -------------------------------------
void
TimeZone::initDefault()
{
if (kSystemInited == FALSE) {
initSystemTimeZones();
}
// This function is called by createDefault() and adoptDefault() to initialize
// fgDefaultZone from the system default time zone. If fgDefaultZone is already
// filled in, we obviously don't have to do anything.
if (fgDefaultZone == NULL)
{
// We access system timezone data through TPlatformUtilities,
// including tzset(), timezone, and tzname[].
TimeZone *newZone = NULL;
int32_t rawOffset = 0;
const char *hostID;
UnicodeString ID;
// First, try to create the timezone from our hashtable, based
// on the string ID in tzname[0].
{
Mutex lock; // mutexed to avoid threading issues in the platform fcns.
icu_tzset(); // Initialize tz... system data
// get the timezone ID from the host.
hostID = icu_tzname(0);
// Invert sign because UNIX semantics are backwards
rawOffset = icu_timezone() * -kMillisPerSecond;
}
// create UnicodeString ID from hostID (to avoid Mutex deadlock)
ID = hostID;
if (ID.size() > 0)
{
UHashtable h = getHashtable();
TimeZone *z = (TimeZone*)uhash_get(&h,ID.hashCode() & 0x7FFFFFFF);
// Important -- must clone the TimeZone because fgDefaultZone may be
// deleted by adoptDefault().
if (z != 0) newZone = z->clone();
}
// If we couldn't get the time zone ID from the host, use the
// default host timezone offset, timezone.
if (newZone == NULL)
{
// just pick the first entry in the time zone list that has the
// appropriate GMT offset (if there is one)
int32_t numMatches = 0;
const UnicodeString** matches = createAvailableIDs(rawOffset, numMatches);
if (numMatches > 0) {
newZone = createTimeZone(*matches[0]);
delete [] matches;
}
}
// If we _still_ don't have a time zone, use the one specified by kLastResortID.
// (This call should always succeed, since we code the Hashtable
// to always contain this TimeZone.)
if (newZone == NULL)
newZone = createTimeZone(kLastResortID);
{
Mutex lock2;
if(fgDefaultZone != NULL)
delete newZone;
else
fgDefaultZone = newZone;
}
}
}
// -------------------------------------
TimeZone*
TimeZone::createDefault()
{
initDefault(); // After this call fgDefaultZone is not NULL
Mutex lock; // Careful...must have mutex here
return fgDefaultZone->clone();
}
// -------------------------------------
void
TimeZone::adoptDefault(TimeZone* zone)
{
if (kSystemInited == FALSE) {
initSystemTimeZones();
}
if (zone != NULL)
{
Mutex mutex;
if (fgDefaultZone != NULL) {
delete fgDefaultZone;
}
fgDefaultZone = zone;
}
}
// -------------------------------------
void
TimeZone::setDefault(const TimeZone& zone)
{
adoptDefault(zone.clone());
}
// -------------------------------------
const UnicodeString** const
TimeZone::createAvailableIDs(int32_t rawOffset, int32_t& numIDs)
{
// We are creating a new array to existing UnicodeString pointers.
// The caller will delete the array when done, but not the pointers
// in the array.
getHashtable(); // Force initialization of fgAvailableIDs
const UnicodeString** const ptrArray =
(const UnicodeString** const) new UnicodeString*[fgAvailableIDsCount];
numIDs = 0;
int32_t pos = -1;
UHashtable e = getHashtable();
void* value;
UnicodeString anID;
while (numIDs < fgAvailableIDsCount && (value = uhash_nextElement(&e, &pos)))
{
if (rawOffset == ((SimpleTimeZone *)value)->getRawOffset())
ptrArray[numIDs++] = new UnicodeString(((SimpleTimeZone *)value)->getID(anID));
}
return ptrArray;
}
// -------------------------------------
const UnicodeString** const
TimeZone::createAvailableIDs(int32_t& numIDs)
{
// We are creating a new array to existing UnicodeString pointers.
// The caller will delete the array when done, but not the pointers
// in the array.
getHashtable(); // Force initialization of fgAvailableIDs
const UnicodeString** const ptrArray =
(const UnicodeString** const) new UnicodeString*[fgAvailableIDsCount];
for (int32_t i=0; i<fgAvailableIDsCount; ++i)
ptrArray[i] = &fgAvailableIDs[i];
numIDs = fgAvailableIDsCount;
return ptrArray;
}
// ---------------------------------------
UnicodeString&
TimeZone::getDisplayName(UnicodeString& result) const
{
return getDisplayName(FALSE,LONG,Locale::getDefault(), result);
}
UnicodeString&
TimeZone::getDisplayName(const Locale& locale, UnicodeString& result) const
{
return getDisplayName(FALSE, LONG, locale, result);
}
UnicodeString&
TimeZone::getDisplayName(bool_t daylight, EDisplayType style, UnicodeString& result) const
{
return getDisplayName(daylight,style, Locale::getDefault(), result);
}
UnicodeString&
TimeZone::getDisplayName(bool_t daylight, EDisplayType style, const Locale& locale, UnicodeString& result) const
{
if (kSystemInited == FALSE) {
initSystemTimeZones();
}
// SRL TODO: cache the SDF, just like java.
UErrorCode status = ZERO_ERROR;
SimpleDateFormat format(style == LONG ? "zzzz" : "z",locale,status);
if(!SUCCESS(status))
{
// *** SRL what do I do here?!!
return result.remove();
}
// Create a new SimpleTimeZone as a stand-in for this zone; the
// stand-in will have no DST, or all DST, but the same ID and offset,
// and hence the same display name.
// We don't cache these because they're small and cheap to create.
UnicodeString tempID;
SimpleTimeZone *tz = daylight ?
// For the pure-DST zone, we use the month before JANUARY and
// the month after DECEMBER; if this fails to work at some future
// date because of increased error checking in SimpleTimeZone,
// change these parameters to JANUARY and DECEMBER, which will
// work equally well, but will be slower.
new SimpleTimeZone(getRawOffset(), getID(tempID),
Calendar::JANUARY - 1, 1, 0, 0,
Calendar::DECEMBER + 1, 31, 0, kMillisPerDay, status) :
new SimpleTimeZone(getRawOffset(), getID(tempID));
format.applyPattern(style == LONG ? "zzzz" : "z");
Calendar *myCalendar = (Calendar*)format.getCalendar();
myCalendar->setTimeZone(*tz); // copy
delete tz;
FieldPosition pos(FieldPosition::DONT_CARE);
return format.format(UDate(), result, pos); // Doesn't matter what date we use
}
/**
* Parse a custom time zone identifier and return a corresponding zone.
* @param id a string of the form GMT[+-]hh:mm, GMT[+-]hhmm, or
* GMT[+-]hh.
* @return a newly created SimpleTimeZone with the given offset and
* no Daylight Savings Time, or null if the id cannot be parsed.
*/
TimeZone*
TimeZone::createCustomTimeZone(const UnicodeString& id)
{
static const int32_t kParseFailed = -99999;
NumberFormat* numberFormat = 0;
UnicodeString idUppercase = id;
idUppercase.toUpper();
if (id.size() > GMT_ID_LENGTH &&
idUppercase.startsWith(GMT_ID))
{
ParsePosition pos(GMT_ID_LENGTH);
bool_t negative = FALSE;
int32_t offset;
if (id[pos.getIndex()] == 0x002D /*'-'*/)
negative = TRUE;
else if (id[pos.getIndex()] != 0x002B /*'+'*/)
return 0;
pos.setIndex(pos.getIndex() + 1);
UErrorCode success = ZERO_ERROR;
numberFormat = NumberFormat::createInstance(success);
numberFormat->setParseIntegerOnly(TRUE);
// Look for either hh:mm, hhmm, or hh
int32_t start = pos.getIndex();
Formattable n(kParseFailed);
numberFormat->parse(id, n, pos);
if (pos.getIndex() == start) return 0;
offset = n.getLong();
if (pos.getIndex() < id.size() &&
id[pos.getIndex()] == 0x003A /*':'*/)
{
// hh:mm
offset *= 60;
pos.setIndex(pos.getIndex() + 1);
int32_t oldPos = pos.getIndex();
n.setLong(kParseFailed);
numberFormat->parse(id, n, pos);
if (pos.getIndex() == oldPos) return 0;
offset += n.getLong();
}
else
{
// hhmm or hh
// Be strict about interpreting something as hh; it must be
// an offset < 30, and it must be one or two digits. Thus
// 0010 is interpreted as 00:10, but 10 is interpreted as
// 10:00.
if (offset < 30 && (pos.getIndex() - start) <= 2)
offset *= 60; // hh, from 00 to 29; 30 is 00:30
else
offset = offset % 100 + offset / 100 * 60; // hhmm
}
if(negative)
offset = -offset;
return new SimpleTimeZone(offset * 60000, CUSTOM_ID);
delete numberFormat;
}
return 0;
}
bool_t
TimeZone::hasSameRules(const TimeZone& other) const
{
return (getRawOffset() == other.getRawOffset() &&
useDaylightTime() == other.useDaylightTime());
}
//eof
Reference in New Issue View Git Blame Copy Permalink