1999-08-16 21:50:52 +00:00
|
|
|
/*
|
|
|
|
*******************************************************************************
|
2003-06-03 20:58:22 +00:00
|
|
|
* Copyright (C) 1996-2003, International Business Machines
|
1999-11-23 01:30:04 +00:00
|
|
|
* Corporation and others. All Rights Reserved.
|
1999-08-16 21:50:52 +00:00
|
|
|
*******************************************************************************
|
|
|
|
*/
|
|
|
|
|
2002-09-20 01:54:48 +00:00
|
|
|
#include "unicode/utypes.h"
|
|
|
|
|
|
|
|
#if !UCONFIG_NO_FORMATTING
|
1999-08-16 21:50:52 +00:00
|
|
|
|
2002-09-20 01:54:48 +00:00
|
|
|
#include "unicode/ucal.h"
|
1999-12-28 23:57:50 +00:00
|
|
|
#include "unicode/uloc.h"
|
|
|
|
#include "unicode/calendar.h"
|
|
|
|
#include "unicode/timezone.h"
|
2003-03-05 18:36:48 +00:00
|
|
|
#include "unicode/simpletz.h"
|
1999-12-28 23:57:50 +00:00
|
|
|
#include "unicode/ustring.h"
|
2002-11-12 23:52:27 +00:00
|
|
|
#include "unicode/strenum.h"
|
2002-07-16 17:50:42 +00:00
|
|
|
#include "cmemory.h"
|
2002-11-12 23:52:27 +00:00
|
|
|
#include "ustrenum.h"
|
1999-08-16 21:50:52 +00:00
|
|
|
|
2001-10-08 23:26:58 +00:00
|
|
|
U_NAMESPACE_USE
|
|
|
|
|
2003-03-05 18:36:48 +00:00
|
|
|
static TimeZone*
|
|
|
|
_createTimeZone(const UChar* zoneID, int32_t len, UErrorCode* ec) {
|
|
|
|
TimeZone* zone = NULL;
|
|
|
|
if (ec!=NULL && U_SUCCESS(*ec)) {
|
|
|
|
// Note that if zoneID is invalid, we get back GMT. This odd
|
|
|
|
// behavior is by design and goes back to the JDK. The only
|
|
|
|
// failure we will see is a memory allocation failure.
|
|
|
|
int32_t l = (len<0 ? u_strlen(zoneID) : len);
|
|
|
|
zone = TimeZone::createTimeZone(UnicodeString(zoneID, l));
|
|
|
|
if (zone == NULL) {
|
|
|
|
*ec = U_MEMORY_ALLOCATION_ERROR;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return zone;
|
|
|
|
}
|
|
|
|
|
|
|
|
U_CAPI UEnumeration* U_EXPORT2
|
|
|
|
ucal_openTimeZones(UErrorCode* ec) {
|
|
|
|
return uenum_openStringEnumeration(TimeZone::createEnumeration(), ec);
|
|
|
|
}
|
|
|
|
|
2002-11-12 23:52:27 +00:00
|
|
|
U_CAPI UEnumeration* U_EXPORT2
|
2003-03-05 18:36:48 +00:00
|
|
|
ucal_openCountryTimeZones(const char* country, UErrorCode* ec) {
|
|
|
|
return uenum_openStringEnumeration(TimeZone::createEnumeration(country), ec);
|
|
|
|
}
|
|
|
|
|
|
|
|
U_CAPI int32_t U_EXPORT2
|
|
|
|
ucal_getDefaultTimeZone(UChar* result, int32_t resultCapacity, UErrorCode* ec) {
|
|
|
|
int32_t len = 0;
|
|
|
|
if (ec!=NULL && U_SUCCESS(*ec)) {
|
|
|
|
TimeZone* zone = TimeZone::createDefault();
|
|
|
|
if (zone == NULL) {
|
|
|
|
*ec = U_MEMORY_ALLOCATION_ERROR;
|
|
|
|
} else {
|
|
|
|
UnicodeString id;
|
|
|
|
zone->getID(id);
|
|
|
|
delete zone;
|
|
|
|
len = id.extract(result, resultCapacity, *ec);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
|
|
|
U_CAPI void U_EXPORT2
|
|
|
|
ucal_setDefaultTimeZone(const UChar* zoneID, UErrorCode* ec) {
|
|
|
|
TimeZone* zone = _createTimeZone(zoneID, -1, ec);
|
|
|
|
if (zone != NULL) {
|
|
|
|
TimeZone::adoptDefault(zone);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
U_CAPI int32_t U_EXPORT2
|
|
|
|
ucal_getDSTSavings(const UChar* zoneID, UErrorCode* ec) {
|
|
|
|
int32_t result = 0;
|
|
|
|
TimeZone* zone = _createTimeZone(zoneID, -1, ec);
|
2003-08-15 21:05:51 +00:00
|
|
|
if (U_SUCCESS(*ec)) {
|
|
|
|
if (zone->getDynamicClassID() == SimpleTimeZone::getStaticClassID()) {
|
|
|
|
result = ((SimpleTimeZone*) zone)->getDSTSavings();
|
|
|
|
} else {
|
|
|
|
// Since there is no getDSTSavings on TimeZone, we use a
|
|
|
|
// heuristic: Starting with the current time, march
|
|
|
|
// forwards for one year, looking for DST savings.
|
|
|
|
// Stepping by weeks is sufficient.
|
|
|
|
UDate d = Calendar::getNow();
|
|
|
|
for (int32_t i=0; i<53; ++i, d+=U_MILLIS_PER_DAY*7.0) {
|
|
|
|
int32_t raw, dst;
|
|
|
|
zone->getOffset(d, FALSE, raw, dst, *ec);
|
|
|
|
if (U_FAILURE(*ec)) {
|
|
|
|
break;
|
|
|
|
} else if (dst != 0) {
|
|
|
|
result = dst;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2003-03-05 18:36:48 +00:00
|
|
|
}
|
|
|
|
delete zone;
|
|
|
|
return result;
|
2002-11-12 23:52:27 +00:00
|
|
|
}
|
|
|
|
|
2003-11-19 21:51:36 +00:00
|
|
|
#ifdef U_USE_UCAL_OBSOLETE_2_8
|
2001-11-21 01:08:55 +00:00
|
|
|
U_CAPI const UChar* U_EXPORT2
|
1999-08-16 21:50:52 +00:00
|
|
|
ucal_getAvailableTZIDs( int32_t rawOffset,
|
|
|
|
int32_t index,
|
|
|
|
UErrorCode* status)
|
|
|
|
{
|
2001-10-08 23:26:58 +00:00
|
|
|
|
1999-10-18 22:48:32 +00:00
|
|
|
if(U_FAILURE(*status)) return 0;
|
1999-08-16 21:50:52 +00:00
|
|
|
|
2002-11-21 00:59:20 +00:00
|
|
|
int32_t count = 0;
|
1999-08-16 21:50:52 +00:00
|
|
|
const UChar *retVal = 0;
|
|
|
|
|
2002-11-21 00:59:20 +00:00
|
|
|
const UnicodeString** tzs = TimeZone::createAvailableIDs(rawOffset,
|
|
|
|
count);
|
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
if(tzs == 0) {
|
1999-10-07 00:07:53 +00:00
|
|
|
*status = U_MEMORY_ALLOCATION_ERROR;
|
1999-08-16 21:50:52 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2002-11-21 00:59:20 +00:00
|
|
|
if(index < count)
|
|
|
|
retVal = tzs[index]->getBuffer();
|
|
|
|
else
|
1999-10-07 00:07:53 +00:00
|
|
|
*status = U_INDEX_OUTOFBOUNDS_ERROR;
|
2002-11-21 00:59:20 +00:00
|
|
|
|
2002-07-16 17:50:42 +00:00
|
|
|
uprv_free(tzs);
|
1999-08-16 21:50:52 +00:00
|
|
|
return retVal;
|
|
|
|
}
|
|
|
|
|
2001-11-21 01:08:55 +00:00
|
|
|
U_CAPI int32_t U_EXPORT2
|
1999-08-16 21:50:52 +00:00
|
|
|
ucal_countAvailableTZIDs(int32_t rawOffset)
|
|
|
|
{
|
2002-11-21 00:59:20 +00:00
|
|
|
|
|
|
|
int32_t count = 0;
|
|
|
|
|
|
|
|
const UnicodeString** tzs = TimeZone::createAvailableIDs(rawOffset,
|
|
|
|
count);
|
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
if(tzs == 0) {
|
1999-10-07 00:07:53 +00:00
|
|
|
// TBD: U_MEMORY_ALLOCATION_ERROR
|
1999-08-16 21:50:52 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2002-11-21 00:59:20 +00:00
|
|
|
|
|
|
|
uprv_free(tzs);
|
1999-08-16 21:50:52 +00:00
|
|
|
return count;
|
|
|
|
}
|
2003-11-19 21:51:36 +00:00
|
|
|
#endif
|
1999-08-16 21:50:52 +00:00
|
|
|
|
2001-11-21 01:08:55 +00:00
|
|
|
U_CAPI UDate U_EXPORT2
|
1999-08-16 21:50:52 +00:00
|
|
|
ucal_getNow()
|
|
|
|
{
|
2001-10-08 23:26:58 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
return Calendar::getNow();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ignore type until we add more subclasses
|
2001-11-21 01:08:55 +00:00
|
|
|
U_CAPI UCalendar* U_EXPORT2
|
1999-08-16 21:50:52 +00:00
|
|
|
ucal_open( const UChar* zoneID,
|
|
|
|
int32_t len,
|
|
|
|
const char* locale,
|
2000-08-15 18:25:20 +00:00
|
|
|
UCalendarType /*type*/,
|
1999-08-16 21:50:52 +00:00
|
|
|
UErrorCode* status)
|
|
|
|
{
|
2001-10-08 23:26:58 +00:00
|
|
|
|
1999-10-18 22:48:32 +00:00
|
|
|
if(U_FAILURE(*status)) return 0;
|
1999-08-16 21:50:52 +00:00
|
|
|
|
2003-03-05 18:36:48 +00:00
|
|
|
TimeZone* zone = (zoneID==NULL) ? TimeZone::createDefault()
|
|
|
|
: _createTimeZone(zoneID, len, status);
|
1999-08-16 21:50:52 +00:00
|
|
|
|
2003-03-05 18:36:48 +00:00
|
|
|
if (U_FAILURE(*status)) {
|
|
|
|
return NULL;
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
|
|
|
|
2000-04-15 21:23:28 +00:00
|
|
|
return (UCalendar*)Calendar::createInstance(zone, Locale(locale), *status);
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
|
|
|
|
2001-11-21 01:08:55 +00:00
|
|
|
U_CAPI void U_EXPORT2
|
1999-08-16 21:50:52 +00:00
|
|
|
ucal_close(UCalendar *cal)
|
|
|
|
{
|
2001-10-08 23:26:58 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
delete (Calendar*) cal;
|
|
|
|
}
|
|
|
|
|
2001-11-21 01:08:55 +00:00
|
|
|
U_CAPI void U_EXPORT2
|
1999-08-16 21:50:52 +00:00
|
|
|
ucal_setTimeZone( UCalendar* cal,
|
|
|
|
const UChar* zoneID,
|
|
|
|
int32_t len,
|
|
|
|
UErrorCode *status)
|
|
|
|
{
|
2001-10-08 23:26:58 +00:00
|
|
|
|
2000-11-29 02:14:29 +00:00
|
|
|
if(U_FAILURE(*status))
|
|
|
|
return;
|
1999-08-16 21:50:52 +00:00
|
|
|
|
2003-03-05 18:36:48 +00:00
|
|
|
TimeZone* zone = (zoneID==NULL) ? TimeZone::createDefault()
|
|
|
|
: _createTimeZone(zoneID, len, status);
|
1999-08-16 21:50:52 +00:00
|
|
|
|
2003-03-05 18:36:48 +00:00
|
|
|
if (zone != NULL) {
|
|
|
|
((Calendar*)cal)->adoptTimeZone(zone);
|
|
|
|
}
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
|
|
|
|
2001-11-21 01:08:55 +00:00
|
|
|
U_CAPI int32_t U_EXPORT2
|
2000-11-29 02:14:29 +00:00
|
|
|
ucal_getTimeZoneDisplayName(const UCalendar* cal,
|
1999-08-16 21:50:52 +00:00
|
|
|
UCalendarDisplayNameType type,
|
2000-11-29 02:14:29 +00:00
|
|
|
const char *locale,
|
1999-08-16 21:50:52 +00:00
|
|
|
UChar* result,
|
|
|
|
int32_t resultLength,
|
|
|
|
UErrorCode* status)
|
|
|
|
{
|
2001-10-08 23:26:58 +00:00
|
|
|
|
1999-10-18 22:48:32 +00:00
|
|
|
if(U_FAILURE(*status)) return -1;
|
1999-08-16 21:50:52 +00:00
|
|
|
|
|
|
|
const TimeZone& tz = ((Calendar*)cal)->getTimeZone();
|
2002-11-16 01:14:40 +00:00
|
|
|
UnicodeString id;
|
|
|
|
if(!(result==NULL && resultLength==0)) {
|
|
|
|
// NULL destination for pure preflighting: empty dummy string
|
|
|
|
// otherwise, alias the destination buffer
|
|
|
|
id.setTo(result, 0, resultLength);
|
|
|
|
}
|
1999-08-16 21:50:52 +00:00
|
|
|
|
|
|
|
switch(type) {
|
|
|
|
case UCAL_STANDARD:
|
2000-04-15 21:23:28 +00:00
|
|
|
tz.getDisplayName(FALSE, TimeZone::LONG, Locale(locale), id);
|
1999-08-16 21:50:52 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case UCAL_SHORT_STANDARD:
|
2000-04-15 21:23:28 +00:00
|
|
|
tz.getDisplayName(FALSE, TimeZone::SHORT, Locale(locale), id);
|
1999-08-16 21:50:52 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case UCAL_DST:
|
2000-04-15 21:23:28 +00:00
|
|
|
tz.getDisplayName(TRUE, TimeZone::LONG, Locale(locale), id);
|
1999-08-16 21:50:52 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case UCAL_SHORT_DST:
|
2000-04-15 21:23:28 +00:00
|
|
|
tz.getDisplayName(TRUE, TimeZone::SHORT, Locale(locale), id);
|
1999-08-16 21:50:52 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2001-09-05 23:39:38 +00:00
|
|
|
return id.extract(result, resultLength, *status);
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
|
|
|
|
2001-11-21 01:08:55 +00:00
|
|
|
U_CAPI UBool U_EXPORT2
|
1999-08-16 21:50:52 +00:00
|
|
|
ucal_inDaylightTime( const UCalendar* cal,
|
|
|
|
UErrorCode* status )
|
|
|
|
{
|
2001-10-08 23:26:58 +00:00
|
|
|
|
2000-05-18 22:08:39 +00:00
|
|
|
if(U_FAILURE(*status)) return (UBool) -1;
|
1999-08-16 21:50:52 +00:00
|
|
|
return ((Calendar*)cal)->inDaylightTime(*status);
|
|
|
|
}
|
|
|
|
|
2001-11-21 01:08:55 +00:00
|
|
|
U_CAPI int32_t U_EXPORT2
|
1999-08-16 21:50:52 +00:00
|
|
|
ucal_getAttribute( const UCalendar* cal,
|
|
|
|
UCalendarAttribute attr)
|
|
|
|
{
|
2001-10-08 23:26:58 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
switch(attr) {
|
|
|
|
case UCAL_LENIENT:
|
|
|
|
return ((Calendar*)cal)->isLenient();
|
|
|
|
|
|
|
|
case UCAL_FIRST_DAY_OF_WEEK:
|
|
|
|
return ((Calendar*)cal)->getFirstDayOfWeek();
|
|
|
|
|
|
|
|
case UCAL_MINIMAL_DAYS_IN_FIRST_WEEK:
|
|
|
|
return ((Calendar*)cal)->getMinimalDaysInFirstWeek();
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
1999-10-22 00:43:39 +00:00
|
|
|
return -1;
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
|
|
|
|
2001-11-21 01:08:55 +00:00
|
|
|
U_CAPI void U_EXPORT2
|
1999-08-16 21:50:52 +00:00
|
|
|
ucal_setAttribute( UCalendar* cal,
|
|
|
|
UCalendarAttribute attr,
|
|
|
|
int32_t newValue)
|
|
|
|
{
|
2001-10-08 23:26:58 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
switch(attr) {
|
|
|
|
case UCAL_LENIENT:
|
2000-05-18 22:08:39 +00:00
|
|
|
((Calendar*)cal)->setLenient((UBool)newValue);
|
1999-08-16 21:50:52 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case UCAL_FIRST_DAY_OF_WEEK:
|
2003-02-21 08:32:22 +00:00
|
|
|
((Calendar*)cal)->setFirstDayOfWeek((UCalendarDaysOfWeek)newValue);
|
1999-08-16 21:50:52 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case UCAL_MINIMAL_DAYS_IN_FIRST_WEEK:
|
|
|
|
((Calendar*)cal)->setMinimalDaysInFirstWeek((uint8_t)newValue);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-11-21 01:08:55 +00:00
|
|
|
U_CAPI const char* U_EXPORT2
|
1999-08-16 21:50:52 +00:00
|
|
|
ucal_getAvailable(int32_t index)
|
|
|
|
{
|
2001-10-08 23:26:58 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
return uloc_getAvailable(index);
|
|
|
|
}
|
|
|
|
|
2001-11-21 01:08:55 +00:00
|
|
|
U_CAPI int32_t U_EXPORT2
|
1999-08-16 21:50:52 +00:00
|
|
|
ucal_countAvailable()
|
|
|
|
{
|
2001-10-08 23:26:58 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
return uloc_countAvailable();
|
|
|
|
}
|
|
|
|
|
2001-11-21 01:08:55 +00:00
|
|
|
U_CAPI UDate U_EXPORT2
|
1999-08-16 21:50:52 +00:00
|
|
|
ucal_getMillis( const UCalendar* cal,
|
|
|
|
UErrorCode* status)
|
|
|
|
{
|
2001-10-08 23:26:58 +00:00
|
|
|
|
1999-10-18 22:48:32 +00:00
|
|
|
if(U_FAILURE(*status)) return (UDate) 0;
|
1999-08-16 21:50:52 +00:00
|
|
|
|
|
|
|
return ((Calendar*)cal)->getTime(*status);
|
|
|
|
}
|
|
|
|
|
2001-11-21 01:08:55 +00:00
|
|
|
U_CAPI void U_EXPORT2
|
1999-08-16 21:50:52 +00:00
|
|
|
ucal_setMillis( UCalendar* cal,
|
|
|
|
UDate dateTime,
|
|
|
|
UErrorCode* status )
|
|
|
|
{
|
1999-10-18 22:48:32 +00:00
|
|
|
if(U_FAILURE(*status)) return;
|
1999-08-16 21:50:52 +00:00
|
|
|
|
|
|
|
((Calendar*)cal)->setTime(dateTime, *status);
|
|
|
|
}
|
|
|
|
|
|
|
|
// TBD: why does this take an UErrorCode?
|
2001-11-21 01:08:55 +00:00
|
|
|
U_CAPI void U_EXPORT2
|
1999-08-16 21:50:52 +00:00
|
|
|
ucal_setDate( UCalendar* cal,
|
|
|
|
int32_t year,
|
|
|
|
int32_t month,
|
|
|
|
int32_t date,
|
|
|
|
UErrorCode *status)
|
|
|
|
{
|
2001-10-08 23:26:58 +00:00
|
|
|
|
1999-10-18 22:48:32 +00:00
|
|
|
if(U_FAILURE(*status)) return;
|
1999-08-16 21:50:52 +00:00
|
|
|
|
|
|
|
((Calendar*)cal)->set(year, month, date);
|
|
|
|
}
|
|
|
|
|
|
|
|
// TBD: why does this take an UErrorCode?
|
2001-11-21 01:08:55 +00:00
|
|
|
U_CAPI void U_EXPORT2
|
1999-08-16 21:50:52 +00:00
|
|
|
ucal_setDateTime( UCalendar* cal,
|
|
|
|
int32_t year,
|
|
|
|
int32_t month,
|
|
|
|
int32_t date,
|
|
|
|
int32_t hour,
|
|
|
|
int32_t minute,
|
|
|
|
int32_t second,
|
|
|
|
UErrorCode *status)
|
|
|
|
{
|
1999-10-18 22:48:32 +00:00
|
|
|
if(U_FAILURE(*status)) return;
|
1999-08-16 21:50:52 +00:00
|
|
|
|
|
|
|
((Calendar*)cal)->set(year, month, date, hour, minute, second);
|
|
|
|
}
|
|
|
|
|
2001-11-21 01:08:55 +00:00
|
|
|
U_CAPI UBool U_EXPORT2
|
1999-08-16 21:50:52 +00:00
|
|
|
ucal_equivalentTo( const UCalendar* cal1,
|
|
|
|
const UCalendar* cal2)
|
|
|
|
{
|
2001-10-08 23:26:58 +00:00
|
|
|
|
2002-08-21 18:33:38 +00:00
|
|
|
return ((Calendar*)cal1)->isEquivalentTo(*((Calendar*)cal2));
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
|
|
|
|
2001-11-21 01:08:55 +00:00
|
|
|
U_CAPI void U_EXPORT2
|
1999-08-16 21:50:52 +00:00
|
|
|
ucal_add( UCalendar* cal,
|
|
|
|
UCalendarDateFields field,
|
|
|
|
int32_t amount,
|
|
|
|
UErrorCode* status)
|
|
|
|
{
|
2001-10-08 23:26:58 +00:00
|
|
|
|
1999-10-18 22:48:32 +00:00
|
|
|
if(U_FAILURE(*status)) return;
|
1999-08-16 21:50:52 +00:00
|
|
|
|
2003-02-21 08:32:22 +00:00
|
|
|
((Calendar*)cal)->add(field, amount, *status);
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
|
|
|
|
2001-11-21 01:08:55 +00:00
|
|
|
U_CAPI void U_EXPORT2
|
1999-08-16 21:50:52 +00:00
|
|
|
ucal_roll( UCalendar* cal,
|
|
|
|
UCalendarDateFields field,
|
|
|
|
int32_t amount,
|
|
|
|
UErrorCode* status)
|
|
|
|
{
|
2001-10-08 23:26:58 +00:00
|
|
|
|
1999-10-18 22:48:32 +00:00
|
|
|
if(U_FAILURE(*status)) return;
|
1999-08-16 21:50:52 +00:00
|
|
|
|
2003-02-21 08:32:22 +00:00
|
|
|
((Calendar*)cal)->roll(field, amount, *status);
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
|
|
|
|
2001-11-21 01:08:55 +00:00
|
|
|
U_CAPI int32_t U_EXPORT2
|
1999-08-16 21:50:52 +00:00
|
|
|
ucal_get( const UCalendar* cal,
|
|
|
|
UCalendarDateFields field,
|
|
|
|
UErrorCode* status )
|
|
|
|
{
|
2001-10-08 23:26:58 +00:00
|
|
|
|
1999-10-18 22:48:32 +00:00
|
|
|
if(U_FAILURE(*status)) return -1;
|
1999-08-16 21:50:52 +00:00
|
|
|
|
2003-02-21 08:32:22 +00:00
|
|
|
return ((Calendar*)cal)->get(field, *status);
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
|
|
|
|
2001-11-21 01:08:55 +00:00
|
|
|
U_CAPI void U_EXPORT2
|
1999-08-16 21:50:52 +00:00
|
|
|
ucal_set( UCalendar* cal,
|
|
|
|
UCalendarDateFields field,
|
|
|
|
int32_t value)
|
|
|
|
{
|
2001-10-08 23:26:58 +00:00
|
|
|
|
2003-02-21 08:32:22 +00:00
|
|
|
((Calendar*)cal)->set(field, value);
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
|
|
|
|
2001-11-21 01:08:55 +00:00
|
|
|
U_CAPI UBool U_EXPORT2
|
1999-08-16 21:50:52 +00:00
|
|
|
ucal_isSet( const UCalendar* cal,
|
|
|
|
UCalendarDateFields field)
|
|
|
|
{
|
2001-10-08 23:26:58 +00:00
|
|
|
|
2003-02-21 08:32:22 +00:00
|
|
|
return ((Calendar*)cal)->isSet(field);
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
|
|
|
|
2001-11-21 01:08:55 +00:00
|
|
|
U_CAPI void U_EXPORT2
|
1999-08-16 21:50:52 +00:00
|
|
|
ucal_clearField( UCalendar* cal,
|
|
|
|
UCalendarDateFields field)
|
|
|
|
{
|
2001-10-08 23:26:58 +00:00
|
|
|
|
2003-02-21 08:32:22 +00:00
|
|
|
((Calendar*)cal)->clear(field);
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
|
|
|
|
2001-11-21 01:08:55 +00:00
|
|
|
U_CAPI void U_EXPORT2
|
1999-08-16 21:50:52 +00:00
|
|
|
ucal_clear(UCalendar* calendar)
|
|
|
|
{
|
2001-10-08 23:26:58 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
((Calendar*)calendar)->clear();
|
|
|
|
}
|
|
|
|
|
2001-11-21 01:08:55 +00:00
|
|
|
U_CAPI int32_t U_EXPORT2
|
1999-08-16 21:50:52 +00:00
|
|
|
ucal_getLimit( const UCalendar* cal,
|
|
|
|
UCalendarDateFields field,
|
|
|
|
UCalendarLimitType type,
|
|
|
|
UErrorCode *status)
|
|
|
|
{
|
2001-10-08 23:26:58 +00:00
|
|
|
|
1999-10-22 00:43:39 +00:00
|
|
|
if(status==0 || U_FAILURE(*status)) {
|
|
|
|
return -1;
|
|
|
|
}
|
1999-08-16 21:50:52 +00:00
|
|
|
|
|
|
|
switch(type) {
|
|
|
|
case UCAL_MINIMUM:
|
2003-02-21 08:32:22 +00:00
|
|
|
return ((Calendar*)cal)->getMinimum(field);
|
1999-08-16 21:50:52 +00:00
|
|
|
|
|
|
|
case UCAL_MAXIMUM:
|
2003-02-21 08:32:22 +00:00
|
|
|
return ((Calendar*)cal)->getMaximum(field);
|
1999-08-16 21:50:52 +00:00
|
|
|
|
|
|
|
case UCAL_GREATEST_MINIMUM:
|
2003-02-21 08:32:22 +00:00
|
|
|
return ((Calendar*)cal)->getGreatestMinimum(field);
|
1999-08-16 21:50:52 +00:00
|
|
|
|
|
|
|
case UCAL_LEAST_MAXIMUM:
|
2003-02-21 08:32:22 +00:00
|
|
|
return ((Calendar*)cal)->getLeastMaximum(field);
|
1999-08-16 21:50:52 +00:00
|
|
|
|
|
|
|
case UCAL_ACTUAL_MINIMUM:
|
2003-02-21 08:32:22 +00:00
|
|
|
return ((Calendar*)cal)->getActualMinimum(field,
|
1999-08-16 21:50:52 +00:00
|
|
|
*status);
|
|
|
|
|
|
|
|
case UCAL_ACTUAL_MAXIMUM:
|
2003-02-21 08:32:22 +00:00
|
|
|
return ((Calendar*)cal)->getActualMaximum(field,
|
1999-08-16 21:50:52 +00:00
|
|
|
*status);
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
1999-10-22 00:43:39 +00:00
|
|
|
return -1;
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
2002-09-20 01:54:48 +00:00
|
|
|
|
2003-11-14 21:08:16 +00:00
|
|
|
U_CAPI const char * U_EXPORT2
|
|
|
|
ucal_getLocaleByType(const UCalendar *cal, ULocDataLocaleType type, UErrorCode* status)
|
|
|
|
{
|
|
|
|
return ((Calendar*)cal)->getLocaleInternal(type, *status);
|
|
|
|
}
|
|
|
|
|
2002-09-20 01:54:48 +00:00
|
|
|
#endif /* #if !UCONFIG_NO_FORMATTING */
|