mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
dd00554d2b
Bug 924839 - Remove a patch already part of ICU 52.1. See http://bugs.icu-project.org/trac/ticket/10283 but also note the relevant code was removed completely upstream. r=glandium * * * Bug 924839 - Remove another patch already part of ICU 52.1. See http://bugs.icu-project.org/trac/ticket/10290 for that. r=gaston * * * Bug 924839 - Remove another patch already in ICU 52.1. See http://bugs.icu-project.org/trac/ticket/10045 for more. r=Norbert * * * Bug 924839 - Remove another patch already applied upstream. See http://bugs.icu-project.org/trac/changeset/32937 for more. r=gaston * * * Bug 924839 - Update the ICU update script to update to 52.1, *without* applying any of our local patches. r=glandium * * * Bug 924839 - Make the ICU update script only do updating within intl/icu/source and nowhere else. r=glandium * * * Bug 924839 - Implement the changes that would be made by |cd intl/; ./update-icu.sh http://source.icu-project.org/repos/icu/icu/tags/release-52-1/;|, run with the prior changesets' changes made (thus not applying any of our local patches). These changes don't actually work without subsequent adjustments, but this provides a codebase upon which those adjustments can be made, for the purpose of generating local patches to be kept in intl/icu-patches/. rs=the-usual-suspects * * * Bug 924839 - Update the bug 899722 local patch to make runConfigureICU not override CC/CXX on BSD systems. r=gaston * * * Bug 924839 - Update the bug 724533 patch that makes ICU builds with MozillaBuild on Windows. r=glandium * * * Bug 924839 - Import an upstream patch fixing the genrb tool to properly handle the -R (--omitCollationRules) option. See http://bugs.icu-project.org/trac/ticket/10043 for the original bug report and a link to the ultimate upstream landing. r=Norbert * * * Bug 924839 - Import the upstream fix for http://bugs.icu-project.org/trac/ticket/10486 so that ICU with -DU_USING_ICU_NAMESPACE=0 will compile on Windows. r=Norbert * * * Bug 924839 - Adjust the update script to update ICU, then to apply all local patches (rather than skipping the second step). Thus if the update script is properly run, now, the final result should be no changes at all to the tree. NOT REVIEWED YET * * * Bug 924839 - Update jstests that depend on CLDR locale data to match CLDR 24. r=Norbert --HG-- extra : rebase_source : e993b6e4a507f92d1b1a24949185d00d1f6201f2
3700 lines
128 KiB
C++
3700 lines
128 KiB
C++
/*
|
|
*******************************************************************************
|
|
* Copyright (C) 1997-2013, International Business Machines Corporation and *
|
|
* others. All Rights Reserved. *
|
|
*******************************************************************************
|
|
*
|
|
* File CALENDAR.CPP
|
|
*
|
|
* Modification History:
|
|
*
|
|
* Date Name Description
|
|
* 02/03/97 clhuang Creation.
|
|
* 04/22/97 aliu Cleaned up, fixed memory leak, made
|
|
* setWeekCountData() more robust.
|
|
* Moved platform code to TPlatformUtilities.
|
|
* 05/01/97 aliu Made equals(), before(), after() arguments const.
|
|
* 05/20/97 aliu Changed logic of when to compute fields and time
|
|
* to fix bugs.
|
|
* 08/12/97 aliu Added equivalentTo. Misc other fixes.
|
|
* 07/28/98 stephen Sync up with JDK 1.2
|
|
* 09/02/98 stephen Sync with JDK 1.2 8/31 build (getActualMin/Max)
|
|
* 03/17/99 stephen Changed adoptTimeZone() - now fAreFieldsSet is
|
|
* set to FALSE to force update of time.
|
|
*******************************************************************************
|
|
*/
|
|
|
|
#include "utypeinfo.h" // for 'typeid' to work
|
|
|
|
#include "unicode/utypes.h"
|
|
|
|
#if !UCONFIG_NO_FORMATTING
|
|
|
|
#include "unicode/gregocal.h"
|
|
#include "unicode/basictz.h"
|
|
#include "unicode/simpletz.h"
|
|
#include "unicode/rbtz.h"
|
|
#include "unicode/vtzone.h"
|
|
#include "gregoimp.h"
|
|
#include "buddhcal.h"
|
|
#include "taiwncal.h"
|
|
#include "japancal.h"
|
|
#include "islamcal.h"
|
|
#include "hebrwcal.h"
|
|
#include "persncal.h"
|
|
#include "indiancal.h"
|
|
#include "chnsecal.h"
|
|
#include "coptccal.h"
|
|
#include "dangical.h"
|
|
#include "ethpccal.h"
|
|
#include "unicode/calendar.h"
|
|
#include "cpputils.h"
|
|
#include "servloc.h"
|
|
#include "ucln_in.h"
|
|
#include "cstring.h"
|
|
#include "locbased.h"
|
|
#include "uresimp.h"
|
|
#include "ustrenum.h"
|
|
#include "uassert.h"
|
|
#include "olsontz.h"
|
|
|
|
#if !UCONFIG_NO_SERVICE
|
|
static icu::ICULocaleService* gService = NULL;
|
|
static icu::UInitOnce gServiceInitOnce = U_INITONCE_INITIALIZER;
|
|
#endif
|
|
|
|
// INTERNAL - for cleanup
|
|
|
|
U_CDECL_BEGIN
|
|
static UBool calendar_cleanup(void) {
|
|
#if !UCONFIG_NO_SERVICE
|
|
if (gService) {
|
|
delete gService;
|
|
gService = NULL;
|
|
}
|
|
gServiceInitOnce.reset();
|
|
#endif
|
|
return TRUE;
|
|
}
|
|
U_CDECL_END
|
|
|
|
// ------------------------------------------
|
|
//
|
|
// Registration
|
|
//
|
|
//-------------------------------------------
|
|
//#define U_DEBUG_CALSVC 1
|
|
//
|
|
|
|
#if defined( U_DEBUG_CALSVC ) || defined (U_DEBUG_CAL)
|
|
|
|
/**
|
|
* fldName was removed as a duplicate implementation.
|
|
* use udbg_ services instead,
|
|
* which depend on include files and library from ../tools/toolutil, the following circular link:
|
|
* CPPFLAGS+=-I$(top_srcdir)/tools/toolutil
|
|
* LIBS+=$(LIBICUTOOLUTIL)
|
|
*/
|
|
#include "udbgutil.h"
|
|
#include <stdio.h>
|
|
|
|
/**
|
|
* convert a UCalendarDateFields into a string - for debugging
|
|
* @param f field enum
|
|
* @return static string to the field name
|
|
* @internal
|
|
*/
|
|
|
|
const char* fldName(UCalendarDateFields f) {
|
|
return udbg_enumName(UDBG_UCalendarDateFields, (int32_t)f);
|
|
}
|
|
|
|
#if UCAL_DEBUG_DUMP
|
|
// from CalendarTest::calToStr - but doesn't modify contents.
|
|
void ucal_dump(const Calendar &cal) {
|
|
cal.dump();
|
|
}
|
|
|
|
void Calendar::dump() const {
|
|
int i;
|
|
fprintf(stderr, "@calendar=%s, timeset=%c, fieldset=%c, allfields=%c, virtualset=%c, t=%.2f",
|
|
getType(), fIsTimeSet?'y':'n', fAreFieldsSet?'y':'n', fAreAllFieldsSet?'y':'n',
|
|
fAreFieldsVirtuallySet?'y':'n',
|
|
fTime);
|
|
|
|
// can add more things here: DST, zone, etc.
|
|
fprintf(stderr, "\n");
|
|
for(i = 0;i<UCAL_FIELD_COUNT;i++) {
|
|
int n;
|
|
const char *f = fldName((UCalendarDateFields)i);
|
|
fprintf(stderr, " %25s: %-11ld", f, fFields[i]);
|
|
if(fStamp[i] == kUnset) {
|
|
fprintf(stderr, " (unset) ");
|
|
} else if(fStamp[i] == kInternallySet) {
|
|
fprintf(stderr, " (internally set) ");
|
|
//} else if(fStamp[i] == kInternalDefault) {
|
|
// fprintf(stderr, " (internal default) ");
|
|
} else {
|
|
fprintf(stderr, " %%%d ", fStamp[i]);
|
|
}
|
|
fprintf(stderr, "\n");
|
|
|
|
}
|
|
}
|
|
|
|
U_CFUNC void ucal_dump(UCalendar* cal) {
|
|
ucal_dump( *((Calendar*)cal) );
|
|
}
|
|
#endif
|
|
|
|
#endif
|
|
|
|
/* Max value for stamp allowable before recalculation */
|
|
#define STAMP_MAX 10000
|
|
|
|
static const char * const gCalTypes[] = {
|
|
"gregorian",
|
|
"japanese",
|
|
"buddhist",
|
|
"roc",
|
|
"persian",
|
|
"islamic-civil",
|
|
"islamic",
|
|
"hebrew",
|
|
"chinese",
|
|
"indian",
|
|
"coptic",
|
|
"ethiopic",
|
|
"ethiopic-amete-alem",
|
|
"iso8601",
|
|
"dangi",
|
|
"islamic-umalqura",
|
|
"islamic-tbla",
|
|
"islamic-rgsa",
|
|
NULL
|
|
};
|
|
|
|
// Must be in the order of gCalTypes above
|
|
typedef enum ECalType {
|
|
CALTYPE_UNKNOWN = -1,
|
|
CALTYPE_GREGORIAN = 0,
|
|
CALTYPE_JAPANESE,
|
|
CALTYPE_BUDDHIST,
|
|
CALTYPE_ROC,
|
|
CALTYPE_PERSIAN,
|
|
CALTYPE_ISLAMIC_CIVIL,
|
|
CALTYPE_ISLAMIC,
|
|
CALTYPE_HEBREW,
|
|
CALTYPE_CHINESE,
|
|
CALTYPE_INDIAN,
|
|
CALTYPE_COPTIC,
|
|
CALTYPE_ETHIOPIC,
|
|
CALTYPE_ETHIOPIC_AMETE_ALEM,
|
|
CALTYPE_ISO8601,
|
|
CALTYPE_DANGI,
|
|
CALTYPE_ISLAMIC_UMALQURA,
|
|
CALTYPE_ISLAMIC_TBLA,
|
|
CALTYPE_ISLAMIC_RGSA
|
|
} ECalType;
|
|
|
|
U_NAMESPACE_BEGIN
|
|
|
|
static ECalType getCalendarType(const char *s) {
|
|
for (int i = 0; gCalTypes[i] != NULL; i++) {
|
|
if (uprv_stricmp(s, gCalTypes[i]) == 0) {
|
|
return (ECalType)i;
|
|
}
|
|
}
|
|
return CALTYPE_UNKNOWN;
|
|
}
|
|
|
|
static UBool isStandardSupportedKeyword(const char *keyword, UErrorCode& status) {
|
|
if(U_FAILURE(status)) {
|
|
return FALSE;
|
|
}
|
|
ECalType calType = getCalendarType(keyword);
|
|
return (calType != CALTYPE_UNKNOWN);
|
|
}
|
|
|
|
static void getCalendarKeyword(const UnicodeString &id, char *targetBuffer, int32_t targetBufferSize) {
|
|
UnicodeString calendarKeyword = UNICODE_STRING_SIMPLE("calendar=");
|
|
int32_t calKeyLen = calendarKeyword.length();
|
|
int32_t keyLen = 0;
|
|
|
|
int32_t keywordIdx = id.indexOf((UChar)0x003D); /* '=' */
|
|
if (id[0] == 0x40/*'@'*/
|
|
&& id.compareBetween(1, keywordIdx+1, calendarKeyword, 0, calKeyLen) == 0)
|
|
{
|
|
keyLen = id.extract(keywordIdx+1, id.length(), targetBuffer, targetBufferSize, US_INV);
|
|
}
|
|
targetBuffer[keyLen] = 0;
|
|
}
|
|
|
|
static ECalType getCalendarTypeForLocale(const char *locid) {
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
ECalType calType = CALTYPE_UNKNOWN;
|
|
|
|
//TODO: ULOC_FULL_NAME is out of date and too small..
|
|
char canonicalName[256];
|
|
|
|
// canonicalize, so grandfathered variant will be transformed to keywords
|
|
// e.g ja_JP_TRADITIONAL -> ja_JP@calendar=japanese
|
|
int32_t canonicalLen = uloc_canonicalize(locid, canonicalName, sizeof(canonicalName) - 1, &status);
|
|
if (U_FAILURE(status)) {
|
|
return CALTYPE_GREGORIAN;
|
|
}
|
|
canonicalName[canonicalLen] = 0; // terminate
|
|
|
|
char calTypeBuf[32];
|
|
int32_t calTypeBufLen;
|
|
|
|
calTypeBufLen = uloc_getKeywordValue(canonicalName, "calendar", calTypeBuf, sizeof(calTypeBuf) - 1, &status);
|
|
if (U_SUCCESS(status)) {
|
|
calTypeBuf[calTypeBufLen] = 0;
|
|
calType = getCalendarType(calTypeBuf);
|
|
if (calType != CALTYPE_UNKNOWN) {
|
|
return calType;
|
|
}
|
|
}
|
|
status = U_ZERO_ERROR;
|
|
|
|
// when calendar keyword is not available or not supported, read supplementalData
|
|
// to get the default calendar type for the locale's region
|
|
char region[ULOC_COUNTRY_CAPACITY];
|
|
int32_t regionLen = 0;
|
|
regionLen = uloc_getCountry(canonicalName, region, sizeof(region) - 1, &status);
|
|
if (regionLen == 0) {
|
|
char fullLoc[256];
|
|
uloc_addLikelySubtags(locid, fullLoc, sizeof(fullLoc) - 1, &status);
|
|
regionLen = uloc_getCountry(fullLoc, region, sizeof(region) - 1, &status);
|
|
}
|
|
if (U_FAILURE(status)) {
|
|
return CALTYPE_GREGORIAN;
|
|
}
|
|
region[regionLen] = 0;
|
|
|
|
// Read preferred calendar values from supplementalData calendarPreference
|
|
UResourceBundle *rb = ures_openDirect(NULL, "supplementalData", &status);
|
|
ures_getByKey(rb, "calendarPreferenceData", rb, &status);
|
|
UResourceBundle *order = ures_getByKey(rb, region, NULL, &status);
|
|
if (status == U_MISSING_RESOURCE_ERROR && rb != NULL) {
|
|
status = U_ZERO_ERROR;
|
|
order = ures_getByKey(rb, "001", NULL, &status);
|
|
}
|
|
|
|
calTypeBuf[0] = 0;
|
|
if (U_SUCCESS(status) && order != NULL) {
|
|
// the first calender type is the default for the region
|
|
int32_t len = 0;
|
|
const UChar *uCalType = ures_getStringByIndex(order, 0, &len, &status);
|
|
if (len < (int32_t)sizeof(calTypeBuf)) {
|
|
u_UCharsToChars(uCalType, calTypeBuf, len);
|
|
*(calTypeBuf + len) = 0; // terminate;
|
|
calType = getCalendarType(calTypeBuf);
|
|
}
|
|
}
|
|
|
|
ures_close(order);
|
|
ures_close(rb);
|
|
|
|
if (calType == CALTYPE_UNKNOWN) {
|
|
// final fallback
|
|
calType = CALTYPE_GREGORIAN;
|
|
}
|
|
return calType;
|
|
}
|
|
|
|
static Calendar *createStandardCalendar(ECalType calType, const Locale &loc, UErrorCode& status) {
|
|
Calendar *cal = NULL;
|
|
|
|
switch (calType) {
|
|
case CALTYPE_GREGORIAN:
|
|
cal = new GregorianCalendar(loc, status);
|
|
break;
|
|
case CALTYPE_JAPANESE:
|
|
cal = new JapaneseCalendar(loc, status);
|
|
break;
|
|
case CALTYPE_BUDDHIST:
|
|
cal = new BuddhistCalendar(loc, status);
|
|
break;
|
|
case CALTYPE_ROC:
|
|
cal = new TaiwanCalendar(loc, status);
|
|
break;
|
|
case CALTYPE_PERSIAN:
|
|
cal = new PersianCalendar(loc, status);
|
|
break;
|
|
case CALTYPE_ISLAMIC_TBLA:
|
|
cal = new IslamicCalendar(loc, status, IslamicCalendar::TBLA);
|
|
break;
|
|
case CALTYPE_ISLAMIC_CIVIL:
|
|
cal = new IslamicCalendar(loc, status, IslamicCalendar::CIVIL);
|
|
break;
|
|
case CALTYPE_ISLAMIC_RGSA:
|
|
// default any region specific not handled individually to islamic
|
|
case CALTYPE_ISLAMIC:
|
|
cal = new IslamicCalendar(loc, status, IslamicCalendar::ASTRONOMICAL);
|
|
break;
|
|
case CALTYPE_ISLAMIC_UMALQURA:
|
|
cal = new IslamicCalendar(loc, status, IslamicCalendar::UMALQURA);
|
|
break;
|
|
case CALTYPE_HEBREW:
|
|
cal = new HebrewCalendar(loc, status);
|
|
break;
|
|
case CALTYPE_CHINESE:
|
|
cal = new ChineseCalendar(loc, status);
|
|
break;
|
|
case CALTYPE_INDIAN:
|
|
cal = new IndianCalendar(loc, status);
|
|
break;
|
|
case CALTYPE_COPTIC:
|
|
cal = new CopticCalendar(loc, status);
|
|
break;
|
|
case CALTYPE_ETHIOPIC:
|
|
cal = new EthiopicCalendar(loc, status, EthiopicCalendar::AMETE_MIHRET_ERA);
|
|
break;
|
|
case CALTYPE_ETHIOPIC_AMETE_ALEM:
|
|
cal = new EthiopicCalendar(loc, status, EthiopicCalendar::AMETE_ALEM_ERA);
|
|
break;
|
|
case CALTYPE_ISO8601:
|
|
cal = new GregorianCalendar(loc, status);
|
|
cal->setFirstDayOfWeek(UCAL_MONDAY);
|
|
cal->setMinimalDaysInFirstWeek(4);
|
|
break;
|
|
case CALTYPE_DANGI:
|
|
cal = new DangiCalendar(loc, status);
|
|
break;
|
|
default:
|
|
status = U_UNSUPPORTED_ERROR;
|
|
}
|
|
return cal;
|
|
}
|
|
|
|
|
|
#if !UCONFIG_NO_SERVICE
|
|
|
|
// -------------------------------------
|
|
|
|
/**
|
|
* a Calendar Factory which creates the "basic" calendar types, that is, those
|
|
* shipped with ICU.
|
|
*/
|
|
class BasicCalendarFactory : public LocaleKeyFactory {
|
|
public:
|
|
/**
|
|
* @param calendarType static const string (caller owns storage - will be aliased) to calendar type
|
|
*/
|
|
BasicCalendarFactory()
|
|
: LocaleKeyFactory(LocaleKeyFactory::INVISIBLE) { }
|
|
|
|
virtual ~BasicCalendarFactory();
|
|
|
|
protected:
|
|
//virtual UBool isSupportedID( const UnicodeString& id, UErrorCode& status) const {
|
|
// if(U_FAILURE(status)) {
|
|
// return FALSE;
|
|
// }
|
|
// char keyword[ULOC_FULLNAME_CAPACITY];
|
|
// getCalendarKeyword(id, keyword, (int32_t)sizeof(keyword));
|
|
// return isStandardSupportedKeyword(keyword, status);
|
|
//}
|
|
|
|
virtual void updateVisibleIDs(Hashtable& result, UErrorCode& status) const
|
|
{
|
|
if (U_SUCCESS(status)) {
|
|
for(int32_t i=0;gCalTypes[i] != NULL;i++) {
|
|
UnicodeString id((UChar)0x40); /* '@' a variant character */
|
|
id.append(UNICODE_STRING_SIMPLE("calendar="));
|
|
id.append(UnicodeString(gCalTypes[i], -1, US_INV));
|
|
result.put(id, (void*)this, status);
|
|
}
|
|
}
|
|
}
|
|
|
|
virtual UObject* create(const ICUServiceKey& key, const ICUService* /*service*/, UErrorCode& status) const {
|
|
#ifdef U_DEBUG_CALSVC
|
|
if(dynamic_cast<const LocaleKey*>(&key) == NULL) {
|
|
fprintf(stderr, "::create - not a LocaleKey!\n");
|
|
}
|
|
#endif
|
|
const LocaleKey& lkey = (LocaleKey&)key;
|
|
Locale curLoc; // current locale
|
|
Locale canLoc; // Canonical locale
|
|
|
|
lkey.currentLocale(curLoc);
|
|
lkey.canonicalLocale(canLoc);
|
|
|
|
char keyword[ULOC_FULLNAME_CAPACITY];
|
|
UnicodeString str;
|
|
|
|
key.currentID(str);
|
|
getCalendarKeyword(str, keyword, (int32_t) sizeof(keyword));
|
|
|
|
#ifdef U_DEBUG_CALSVC
|
|
fprintf(stderr, "BasicCalendarFactory::create() - cur %s, can %s\n", (const char*)curLoc.getName(), (const char*)canLoc.getName());
|
|
#endif
|
|
|
|
if(!isStandardSupportedKeyword(keyword,status)) { // Do we handle this type?
|
|
#ifdef U_DEBUG_CALSVC
|
|
|
|
fprintf(stderr, "BasicCalendarFactory - not handling %s.[%s]\n", (const char*) curLoc.getName(), tmp );
|
|
#endif
|
|
return NULL;
|
|
}
|
|
|
|
return createStandardCalendar(getCalendarType(keyword), canLoc, status);
|
|
}
|
|
};
|
|
|
|
BasicCalendarFactory::~BasicCalendarFactory() {}
|
|
|
|
/**
|
|
* A factory which looks up the DefaultCalendar resource to determine which class of calendar to use
|
|
*/
|
|
|
|
class DefaultCalendarFactory : public ICUResourceBundleFactory {
|
|
public:
|
|
DefaultCalendarFactory() : ICUResourceBundleFactory() { }
|
|
virtual ~DefaultCalendarFactory();
|
|
protected:
|
|
virtual UObject* create(const ICUServiceKey& key, const ICUService* /*service*/, UErrorCode& status) const {
|
|
|
|
LocaleKey &lkey = (LocaleKey&)key;
|
|
Locale loc;
|
|
lkey.currentLocale(loc);
|
|
|
|
UnicodeString *ret = new UnicodeString();
|
|
if (ret == NULL) {
|
|
status = U_MEMORY_ALLOCATION_ERROR;
|
|
} else {
|
|
ret->append((UChar)0x40); // '@' is a variant character
|
|
ret->append(UNICODE_STRING("calendar=", 9));
|
|
ret->append(UnicodeString(gCalTypes[getCalendarTypeForLocale(loc.getName())], -1, US_INV));
|
|
}
|
|
return ret;
|
|
}
|
|
};
|
|
|
|
DefaultCalendarFactory::~DefaultCalendarFactory() {}
|
|
|
|
// -------------------------------------
|
|
class CalendarService : public ICULocaleService {
|
|
public:
|
|
CalendarService()
|
|
: ICULocaleService(UNICODE_STRING_SIMPLE("Calendar"))
|
|
{
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
registerFactory(new DefaultCalendarFactory(), status);
|
|
}
|
|
|
|
virtual ~CalendarService();
|
|
|
|
virtual UObject* cloneInstance(UObject* instance) const {
|
|
UnicodeString *s = dynamic_cast<UnicodeString *>(instance);
|
|
if(s != NULL) {
|
|
return s->clone();
|
|
} else {
|
|
#ifdef U_DEBUG_CALSVC_F
|
|
UErrorCode status2 = U_ZERO_ERROR;
|
|
fprintf(stderr, "Cloning a %s calendar with tz=%ld\n", ((Calendar*)instance)->getType(), ((Calendar*)instance)->get(UCAL_ZONE_OFFSET, status2));
|
|
#endif
|
|
return ((Calendar*)instance)->clone();
|
|
}
|
|
}
|
|
|
|
virtual UObject* handleDefault(const ICUServiceKey& key, UnicodeString* /*actualID*/, UErrorCode& status) const {
|
|
LocaleKey& lkey = (LocaleKey&)key;
|
|
//int32_t kind = lkey.kind();
|
|
|
|
Locale loc;
|
|
lkey.canonicalLocale(loc);
|
|
|
|
#ifdef U_DEBUG_CALSVC
|
|
Locale loc2;
|
|
lkey.currentLocale(loc2);
|
|
fprintf(stderr, "CalSvc:handleDefault for currentLoc %s, canloc %s\n", (const char*)loc.getName(), (const char*)loc2.getName());
|
|
#endif
|
|
Calendar *nc = new GregorianCalendar(loc, status);
|
|
|
|
#ifdef U_DEBUG_CALSVC
|
|
UErrorCode status2 = U_ZERO_ERROR;
|
|
fprintf(stderr, "New default calendar has tz=%d\n", ((Calendar*)nc)->get(UCAL_ZONE_OFFSET, status2));
|
|
#endif
|
|
return nc;
|
|
}
|
|
|
|
virtual UBool isDefault() const {
|
|
return countFactories() == 1;
|
|
}
|
|
};
|
|
|
|
CalendarService::~CalendarService() {}
|
|
|
|
// -------------------------------------
|
|
|
|
static inline UBool
|
|
isCalendarServiceUsed() {
|
|
return !gServiceInitOnce.isReset();
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
static void U_CALLCONV
|
|
initCalendarService(UErrorCode &status)
|
|
{
|
|
#ifdef U_DEBUG_CALSVC
|
|
fprintf(stderr, "Spinning up Calendar Service\n");
|
|
#endif
|
|
ucln_i18n_registerCleanup(UCLN_I18N_CALENDAR, calendar_cleanup);
|
|
gService = new CalendarService();
|
|
if (gService == NULL) {
|
|
status = U_MEMORY_ALLOCATION_ERROR;
|
|
return;
|
|
}
|
|
#ifdef U_DEBUG_CALSVC
|
|
fprintf(stderr, "Registering classes..\n");
|
|
#endif
|
|
|
|
// Register all basic instances.
|
|
gService->registerFactory(new BasicCalendarFactory(),status);
|
|
|
|
#ifdef U_DEBUG_CALSVC
|
|
fprintf(stderr, "Done..\n");
|
|
#endif
|
|
|
|
if(U_FAILURE(status)) {
|
|
#ifdef U_DEBUG_CALSVC
|
|
fprintf(stderr, "err (%s) registering classes, deleting service.....\n", u_errorName(status));
|
|
#endif
|
|
delete gService;
|
|
gService = NULL;
|
|
}
|
|
}
|
|
|
|
static ICULocaleService*
|
|
getCalendarService(UErrorCode &status)
|
|
{
|
|
umtx_initOnce(gServiceInitOnce, &initCalendarService, status);
|
|
return gService;
|
|
}
|
|
|
|
URegistryKey Calendar::registerFactory(ICUServiceFactory* toAdopt, UErrorCode& status)
|
|
{
|
|
return getCalendarService(status)->registerFactory(toAdopt, status);
|
|
}
|
|
|
|
UBool Calendar::unregister(URegistryKey key, UErrorCode& status) {
|
|
return getCalendarService(status)->unregister(key, status);
|
|
}
|
|
#endif /* UCONFIG_NO_SERVICE */
|
|
|
|
// -------------------------------------
|
|
|
|
static const int32_t kCalendarLimits[UCAL_FIELD_COUNT][4] = {
|
|
// Minimum Greatest min Least max Greatest max
|
|
{/*N/A*/-1, /*N/A*/-1, /*N/A*/-1, /*N/A*/-1}, // ERA
|
|
{/*N/A*/-1, /*N/A*/-1, /*N/A*/-1, /*N/A*/-1}, // YEAR
|
|
{/*N/A*/-1, /*N/A*/-1, /*N/A*/-1, /*N/A*/-1}, // MONTH
|
|
{/*N/A*/-1, /*N/A*/-1, /*N/A*/-1, /*N/A*/-1}, // WEEK_OF_YEAR
|
|
{/*N/A*/-1, /*N/A*/-1, /*N/A*/-1, /*N/A*/-1}, // WEEK_OF_MONTH
|
|
{/*N/A*/-1, /*N/A*/-1, /*N/A*/-1, /*N/A*/-1}, // DAY_OF_MONTH
|
|
{/*N/A*/-1, /*N/A*/-1, /*N/A*/-1, /*N/A*/-1}, // DAY_OF_YEAR
|
|
{ 1, 1, 7, 7 }, // DAY_OF_WEEK
|
|
{/*N/A*/-1, /*N/A*/-1, /*N/A*/-1, /*N/A*/-1}, // DAY_OF_WEEK_IN_MONTH
|
|
{ 0, 0, 1, 1 }, // AM_PM
|
|
{ 0, 0, 11, 11 }, // HOUR
|
|
{ 0, 0, 23, 23 }, // HOUR_OF_DAY
|
|
{ 0, 0, 59, 59 }, // MINUTE
|
|
{ 0, 0, 59, 59 }, // SECOND
|
|
{ 0, 0, 999, 999 }, // MILLISECOND
|
|
{-12*kOneHour, -12*kOneHour, 12*kOneHour, 15*kOneHour }, // ZONE_OFFSET
|
|
{ 0, 0, 1*kOneHour, 1*kOneHour }, // DST_OFFSET
|
|
{/*N/A*/-1, /*N/A*/-1, /*N/A*/-1, /*N/A*/-1}, // YEAR_WOY
|
|
{ 1, 1, 7, 7 }, // DOW_LOCAL
|
|
{/*N/A*/-1, /*N/A*/-1, /*N/A*/-1, /*N/A*/-1}, // EXTENDED_YEAR
|
|
{ -0x7F000000, -0x7F000000, 0x7F000000, 0x7F000000 }, // JULIAN_DAY
|
|
{ 0, 0, 24*kOneHour-1, 24*kOneHour-1 }, // MILLISECONDS_IN_DAY
|
|
{ 0, 0, 1, 1 }, // IS_LEAP_MONTH
|
|
};
|
|
|
|
// Resource bundle tags read by this class
|
|
static const char gMonthNames[] = "monthNames";
|
|
|
|
// Data flow in Calendar
|
|
// ---------------------
|
|
|
|
// The current time is represented in two ways by Calendar: as UTC
|
|
// milliseconds from the epoch start (1 January 1970 0:00 UTC), and as local
|
|
// fields such as MONTH, HOUR, AM_PM, etc. It is possible to compute the
|
|
// millis from the fields, and vice versa. The data needed to do this
|
|
// conversion is encapsulated by a TimeZone object owned by the Calendar.
|
|
// The data provided by the TimeZone object may also be overridden if the
|
|
// user sets the ZONE_OFFSET and/or DST_OFFSET fields directly. The class
|
|
// keeps track of what information was most recently set by the caller, and
|
|
// uses that to compute any other information as needed.
|
|
|
|
// If the user sets the fields using set(), the data flow is as follows.
|
|
// This is implemented by the Calendar subclass's computeTime() method.
|
|
// During this process, certain fields may be ignored. The disambiguation
|
|
// algorithm for resolving which fields to pay attention to is described
|
|
// above.
|
|
|
|
// local fields (YEAR, MONTH, DATE, HOUR, MINUTE, etc.)
|
|
// |
|
|
// | Using Calendar-specific algorithm
|
|
// V
|
|
// local standard millis
|
|
// |
|
|
// | Using TimeZone or user-set ZONE_OFFSET / DST_OFFSET
|
|
// V
|
|
// UTC millis (in time data member)
|
|
|
|
// If the user sets the UTC millis using setTime(), the data flow is as
|
|
// follows. This is implemented by the Calendar subclass's computeFields()
|
|
// method.
|
|
|
|
// UTC millis (in time data member)
|
|
// |
|
|
// | Using TimeZone getOffset()
|
|
// V
|
|
// local standard millis
|
|
// |
|
|
// | Using Calendar-specific algorithm
|
|
// V
|
|
// local fields (YEAR, MONTH, DATE, HOUR, MINUTE, etc.)
|
|
|
|
// In general, a round trip from fields, through local and UTC millis, and
|
|
// back out to fields is made when necessary. This is implemented by the
|
|
// complete() method. Resolving a partial set of fields into a UTC millis
|
|
// value allows all remaining fields to be generated from that value. If
|
|
// the Calendar is lenient, the fields are also renormalized to standard
|
|
// ranges when they are regenerated.
|
|
|
|
// -------------------------------------
|
|
|
|
Calendar::Calendar(UErrorCode& success)
|
|
: UObject(),
|
|
fIsTimeSet(FALSE),
|
|
fAreFieldsSet(FALSE),
|
|
fAreAllFieldsSet(FALSE),
|
|
fAreFieldsVirtuallySet(FALSE),
|
|
fNextStamp((int32_t)kMinimumUserStamp),
|
|
fTime(0),
|
|
fLenient(TRUE),
|
|
fZone(0),
|
|
fRepeatedWallTime(UCAL_WALLTIME_LAST),
|
|
fSkippedWallTime(UCAL_WALLTIME_LAST)
|
|
{
|
|
clear();
|
|
fZone = TimeZone::createDefault();
|
|
if (fZone == NULL) {
|
|
success = U_MEMORY_ALLOCATION_ERROR;
|
|
}
|
|
setWeekData(Locale::getDefault(), NULL, success);
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
Calendar::Calendar(TimeZone* zone, const Locale& aLocale, UErrorCode& success)
|
|
: UObject(),
|
|
fIsTimeSet(FALSE),
|
|
fAreFieldsSet(FALSE),
|
|
fAreAllFieldsSet(FALSE),
|
|
fAreFieldsVirtuallySet(FALSE),
|
|
fNextStamp((int32_t)kMinimumUserStamp),
|
|
fTime(0),
|
|
fLenient(TRUE),
|
|
fZone(0),
|
|
fRepeatedWallTime(UCAL_WALLTIME_LAST),
|
|
fSkippedWallTime(UCAL_WALLTIME_LAST)
|
|
{
|
|
if(zone == 0) {
|
|
#if defined (U_DEBUG_CAL)
|
|
fprintf(stderr, "%s:%d: ILLEGAL ARG because timezone cannot be 0\n",
|
|
__FILE__, __LINE__);
|
|
#endif
|
|
success = U_ILLEGAL_ARGUMENT_ERROR;
|
|
return;
|
|
}
|
|
|
|
clear();
|
|
fZone = zone;
|
|
|
|
setWeekData(aLocale, NULL, success);
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
Calendar::Calendar(const TimeZone& zone, const Locale& aLocale, UErrorCode& success)
|
|
: UObject(),
|
|
fIsTimeSet(FALSE),
|
|
fAreFieldsSet(FALSE),
|
|
fAreAllFieldsSet(FALSE),
|
|
fAreFieldsVirtuallySet(FALSE),
|
|
fNextStamp((int32_t)kMinimumUserStamp),
|
|
fTime(0),
|
|
fLenient(TRUE),
|
|
fZone(0),
|
|
fRepeatedWallTime(UCAL_WALLTIME_LAST),
|
|
fSkippedWallTime(UCAL_WALLTIME_LAST)
|
|
{
|
|
clear();
|
|
fZone = zone.clone();
|
|
if (fZone == NULL) {
|
|
success = U_MEMORY_ALLOCATION_ERROR;
|
|
}
|
|
setWeekData(aLocale, NULL, success);
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
Calendar::~Calendar()
|
|
{
|
|
delete fZone;
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
Calendar::Calendar(const Calendar &source)
|
|
: UObject(source)
|
|
{
|
|
fZone = 0;
|
|
*this = source;
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
Calendar &
|
|
Calendar::operator=(const Calendar &right)
|
|
{
|
|
if (this != &right) {
|
|
uprv_arrayCopy(right.fFields, fFields, UCAL_FIELD_COUNT);
|
|
uprv_arrayCopy(right.fIsSet, fIsSet, UCAL_FIELD_COUNT);
|
|
uprv_arrayCopy(right.fStamp, fStamp, UCAL_FIELD_COUNT);
|
|
fTime = right.fTime;
|
|
fIsTimeSet = right.fIsTimeSet;
|
|
fAreAllFieldsSet = right.fAreAllFieldsSet;
|
|
fAreFieldsSet = right.fAreFieldsSet;
|
|
fAreFieldsVirtuallySet = right.fAreFieldsVirtuallySet;
|
|
fLenient = right.fLenient;
|
|
fRepeatedWallTime = right.fRepeatedWallTime;
|
|
fSkippedWallTime = right.fSkippedWallTime;
|
|
if (fZone != NULL) {
|
|
delete fZone;
|
|
}
|
|
if (right.fZone != NULL) {
|
|
fZone = right.fZone->clone();
|
|
}
|
|
fFirstDayOfWeek = right.fFirstDayOfWeek;
|
|
fMinimalDaysInFirstWeek = right.fMinimalDaysInFirstWeek;
|
|
fWeekendOnset = right.fWeekendOnset;
|
|
fWeekendOnsetMillis = right.fWeekendOnsetMillis;
|
|
fWeekendCease = right.fWeekendCease;
|
|
fWeekendCeaseMillis = right.fWeekendCeaseMillis;
|
|
fNextStamp = right.fNextStamp;
|
|
uprv_strcpy(validLocale, right.validLocale);
|
|
uprv_strcpy(actualLocale, right.actualLocale);
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
Calendar* U_EXPORT2
|
|
Calendar::createInstance(UErrorCode& success)
|
|
{
|
|
return createInstance(TimeZone::createDefault(), Locale::getDefault(), success);
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
Calendar* U_EXPORT2
|
|
Calendar::createInstance(const TimeZone& zone, UErrorCode& success)
|
|
{
|
|
return createInstance(zone, Locale::getDefault(), success);
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
Calendar* U_EXPORT2
|
|
Calendar::createInstance(const Locale& aLocale, UErrorCode& success)
|
|
{
|
|
return createInstance(TimeZone::createDefault(), aLocale, success);
|
|
}
|
|
|
|
// ------------------------------------- Adopting
|
|
|
|
// Note: this is the bottleneck that actually calls the service routines.
|
|
|
|
Calendar* U_EXPORT2
|
|
Calendar::createInstance(TimeZone* zone, const Locale& aLocale, UErrorCode& success)
|
|
{
|
|
if (U_FAILURE(success)) {
|
|
return NULL;
|
|
}
|
|
|
|
Locale actualLoc;
|
|
UObject* u = NULL;
|
|
|
|
#if !UCONFIG_NO_SERVICE
|
|
if (isCalendarServiceUsed()) {
|
|
u = getCalendarService(success)->get(aLocale, LocaleKey::KIND_ANY, &actualLoc, success);
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
u = createStandardCalendar(getCalendarTypeForLocale(aLocale.getName()), aLocale, success);
|
|
}
|
|
Calendar* c = NULL;
|
|
|
|
if(U_FAILURE(success) || !u) {
|
|
delete zone;
|
|
if(U_SUCCESS(success)) { // Propagate some kind of err
|
|
success = U_INTERNAL_PROGRAM_ERROR;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
#if !UCONFIG_NO_SERVICE
|
|
const UnicodeString* str = dynamic_cast<const UnicodeString*>(u);
|
|
if(str != NULL) {
|
|
// It's a unicode string telling us what type of calendar to load ("gregorian", etc)
|
|
// Create a Locale over this string
|
|
Locale l("");
|
|
LocaleUtility::initLocaleFromName(*str, l);
|
|
|
|
#ifdef U_DEBUG_CALSVC
|
|
fprintf(stderr, "Calendar::createInstance(%s), looking up [%s]\n", aLocale.getName(), l.getName());
|
|
#endif
|
|
|
|
Locale actualLoc2;
|
|
delete u;
|
|
u = NULL;
|
|
|
|
// Don't overwrite actualLoc, since the actual loc from this call
|
|
// may be something like "@calendar=gregorian" -- TODO investigate
|
|
// further...
|
|
c = (Calendar*)getCalendarService(success)->get(l, LocaleKey::KIND_ANY, &actualLoc2, success);
|
|
|
|
if(U_FAILURE(success) || !c) {
|
|
delete zone;
|
|
if(U_SUCCESS(success)) {
|
|
success = U_INTERNAL_PROGRAM_ERROR; // Propagate some err
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
str = dynamic_cast<const UnicodeString*>(c);
|
|
if(str != NULL) {
|
|
// recursed! Second lookup returned a UnicodeString.
|
|
// Perhaps DefaultCalendar{} was set to another locale.
|
|
#ifdef U_DEBUG_CALSVC
|
|
char tmp[200];
|
|
// Extract a char* out of it..
|
|
int32_t len = str->length();
|
|
int32_t actLen = sizeof(tmp)-1;
|
|
if(len > actLen) {
|
|
len = actLen;
|
|
}
|
|
str->extract(0,len,tmp);
|
|
tmp[len]=0;
|
|
|
|
fprintf(stderr, "err - recursed, 2nd lookup was unistring %s\n", tmp);
|
|
#endif
|
|
success = U_MISSING_RESOURCE_ERROR; // requested a calendar type which could NOT be found.
|
|
delete c;
|
|
delete zone;
|
|
return NULL;
|
|
}
|
|
#ifdef U_DEBUG_CALSVC
|
|
fprintf(stderr, "%p: setting week count data to locale %s, actual locale %s\n", c, (const char*)aLocale.getName(), (const char *)actualLoc.getName());
|
|
#endif
|
|
c->setWeekData(aLocale, c->getType(), success); // set the correct locale (this was an indirected calendar)
|
|
|
|
char keyword[ULOC_FULLNAME_CAPACITY];
|
|
UErrorCode tmpStatus = U_ZERO_ERROR;
|
|
l.getKeywordValue("calendar", keyword, ULOC_FULLNAME_CAPACITY, tmpStatus);
|
|
if (U_SUCCESS(tmpStatus) && uprv_strcmp(keyword, "iso8601") == 0) {
|
|
c->setFirstDayOfWeek(UCAL_MONDAY);
|
|
c->setMinimalDaysInFirstWeek(4);
|
|
}
|
|
}
|
|
else
|
|
#endif /* UCONFIG_NO_SERVICE */
|
|
{
|
|
// a calendar was returned - we assume the factory did the right thing.
|
|
c = (Calendar*)u;
|
|
}
|
|
|
|
// Now, reset calendar to default state:
|
|
c->adoptTimeZone(zone); // Set the correct time zone
|
|
c->setTimeInMillis(getNow(), success); // let the new calendar have the current time.
|
|
|
|
return c;
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
Calendar* U_EXPORT2
|
|
Calendar::createInstance(const TimeZone& zone, const Locale& aLocale, UErrorCode& success)
|
|
{
|
|
Calendar* c = createInstance(aLocale, success);
|
|
if(U_SUCCESS(success) && c) {
|
|
c->setTimeZone(zone);
|
|
}
|
|
return c;
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
UBool
|
|
Calendar::operator==(const Calendar& that) const
|
|
{
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
return isEquivalentTo(that) &&
|
|
getTimeInMillis(status) == that.getTimeInMillis(status) &&
|
|
U_SUCCESS(status);
|
|
}
|
|
|
|
UBool
|
|
Calendar::isEquivalentTo(const Calendar& other) const
|
|
{
|
|
return typeid(*this) == typeid(other) &&
|
|
fLenient == other.fLenient &&
|
|
fRepeatedWallTime == other.fRepeatedWallTime &&
|
|
fSkippedWallTime == other.fSkippedWallTime &&
|
|
fFirstDayOfWeek == other.fFirstDayOfWeek &&
|
|
fMinimalDaysInFirstWeek == other.fMinimalDaysInFirstWeek &&
|
|
fWeekendOnset == other.fWeekendOnset &&
|
|
fWeekendOnsetMillis == other.fWeekendOnsetMillis &&
|
|
fWeekendCease == other.fWeekendCease &&
|
|
fWeekendCeaseMillis == other.fWeekendCeaseMillis &&
|
|
*fZone == *other.fZone;
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
UBool
|
|
Calendar::equals(const Calendar& when, UErrorCode& status) const
|
|
{
|
|
return (this == &when ||
|
|
getTime(status) == when.getTime(status));
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
UBool
|
|
Calendar::before(const Calendar& when, UErrorCode& status) const
|
|
{
|
|
return (this != &when &&
|
|
getTimeInMillis(status) < when.getTimeInMillis(status));
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
UBool
|
|
Calendar::after(const Calendar& when, UErrorCode& status) const
|
|
{
|
|
return (this != &when &&
|
|
getTimeInMillis(status) > when.getTimeInMillis(status));
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
|
|
const Locale* U_EXPORT2
|
|
Calendar::getAvailableLocales(int32_t& count)
|
|
{
|
|
return Locale::getAvailableLocales(count);
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
StringEnumeration* U_EXPORT2
|
|
Calendar::getKeywordValuesForLocale(const char* key,
|
|
const Locale& locale, UBool commonlyUsed, UErrorCode& status)
|
|
{
|
|
// This is a wrapper over ucal_getKeywordValuesForLocale
|
|
UEnumeration *uenum = ucal_getKeywordValuesForLocale(key, locale.getName(),
|
|
commonlyUsed, &status);
|
|
if (U_FAILURE(status)) {
|
|
uenum_close(uenum);
|
|
return NULL;
|
|
}
|
|
return new UStringEnumeration(uenum);
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
UDate U_EXPORT2
|
|
Calendar::getNow()
|
|
{
|
|
return uprv_getUTCtime(); // return as milliseconds
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
/**
|
|
* Gets this Calendar's current time as a long.
|
|
* @return the current time as UTC milliseconds from the epoch.
|
|
*/
|
|
double
|
|
Calendar::getTimeInMillis(UErrorCode& status) const
|
|
{
|
|
if(U_FAILURE(status))
|
|
return 0.0;
|
|
|
|
if ( ! fIsTimeSet)
|
|
((Calendar*)this)->updateTime(status);
|
|
|
|
/* Test for buffer overflows */
|
|
if(U_FAILURE(status)) {
|
|
return 0.0;
|
|
}
|
|
return fTime;
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
/**
|
|
* Sets this Calendar's current time from the given long value.
|
|
* A status of U_ILLEGAL_ARGUMENT_ERROR is set when millis is
|
|
* outside the range permitted by a Calendar object when not in lenient mode.
|
|
* when in lenient mode the out of range values are pinned to their respective min/max.
|
|
* @param date the new time in UTC milliseconds from the epoch.
|
|
*/
|
|
void
|
|
Calendar::setTimeInMillis( double millis, UErrorCode& status ) {
|
|
if(U_FAILURE(status))
|
|
return;
|
|
|
|
if (millis > MAX_MILLIS) {
|
|
if(isLenient()) {
|
|
millis = MAX_MILLIS;
|
|
} else {
|
|
status = U_ILLEGAL_ARGUMENT_ERROR;
|
|
return;
|
|
}
|
|
} else if (millis < MIN_MILLIS) {
|
|
if(isLenient()) {
|
|
millis = MIN_MILLIS;
|
|
} else {
|
|
status = U_ILLEGAL_ARGUMENT_ERROR;
|
|
return;
|
|
}
|
|
}
|
|
|
|
fTime = millis;
|
|
fAreFieldsSet = fAreAllFieldsSet = FALSE;
|
|
fIsTimeSet = fAreFieldsVirtuallySet = TRUE;
|
|
|
|
for (int32_t i=0; i<UCAL_FIELD_COUNT; ++i) {
|
|
fFields[i] = 0;
|
|
fStamp[i] = kUnset;
|
|
fIsSet[i] = FALSE;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
int32_t
|
|
Calendar::get(UCalendarDateFields field, UErrorCode& status) const
|
|
{
|
|
// field values are only computed when actually requested; for more on when computation
|
|
// of various things happens, see the "data flow in Calendar" description at the top
|
|
// of this file
|
|
if (U_SUCCESS(status)) ((Calendar*)this)->complete(status); // Cast away const
|
|
return U_SUCCESS(status) ? fFields[field] : 0;
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
void
|
|
Calendar::set(UCalendarDateFields field, int32_t value)
|
|
{
|
|
if (fAreFieldsVirtuallySet) {
|
|
UErrorCode ec = U_ZERO_ERROR;
|
|
computeFields(ec);
|
|
}
|
|
fFields[field] = value;
|
|
/* Ensure that the fNextStamp value doesn't go pass max value for int32_t */
|
|
if (fNextStamp == STAMP_MAX) {
|
|
recalculateStamp();
|
|
}
|
|
fStamp[field] = fNextStamp++;
|
|
fIsSet[field] = TRUE; // Remove later
|
|
fIsTimeSet = fAreFieldsSet = fAreFieldsVirtuallySet = FALSE;
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
void
|
|
Calendar::set(int32_t year, int32_t month, int32_t date)
|
|
{
|
|
set(UCAL_YEAR, year);
|
|
set(UCAL_MONTH, month);
|
|
set(UCAL_DATE, date);
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
void
|
|
Calendar::set(int32_t year, int32_t month, int32_t date, int32_t hour, int32_t minute)
|
|
{
|
|
set(UCAL_YEAR, year);
|
|
set(UCAL_MONTH, month);
|
|
set(UCAL_DATE, date);
|
|
set(UCAL_HOUR_OF_DAY, hour);
|
|
set(UCAL_MINUTE, minute);
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
void
|
|
Calendar::set(int32_t year, int32_t month, int32_t date, int32_t hour, int32_t minute, int32_t second)
|
|
{
|
|
set(UCAL_YEAR, year);
|
|
set(UCAL_MONTH, month);
|
|
set(UCAL_DATE, date);
|
|
set(UCAL_HOUR_OF_DAY, hour);
|
|
set(UCAL_MINUTE, minute);
|
|
set(UCAL_SECOND, second);
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
void
|
|
Calendar::clear()
|
|
{
|
|
for (int32_t i=0; i<UCAL_FIELD_COUNT; ++i) {
|
|
fFields[i] = 0; // Must do this; other code depends on it
|
|
fStamp[i] = kUnset;
|
|
fIsSet[i] = FALSE; // Remove later
|
|
}
|
|
fIsTimeSet = fAreFieldsSet = fAreAllFieldsSet = fAreFieldsVirtuallySet = FALSE;
|
|
// fTime is not 'cleared' - may be used if no fields are set.
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
void
|
|
Calendar::clear(UCalendarDateFields field)
|
|
{
|
|
if (fAreFieldsVirtuallySet) {
|
|
UErrorCode ec = U_ZERO_ERROR;
|
|
computeFields(ec);
|
|
}
|
|
fFields[field] = 0;
|
|
fStamp[field] = kUnset;
|
|
fIsSet[field] = FALSE; // Remove later
|
|
fIsTimeSet = fAreFieldsSet = fAreAllFieldsSet = fAreFieldsVirtuallySet = FALSE;
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
UBool
|
|
Calendar::isSet(UCalendarDateFields field) const
|
|
{
|
|
return fAreFieldsVirtuallySet || (fStamp[field] != kUnset);
|
|
}
|
|
|
|
|
|
int32_t Calendar::newestStamp(UCalendarDateFields first, UCalendarDateFields last, int32_t bestStampSoFar) const
|
|
{
|
|
int32_t bestStamp = bestStampSoFar;
|
|
for (int32_t i=(int32_t)first; i<=(int32_t)last; ++i) {
|
|
if (fStamp[i] > bestStamp) {
|
|
bestStamp = fStamp[i];
|
|
}
|
|
}
|
|
return bestStamp;
|
|
}
|
|
|
|
|
|
// -------------------------------------
|
|
|
|
void
|
|
Calendar::complete(UErrorCode& status)
|
|
{
|
|
if (!fIsTimeSet) {
|
|
updateTime(status);
|
|
/* Test for buffer overflows */
|
|
if(U_FAILURE(status)) {
|
|
return;
|
|
}
|
|
}
|
|
if (!fAreFieldsSet) {
|
|
computeFields(status); // fills in unset fields
|
|
/* Test for buffer overflows */
|
|
if(U_FAILURE(status)) {
|
|
return;
|
|
}
|
|
fAreFieldsSet = TRUE;
|
|
fAreAllFieldsSet = TRUE;
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
// Protected utility methods for use by subclasses. These are very handy
|
|
// for implementing add, roll, and computeFields.
|
|
//-------------------------------------------------------------------------
|
|
|
|
/**
|
|
* Adjust the specified field so that it is within
|
|
* the allowable range for the date to which this calendar is set.
|
|
* For example, in a Gregorian calendar pinning the {@link #DAY_OF_MONTH DAY_OF_MONTH}
|
|
* field for a calendar set to April 31 would cause it to be set
|
|
* to April 30.
|
|
* <p>
|
|
* <b>Subclassing:</b>
|
|
* <br>
|
|
* This utility method is intended for use by subclasses that need to implement
|
|
* their own overrides of {@link #roll roll} and {@link #add add}.
|
|
* <p>
|
|
* <b>Note:</b>
|
|
* <code>pinField</code> is implemented in terms of
|
|
* {@link #getActualMinimum getActualMinimum}
|
|
* and {@link #getActualMaximum getActualMaximum}. If either of those methods uses
|
|
* a slow, iterative algorithm for a particular field, it would be
|
|
* unwise to attempt to call <code>pinField</code> for that field. If you
|
|
* really do need to do so, you should override this method to do
|
|
* something more efficient for that field.
|
|
* <p>
|
|
* @param field The calendar field whose value should be pinned.
|
|
*
|
|
* @see #getActualMinimum
|
|
* @see #getActualMaximum
|
|
* @stable ICU 2.0
|
|
*/
|
|
void Calendar::pinField(UCalendarDateFields field, UErrorCode& status) {
|
|
int32_t max = getActualMaximum(field, status);
|
|
int32_t min = getActualMinimum(field, status);
|
|
|
|
if (fFields[field] > max) {
|
|
set(field, max);
|
|
} else if (fFields[field] < min) {
|
|
set(field, min);
|
|
}
|
|
}
|
|
|
|
|
|
void Calendar::computeFields(UErrorCode &ec)
|
|
{
|
|
if (U_FAILURE(ec)) {
|
|
return;
|
|
}
|
|
// Compute local wall millis
|
|
double localMillis = internalGetTime();
|
|
int32_t rawOffset, dstOffset;
|
|
getTimeZone().getOffset(localMillis, FALSE, rawOffset, dstOffset, ec);
|
|
localMillis += (rawOffset + dstOffset);
|
|
|
|
// Mark fields as set. Do this before calling handleComputeFields().
|
|
uint32_t mask = //fInternalSetMask;
|
|
(1 << UCAL_ERA) |
|
|
(1 << UCAL_YEAR) |
|
|
(1 << UCAL_MONTH) |
|
|
(1 << UCAL_DAY_OF_MONTH) | // = UCAL_DATE
|
|
(1 << UCAL_DAY_OF_YEAR) |
|
|
(1 << UCAL_EXTENDED_YEAR);
|
|
|
|
for (int32_t i=0; i<UCAL_FIELD_COUNT; ++i) {
|
|
if ((mask & 1) == 0) {
|
|
fStamp[i] = kInternallySet;
|
|
fIsSet[i] = TRUE; // Remove later
|
|
} else {
|
|
fStamp[i] = kUnset;
|
|
fIsSet[i] = FALSE; // Remove later
|
|
}
|
|
mask >>= 1;
|
|
}
|
|
|
|
// We used to check for and correct extreme millis values (near
|
|
// Long.MIN_VALUE or Long.MAX_VALUE) here. Such values would cause
|
|
// overflows from positive to negative (or vice versa) and had to
|
|
// be manually tweaked. We no longer need to do this because we
|
|
// have limited the range of supported dates to those that have a
|
|
// Julian day that fits into an int. This allows us to implement a
|
|
// JULIAN_DAY field and also removes some inelegant code. - Liu
|
|
// 11/6/00
|
|
|
|
int32_t days = (int32_t)ClockMath::floorDivide(localMillis, (double)kOneDay);
|
|
|
|
internalSet(UCAL_JULIAN_DAY,days + kEpochStartAsJulianDay);
|
|
|
|
#if defined (U_DEBUG_CAL)
|
|
//fprintf(stderr, "%s:%d- Hmm! Jules @ %d, as per %.0lf millis\n",
|
|
//__FILE__, __LINE__, fFields[UCAL_JULIAN_DAY], localMillis);
|
|
#endif
|
|
|
|
computeGregorianAndDOWFields(fFields[UCAL_JULIAN_DAY], ec);
|
|
|
|
// Call framework method to have subclass compute its fields.
|
|
// These must include, at a minimum, MONTH, DAY_OF_MONTH,
|
|
// EXTENDED_YEAR, YEAR, DAY_OF_YEAR. This method will call internalSet(),
|
|
// which will update stamp[].
|
|
handleComputeFields(fFields[UCAL_JULIAN_DAY], ec);
|
|
|
|
// Compute week-related fields, based on the subclass-computed
|
|
// fields computed by handleComputeFields().
|
|
computeWeekFields(ec);
|
|
|
|
// Compute time-related fields. These are indepent of the date and
|
|
// of the subclass algorithm. They depend only on the local zone
|
|
// wall milliseconds in day.
|
|
int32_t millisInDay = (int32_t) (localMillis - (days * kOneDay));
|
|
fFields[UCAL_MILLISECONDS_IN_DAY] = millisInDay;
|
|
fFields[UCAL_MILLISECOND] = millisInDay % 1000;
|
|
millisInDay /= 1000;
|
|
fFields[UCAL_SECOND] = millisInDay % 60;
|
|
millisInDay /= 60;
|
|
fFields[UCAL_MINUTE] = millisInDay % 60;
|
|
millisInDay /= 60;
|
|
fFields[UCAL_HOUR_OF_DAY] = millisInDay;
|
|
fFields[UCAL_AM_PM] = millisInDay / 12; // Assume AM == 0
|
|
fFields[UCAL_HOUR] = millisInDay % 12;
|
|
fFields[UCAL_ZONE_OFFSET] = rawOffset;
|
|
fFields[UCAL_DST_OFFSET] = dstOffset;
|
|
}
|
|
|
|
uint8_t Calendar::julianDayToDayOfWeek(double julian)
|
|
{
|
|
// If julian is negative, then julian%7 will be negative, so we adjust
|
|
// accordingly. We add 1 because Julian day 0 is Monday.
|
|
int8_t dayOfWeek = (int8_t) uprv_fmod(julian + 1, 7);
|
|
|
|
uint8_t result = (uint8_t)(dayOfWeek + ((dayOfWeek < 0) ? (7+UCAL_SUNDAY ) : UCAL_SUNDAY));
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Compute the Gregorian calendar year, month, and day of month from
|
|
* the given Julian day. These values are not stored in fields, but in
|
|
* member variables gregorianXxx. Also compute the DAY_OF_WEEK and
|
|
* DOW_LOCAL fields.
|
|
*/
|
|
void Calendar::computeGregorianAndDOWFields(int32_t julianDay, UErrorCode &ec)
|
|
{
|
|
computeGregorianFields(julianDay, ec);
|
|
|
|
// Compute day of week: JD 0 = Monday
|
|
int32_t dow = julianDayToDayOfWeek(julianDay);
|
|
internalSet(UCAL_DAY_OF_WEEK,dow);
|
|
|
|
// Calculate 1-based localized day of week
|
|
int32_t dowLocal = dow - getFirstDayOfWeek() + 1;
|
|
if (dowLocal < 1) {
|
|
dowLocal += 7;
|
|
}
|
|
internalSet(UCAL_DOW_LOCAL,dowLocal);
|
|
fFields[UCAL_DOW_LOCAL] = dowLocal;
|
|
}
|
|
|
|
/**
|
|
* Compute the Gregorian calendar year, month, and day of month from the
|
|
* Julian day. These values are not stored in fields, but in member
|
|
* variables gregorianXxx. They are used for time zone computations and by
|
|
* subclasses that are Gregorian derivatives. Subclasses may call this
|
|
* method to perform a Gregorian calendar millis->fields computation.
|
|
*/
|
|
void Calendar::computeGregorianFields(int32_t julianDay, UErrorCode & /* ec */) {
|
|
int32_t gregorianDayOfWeekUnused;
|
|
Grego::dayToFields(julianDay - kEpochStartAsJulianDay, fGregorianYear, fGregorianMonth, fGregorianDayOfMonth, gregorianDayOfWeekUnused, fGregorianDayOfYear);
|
|
}
|
|
|
|
/**
|
|
* Compute the fields WEEK_OF_YEAR, YEAR_WOY, WEEK_OF_MONTH,
|
|
* DAY_OF_WEEK_IN_MONTH, and DOW_LOCAL from EXTENDED_YEAR, YEAR,
|
|
* DAY_OF_WEEK, and DAY_OF_YEAR. The latter fields are computed by the
|
|
* subclass based on the calendar system.
|
|
*
|
|
* <p>The YEAR_WOY field is computed simplistically. It is equal to YEAR
|
|
* most of the time, but at the year boundary it may be adjusted to YEAR-1
|
|
* or YEAR+1 to reflect the overlap of a week into an adjacent year. In
|
|
* this case, a simple increment or decrement is performed on YEAR, even
|
|
* though this may yield an invalid YEAR value. For instance, if the YEAR
|
|
* is part of a calendar system with an N-year cycle field CYCLE, then
|
|
* incrementing the YEAR may involve incrementing CYCLE and setting YEAR
|
|
* back to 0 or 1. This is not handled by this code, and in fact cannot be
|
|
* simply handled without having subclasses define an entire parallel set of
|
|
* fields for fields larger than or equal to a year. This additional
|
|
* complexity is not warranted, since the intention of the YEAR_WOY field is
|
|
* to support ISO 8601 notation, so it will typically be used with a
|
|
* proleptic Gregorian calendar, which has no field larger than a year.
|
|
*/
|
|
void Calendar::computeWeekFields(UErrorCode &ec) {
|
|
if(U_FAILURE(ec)) {
|
|
return;
|
|
}
|
|
int32_t eyear = fFields[UCAL_EXTENDED_YEAR];
|
|
int32_t dayOfWeek = fFields[UCAL_DAY_OF_WEEK];
|
|
int32_t dayOfYear = fFields[UCAL_DAY_OF_YEAR];
|
|
|
|
// WEEK_OF_YEAR start
|
|
// Compute the week of the year. For the Gregorian calendar, valid week
|
|
// numbers run from 1 to 52 or 53, depending on the year, the first day
|
|
// of the week, and the minimal days in the first week. For other
|
|
// calendars, the valid range may be different -- it depends on the year
|
|
// length. Days at the start of the year may fall into the last week of
|
|
// the previous year; days at the end of the year may fall into the
|
|
// first week of the next year. ASSUME that the year length is less than
|
|
// 7000 days.
|
|
int32_t yearOfWeekOfYear = eyear;
|
|
int32_t relDow = (dayOfWeek + 7 - getFirstDayOfWeek()) % 7; // 0..6
|
|
int32_t relDowJan1 = (dayOfWeek - dayOfYear + 7001 - getFirstDayOfWeek()) % 7; // 0..6
|
|
int32_t woy = (dayOfYear - 1 + relDowJan1) / 7; // 0..53
|
|
if ((7 - relDowJan1) >= getMinimalDaysInFirstWeek()) {
|
|
++woy;
|
|
}
|
|
|
|
// Adjust for weeks at the year end that overlap into the previous or
|
|
// next calendar year.
|
|
if (woy == 0) {
|
|
// We are the last week of the previous year.
|
|
// Check to see if we are in the last week; if so, we need
|
|
// to handle the case in which we are the first week of the
|
|
// next year.
|
|
|
|
int32_t prevDoy = dayOfYear + handleGetYearLength(eyear - 1);
|
|
woy = weekNumber(prevDoy, dayOfWeek);
|
|
yearOfWeekOfYear--;
|
|
} else {
|
|
int32_t lastDoy = handleGetYearLength(eyear);
|
|
// Fast check: For it to be week 1 of the next year, the DOY
|
|
// must be on or after L-5, where L is yearLength(), then it
|
|
// cannot possibly be week 1 of the next year:
|
|
// L-5 L
|
|
// doy: 359 360 361 362 363 364 365 001
|
|
// dow: 1 2 3 4 5 6 7
|
|
if (dayOfYear >= (lastDoy - 5)) {
|
|
int32_t lastRelDow = (relDow + lastDoy - dayOfYear) % 7;
|
|
if (lastRelDow < 0) {
|
|
lastRelDow += 7;
|
|
}
|
|
if (((6 - lastRelDow) >= getMinimalDaysInFirstWeek()) &&
|
|
((dayOfYear + 7 - relDow) > lastDoy)) {
|
|
woy = 1;
|
|
yearOfWeekOfYear++;
|
|
}
|
|
}
|
|
}
|
|
fFields[UCAL_WEEK_OF_YEAR] = woy;
|
|
fFields[UCAL_YEAR_WOY] = yearOfWeekOfYear;
|
|
// WEEK_OF_YEAR end
|
|
|
|
int32_t dayOfMonth = fFields[UCAL_DAY_OF_MONTH];
|
|
fFields[UCAL_WEEK_OF_MONTH] = weekNumber(dayOfMonth, dayOfWeek);
|
|
fFields[UCAL_DAY_OF_WEEK_IN_MONTH] = (dayOfMonth-1) / 7 + 1;
|
|
#if defined (U_DEBUG_CAL)
|
|
if(fFields[UCAL_DAY_OF_WEEK_IN_MONTH]==0) fprintf(stderr, "%s:%d: DOWIM %d on %g\n",
|
|
__FILE__, __LINE__,fFields[UCAL_DAY_OF_WEEK_IN_MONTH], fTime);
|
|
#endif
|
|
}
|
|
|
|
|
|
int32_t Calendar::weekNumber(int32_t desiredDay, int32_t dayOfPeriod, int32_t dayOfWeek)
|
|
{
|
|
// Determine the day of the week of the first day of the period
|
|
// in question (either a year or a month). Zero represents the
|
|
// first day of the week on this calendar.
|
|
int32_t periodStartDayOfWeek = (dayOfWeek - getFirstDayOfWeek() - dayOfPeriod + 1) % 7;
|
|
if (periodStartDayOfWeek < 0) periodStartDayOfWeek += 7;
|
|
|
|
// Compute the week number. Initially, ignore the first week, which
|
|
// may be fractional (or may not be). We add periodStartDayOfWeek in
|
|
// order to fill out the first week, if it is fractional.
|
|
int32_t weekNo = (desiredDay + periodStartDayOfWeek - 1)/7;
|
|
|
|
// If the first week is long enough, then count it. If
|
|
// the minimal days in the first week is one, or if the period start
|
|
// is zero, we always increment weekNo.
|
|
if ((7 - periodStartDayOfWeek) >= getMinimalDaysInFirstWeek()) ++weekNo;
|
|
|
|
return weekNo;
|
|
}
|
|
|
|
void Calendar::handleComputeFields(int32_t /* julianDay */, UErrorCode &/* status */)
|
|
{
|
|
internalSet(UCAL_MONTH, getGregorianMonth());
|
|
internalSet(UCAL_DAY_OF_MONTH, getGregorianDayOfMonth());
|
|
internalSet(UCAL_DAY_OF_YEAR, getGregorianDayOfYear());
|
|
int32_t eyear = getGregorianYear();
|
|
internalSet(UCAL_EXTENDED_YEAR, eyear);
|
|
int32_t era = GregorianCalendar::AD;
|
|
if (eyear < 1) {
|
|
era = GregorianCalendar::BC;
|
|
eyear = 1 - eyear;
|
|
}
|
|
internalSet(UCAL_ERA, era);
|
|
internalSet(UCAL_YEAR, eyear);
|
|
}
|
|
// -------------------------------------
|
|
|
|
|
|
void Calendar::roll(EDateFields field, int32_t amount, UErrorCode& status)
|
|
{
|
|
roll((UCalendarDateFields)field, amount, status);
|
|
}
|
|
|
|
void Calendar::roll(UCalendarDateFields field, int32_t amount, UErrorCode& status)
|
|
{
|
|
if (amount == 0) {
|
|
return; // Nothing to do
|
|
}
|
|
|
|
complete(status);
|
|
|
|
if(U_FAILURE(status)) {
|
|
return;
|
|
}
|
|
switch (field) {
|
|
case UCAL_DAY_OF_MONTH:
|
|
case UCAL_AM_PM:
|
|
case UCAL_MINUTE:
|
|
case UCAL_SECOND:
|
|
case UCAL_MILLISECOND:
|
|
case UCAL_MILLISECONDS_IN_DAY:
|
|
case UCAL_ERA:
|
|
// These are the standard roll instructions. These work for all
|
|
// simple cases, that is, cases in which the limits are fixed, such
|
|
// as the hour, the day of the month, and the era.
|
|
{
|
|
int32_t min = getActualMinimum(field,status);
|
|
int32_t max = getActualMaximum(field,status);
|
|
int32_t gap = max - min + 1;
|
|
|
|
int32_t value = internalGet(field) + amount;
|
|
value = (value - min) % gap;
|
|
if (value < 0) {
|
|
value += gap;
|
|
}
|
|
value += min;
|
|
|
|
set(field, value);
|
|
return;
|
|
}
|
|
|
|
case UCAL_HOUR:
|
|
case UCAL_HOUR_OF_DAY:
|
|
// Rolling the hour is difficult on the ONSET and CEASE days of
|
|
// daylight savings. For example, if the change occurs at
|
|
// 2 AM, we have the following progression:
|
|
// ONSET: 12 Std -> 1 Std -> 3 Dst -> 4 Dst
|
|
// CEASE: 12 Dst -> 1 Dst -> 1 Std -> 2 Std
|
|
// To get around this problem we don't use fields; we manipulate
|
|
// the time in millis directly.
|
|
{
|
|
// Assume min == 0 in calculations below
|
|
double start = getTimeInMillis(status);
|
|
int32_t oldHour = internalGet(field);
|
|
int32_t max = getMaximum(field);
|
|
int32_t newHour = (oldHour + amount) % (max + 1);
|
|
if (newHour < 0) {
|
|
newHour += max + 1;
|
|
}
|
|
setTimeInMillis(start + kOneHour * (newHour - oldHour),status);
|
|
return;
|
|
}
|
|
|
|
case UCAL_MONTH:
|
|
// Rolling the month involves both pinning the final value
|
|
// and adjusting the DAY_OF_MONTH if necessary. We only adjust the
|
|
// DAY_OF_MONTH if, after updating the MONTH field, it is illegal.
|
|
// E.g., <jan31>.roll(MONTH, 1) -> <feb28> or <feb29>.
|
|
{
|
|
int32_t max = getActualMaximum(UCAL_MONTH, status);
|
|
int32_t mon = (internalGet(UCAL_MONTH) + amount) % (max+1);
|
|
|
|
if (mon < 0) {
|
|
mon += (max + 1);
|
|
}
|
|
set(UCAL_MONTH, mon);
|
|
|
|
// Keep the day of month in range. We don't want to spill over
|
|
// into the next month; e.g., we don't want jan31 + 1 mo -> feb31 ->
|
|
// mar3.
|
|
pinField(UCAL_DAY_OF_MONTH,status);
|
|
return;
|
|
}
|
|
|
|
case UCAL_YEAR:
|
|
case UCAL_YEAR_WOY:
|
|
{
|
|
// * If era==0 and years go backwards in time, change sign of amount.
|
|
// * Until we have new API per #9393, we temporarily hardcode knowledge of
|
|
// which calendars have era 0 years that go backwards.
|
|
UBool era0WithYearsThatGoBackwards = FALSE;
|
|
int32_t era = get(UCAL_ERA, status);
|
|
if (era == 0) {
|
|
const char * calType = getType();
|
|
if ( uprv_strcmp(calType,"gregorian")==0 || uprv_strcmp(calType,"roc")==0 || uprv_strcmp(calType,"coptic")==0 ) {
|
|
amount = -amount;
|
|
era0WithYearsThatGoBackwards = TRUE;
|
|
}
|
|
}
|
|
int32_t newYear = internalGet(field) + amount;
|
|
if (era > 0 || newYear >= 1) {
|
|
int32_t maxYear = getActualMaximum(field, status);
|
|
if (maxYear < 32768) {
|
|
// this era has real bounds, roll should wrap years
|
|
if (newYear < 1) {
|
|
newYear = maxYear - ((-newYear) % maxYear);
|
|
} else if (newYear > maxYear) {
|
|
newYear = ((newYear - 1) % maxYear) + 1;
|
|
}
|
|
// else era is unbounded, just pin low year instead of wrapping
|
|
} else if (newYear < 1) {
|
|
newYear = 1;
|
|
}
|
|
// else we are in era 0 with newYear < 1;
|
|
// calendars with years that go backwards must pin the year value at 0,
|
|
// other calendars can have years < 0 in era 0
|
|
} else if (era0WithYearsThatGoBackwards) {
|
|
newYear = 1;
|
|
}
|
|
set(field, newYear);
|
|
pinField(UCAL_MONTH,status);
|
|
pinField(UCAL_DAY_OF_MONTH,status);
|
|
return;
|
|
}
|
|
|
|
case UCAL_EXTENDED_YEAR:
|
|
// Rolling the year can involve pinning the DAY_OF_MONTH.
|
|
set(field, internalGet(field) + amount);
|
|
pinField(UCAL_MONTH,status);
|
|
pinField(UCAL_DAY_OF_MONTH,status);
|
|
return;
|
|
|
|
case UCAL_WEEK_OF_MONTH:
|
|
{
|
|
// This is tricky, because during the roll we may have to shift
|
|
// to a different day of the week. For example:
|
|
|
|
// s m t w r f s
|
|
// 1 2 3 4 5
|
|
// 6 7 8 9 10 11 12
|
|
|
|
// When rolling from the 6th or 7th back one week, we go to the
|
|
// 1st (assuming that the first partial week counts). The same
|
|
// thing happens at the end of the month.
|
|
|
|
// The other tricky thing is that we have to figure out whether
|
|
// the first partial week actually counts or not, based on the
|
|
// minimal first days in the week. And we have to use the
|
|
// correct first day of the week to delineate the week
|
|
// boundaries.
|
|
|
|
// Here's our algorithm. First, we find the real boundaries of
|
|
// the month. Then we discard the first partial week if it
|
|
// doesn't count in this locale. Then we fill in the ends with
|
|
// phantom days, so that the first partial week and the last
|
|
// partial week are full weeks. We then have a nice square
|
|
// block of weeks. We do the usual rolling within this block,
|
|
// as is done elsewhere in this method. If we wind up on one of
|
|
// the phantom days that we added, we recognize this and pin to
|
|
// the first or the last day of the month. Easy, eh?
|
|
|
|
// Normalize the DAY_OF_WEEK so that 0 is the first day of the week
|
|
// in this locale. We have dow in 0..6.
|
|
int32_t dow = internalGet(UCAL_DAY_OF_WEEK) - getFirstDayOfWeek();
|
|
if (dow < 0) dow += 7;
|
|
|
|
// Find the day of the week (normalized for locale) for the first
|
|
// of the month.
|
|
int32_t fdm = (dow - internalGet(UCAL_DAY_OF_MONTH) + 1) % 7;
|
|
if (fdm < 0) fdm += 7;
|
|
|
|
// Get the first day of the first full week of the month,
|
|
// including phantom days, if any. Figure out if the first week
|
|
// counts or not; if it counts, then fill in phantom days. If
|
|
// not, advance to the first real full week (skip the partial week).
|
|
int32_t start;
|
|
if ((7 - fdm) < getMinimalDaysInFirstWeek())
|
|
start = 8 - fdm; // Skip the first partial week
|
|
else
|
|
start = 1 - fdm; // This may be zero or negative
|
|
|
|
// Get the day of the week (normalized for locale) for the last
|
|
// day of the month.
|
|
int32_t monthLen = getActualMaximum(UCAL_DAY_OF_MONTH, status);
|
|
int32_t ldm = (monthLen - internalGet(UCAL_DAY_OF_MONTH) + dow) % 7;
|
|
// We know monthLen >= DAY_OF_MONTH so we skip the += 7 step here.
|
|
|
|
// Get the limit day for the blocked-off rectangular month; that
|
|
// is, the day which is one past the last day of the month,
|
|
// after the month has already been filled in with phantom days
|
|
// to fill out the last week. This day has a normalized DOW of 0.
|
|
int32_t limit = monthLen + 7 - ldm;
|
|
|
|
// Now roll between start and (limit - 1).
|
|
int32_t gap = limit - start;
|
|
int32_t day_of_month = (internalGet(UCAL_DAY_OF_MONTH) + amount*7 -
|
|
start) % gap;
|
|
if (day_of_month < 0) day_of_month += gap;
|
|
day_of_month += start;
|
|
|
|
// Finally, pin to the real start and end of the month.
|
|
if (day_of_month < 1) day_of_month = 1;
|
|
if (day_of_month > monthLen) day_of_month = monthLen;
|
|
|
|
// Set the DAY_OF_MONTH. We rely on the fact that this field
|
|
// takes precedence over everything else (since all other fields
|
|
// are also set at this point). If this fact changes (if the
|
|
// disambiguation algorithm changes) then we will have to unset
|
|
// the appropriate fields here so that DAY_OF_MONTH is attended
|
|
// to.
|
|
set(UCAL_DAY_OF_MONTH, day_of_month);
|
|
return;
|
|
}
|
|
case UCAL_WEEK_OF_YEAR:
|
|
{
|
|
// This follows the outline of WEEK_OF_MONTH, except it applies
|
|
// to the whole year. Please see the comment for WEEK_OF_MONTH
|
|
// for general notes.
|
|
|
|
// Normalize the DAY_OF_WEEK so that 0 is the first day of the week
|
|
// in this locale. We have dow in 0..6.
|
|
int32_t dow = internalGet(UCAL_DAY_OF_WEEK) - getFirstDayOfWeek();
|
|
if (dow < 0) dow += 7;
|
|
|
|
// Find the day of the week (normalized for locale) for the first
|
|
// of the year.
|
|
int32_t fdy = (dow - internalGet(UCAL_DAY_OF_YEAR) + 1) % 7;
|
|
if (fdy < 0) fdy += 7;
|
|
|
|
// Get the first day of the first full week of the year,
|
|
// including phantom days, if any. Figure out if the first week
|
|
// counts or not; if it counts, then fill in phantom days. If
|
|
// not, advance to the first real full week (skip the partial week).
|
|
int32_t start;
|
|
if ((7 - fdy) < getMinimalDaysInFirstWeek())
|
|
start = 8 - fdy; // Skip the first partial week
|
|
else
|
|
start = 1 - fdy; // This may be zero or negative
|
|
|
|
// Get the day of the week (normalized for locale) for the last
|
|
// day of the year.
|
|
int32_t yearLen = getActualMaximum(UCAL_DAY_OF_YEAR,status);
|
|
int32_t ldy = (yearLen - internalGet(UCAL_DAY_OF_YEAR) + dow) % 7;
|
|
// We know yearLen >= DAY_OF_YEAR so we skip the += 7 step here.
|
|
|
|
// Get the limit day for the blocked-off rectangular year; that
|
|
// is, the day which is one past the last day of the year,
|
|
// after the year has already been filled in with phantom days
|
|
// to fill out the last week. This day has a normalized DOW of 0.
|
|
int32_t limit = yearLen + 7 - ldy;
|
|
|
|
// Now roll between start and (limit - 1).
|
|
int32_t gap = limit - start;
|
|
int32_t day_of_year = (internalGet(UCAL_DAY_OF_YEAR) + amount*7 -
|
|
start) % gap;
|
|
if (day_of_year < 0) day_of_year += gap;
|
|
day_of_year += start;
|
|
|
|
// Finally, pin to the real start and end of the month.
|
|
if (day_of_year < 1) day_of_year = 1;
|
|
if (day_of_year > yearLen) day_of_year = yearLen;
|
|
|
|
// Make sure that the year and day of year are attended to by
|
|
// clearing other fields which would normally take precedence.
|
|
// If the disambiguation algorithm is changed, this section will
|
|
// have to be updated as well.
|
|
set(UCAL_DAY_OF_YEAR, day_of_year);
|
|
clear(UCAL_MONTH);
|
|
return;
|
|
}
|
|
case UCAL_DAY_OF_YEAR:
|
|
{
|
|
// Roll the day of year using millis. Compute the millis for
|
|
// the start of the year, and get the length of the year.
|
|
double delta = amount * kOneDay; // Scale up from days to millis
|
|
double min2 = internalGet(UCAL_DAY_OF_YEAR)-1;
|
|
min2 *= kOneDay;
|
|
min2 = internalGetTime() - min2;
|
|
|
|
// double min2 = internalGetTime() - (internalGet(UCAL_DAY_OF_YEAR) - 1.0) * kOneDay;
|
|
double newtime;
|
|
|
|
double yearLength = getActualMaximum(UCAL_DAY_OF_YEAR,status);
|
|
double oneYear = yearLength;
|
|
oneYear *= kOneDay;
|
|
newtime = uprv_fmod((internalGetTime() + delta - min2), oneYear);
|
|
if (newtime < 0) newtime += oneYear;
|
|
setTimeInMillis(newtime + min2, status);
|
|
return;
|
|
}
|
|
case UCAL_DAY_OF_WEEK:
|
|
case UCAL_DOW_LOCAL:
|
|
{
|
|
// Roll the day of week using millis. Compute the millis for
|
|
// the start of the week, using the first day of week setting.
|
|
// Restrict the millis to [start, start+7days).
|
|
double delta = amount * kOneDay; // Scale up from days to millis
|
|
// Compute the number of days before the current day in this
|
|
// week. This will be a value 0..6.
|
|
int32_t leadDays = internalGet(field);
|
|
leadDays -= (field == UCAL_DAY_OF_WEEK) ? getFirstDayOfWeek() : 1;
|
|
if (leadDays < 0) leadDays += 7;
|
|
double min2 = internalGetTime() - leadDays * kOneDay;
|
|
double newtime = uprv_fmod((internalGetTime() + delta - min2), kOneWeek);
|
|
if (newtime < 0) newtime += kOneWeek;
|
|
setTimeInMillis(newtime + min2, status);
|
|
return;
|
|
}
|
|
case UCAL_DAY_OF_WEEK_IN_MONTH:
|
|
{
|
|
// Roll the day of week in the month using millis. Determine
|
|
// the first day of the week in the month, and then the last,
|
|
// and then roll within that range.
|
|
double delta = amount * kOneWeek; // Scale up from weeks to millis
|
|
// Find the number of same days of the week before this one
|
|
// in this month.
|
|
int32_t preWeeks = (internalGet(UCAL_DAY_OF_MONTH) - 1) / 7;
|
|
// Find the number of same days of the week after this one
|
|
// in this month.
|
|
int32_t postWeeks = (getActualMaximum(UCAL_DAY_OF_MONTH,status) -
|
|
internalGet(UCAL_DAY_OF_MONTH)) / 7;
|
|
// From these compute the min and gap millis for rolling.
|
|
double min2 = internalGetTime() - preWeeks * kOneWeek;
|
|
double gap2 = kOneWeek * (preWeeks + postWeeks + 1); // Must add 1!
|
|
// Roll within this range
|
|
double newtime = uprv_fmod((internalGetTime() + delta - min2), gap2);
|
|
if (newtime < 0) newtime += gap2;
|
|
setTimeInMillis(newtime + min2, status);
|
|
return;
|
|
}
|
|
case UCAL_JULIAN_DAY:
|
|
set(field, internalGet(field) + amount);
|
|
return;
|
|
default:
|
|
// Other fields cannot be rolled by this method
|
|
#if defined (U_DEBUG_CAL)
|
|
fprintf(stderr, "%s:%d: ILLEGAL ARG because of roll on non-rollable field %s\n",
|
|
__FILE__, __LINE__,fldName(field));
|
|
#endif
|
|
status = U_ILLEGAL_ARGUMENT_ERROR;
|
|
}
|
|
}
|
|
|
|
void Calendar::add(EDateFields field, int32_t amount, UErrorCode& status)
|
|
{
|
|
Calendar::add((UCalendarDateFields)field, amount, status);
|
|
}
|
|
|
|
// -------------------------------------
|
|
void Calendar::add(UCalendarDateFields field, int32_t amount, UErrorCode& status)
|
|
{
|
|
if (amount == 0) {
|
|
return; // Do nothing!
|
|
}
|
|
|
|
// We handle most fields in the same way. The algorithm is to add
|
|
// a computed amount of millis to the current millis. The only
|
|
// wrinkle is with DST (and/or a change to the zone's UTC offset, which
|
|
// we'll include with DST) -- for some fields, like the DAY_OF_MONTH,
|
|
// we don't want the HOUR to shift due to changes in DST. If the
|
|
// result of the add operation is to move from DST to Standard, or
|
|
// vice versa, we need to adjust by an hour forward or back,
|
|
// respectively. For such fields we set keepHourInvariant to TRUE.
|
|
|
|
// We only adjust the DST for fields larger than an hour. For
|
|
// fields smaller than an hour, we cannot adjust for DST without
|
|
// causing problems. for instance, if you add one hour to April 5,
|
|
// 1998, 1:00 AM, in PST, the time becomes "2:00 AM PDT" (an
|
|
// illegal value), but then the adjustment sees the change and
|
|
// compensates by subtracting an hour. As a result the time
|
|
// doesn't advance at all.
|
|
|
|
// For some fields larger than a day, such as a UCAL_MONTH, we pin the
|
|
// UCAL_DAY_OF_MONTH. This allows <March 31>.add(UCAL_MONTH, 1) to be
|
|
// <April 30>, rather than <April 31> => <May 1>.
|
|
|
|
double delta = amount; // delta in ms
|
|
UBool keepHourInvariant = TRUE;
|
|
|
|
switch (field) {
|
|
case UCAL_ERA:
|
|
set(field, get(field, status) + amount);
|
|
pinField(UCAL_ERA, status);
|
|
return;
|
|
|
|
case UCAL_YEAR:
|
|
case UCAL_YEAR_WOY:
|
|
{
|
|
// * If era=0 and years go backwards in time, change sign of amount.
|
|
// * Until we have new API per #9393, we temporarily hardcode knowledge of
|
|
// which calendars have era 0 years that go backwards.
|
|
// * Note that for UCAL_YEAR (but not UCAL_YEAR_WOY) we could instead handle
|
|
// this by applying the amount to the UCAL_EXTENDED_YEAR field; but since
|
|
// we would still need to handle UCAL_YEAR_WOY as below, might as well
|
|
// also handle UCAL_YEAR the same way.
|
|
int32_t era = get(UCAL_ERA, status);
|
|
if (era == 0) {
|
|
const char * calType = getType();
|
|
if ( uprv_strcmp(calType,"gregorian")==0 || uprv_strcmp(calType,"roc")==0 || uprv_strcmp(calType,"coptic")==0 ) {
|
|
amount = -amount;
|
|
}
|
|
}
|
|
}
|
|
// Fall through into normal handling
|
|
case UCAL_EXTENDED_YEAR:
|
|
case UCAL_MONTH:
|
|
{
|
|
UBool oldLenient = isLenient();
|
|
setLenient(TRUE);
|
|
set(field, get(field, status) + amount);
|
|
pinField(UCAL_DAY_OF_MONTH, status);
|
|
if(oldLenient==FALSE) {
|
|
complete(status); /* force recalculate */
|
|
setLenient(oldLenient);
|
|
}
|
|
}
|
|
return;
|
|
|
|
case UCAL_WEEK_OF_YEAR:
|
|
case UCAL_WEEK_OF_MONTH:
|
|
case UCAL_DAY_OF_WEEK_IN_MONTH:
|
|
delta *= kOneWeek;
|
|
break;
|
|
|
|
case UCAL_AM_PM:
|
|
delta *= 12 * kOneHour;
|
|
break;
|
|
|
|
case UCAL_DAY_OF_MONTH:
|
|
case UCAL_DAY_OF_YEAR:
|
|
case UCAL_DAY_OF_WEEK:
|
|
case UCAL_DOW_LOCAL:
|
|
case UCAL_JULIAN_DAY:
|
|
delta *= kOneDay;
|
|
break;
|
|
|
|
case UCAL_HOUR_OF_DAY:
|
|
case UCAL_HOUR:
|
|
delta *= kOneHour;
|
|
keepHourInvariant = FALSE;
|
|
break;
|
|
|
|
case UCAL_MINUTE:
|
|
delta *= kOneMinute;
|
|
keepHourInvariant = FALSE;
|
|
break;
|
|
|
|
case UCAL_SECOND:
|
|
delta *= kOneSecond;
|
|
keepHourInvariant = FALSE;
|
|
break;
|
|
|
|
case UCAL_MILLISECOND:
|
|
case UCAL_MILLISECONDS_IN_DAY:
|
|
keepHourInvariant = FALSE;
|
|
break;
|
|
|
|
default:
|
|
#if defined (U_DEBUG_CAL)
|
|
fprintf(stderr, "%s:%d: ILLEGAL ARG because field %s not addable",
|
|
__FILE__, __LINE__, fldName(field));
|
|
#endif
|
|
status = U_ILLEGAL_ARGUMENT_ERROR;
|
|
return;
|
|
// throw new IllegalArgumentException("Calendar.add(" + fieldName(field) +
|
|
// ") not supported");
|
|
}
|
|
|
|
// In order to keep the hour invariant (for fields where this is
|
|
// appropriate), check the combined DST & ZONE offset before and
|
|
// after the add() operation. If it changes, then adjust the millis
|
|
// to compensate.
|
|
int32_t prevOffset = 0;
|
|
int32_t hour = 0;
|
|
if (keepHourInvariant) {
|
|
prevOffset = get(UCAL_DST_OFFSET, status) + get(UCAL_ZONE_OFFSET, status);
|
|
hour = internalGet(UCAL_HOUR_OF_DAY);
|
|
}
|
|
|
|
setTimeInMillis(getTimeInMillis(status) + delta, status);
|
|
|
|
if (keepHourInvariant) {
|
|
int32_t newOffset = get(UCAL_DST_OFFSET, status) + get(UCAL_ZONE_OFFSET, status);
|
|
if (newOffset != prevOffset) {
|
|
// We have done an hour-invariant adjustment but the
|
|
// combined offset has changed. We adjust millis to keep
|
|
// the hour constant. In cases such as midnight after
|
|
// a DST change which occurs at midnight, there is the
|
|
// danger of adjusting into a different day. To avoid
|
|
// this we make the adjustment only if it actually
|
|
// maintains the hour.
|
|
|
|
// When the difference of the previous UTC offset and
|
|
// the new UTC offset exceeds 1 full day, we do not want
|
|
// to roll over/back the date. For now, this only happens
|
|
// in Samoa (Pacific/Apia) on Dec 30, 2011. See ticket:9452.
|
|
int32_t adjAmount = prevOffset - newOffset;
|
|
adjAmount = adjAmount >= 0 ? adjAmount % (int32_t)kOneDay : -(-adjAmount % (int32_t)kOneDay);
|
|
if (adjAmount != 0) {
|
|
double t = internalGetTime();
|
|
setTimeInMillis(t + adjAmount, status);
|
|
if (get(UCAL_HOUR_OF_DAY, status) != hour) {
|
|
setTimeInMillis(t, status);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// -------------------------------------
|
|
int32_t Calendar::fieldDifference(UDate when, EDateFields field, UErrorCode& status) {
|
|
return fieldDifference(when, (UCalendarDateFields) field, status);
|
|
}
|
|
|
|
int32_t Calendar::fieldDifference(UDate targetMs, UCalendarDateFields field, UErrorCode& ec) {
|
|
if (U_FAILURE(ec)) return 0;
|
|
int32_t min = 0;
|
|
double startMs = getTimeInMillis(ec);
|
|
// Always add from the start millis. This accomodates
|
|
// operations like adding years from February 29, 2000 up to
|
|
// February 29, 2004. If 1, 1, 1, 1 is added to the year
|
|
// field, the DOM gets pinned to 28 and stays there, giving an
|
|
// incorrect DOM difference of 1. We have to add 1, reset, 2,
|
|
// reset, 3, reset, 4.
|
|
if (startMs < targetMs) {
|
|
int32_t max = 1;
|
|
// Find a value that is too large
|
|
while (U_SUCCESS(ec)) {
|
|
setTimeInMillis(startMs, ec);
|
|
add(field, max, ec);
|
|
double ms = getTimeInMillis(ec);
|
|
if (ms == targetMs) {
|
|
return max;
|
|
} else if (ms > targetMs) {
|
|
break;
|
|
} else if (max < INT32_MAX) {
|
|
min = max;
|
|
max <<= 1;
|
|
if (max < 0) {
|
|
max = INT32_MAX;
|
|
}
|
|
} else {
|
|
// Field difference too large to fit into int32_t
|
|
#if defined (U_DEBUG_CAL)
|
|
fprintf(stderr, "%s:%d: ILLEGAL ARG because field %s's max too large for int32_t\n",
|
|
__FILE__, __LINE__, fldName(field));
|
|
#endif
|
|
ec = U_ILLEGAL_ARGUMENT_ERROR;
|
|
}
|
|
}
|
|
// Do a binary search
|
|
while ((max - min) > 1 && U_SUCCESS(ec)) {
|
|
int32_t t = min + (max - min)/2; // make sure intermediate values don't exceed INT32_MAX
|
|
setTimeInMillis(startMs, ec);
|
|
add(field, t, ec);
|
|
double ms = getTimeInMillis(ec);
|
|
if (ms == targetMs) {
|
|
return t;
|
|
} else if (ms > targetMs) {
|
|
max = t;
|
|
} else {
|
|
min = t;
|
|
}
|
|
}
|
|
} else if (startMs > targetMs) {
|
|
int32_t max = -1;
|
|
// Find a value that is too small
|
|
while (U_SUCCESS(ec)) {
|
|
setTimeInMillis(startMs, ec);
|
|
add(field, max, ec);
|
|
double ms = getTimeInMillis(ec);
|
|
if (ms == targetMs) {
|
|
return max;
|
|
} else if (ms < targetMs) {
|
|
break;
|
|
} else {
|
|
min = max;
|
|
max <<= 1;
|
|
if (max == 0) {
|
|
// Field difference too large to fit into int32_t
|
|
#if defined (U_DEBUG_CAL)
|
|
fprintf(stderr, "%s:%d: ILLEGAL ARG because field %s's max too large for int32_t\n",
|
|
__FILE__, __LINE__, fldName(field));
|
|
#endif
|
|
ec = U_ILLEGAL_ARGUMENT_ERROR;
|
|
}
|
|
}
|
|
}
|
|
// Do a binary search
|
|
while ((min - max) > 1 && U_SUCCESS(ec)) {
|
|
int32_t t = min + (max - min)/2; // make sure intermediate values don't exceed INT32_MAX
|
|
setTimeInMillis(startMs, ec);
|
|
add(field, t, ec);
|
|
double ms = getTimeInMillis(ec);
|
|
if (ms == targetMs) {
|
|
return t;
|
|
} else if (ms < targetMs) {
|
|
max = t;
|
|
} else {
|
|
min = t;
|
|
}
|
|
}
|
|
}
|
|
// Set calendar to end point
|
|
setTimeInMillis(startMs, ec);
|
|
add(field, min, ec);
|
|
|
|
/* Test for buffer overflows */
|
|
if(U_FAILURE(ec)) {
|
|
return 0;
|
|
}
|
|
return min;
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
void
|
|
Calendar::adoptTimeZone(TimeZone* zone)
|
|
{
|
|
// Do nothing if passed-in zone is NULL
|
|
if (zone == NULL) return;
|
|
|
|
// fZone should always be non-null
|
|
if (fZone != NULL) delete fZone;
|
|
fZone = zone;
|
|
|
|
// if the zone changes, we need to recompute the time fields
|
|
fAreFieldsSet = FALSE;
|
|
}
|
|
|
|
// -------------------------------------
|
|
void
|
|
Calendar::setTimeZone(const TimeZone& zone)
|
|
{
|
|
adoptTimeZone(zone.clone());
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
const TimeZone&
|
|
Calendar::getTimeZone() const
|
|
{
|
|
return *fZone;
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
TimeZone*
|
|
Calendar::orphanTimeZone()
|
|
{
|
|
TimeZone *z = fZone;
|
|
// we let go of the time zone; the new time zone is the system default time zone
|
|
fZone = TimeZone::createDefault();
|
|
return z;
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
void
|
|
Calendar::setLenient(UBool lenient)
|
|
{
|
|
fLenient = lenient;
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
UBool
|
|
Calendar::isLenient() const
|
|
{
|
|
return fLenient;
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
void
|
|
Calendar::setRepeatedWallTimeOption(UCalendarWallTimeOption option)
|
|
{
|
|
if (option == UCAL_WALLTIME_LAST || option == UCAL_WALLTIME_FIRST) {
|
|
fRepeatedWallTime = option;
|
|
}
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
UCalendarWallTimeOption
|
|
Calendar::getRepeatedWallTimeOption(void) const
|
|
{
|
|
return fRepeatedWallTime;
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
void
|
|
Calendar::setSkippedWallTimeOption(UCalendarWallTimeOption option)
|
|
{
|
|
fSkippedWallTime = option;
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
UCalendarWallTimeOption
|
|
Calendar::getSkippedWallTimeOption(void) const
|
|
{
|
|
return fSkippedWallTime;
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
void
|
|
Calendar::setFirstDayOfWeek(UCalendarDaysOfWeek value)
|
|
{
|
|
if (fFirstDayOfWeek != value &&
|
|
value >= UCAL_SUNDAY && value <= UCAL_SATURDAY) {
|
|
fFirstDayOfWeek = value;
|
|
fAreFieldsSet = FALSE;
|
|
}
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
Calendar::EDaysOfWeek
|
|
Calendar::getFirstDayOfWeek() const
|
|
{
|
|
return (Calendar::EDaysOfWeek)fFirstDayOfWeek;
|
|
}
|
|
|
|
UCalendarDaysOfWeek
|
|
Calendar::getFirstDayOfWeek(UErrorCode & /*status*/) const
|
|
{
|
|
return fFirstDayOfWeek;
|
|
}
|
|
// -------------------------------------
|
|
|
|
void
|
|
Calendar::setMinimalDaysInFirstWeek(uint8_t value)
|
|
{
|
|
// Values less than 1 have the same effect as 1; values greater
|
|
// than 7 have the same effect as 7. However, we normalize values
|
|
// so operator== and so forth work.
|
|
if (value < 1) {
|
|
value = 1;
|
|
} else if (value > 7) {
|
|
value = 7;
|
|
}
|
|
if (fMinimalDaysInFirstWeek != value) {
|
|
fMinimalDaysInFirstWeek = value;
|
|
fAreFieldsSet = FALSE;
|
|
}
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
uint8_t
|
|
Calendar::getMinimalDaysInFirstWeek() const
|
|
{
|
|
return fMinimalDaysInFirstWeek;
|
|
}
|
|
|
|
// -------------------------------------
|
|
// weekend functions, just dummy implementations for now (for API freeze)
|
|
|
|
UCalendarWeekdayType
|
|
Calendar::getDayOfWeekType(UCalendarDaysOfWeek dayOfWeek, UErrorCode &status) const
|
|
{
|
|
if (U_FAILURE(status)) {
|
|
return UCAL_WEEKDAY;
|
|
}
|
|
if (dayOfWeek < UCAL_SUNDAY || dayOfWeek > UCAL_SATURDAY) {
|
|
status = U_ILLEGAL_ARGUMENT_ERROR;
|
|
return UCAL_WEEKDAY;
|
|
}
|
|
if (fWeekendOnset == fWeekendCease) {
|
|
if (dayOfWeek != fWeekendOnset)
|
|
return UCAL_WEEKDAY;
|
|
return (fWeekendOnsetMillis == 0) ? UCAL_WEEKEND : UCAL_WEEKEND_ONSET;
|
|
}
|
|
if (fWeekendOnset < fWeekendCease) {
|
|
if (dayOfWeek < fWeekendOnset || dayOfWeek > fWeekendCease) {
|
|
return UCAL_WEEKDAY;
|
|
}
|
|
} else {
|
|
if (dayOfWeek > fWeekendCease && dayOfWeek < fWeekendOnset) {
|
|
return UCAL_WEEKDAY;
|
|
}
|
|
}
|
|
if (dayOfWeek == fWeekendOnset) {
|
|
return (fWeekendOnsetMillis == 0) ? UCAL_WEEKEND : UCAL_WEEKEND_ONSET;
|
|
}
|
|
if (dayOfWeek == fWeekendCease) {
|
|
return (fWeekendCeaseMillis >= 86400000) ? UCAL_WEEKEND : UCAL_WEEKEND_CEASE;
|
|
}
|
|
return UCAL_WEEKEND;
|
|
}
|
|
|
|
int32_t
|
|
Calendar::getWeekendTransition(UCalendarDaysOfWeek dayOfWeek, UErrorCode &status) const
|
|
{
|
|
if (U_FAILURE(status)) {
|
|
return 0;
|
|
}
|
|
if (dayOfWeek == fWeekendOnset) {
|
|
return fWeekendOnsetMillis;
|
|
} else if (dayOfWeek == fWeekendCease) {
|
|
return fWeekendCeaseMillis;
|
|
}
|
|
status = U_ILLEGAL_ARGUMENT_ERROR;
|
|
return 0;
|
|
}
|
|
|
|
UBool
|
|
Calendar::isWeekend(UDate date, UErrorCode &status) const
|
|
{
|
|
if (U_FAILURE(status)) {
|
|
return FALSE;
|
|
}
|
|
// clone the calendar so we don't mess with the real one.
|
|
Calendar *work = (Calendar*)this->clone();
|
|
if (work == NULL) {
|
|
status = U_MEMORY_ALLOCATION_ERROR;
|
|
return FALSE;
|
|
}
|
|
UBool result = FALSE;
|
|
work->setTime(date, status);
|
|
if (U_SUCCESS(status)) {
|
|
result = work->isWeekend();
|
|
}
|
|
delete work;
|
|
return result;
|
|
}
|
|
|
|
UBool
|
|
Calendar::isWeekend(void) const
|
|
{
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
UCalendarDaysOfWeek dayOfWeek = (UCalendarDaysOfWeek)get(UCAL_DAY_OF_WEEK, status);
|
|
UCalendarWeekdayType dayType = getDayOfWeekType(dayOfWeek, status);
|
|
if (U_SUCCESS(status)) {
|
|
switch (dayType) {
|
|
case UCAL_WEEKDAY:
|
|
return FALSE;
|
|
case UCAL_WEEKEND:
|
|
return TRUE;
|
|
case UCAL_WEEKEND_ONSET:
|
|
case UCAL_WEEKEND_CEASE:
|
|
// Use internalGet() because the above call to get() populated all fields.
|
|
{
|
|
int32_t millisInDay = internalGet(UCAL_MILLISECONDS_IN_DAY);
|
|
int32_t transitionMillis = getWeekendTransition(dayOfWeek, status);
|
|
if (U_SUCCESS(status)) {
|
|
return (dayType == UCAL_WEEKEND_ONSET)?
|
|
(millisInDay >= transitionMillis):
|
|
(millisInDay < transitionMillis);
|
|
}
|
|
// else fall through, return FALSE
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
// ------------------------------------- limits
|
|
|
|
int32_t
|
|
Calendar::getMinimum(EDateFields field) const {
|
|
return getLimit((UCalendarDateFields) field,UCAL_LIMIT_MINIMUM);
|
|
}
|
|
|
|
int32_t
|
|
Calendar::getMinimum(UCalendarDateFields field) const
|
|
{
|
|
return getLimit(field,UCAL_LIMIT_MINIMUM);
|
|
}
|
|
|
|
// -------------------------------------
|
|
int32_t
|
|
Calendar::getMaximum(EDateFields field) const
|
|
{
|
|
return getLimit((UCalendarDateFields) field,UCAL_LIMIT_MAXIMUM);
|
|
}
|
|
|
|
int32_t
|
|
Calendar::getMaximum(UCalendarDateFields field) const
|
|
{
|
|
return getLimit(field,UCAL_LIMIT_MAXIMUM);
|
|
}
|
|
|
|
// -------------------------------------
|
|
int32_t
|
|
Calendar::getGreatestMinimum(EDateFields field) const
|
|
{
|
|
return getLimit((UCalendarDateFields)field,UCAL_LIMIT_GREATEST_MINIMUM);
|
|
}
|
|
|
|
int32_t
|
|
Calendar::getGreatestMinimum(UCalendarDateFields field) const
|
|
{
|
|
return getLimit(field,UCAL_LIMIT_GREATEST_MINIMUM);
|
|
}
|
|
|
|
// -------------------------------------
|
|
int32_t
|
|
Calendar::getLeastMaximum(EDateFields field) const
|
|
{
|
|
return getLimit((UCalendarDateFields) field,UCAL_LIMIT_LEAST_MAXIMUM);
|
|
}
|
|
|
|
int32_t
|
|
Calendar::getLeastMaximum(UCalendarDateFields field) const
|
|
{
|
|
return getLimit( field,UCAL_LIMIT_LEAST_MAXIMUM);
|
|
}
|
|
|
|
// -------------------------------------
|
|
int32_t
|
|
Calendar::getActualMinimum(EDateFields field, UErrorCode& status) const
|
|
{
|
|
return getActualMinimum((UCalendarDateFields) field, status);
|
|
}
|
|
|
|
int32_t Calendar::getLimit(UCalendarDateFields field, ELimitType limitType) const {
|
|
switch (field) {
|
|
case UCAL_DAY_OF_WEEK:
|
|
case UCAL_AM_PM:
|
|
case UCAL_HOUR:
|
|
case UCAL_HOUR_OF_DAY:
|
|
case UCAL_MINUTE:
|
|
case UCAL_SECOND:
|
|
case UCAL_MILLISECOND:
|
|
case UCAL_ZONE_OFFSET:
|
|
case UCAL_DST_OFFSET:
|
|
case UCAL_DOW_LOCAL:
|
|
case UCAL_JULIAN_DAY:
|
|
case UCAL_MILLISECONDS_IN_DAY:
|
|
case UCAL_IS_LEAP_MONTH:
|
|
return kCalendarLimits[field][limitType];
|
|
|
|
case UCAL_WEEK_OF_MONTH:
|
|
{
|
|
int32_t limit;
|
|
if (limitType == UCAL_LIMIT_MINIMUM) {
|
|
limit = getMinimalDaysInFirstWeek() == 1 ? 1 : 0;
|
|
} else if (limitType == UCAL_LIMIT_GREATEST_MINIMUM) {
|
|
limit = 1;
|
|
} else {
|
|
int32_t minDaysInFirst = getMinimalDaysInFirstWeek();
|
|
int32_t daysInMonth = handleGetLimit(UCAL_DAY_OF_MONTH, limitType);
|
|
if (limitType == UCAL_LIMIT_LEAST_MAXIMUM) {
|
|
limit = (daysInMonth + (7 - minDaysInFirst)) / 7;
|
|
} else { // limitType == UCAL_LIMIT_MAXIMUM
|
|
limit = (daysInMonth + 6 + (7 - minDaysInFirst)) / 7;
|
|
}
|
|
}
|
|
return limit;
|
|
}
|
|
default:
|
|
return handleGetLimit(field, limitType);
|
|
}
|
|
}
|
|
|
|
|
|
int32_t
|
|
Calendar::getActualMinimum(UCalendarDateFields field, UErrorCode& status) const
|
|
{
|
|
int32_t fieldValue = getGreatestMinimum(field);
|
|
int32_t endValue = getMinimum(field);
|
|
|
|
// if we know that the minimum value is always the same, just return it
|
|
if (fieldValue == endValue) {
|
|
return fieldValue;
|
|
}
|
|
|
|
// clone the calendar so we don't mess with the real one, and set it to
|
|
// accept anything for the field values
|
|
Calendar *work = (Calendar*)this->clone();
|
|
if (work == NULL) {
|
|
status = U_MEMORY_ALLOCATION_ERROR;
|
|
return 0;
|
|
}
|
|
work->setLenient(TRUE);
|
|
|
|
// now try each value from getLeastMaximum() to getMaximum() one by one until
|
|
// we get a value that normalizes to another value. The last value that
|
|
// normalizes to itself is the actual minimum for the current date
|
|
int32_t result = fieldValue;
|
|
|
|
do {
|
|
work->set(field, fieldValue);
|
|
if (work->get(field, status) != fieldValue) {
|
|
break;
|
|
}
|
|
else {
|
|
result = fieldValue;
|
|
fieldValue--;
|
|
}
|
|
} while (fieldValue >= endValue);
|
|
|
|
delete work;
|
|
|
|
/* Test for buffer overflows */
|
|
if(U_FAILURE(status)) {
|
|
return 0;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
|
|
|
|
/**
|
|
* Ensure that each field is within its valid range by calling {@link
|
|
* #validateField(int)} on each field that has been set. This method
|
|
* should only be called if this calendar is not lenient.
|
|
* @see #isLenient
|
|
* @see #validateField(int)
|
|
*/
|
|
void Calendar::validateFields(UErrorCode &status) {
|
|
for (int32_t field = 0; U_SUCCESS(status) && (field < UCAL_FIELD_COUNT); field++) {
|
|
if (fStamp[field] >= kMinimumUserStamp) {
|
|
validateField((UCalendarDateFields)field, status);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Validate a single field of this calendar. Subclasses should
|
|
* override this method to validate any calendar-specific fields.
|
|
* Generic fields can be handled by
|
|
* <code>Calendar.validateField()</code>.
|
|
* @see #validateField(int, int, int)
|
|
*/
|
|
void Calendar::validateField(UCalendarDateFields field, UErrorCode &status) {
|
|
int32_t y;
|
|
switch (field) {
|
|
case UCAL_DAY_OF_MONTH:
|
|
y = handleGetExtendedYear();
|
|
validateField(field, 1, handleGetMonthLength(y, internalGet(UCAL_MONTH)), status);
|
|
break;
|
|
case UCAL_DAY_OF_YEAR:
|
|
y = handleGetExtendedYear();
|
|
validateField(field, 1, handleGetYearLength(y), status);
|
|
break;
|
|
case UCAL_DAY_OF_WEEK_IN_MONTH:
|
|
if (internalGet(field) == 0) {
|
|
#if defined (U_DEBUG_CAL)
|
|
fprintf(stderr, "%s:%d: ILLEGAL ARG because DOW in month cannot be 0\n",
|
|
__FILE__, __LINE__);
|
|
#endif
|
|
status = U_ILLEGAL_ARGUMENT_ERROR; // "DAY_OF_WEEK_IN_MONTH cannot be zero"
|
|
return;
|
|
}
|
|
validateField(field, getMinimum(field), getMaximum(field), status);
|
|
break;
|
|
default:
|
|
validateField(field, getMinimum(field), getMaximum(field), status);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Validate a single field of this calendar given its minimum and
|
|
* maximum allowed value. If the field is out of range, throw a
|
|
* descriptive <code>IllegalArgumentException</code>. Subclasses may
|
|
* use this method in their implementation of {@link
|
|
* #validateField(int)}.
|
|
*/
|
|
void Calendar::validateField(UCalendarDateFields field, int32_t min, int32_t max, UErrorCode& status)
|
|
{
|
|
int32_t value = fFields[field];
|
|
if (value < min || value > max) {
|
|
#if defined (U_DEBUG_CAL)
|
|
fprintf(stderr, "%s:%d: ILLEGAL ARG because of field %s out of range %d..%d at %d\n",
|
|
__FILE__, __LINE__,fldName(field),min,max,value);
|
|
#endif
|
|
status = U_ILLEGAL_ARGUMENT_ERROR;
|
|
return;
|
|
}
|
|
}
|
|
|
|
// -------------------------
|
|
|
|
const UFieldResolutionTable* Calendar::getFieldResolutionTable() const {
|
|
return kDatePrecedence;
|
|
}
|
|
|
|
|
|
UCalendarDateFields Calendar::newerField(UCalendarDateFields defaultField, UCalendarDateFields alternateField) const
|
|
{
|
|
if (fStamp[alternateField] > fStamp[defaultField]) {
|
|
return alternateField;
|
|
}
|
|
return defaultField;
|
|
}
|
|
|
|
UCalendarDateFields Calendar::resolveFields(const UFieldResolutionTable* precedenceTable) {
|
|
int32_t bestField = UCAL_FIELD_COUNT;
|
|
int32_t tempBestField;
|
|
for (int32_t g=0; precedenceTable[g][0][0] != -1 && (bestField == UCAL_FIELD_COUNT); ++g) {
|
|
int32_t bestStamp = kUnset;
|
|
for (int32_t l=0; precedenceTable[g][l][0] != -1; ++l) {
|
|
int32_t lineStamp = kUnset;
|
|
// Skip over first entry if it is negative
|
|
for (int32_t i=((precedenceTable[g][l][0]>=kResolveRemap)?1:0); precedenceTable[g][l][i]!=-1; ++i) {
|
|
U_ASSERT(precedenceTable[g][l][i] < UCAL_FIELD_COUNT);
|
|
int32_t s = fStamp[precedenceTable[g][l][i]];
|
|
// If any field is unset then don't use this line
|
|
if (s == kUnset) {
|
|
goto linesInGroup;
|
|
} else if(s > lineStamp) {
|
|
lineStamp = s;
|
|
}
|
|
}
|
|
// Record new maximum stamp & field no.
|
|
if (lineStamp > bestStamp) {
|
|
tempBestField = precedenceTable[g][l][0]; // First field refers to entire line
|
|
if (tempBestField >= kResolveRemap) {
|
|
tempBestField &= (kResolveRemap-1);
|
|
// This check is needed to resolve some issues with UCAL_YEAR precedence mapping
|
|
if (tempBestField != UCAL_DATE || (fStamp[UCAL_WEEK_OF_MONTH] < fStamp[tempBestField])) {
|
|
bestField = tempBestField;
|
|
}
|
|
} else {
|
|
bestField = tempBestField;
|
|
}
|
|
|
|
if (bestField == tempBestField) {
|
|
bestStamp = lineStamp;
|
|
}
|
|
}
|
|
linesInGroup:
|
|
;
|
|
}
|
|
}
|
|
return (UCalendarDateFields)bestField;
|
|
}
|
|
|
|
const UFieldResolutionTable Calendar::kDatePrecedence[] =
|
|
{
|
|
{
|
|
{ UCAL_DAY_OF_MONTH, kResolveSTOP },
|
|
{ UCAL_WEEK_OF_YEAR, UCAL_DAY_OF_WEEK, kResolveSTOP },
|
|
{ UCAL_WEEK_OF_MONTH, UCAL_DAY_OF_WEEK, kResolveSTOP },
|
|
{ UCAL_DAY_OF_WEEK_IN_MONTH, UCAL_DAY_OF_WEEK, kResolveSTOP },
|
|
{ UCAL_WEEK_OF_YEAR, UCAL_DOW_LOCAL, kResolveSTOP },
|
|
{ UCAL_WEEK_OF_MONTH, UCAL_DOW_LOCAL, kResolveSTOP },
|
|
{ UCAL_DAY_OF_WEEK_IN_MONTH, UCAL_DOW_LOCAL, kResolveSTOP },
|
|
{ UCAL_DAY_OF_YEAR, kResolveSTOP },
|
|
{ kResolveRemap | UCAL_DAY_OF_MONTH, UCAL_YEAR, kResolveSTOP }, // if YEAR is set over YEAR_WOY use DAY_OF_MONTH
|
|
{ kResolveRemap | UCAL_WEEK_OF_YEAR, UCAL_YEAR_WOY, kResolveSTOP }, // if YEAR_WOY is set, calc based on WEEK_OF_YEAR
|
|
{ kResolveSTOP }
|
|
},
|
|
{
|
|
{ UCAL_WEEK_OF_YEAR, kResolveSTOP },
|
|
{ UCAL_WEEK_OF_MONTH, kResolveSTOP },
|
|
{ UCAL_DAY_OF_WEEK_IN_MONTH, kResolveSTOP },
|
|
{ kResolveRemap | UCAL_DAY_OF_WEEK_IN_MONTH, UCAL_DAY_OF_WEEK, kResolveSTOP },
|
|
{ kResolveRemap | UCAL_DAY_OF_WEEK_IN_MONTH, UCAL_DOW_LOCAL, kResolveSTOP },
|
|
{ kResolveSTOP }
|
|
},
|
|
{{kResolveSTOP}}
|
|
};
|
|
|
|
|
|
const UFieldResolutionTable Calendar::kDOWPrecedence[] =
|
|
{
|
|
{
|
|
{ UCAL_DAY_OF_WEEK,kResolveSTOP, kResolveSTOP },
|
|
{ UCAL_DOW_LOCAL,kResolveSTOP, kResolveSTOP },
|
|
{kResolveSTOP}
|
|
},
|
|
{{kResolveSTOP}}
|
|
};
|
|
|
|
// precedence for calculating a year
|
|
const UFieldResolutionTable Calendar::kYearPrecedence[] =
|
|
{
|
|
{
|
|
{ UCAL_YEAR, kResolveSTOP },
|
|
{ UCAL_EXTENDED_YEAR, kResolveSTOP },
|
|
{ UCAL_YEAR_WOY, UCAL_WEEK_OF_YEAR, kResolveSTOP }, // YEAR_WOY is useless without WEEK_OF_YEAR
|
|
{ kResolveSTOP }
|
|
},
|
|
{{kResolveSTOP}}
|
|
};
|
|
|
|
|
|
// -------------------------
|
|
|
|
|
|
void Calendar::computeTime(UErrorCode& status) {
|
|
if (!isLenient()) {
|
|
validateFields(status);
|
|
if (U_FAILURE(status)) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Compute the Julian day
|
|
int32_t julianDay = computeJulianDay();
|
|
|
|
double millis = Grego::julianDayToMillis(julianDay);
|
|
|
|
#if defined (U_DEBUG_CAL)
|
|
// int32_t julianInsanityCheck = (int32_t)ClockMath::floorDivide(millis, kOneDay);
|
|
// julianInsanityCheck += kEpochStartAsJulianDay;
|
|
// if(1 || julianInsanityCheck != julianDay) {
|
|
// fprintf(stderr, "%s:%d- D'oh- computed jules %d, to mills (%s)%.lf, recomputed %d\n",
|
|
// __FILE__, __LINE__, julianDay, millis<0.0?"NEG":"", millis, julianInsanityCheck);
|
|
// }
|
|
#endif
|
|
|
|
int32_t millisInDay;
|
|
|
|
// We only use MILLISECONDS_IN_DAY if it has been set by the user.
|
|
// This makes it possible for the caller to set the calendar to a
|
|
// time and call clear(MONTH) to reset the MONTH to January. This
|
|
// is legacy behavior. Without this, clear(MONTH) has no effect,
|
|
// since the internally set JULIAN_DAY is used.
|
|
if (fStamp[UCAL_MILLISECONDS_IN_DAY] >= ((int32_t)kMinimumUserStamp) &&
|
|
newestStamp(UCAL_AM_PM, UCAL_MILLISECOND, kUnset) <= fStamp[UCAL_MILLISECONDS_IN_DAY]) {
|
|
millisInDay = internalGet(UCAL_MILLISECONDS_IN_DAY);
|
|
} else {
|
|
millisInDay = computeMillisInDay();
|
|
}
|
|
|
|
UDate t = 0;
|
|
if (fStamp[UCAL_ZONE_OFFSET] >= ((int32_t)kMinimumUserStamp) || fStamp[UCAL_DST_OFFSET] >= ((int32_t)kMinimumUserStamp)) {
|
|
t = millis + millisInDay - (internalGet(UCAL_ZONE_OFFSET) + internalGet(UCAL_DST_OFFSET));
|
|
} else {
|
|
// Compute the time zone offset and DST offset. There are two potential
|
|
// ambiguities here. We'll assume a 2:00 am (wall time) switchover time
|
|
// for discussion purposes here.
|
|
//
|
|
// 1. The positive offset change such as transition into DST.
|
|
// Here, a designated time of 2:00 am - 2:59 am does not actually exist.
|
|
// For this case, skippedWallTime option specifies the behavior.
|
|
// For example, 2:30 am is interpreted as;
|
|
// - WALLTIME_LAST(default): 3:30 am (DST) (interpreting 2:30 am as 31 minutes after 1:59 am (STD))
|
|
// - WALLTIME_FIRST: 1:30 am (STD) (interpreting 2:30 am as 30 minutes before 3:00 am (DST))
|
|
// - WALLTIME_NEXT_VALID: 3:00 am (DST) (next valid time after 2:30 am on a wall clock)
|
|
// 2. The negative offset change such as transition out of DST.
|
|
// Here, a designated time of 1:00 am - 1:59 am can be in standard or DST. Both are valid
|
|
// representations (the rep jumps from 1:59:59 DST to 1:00:00 Std).
|
|
// For this case, repeatedWallTime option specifies the behavior.
|
|
// For example, 1:30 am is interpreted as;
|
|
// - WALLTIME_LAST(default): 1:30 am (STD) - latter occurrence
|
|
// - WALLTIME_FIRST: 1:30 am (DST) - former occurrence
|
|
//
|
|
// In addition to above, when calendar is strict (not default), wall time falls into
|
|
// the skipped time range will be processed as an error case.
|
|
//
|
|
// These special cases are mostly handled in #computeZoneOffset(long), except WALLTIME_NEXT_VALID
|
|
// at positive offset change. The protected method computeZoneOffset(long) is exposed to Calendar
|
|
// subclass implementations and marked as @stable. Strictly speaking, WALLTIME_NEXT_VALID
|
|
// should be also handled in the same place, but we cannot change the code flow without deprecating
|
|
// the protected method.
|
|
//
|
|
// We use the TimeZone object, unless the user has explicitly set the ZONE_OFFSET
|
|
// or DST_OFFSET fields; then we use those fields.
|
|
|
|
if (!isLenient() || fSkippedWallTime == UCAL_WALLTIME_NEXT_VALID) {
|
|
// When strict, invalidate a wall time falls into a skipped wall time range.
|
|
// When lenient and skipped wall time option is WALLTIME_NEXT_VALID,
|
|
// the result time will be adjusted to the next valid time (on wall clock).
|
|
int32_t zoneOffset = computeZoneOffset(millis, millisInDay, status);
|
|
UDate tmpTime = millis + millisInDay - zoneOffset;
|
|
|
|
int32_t raw, dst;
|
|
fZone->getOffset(tmpTime, FALSE, raw, dst, status);
|
|
|
|
if (U_SUCCESS(status)) {
|
|
// zoneOffset != (raw + dst) only when the given wall time fall into
|
|
// a skipped wall time range caused by positive zone offset transition.
|
|
if (zoneOffset != (raw + dst)) {
|
|
if (!isLenient()) {
|
|
status = U_ILLEGAL_ARGUMENT_ERROR;
|
|
} else {
|
|
U_ASSERT(fSkippedWallTime == UCAL_WALLTIME_NEXT_VALID);
|
|
// Adjust time to the next valid wall clock time.
|
|
// At this point, tmpTime is on or after the zone offset transition causing
|
|
// the skipped time range.
|
|
|
|
BasicTimeZone *btz = getBasicTimeZone();
|
|
if (btz) {
|
|
TimeZoneTransition transition;
|
|
UBool hasTransition = btz->getPreviousTransition(tmpTime, TRUE, transition);
|
|
if (hasTransition) {
|
|
t = transition.getTime();
|
|
} else {
|
|
// Could not find any transitions.
|
|
// Note: This should never happen.
|
|
status = U_INTERNAL_PROGRAM_ERROR;
|
|
}
|
|
} else {
|
|
// If not BasicTimeZone, return unsupported error for now.
|
|
// TODO: We may support non-BasicTimeZone in future.
|
|
status = U_UNSUPPORTED_ERROR;
|
|
}
|
|
}
|
|
} else {
|
|
t = tmpTime;
|
|
}
|
|
}
|
|
} else {
|
|
t = millis + millisInDay - computeZoneOffset(millis, millisInDay, status);
|
|
}
|
|
}
|
|
if (U_SUCCESS(status)) {
|
|
internalSetTime(t);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Compute the milliseconds in the day from the fields. This is a
|
|
* value from 0 to 23:59:59.999 inclusive, unless fields are out of
|
|
* range, in which case it can be an arbitrary value. This value
|
|
* reflects local zone wall time.
|
|
* @stable ICU 2.0
|
|
*/
|
|
int32_t Calendar::computeMillisInDay() {
|
|
// Do the time portion of the conversion.
|
|
|
|
int32_t millisInDay = 0;
|
|
|
|
// Find the best set of fields specifying the time of day. There
|
|
// are only two possibilities here; the HOUR_OF_DAY or the
|
|
// AM_PM and the HOUR.
|
|
int32_t hourOfDayStamp = fStamp[UCAL_HOUR_OF_DAY];
|
|
int32_t hourStamp = (fStamp[UCAL_HOUR] > fStamp[UCAL_AM_PM])?fStamp[UCAL_HOUR]:fStamp[UCAL_AM_PM];
|
|
int32_t bestStamp = (hourStamp > hourOfDayStamp) ? hourStamp : hourOfDayStamp;
|
|
|
|
// Hours
|
|
if (bestStamp != kUnset) {
|
|
if (bestStamp == hourOfDayStamp) {
|
|
// Don't normalize here; let overflow bump into the next period.
|
|
// This is consistent with how we handle other fields.
|
|
millisInDay += internalGet(UCAL_HOUR_OF_DAY);
|
|
} else {
|
|
// Don't normalize here; let overflow bump into the next period.
|
|
// This is consistent with how we handle other fields.
|
|
millisInDay += internalGet(UCAL_HOUR);
|
|
millisInDay += 12 * internalGet(UCAL_AM_PM); // Default works for unset AM_PM
|
|
}
|
|
}
|
|
|
|
// We use the fact that unset == 0; we start with millisInDay
|
|
// == HOUR_OF_DAY.
|
|
millisInDay *= 60;
|
|
millisInDay += internalGet(UCAL_MINUTE); // now have minutes
|
|
millisInDay *= 60;
|
|
millisInDay += internalGet(UCAL_SECOND); // now have seconds
|
|
millisInDay *= 1000;
|
|
millisInDay += internalGet(UCAL_MILLISECOND); // now have millis
|
|
|
|
return millisInDay;
|
|
}
|
|
|
|
/**
|
|
* This method can assume EXTENDED_YEAR has been set.
|
|
* @param millis milliseconds of the date fields
|
|
* @param millisInDay milliseconds of the time fields; may be out
|
|
* or range.
|
|
* @stable ICU 2.0
|
|
*/
|
|
int32_t Calendar::computeZoneOffset(double millis, int32_t millisInDay, UErrorCode &ec) {
|
|
int32_t rawOffset, dstOffset;
|
|
UDate wall = millis + millisInDay;
|
|
BasicTimeZone* btz = getBasicTimeZone();
|
|
if (btz) {
|
|
int duplicatedTimeOpt = (fRepeatedWallTime == UCAL_WALLTIME_FIRST) ? BasicTimeZone::kFormer : BasicTimeZone::kLatter;
|
|
int nonExistingTimeOpt = (fSkippedWallTime == UCAL_WALLTIME_FIRST) ? BasicTimeZone::kLatter : BasicTimeZone::kFormer;
|
|
btz->getOffsetFromLocal(wall, nonExistingTimeOpt, duplicatedTimeOpt, rawOffset, dstOffset, ec);
|
|
} else {
|
|
const TimeZone& tz = getTimeZone();
|
|
// By default, TimeZone::getOffset behaves UCAL_WALLTIME_LAST for both.
|
|
tz.getOffset(wall, TRUE, rawOffset, dstOffset, ec);
|
|
|
|
UBool sawRecentNegativeShift = FALSE;
|
|
if (fRepeatedWallTime == UCAL_WALLTIME_FIRST) {
|
|
// Check if the given wall time falls into repeated time range
|
|
UDate tgmt = wall - (rawOffset + dstOffset);
|
|
|
|
// Any negative zone transition within last 6 hours?
|
|
// Note: The maximum historic negative zone transition is -3 hours in the tz database.
|
|
// 6 hour window would be sufficient for this purpose.
|
|
int32_t tmpRaw, tmpDst;
|
|
tz.getOffset(tgmt - 6*60*60*1000, FALSE, tmpRaw, tmpDst, ec);
|
|
int32_t offsetDelta = (rawOffset + dstOffset) - (tmpRaw + tmpDst);
|
|
|
|
U_ASSERT(offsetDelta < -6*60*60*1000);
|
|
if (offsetDelta < 0) {
|
|
sawRecentNegativeShift = TRUE;
|
|
// Negative shift within last 6 hours. When UCAL_WALLTIME_FIRST is used and the given wall time falls
|
|
// into the repeated time range, use offsets before the transition.
|
|
// Note: If it does not fall into the repeated time range, offsets remain unchanged below.
|
|
tz.getOffset(wall + offsetDelta, TRUE, rawOffset, dstOffset, ec);
|
|
}
|
|
}
|
|
if (!sawRecentNegativeShift && fSkippedWallTime == UCAL_WALLTIME_FIRST) {
|
|
// When skipped wall time option is WALLTIME_FIRST,
|
|
// recalculate offsets from the resolved time (non-wall).
|
|
// When the given wall time falls into skipped wall time,
|
|
// the offsets will be based on the zone offsets AFTER
|
|
// the transition (which means, earliest possibe interpretation).
|
|
UDate tgmt = wall - (rawOffset + dstOffset);
|
|
tz.getOffset(tgmt, FALSE, rawOffset, dstOffset, ec);
|
|
}
|
|
}
|
|
return rawOffset + dstOffset;
|
|
}
|
|
|
|
int32_t Calendar::computeJulianDay()
|
|
{
|
|
// We want to see if any of the date fields is newer than the
|
|
// JULIAN_DAY. If not, then we use JULIAN_DAY. If so, then we do
|
|
// the normal resolution. We only use JULIAN_DAY if it has been
|
|
// set by the user. This makes it possible for the caller to set
|
|
// the calendar to a time and call clear(MONTH) to reset the MONTH
|
|
// to January. This is legacy behavior. Without this,
|
|
// clear(MONTH) has no effect, since the internally set JULIAN_DAY
|
|
// is used.
|
|
if (fStamp[UCAL_JULIAN_DAY] >= (int32_t)kMinimumUserStamp) {
|
|
int32_t bestStamp = newestStamp(UCAL_ERA, UCAL_DAY_OF_WEEK_IN_MONTH, kUnset);
|
|
bestStamp = newestStamp(UCAL_YEAR_WOY, UCAL_EXTENDED_YEAR, bestStamp);
|
|
if (bestStamp <= fStamp[UCAL_JULIAN_DAY]) {
|
|
return internalGet(UCAL_JULIAN_DAY);
|
|
}
|
|
}
|
|
|
|
UCalendarDateFields bestField = resolveFields(getFieldResolutionTable());
|
|
if (bestField == UCAL_FIELD_COUNT) {
|
|
bestField = UCAL_DAY_OF_MONTH;
|
|
}
|
|
|
|
return handleComputeJulianDay(bestField);
|
|
}
|
|
|
|
// -------------------------------------------
|
|
|
|
int32_t Calendar::handleComputeJulianDay(UCalendarDateFields bestField) {
|
|
UBool useMonth = (bestField == UCAL_DAY_OF_MONTH ||
|
|
bestField == UCAL_WEEK_OF_MONTH ||
|
|
bestField == UCAL_DAY_OF_WEEK_IN_MONTH);
|
|
int32_t year;
|
|
|
|
if (bestField == UCAL_WEEK_OF_YEAR) {
|
|
year = internalGet(UCAL_YEAR_WOY, handleGetExtendedYear());
|
|
internalSet(UCAL_EXTENDED_YEAR, year);
|
|
} else {
|
|
year = handleGetExtendedYear();
|
|
internalSet(UCAL_EXTENDED_YEAR, year);
|
|
}
|
|
|
|
#if defined (U_DEBUG_CAL)
|
|
fprintf(stderr, "%s:%d: bestField= %s - y=%d\n", __FILE__, __LINE__, fldName(bestField), year);
|
|
#endif
|
|
|
|
// Get the Julian day of the day BEFORE the start of this year.
|
|
// If useMonth is true, get the day before the start of the month.
|
|
|
|
// give calendar subclass a chance to have a default 'first' month
|
|
int32_t month;
|
|
|
|
if(isSet(UCAL_MONTH)) {
|
|
month = internalGet(UCAL_MONTH);
|
|
} else {
|
|
month = getDefaultMonthInYear(year);
|
|
}
|
|
|
|
int32_t julianDay = handleComputeMonthStart(year, useMonth ? month : 0, useMonth);
|
|
|
|
if (bestField == UCAL_DAY_OF_MONTH) {
|
|
|
|
// give calendar subclass a chance to have a default 'first' dom
|
|
int32_t dayOfMonth;
|
|
if(isSet(UCAL_DAY_OF_MONTH)) {
|
|
dayOfMonth = internalGet(UCAL_DAY_OF_MONTH,1);
|
|
} else {
|
|
dayOfMonth = getDefaultDayInMonth(year, month);
|
|
}
|
|
return julianDay + dayOfMonth;
|
|
}
|
|
|
|
if (bestField == UCAL_DAY_OF_YEAR) {
|
|
return julianDay + internalGet(UCAL_DAY_OF_YEAR);
|
|
}
|
|
|
|
int32_t firstDayOfWeek = getFirstDayOfWeek(); // Localized fdw
|
|
|
|
// At this point julianDay is the 0-based day BEFORE the first day of
|
|
// January 1, year 1 of the given calendar. If julianDay == 0, it
|
|
// specifies (Jan. 1, 1) - 1, in whatever calendar we are using (Julian
|
|
// or Gregorian). (or it is before the month we are in, if useMonth is True)
|
|
|
|
// At this point we need to process the WEEK_OF_MONTH or
|
|
// WEEK_OF_YEAR, which are similar, or the DAY_OF_WEEK_IN_MONTH.
|
|
// First, perform initial shared computations. These locate the
|
|
// first week of the period.
|
|
|
|
// Get the 0-based localized DOW of day one of the month or year.
|
|
// Valid range 0..6.
|
|
int32_t first = julianDayToDayOfWeek(julianDay + 1) - firstDayOfWeek;
|
|
if (first < 0) {
|
|
first += 7;
|
|
}
|
|
|
|
int32_t dowLocal = getLocalDOW();
|
|
|
|
// Find the first target DOW (dowLocal) in the month or year.
|
|
// Actually, it may be just before the first of the month or year.
|
|
// It will be an integer from -5..7.
|
|
int32_t date = 1 - first + dowLocal;
|
|
|
|
if (bestField == UCAL_DAY_OF_WEEK_IN_MONTH) {
|
|
// Adjust the target DOW to be in the month or year.
|
|
if (date < 1) {
|
|
date += 7;
|
|
}
|
|
|
|
// The only trickiness occurs if the day-of-week-in-month is
|
|
// negative.
|
|
int32_t dim = internalGet(UCAL_DAY_OF_WEEK_IN_MONTH, 1);
|
|
if (dim >= 0) {
|
|
date += 7*(dim - 1);
|
|
|
|
} else {
|
|
// Move date to the last of this day-of-week in this month,
|
|
// then back up as needed. If dim==-1, we don't back up at
|
|
// all. If dim==-2, we back up once, etc. Don't back up
|
|
// past the first of the given day-of-week in this month.
|
|
// Note that we handle -2, -3, etc. correctly, even though
|
|
// values < -1 are technically disallowed.
|
|
int32_t m = internalGet(UCAL_MONTH, UCAL_JANUARY);
|
|
int32_t monthLength = handleGetMonthLength(year, m);
|
|
date += ((monthLength - date) / 7 + dim + 1) * 7;
|
|
}
|
|
} else {
|
|
#if defined (U_DEBUG_CAL)
|
|
fprintf(stderr, "%s:%d - bf= %s\n", __FILE__, __LINE__, fldName(bestField));
|
|
#endif
|
|
|
|
if(bestField == UCAL_WEEK_OF_YEAR) { // ------------------------------------- WOY -------------
|
|
if(!isSet(UCAL_YEAR_WOY) || // YWOY not set at all or
|
|
( (resolveFields(kYearPrecedence) != UCAL_YEAR_WOY) // YWOY doesn't have precedence
|
|
&& (fStamp[UCAL_YEAR_WOY]!=kInternallySet) ) ) // (excluding where all fields are internally set - then YWOY is used)
|
|
{
|
|
// need to be sure to stay in 'real' year.
|
|
int32_t woy = internalGet(bestField);
|
|
|
|
int32_t nextJulianDay = handleComputeMonthStart(year+1, 0, FALSE); // jd of day before jan 1
|
|
int32_t nextFirst = julianDayToDayOfWeek(nextJulianDay + 1) - firstDayOfWeek;
|
|
|
|
if (nextFirst < 0) { // 0..6 ldow of Jan 1
|
|
nextFirst += 7;
|
|
}
|
|
|
|
if(woy==1) { // FIRST WEEK ---------------------------------
|
|
#if defined (U_DEBUG_CAL)
|
|
fprintf(stderr, "%s:%d - woy=%d, yp=%d, nj(%d)=%d, nf=%d", __FILE__, __LINE__,
|
|
internalGet(bestField), resolveFields(kYearPrecedence), year+1,
|
|
nextJulianDay, nextFirst);
|
|
|
|
fprintf(stderr, " next: %d DFW, min=%d \n", (7-nextFirst), getMinimalDaysInFirstWeek() );
|
|
#endif
|
|
|
|
// nextFirst is now the localized DOW of Jan 1 of y-woy+1
|
|
if((nextFirst > 0) && // Jan 1 starts on FDOW
|
|
(7-nextFirst) >= getMinimalDaysInFirstWeek()) // or enough days in the week
|
|
{
|
|
// Jan 1 of (yearWoy+1) is in yearWoy+1 - recalculate JD to next year
|
|
#if defined (U_DEBUG_CAL)
|
|
fprintf(stderr, "%s:%d - was going to move JD from %d to %d [d%d]\n", __FILE__, __LINE__,
|
|
julianDay, nextJulianDay, (nextJulianDay-julianDay));
|
|
#endif
|
|
julianDay = nextJulianDay;
|
|
|
|
// recalculate 'first' [0-based local dow of jan 1]
|
|
first = julianDayToDayOfWeek(julianDay + 1) - firstDayOfWeek;
|
|
if (first < 0) {
|
|
first += 7;
|
|
}
|
|
// recalculate date.
|
|
date = 1 - first + dowLocal;
|
|
}
|
|
} else if(woy>=getLeastMaximum(bestField)) {
|
|
// could be in the last week- find out if this JD would overstep
|
|
int32_t testDate = date;
|
|
if ((7 - first) < getMinimalDaysInFirstWeek()) {
|
|
testDate += 7;
|
|
}
|
|
|
|
// Now adjust for the week number.
|
|
testDate += 7 * (woy - 1);
|
|
|
|
#if defined (U_DEBUG_CAL)
|
|
fprintf(stderr, "%s:%d - y=%d, y-1=%d doy%d, njd%d (C.F. %d)\n",
|
|
__FILE__, __LINE__, year, year-1, testDate, julianDay+testDate, nextJulianDay);
|
|
#endif
|
|
if(julianDay+testDate > nextJulianDay) { // is it past Dec 31? (nextJulianDay is day BEFORE year+1's Jan 1)
|
|
// Fire up the calculating engines.. retry YWOY = (year-1)
|
|
julianDay = handleComputeMonthStart(year-1, 0, FALSE); // jd before Jan 1 of previous year
|
|
first = julianDayToDayOfWeek(julianDay + 1) - firstDayOfWeek; // 0 based local dow of first week
|
|
|
|
if(first < 0) { // 0..6
|
|
first += 7;
|
|
}
|
|
date = 1 - first + dowLocal;
|
|
|
|
#if defined (U_DEBUG_CAL)
|
|
fprintf(stderr, "%s:%d - date now %d, jd%d, ywoy%d\n",
|
|
__FILE__, __LINE__, date, julianDay, year-1);
|
|
#endif
|
|
|
|
|
|
} /* correction needed */
|
|
} /* leastmaximum */
|
|
} /* resolvefields(year) != year_woy */
|
|
} /* bestfield != week_of_year */
|
|
|
|
// assert(bestField == WEEK_OF_MONTH || bestField == WEEK_OF_YEAR)
|
|
// Adjust for minimal days in first week
|
|
if ((7 - first) < getMinimalDaysInFirstWeek()) {
|
|
date += 7;
|
|
}
|
|
|
|
// Now adjust for the week number.
|
|
date += 7 * (internalGet(bestField) - 1);
|
|
}
|
|
|
|
return julianDay + date;
|
|
}
|
|
|
|
int32_t
|
|
Calendar::getDefaultMonthInYear(int32_t /*eyear*/)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int32_t
|
|
Calendar::getDefaultDayInMonth(int32_t /*eyear*/, int32_t /*month*/)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
|
|
int32_t Calendar::getLocalDOW()
|
|
{
|
|
// Get zero-based localized DOW, valid range 0..6. This is the DOW
|
|
// we are looking for.
|
|
int32_t dowLocal = 0;
|
|
switch (resolveFields(kDOWPrecedence)) {
|
|
case UCAL_DAY_OF_WEEK:
|
|
dowLocal = internalGet(UCAL_DAY_OF_WEEK) - fFirstDayOfWeek;
|
|
break;
|
|
case UCAL_DOW_LOCAL:
|
|
dowLocal = internalGet(UCAL_DOW_LOCAL) - 1;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
dowLocal = dowLocal % 7;
|
|
if (dowLocal < 0) {
|
|
dowLocal += 7;
|
|
}
|
|
return dowLocal;
|
|
}
|
|
|
|
int32_t Calendar::handleGetExtendedYearFromWeekFields(int32_t yearWoy, int32_t woy)
|
|
{
|
|
// We have UCAL_YEAR_WOY and UCAL_WEEK_OF_YEAR - from those, determine
|
|
// what year we fall in, so that other code can set it properly.
|
|
// (code borrowed from computeWeekFields and handleComputeJulianDay)
|
|
//return yearWoy;
|
|
|
|
// First, we need a reliable DOW.
|
|
UCalendarDateFields bestField = resolveFields(kDatePrecedence); // !! Note: if subclasses have a different table, they should override handleGetExtendedYearFromWeekFields
|
|
|
|
// Now, a local DOW
|
|
int32_t dowLocal = getLocalDOW(); // 0..6
|
|
int32_t firstDayOfWeek = getFirstDayOfWeek(); // Localized fdw
|
|
int32_t jan1Start = handleComputeMonthStart(yearWoy, 0, FALSE);
|
|
int32_t nextJan1Start = handleComputeMonthStart(yearWoy+1, 0, FALSE); // next year's Jan1 start
|
|
|
|
// At this point julianDay is the 0-based day BEFORE the first day of
|
|
// January 1, year 1 of the given calendar. If julianDay == 0, it
|
|
// specifies (Jan. 1, 1) - 1, in whatever calendar we are using (Julian
|
|
// or Gregorian). (or it is before the month we are in, if useMonth is True)
|
|
|
|
// At this point we need to process the WEEK_OF_MONTH or
|
|
// WEEK_OF_YEAR, which are similar, or the DAY_OF_WEEK_IN_MONTH.
|
|
// First, perform initial shared computations. These locate the
|
|
// first week of the period.
|
|
|
|
// Get the 0-based localized DOW of day one of the month or year.
|
|
// Valid range 0..6.
|
|
int32_t first = julianDayToDayOfWeek(jan1Start + 1) - firstDayOfWeek;
|
|
if (first < 0) {
|
|
first += 7;
|
|
}
|
|
int32_t nextFirst = julianDayToDayOfWeek(nextJan1Start + 1) - firstDayOfWeek;
|
|
if (nextFirst < 0) {
|
|
nextFirst += 7;
|
|
}
|
|
|
|
int32_t minDays = getMinimalDaysInFirstWeek();
|
|
UBool jan1InPrevYear = FALSE; // January 1st in the year of WOY is the 1st week? (i.e. first week is < minimal )
|
|
//UBool nextJan1InPrevYear = FALSE; // January 1st of Year of WOY + 1 is in the first week?
|
|
|
|
if((7 - first) < minDays) {
|
|
jan1InPrevYear = TRUE;
|
|
}
|
|
|
|
// if((7 - nextFirst) < minDays) {
|
|
// nextJan1InPrevYear = TRUE;
|
|
// }
|
|
|
|
switch(bestField) {
|
|
case UCAL_WEEK_OF_YEAR:
|
|
if(woy == 1) {
|
|
if(jan1InPrevYear == TRUE) {
|
|
// the first week of January is in the previous year
|
|
// therefore WOY1 is always solidly within yearWoy
|
|
return yearWoy;
|
|
} else {
|
|
// First WOY is split between two years
|
|
if( dowLocal < first) { // we are prior to Jan 1
|
|
return yearWoy-1; // previous year
|
|
} else {
|
|
return yearWoy; // in this year
|
|
}
|
|
}
|
|
} else if(woy >= getLeastMaximum(bestField)) {
|
|
// we _might_ be in the last week..
|
|
int32_t jd = // Calculate JD of our target day:
|
|
jan1Start + // JD of Jan 1
|
|
(7-first) + // days in the first week (Jan 1.. )
|
|
(woy-1)*7 + // add the weeks of the year
|
|
dowLocal; // the local dow (0..6) of last week
|
|
if(jan1InPrevYear==FALSE) {
|
|
jd -= 7; // woy already includes Jan 1's week.
|
|
}
|
|
|
|
if( (jd+1) >= nextJan1Start ) {
|
|
// we are in week 52 or 53 etc. - actual year is yearWoy+1
|
|
return yearWoy+1;
|
|
} else {
|
|
// still in yearWoy;
|
|
return yearWoy;
|
|
}
|
|
} else {
|
|
// we're not possibly in the last week -must be ywoy
|
|
return yearWoy;
|
|
}
|
|
|
|
case UCAL_DATE:
|
|
if((internalGet(UCAL_MONTH)==0) &&
|
|
(woy >= getLeastMaximum(UCAL_WEEK_OF_YEAR))) {
|
|
return yearWoy+1; // month 0, late woy = in the next year
|
|
} else if(woy==1) {
|
|
//if(nextJan1InPrevYear) {
|
|
if(internalGet(UCAL_MONTH)==0) {
|
|
return yearWoy;
|
|
} else {
|
|
return yearWoy-1;
|
|
}
|
|
//}
|
|
}
|
|
|
|
//(internalGet(UCAL_DATE) <= (7-first)) /* && in minDow */ ) {
|
|
//within 1st week and in this month..
|
|
//return yearWoy+1;
|
|
return yearWoy;
|
|
|
|
default: // assume the year is appropriate
|
|
return yearWoy;
|
|
}
|
|
}
|
|
|
|
int32_t Calendar::handleGetMonthLength(int32_t extendedYear, int32_t month) const
|
|
{
|
|
return handleComputeMonthStart(extendedYear, month+1, TRUE) -
|
|
handleComputeMonthStart(extendedYear, month, TRUE);
|
|
}
|
|
|
|
int32_t Calendar::handleGetYearLength(int32_t eyear) const {
|
|
return handleComputeMonthStart(eyear+1, 0, FALSE) -
|
|
handleComputeMonthStart(eyear, 0, FALSE);
|
|
}
|
|
|
|
int32_t
|
|
Calendar::getActualMaximum(UCalendarDateFields field, UErrorCode& status) const
|
|
{
|
|
int32_t result;
|
|
switch (field) {
|
|
case UCAL_DATE:
|
|
{
|
|
if(U_FAILURE(status)) return 0;
|
|
Calendar *cal = clone();
|
|
if(!cal) { status = U_MEMORY_ALLOCATION_ERROR; return 0; }
|
|
cal->setLenient(TRUE);
|
|
cal->prepareGetActual(field,FALSE,status);
|
|
result = handleGetMonthLength(cal->get(UCAL_EXTENDED_YEAR, status), cal->get(UCAL_MONTH, status));
|
|
delete cal;
|
|
}
|
|
break;
|
|
|
|
case UCAL_DAY_OF_YEAR:
|
|
{
|
|
if(U_FAILURE(status)) return 0;
|
|
Calendar *cal = clone();
|
|
if(!cal) { status = U_MEMORY_ALLOCATION_ERROR; return 0; }
|
|
cal->setLenient(TRUE);
|
|
cal->prepareGetActual(field,FALSE,status);
|
|
result = handleGetYearLength(cal->get(UCAL_EXTENDED_YEAR, status));
|
|
delete cal;
|
|
}
|
|
break;
|
|
|
|
case UCAL_DAY_OF_WEEK:
|
|
case UCAL_AM_PM:
|
|
case UCAL_HOUR:
|
|
case UCAL_HOUR_OF_DAY:
|
|
case UCAL_MINUTE:
|
|
case UCAL_SECOND:
|
|
case UCAL_MILLISECOND:
|
|
case UCAL_ZONE_OFFSET:
|
|
case UCAL_DST_OFFSET:
|
|
case UCAL_DOW_LOCAL:
|
|
case UCAL_JULIAN_DAY:
|
|
case UCAL_MILLISECONDS_IN_DAY:
|
|
// These fields all have fixed minima/maxima
|
|
result = getMaximum(field);
|
|
break;
|
|
|
|
default:
|
|
// For all other fields, do it the hard way....
|
|
result = getActualHelper(field, getLeastMaximum(field), getMaximum(field),status);
|
|
break;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
/**
|
|
* Prepare this calendar for computing the actual minimum or maximum.
|
|
* This method modifies this calendar's fields; it is called on a
|
|
* temporary calendar.
|
|
*
|
|
* <p>Rationale: The semantics of getActualXxx() is to return the
|
|
* maximum or minimum value that the given field can take, taking into
|
|
* account other relevant fields. In general these other fields are
|
|
* larger fields. For example, when computing the actual maximum
|
|
* DATE, the current value of DATE itself is ignored,
|
|
* as is the value of any field smaller.
|
|
*
|
|
* <p>The time fields all have fixed minima and maxima, so we don't
|
|
* need to worry about them. This also lets us set the
|
|
* MILLISECONDS_IN_DAY to zero to erase any effects the time fields
|
|
* might have when computing date fields.
|
|
*
|
|
* <p>DAY_OF_WEEK is adjusted specially for the WEEK_OF_MONTH and
|
|
* WEEK_OF_YEAR fields to ensure that they are computed correctly.
|
|
* @internal
|
|
*/
|
|
void Calendar::prepareGetActual(UCalendarDateFields field, UBool isMinimum, UErrorCode &status)
|
|
{
|
|
set(UCAL_MILLISECONDS_IN_DAY, 0);
|
|
|
|
switch (field) {
|
|
case UCAL_YEAR:
|
|
case UCAL_EXTENDED_YEAR:
|
|
set(UCAL_DAY_OF_YEAR, getGreatestMinimum(UCAL_DAY_OF_YEAR));
|
|
break;
|
|
|
|
case UCAL_YEAR_WOY:
|
|
set(UCAL_WEEK_OF_YEAR, getGreatestMinimum(UCAL_WEEK_OF_YEAR));
|
|
|
|
case UCAL_MONTH:
|
|
set(UCAL_DATE, getGreatestMinimum(UCAL_DATE));
|
|
break;
|
|
|
|
case UCAL_DAY_OF_WEEK_IN_MONTH:
|
|
// For dowim, the maximum occurs for the DOW of the first of the
|
|
// month.
|
|
set(UCAL_DATE, 1);
|
|
set(UCAL_DAY_OF_WEEK, get(UCAL_DAY_OF_WEEK, status)); // Make this user set
|
|
break;
|
|
|
|
case UCAL_WEEK_OF_MONTH:
|
|
case UCAL_WEEK_OF_YEAR:
|
|
// If we're counting weeks, set the day of the week to either the
|
|
// first or last localized DOW. We know the last week of a month
|
|
// or year will contain the first day of the week, and that the
|
|
// first week will contain the last DOW.
|
|
{
|
|
int32_t dow = fFirstDayOfWeek;
|
|
if (isMinimum) {
|
|
dow = (dow + 6) % 7; // set to last DOW
|
|
if (dow < UCAL_SUNDAY) {
|
|
dow += 7;
|
|
}
|
|
}
|
|
#if defined (U_DEBUG_CAL)
|
|
fprintf(stderr, "prepareGetActualHelper(WOM/WOY) - dow=%d\n", dow);
|
|
#endif
|
|
set(UCAL_DAY_OF_WEEK, dow);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
// Do this last to give it the newest time stamp
|
|
set(field, getGreatestMinimum(field));
|
|
}
|
|
|
|
int32_t Calendar::getActualHelper(UCalendarDateFields field, int32_t startValue, int32_t endValue, UErrorCode &status) const
|
|
{
|
|
#if defined (U_DEBUG_CAL)
|
|
fprintf(stderr, "getActualHelper(%d,%d .. %d, %s)\n", field, startValue, endValue, u_errorName(status));
|
|
#endif
|
|
if (startValue == endValue) {
|
|
// if we know that the maximum value is always the same, just return it
|
|
return startValue;
|
|
}
|
|
|
|
int32_t delta = (endValue > startValue) ? 1 : -1;
|
|
|
|
// clone the calendar so we don't mess with the real one, and set it to
|
|
// accept anything for the field values
|
|
if(U_FAILURE(status)) return startValue;
|
|
Calendar *work = clone();
|
|
if(!work) { status = U_MEMORY_ALLOCATION_ERROR; return startValue; }
|
|
|
|
// need to resolve time here, otherwise, fields set for actual limit
|
|
// may cause conflict with fields previously set (but not yet resolved).
|
|
work->complete(status);
|
|
|
|
work->setLenient(TRUE);
|
|
work->prepareGetActual(field, delta < 0, status);
|
|
|
|
// now try each value from the start to the end one by one until
|
|
// we get a value that normalizes to another value. The last value that
|
|
// normalizes to itself is the actual maximum for the current date
|
|
work->set(field, startValue);
|
|
|
|
// prepareGetActual sets the first day of week in the same week with
|
|
// the first day of a month. Unlike WEEK_OF_YEAR, week number for the
|
|
// week which contains days from both previous and current month is
|
|
// not unique. For example, last several days in the previous month
|
|
// is week 5, and the rest of week is week 1.
|
|
int32_t result = startValue;
|
|
if ((work->get(field, status) != startValue
|
|
&& field != UCAL_WEEK_OF_MONTH && delta > 0 ) || U_FAILURE(status)) {
|
|
#if defined (U_DEBUG_CAL)
|
|
fprintf(stderr, "getActualHelper(fld %d) - got %d (not %d) - %s\n", field, work->get(field,status), startValue, u_errorName(status));
|
|
#endif
|
|
} else {
|
|
do {
|
|
startValue += delta;
|
|
work->add(field, delta, status);
|
|
if (work->get(field, status) != startValue || U_FAILURE(status)) {
|
|
#if defined (U_DEBUG_CAL)
|
|
fprintf(stderr, "getActualHelper(fld %d) - got %d (not %d), BREAK - %s\n", field, work->get(field,status), startValue, u_errorName(status));
|
|
#endif
|
|
break;
|
|
}
|
|
result = startValue;
|
|
} while (startValue != endValue);
|
|
}
|
|
delete work;
|
|
#if defined (U_DEBUG_CAL)
|
|
fprintf(stderr, "getActualHelper(%d) = %d\n", field, result);
|
|
#endif
|
|
return result;
|
|
}
|
|
|
|
|
|
|
|
|
|
// -------------------------------------
|
|
|
|
void
|
|
Calendar::setWeekData(const Locale& desiredLocale, const char *type, UErrorCode& status)
|
|
{
|
|
|
|
if (U_FAILURE(status)) return;
|
|
|
|
fFirstDayOfWeek = UCAL_SUNDAY;
|
|
fMinimalDaysInFirstWeek = 1;
|
|
fWeekendOnset = UCAL_SATURDAY;
|
|
fWeekendOnsetMillis = 0;
|
|
fWeekendCease = UCAL_SUNDAY;
|
|
fWeekendCeaseMillis = 86400000; // 24*60*60*1000
|
|
|
|
// Since week and weekend data is territory based instead of language based,
|
|
// we may need to tweak the locale that we are using to try to get the appropriate
|
|
// values, using the following logic:
|
|
// 1). If the locale has a language but no territory, use the territory as defined by
|
|
// the likely subtags.
|
|
// 2). If the locale has a script designation then we ignore it,
|
|
// then remove it ( i.e. "en_Latn_US" becomes "en_US" )
|
|
|
|
char minLocaleID[ULOC_FULLNAME_CAPACITY] = { 0 };
|
|
UErrorCode myStatus = U_ZERO_ERROR;
|
|
|
|
uloc_minimizeSubtags(desiredLocale.getName(),minLocaleID,ULOC_FULLNAME_CAPACITY,&myStatus);
|
|
Locale min = Locale::createFromName(minLocaleID);
|
|
Locale useLocale;
|
|
if ( uprv_strlen(desiredLocale.getCountry()) == 0 ||
|
|
(uprv_strlen(desiredLocale.getScript()) > 0 && uprv_strlen(min.getScript()) == 0) ) {
|
|
char maxLocaleID[ULOC_FULLNAME_CAPACITY] = { 0 };
|
|
myStatus = U_ZERO_ERROR;
|
|
uloc_addLikelySubtags(desiredLocale.getName(),maxLocaleID,ULOC_FULLNAME_CAPACITY,&myStatus);
|
|
Locale max = Locale::createFromName(maxLocaleID);
|
|
useLocale = Locale(max.getLanguage(),max.getCountry());
|
|
} else {
|
|
useLocale = Locale(desiredLocale);
|
|
}
|
|
|
|
/* The code here is somewhat of a hack, since week data and weekend data aren't really tied to
|
|
a specific calendar, they aren't truly locale data. But this is the only place where valid and
|
|
actual locale can be set, so we take a shot at it here by loading a representative resource
|
|
from the calendar data. The code used to use the dateTimeElements resource to get first day
|
|
of week data, but this was moved to supplemental data under ticket 7755. (JCE) */
|
|
|
|
CalendarData calData(useLocale,type,status);
|
|
UResourceBundle *monthNames = calData.getByKey(gMonthNames,status);
|
|
if (U_SUCCESS(status)) {
|
|
U_LOCALE_BASED(locBased,*this);
|
|
locBased.setLocaleIDs(ures_getLocaleByType(monthNames, ULOC_VALID_LOCALE, &status),
|
|
ures_getLocaleByType(monthNames, ULOC_ACTUAL_LOCALE, &status));
|
|
} else {
|
|
status = U_USING_FALLBACK_WARNING;
|
|
return;
|
|
}
|
|
|
|
|
|
// Read week data values from supplementalData week data
|
|
UResourceBundle *rb = ures_openDirect(NULL, "supplementalData", &status);
|
|
ures_getByKey(rb, "weekData", rb, &status);
|
|
UResourceBundle *weekData = ures_getByKey(rb, useLocale.getCountry(), NULL, &status);
|
|
if (status == U_MISSING_RESOURCE_ERROR && rb != NULL) {
|
|
status = U_ZERO_ERROR;
|
|
weekData = ures_getByKey(rb, "001", NULL, &status);
|
|
}
|
|
|
|
if (U_FAILURE(status)) {
|
|
#if defined (U_DEBUG_CALDATA)
|
|
fprintf(stderr, " Failure loading weekData from supplemental = %s\n", u_errorName(status));
|
|
#endif
|
|
status = U_USING_FALLBACK_WARNING;
|
|
} else {
|
|
int32_t arrLen;
|
|
const int32_t *weekDataArr = ures_getIntVector(weekData,&arrLen,&status);
|
|
if( U_SUCCESS(status) && arrLen == 6
|
|
&& 1 <= weekDataArr[0] && weekDataArr[0] <= 7
|
|
&& 1 <= weekDataArr[1] && weekDataArr[1] <= 7
|
|
&& 1 <= weekDataArr[2] && weekDataArr[2] <= 7
|
|
&& 1 <= weekDataArr[4] && weekDataArr[4] <= 7) {
|
|
fFirstDayOfWeek = (UCalendarDaysOfWeek)weekDataArr[0];
|
|
fMinimalDaysInFirstWeek = (uint8_t)weekDataArr[1];
|
|
fWeekendOnset = (UCalendarDaysOfWeek)weekDataArr[2];
|
|
fWeekendOnsetMillis = weekDataArr[3];
|
|
fWeekendCease = (UCalendarDaysOfWeek)weekDataArr[4];
|
|
fWeekendCeaseMillis = weekDataArr[5];
|
|
} else {
|
|
status = U_INVALID_FORMAT_ERROR;
|
|
}
|
|
}
|
|
ures_close(weekData);
|
|
ures_close(rb);
|
|
}
|
|
|
|
/**
|
|
* Recompute the time and update the status fields isTimeSet
|
|
* and areFieldsSet. Callers should check isTimeSet and only
|
|
* call this method if isTimeSet is false.
|
|
*/
|
|
void
|
|
Calendar::updateTime(UErrorCode& status)
|
|
{
|
|
computeTime(status);
|
|
if(U_FAILURE(status))
|
|
return;
|
|
|
|
// If we are lenient, we need to recompute the fields to normalize
|
|
// the values. Also, if we haven't set all the fields yet (i.e.,
|
|
// in a newly-created object), we need to fill in the fields. [LIU]
|
|
if (isLenient() || ! fAreAllFieldsSet)
|
|
fAreFieldsSet = FALSE;
|
|
|
|
fIsTimeSet = TRUE;
|
|
fAreFieldsVirtuallySet = FALSE;
|
|
}
|
|
|
|
Locale
|
|
Calendar::getLocale(ULocDataLocaleType type, UErrorCode& status) const {
|
|
U_LOCALE_BASED(locBased, *this);
|
|
return locBased.getLocale(type, status);
|
|
}
|
|
|
|
const char *
|
|
Calendar::getLocaleID(ULocDataLocaleType type, UErrorCode& status) const {
|
|
U_LOCALE_BASED(locBased, *this);
|
|
return locBased.getLocaleID(type, status);
|
|
}
|
|
|
|
void
|
|
Calendar::recalculateStamp() {
|
|
int32_t index;
|
|
int32_t currentValue;
|
|
int32_t j, i;
|
|
|
|
fNextStamp = 1;
|
|
|
|
for (j = 0; j < UCAL_FIELD_COUNT; j++) {
|
|
currentValue = STAMP_MAX;
|
|
index = -1;
|
|
for (i = 0; i < UCAL_FIELD_COUNT; i++) {
|
|
if (fStamp[i] > fNextStamp && fStamp[i] < currentValue) {
|
|
currentValue = fStamp[i];
|
|
index = i;
|
|
}
|
|
}
|
|
|
|
if (index >= 0) {
|
|
fStamp[index] = ++fNextStamp;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
fNextStamp++;
|
|
}
|
|
|
|
// Deprecated function. This doesn't need to be inline.
|
|
void
|
|
Calendar::internalSet(EDateFields field, int32_t value)
|
|
{
|
|
internalSet((UCalendarDateFields) field, value);
|
|
}
|
|
|
|
BasicTimeZone*
|
|
Calendar::getBasicTimeZone(void) const {
|
|
if (dynamic_cast<const OlsonTimeZone *>(fZone) != NULL
|
|
|| dynamic_cast<const SimpleTimeZone *>(fZone) != NULL
|
|
|| dynamic_cast<const RuleBasedTimeZone *>(fZone) != NULL
|
|
|| dynamic_cast<const VTimeZone *>(fZone) != NULL) {
|
|
return (BasicTimeZone*)fZone;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
U_NAMESPACE_END
|
|
|
|
#endif /* #if !UCONFIG_NO_FORMATTING */
|
|
|
|
|
|
//eof
|
|
|