Change error condition of ToDouble()&ToFloat()
[platform/framework/native/appfw.git] / inc / FLclGregorianCalendar.h
1 //
2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
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 /**
18  * @file                FLclGregorianCalendar.h
19  * @brief               This is the header file for the %GregorianCalendar class.
20  *
21  * This header file contains the declarations of the %GregorianCalendar class.
22  */
23 #ifndef _FLCL_GREGORIAN_CALENDAR_H_
24 #define _FLCL_GREGORIAN_CALENDAR_H_
25
26 #include <FBase.h>
27
28 #include <FLclCalendar.h>
29 #include <FLclLocale.h>
30 #include <FLclTimeZone.h>
31
32 namespace Tizen { namespace Locales
33 {
34
35 /**
36  * @class               GregorianCalendar
37  * @brief               This class is a concrete subclass of calendar and provides the Gregorian calendar that is the most commonly used standard calendar.
38  *
39  * @since               2.0
40  *
41  * @final       This class is not intended for extension.
42  *
43  * The %GregorianCalendar class is a concrete subclass of calendar and provides the Gregorian calendar that is the most commonly used standard calendar.
44  *
45  * For more information on the class features, see <a href="../org.tizen.native.appprogramming/html/guide/locales/gregorian_calendar.htm">Gregorian Calendar</a>.
46  *
47  * @see Tizen::Locales::Locale
48  * @see Tizen::Locales::TimeZone
49  *
50  * The following example demonstrates how to use the %GregorianCalendar class.
51  * @code
52  #include <FBase.h>
53  #include <FLocales.h>
54
55  using namespace Tizen::Base;
56  using namespace Tizen::Locales;
57
58  void
59  MyClass::GregorianCalendarExample(void)
60  {
61         Calendar* pGregorianCalendar = Calendar::CreateInstanceN(CALENDAR_GREGORIAN);
62
63         pGregorianCalendar->SetTimeField(TIME_FIELD_YEAR, 2005);
64         pGregorianCalendar->SetTimeField(TIME_FIELD_MONTH, JANUARY);
65         pGregorianCalendar->SetTimeField(TIME_FIELD_DAY_OF_MONTH, 3);
66
67         int dayOfWeek = pGregorianCalendar->GetTimeField(TIME_FIELD_DAY_OF_WEEK);// It is Monday.
68
69         pGregorianCalendar->Clear();
70         pGregorianCalendar->SetTimeField(TIME_FIELD_YEAR, 1972);
71         pGregorianCalendar->SetTimeField(TIME_FIELD_MONTH, OCTOBER);
72         pGregorianCalendar->SetTimeField(TIME_FIELD_DAY_OF_MONTH, 26); // It is Thursday
73
74         pGregorianCalendar->AddTimeField(TIME_FIELD_DAY_OF_MONTH, 1);
75         dayOfWeek = pGregorianCalendar->GetTimeField(TIME_FIELD_DAY_OF_WEEK); // It is Friday.
76 }
77  @endcode
78  *
79  */
80
81 class _OSP_EXPORT_ GregorianCalendar
82         : public Calendar
83 {
84 public:
85         /**
86          * This is the default constructor for this class. @n
87          * The object is not fully constructed after this constructor is called. For full construction, the Construct() method must be called right after calling this constructor.
88          *
89          * @since                       2.0
90          *
91          * @see                         Construct()
92          */
93         GregorianCalendar(void);
94
95
96         /**
97          * This is the destructor for this class. @n
98          * This destructor overrides Tizen::Locales::Calendar::~Calendar().
99          *
100          * @since                       2.0
101          */
102         virtual ~GregorianCalendar(void);
103
104
105         /**
106          * Initializes this instance of %GregorianCalendar with the current GMT time zone and the system locale.
107          * The time zone is used for the zone offset and the DST offset.
108          * An instance has weekdata which are the first of week, minimal days in the first week, weekend on set and weekend cease.
109          * The weekdata are set as default values by the locale.
110          *
111          * @since                       2.0
112          *
113          * @return                      An error code
114          * @exception           E_SUCCESS                                       The method is successful.
115          * @exception           E_OUT_OF_MEMORY                         The memory is insufficient.
116          */
117         result Construct(void);
118
119
120         /**
121          * Initializes this instance of %GregorianCalendar with the specified parameter.
122          *
123          * @since                       2.0
124          *
125          * @return                      An error code
126          * @param[in]           gc                                                      An instance of %GregorianCalendar to copy
127          * @exception           E_SUCCESS                                       The method is successful.
128          * @exception           E_OUT_OF_MEMORY                         The memory is insufficient.
129          */
130         result Construct(const GregorianCalendar& gc);
131
132
133         /**
134          * Initializes this instance of %GregorianCalendar based on the current time in the specified time zone with the system locale. @n 
135          * The @c timeZone is used for the zone offset and the DST offset.
136          * An instance has weekdata which are the first of week, minimal days in the first week, weekend on set, and weekend cease.
137          * The weekdata are set as default values by the locale. 
138          *
139          * @since                       2.0
140          *
141          * @return                      An error code
142          * @param[in]           timeZone                                        An instance of TimeZone
143          * @exception           E_SUCCESS                                       The method is successful.
144          * @exception           E_OUT_OF_MEMORY                         The memory is insufficient.
145          */
146         result Construct(const TimeZone& timeZone);
147
148
149         /**
150          * Initializes this instance of %GregorianCalendar based on the current time in the GMT time zone with the specified @c locale.
151          * The time zone is used for the zone offset and the DST offset.
152          * An instance has weekdata which are the first of week, minimal days in the first week, weekend on set, and weekend cease.
153          * The weekdata are set as default values by the specified @c locale.
154          *
155          * @if OSPCOMPAT 
156          * @brief <i> [Compatibility] </i>
157          * @endif 
158          * @since                       2.0
159          * @if OSPCOMPAT
160          * @compatibility     This method has compatibility issues with OSP compatible applications. @n
161          *                              For more information, see @ref CompGregorianCalendarConstructPage "here".   
162          * @endif
163          *
164          * @return                      An error code
165          * @param[in]           locale                                          An instance of Locale
166          * @exception           E_SUCCESS                                       The method is successful.
167          * @exception           E_OUT_OF_MEMORY                         The memory is insufficient.
168          * @exception                            E_INVALID_ARG           The specified @c locale is invalid. 
169          */
170         result Construct(const Locale& locale);
171
172
173         /**
174          * Initializes this instance of %GregorianCalendar based on the current time in the specified time zone with the specified system locale. @n
175          * The @c timeZone is used for the zone offset and the DST offset.
176          * An instance has weekdata which are the first of week, minimal days in the first week, weekend on set, and weekend cease.
177          * The weekdata are set as default values by the specified @c locale.
178          *
179          * @if OSPCOMPAT
180          * @brief <i> [Compatibility] </i>
181          * @endif
182          * @since                       2.0
183          * @if OSPCOMPAT
184          * @compatibility     This method has compatibility issues with OSP compatible applications. @n
185          *                              For more information, see @ref CompGregorianCalendarConstructPage "here".   
186          * @endif
187          *
188          * @return                      An error code
189          * @param[in]           timeZone                                        An instance of TimeZone
190          * @param[in]           locale                                          An instance of Locale
191          * @exception           E_SUCCESS                                       The method is successful.
192          * @exception           E_OUT_OF_MEMORY                         The memory is insufficient.
193          * @exception                            E_INVALID_ARG           The specified @c locale is invalid. 
194          */
195         result Construct(const TimeZone& timeZone, const Locale& locale);
196
197         /**
198          * @if OSPCOMPAT
199          * @page                    CompGregorianCalendarConstructPage Compatibility for Construct()
200          * @section                   CompGregorianCalendarConstructIssueSection Issues
201          * Implementation of this method in OSP compatible applications has the following issue: @n
202          * -# The method returns E_UNSUPPORTED_OPERATION if the @c locale is invalid.
203          *
204          * @section                 CompGregorianCalendarConstructSolutionSection Resolutions
205          * This issue has been resolved in Tizen.
206          * @par When working in Tizen:
207          * -# The method returns E_INVALID_ARG if the @c locale is invalid.
208          * @endif
209         */
210
211         /**
212          * Initializes this instance of %GregorianCalendar based on the specified @c year, @c month, @c day, @c hour, @c minute, and @c second
213          * in the GMT time zone with the system locale. @n
214          * The time zone is used for the zone offset and the DST offset.
215          * An instance has weekdata which are the first of week, minimal days in the first week, weekend on set, and weekend cease.
216          * The weekdata are set as default values by the locale.
217          * The Gregorian calendar is lenient: time fields are normalized when the user calls the Calendar::GetTimeField() method.
218          *
219          * @since                       2.0
220          *
221          * @return                      An error code
222          * @param[in]           year                                            An integer value used to set the year time field
223          * @param[in]           month                                           An integer value used to set the month time field @n
224          *                                                                                              The indexing is 1-based. Therefore, 1 means January.
225          * @param[in]           day                                                     An integer value used to set the date time field
226          * @param[in]           hour                                            An integer value used to set the hour time field
227          * @param[in]           minute                                          An integer value used to set the minute time field
228          * @param[in]           second                                          An integer value used to set the second time field
229          * @exception           E_SUCCESS                                       The method is successful.
230          * @exception           E_INVALID_ARG           An argument is invalid.
231          * @exception           E_OUT_OF_MEMORY                         The memory is insufficient.
232          * @exception           E_OUT_OF_RANGE                          In this method, time fields of this instance are calculated. @n
233          *                                                If the value of the time fields goes out of range, this exception is returned.
234          */
235         result Construct(int year, int month, int day, int hour = 0, int minute = 0, int second = 0);
236
237
238         /**
239          * Initializes this instance of %GregorianCalendar based on the specified date and time in the GMT time zone with the system locale. @n
240          * The time zone is used for the zone offset and the DST offset.
241          * An instance has weekdata which are the first of week, minimal days in the first week, weekend on set, and weekend cease.
242          * The weekdata are set as default values by the locale.
243          *
244          * @since                       2.0
245          *
246          * @return                      An error code
247          * @param[in]           dateTime                                        An instance of Tizen::Base::DateTime
248          * @exception           E_SUCCESS                                       The method is successful.
249          * @exception           E_OUT_OF_MEMORY                         The memory is insufficient.
250          * @exception           E_INVALID_ARG           The specified @c dateTime is invalid.
251          * @exception           E_OUT_OF_RANGE                          In this method, time fields of this instance are calculated. @n
252          *                                                If the value of the time fields goes out of range, this exception is returned.
253          */
254         result Construct(const Tizen::Base::DateTime& dateTime);
255
256
257         /**
258          * Adds the specified amount to the specified time field, based on the calendar rules. @n
259          * It is equivalent to calling Set(field, GetTimeField(field)+amount) with two adjustments. @n
260          *
261          * @b Add @b Rule1: The value of @c field after the call minus the value of @c field before the call is delta, modulo any overflow that has occurred in @c field.
262          * Overflow occurs when the @c field value exceeds its range and, as a result, the next larger field is incremented or decremented and the @c field value is adjusted back into its range. @n
263          *
264          * @b Add @b Rule2: If a smaller field is expected to be invariant, but it is impossible for it to be equal to its prior value because of
265          * changes in its minimum or maximum value after the @c field value is changed, then its value is adjusted to the closest possible value. @n
266          *
267          * A smaller field represents a smaller unit of time. The TIME_FIELD_HOUR field is smaller than the TIME_FIELD_DAY_OF_MONTH field.
268          * No adjustment is made to smaller fields that are not expected to be invariant.
269          * The calendar system determines what fields are expected to be invariant. @n
270          *
271          * In addition, this method forces re-computation of the calendar's milliseconds and all time fields immediately.
272          * @n
273          * For example, consider a %GregorianCalendar set to Oct. 31. 2004. Calling AddTimeField(TIME_FIELD_MONTH, 13) sets the calendar to Nov. 30. 2005.
274          * The TIME_FIELD_MONTH field is set to TIME_FIELD_NOVEMBER by @b Rule1, since adding 13 months to October gives November of the next year. Since
275          * the TIME_FIELD_DAY_OF_MONTH cannot be 31 in November in a %GregorianCalendar, TIME_FIELD_DAY_OF_MONTH is set to 30 by @b Rule2.
276          *
277          * @since                       2.0
278          *
279          * @return                      An error code
280          * @param[in]           field                                           The time field
281          * @param[in]           amount                                          The amount to add
282          * @exception           E_SUCCESS                                       The method is successful.
283          * @exception           E_INVALID_ARG                           The specified @c field is invalid.
284          * @exception           E_OUT_OF_RANGE          In this method, time fields of this instance are calculated. @n
285          *                                                                              If the value of the time fields goes out of range, this exception is returned. 
286          * @remarks                     The TIME_FIELD_EXTENDED_YEAR and TIME_FIELD_YEAR_WOY fields cannot be added.
287          */
288         virtual result AddTimeField(TimeField field, int amount);
289
290
291         /**
292          * Gets the actual minimum value that the specified time field can have, given the current date. @n
293          * For the Gregorian calendar, this is the same as Calendar::GetMinTimeField() and Calendar::GetGreatestMinTimeField().
294          *
295          * @since                       2.0
296          *
297          * @return                      An integer value indicating the actual minimum value
298          * @param[in]                           field           The time field
299          * @exception                           E_SUCCESS                       The method is successful.
300          * @exception                           E_INVALID_ARG                   The specified time field is invalid.
301          * @remarks                                     The specific error code can be accessed using the GetLastResult() method.
302          */
303         virtual int GetActualMinTimeField(TimeField field) const;
304
305
306         /**
307          * Gets the actual maximum value that the specified time field can have, given the current date. @n
308          * For example, if the current date is "Feb. 3. 2004", then the maximum value of the DATE field is 29.
309          *
310          * @since                       2.0
311          *
312          * @return                      An integer value indicating the actual maximum value
313          * @param[in]                           field           The time field
314          * @exception                           E_SUCCESS                       The method is successful.
315          * @exception                           E_INVALID_ARG                   The specified time field is invalid.
316
317          * @remarks                                     The specific error code can be accessed using the GetLastResult() method.
318          */
319         virtual int GetActualMaxTimeField(TimeField field) const;
320
321
322         /*
323          * Gets the Gregorian Calendar change date. @n
324          * This is the point when the switch from Julian dates to Gregorian dates occurred.
325          * Default is 00:00:00 local time, October 15, 1582. Previous to this the time and date are Julian dates.
326          *
327          * @since                       2.0
328          *
329          * @return                      The milliseconds which is the Gregorian cutover time for this calendar
330          */
331         long long GetGregorianChange(void) const;
332
333
334         /**
335          * Gets the calendar type of the current instance.
336          *
337          * @since                       2.0
338          *
339          * @return                      An instance of CalendarType representing the calendar type of the current instance of Calendar @n
340          *                                      In this case, CALENDAR_GREGORIAN.
341          */
342         virtual CalendarType GetType(void) const;
343
344         /**
345          * Checks whether the current date for the current instance is in Daylight Saving Time (DST).
346          *
347          * @since                       2.0
348          *
349          * @return                      An error code
350          * @param[out]          isInDst                                         Set to @c true if the current date is in DST, @n
351          *                                                                                              else @c false
352          * @exception           E_SUCCESS                                       The method is successful.
353          * @exception           E_OUT_OF_RANGE          In this method, time fields of this instance are calculated. @n
354          *                                                                              If the value of the time fields goes out of range, this exception is returned.
355          * @exception           E_INVALID_STATE         In this method, time fields of this instance are calculated. @n 
356          *                     If any time field value previously set is invalid, this exception is returned.
357          */
358         virtual result IsInDst(bool& isInDst) const;
359
360
361         /**
362          * Checks whether the specified year is a leap year.
363          *
364          * @since                       2.0
365          *
366          * @return                      @c true if the specified year is a leap year, @n
367          *                                      else @c false
368          * @param[in]           year                                            The year to check
369          */
370         bool IsLeapYear(int year) const;
371
372
373         /*
374          * Sets the Gregorian Calendar change date. @n
375          * This is the point when the switch from Julian dates to Gregorian dates occurred.
376          * Default is 00:00:00 local time, Oct 15, 1582. Previous to this, dates are in the Julian calendar.
377          *
378          * To obtain a pure Julian calendar, set the change @c change to MAX_MILLISECOND.
379          * To obtain a pure Gregorian calendar, set the change @c change to MIN_MILLISECOND.
380          *
381          * @since                       2.0
382          *
383          * @return                      An error code
384          * @param[in]           change                                          The given Gregorian cutover date
385          * @exception           E_SUCCESS                                       The method is successful.
386          * @exception           E_OUT_OF_MEMORY                         The memory is insufficient.
387          */
388         result SetGregorianChange(long long change);
389
390         /**
391          * Rolls up or down as per the specified amount in the specified field. @n
392          * This method overrides Calendar(). @n
393          * For more details, refer to Tizen::Locales::Calendar::Roll(TimeField, int).
394          *
395          * @since                       2.0
396          *
397          * @return                      An error code
398          * @param[in]           field                                           The time field
399          * @param[in]           amount                                          The amount to roll up/down
400          * @exception           E_SUCCESS                                       The method is successful.
401          * @exception           E_INVALID_STATE                         In this method, time fields of this instance are calculated. @n
402          *                                                                      If any time field value previously set is invalid, this exception is returned.
403          * @exception           E_INVALID_ARG                           The specified @c field is invalid (for example, TIME_FIELD_DST_OFFSET, TIME_FIELD_ZONE_OFFSET).
404          * @exception           E_OUT_OF_RANGE                  In this method, time fields of this instance are calculated. @n
405          *                                               If the value of the time fields goes out of range, this exception is returned.
406          */
407         virtual result Roll(TimeField field, int amount);
408
409
410         /*
411          * Gets the millisecond which is midnight, local time at or before the Gregorian cutover.
412          *
413          * @since                       2.0
414          *
415          * @return                      The millisecond which is midnight, local time at or before the Gregorian cutover
416          *                                      If this method fails, @c -1 is returned.
417          *                                      The specific error code can be accessed using the GetLastResult() method.
418          */
419         long long GetNormalizedGregorianCutover(void) const;
420
421         /*
422          * Gets the year of the Gregorian cutover, with @c 0 representing 1 BC, @c -1 representing 2 BC, and so on.
423          *
424          * @since                       2.0
425          *
426          * @return                      The year of the Gregorian cutover
427          *                                      If this method fails, @c -1 is returned.
428          *                                      The specific error code can be accessed using the GetLastResult() method.
429          */
430         int GetGregorianCutoverYear(void) const;
431
432         /*
433          * Gets the Julian day number of the Gregorian cutover.
434          *
435          * @since                       2.0
436          *
437          * @return                      The Julian day number of the Gregorian cutover
438          */
439         int GetCutoverJulianDay(void) const;
440
441
442         /*
443          * Checks whether the current calendar is a Gregorian calendar or not.
444          *
445          * @since                       2.0
446          *
447          * @return                      @c true if the current calendar is a Gregorian calendar, @n
448          *                                      else @c false
449          */
450         bool IsGregorian() const;
451
452
453         /**
454          * Gets the current time of the instance in milliseconds from epoch.
455          *
456          * @since                       2.0
457          *
458          * @return                      An error code
459          * @param[out]          millisec                                        The current time in milliseconds from the epoch
460          * @exception           E_SUCCESS                                       The method is successful.
461          * @exception           E_INVALID_STATE                         If any time field value previously set is invalid, this exception is returned.
462          * @exception           E_OUT_OF_RANGE                          A time field or its value is out of range.
463          */
464         result GetTimeInMillisecFromEpoch(long long& millisec) const;
465
466
467         /**
468          * Sets the current time of the instance with the specified milliseconds value.
469          *
470          * @since                       2.0
471          *
472          * @return                      An error code
473          * @param[in]           millisec                                        The new time in milliseconds from the epoch
474          * @exception           E_OUT_OF_RANGE                          A time field or its value is out of range.
475          */
476         result SetTimeInMillisecFromEpoch(long long millisec);
477
478
479         /**
480          * Converts the 1970-epoch day number to the Gregorian year, month, date, day of week, and day of year.
481          *
482          * @since                       2.0
483          *
484          * @param[in]           day                                                     The 1970-epoch day number
485          * @param[out]          year                                            The year to convert
486          * @param[out]          month                                           The month to convert
487          * @param[out]          dayOfMonth                                      The date to convert
488          * @param[out]          dayOfWeek                                       The day of week to convert
489          * @param[out]          dayOfYear                                       The day of year to convert
490          */
491         static void DayToFields(int day, int& year, int& month, int& dayOfMonth, int& dayOfWeek, int& dayOfYear);
492
493 private:
494         /*
495          * @enum                GregorianCalendarEras
496          *
497          * Defines Era for Gregorian calendar. The indexing is 0-based.
498          */
499         enum GregorianCalendarEras
500         {
501                 GREGORIAN_CALENDAR_BC = 0,      // BC
502                 GREGORIAN_CALENDAR_AD = 1,      // AD
503
504                 GREGORIAN_CALENDAR_BCE = 0,     // BCE
505                 GREGORIAN_CALENDAR_CE = 1,      // CE
506         };
507
508         /*
509          * The implementation of this copy constructor is intentionally blank and declared as private to
510          * prohibit copying of objects.
511          */
512         GregorianCalendar(const GregorianCalendar& gregorianCalendar);
513
514         /*
515          * The implementation of this copy assignment operator is intentionally blank and declared as private
516          * to prohibit copying of objects.
517          */
518         GregorianCalendar& operator =(const GregorianCalendar& gregorianCalendar);
519
520         // added for backward compatibility
521         virtual result RollWithSingleUnit(TimeField field, bool up);
522         virtual result ComputeTimeFields(void);
523         virtual result ComputeTime(void);
524         virtual int GetMonthLength(int extendedYear, int month) const;
525         virtual int HandleGetLimit(TimeField field, CalendarLimitType limitType) const;
526         virtual Calendar* CloneN(void) const;
527
528 public:
529         /*
530          * Defines the length of months.
531          *
532          * @since 2.0
533          */
534         static const int MONTH_LENGTH[24];
535
536         /*
537          * Defines the days of a year.
538          *
539          * @since 2.0
540          */
541         static const int NUM_DAYS[24];
542
543         /*
544          * The Gregorian cutover number for Julian day.
545          *
546          * @since 2.0
547          */
548         static const int CUTOVER_JULIAN_DAY = 2299161;      // Oct 15, 1582
549
550         /*
551          * The epoch year.
552          *
553          * @since 2.0
554          */
555         static const int EPOCH_YEAR = 1970;
556
557         /*
558          * The epoch start for Julian day.
559          *
560          * @since 2.0
561          */
562         static const int EPOCH_START_AS_JULIAN_DAY = 2440588; // Jan 1, 1970(Gregorian)
563
564         /*
565          * Jan 1, 1 epoch start for Julian day.
566          *
567          * @since 2.0
568          */
569         static const int JAN_1_1_JULIAN_DAY = 1721426;  // Jan 1, 1 CE Gregorian
570
571         /*
572          * Temporary value for the Gregorian cutover.
573          *
574          * @since 2.0
575          */
576         static const long long PAPAL_CUTOVER =
577                 ((long long) (GregorianCalendar::CUTOVER_JULIAN_DAY -
578                                           GregorianCalendar::EPOCH_START_AS_JULIAN_DAY) * (long long) ONE_DAY_IN_MILLISEC);
579
580         /*
581          * Maximum value for longlong.
582          *
583          * @since 2.0
584          */
585         static const long long MAX_LONGLONG = (2 ^ 63) - 1;
586
587         /*
588          * Minimum value for longlong.
589          *
590          * @since 2.0
591          */
592         static const long long MIN_LONGLONG = -1 * (2 ^ 63);
593
594         /*
595          * Maximum value for Julian day.
596          *
597          * @since 2.0
598          */
599         static const int MAX_JULIAN = 0x7F000000;
600
601         /*
602          * Minimum value for Julian day.
603          *
604          * @since 2.0
605          */
606         static const int MIN_JULIAN = -0x7F000000;
607
608         /*
609          * Maximum millisecond value for Julian day.
610          *
611          * @since 2.0
612          */
613         static const long long MAX_MILLISEC = ((GregorianCalendar::MAX_JULIAN - GregorianCalendar::EPOCH_START_AS_JULIAN_DAY) * (long long) ONE_DAY_IN_MILLISEC);
614
615         /*
616          * Minimum millisecond value for Julian day.
617          *
618          * @since 2.0
619          */
620         static const long long MIN_MILLISEC = ((GregorianCalendar::MIN_JULIAN - GregorianCalendar::EPOCH_START_AS_JULIAN_DAY) * (long long) ONE_DAY_IN_MILLISEC);
621
622         /*
623          * Epoch offset in millisecond value.
624          *
625          * @since 2.0
626          */
627         static const long long EPOCH_OFFSET_IN_MILLISEC = 62135596800000LL; // Jan 1, 1970
628
629         /*
630          * Default Gregorian cutover.
631          *
632          * @since 2.0
633          */
634         static const long long DEFAULT_GREGORIAN_CUTOVER = -12219292800000LL;
635
636 private:
637         long long __normalizedGregorianCutover; // = __gregorianCutover;
638         int __gregorianCutoverYear; // 1582
639         int __cutoverJulianDay;
640
641         friend class _GregorianCalendarImpl;
642         class _GregorianCalendarImpl* __pGregorianCalendarImpl;
643
644 }; // GregorianCalendar
645
646 }} // Tizen::Locales
647
648 #endif //_FLCL_GREGORIAN_CALENDAR_H_