Fix the boiler plate codes
[platform/framework/native/appfw.git] / inc / FLclCalendar.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                FLclCalendar.h
19  * @brief               This is the header file for the %Calendar class.
20  *
21  * This header file contains the declarations of the %Calendar class.
22  *
23  */
24 #ifndef _FLCL_CALENDAR_H_
25 #define _FLCL_CALENDAR_H_
26
27 #include <FBase.h>
28 #include <FLclLocale.h>
29 #include <FLclTimeZone.h>
30
31 namespace Tizen { namespace Locales
32 {
33 /**
34  * @class               Calendar
35  * @brief               This class provides methods for displaying a calendar.
36  *
37  * @since               2.0
38  *
39  * The %Calendar class is an abstract base class for displaying a calendar. It is used to convert between the Tizen::Base::DateTime instance and a set of time fields, such as TIME_FIELD_YEAR, TIME_FIELD_MONTH, and TIME_FIELD_DAY_OF_MONTH.
40  * Subclasses of %Calendar interpret %Tizen::Base::DateTime according to the rules of a specific calendar system. GregorianCalendar is commonly used.
41  *
42  * For more information on the class features, see <a href="../org.tizen.native.appprogramming/html/guide/locales/calendar.htm">Calendar</a>.
43  *
44  * @see                 Tizen::Locales::TimeZone
45  *
46  * The following example demonstrates how to use the %Calendar class to set or add the time field.
47  *
48  @code
49  *
50  #include <FBase.h>
51  #include <FLocales.h>
52
53  using namespace Tizen::Base;
54  using namespace Tizen::Locales;
55
56  void
57  MyClass::CalendarExample(void)
58  {
59         int offset = 60;
60         String timeZoneName(L"Europe/Paris");
61         TimeZone timeZone(offset, timeZoneName);
62
63         Calendar* pCalendar = Calendar::CreateInstanceN(timeZone, CALENDAR_GREGORIAN);
64         pCalendar->SetTime(2012,7,18);
65
66         // Increase one day. The date will be 2012/7/19
67         pCalendar->AddTimeField(TIME_FIELD_DAY_OF_MONTH, 1);
68
69         // Decrease two months. The date will be 2012/5/19
70         pCalendar->AddTimeField(TIME_FIELD_MONTH, -2);
71
72         delete pCalendar;
73  }
74  @endcode
75  */
76 #define GET_TIME_FIELD_MASK(X)  (static_cast<int>(1 << (X)))
77 /**
78 * @enum TimeField
79 *
80 * Defines the time fields for date and time. @n
81 * This enum is used in %Calendar.
82 *
83 * @since                2.0
84 */
85 enum TimeField
86 {
87         TIME_FIELD_ERA,                                                 /**< Era : 0 - BC, 1 - AD */
88         TIME_FIELD_YEAR,                                                /**< Year : 1-based */
89         TIME_FIELD_MONTH,                                               /**< Month : 1-based (1~13)*/
90         TIME_FIELD_WEEK_OF_YEAR,                                /**< Week of Year : 1-based (1~53) */
91         TIME_FIELD_WEEK_OF_MONTH,                               /**< Week of Month : 1-based (1~5, may be specified as 0) */
92         TIME_FIELD_DAY_OF_MONTH,                                /**< Date : 1-based (1~31) */
93         TIME_FIELD_DAY_OF_YEAR,                                 /**< Day of Year : 1-based (1~366) */
94         TIME_FIELD_DAY_OF_WEEK,                                 /**< Day of Week : 1-based (1~7) */
95         TIME_FIELD_DAY_OF_WEEK_IN_MONTH,                /**< Day of Week in Month : 1-based (1~5, may be specified as -1) */
96         TIME_FIELD_AM_PM,                                               /**< AmPm : 0 - AM, 1 - PM */
97         TIME_FIELD_HOUR,                                                /**< Hour : 0-based (0~11) */
98         TIME_FIELD_HOUR_OF_DAY,                                 /**< Hour of Day : 0-based (0~23) */
99         TIME_FIELD_MINUTE,                                              /**< Minute : 0-based (0~59) */
100         TIME_FIELD_SECOND,                                              /**< Second : 0-based (0~59) */
101         TIME_FIELD_MILLISECOND,                                 /**< Millisecond : 0-based (0~999) */
102         TIME_FIELD_ZONE_OFFSET,                                 /**< Time Zone Offset : 0-based (-43200000~54000000 in milliseconds) */ 
103         TIME_FIELD_DST_OFFSET,                                  /**< Daylight Saving Offset : 0-based (0~3600000 in milliseconds)*/
104         TIME_FIELD_FIELD_COUNT                                  /**< The number of time field */
105 };
106
107 class _OSP_EXPORT_ Calendar
108         : public Tizen::Base::Object
109 {
110 public:
111         /**
112          * This is the destructor for this class. @n 
113          * This destructor overrides Tizen::Base::Object::~Object().
114          *
115          * @since               2.0
116          */
117         virtual ~Calendar(void);
118
119         /**
120         * Adds the specified amount to the given time field, based on the calendar rules. @n
121         * It is equivalent to calling SetTimeField(field, GetTimeField(field)+amount) with two adjustments. @n
122         *
123         * @b Add @b Rule1: The value of the time field @c field after the call minus the value of the field
124         * before the call is delta modulo any overflow that has occurred in the field.
125         * Overflow occurs when a time field value exceeds its range and, as a result, the next larger field
126         * is incremented or decremented and the field value is adjusted back into its range. @n
127         *
128         * @b Add @b Rule2: If a smaller field is expected to be invariant, but it is impossible for it to be
129         * equal to its prior value because of changes in its minimum or maximum value after the time field @c field
130         * is changed, then its value is adjusted to be as close as possible to its expected value. @n
131         *
132         * A smaller field represents a smaller unit of time. TIME_FIELD_HOUR is a smaller field than TIME_FIELD_DAY_OF_MONTH.
133         * No adjustment is made to smaller fields that are not expected to be invariant.
134         * The calendar system determines what fields are expected to be invariant.
135         *
136         * In addition, this method forces re-computation of the calendar's milliseconds and
137         * all time fields immediately. @n
138         *
139         * For example, consider a GregorianCalendar set to Oct 31, 2004.
140         * Calling AddTimeField(TIME_FIELD_MONTH, 13) sets the calendar to Nov 30, 2005. @n
141         * The TIME_FIELD_MONTH field is set to NOVEMBER by @b Rule1, since adding 13 months to October gives the
142         * November of the next year.
143         * Since, the TIME_FIELD_DAY_OF_MONTH cannot be 31 in November in a %GregorianCalendar, the TIME_FIELD_DAY_OF_MONTH is set to 30 by @b Rule2.
144         *
145         * @if OSPCOMPAT
146         * @brief <i> [Compatibility] </i>
147         * @endif
148         * @since                        2.0
149         * @if OSPCOMPAT
150         * @compatibility     This method has compatibility issues with OSP compatible applications. @n
151         *                              For more information, see @ref CompCalendarAddTimeFieldPage "here".
152         * @endif
153         *
154         * @return                       An error code
155         * @param[in]            field                                           The time field
156         * @param[in]            amount                                          The amount to add
157         * @exception            E_SUCCESS                                       The method is successful.
158         * @exception            E_INVALID_ARG                                  The specified @c field is invalid.  
159         */
160         virtual result AddTimeField(TimeField field, int amount) = 0;
161
162         /**
163         * @if OSPCOMPAT
164         * @page                    CompCalendarAddTimeFieldPage Compatibility for AddTimeField()
165         * @section                   CompCalendarAddTimeFieldIssueSection Issues
166         * Implementation of this method in OSP compatible applications has the following issue: @n
167         * -# The method returns E_INVALID_STATE if the time field is invalid.
168         *
169         * @section                 CompCalendarAddTimeFieldSolutionSection Resolutions
170         * This issue has been resolved in Tizen.
171         *
172         * @par When working in Tizen:
173         * -# The method returns E_INVALID_ARG if the time field is invalid.
174         * @endif
175         */
176
177         /**
178         * Compares the current instance of %Calendar with the specified instance.
179         *
180         * @if OSPCOMPAT
181         * @brief <i> [Compatibility] </i>
182         * @endif
183         * @since                                2.0
184         * @if OSPCOMPAT
185         * @compatibility     This method has compatibility issues with OSP compatible applications. @n
186         *                              For more information, see @ref CompCalendarAfterPage "here".
187         * @endif
188         *
189         * @return                               An error code
190         * @param[in]            otherCalendar                                   The instance of %Calendar to compare
191         * @param[out]           after                                           Set to @c true if the current instance of %Calendar is after the specified instance of %Calendar, @n
192         *                                                                               else @c false
193         * @exception            E_SUCCESS                                       The method is successful.
194         * @exception            E_INVALID_ARG                                   The specified @c otherCalendar is invalid. 
195         * @exception            E_INVALID_STATE                                 In this method, the time fields of this instance are calculated. @n 
196         *                                                                               If any time field value previously set is invalid, this exception is returned. 
197         * @exception            E_OUT_OF_RANGE                                  In this method, the time fields of this instance are calculated. @n
198         *                                                                                If the value of the time fields goes out of range, this exception is returned. 
199         */
200         result After(const Calendar& otherCalendar, bool& after);
201
202         /**
203         * @if OSPCOMPAT
204         * @page                    CompCalendarAfterPage Compatibility for After()
205         * @section                   CompCalendarAfterIssueSection Issues
206         * Implementation of this method in OSP compatible applications has the following issue: @n
207         * -# The method returns E_INVALID_STATE and E_OUT_OF_RANGE if the instance of %Calendar to be compared is invalid.
208         *
209         * @section                 CompCalendarAfterSolutionSection Resolutions
210         * This issue has been resolved in Tizen.
211         *
212         * @par When working in Tizen: 
213         * -# The method returns E_INVALID_ARG if the instance of %Calendar to be compared is invalid.
214         * -# The method returns E_INVALID_STATE if any time field value previously set is invalid.
215         * -# The method returns E_OUT_OF_RANGE if the value of the time fields goes out of range.
216         * @endif
217         */                                        
218
219         /**
220         * Compares the current instance of %Calendar with the specified instance.
221         *
222         * @if OSPCOMPAT
223         * @brief <i> [Compatibility] </i>
224         * @endif
225         * @since                                2.0
226         * @if OSPCOMPAT
227         * @compatibility     This method has compatibility issues with OSP compatible applications. @n
228         *                              For more information, see @ref CompCalendarBeforePage "here".
229         * @endif
230         *
231         * @return                               An error code
232         * @param[in]                    otherCalendar                           The instance of %Calendar to compare
233         * @param[out]                   before                                  Set to @c true if the current instance of %Calendar is before the specified instance of %Calendar, @n
234         *                                                                               else @c false
235         * @exception            E_SUCCESS                               The method is successful.
236         * @exception            E_INVALID_ARG                           The specified @c otherCalendar is invalid. 
237         * @exception            E_INVALID_STATE                         In this method, the time fields of this instance are calculated. @n
238         *                                                                        If any time field value previously set is invalid, this exception is returned. 
239         * @exception            E_OUT_OF_RANGE                          In this method, the time fields of this instance are calculated. @n
240         *                                                                        If the value of the time fields goes out of range, this exception is returned. 
241         */
242         result Before(const Calendar& otherCalendar, bool& before);
243
244         /**
245         * @if OSPCOMPAT
246         * @page                    CompCalendarBeforePage Compatibility for Before()
247         * @section                   CompCalendarBeforeIssueSection Issues
248         * Implementation of this method in OSP compatible applications has the following issue: @n
249         * -# The method returns E_INVALID_STATE and E_OUT_OF_RANGE if the instance of %Calendar to be compared is invalid.
250         *
251         * @section                 CompCalendarBeforeSolutionSection Resolutions
252         * This issue has been resolved in Tizen.
253         *
254         * @par When working in Tizen: 
255         * -# The method returns E_INVALID_ARG if the instance of %Calendar to be compared is invalid.
256         * -# The method returns E_INVALID_STATE if any time field value previously set is invalid.
257         * -# The method returns E_OUT_OF_RANGE if the value of the time fields goes out of range.
258         * @endif
259         */
260
261         /**
262         * Clears all the time fields and sets it to @c 0. @n
263         * Zero is not the default value for each field. It means the field is cleared.
264         *
265         * @since                                2.0
266         *
267         * @return                               An error code
268         * @exception                    E_SUCCESS                                       The method is successful.
269         */
270         result Clear(void);
271
272         /**
273         * Clears the specified time field and sets it to @c 0. @n
274         * Zero is not the default value for each field. It means the field is cleared.
275         *
276         * @since                                2.0
277         *
278         * @return                               An error code
279         * @param[in]                    field                                           The time field to clear
280         * @exception                    E_SUCCESS                                       The method is successful.
281         */
282         result Clear(TimeField field);
283
284         /**
285         * Checks whether the value of the specified instance of Tizen::Base::Object is equal to the value of the current instance of %Calendar.
286         *
287         * @since                        2.0
288         *
289         * @return                       @c true if the value of the specified instance of Tizen::Base::Object is equal to the value of the current instance of %Calendar, @n
290         *                                       else @c false
291         * @param[in]            obj An instance of Tizen::Base::Object to compare
292         */
293         virtual bool Equals(const Tizen::Base::Object& obj) const;
294
295         /**
296         * Gets the hash value of the current instance.
297         *
298         * @since                        2.0
299         *
300         * @return                       The hash value of the current instance
301         */
302         virtual int GetHashCode(void) const;
303
304         /**
305         * Rolls up or down as per the specified @c amount in the specified time field without changing the larger fields (for example, TIME_FIELD_YEAR field cannot be changed when the input field is TIME_FIELD_MONTH). @n
306         * If the specified @c amount is negative, the amount value is deducted from the specified time field value.
307         * In this method, the time field of this instance is operated upon. If the value of the specified @c field goes out of range, E_OUT_OF_RANGE is returned.
308         *
309         * @if OSPCOMPAT
310         * @brief <i> [Compatibility] </i>
311         * @endif
312         * @since                                2.0
313         * @if OSPCOMPAT
314         * @compatibility     This method has compatibility issues with OSP compatible applications. @n
315         *                              For more information, see @ref CompCalendarRollPage "here".
316         * @endif
317         *
318         * @return                               An error code
319         * @param[in]                    field                                                   The time field to roll
320         * @param[in]                    amount                                                  The amount to add to the time field
321         * @exception                    E_SUCCESS                                               The method is successful.
322         * @exception                    E_INVALID_ARG                                   The specified @c field is invalid (for example, TIME_FIELD_DST_OFFSET, TIME_FIELD_ZONE_OFFSET). 
323         * @exception            E_OUT_OF_RANGE                          In this method, the time fields of this instance are calculated. @n
324         *                                                                        If the value of the time fields goes out of range, this exception is returned.
325         */
326         virtual result Roll(TimeField field, int amount);
327
328         /**
329         * @if OSPCOMPAT
330         * @page                    CompCalendarRollPage Compatibility for Roll()
331         * @section                   CompCalendarRollIssueSection Issues
332         * Implementation of this method in OSP compatible applications has the following issue: @n
333         * -# The method returns E_INVALID_STATE if the time field is invalid.
334         *
335         * @section                 CompCalendarRollSolutionSection Resolutions
336         * This issue has been resolved in Tizen.
337         *
338         * @par When working in Tizen: 
339         * -# The method returns E_INVALID_ARG if the time field is invalid.
340         * @endif
341         */
342
343         /**
344         * Sets the specified time field with the specified @c value. @n
345         * This sets an internal member variable to indicate that the field has been changed.
346         * Although the time field is changed, the milliseconds of %Calendar are not recomputed
347         * until GetTimeField(), GetTime(), or GetTimeInMillisec() is called.
348         * Thus, even if you call this method several times, unnecessary multiple computations are not triggered. @n
349         *
350         * As a result of changing a field using SetTimeField(), other fields may also change
351         * depending on the field, the field value, and the calendar system. @n
352         *
353         * For example, consider a GregorianCalendar set to Oct. 31, 2004.
354         * Calling SetTimeField(TIME_FIELD_MONTH, NOVEMBER) sets the calendar to Nov 31, 2004. @n
355         * But, if you call GetTime(), then Dec 1, 2004 is returned because Nov 31, 2004 does not exist.
356         * However, a call to SetTimeField(TIME_FIELD_MONTH, SEPTEMBER) before a call to GetTime() sets the calendar
357         * to Sep 30, 2004, since no re-computation has occurred after the first call to SetTimeField().
358         *
359         * The value of field is not affected by it being local time or UTC time.
360         * The value is only overwritten.
361         *
362         * @since                                2.0
363         *
364         * @return                               An error code
365         * @param[in]                    field                                   The time field to set
366         * @param[in]                    value                                   The value to set
367         * @exception                    E_SUCCESS                               The method is successful.
368         * @exception                    E_OUT_OF_RANGE                  The value is out of range in lenient mode.
369         * @exception                    E_INVALID_ARG                   The specified @c field is invalid.
370         */
371         result SetTimeField(TimeField field, int value);
372
373         /**
374         * Sets the first day of the week.
375         *
376         * @since                                2.0
377         *
378         * @return                               An error code
379         * @param[in]                    dayOfWeek                               The value to set as the first day of the week
380         * @exception                    E_SUCCESS                               The method is successful.
381         * @exception                    E_INVALID_ARG                   The specified @c dayOfWeek is invalid.
382         */
383         result SetFirstDayOfWeek(DayOfWeek dayOfWeek);
384
385         /**
386         * Sets the leniency of date and time interpretations.
387         *
388         * @since                                2.0
389         *
390         * @return                               An error code
391         * @param[in]                    lenient                                 Set to @c true if the date and time interpretation is set to lenient, @n
392         *                                                                                               else @c false
393         * @exception                    E_SUCCESS                               The method is successful.
394         */
395         result SetLenient(bool lenient);
396
397         /**
398         * Sets the minimal days required in the first week.
399         *
400         * @since                                2.0
401         *
402         * @return                               An error code
403         * @param[in]                    value                                   The minimal days required in the first week
404         * @exception                    E_SUCCESS                               The method is successful.
405         */
406         result SetMinDaysInFirstWeek(short value);
407
408         /**
409         * Sets the value of year, month, day, hour, minute, and seconds. @n
410         * The date and time are local time.
411         *
412         * @since                                2.0
413         *
414         * @return                               An error code
415         * @param[in]                    year                                    The value to set for year
416         * @param[in]                    month                                   The value to set for month @n
417         *                                                                                               The indexing is 1-based. Therefore, 1 means January.
418         * @param[in]                    day                                             The value to set for day
419         * @param[in]                    hour                                    The value to set for hour
420         * @param[in]                    minute                                  The value to set for minute
421         * @param[in]                    second                                  The value to set for second
422         * @exception                    E_SUCCESS                               The method is successful.
423         * @exception                    E_OUT_OF_RANGE                   A time field or its value is out of range in lenient mode.
424         */
425         result SetTime(int year, int month, int day, int hour = 0, int minute = 0, int second = 0);
426
427         /**
428         * Sets the calendar's current time with the specified Tizen::Base::DateTime.
429         *
430         * @since                                2.0
431         *
432         * @return                               An error code
433         * @param[in]                    dateTime                                The Tizen::Base::DateTime instance to set
434         * @exception                    E_SUCCESS                               The method is successful.
435         * @remarks                              The time specified is the local time.
436         */
437         result SetTime(const Tizen::Base::DateTime& dateTime);
438
439         /**
440         * Sets the current time of this %Calendar instance with the specified value.
441         *
442         * @since                                2.0
443         *
444         * @return                               An error code
445         * @param[in]                    millisec                                The new time in milliseconds from the starting day (Jan 1, 1.)
446         * @exception                    E_SUCCESS                               The method is successful.
447         * @exception                    E_OUT_OF_RANGE                  A time field or its value is out of range.
448         */
449         result SetTimeInMillisec(long long millisec);
450
451         /**
452         * Sets the time zone of the calendar to the specified time zone.
453         *
454         * @since                        2.0
455         *
456         * @return                       An error code
457         * @param[in]            timeZone                                The time zone to set
458         * @exception            E_SUCCESS                               The method is successful.
459         */
460         result SetTimeZone(const TimeZone& timeZone);
461
462         /**
463          * Gets the actual maximum value that the specified field can have, given the current date. @n
464          * For example, if the current date is "Feb 10, 2004" and the time field specified is TIME_FIELD_DAY_OF_MONTH, then the actual
465          * maximum value for this time field is 29.
466          *
467          * @since                                       2.0
468          *
469          * @return                                      An integer value indicating the actual maximum value
470          * @param[in]                           field           The time field
471          * @exception                           E_SUCCESS                       The method is successful.
472          * @exception                           E_INVALID_ARG                   The specified @c field is invalid.
473          * @remarks                                     The specific error code can be accessed using the GetLastResult() method.
474          */
475         virtual int GetActualMaxTimeField(TimeField field) const;
476
477         /**
478          * Gets the actual minimum value that the specified time field can have, given the current date. @n
479          * For the Gregorian calendar, this is the same as GetMinTimeField() and
480          * GetGreatestMinTimeField().
481          *
482          * @since                                       2.0
483          *
484          * @return                                      An integer value indicating the actual minimum value 
485          * @param[in]                           field           The time field
486          * @exception                           E_SUCCESS                       The method is successful.
487          * @exception                           E_INVALID_ARG                   The specified @c field is invalid.
488          * @exception                           E_SYSTEM                        A system error has occurred.
489          * @remarks                                     The specific error code can be accessed using the GetLastResult() method.
490          */
491         virtual int GetActualMinTimeField(TimeField field) const;
492
493         /**
494         * Gets the value of the first day of the week. @n
495         * For example, in USA, the first day of the week is SUNDAY. But, it is MONDAY in France.
496         *
497         * @since                                        2.0
498         *
499         * @return                                       An integer value indicating the first day of the week, @n
500         *                                               else @c -1 if the method fails
501         */
502         int GetFirstDayOfWeek(void) const;
503
504         /**
505         * Gets the greatest minimum value that the specified time field can have.
506         *
507         * @since                                        2.0
508         *
509         * @return                                       An integer value indicating the greatest minimum value for the specified time field
510         * @param[in]                            field           The time field
511         * @exception                            E_SUCCESS                       The method is successful.
512         * @exception                            E_INVALID_ARG                   The specified @c field is invalid.
513         * @exception                            E_SYSTEM                        A system error has occurred.
514         * @remarks                                      The specific error code can be accessed using the GetLastResult() method.
515         */
516         virtual int GetGreatestMinTimeField(TimeField field) const;
517
518         /**
519         * Gets the least maximum value that the specified time field can have.
520         *
521         * @since                                        2.0
522         *
523         * @return                                       An integer value indicating the least maximum value for the specified time field
524         * @param[in]                            field           The time field
525         * @exception                            E_SUCCESS                       The method is successful.
526         * @exception                            E_INVALID_ARG                   The specified @c field is invalid.
527         * @exception                            E_SYSTEM                        A system error has occurred.
528         * @remarks                                      The specific error code can be accessed using the GetLastResult() method.
529         */
530         virtual int GetLeastMaxTimeField(TimeField field) const;
531
532         /**
533         * Gets the maximum value that the specified time field can have.
534         *
535         * @since                                        2.0
536         *
537         * @return                                       An integer value indicating the maximum value for the specified time field
538         * @param[in]                            field           The time field
539         * @exception                            E_SUCCESS                       The method is successful.
540         * @exception                            E_INVALID_ARG                   The specified @c field is invalid.
541         * @exception                            E_SYSTEM                        A system error has occurred.
542         * @remarks                                      The specific error code can be accessed using the GetLastResult() method.
543         */
544         virtual int GetMaxTimeField(TimeField field) const;
545
546         /**
547         * Gets the minimum value that the specified time field can have.
548         *
549         * @since                                        2.0
550         *
551         * @return                                       An integer value indicating the minimum value for the specified time field
552         * @param[in]                            field           The time field
553         * @exception                            E_SUCCESS                       The method is successful.
554         * @exception                            E_INVALID_ARG                   The specified @c field is invalid.
555         * @exception                            E_SYSTEM                        A system error has occurred.
556         * @remarks                                      The specific error code can be accessed using the GetLastResult() method.
557         */
558         virtual int GetMinTimeField(TimeField field) const;
559
560         /**
561         * Gets the minimum number of days required in the first week of the year. @n
562         * For example, if the first week is defined as the one that contains the first day of
563         * the first month of a year, this method returns @c 1.
564         *
565         * @since                                        2.0
566         *
567         * @return                                       An integer value indicating the minimum number of days required in the first week
568         */
569         int GetMinDaysInFirstWeek(void) const;
570
571         /**
572         * Gets the date and time of the current instance of %Calendar.
573         *
574         * @since                                        2.0
575         *
576         * @return                                       An instance of Tizen::Base::DateTime with the current time in local time
577         * @remarks                                      The time specified is local time.
578         */
579         Tizen::Base::DateTime GetTime(void) const;
580
581         /**
582         * Gets the value of the specified time field.
583         *
584         * @since                                        2.0
585         *
586         * @return                                       An integer value indicating the value of the specified time field
587         *                                                       
588         * @param[in]                            field           The given time field
589         * @exception                            E_SUCCESS                       The method is successful.
590         * @exception                            E_INVALID_ARG                   The specified @c field is invalid.
591         * @exception                            E_SYSTEM                        A system error has occurred.
592         * @remarks                                      This method is semantically const, but may alter the instance in memory.
593         *                                               All fields are re-computed if any field is invalid.
594         *                                               The specific error code can be accessed using the GetLastResult() method.
595         */
596         int GetTimeField(TimeField field) const;
597
598         /**
599         * Gets the current time of the instance in the @c long format.
600         *
601         * @since                                        2.0
602         *
603         * @return                                       An error code
604         * @param[out]                           millisec                                                The current time in milliseconds from starting day (Jan 1, 1.)
605         * @exception                            E_SUCCESS                                               The method is successful.
606         * @exception                            E_INVALID_STATE                                 In this method, the time fields of this instance are calculated. @n
607         *                                                                                                If any time field value previously set is invalid, this exception is returned.
608         * @exception                            E_OUT_OF_RANGE                                  The value of the argument is out of the valid range defined by the method.
609         */
610         result GetTimeInMillisec(long long& millisec) const;
611
612         /**
613         * Gets a reference to the time zone owned by this instance of %Calendar.
614         *
615         * @since                                        2.0
616         *
617         * @return                                       The TimeZone instance associated with the current instance of %Calendar
618         * @remarks                                      The returned reference is valid only until the SetTimeZone() method is called or this instance of %Calendar is destroyed.
619         * @see                                          SetTimeZone()
620         */
621         TimeZone GetTimeZone(void) const;
622
623         /**
624         * Gets the calendar type of the current instance of %Calendar.
625         *
626         * @since                                        2.0
627         *
628         * @return                                       An instance of CalendarType representing the calendar type of the current instance of %Calendar @n
629         *                                                       For example, CALENDAR_GREGORIAN.
630         */
631         virtual CalendarType GetType(void) const = 0;
632
633         /**
634         * Checks whether the current date for the instance of %Calendar is in Daylight Saving Time (DST).
635         *
636         * @since                                        2.0
637         *
638         * @return                                       An error code
639         * @param[out]                           isInDst                 Set to @c true if the current date is in DST, @n
640         *                                                                                       else @c false
641         * @exception                            E_SUCCESS                                               The method is successful.
642         * @exception                            E_INVALID_STATE         In this method, the time fields of this instance are calculated. @n 
643         *                                                                       If any time field value previously set is invalid, this exception is returned.
644         * @exception                            E_OUT_OF_RANGE                                  A time field or its value is out of range. @n
645         *                                       In this method, the time fields of this instance are calculated. If the value of the time fields goes out of range, this exception is returned.
646         */
647         virtual result IsInDst(bool& isInDst) const = 0;
648
649         /**
650         * Checks whether the date and time interpretation is lenient.
651         *
652         * @since                                        2.0
653         *
654         * @return                                       @c true if the date and time interpretation is set to lenient, @n
655         *                                                       else @c false
656         */
657         bool IsLenient(void) const;
658
659         /**
660         * Checks whether the specified time field has a value.
661         *
662         * @since                                        2.0
663         *
664         * @return                                       @c true if the specified time field has a value, @n
665         *                                                       else @c false
666         * @param[in]                            field           The time field
667         */
668         bool IsSet(TimeField field) const;
669
670         /**
671         * Creates an instance of %Calendar of the specified type with the GMT time zone and the system locale. @n
672         * The time zone is used for the zone offset and the DST offset.
673         * An instance has weekdata which are the first of week, minimal days in the first week, weekend on set, and weekend cease.
674         * The weekdata are set as default values by the locale.
675         *
676         * @since                                        2.0
677         *
678         * @return                                       A pointer to the created %Calendar instance, @n
679         *                                                       else @c null if the method fails
680         * @param[in]                            calendarType            The type of calendar @n
681         *                                                                               Default calendar is the Gregorian calendar (CALENDAR_GREGORIAN).
682         * @exception                            E_SUCCESS                       The method is successful.
683         * @exception                            E_OUT_OF_MEMORY         The memory is insufficient.
684         * @exception                            E_SYSTEM                        A system error has occurred.
685         * @remarks                                      The specific error code can be accessed using the GetLastResult() method.
686         */
687         static Calendar* CreateInstanceN(CalendarType calendarType = CALENDAR_GREGORIAN);
688
689         /**
690         * Creates an instance of %Calendar of the specified type with the specified time zone and the system locale. @n
691         * The @c timeZone is used for the zone offset and the DST offset.
692         * An instance has weekdata which are the first of week, minimal days in the first week, weekend on set, and weekend cease.
693         * The weekdata are set as default values by the locale.
694         *
695         * @since                                        2.0
696         *
697         * @return                                       A pointer to the created %Calendar instance, @n
698         *                                                       else @c null if the method fails
699         * @param[in]                            timeZone                        An instance of TimeZone
700         * @param[in]                            calendarType            The type of calendar @n
701         *                                                                               Default calendar is the Gregorian calendar (CALENDAR_GREGORIAN).
702         * @exception                            E_SUCCESS                       The method is successful.
703         * @exception                            E_OUT_OF_MEMORY         The memory is insufficient.
704         * @exception                            E_SYSTEM                        A system error has occurred.
705         * @remarks                                      The specific error code can be accessed using the GetLastResult() method.
706         */
707         static Calendar* CreateInstanceN(const TimeZone& timeZone, CalendarType calendarType = CALENDAR_GREGORIAN);
708
709         /**
710         * Creates an instance of %Calendar of the specified type with the specified @c locale and the GMT time zone. @n
711         * The time zone is used for the zone offset and the DST offset.
712         * An instance has weekdata which are the first of week, minimal days in the first week, weekend on set, and weekend cease.
713         * The weekdata are set as default values by the specified @c locale.
714         *
715         * @if OSPCOMPAT
716         * @brief <i> [Compatibility] </i>
717         * @endif
718         * @since                                        2.0
719         * @if OSPCOMPAT
720         * @compatibility     This method has compatibility issues with OSP compatible applications. @n
721         *                              For more information, see @ref CompCalendarCreateInstanceNPage "here".
722         * @endif
723         *
724         * @return                                       A pointer to the created %Calendar instance, @n
725         *                                                       else @c null if the method fails
726         * @param[in]                            locale                          The locale for whose country the %Calendar instance is needed
727         * @param[in]                            calendarType            The type of calendar @n
728         *                                                                               Default calendar is the Gregorian calendar (CALENDAR_GREGORIAN).
729         * @exception                            E_SUCCESS                       The method is successful.
730         * @exception                            E_SYSTEM                        A system error has occurred.
731         * @exception                            E_OUT_OF_MEMORY                         The memory is insufficient.
732         * @exception                            E_INVALID_ARG           The specified @c locale is invalid. 
733         * @remarks                                      The specific error code can be accessed using the GetLastResult() method.
734         */
735         static Calendar* CreateInstanceN(const Locale& locale, CalendarType calendarType = CALENDAR_GREGORIAN);
736
737         /**
738         * Creates an instance of %Calendar of the specified type with the specified time zone and @c locale. @n
739         * The @c timeZone is used for the zone offset and the DST offset.
740         * An instance has weekdata which are the first of week, minimal days in the first week, weekend on set, and weekend cease.
741         * The weekdata are set as default values by the specified @c locale.
742         *
743         * @if OSPCOMPAT
744         * @brief <i> [Compatibility] </i>
745         * @endif
746         * @since                                        2.0
747         * @if OSPCOMPAT
748         * @compatibility     This method has compatibility issues with OSP compatible applications. @n
749         *                              For more information, see @ref CompCalendarCreateInstanceNPage "here".
750         * @endif        
751         *
752         * @return                                       A pointer to the created %Calendar instance, @n
753         *                                                       else @c null if the method fails
754         * @param[in]                            timeZone                        An instance of TimeZone
755         * @param[in]                            locale                          The locale for whose country the %Calendar instance is needed
756         * @param[in]                            calendarType            The type of calendar @n
757         *                                                                               Default calendar is the Gregorian calendar (CALENDAR_GREGORIAN).
758         * @exception                            E_SUCCESS                       The method is successful.
759         * @exception                            E_SYSTEM                        A system error has occurred.
760         * @exception                            E_OUT_OF_MEMORY                         The memory is insufficient.
761         * @exception                            E_INVALID_ARG           The specified @c locale is invalid. 
762         * @remarks                                      The specific error code can be accessed using the GetLastResult() method.
763         */
764         static Calendar* CreateInstanceN(const TimeZone& timeZone, const Locale& locale, CalendarType calendarType = CALENDAR_GREGORIAN);
765
766         /**
767         * @if OSPCOMPAT
768         * @page                    CompCalendarCreateInstanceNPage Compatibility for CreateInstanceN()
769         * @section                   CompCalendarCreateInstanceNIssueSection Issues
770         * Implementation of this method in OSP compatible applications has the following issue: @n
771         * -# The method returns E_UNSUPPORTED_OPERATION if the locale is invalid.
772         *
773         * @section                 CompCalendarCreateInstanceNSolutionSection Resolutions
774         * This issue has been resolved in Tizen.
775         * @par When working in Tizen: 
776         * -# The method returns E_INVALID_ARG if the locale is invalid.
777         * @endif
778         */
779
780 protected:
781         /**
782         * @enum AmPm
783         *
784         * Defines the AM/PM mode. @n
785         * This is a.m./p.m. The indexing is 0-based.
786         *
787         * @since                                        2.0
788         */
789         enum AmPm
790         {
791                 AM, /**< The time is in A.M */
792                 PM  /**< The time is in P.M */
793         };
794
795         /**
796         * @enum CalendarLimitType
797         *
798         * Defines the calendar limitations.
799         *
800         * @since                                        2.0
801         */
802         enum CalendarLimitType
803         {
804                 CALENDAR_LIMIT_MINIMUM = 0,             /**< The minimum limit */
805                 CALENDAR_LIMIT_GREATEST_MINIMUM,        /**< The greatest minimum limit */
806                 CALENDAR_LIMIT_LEAST_MAXIMUM,           /**< The least maximum limit */
807                 CALENDAR_LIMIT_MAXIMUM,                 /**< The maximum limit */
808                 CALENDAR_LIMIT_COUNT                    /**< The number of limit type */
809         };
810
811         /**
812         * @enum StampValue
813         *
814         * Defines the stamp value.
815         *
816         * @since                                        2.0
817         */
818         enum StampValue
819         {
820                 UNSET = 0,              /**< Unset */
821                 COMPUTED,               /**< Computed */
822                 MINIMUM_USER_STAMP      /**< Minimum user stamp */
823         };
824
825         /**
826          * This is the default constructor for this class. @n
827          * 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.
828          *
829          * @since                                       2.0
830          *
831          * @see                                         Construct()
832          */
833         Calendar(void);
834
835         /**
836          * Initializes this instance of %Calendar.
837          *
838          * @since                                       2.0
839          *
840          * @return                                      An error code
841          * @exception                           E_SUCCESS                                       The method is successful.
842          */
843         result Construct(void);
844
845         /**
846          * Initializes this instance of %Calendar with the specified parameter.
847          *
848          * @since                                       2.0
849          *
850          * @return                                      An error code
851          * @param[in]                           calendar                                        The %Calendar instance to copy
852          * @exception                           E_SUCCESS                                       The method is successful.
853          * @exception                           E_SYSTEM                                        A system error has occurred.
854          *
855          */
856         result Construct(const Calendar& calendar);
857
858         /**
859          * Initializes this instance of %Calendar with the specified time zone and @c locale. @n
860          * The @c timeZone is used for the zone offset and the DST offset.
861          * An instance has weekdata which are the first of week, minimal days in the first week, weekend on set, and weekend cease.
862          * The weekdata are set as default values by the specified @c locale.
863          *
864          * @if OSPCOMPAT
865          * @brief <i> [Compatibility] </i>
866          * @endif
867          * @since                                       2.0
868          * @if OSPCOMPAT
869          * @compatibility     This method has compatibility issues with OSP compatible applications. @n
870          *                              For more information, see @ref CompCalendarConstructPage "here".       
871          * @endif
872          *
873          * @return                                      An error code
874          * @param[in]                           timeZone                                        An instance of TimeZone
875          * @param[in]                           locale                                          An instance of Locale
876          * @exception                           E_SUCCESS                                       The method is successful.
877          * @exception                            E_INVALID_ARG           The specified @c locale is invalid. 
878          */
879         result Construct(const Tizen::Locales::TimeZone& timeZone, const Locale& locale);
880
881         /**
882          * @if OSPCOMPAT
883          * @page                    CompCalendarConstructPage Compatibility for Construct()
884          * @section                   CompCalendarConstructIssueSection Issues
885          * Implementation of this method in OSP compatible applications has the following issue: @n
886          * -# The method returns E_UNSUPPORTED_OPERATION if the locale is invalid.
887          *
888          * @section                 CompCalendarConstructSolutionSection Resolutions
889          * This issue has been resolved in Tizen.
890          * @par When working in Tizen: 
891          * -# The method returns E_INVALID_ARG if the locale is invalid.
892          * @endif        
893          */
894
895         /**
896         * Rolls up or down with a single unit of time on a given time field without changing larger fields. @n
897         * When rolling on the MONTH field, other fields such as DATE field might conflict
898         * and needs to be changed.
899         *
900         * @since                                        2.0
901         *
902         * @return                                       An error code
903         * @param[in]                            field                                                   The time field to change
904         * @param[in]                            up                                                              Set to @c true if the time field must be rolled upwards, @n
905         *                                                                                                                       else @c false
906         * @exception                            E_SUCCESS                                               The method is successful.
907         * @exception                            E_INVALID_STATE                                 In this method, the time fields of this instance are calculated. @n 
908         *                                                                                               If any time field value previously set is invalid, this exception is returned.
909         * @exception                            E_INVALID_ARG                                   The specified @c field is invalid (for example, TIME_FIELD_DST_OFFSET, TIME_FIELD_ZONE_OFFSET).
910         * @exception                            E_OUT_OF_RANGE           A time field or its value is out of range. @n
911         *                                                       In this method, the time fields of this instance are calculated.
912         *                                                       If the value of the time fields goes out of range, this exception is returned.
913         */
914         virtual result RollWithSingleUnit(TimeField field, bool up) = 0;
915
916         /**
917          * Checks whether the current instance of %Calendar is equivalent to the specified instance of %Calendar.
918          *
919          * @since                                       2.0
920          *
921          * @return                                      @c true if the current instance of %Calendar is equivalent to the specified %Calendar instance, @n
922          *                                                      else @c false
923          * @param[in]                           calendar                The instance of %Calendar to compare with
924          * @remarks                                     If the specified %Calendar instance is equivalent to the current instance, the two instances behave
925          *                                                      exactly the same, but they may be set to different times.
926          */
927         virtual bool IsEquivalentTo(const Calendar& calendar) const;
928
929         /**
930         * Computes the time field value. @n
931         * Converts the current millisecond time value to TimeField. @n
932         * This allows synching up the time field values with a new time that is set for the calendar.
933         *
934         * @since                                                2.0
935         *
936         * @return                                               An error code
937         * @exception                                    E_SUCCESS                                       The method is successful.
938         * @exception                                    E_OUT_OF_RANGE  The time fields contain an invalid value. @n
939         *                                                               In this method, the time fields of this instance are calculated. If the value of the time fields goes out of range, this exception is returned.
940         */
941         virtual result ComputeTimeFields(void) = 0;
942
943         /**
944         * Computes the time value. @n
945         * Converts the current values of time field to the millisecond time value.
946         *
947         * @since                                                2.0
948         *
949         * @return                                               An error code
950         * @exception                                    E_SUCCESS                                       The method is successful.
951         * @exception                                    E_INVALID_STATE                         A value of the internal time field is invalid.
952         */
953         virtual result ComputeTime(void) = 0;
954
955         /**
956         * Gets the length of the specified month.
957         *
958         * @since                                                2.0
959         *
960         * @return                                               An integer value indicating the number of days in the specified month
961         * @param[in]                                    extendedYear                            An extended year
962         * @param[in]                                    month                                           A month
963         */
964         virtual int GetMonthLength(int extendedYear, int month) const = 0;
965
966         /**
967         * Handles the limits of different types. @n
968         * Derived classes must implement this method for the following fields:
969         * TIME_FIELD_ERA, TIME_FIELD_YEAR, TIME_FIELD_MONTH, TIME_FIELD_WEEK_OF_YEAR, TIME_FIELD_WEEK_OF_MONTH,
970         * TIME_FIELD_DAY_OF_MONTH, TIME_FIELD_DAY_OF_YEAR, TIME_FIELD_DAY_OF_WEEK_IN_MONTH, TIME_FIELD_YEAR_WOY,
971         * TIME_FIELD_EXTENDED_YEAR.
972         *
973         * @since                                                2.0
974         *
975         * @return                                               The limit of the specified field
976         * @param[in]                                    field                                           The time field
977         * @param[in]                                    limitType                                       The type of limit
978         */
979         virtual int HandleGetLimit(TimeField field, CalendarLimitType limitType) const = 0;
980
981         /*
982         * Creates and returns a polymorphic copy of this calendar.
983         *
984         * @since                                                2.0
985         *
986         * @return                                       A polymorphic copy of this calendar
987         */
988         virtual Tizen::Locales::Calendar* CloneN(void) const = 0;
989
990         //
991         // This method is for internal use only. Using this method can cause behavioral, security-related,
992         // and consistency-related issues in the application.
993         //
994         // This method is reserved and may change its name at any time without prior notice.
995         //
996         // @since       2.0
997         //
998         virtual void Calendar_Reserved1(void) { }
999
1000         //
1001         // This method is for internal use only. Using this method can cause behavioral, security-related,
1002         // and consistency-related issues in the application.
1003         //
1004         // This method is reserved and may change its name at any time without prior notice.
1005         //
1006         // @since       2.0
1007         //
1008         virtual void Calendar_Reserved2(void) { }
1009
1010         //
1011         // This method is for internal use only. Using this method can cause behavioral, security-related,
1012         // and consistency-related issues in the application.
1013         //
1014         // This method is reserved and may change its name at any time without prior notice.
1015         //
1016         // @since       2.0
1017         //
1018         virtual void Calendar_Reserved3(void) { }
1019
1020         //
1021         // This method is for internal use only. Using this method can cause behavioral, security-related,
1022         // and consistency-related issues in the application.
1023         //
1024         // This method is reserved and may change its name at any time without prior notice.
1025         //
1026         // @since       2.0
1027         //
1028         virtual void Calendar_Reserved4(void) { }
1029
1030         //
1031         // This method is for internal use only. Using this method can cause behavioral, security-related,
1032         // and consistency-related issues in the application.
1033         //
1034         // This method is reserved and may change its name at any time without prior notice.
1035         //
1036         // @since       2.0
1037         //
1038         virtual void Calendar_Reserved5(void) { }
1039
1040 private:
1041         /**
1042          * The implementation of this copy constructor is intentionally blank and declared as private to
1043          * prohibit copying of objects. Use CloneN() to get an exact copy of the instance.
1044          */
1045         Calendar(const Calendar& calendar);
1046
1047         /**
1048          * The implementation of this copy assignment operator is intentionally blank and declared as private
1049          * to prohibit copying of objects. Use CloneN() to get an exact copy of the instance.
1050          */
1051         Calendar& operator =(const Calendar& calendar);
1052
1053 public:
1054         /**
1055          * Millisecond constants for one day.
1056          *
1057          * @since       2.0
1058          */
1059         static const int ONE_DAY_IN_MILLISEC = 86400000;
1060
1061         /**
1062          * Millisecond constants for one hour.
1063          *
1064          * @since       2.0
1065          */
1066         static const int ONE_HOUR_IN_MILLISEC = 60 * 60 * 1000;
1067
1068         /**
1069          * Millisecond constants for one minute.
1070          *
1071          * @since       2.0
1072          */
1073         static const int ONE_MINUTE_IN_MILLISEC = 60000;
1074
1075         /**
1076          * Millisecond constants for one second.
1077          *
1078          * @since       2.0
1079          */
1080         static const int ONE_SECOND_IN_MILLISEC = 1000;
1081
1082         /**
1083          * Millisecond constants for one week.
1084          *
1085          * @since       2.0
1086          */
1087         static const long long ONE_WEEK_IN_MILLISEC = 7 * ONE_DAY_IN_MILLISEC;
1088
1089 protected:
1090         /*
1091          * The field values for the currently set time for this calendar.
1092          */
1093         int _timeFields[TIME_FIELD_FIELD_COUNT];
1094
1095         /*
1096          * Pseudo-time-stamps which specify when each field is set.
1097          * There are two special values - UNSET and INTERNALLY_SET.
1098          */
1099         int _stamp[TIME_FIELD_FIELD_COUNT];
1100
1101         /*
1102          * The flags which tell if a specified time field for the calendar is set.
1103          */
1104         bool _isSet[TIME_FIELD_FIELD_COUNT];
1105
1106         long long _time; // UTC time
1107         Tizen::Locales::TimeZone _timeZone;
1108
1109         bool _isTimeSet;
1110         bool _areFieldsSet;
1111         bool _areAllFieldsSet;
1112         int _nextStamp;
1113         bool _isLenient;
1114         bool _isConstructed;
1115
1116         // Mask values for calendar fields
1117         static const int ERA_MASK = GET_TIME_FIELD_MASK(TIME_FIELD_ERA);
1118         static const int YEAR_MASK = GET_TIME_FIELD_MASK(TIME_FIELD_YEAR);
1119         static const int MONTH_MASK = GET_TIME_FIELD_MASK(TIME_FIELD_MONTH);
1120         static const int WEEK_OF_YEAR_MASK = GET_TIME_FIELD_MASK(TIME_FIELD_WEEK_OF_YEAR);
1121         static const int WEEK_OF_MONTH_MASK = GET_TIME_FIELD_MASK(TIME_FIELD_WEEK_OF_MONTH);
1122         static const int DAY_OF_MONTH_MASK = GET_TIME_FIELD_MASK(TIME_FIELD_DAY_OF_MONTH);
1123         static const int DAY_OF_YEAR_MASK = GET_TIME_FIELD_MASK(TIME_FIELD_DAY_OF_YEAR);
1124         static const int DAY_OF_WEEK_MASK = GET_TIME_FIELD_MASK(TIME_FIELD_DAY_OF_WEEK);
1125         static const int DAY_OF_WEEK_IN_MONTH_MASK = GET_TIME_FIELD_MASK(TIME_FIELD_DAY_OF_WEEK_IN_MONTH);
1126         static const int AM_PM_MASK = GET_TIME_FIELD_MASK(TIME_FIELD_AM_PM);
1127         static const int HOUR_MASK = GET_TIME_FIELD_MASK(TIME_FIELD_HOUR);
1128         static const int HOUR_OF_DAY_MASK = GET_TIME_FIELD_MASK(TIME_FIELD_HOUR_OF_DAY);
1129         static const int MINUTE_MASK = GET_TIME_FIELD_MASK(TIME_FIELD_MINUTE);
1130         static const int SECOND_MASK = GET_TIME_FIELD_MASK(TIME_FIELD_SECOND);
1131         static const int MILLISECOND_MASK = GET_TIME_FIELD_MASK(TIME_FIELD_MILLISECOND);
1132         static const int ZONE_OFFSET_MASK = GET_TIME_FIELD_MASK(TIME_FIELD_ZONE_OFFSET);
1133         static const int DST_OFFSET_MASK = GET_TIME_FIELD_MASK(TIME_FIELD_DST_OFFSET);
1134         static const int ALL_FIELDS = GET_TIME_FIELD_MASK(TIME_FIELD_FIELD_COUNT) - 1;
1135
1136 //private:
1137         friend class _CalendarImpl;
1138         class _CalendarImpl* _pCalendarImpl;
1139
1140 }; // Calendar
1141
1142 }} // Tizen::Locales
1143
1144 #endif //_FLCL_CALENDAR_H_