src/utils_i18n_ucalendar.c

   1 /*
   2  * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *    Licensed under the Apache License, Version 2.0 (the "License");
   5  *    you may not use this file except in compliance with the License.
   6  *    You may obtain a copy of the License at
   7  *
   8  *        http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *    Unless required by applicable law or agreed to in writing, software
  11  *    distributed under the License is distributed on an "AS IS" BASIS,
  12  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *    See the License for the specific language governing permissions and
  14  *    limitations under the License.
  15  */
  16
  17 #include <unicode/ucal.h>
  18 #include <utils_i18n_ucalendar.h>
  19 #include <utils_i18n_private.h>
  20
  21 int i18n_ucalendar_create ( const i18n_uchar *zone_id, int32_t len, const char *locale, i18n_ucalendar_type_e type, i18n_ucalendar_h *calendar )
  22 {
  23     retv_if(calendar == NULL, I18N_ERROR_INVALID_PARAMETER);
  24
  25     i18n_error_code_e i18n_error;
  26     UErrorCode icu_error = U_ZERO_ERROR;
  27     *calendar = ucal_open(zone_id, len, locale, type, &icu_error);
  28     ERR("Error code: %d", icu_error);
  29     ERR_MAPPING(icu_error, i18n_error);
  30     return i18n_error;
  31 }
  32
  33 int i18n_ucalendar_destroy ( i18n_ucalendar_h calendar )
  34 {
  35     retv_if(calendar == NULL, I18N_ERROR_INVALID_PARAMETER);
  36
  37     ucal_close(calendar);
  38     return I18N_ERROR_NONE;
  39 }
  40
  41 int i18n_ucalendar_clone ( const i18n_ucalendar_h cal, i18n_ucalendar_h *identical_to_cal )
  42 {
  43     retv_if(cal == NULL || identical_to_cal == NULL, I18N_ERROR_INVALID_PARAMETER);
  44
  45     i18n_error_code_e i18n_error;
  46     UErrorCode icu_error = U_ZERO_ERROR;
  47     *identical_to_cal =  ucal_clone(cal, &icu_error);
  48     ERR("Error code: %d", icu_error);
  49     ERR_MAPPING(icu_error, i18n_error);
  50     return i18n_error;
  51 }
  52
  53 int i18n_ucalendar_add ( i18n_ucalendar_h calendar, i18n_ucalendar_date_fields_e field, int32_t amount )
  54 {
  55     retv_if(calendar == NULL, I18N_ERROR_INVALID_PARAMETER);
  56
  57     i18n_error_code_e i18n_error;
  58     UErrorCode icu_error = U_ZERO_ERROR;
  59     ucal_add(calendar, field, amount, &icu_error);
  60     ERR("Error code: %d", icu_error);
  61     ERR_MAPPING(icu_error, i18n_error);
  62     return i18n_error;
  63 }
  64
  65 int i18n_ucalendar_is_equivalent_to ( const i18n_ucalendar_h calendar1, const i18n_ucalendar_h calendar2, i18n_ubool *equiv )
  66 {
  67     retv_if(equiv == NULL || calendar1 == NULL || calendar2 == NULL, I18N_ERROR_INVALID_PARAMETER);
  68
  69     *equiv = ucal_equivalentTo(calendar1, calendar2);
  70     return I18N_ERROR_NONE;
  71 }
  72
  73 int i18n_ucalendar_get_milliseconds ( const i18n_ucalendar_h calendar, i18n_udate *date )
  74 {
  75     retv_if(calendar == NULL || date == NULL, I18N_ERROR_INVALID_PARAMETER);
  76
  77     i18n_error_code_e i18n_error;
  78     UErrorCode icu_error = U_ZERO_ERROR;
  79     *date = ucal_getMillis(calendar, &icu_error);
  80     ERR("Error code: %d", icu_error);
  81     ERR_MAPPING(icu_error, i18n_error);
  82     return i18n_error;
  83 }
  84
  85 int i18n_ucalendar_get ( const i18n_ucalendar_h calendar, i18n_ucalendar_date_fields_e field, int32_t *val )
  86 {
  87     retv_if(calendar == NULL || val == NULL, I18N_ERROR_INVALID_PARAMETER);
  88
  89     i18n_error_code_e i18n_error;
  90     UErrorCode icu_error = U_ZERO_ERROR;
  91     *val = ucal_get(calendar, field, &icu_error);
  92     ERR("Error code: %d", icu_error);
  93     ERR_MAPPING(icu_error, i18n_error);
  94     return i18n_error;
  95 }
  96
  97 int i18n_ucalendar_get_attribute ( i18n_ucalendar_h calendar, i18n_ucalendar_attribute_e attr, int32_t *val)
  98 {
  99     retv_if(calendar == NULL || val == NULL, I18N_ERROR_INVALID_PARAMETER);
 100
 101     *val = ucal_getAttribute(calendar, attr);
 102     return I18N_ERROR_NONE;
 103 }
 104
 105 int i18n_ucalendar_get_timezone_displayname ( const i18n_ucalendar_h calendar, i18n_ucalendar_displayname_type_e type, const char *locale,
 106     i18n_uchar *result, int32_t result_len, int32_t *buf_size_needed )
 107 {
 108     retv_if(calendar == NULL || result == NULL || buf_size_needed == NULL, I18N_ERROR_INVALID_PARAMETER);
 109
 110     i18n_error_code_e i18n_error;
 111     UErrorCode icu_error = U_ZERO_ERROR;
 112     *buf_size_needed = ucal_getTimeZoneDisplayName(calendar, type, locale, result, result_len, &icu_error);
 113     ERR("Error code: %d", icu_error);
 114     ERR_MAPPING(icu_error, i18n_error);
 115     return i18n_error;
 116 }
 117
 118 int i18n_ucalendar_is_in_daylight_time ( const i18n_ucalendar_h calendar, i18n_ubool *is_in )
 119 {
 120     retv_if(calendar == NULL || is_in == NULL, I18N_ERROR_INVALID_PARAMETER);
 121
 122     i18n_error_code_e i18n_error;
 123     UErrorCode icu_error = U_ZERO_ERROR;
 124     *is_in = ucal_inDaylightTime(calendar, &icu_error);
 125     ERR("Error code: %d", icu_error);
 126     ERR_MAPPING(icu_error, i18n_error);
 127     return i18n_error;
 128 }
 129
 130 int i18n_ucalendar_set ( i18n_ucalendar_h cal, i18n_ucalendar_date_fields_e field, int32_t val )
 131 {
 132     retv_if(cal == NULL, I18N_ERROR_INVALID_PARAMETER);
 133
 134     ucal_set(cal, field, val);
 135     return I18N_ERROR_NONE;
 136 }
 137
 138 int i18n_ucalendar_set_attribute ( i18n_ucalendar_h calendar, i18n_ucalendar_attribute_e attr, int32_t val )
 139 {
 140     retv_if(calendar == NULL, I18N_ERROR_INVALID_PARAMETER);
 141
 142     ucal_setAttribute(calendar, attr, val);
 143     return I18N_ERROR_NONE;
 144 }
 145
 146 int i18n_ucalendar_set_date_time ( i18n_ucalendar_h calendar, int32_t year, int32_t month, int32_t date, int32_t hour, int32_t min, int32_t sec )
 147 {
 148     retv_if(calendar == NULL, I18N_ERROR_INVALID_PARAMETER);
 149
 150     i18n_error_code_e i18n_error;
 151     UErrorCode icu_error = U_ZERO_ERROR;
 152     ucal_setDateTime(calendar, year, month, date, hour, min, sec, &icu_error);
 153     ERR("Error code: %d", icu_error);
 154     ERR_MAPPING(icu_error, i18n_error);
 155     return i18n_error;
 156 }
 157
 158 int i18n_ucalendar_set_milliseconds ( i18n_ucalendar_h calendar, i18n_udate milliseconds )
 159 {
 160     retv_if(calendar == NULL, I18N_ERROR_INVALID_PARAMETER);
 161
 162     i18n_error_code_e i18n_error;
 163     UErrorCode icu_error = U_ZERO_ERROR;
 164     ucal_setMillis(calendar, milliseconds, &icu_error);
 165     ERR("Error code: %d", icu_error);
 166     ERR_MAPPING(icu_error, i18n_error);
 167     return i18n_error;
 168 }
 169
 170 int i18n_ucalendar_set_default_timezone ( const i18n_uchar *zone_id )
 171 {
 172     retv_if(zone_id == NULL, I18N_ERROR_INVALID_PARAMETER);
 173
 174     i18n_error_code_e i18n_error;
 175     UErrorCode icu_error = U_ZERO_ERROR;
 176     ucal_setDefaultTimeZone(zone_id, &icu_error);
 177     ERR("Error code: %d", icu_error);
 178     ERR_MAPPING(icu_error, i18n_error);
 179     return i18n_error;
 180 }
 181
 182 int32_t i18n_ucalendar_get_field_difference ( i18n_ucalendar_h calendar, i18n_udate target, i18n_ucalendar_date_fields_e field, i18n_error_code_e *status )
 183 {
 184     if(calendar == NULL)
 185     {
 186         if(NULL != status) {
 187             *status = I18N_ERROR_INVALID_PARAMETER;
 188         }
 189         return 0;
 190     }
 191
 192     UErrorCode icu_error = U_ZERO_ERROR;
 193     int32_t result = ucal_getFieldDifference(calendar, target, field, &icu_error);
 194     ERR("Error code: %d", icu_error);
 195
 196     if(NULL != status) {
 197         ERR_MAPPING(icu_error, *status);
 198     }
 199
 200     return result;
 201 }
 202
 203 int i18n_ucalendar_get_now ( i18n_udate *date )
 204 {
 205     retv_if(date == NULL, I18N_ERROR_INVALID_PARAMETER);
 206
 207     *date = ucal_getNow();
 208     return I18N_ERROR_NONE;
 209 }
 210
 211 // Newly Added APIs
 212 int i18n_ucalendar_timezone_id_enumeration_create ( i18n_system_timezone_type_e zone_type, const char *region, const int32_t *raw_offset, i18n_uenumeration_h *enumeration )
 213 {
 214     if(region == NULL || enumeration == NULL){
 215         return I18N_ERROR_INVALID_PARAMETER;
 216     }
 217     i18n_error_code_e i18n_error;
 218     UErrorCode icu_error = U_ZERO_ERROR;
 219     *enumeration = (i18n_uenumeration_h)ucal_openTimeZoneIDEnumeration (zone_type, region, raw_offset, &icu_error);
 220     ERR("Error code: %d", icu_error);
 221     ERR_MAPPING(icu_error, i18n_error);
 222     return i18n_error;
 223 }
 224
 225 int i18n_ucalendar_timezones_create (i18n_uenumeration_h *enumeration)
 226 {
 227     if(enumeration == NULL){
 228         return I18N_ERROR_INVALID_PARAMETER;
 229     }
 230     i18n_error_code_e i18n_error;
 231     UErrorCode icu_error = U_ZERO_ERROR;
 232     *enumeration = (i18n_uenumeration_h)ucal_openTimeZones(&icu_error);
 233     ERR("ErrorCode : %d", icu_error);
 234     ERR_MAPPING(icu_error, i18n_error);
 235     return i18n_error;
 236 }
 237
 238 int i18n_ucalendar_country_timezones_create (const char *country, i18n_uenumeration_h *enumeration)
 239 {
 240     if (country == NULL || enumeration == NULL) {
 241         return I18N_ERROR_INVALID_PARAMETER;
 242     }
 243     i18n_error_code_e i18n_error;
 244     UErrorCode icu_error = U_ZERO_ERROR;
 245     *enumeration = (i18n_uenumeration_h)ucal_openCountryTimeZones(country, &icu_error);
 246     ERR("ErrorCode : %d", icu_error);
 247     ERR_MAPPING(icu_error, i18n_error);
 248     return i18n_error;
 249 }
 250
 251 int32_t i18n_ucalendar_get_default_timezone (i18n_uchar *result, int32_t result_capacity)
 252 {
 253     i18n_error_code_e i18n_error;
 254     UErrorCode icu_error = U_ZERO_ERROR;
 255     int32_t result_ucal_getDefaultTimeZone = ucal_getDefaultTimeZone(result, result_capacity, &icu_error);
 256     ERR("ErrorCode : %d", icu_error);
 257     ERR_MAPPING(icu_error, i18n_error);
 258     set_last_result(i18n_error);
 259     return result_ucal_getDefaultTimeZone;
 260 }
 261
 262 int i18n_ucalendar_set_timezone ( i18n_ucalendar_h calendar, const i18n_uchar *zone_id, int32_t length)
 263 {
 264     if (calendar == NULL) {
 265         return I18N_ERROR_INVALID_PARAMETER;
 266     }
 267     i18n_error_code_e i18n_error;
 268     UErrorCode icu_error = U_ZERO_ERROR;
 269     ucal_setTimeZone(calendar, zone_id, length, &icu_error);
 270     ERR("ErrorCode : %d", icu_error);
 271     ERR_MAPPING(icu_error, i18n_error);
 272     return i18n_error;
 273 }
 274
 275 int32_t i18n_ucalendar_get_timezone_id (const  i18n_ucalendar_h calendar, i18n_uchar *result, int32_t result_length)
 276 {
 277     if (calendar == NULL || result == NULL) {
 278         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 279         return 0;
 280     }
 281     i18n_error_code_e i18n_error;
 282     UErrorCode icu_error = U_ZERO_ERROR;
 283     int32_t result_ucal_getTimeZoneID = ucal_getTimeZoneID(calendar, result, result_length, &icu_error);
 284     ERR("ErrorCode : %d", icu_error);
 285     ERR_MAPPING(icu_error, i18n_error);
 286     set_last_result(i18n_error);
 287     return result_ucal_getTimeZoneID;
 288 }
 289
 290 int i18n_ucalendar_set_gregorian_change ( i18n_ucalendar_h calendar, i18n_udate date)
 291 {
 292     if (calendar == NULL) {
 293         return I18N_ERROR_INVALID_PARAMETER;
 294     }
 295     i18n_error_code_e i18n_error;
 296     UErrorCode icu_error = U_ZERO_ERROR;
 297     ucal_setGregorianChange(calendar, date, &icu_error);
 298     ERR("ErrorCode : %d", icu_error);
 299     ERR_MAPPING(icu_error, i18n_error);
 300     return i18n_error;
 301
 302 }
 303
 304 int i18n_ucalendar_get_gregorian_change ( const  i18n_ucalendar_h calendar, i18n_udate *date)
 305 {
 306     if (calendar == NULL || date == NULL) {
 307         return I18N_ERROR_INVALID_PARAMETER;
 308     }
 309     i18n_error_code_e i18n_error;
 310     UErrorCode icu_error = U_ZERO_ERROR;
 311     *date = ucal_getGregorianChange(calendar, &icu_error);
 312     ERR("ErrorCode : %d", icu_error);
 313     ERR_MAPPING(icu_error, i18n_error);
 314     return i18n_error;
 315 }
 316
 317 const char * i18n_ucalendar_get_available ( int32_t locale_index )
 318 {
 319     if (locale_index < 0) {
 320         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 321         return NULL;
 322     }
 323
 324     set_last_result(I18N_ERROR_NONE);
 325     return ucal_getAvailable(locale_index);
 326 }
 327
 328 int32_t i18n_ucalendar_count_available ( void )
 329 {
 330     set_last_result(I18N_ERROR_NONE);
 331     return ucal_countAvailable();
 332 }
 333
 334 int i18n_ucalendar_set_date ( i18n_ucalendar_h calendar, int32_t year, int32_t month, int32_t date)
 335 {
 336     if (calendar == NULL) {
 337         return I18N_ERROR_INVALID_PARAMETER;
 338     }
 339     i18n_error_code_e i18n_error;
 340     UErrorCode icu_error = U_ZERO_ERROR;
 341     ucal_setDate(calendar, year, month, date, &icu_error);
 342     ERR("ErrorCode : %d", icu_error);
 343     ERR_MAPPING(icu_error, i18n_error);
 344     return i18n_error;
 345 }
 346
 347 int i18n_ucalendar_roll ( i18n_ucalendar_h calendar, i18n_ucalendar_date_fields_e field, int32_t amount)
 348 {
 349     if (calendar == NULL) {
 350         return I18N_ERROR_INVALID_PARAMETER;
 351     }
 352     i18n_error_code_e i18n_error;
 353     UErrorCode icu_error = U_ZERO_ERROR;
 354     ucal_roll(calendar, field, amount, &icu_error);
 355     ERR("ErrorCode : %d", icu_error);
 356     ERR_MAPPING(icu_error, i18n_error);
 357     return i18n_error;
 358 }
 359
 360 i18n_ubool i18n_ucalendar_is_set ( const i18n_ucalendar_h calendar, i18n_ucalendar_date_fields_e field )
 361 {
 362     if (calendar == NULL) {
 363         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 364         return false;
 365     }
 366
 367     set_last_result(I18N_ERROR_NONE);
 368     return ucal_isSet (calendar, field);
 369 }
 370 int i18n_ucalendar_clear_field ( i18n_ucalendar_h calendar, i18n_ucalendar_date_fields_e field )
 371 {
 372     if (calendar == NULL) {
 373         return I18N_ERROR_INVALID_PARAMETER;
 374     }
 375     ucal_clearField (calendar, field);
 376     return I18N_ERROR_NONE;
 377 }
 378
 379 int i18n_ucalendar_clear ( i18n_ucalendar_h calendar )
 380 {
 381     if (calendar == NULL) {
 382         return I18N_ERROR_INVALID_PARAMETER;
 383     }
 384     ucal_clear(calendar);
 385     return I18N_ERROR_NONE;
 386 }
 387
 388 int32_t i18n_ucalendar_get_limit ( const i18n_ucalendar_h calendar, i18n_ucalendar_date_fields_e field, i18n_ucalendar_limit_type_e type)
 389 {
 390     if (calendar == NULL) {
 391         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 392         return 0;
 393     }
 394
 395     int32_t result_ucal_getLimit = 0;
 396     switch (field) {
 397         case I18N_UCALENDAR_YEAR_WOY:
 398         case I18N_UCALENDAR_DOW_LOCAL:
 399         case I18N_UCALENDAR_EXTENDED_YEAR:
 400         case I18N_UCALENDAR_JULIAN_DAY:
 401         case I18N_UCALENDAR_MILLISECONDS_IN_DAY:
 402         case I18N_UCALENDAR_IS_LEAP_MONTH:
 403         case I18N_UCALENDAR_FIELD_COUNT:
 404             {
 405                 set_last_result(I18N_ERROR_INVALID_PARAMETER);
 406                 ERR("Unsupported filed");
 407                 break;
 408             }
 409         default:
 410             {
 411                 i18n_error_code_e i18n_error = I18N_ERROR_NONE;
 412                 UErrorCode icu_error = U_ZERO_ERROR;
 413                 int32_t limit = ucal_getLimit(calendar, field, type, &icu_error);
 414                 ERR("ErrorCode : %d", icu_error);
 415                 ERR_MAPPING(icu_error, i18n_error);
 416                 set_last_result(i18n_error);
 417                 if(i18n_error == I18N_ERROR_NONE)
 418                     result_ucal_getLimit = limit;
 419             }
 420     }
 421
 422     return result_ucal_getLimit;
 423 }
 424
 425 const char *i18n_ucalendar_get_locale_by_type ( const i18n_ucalendar_h calendar, i18n_ulocale_data_locale_type_e type )
 426 {
 427     if (calendar == NULL) {
 428         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 429         return 0;
 430     }
 431     i18n_error_code_e i18n_error;
 432     UErrorCode icu_error = U_ZERO_ERROR;
 433     const char *result_ucal_getLocaleByType = ucal_getLocaleByType(calendar, type, &icu_error);
 434     ERR("ErrorCode : %d", icu_error);
 435     ERR_MAPPING(icu_error, i18n_error);
 436     set_last_result(i18n_error);
 437     return result_ucal_getLocaleByType;
 438 }
 439
 440 const char *i18n_ucalendar_get_tz_data_version (void)
 441 {
 442     i18n_error_code_e i18n_error;
 443     UErrorCode icu_error = U_ZERO_ERROR;
 444     const char *result_ucal_getTZDataVersion = ucal_getTZDataVersion(&icu_error);
 445     ERR("ErrorCode : %d", icu_error);
 446     ERR_MAPPING(icu_error, i18n_error);
 447     set_last_result(i18n_error);
 448     return result_ucal_getTZDataVersion;
 449 }
 450
 451 int32_t i18n_ucalendar_get_canonical_timezone_id ( const i18n_uchar *id, int32_t length, i18n_uchar *result, int32_t result_capacity,  i18n_ubool *is_system_id )
 452 {
 453     if (id == NULL) {
 454         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 455         return 0;
 456     }
 457     i18n_error_code_e i18n_error;
 458     UErrorCode icu_error = U_ZERO_ERROR;
 459     int32_t result_ucal_getCanonicalTimeZoneID = ucal_getCanonicalTimeZoneID(id, length, result, result_capacity, is_system_id, &icu_error);
 460     ERR("ErrorCode : %d", icu_error);
 461     ERR_MAPPING(icu_error, i18n_error);
 462     set_last_result(i18n_error);
 463     return result_ucal_getCanonicalTimeZoneID ;
 464 }
 465
 466 const char *i18n_ucalendar_get_type ( const i18n_ucalendar_h calendar )
 467 {
 468     if (calendar == NULL) {
 469         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 470         return 0;
 471     }
 472     i18n_error_code_e i18n_error;
 473     UErrorCode icu_error = U_ZERO_ERROR;
 474     const char *result_ucal_getType = ucal_getType(calendar, &icu_error);
 475     ERR("ErrorCode : %d", icu_error);
 476     ERR_MAPPING(icu_error, i18n_error);
 477     set_last_result(i18n_error);
 478     return result_ucal_getType;
 479 }
 480
 481 int i18n_ucalendar_get_keyword_values_for_locale ( const char *key, const char *locale,  i18n_ubool commonly_used, i18n_uenumeration_h * enumeration )
 482 {
 483     if (key == NULL || enumeration == NULL) {
 484         return I18N_ERROR_INVALID_PARAMETER;
 485     }
 486     i18n_error_code_e i18n_error;
 487     UErrorCode icu_error = U_ZERO_ERROR;
 488     *enumeration = (i18n_uenumeration_h )ucal_getKeywordValuesForLocale(key, locale, commonly_used, &icu_error);
 489     ERR("ErrorCode : %d", icu_error);
 490     ERR_MAPPING(icu_error, i18n_error);
 491     return i18n_error;
 492 }
 493
 494 int i18n_ucalendar_get_day_of_week_type ( const i18n_ucalendar_h calendar, i18n_ucalendar_days_of_week_e day_of_week, i18n_ucalendar_weekday_type_e *weekday_type )
 495 {
 496     if (calendar == NULL || weekday_type == NULL) {
 497         return I18N_ERROR_INVALID_PARAMETER;
 498     }
 499     i18n_error_code_e i18n_error;
 500     UErrorCode icu_error = U_ZERO_ERROR;
 501     *weekday_type = ucal_getDayOfWeekType(calendar, day_of_week, &icu_error);
 502     ERR("ErrorCode : %d", icu_error);
 503     ERR_MAPPING(icu_error, i18n_error);
 504     return i18n_error;
 505 }
 506
 507 int32_t i18n_ucalendar_get_weekend_transition ( const i18n_ucalendar_h calendar, i18n_ucalendar_days_of_week_e day_of_week )
 508 {
 509     if (calendar == NULL) {
 510         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 511         return 0;
 512     }
 513     i18n_error_code_e i18n_error;
 514     UErrorCode icu_error = U_ZERO_ERROR;
 515     int32_t result_ucal_getWeekendTransition = ucal_getWeekendTransition(calendar, day_of_week, &icu_error);
 516     ERR("ErrorCode : %d", icu_error);
 517     ERR_MAPPING(icu_error, i18n_error);
 518     set_last_result(i18n_error);
 519     return result_ucal_getWeekendTransition;
 520 }
 521
 522 i18n_ubool i18n_ucalendar_is_weekend ( i18n_ucalendar_h calendar, i18n_udate date )
 523 {
 524     if (calendar == NULL) {
 525         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 526         return 0;
 527     }
 528     i18n_error_code_e i18n_error;
 529     UErrorCode icu_error = U_ZERO_ERROR;
 530     i18n_ubool result_ucal_isWeekend = ucal_isWeekend(calendar, date, &icu_error);
 531     ERR("ErrorCode : %d", icu_error);
 532     ERR_MAPPING(icu_error, i18n_error);
 533     set_last_result(i18n_error);
 534     return result_ucal_isWeekend;
 535 }
 536
 537 i18n_ubool i18n_ucalendar_get_timezone_transition_date ( const i18n_ucalendar_h calendar, i18n_utimezone_transition_type_e type, i18n_udate *transition)
 538 {
 539     if (calendar == NULL || transition == NULL) {
 540         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 541         return 0;
 542     }
 543     i18n_error_code_e i18n_error;
 544     UErrorCode icu_error = U_ZERO_ERROR;
 545     i18n_ubool result_ucal_getTimeZoneTransitionDate = ucal_getTimeZoneTransitionDate(calendar, type, transition, &icu_error);
 546     ERR("ErrorCode : %d", icu_error);
 547     ERR_MAPPING(icu_error, i18n_error);
 548     set_last_result(i18n_error);
 549     return result_ucal_getTimeZoneTransitionDate;
 550 }