blob: 7a2a6ee383edb3c4ceec3c057214e9a76e78f6bf [file] [log] [blame]
// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
*******************************************************************************
* Copyright (C) 1997-2016, 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"
#include "sharedcalendar.h"
#include "unifiedcache.h"
#include "ulocimp.h"
#if !UCONFIG_NO_SERVICE
static icu::ICULocaleService* gService = NULL;
static icu::UInitOnce gServiceInitOnce = U_INITONCE_INITIALIZER;
// 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
#endif
// ------------------------------------------
//
// 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
SharedCalendar::~SharedCalendar() {
delete ptr;
}
template<> U_I18N_API
const SharedCalendar *LocaleCacheKey<SharedCalendar>::createObject(
const void * /*unusedCreationContext*/, UErrorCode &status) const {
Calendar *calendar = Calendar::makeInstance(fLoc, status);
if (U_FAILURE(status)) {
return NULL;
}
SharedCalendar *shared = new SharedCalendar(calendar);
if (shared == NULL) {
delete calendar;
status = U_MEMORY_ALLOCATION_ERROR;
return NULL;
}
shared->addRef();
return shared;
}
static ECalType getCalendarType(const char *s) {
for (int i = 0; gCalTypes[i] != NULL; i++) {
if (uprv_stricmp(s, gCalTypes[i]) == 0) {
return (ECalType)i;
}
}
return CALTYPE_UNKNOWN;
}
#if !UCONFIG_NO_SERVICE
// Only used with service registration.
static UBool isStandardSupportedKeyword(const char *keyword, UErrorCode& status) {
if(U_FAILURE(status)) {
return FALSE;
}
ECalType calType = getCalendarType(keyword);
return (calType != CALTYPE_UNKNOWN);
}
// only used with service registration.
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;
}
#endif
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];
(void)ulocimp_getRegionForSupplementalData(canonicalName, TRUE, region, sizeof(region), &status);
if (U_FAILURE(status)) {
return CALTYPE_GREGORIAN;
}
// 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 gCalendar[] = "calendar";
static const char gMonthNames[] = "monthNames";
static const char gGregorian[] = "gregorian";
// 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(NULL),
fRepeatedWallTime(UCAL_WALLTIME_LAST),
fSkippedWallTime(UCAL_WALLTIME_LAST)
{
validLocale[0] = 0;
actualLocale[0] = 0;
clear();
if (U_FAILURE(success)) {
return;
}
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(NULL),
fRepeatedWallTime(UCAL_WALLTIME_LAST),
fSkippedWallTime(UCAL_WALLTIME_LAST)
{
validLocale[0] = 0;
actualLocale[0] = 0;
if (U_FAILURE(success)) {
return;
}
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(NULL),
fRepeatedWallTime(UCAL_WALLTIME_LAST),
fSkippedWallTime(UCAL_WALLTIME_LAST)
{
validLocale[0] = 0;
actualLocale[0] = 0;
if (U_FAILURE(success)) {
return;
}
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 = NULL;
*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;
delete fZone;
fZone = NULL;
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_strncpy(validLocale, right.validLocale, sizeof(validLocale));
uprv_strncpy(actualLocale, right.actualLocale, sizeof(actualLocale));
validLocale[sizeof(validLocale)-1] = 0;
actualLocale[sizeof(validLocale)-1] = 0;
}
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::makeInstance(const Locale& aLocale, UErrorCode& success) {
if (U_FAILURE(success)) {
return NULL;
}
Locale actualLoc;
UObject* u = NULL;
#if !UCONFIG_NO_SERVICE
if (isCalendarServiceUsed()) {
u = getCalendarService(success)->get(aLocale, LocaleKey::KIND_ANY, &actualLoc, success);
}
else
#endif
{
u = createStandardCalendar(getCalendarTypeForLocale(aLocale.getName()), aLocale, success);
}
Calendar* c = NULL;
if(U_FAILURE(success) || !u) {
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) {
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;
return NULL;
}
#ifdef U_DEBUG_CALSVC
fprintf(stderr, "%p: setting week count data to locale %s, actual locale %s\n", c, (const char*)aLocale.getName(), (const char *)actualLoc.getName());
#endif
c->setWeekData(aLocale, c->getType(), success); // set the correct locale (this was an indirected calendar)
char keyword[ULOC_FULLNAME_CAPACITY];
UErrorCode tmpStatus = U_ZERO_ERROR;
l.getKeywordValue("calendar", keyword, ULOC_FULLNAME_CAPACITY, tmpStatus);
if (U_SUCCESS(tmpStatus) && uprv_strcmp(keyword, "iso8601") == 0) {
c->setFirstDayOfWeek(UCAL_MONDAY);
c->setMinimalDaysInFirstWeek(4);
}
}
else
#endif /* UCONFIG_NO_SERVICE */
{
// a calendar was returned - we assume the factory did the right thing.
c = (Calendar*)u;
}
return c;
}
Calendar* U_EXPORT2
Calendar::createInstance(TimeZone* zone, const Locale& aLocale, UErrorCode& success)
{
LocalPointer<TimeZone> zonePtr(zone);
const SharedCalendar *shared = NULL;
UnifiedCache::getByLocale(aLocale, shared, success);
if (U_FAILURE(success)) {
return NULL;
}
Calendar *c = (*shared)->clone();
shared->removeRef();
if (c == NULL) {
success = U_MEMORY_ALLOCATION_ERROR;
return NULL;
}
// Now, reset calendar to default state:
c->adoptTimeZone(zonePtr.orphan()); // Set the correct time zone
c->setTimeInMillis(getNow(), success); // let the new calendar have the current time.
return c;
}
// -------------------------------------
Calendar* U_EXPORT2
Calendar::createInstance(const TimeZone& zone, const Locale& aLocale, UErrorCode& success)
{
Calendar* c = createInstance(aLocale, success);
if(U_SUCCESS(success) && c) {
c->setTimeZone(zone);
}
return c;
}
// -------------------------------------
void U_EXPORT2
Calendar::getCalendarTypeFromLocale(
const Locale &aLocale,
char *typeBuffer,
int32_t typeBufferSize,
UErrorCode &success) {
const SharedCalendar *shared = NULL;
UnifiedCache::getByLocale(aLocale, shared, success);
if (U_FAILURE(success)) {
return;
}
uprv_strncpy(typeBuffer, (*shared)->getType(), typeBufferSize);
shared->removeRef();
if (typeBuffer[typeBufferSize - 1]) {
success = U_BUFFER_OVERFLOW_ERROR;
}
}
UBool
Calendar::operator==(const Calendar& that) const
{
UErrorCode status = U_ZERO_ERROR;
return isEquivalentTo(that) &&
getTimeInMillis(status) == that.getTimeInMillis(status) &&
U_SUCCESS(status);
}
UBool
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);
}
// -------------------------------------
// For now the full getRelatedYear implementation is here;
// per #10752 move the non-default implementation to subclasses
// (default implementation will do no year adjustment)
static int32_t gregoYearFromIslamicStart(int32_t year) {
// ad hoc conversion, improve under #10752
// rough est for now, ok for grego 1846-2138,
// otherwise occasionally wrong (for 3% of years)
int cycle, offset, shift = 0;
if (year >= 1397) {
cycle = (year - 1397) / 67;
offset = (year - 1397) % 67;
shift = 2*cycle + ((offset >= 33)? 1: 0);
} else {
cycle = (year - 1396) / 67 - 1;
offset = -(year - 1396) % 67;
shift = 2*cycle + ((offset <= 33)? 1: 0);
}
return year + 579 - shift;
}
int32_t Calendar::getRelatedYear(UErrorCode &status) const
{
if (U_FAILURE(status)) {
return 0;
}
int32_t year = get(UCAL_EXTENDED_YEAR, status);
if (U_FAILURE(status)) {
return 0;
}
// modify for calendar type
ECalType type = getCalendarType(getType());
switch (type) {
case CALTYPE_PERSIAN:
year += 622; break;
case CALTYPE_HEBREW:
year -= 3760; break;
case CALTYPE_CHINESE:
year -= 2637; break;
case CALTYPE_INDIAN:
year += 79; break;
case CALTYPE_COPTIC:
year += 284; break;
case CALTYPE_ETHIOPIC:
year += 8; break;
case CALTYPE_ETHIOPIC_AMETE_ALEM:
year -=5492; break;
case CALTYPE_DANGI:
year -= 2333; break;
case CALTYPE_ISLAMIC_CIVIL:
case CALTYPE_ISLAMIC:
case CALTYPE_ISLAMIC_UMALQURA:
case CALTYPE_ISLAMIC_TBLA:
case CALTYPE_ISLAMIC_RGSA:
year = gregoYearFromIslamicStart(year); break;
default:
// CALTYPE_GREGORIAN
// CALTYPE_JAPANESE
// CALTYPE_BUDDHIST
// CALTYPE_ROC
// CALTYPE_ISO8601
// do nothing, EXTENDED_YEAR same as Gregorian
break;
}
return year;
}
// -------------------------------------
// For now the full setRelatedYear implementation is here;
// per #10752 move the non-default implementation to subclasses
// (default implementation will do no year adjustment)
static int32_t firstIslamicStartYearFromGrego(int32_t year) {
// ad hoc conversion, improve under #10752
// rough est for now, ok for grego 1846-2138,
// otherwise occasionally wrong (for 3% of years)
int cycle, offset, shift = 0;
if (year >= 1977) {
cycle = (year - 1977) / 65;
offset = (year - 1977) % 65;
shift = 2*cycle + ((offset >= 32)? 1: 0);
} else {
cycle = (year - 1976) / 65 - 1;
offset = -(year - 1976) % 65;
shift = 2*cycle + ((offset <= 32)? 1: 0);
}
return year - 579 + shift;
}
void Calendar::setRelatedYear(int32_t year)
{
// modify for calendar type
ECalType type = getCalendarType(getType());
switch (type) {
case CALTYPE_PERSIAN:
year -= 622; break;
case CALTYPE_HEBREW:
year += 3760; break;
case CALTYPE_CHINESE:
year += 2637; break;
case CALTYPE_INDIAN:
year -= 79; break;
case CALTYPE_COPTIC:
year -= 284; break;
case CALTYPE_ETHIOPIC:
year -= 8; break;
case CALTYPE_ETHIOPIC_AMETE_ALEM:
year +=5492; break;
case CALTYPE_DANGI:
year += 2333; break;
case CALTYPE_ISLAMIC_CIVIL:
case CALTYPE_ISLAMIC:
case CALTYPE_ISLAMIC_UMALQURA:
case CALTYPE_ISLAMIC_TBLA:
case CALTYPE_ISLAMIC_RGSA:
year = firstIslamicStartYearFromGrego(year); break;
default:
// CALTYPE_GREGORIAN
// CALTYPE_JAPANESE
// CALTYPE_BUDDHIST
// CALTYPE_ROC
// CALTYPE_ISO8601
// do nothing, EXTENDED_YEAR same as Gregorian
break;
}
// set extended year
set(UCAL_EXTENDED_YEAR, year);
}
// -------------------------------------
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 wall time 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 keepWallTimeInvariant 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 keepWallTimeInvariant = 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
U_FALLTHROUGH;
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;
keepWallTimeInvariant = FALSE;
break;
case UCAL_MINUTE:
delta *= kOneMinute;
keepWallTimeInvariant = FALSE;
break;
case UCAL_SECOND:
delta *= kOneSecond;
keepWallTimeInvariant = FALSE;
break;
case UCAL_MILLISECOND:
case UCAL_MILLISECONDS_IN_DAY:
keepWallTimeInvariant = 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 wall time 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 prevWallTime = 0;
if (keepWallTimeInvariant) {
prevOffset = get(UCAL_DST_OFFSET, status) + get(UCAL_ZONE_OFFSET, status);
prevWallTime = get(UCAL_MILLISECONDS_IN_DAY, status);
}
setTimeInMillis(getTimeInMillis(status) + delta, status);
if (keepWallTimeInvariant) {
int32_t newWallTime = get(UCAL_MILLISECONDS_IN_DAY, status);
if (newWallTime != prevWallTime) {
// There is at least one zone transition between the base
// time and the result time. As the result, wall time has
// changed.
UDate t = internalGetTime();
int32_t newOffset = get(UCAL_DST_OFFSET, status) + get(UCAL_ZONE_OFFSET, status);
if (newOffset != prevOffset) {
// 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) {
setTimeInMillis(t + adjAmount, status);
newWallTime = get(UCAL_MILLISECONDS_IN_DAY, status);
}
if (newWallTime != prevWallTime) {
// The result wall time or adjusted wall time was shifted because
// the target wall time does not exist on the result date.
switch (fSkippedWallTime) {
case UCAL_WALLTIME_FIRST:
if (adjAmount > 0) {
setTimeInMillis(t, status);
}
break;
case UCAL_WALLTIME_LAST:
if (adjAmount < 0) {
setTimeInMillis(t, status);
}
break;
case UCAL_WALLTIME_NEXT_VALID:
UDate tmpT = adjAmount > 0 ? internalGetTime() : t;
UDate immediatePrevTrans;
UBool hasTransition = getImmediatePreviousZoneTransition(tmpT, &immediatePrevTrans, status);
if (U_SUCCESS(status) && hasTransition) {
setTimeInMillis(immediatePrevTrans, status);
}
break;
}
}
}
}
}
}
// -------------------------------------
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
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
{
U_ASSERT(fZone != NULL);
return *fZone;
}
// -------------------------------------
TimeZone*
Calendar::orphanTimeZone()
{
// we let go of the time zone; the new time zone is the system default time zone
TimeZone *defaultZone = TimeZone::createDefault();
if (defaultZone == NULL) {
// No error handling available. Must keep fZone non-NULL, there are many unchecked uses.
return NULL;
}
TimeZone *z = fZone;
fZone = defaultZone;
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
U_FALLTHROUGH;
}
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 (<