Modified an api call flow
[platform/framework/native/appfw.git] / src / locales / FLcl_CalendarImpl.cpp
1 //
2 // Open Service Platform
3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
4 //
5 // Licensed under the Apache License, Version 2.0 (the License);
6 // you may not use this file except in compliance with the License.
7 // You may obtain a copy of the License at
8 //
9 // http://www.apache.org/licenses/LICENSE-2.0
10 //
11 // Unless required by applicable law or agreed to in writing, software
12 // distributed under the License is distributed on an "AS IS" BASIS,
13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 // See the License for the specific language governing permissions and
15 // limitations under the License.
16 //
17
18 /**
19  * @file     FLcl_CalendarImpl.cpp
20  * @brief    This is the implementation file for _CalendarImpl class.
21  */
22
23 #include <new>
24 #include <unique_ptr.h>
25
26 #include <FBaseDateTime.h>
27 #include <FBaseSysLog.h>
28 #include <FApp_AppInfo.h>
29 #include <FLclGregorianCalendar.h>
30
31 #include "FLcl_CalendarImpl.h"
32 #include "FLcl_IcuCalendarImpl.h"
33 #include "FLcl_LocaleData.h"
34 #include "FLcl_LocaleImpl.h"
35 #include "FLcl_LocaleManagerImpl.h"
36
37 using namespace Tizen::Base;
38
39 namespace Tizen { namespace Locales
40 {
41
42 static const int ONE_MINUTE_IN_MILLISEC = 60000;
43
44 _CalendarImpl::_CalendarImpl()
45         : __type(CALENDAR_GREGORIAN)
46         , __locale(LANGUAGE_INVALID, COUNTRY_INVALID)
47         , __timezone()
48         , __pCalendar(null)
49 {
50 }
51
52 _CalendarImpl::~_CalendarImpl()
53 {
54         delete __pCalendar;
55         __pCalendar = null;
56 }
57
58
59 Calendar*
60 _CalendarImpl::CreateCalendarInstanceN(CalendarType calendarType)
61 {
62         return CreateInstanceN(TimeZone::GetGmtTimeZone(), calendarType);
63 }
64
65 Calendar*
66 _CalendarImpl::CreateCalendarInstanceN(const TimeZone& timeZone, CalendarType calendarType)
67 {
68         return CreateInstanceN(timeZone, _LocaleManagerImpl::GetSystemLocale(), calendarType);
69 }
70
71 Calendar*
72 _CalendarImpl::CreateCalendarInstanceN(const Locale& locale, CalendarType calendarType)
73 {
74         // Create calendar using system time zone and given locale and calendar type
75         return CreateInstanceN(TimeZone::GetGmtTimeZone(), locale, calendarType);
76 }
77
78 Calendar*
79 _CalendarImpl::CreateCalendarInstanceN(const TimeZone& timeZone, const Locale& locale, CalendarType calendarType)
80 {
81         ClearLastResult();
82         result r = E_SYSTEM;
83         switch (calendarType)
84         {
85         case CALENDAR_GREGORIAN:
86         {
87                 std::unique_ptr< GregorianCalendar > pGregCalendar(new (std::nothrow) GregorianCalendar);
88                 SysTryReturn(NID_LCL, pGregCalendar != null, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed", GetErrorMessage(E_OUT_OF_MEMORY));
89
90                 r = pGregCalendar->Construct(timeZone, locale);
91                 SysTryReturn(NID_LCL, !IsFailed(r), null, r, "[%s] Unable to construct calendar", GetErrorMessage(r));
92
93                 return pGregCalendar.release();
94         }
95
96         default:
97                 break;
98         }
99
100         std::unique_ptr< _CalendarImpl > pCalendar(new (std::nothrow) _CalendarImpl);
101         SysTryReturn(NID_LCL, pCalendar != null, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed", GetErrorMessage(E_OUT_OF_MEMORY));
102
103         r = pCalendar->Construct(timeZone, locale, calendarType);
104         SetLastResult(r);
105         SysTryReturn(NID_LCL, !IsFailed(r), null, r, "[%s] Unable to construct calendar", GetErrorMessage(r));
106         return pCalendar.release();
107 }
108
109 Calendar*
110 _CalendarImpl::CloneN(void) const
111 {
112         std::unique_ptr< _CalendarImpl > pCalendar(new (std::nothrow) _CalendarImpl());
113         SysTryReturn(NID_LCL, pCalendar != null, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed", GetErrorMessage(E_OUT_OF_MEMORY));
114
115         if (__pCalendar != null)
116         {
117                 pCalendar->__pCalendar = __pCalendar->CloneN();
118                 if (pCalendar->__pCalendar != null)
119                 {
120                         pCalendar->__type = __type;
121                         pCalendar->__locale = __locale;
122                         pCalendar->__timezone = __timezone;
123
124                         pCalendar->_pCalendarImpl = pCalendar.get();
125                 }
126         }
127
128         return pCalendar.release();
129 }
130
131 result
132 _CalendarImpl::Construct(CalendarType calendarType)
133 {
134         Locale defaultLocale = _LocaleManagerImpl::GetSystemLocale();
135         return Construct( TimeZone::GetGmtTimeZone(), defaultLocale, calendarType);
136 }
137
138 result
139 _CalendarImpl::Construct(const TimeZone& timezone, CalendarType calendarType)
140 {
141         Locale defaultLocale = _LocaleManagerImpl::GetSystemLocale();
142         return Construct(timezone, defaultLocale, calendarType);
143 }
144
145 result
146 _CalendarImpl::Construct(const Locale& locale, CalendarType calendarType)
147 {
148         TimeZone defaultTimeZone = TimeZone::GetGmtTimeZone();
149         return Construct(defaultTimeZone, locale, calendarType);
150 }
151
152 result
153 _CalendarImpl::Construct(const TimeZone& timeZone, const Locale& locale, CalendarType calendarType)
154 {
155         // Object is not allowed to construct twice
156         SysAssertf(__pCalendar == null,
157                            "Already constructed! Calling Construct() twice or more on a same instance is not allowed for this class");
158
159         SysTryReturnResult(NID_LCL, _LocaleImpl::IsSupported(locale), E_INVALID_ARG, "Given locale is not supported");
160
161         std::unique_ptr< _IcuCalendarImpl > pCalendar(new (std::nothrow) _IcuCalendarImpl);
162         SysTryReturnResult(NID_LCL, pCalendar != null, E_OUT_OF_MEMORY, "Memory allocation failed");
163
164         result r = pCalendar->Construct(timeZone, locale, calendarType);
165         if (!IsFailed(r))
166         {
167                 __pCalendar = pCalendar.release();
168                 __type = calendarType;
169                 __locale = locale;
170                 __timezone = timeZone;
171
172                 _pCalendarImpl = this;
173                 return E_SUCCESS;
174         }
175
176         return E_SYSTEM;
177 }
178
179 result
180 _CalendarImpl::Construct(const Calendar& otherCalendar)
181 {
182         // Object is not allowed to construct twice
183         SysAssertf(__pCalendar == null,
184                            "Already constructed! Calling Construct() twice or more on a same instance is not allowed for this class");
185
186         result r = E_SYSTEM;
187         const _CalendarImpl* pOtherCalendar = dynamic_cast< const _CalendarImpl* >(&otherCalendar);
188         if ((pOtherCalendar != null) && (pOtherCalendar->__pCalendar != null))
189         {
190                 delete __pCalendar;
191
192                 __pCalendar = pOtherCalendar->__pCalendar->CloneN();
193                 if (__pCalendar != null)
194                 {
195                         __type = pOtherCalendar->__type;
196                         __locale = pOtherCalendar->__locale;
197                         __timezone = pOtherCalendar->__timezone;
198
199                         _pCalendarImpl = pOtherCalendar->_pCalendarImpl;
200                         return E_SUCCESS;
201                 }
202                 r = GetLastResult();
203         }
204         return r;
205 }
206
207 result
208 _CalendarImpl::SetTimeFieldImpl(TimeField field, int value)
209 {
210         SysAssertf(__pCalendar != null, "Not yet constructed! Construct() should be called before use.");
211         SysTryReturnResult(NID_LCL, ValidateTimeField(field),
212                         E_INVALID_ARG, "Invalid argument is used. Timefield is less than 0 or grater than time field count.");
213         SysTryReturnResult(NID_LCL, ValidateTimeFieldValue(field, value), E_OUT_OF_RANGE, "value(%d) is out of range.", value);
214
215         return __pCalendar->SetTimeField(field, value);
216 }
217
218 result
219 _CalendarImpl::SetTimeInMillisecImpl(long long millisec)
220 {
221         SysAssertf(__pCalendar != null, "Not yet constructed! Construct() should be called before use.");
222         return __pCalendar->SetTimeInMillisec(millisec - __timezone.GetRawOffset() * ONE_MINUTE_IN_MILLISEC);
223 }
224
225 result
226 _CalendarImpl::SetTimeImpl(const DateTime& dateTime)
227 {
228         return SetTimeImpl(dateTime.GetYear(), dateTime.GetMonth(), dateTime.GetDay(),
229                          dateTime.GetHour(), dateTime.GetMinute(), dateTime.GetSecond(), dateTime.GetMillisecond());
230 }
231
232 result
233 _CalendarImpl::SetTimeImpl(int year, int month, int day, int hour, int minute, int second, int millisecond)
234 {
235         SysAssertf(__pCalendar != null, "Not yet constructed! Construct() should be called before use.");
236         return __pCalendar->SetTime(year, month, day, hour, minute, second, millisecond);
237 }
238
239 result
240 _CalendarImpl::SetFirstDayOfWeekImpl(DayOfWeek dayOfWeek)
241 {
242         SysAssertf(__pCalendar != null, "Not yet constructed! Construct() should be called before use.");
243         SysTryReturnResult(NID_LCL, ValidateDaysOfWeek(dayOfWeek), E_INVALID_ARG, "Invalid argument is used. Unknown day of week");
244
245         return __pCalendar->SetFirstDayOfWeek(dayOfWeek);
246 }
247
248 result
249 _CalendarImpl::SetLenientImpl(bool lenient)
250 {
251         SysAssertf(__pCalendar != null, "Not yet constructed! Construct() should be called before use.");
252         return __pCalendar->SetLenient(lenient);
253 }
254
255 result
256 _CalendarImpl::SetMinDaysInFirstWeekImpl(short value)
257 {
258         SysAssertf(__pCalendar != null, "Not yet constructed! Construct() should be called before use.");
259         return __pCalendar->SetMinDaysInFirstWeek(value);
260 }
261
262 result
263 _CalendarImpl::SetTimeZoneImpl(const TimeZone& timeZone)
264 {
265         SysAssertf(__pCalendar != null, "Not yet constructed! Construct() should be called before use.");
266
267         _timeZone = timeZone;
268         __timezone = timeZone;
269         return __pCalendar->SetTimeZone(__timezone);
270 }
271
272 result
273 _CalendarImpl::ClearImpl(void)
274 {
275         SysAssertf(__pCalendar != null, "Not yet constructed! Construct() should be called before use.");
276         return __pCalendar->Clear();
277 }
278
279 result
280 _CalendarImpl::ClearImpl(TimeField field)
281 {
282         SysAssertf(__pCalendar != null, "Not yet constructed! Construct() should be called before use.");
283         SysTryReturnResult(NID_LCL, ValidateTimeField(field), E_INVALID_ARG,
284                                 "Invalid argument is used. Timefield is less than 0 or grater than time field count.");
285
286         return __pCalendar->Clear(field);
287 }
288
289 result
290 _CalendarImpl::AddTimeField(TimeField field, int amount)
291 {
292         SysAssertf(__pCalendar != null, "Not yet constructed! Construct() should be called before use.");
293
294         result r = E_INVALID_ARG;
295
296         if (Tizen::App::_AppInfo::GetApiVersion() == _API_VERSION_2_0 && Tizen::App::_AppInfo::IsOspCompat())
297         {
298                 r = E_INVALID_STATE;
299         }
300
301         SysTryReturnResult(NID_LCL, ValidateTimeField(field), r,
302                                 "Invalid argument is used. Timefield is less than 0 or grater than time field count.");
303
304         return __pCalendar->AddTimeField(field, amount);
305 }
306
307 result
308 _CalendarImpl::RollImpl(TimeField field, int amount)
309 {
310         SysAssertf(__pCalendar != null, "Not yet constructed! Construct() should be called before use.");
311         result r = E_INVALID_ARG;
312         if (Tizen::App::_AppInfo::GetApiVersion() == _API_VERSION_2_0 && Tizen::App::_AppInfo::IsOspCompat())
313         {
314                 r = E_INVALID_STATE;
315         }
316
317         SysTryReturnResult(NID_LCL, ValidateTimeField(field), r,
318                                 "Invalid argument is used. Timefield is less than 0 or grater than time field count.");
319
320         return __pCalendar->Roll(field, amount);
321 }
322
323 result
324 _CalendarImpl::After(const _CalendarImpl& otherInstance, bool& after)
325 {
326         SysAssertf(__pCalendar != null, "Not yet constructed! Construct() should be called before use.");
327
328         result r = E_INVALID_ARG;
329         if (Tizen::App::_AppInfo::GetApiVersion() == _API_VERSION_2_0 && Tizen::App::_AppInfo::IsOspCompat())
330         {
331                 r = E_INVALID_STATE;
332         }
333
334         SysTryReturnResult(NID_LCL, otherInstance.__pCalendar, r, "Invalid argument is used. otherCalendar instance is invalid");
335
336         return __pCalendar->After(*(otherInstance.__pCalendar), after);
337 }
338
339 result
340 _CalendarImpl::Before(const _CalendarImpl& otherInstance, bool& before)
341 {
342         SysAssertf(__pCalendar != null, "Not yet constructed! Construct() should be called before use.");
343
344         result r = E_INVALID_ARG;
345         if (Tizen::App::_AppInfo::GetApiVersion() == _API_VERSION_2_0 && Tizen::App::_AppInfo::IsOspCompat())
346         {
347                 r = E_INVALID_STATE;
348         }
349
350         SysTryReturnResult(NID_LCL, otherInstance.__pCalendar, r, "Invalid argument is used. otherCalendar instance is invalid");
351
352         return __pCalendar->Before(*(otherInstance.__pCalendar), before);
353 }
354
355 bool
356 _CalendarImpl::Equals(const _CalendarImpl& otherInstance) const
357 {
358         if ((__pCalendar != null) && (otherInstance.__pCalendar != null))
359         {
360                 return __pCalendar->Equals(*(otherInstance.__pCalendar));
361         }
362         return (__pCalendar == otherInstance.__pCalendar);
363 }
364
365 int
366 _CalendarImpl::GetHashCode(void) const
367 {
368         Integer intValues = IsLenient() + GetFirstDayOfWeek() + GetMinDaysInFirstWeek();
369         int hashCode = intValues.GetHashCode();
370
371         long long myTicks = 0;
372         GetTimeInMillisec(myTicks);
373         hashCode = (hashCode << 5) - hashCode + LongLong(myTicks).GetHashCode()+__timezone.GetHashCode();
374
375         return hashCode;
376 }
377
378 CalendarType
379 _CalendarImpl::GetType(void) const
380 {
381         return __type;
382 }
383
384 int
385 _CalendarImpl::GetTimeFieldImpl(TimeField field) const
386 {
387         SysAssertf(__pCalendar != null, "Not yet constructed! Construct() should be called before use.");
388         SysTryReturn(NID_LCL, ValidateTimeField(field), -1, E_INVALID_ARG,
389                                 "[%s] Invalid argument is used. Timefield is less than 0 or grater than time field count.", GetErrorMessage(E_INVALID_ARG));
390
391         return __pCalendar->GetTimeField(field);
392 }
393
394 result
395 _CalendarImpl::GetTimeInMillisecImpl(long long& millisec) const
396 {
397         SysAssertf(__pCalendar != null, "Not yet constructed! Construct() should be called before use.");
398         result r;
399         long long tempMillisec;
400
401         r =  __pCalendar->GetTimeInMillisec(tempMillisec);
402         SysTryReturnResult(NID_LCL, r == E_SUCCESS, r, "Unable to get time in milli sec");
403         millisec = tempMillisec + __timezone.GetRawOffset() * ONE_MINUTE_IN_MILLISEC;
404         return r;
405 }
406
407 DateTime
408 _CalendarImpl::GetTimeImpl(void) const
409 {
410         int year = __pCalendar->GetTimeField(TIME_FIELD_YEAR);
411         int month = __pCalendar->GetTimeField(TIME_FIELD_MONTH);
412         int date = __pCalendar->GetTimeField(TIME_FIELD_DAY_OF_MONTH);
413
414         int hour = __pCalendar->GetTimeField(TIME_FIELD_HOUR_OF_DAY);
415         int minute = __pCalendar->GetTimeField(TIME_FIELD_MINUTE);
416         int second = __pCalendar->GetTimeField(TIME_FIELD_SECOND);
417         int millisecond = __pCalendar->GetTimeField(TIME_FIELD_MILLISECOND);
418
419         DateTime dateTime;
420         result r = dateTime.SetValue(year, month, date, hour, minute, second, millisecond);
421         SysTryReturn(NID_LCL, r == E_SUCCESS, DateTime(), r, "[%s] Unable to set time in DateTime object", GetErrorMessage(r));
422
423         return dateTime;
424 }
425
426 int
427 _CalendarImpl::GetMinTimeField(TimeField field) const
428 {
429         SysAssertf(__pCalendar != null, "Not yet constructed! Construct() should be called before use.");
430         SysTryReturn(NID_LCL, ValidateTimeField(field), -1, E_INVALID_ARG,
431                                 "[%s] Invalid argument is used. Timefield is less than 0 or grater than time field count.", GetErrorMessage(E_INVALID_ARG));
432
433         return __pCalendar->GetMinTimeField(field);
434 }
435
436 int
437 _CalendarImpl::GetActualMinTimeFieldImpl(TimeField field) const
438 {
439         SysAssertf(__pCalendar != null, "Not yet constructed! Construct() should be called before use.");
440         SysTryReturn(NID_LCL, ValidateTimeField(field), -1, E_INVALID_ARG,
441                                 "[%s] Invalid argument is used. Timefield is less than 0 or grater than time field count.", GetErrorMessage(E_INVALID_ARG));
442
443         return __pCalendar->GetActualMinTimeField(field);
444 }
445
446 int
447 _CalendarImpl::GetGreatestMinTimeField(TimeField field) const
448 {
449         SysAssertf(__pCalendar != null, "Not yet constructed! Construct() should be called before use.");
450         SysTryReturn(NID_LCL, ValidateTimeField(field), -1, E_INVALID_ARG,
451                                 "[%s] Invalid argument is used. Timefield is less than 0 or grater than time field count.", GetErrorMessage(E_INVALID_ARG));
452
453         return __pCalendar->GetGreatestMinTimeField(field);
454 }
455
456 int
457 _CalendarImpl::GetLeastMaxTimeField(TimeField field) const
458 {
459         SysAssertf(__pCalendar != null, "Not yet constructed! Construct() should be called before use.");
460         SysTryReturn(NID_LCL, ValidateTimeField(field), -1, E_INVALID_ARG,
461                                 "[%s] Invalid argument is used. Timefield is less than 0 or grater than time field count.", GetErrorMessage(E_INVALID_ARG));
462
463         return __pCalendar->GetLeastMaxTimeField(field);
464 }
465
466 int
467 _CalendarImpl::GetActualMaxTimeFieldImpl(TimeField field) const
468 {
469         SysAssertf(__pCalendar != null, "Not yet constructed! Construct() should be called before use.");
470         SysTryReturn(NID_LCL, ValidateTimeField(field), -1, E_INVALID_ARG,
471                                 "[%s] Invalid argument is used. Timefield is less than 0 or grater than time field count.", GetErrorMessage(E_INVALID_ARG));
472
473         return __pCalendar->GetActualMaxTimeField(field);
474 }
475
476 int
477 _CalendarImpl::GetMaxTimeField(TimeField field) const
478 {
479         SysAssertf(__pCalendar != null, "Not yet constructed! Construct() should be called before use.");
480         SysTryReturn(NID_LCL, ValidateTimeField(field), -1, E_INVALID_ARG,
481                                 "[%s] Invalid argument is used. Timefield is less than 0 or grater than time field count.", GetErrorMessage(E_INVALID_ARG));
482
483         return __pCalendar->GetMaxTimeField(field);
484 }
485
486 int
487 _CalendarImpl::GetFirstDayOfWeekImpl(void) const
488 {
489         SysAssertf(__pCalendar != null, "Not yet constructed! Construct() should be called before use.");
490         return __pCalendar->GetFirstDayOfWeek();
491 }
492
493 int
494 _CalendarImpl::GetMinDaysInFirstWeekImpl(void) const
495 {
496         SysAssertf(__pCalendar != null, "Not yet constructed! Construct() should be called before use.");
497         return __pCalendar->GetMinDaysInFirstWeek();
498 }
499
500 result
501 _CalendarImpl::IsInDst(bool& isInDst) const
502 {
503         SysAssertf(__pCalendar != null, "Not yet constructed! Construct() should be called before use.");
504         return __pCalendar->IsInDst(isInDst);
505 }
506
507 bool
508 _CalendarImpl::IsLenientImpl(void) const
509 {
510         SysAssertf(__pCalendar != null, "Not yet constructed! Construct() should be called before use.");
511         return __pCalendar->IsLenient();
512 }
513
514 bool
515 _CalendarImpl::IsSetImpl(TimeField field) const
516 {
517         SysAssertf(__pCalendar != null, "Not yet constructed! Construct() should be called before use.");
518         return __pCalendar->IsSet(field);
519 }
520
521 TimeZone
522 _CalendarImpl::GetTimeZoneImpl(void) const
523 {
524         return __timezone;
525 }
526
527 bool
528 _CalendarImpl::IsLeapYear(int year) const
529 {
530         SysAssertf(__pCalendar != null, "Not yet constructed! Construct() should be called before use.");
531         return __pCalendar->IsLeapYear(year);
532 }
533
534 result
535 _CalendarImpl::SetGregorianChange(long long change)
536 {
537         SysAssertf(__pCalendar != null, "Not yet constructed! Construct() should be called before use.");
538         return __pCalendar->SetGregorianChange(change);
539 }
540
541 long long
542 _CalendarImpl::GetGregorianChange(void) const
543 {
544         SysAssertf(__pCalendar != null, "Not yet constructed! Construct() should be called before use.");
545         return __pCalendar->GetGregorianChange();
546 }
547
548 result
549 _CalendarImpl::SetJulianDay(int julianDay)
550 {
551         SysAssertf(__pCalendar != null, "Not yet constructed! Construct() should be called before use.");
552         return __pCalendar->SetJulianDay(julianDay);
553 }
554
555 int
556 _CalendarImpl::GetJulianDay(void) const
557 {
558         SysAssertf(__pCalendar != null, "Not yet constructed! Construct() should be called before use.");
559         return __pCalendar->GetJulianDay();
560 }
561
562 bool
563 _CalendarImpl::ValidateTimeField(TimeField field) const
564 {
565         if (field < 0 || field >= TIME_FIELD_FIELD_COUNT)
566         {
567                 return false;
568         }
569         return true;
570 }
571
572 bool
573 _CalendarImpl::ValidateTimeFieldValue(TimeField field, int value) const
574 {
575         if (IsLenientImpl() == false)
576         {
577                 if ((value < GetMinTimeField(field)) || (value > GetMaxTimeField(field)))
578                 {
579                         return false;
580                 }
581         }
582
583         return true;
584 }
585
586 bool
587 _CalendarImpl::ValidateDaysOfWeek(DayOfWeek dayOfWeek) const
588 {
589         if (dayOfWeek < SUNDAY || dayOfWeek > SATURDAY)
590         {
591                 return false;
592         }
593         return true;
594 }
595
596 // added for backward compatibility
597 result
598 _CalendarImpl::RollWithSingleUnit(TimeField field, bool up)
599 {
600         return E_UNSUPPORTED_OPERATION;
601 }
602
603 // added for backward compatibility
604 result
605 _CalendarImpl::ComputeTimeFields(void)
606 {
607         return E_UNSUPPORTED_OPERATION;
608 }
609
610 // added for backward compatibility
611 result
612 _CalendarImpl::ComputeTime(void)
613 {
614         return E_UNSUPPORTED_OPERATION;
615 }
616
617 // added for backward compatibility
618 int
619 _CalendarImpl::GetMonthLength(int extendedYear, int month) const
620 {
621         SetLastResult(E_UNSUPPORTED_OPERATION);
622         return -1;
623 }
624
625 // added for backward compatibility
626 int
627 _CalendarImpl::HandleGetLimit(TimeField field, CalendarLimitType limitType) const
628 {
629         SetLastResult(E_UNSUPPORTED_OPERATION);
630         return -1;
631 }
632
633 const _IcuCalendarImpl*
634 _CalendarImpl::GetImpl(const Calendar& calendar)
635 {
636         if (calendar._pCalendarImpl)
637         {
638                 return calendar._pCalendarImpl->__pCalendar;
639         }
640
641         return null;
642 }
643
644 };
645 };      // Tizen::Locales