src/corelib/tools/qdatetime.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
   4 ** Contact: http://www.qt-project.org/legal
   5 **
   6 ** This file is part of the QtCore module of the Qt Toolkit.
   7 **
   8 ** $QT_BEGIN_LICENSE:LGPL$
   9 ** Commercial License Usage
  10 ** Licensees holding valid commercial Qt licenses may use this file in
  11 ** accordance with the commercial license agreement provided with the
  12 ** Software or, alternatively, in accordance with the terms contained in
  13 ** a written agreement between you and Digia.  For licensing terms and
  14 ** conditions see http://qt.digia.com/licensing.  For further information
  15 ** use the contact form at http://qt.digia.com/contact-us.
  16 **
  17 ** GNU Lesser General Public License Usage
  18 ** Alternatively, this file may be used under the terms of the GNU Lesser
  19 ** General Public License version 2.1 as published by the Free Software
  20 ** Foundation and appearing in the file LICENSE.LGPL included in the
  21 ** packaging of this file.  Please review the following information to
  22 ** ensure the GNU Lesser General Public License version 2.1 requirements
  23 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  24 **
  25 ** In addition, as a special exception, Digia gives you certain additional
  26 ** rights.  These rights are described in the Digia Qt LGPL Exception
  27 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  28 **
  29 ** GNU General Public License Usage
  30 ** Alternatively, this file may be used under the terms of the GNU
  31 ** General Public License version 3.0 as published by the Free Software
  32 ** Foundation and appearing in the file LICENSE.GPL included in the
  33 ** packaging of this file.  Please review the following information to
  34 ** ensure the GNU General Public License version 3.0 requirements will be
  35 ** met: http://www.gnu.org/copyleft/gpl.html.
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 #include "qplatformdefs.h"
  43 #include "private/qdatetime_p.h"
  44
  45 #include "qdatastream.h"
  46 #include "qset.h"
  47 #include "qlocale.h"
  48 #include "qdatetime.h"
  49 #include "qregexp.h"
  50 #include "qdebug.h"
  51 #if defined(Q_OS_WIN32) || defined(Q_OS_WINCE)
  52 #include <qt_windows.h>
  53 #endif
  54 #ifndef Q_WS_WIN
  55 #include <locale.h>
  56 #endif
  57
  58 #include <time.h>
  59 #if defined(Q_OS_WINCE)
  60 #include "qfunctions_wince.h"
  61 #endif
  62
  63 //#define QDATETIMEPARSER_DEBUG
  64 #if defined (QDATETIMEPARSER_DEBUG) && !defined(QT_NO_DEBUG_STREAM)
  65 #  define QDTPDEBUG qDebug() << QString("%1:%2").arg(__FILE__).arg(__LINE__)
  66 #  define QDTPDEBUGN qDebug
  67 #else
  68 #  define QDTPDEBUG if (false) qDebug()
  69 #  define QDTPDEBUGN if (false) qDebug
  70 #endif
  71
  72 #if defined(Q_WS_MAC)
  73 #include <private/qcore_mac_p.h>
  74 #endif
  75
  76 #if defined(Q_OS_SYMBIAN)
  77 #include <e32std.h>
  78 #include <tz.h>
  79 #endif
  80
  81 QT_BEGIN_NAMESPACE
  82
  83 enum {
  84     FIRST_YEAR = -4713,
  85     FIRST_MONTH = 1,
  86     FIRST_DAY = 2,  // ### Qt 5: make FIRST_DAY = 1, by support jd == 0 as valid
  87     SECS_PER_DAY = 86400,
  88     MSECS_PER_DAY = 86400000,
  89     SECS_PER_HOUR = 3600,
  90     MSECS_PER_HOUR = 3600000,
  91     SECS_PER_MIN = 60,
  92     MSECS_PER_MIN = 60000,
  93     JULIAN_DAY_FOR_EPOCH = 2440588 // result of julianDayFromGregorianDate(1970, 1, 1)
  94 };
  95
  96 static inline QDate fixedDate(int y, int m, int d)
  97 {
  98     QDate result(y, m, 1);
  99     result.setDate(y, m, qMin(d, result.daysInMonth()));
 100     return result;
 101 }
 102
 103 static inline uint julianDayFromGregorianDate(int year, int month, int day)
 104 {
 105     // Gregorian calendar starting from October 15, 1582
 106     // Algorithm from Henry F. Fliegel and Thomas C. Van Flandern
 107     return (1461 * (year + 4800 + (month - 14) / 12)) / 4
 108            + (367 * (month - 2 - 12 * ((month - 14) / 12))) / 12
 109            - (3 * ((year + 4900 + (month - 14) / 12) / 100)) / 4
 110            + day - 32075;
 111 }
 112
 113 static uint julianDayFromDate(int year, int month, int day)
 114 {
 115     if (year < 0)
 116         ++year;
 117
 118     if (year > 1582 || (year == 1582 && (month > 10 || (month == 10 && day >= 15)))) {
 119         return julianDayFromGregorianDate(year, month, day);
 120     } else if (year < 1582 || (year == 1582 && (month < 10 || (month == 10 && day <= 4)))) {
 121         // Julian calendar until October 4, 1582
 122         // Algorithm from Frequently Asked Questions about Calendars by Claus Toendering
 123         int a = (14 - month) / 12;
 124         return (153 * (month + (12 * a) - 3) + 2) / 5
 125                + (1461 * (year + 4800 - a)) / 4
 126                + day - 32083;
 127     } else {
 128         // the day following October 4, 1582 is October 15, 1582
 129         return 0;
 130     }
 131 }
 132
 133 static void getDateFromJulianDay(uint julianDay, int *year, int *month, int *day)
 134 {
 135     int y, m, d;
 136
 137     if (julianDay >= 2299161) {
 138         // Gregorian calendar starting from October 15, 1582
 139         // This algorithm is from Henry F. Fliegel and Thomas C. Van Flandern
 140         qulonglong ell, n, i, j;
 141         ell = qulonglong(julianDay) + 68569;
 142         n = (4 * ell) / 146097;
 143         ell = ell - (146097 * n + 3) / 4;
 144         i = (4000 * (ell + 1)) / 1461001;
 145         ell = ell - (1461 * i) / 4 + 31;
 146         j = (80 * ell) / 2447;
 147         d = ell - (2447 * j) / 80;
 148         ell = j / 11;
 149         m = j + 2 - (12 * ell);
 150         y = 100 * (n - 49) + i + ell;
 151     } else {
 152         // Julian calendar until October 4, 1582
 153         // Algorithm from Frequently Asked Questions about Calendars by Claus Toendering
 154         julianDay += 32082;
 155         int dd = (4 * julianDay + 3) / 1461;
 156         int ee = julianDay - (1461 * dd) / 4;
 157         int mm = ((5 * ee) + 2) / 153;
 158         d = ee - (153 * mm + 2) / 5 + 1;
 159         m = mm + 3 - 12 * (mm / 10);
 160         y = dd - 4800 + (mm / 10);
 161         if (y <= 0)
 162             --y;
 163     }
 164     if (year)
 165         *year = y;
 166     if (month)
 167         *month = m;
 168     if (day)
 169         *day = d;
 170 }
 171
 172
 173 static const char monthDays[] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
 174
 175 #ifndef QT_NO_TEXTDATE
 176 static const char * const qt_shortMonthNames[] = {
 177     "Jan", "Feb", "Mar", "Apr", "May", "Jun",
 178     "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
 179 #endif
 180 #ifndef QT_NO_DATESTRING
 181 static QString fmtDateTime(const QString& f, const QTime* dt = 0, const QDate* dd = 0);
 182 #endif
 183
 184 /*****************************************************************************
 185   QDate member functions
 186  *****************************************************************************/
 187
 188 /*!
 189     \since 4.5
 190
 191     \enum QDate::MonthNameType
 192
 193     This enum describes the types of the string representation used
 194     for the month name.
 195
 196     \value DateFormat This type of name can be used for date-to-string formatting.
 197     \value StandaloneFormat This type is used when you need to enumerate months or weekdays.
 198            Usually standalone names are represented in singular forms with
 199            capitalized first letter.
 200 */
 201
 202 /*!
 203     \class QDate
 204     \reentrant
 205     \brief The QDate class provides date functions.
 206
 207
 208     A QDate object contains a calendar date, i.e. year, month, and day
 209     numbers, in the Gregorian calendar. (see \l{QDate G and J} {Use of
 210     Gregorian and Julian Calendars} for dates prior to 15 October
 211     1582). It can read the current date from the system clock. It
 212     provides functions for comparing dates, and for manipulating
 213     dates. For example, it is possible to add and subtract days,
 214     months, and years to dates.
 215
 216     A QDate object is typically created either by giving the year,
 217     month, and day numbers explicitly. Note that QDate interprets two
 218     digit years as is, i.e., years 0 - 99. A QDate can also be
 219     constructed with the static function currentDate(), which creates
 220     a QDate object containing the system clock's date.  An explicit
 221     date can also be set using setDate(). The fromString() function
 222     returns a QDate given a string and a date format which is used to
 223     interpret the date within the string.
 224
 225     The year(), month(), and day() functions provide access to the
 226     year, month, and day numbers. Also, dayOfWeek() and dayOfYear()
 227     functions are provided. The same information is provided in
 228     textual format by the toString(), shortDayName(), longDayName(),
 229     shortMonthName(), and longMonthName() functions.
 230
 231     QDate provides a full set of operators to compare two QDate
 232     objects where smaller means earlier, and larger means later.
 233
 234     You can increment (or decrement) a date by a given number of days
 235     using addDays(). Similarly you can use addMonths() and addYears().
 236     The daysTo() function returns the number of days between two
 237     dates.
 238
 239     The daysInMonth() and daysInYear() functions return how many days
 240     there are in this date's month and year, respectively. The
 241     isLeapYear() function indicates whether a date is in a leap year.
 242
 243     \section1
 244
 245     \target QDate G and J
 246     \section2 Use of Gregorian and Julian Calendars
 247
 248     QDate uses the Gregorian calendar in all locales, beginning
 249     on the date 15 October 1582. For dates up to and including 4
 250     October 1582, the Julian calendar is used.  This means there is a
 251     10-day gap in the internal calendar between the 4th and the 15th
 252     of October 1582. When you use QDateTime for dates in that epoch,
 253     the day after 4 October 1582 is 15 October 1582, and the dates in
 254     the gap are invalid.
 255
 256     The Julian to Gregorian changeover date used here is the date when
 257     the Gregorian calendar was first introduced, by Pope Gregory
 258     XIII. That change was not universally accepted and some localities
 259     only executed it at a later date (if at all).  QDateTime
 260     doesn't take any of these historical facts into account. If an
 261     application must support a locale-specific dating system, it must
 262     do so on its own, remembering to convert the dates using the
 263     Julian day.
 264
 265     \section2 No Year 0
 266
 267     There is no year 0. Dates in that year are considered invalid. The
 268     year -1 is the year "1 before Christ" or "1 before current era."
 269     The day before 0001-01-01 is December 31st, 1 BCE.
 270
 271     \section2 Range of Valid Dates
 272
 273     The range of valid dates is from January 2nd, 4713 BCE, to
 274     sometime in the year 11 million CE. The Julian Day returned by
 275     QDate::toJulianDay() is a number in the contiguous range from 1 to
 276     \e{overflow}, even across QDateTime's "date holes". It is suitable
 277     for use in applications that must convert a QDateTime to a date in
 278     another calendar system, e.g., Hebrew, Islamic or Chinese.
 279
 280     \sa QTime, QDateTime, QDateEdit, QDateTimeEdit, QCalendarWidget
 281 */
 282
 283 /*!
 284     \fn QDate::QDate()
 285
 286     Constructs a null date. Null dates are invalid.
 287
 288     \sa isNull(), isValid()
 289 */
 290
 291 /*!
 292     Constructs a date with year \a y, month \a m and day \a d.
 293
 294     If the specified date is invalid, the date is not set and
 295     isValid() returns false. A date before 2 January 4713 B.C. is
 296     considered invalid.
 297
 298     \warning Years 0 to 99 are interpreted as is, i.e., years
 299              0-99.
 300
 301     \sa isValid()
 302 */
 303
 304 QDate::QDate(int y, int m, int d)
 305 {
 306     setDate(y, m, d);
 307 }
 308
 309
 310 /*!
 311     \fn bool QDate::isNull() const
 312
 313     Returns true if the date is null; otherwise returns false. A null
 314     date is invalid.
 315
 316     \note The behavior of this function is equivalent to isValid().
 317
 318     \sa isValid()
 319 */
 320
 321
 322 /*!
 323     Returns true if this date is valid; otherwise returns false.
 324
 325     \sa isNull()
 326 */
 327
 328 bool QDate::isValid() const
 329 {
 330     return !isNull();
 331 }
 332
 333
 334 /*!
 335     Returns the year of this date. Negative numbers indicate years
 336     before 1 A.D. = 1 C.E., such that year -44 is 44 B.C.
 337
 338     \sa month(), day()
 339 */
 340
 341 int QDate::year() const
 342 {
 343     int y;
 344     getDateFromJulianDay(jd, &y, 0, 0);
 345     return y;
 346 }
 347
 348 /*!
 349     Returns the number corresponding to the month of this date, using
 350     the following convention:
 351
 352     \list
 353     \i 1 = "January"
 354     \i 2 = "February"
 355     \i 3 = "March"
 356     \i 4 = "April"
 357     \i 5 = "May"
 358     \i 6 = "June"
 359     \i 7 = "July"
 360     \i 8 = "August"
 361     \i 9 = "September"
 362     \i 10 = "October"
 363     \i 11 = "November"
 364     \i 12 = "December"
 365     \endlist
 366
 367     \sa year(), day()
 368 */
 369
 370 int QDate::month() const
 371 {
 372     int m;
 373     getDateFromJulianDay(jd, 0, &m, 0);
 374     return m;
 375 }
 376
 377 /*!
 378     Returns the day of the month (1 to 31) of this date.
 379
 380     \sa year(), month(), dayOfWeek()
 381 */
 382
 383 int QDate::day() const
 384 {
 385     int d;
 386     getDateFromJulianDay(jd, 0, 0, &d);
 387     return d;
 388 }
 389
 390 /*!
 391     Returns the weekday (1 = Monday to 7 = Sunday) for this date.
 392
 393     \sa day(), dayOfYear(), Qt::DayOfWeek
 394 */
 395
 396 int QDate::dayOfWeek() const
 397 {
 398     return (jd % 7) + 1;
 399 }
 400
 401 /*!
 402     Returns the day of the year (1 to 365 or 366 on leap years) for
 403     this date.
 404
 405     \sa day(), dayOfWeek()
 406 */
 407
 408 int QDate::dayOfYear() const
 409 {
 410     return jd - julianDayFromDate(year(), 1, 1) + 1;
 411 }
 412
 413 /*!
 414     Returns the number of days in the month (28 to 31) for this date.
 415
 416     \sa day(), daysInYear()
 417 */
 418
 419 int QDate::daysInMonth() const
 420 {
 421     int y, m, d;
 422     getDateFromJulianDay(jd, &y, &m, &d);
 423     if (m == 2 && isLeapYear(y))
 424         return 29;
 425     else
 426         return monthDays[m];
 427 }
 428
 429 /*!
 430     Returns the number of days in the year (365 or 366) for this date.
 431
 432     \sa day(), daysInMonth()
 433 */
 434
 435 int QDate::daysInYear() const
 436 {
 437     int y, m, d;
 438     getDateFromJulianDay(jd, &y, &m, &d);
 439     return isLeapYear(y) ? 366 : 365;
 440 }
 441
 442 /*!
 443     Returns the week number (1 to 53), and stores the year in
 444     *\a{yearNumber} unless \a yearNumber is null (the default).
 445
 446     Returns 0 if the date is invalid.
 447
 448     In accordance with ISO 8601, weeks start on Monday and the first
 449     Thursday of a year is always in week 1 of that year. Most years
 450     have 52 weeks, but some have 53.
 451
 452     *\a{yearNumber} is not always the same as year(). For example, 1
 453     January 2000 has week number 52 in the year 1999, and 31 December
 454     2002 has week number 1 in the year 2003.
 455
 456     \sa isValid()
 457 */
 458
 459 int QDate::weekNumber(int *yearNumber) const
 460 {
 461     if (!isValid())
 462         return 0;
 463
 464     int year = QDate::year();
 465     int yday = dayOfYear();
 466     int wday = dayOfWeek();
 467
 468     int week = (yday - wday + 10) / 7;
 469
 470     if (week == 0) {
 471         // last week of previous year
 472         --year;
 473         week = (yday + 365 + (QDate::isLeapYear(year) ? 1 : 0) - wday + 10) / 7;
 474         Q_ASSERT(week == 52 || week == 53);
 475     } else if (week == 53) {
 476         // maybe first week of next year
 477         int w = (yday - 365 - (QDate::isLeapYear(year + 1) ? 1 : 0) - wday + 10) / 7;
 478         if (w > 0) {
 479             ++year;
 480             week = w;
 481         }
 482         Q_ASSERT(week == 53 || week == 1);
 483     }
 484
 485     if (yearNumber != 0)
 486         *yearNumber = year;
 487     return week;
 488 }
 489
 490 #ifndef QT_NO_TEXTDATE
 491 /*!
 492     \since 4.5
 493
 494     Returns the short name of the \a month for the representation specified
 495     by \a type.
 496
 497     The months are enumerated using the following convention:
 498
 499     \list
 500     \i 1 = "Jan"
 501     \i 2 = "Feb"
 502     \i 3 = "Mar"
 503     \i 4 = "Apr"
 504     \i 5 = "May"
 505     \i 6 = "Jun"
 506     \i 7 = "Jul"
 507     \i 8 = "Aug"
 508     \i 9 = "Sep"
 509     \i 10 = "Oct"
 510     \i 11 = "Nov"
 511     \i 12 = "Dec"
 512     \endlist
 513
 514     The month names will be localized according to the system's default
 515     locale settings.
 516
 517     \sa toString(), longMonthName(), shortDayName(), longDayName()
 518 */
 519
 520 QString QDate::shortMonthName(int month, QDate::MonthNameType type)
 521 {
 522     if (month < 1 || month > 12) {
 523         month = 1;
 524     }
 525     switch (type) {
 526     case QDate::DateFormat:
 527         return QLocale::system().monthName(month, QLocale::ShortFormat);
 528     case QDate::StandaloneFormat:
 529         return QLocale::system().standaloneMonthName(month, QLocale::ShortFormat);
 530     default:
 531         break;
 532     }
 533     return QString();
 534 }
 535
 536 /*!
 537     Returns the short version of the name of the \a month. The
 538     returned name is in normal type which can be used for date formatting.
 539
 540     \sa toString(), longMonthName(), shortDayName(), longDayName()
 541  */
 542
 543 QString QDate::shortMonthName(int month)
 544 {
 545     return shortMonthName(month, QDate::DateFormat);
 546 }
 547
 548 /*!
 549     \since 4.5
 550
 551     Returns the long name of the \a month for the representation specified
 552     by \a type.
 553
 554     The months are enumerated using the following convention:
 555
 556     \list
 557     \i 1 = "January"
 558     \i 2 = "February"
 559     \i 3 = "March"
 560     \i 4 = "April"
 561     \i 5 = "May"
 562     \i 6 = "June"
 563     \i 7 = "July"
 564     \i 8 = "August"
 565     \i 9 = "September"
 566     \i 10 = "October"
 567     \i 11 = "November"
 568     \i 12 = "December"
 569     \endlist
 570
 571     The month names will be localized according to the system's default
 572     locale settings.
 573
 574     \sa toString(), shortMonthName(), shortDayName(), longDayName()
 575 */
 576
 577 QString QDate::longMonthName(int month, MonthNameType type)
 578 {
 579     if (month < 1 || month > 12) {
 580         month = 1;
 581     }
 582     switch (type) {
 583     case QDate::DateFormat:
 584         return QLocale::system().monthName(month, QLocale::LongFormat);
 585     case QDate::StandaloneFormat:
 586         return QLocale::system().standaloneMonthName(month, QLocale::LongFormat);
 587     default:
 588         break;
 589     }
 590     return QString();
 591 }
 592
 593 /*!
 594     Returns the long version of the name of the \a month. The
 595     returned name is in normal type which can be used for date formatting.
 596
 597     \sa toString(), shortMonthName(), shortDayName(), longDayName()
 598  */
 599
 600 QString QDate::longMonthName(int month)
 601 {
 602     if (month < 1 || month > 12) {
 603         month = 1;
 604     }
 605     return QLocale::system().monthName(month, QLocale::LongFormat);
 606 }
 607
 608 /*!
 609     \since 4.5
 610
 611     Returns the short name of the \a weekday for the representation specified
 612     by \a type.
 613
 614     The days are enumerated using the following convention:
 615
 616     \list
 617     \i 1 = "Mon"
 618     \i 2 = "Tue"
 619     \i 3 = "Wed"
 620     \i 4 = "Thu"
 621     \i 5 = "Fri"
 622     \i 6 = "Sat"
 623     \i 7 = "Sun"
 624     \endlist
 625
 626     The day names will be localized according to the system's default
 627     locale settings.
 628
 629     \sa toString(), shortMonthName(), longMonthName(), longDayName()
 630 */
 631
 632 QString QDate::shortDayName(int weekday, MonthNameType type)
 633 {
 634     if (weekday < 1 || weekday > 7) {
 635         weekday = 1;
 636     }
 637     switch (type) {
 638     case QDate::DateFormat:
 639         return QLocale::system().dayName(weekday, QLocale::ShortFormat);
 640     case QDate::StandaloneFormat:
 641         return QLocale::system().standaloneDayName(weekday, QLocale::ShortFormat);
 642     default:
 643         break;
 644     }
 645     return QString();
 646 }
 647
 648 /*!
 649     Returns the short version of the name of the \a weekday. The
 650     returned name is in normal type which can be used for date formatting.
 651
 652     \sa toString(), longDayName(), shortMonthName(), longMonthName()
 653  */
 654
 655 QString QDate::shortDayName(int weekday)
 656 {
 657     if (weekday < 1 || weekday > 7) {
 658         weekday = 1;
 659     }
 660     return QLocale::system().dayName(weekday, QLocale::ShortFormat);
 661 }
 662
 663 /*!
 664     \since 4.5
 665
 666     Returns the long name of the \a weekday for the representation specified
 667     by \a type.
 668
 669     The days are enumerated using the following convention:
 670
 671     \list
 672     \i 1 = "Monday"
 673     \i 2 = "Tuesday"
 674     \i 3 = "Wednesday"
 675     \i 4 = "Thursday"
 676     \i 5 = "Friday"
 677     \i 6 = "Saturday"
 678     \i 7 = "Sunday"
 679     \endlist
 680
 681     The day names will be localized according to the system's default
 682     locale settings.
 683
 684     \sa toString(), shortDayName(), shortMonthName(), longMonthName()
 685 */
 686
 687 QString QDate::longDayName(int weekday, MonthNameType type)
 688 {
 689     if (weekday < 1 || weekday > 7) {
 690         weekday = 1;
 691     }
 692     switch (type) {
 693     case QDate::DateFormat:
 694         return QLocale::system().dayName(weekday, QLocale::LongFormat);
 695     case QDate::StandaloneFormat:
 696         return QLocale::system().standaloneDayName(weekday, QLocale::LongFormat);
 697     default:
 698         break;
 699     }
 700     return QLocale::system().dayName(weekday, QLocale::LongFormat);
 701 }
 702
 703 /*!
 704     Returns the long version of the name of the \a weekday. The
 705     returned name is in normal type which can be used for date formatting.
 706
 707     \sa toString(), shortDayName(), shortMonthName(), longMonthName()
 708  */
 709
 710 QString QDate::longDayName(int weekday)
 711 {
 712     if (weekday < 1 || weekday > 7) {
 713         weekday = 1;
 714     }
 715     return QLocale::system().dayName(weekday, QLocale::LongFormat);
 716 }
 717 #endif //QT_NO_TEXTDATE
 718
 719 #ifndef QT_NO_DATESTRING
 720
 721 /*!
 722     \fn QString QDate::toString(Qt::DateFormat format) const
 723
 724     \overload
 725
 726     Returns the date as a string. The \a format parameter determines
 727     the format of the string.
 728
 729     If the \a format is Qt::TextDate, the string is formatted in
 730     the default way. QDate::shortDayName() and QDate::shortMonthName()
 731     are used to generate the string, so the day and month names will
 732     be localized names using the default locale from the system. An
 733     example of this formatting is "Sat May 20 1995".
 734
 735     If the \a format is Qt::ISODate, the string format corresponds
 736     to the ISO 8601 extended specification for representations of
 737     dates and times, taking the form YYYY-MM-DD, where YYYY is the
 738     year, MM is the month of the year (between 01 and 12), and DD is
 739     the day of the month between 01 and 31.
 740
 741     If the \a format is Qt::SystemLocaleShortDate or
 742     Qt::SystemLocaleLongDate, the string format depends on the locale
 743     settings of the system. Identical to calling
 744     QLocale::system().toString(date, QLocale::ShortFormat) or
 745     QLocale::system().toString(date, QLocale::LongFormat).
 746
 747     If the \a format is Qt::DefaultLocaleShortDate or
 748     Qt::DefaultLocaleLongDate, the string format depends on the
 749     default application locale. This is the locale set with
 750     QLocale::setDefault(), or the system locale if no default locale
 751     has been set. Identical to calling QLocale().toString(date,
 752     QLocale::ShortFormat) or QLocale().toString(date,
 753     QLocale::LongFormat).
 754
 755     If the date is invalid, an empty string will be returned.
 756
 757     \warning The Qt::ISODate format is only valid for years in the
 758     range 0 to 9999. This restriction may apply to locale-aware
 759     formats as well, depending on the locale settings.
 760
 761     \sa shortDayName(), shortMonthName()
 762 */
 763 QString QDate::toString(Qt::DateFormat f) const
 764 {
 765     if (!isValid())
 766         return QString();
 767     int y, m, d;
 768     getDateFromJulianDay(jd, &y, &m, &d);
 769     switch (f) {
 770     case Qt::SystemLocaleDate:
 771     case Qt::SystemLocaleShortDate:
 772     case Qt::SystemLocaleLongDate:
 773         return QLocale::system().toString(*this, f == Qt::SystemLocaleLongDate ? QLocale::LongFormat
 774                                                                                : QLocale::ShortFormat);
 775     case Qt::LocaleDate:
 776     case Qt::DefaultLocaleShortDate:
 777     case Qt::DefaultLocaleLongDate:
 778         return QLocale().toString(*this, f == Qt::DefaultLocaleLongDate ? QLocale::LongFormat
 779                                                                         : QLocale::ShortFormat);
 780     default:
 781 #ifndef QT_NO_TEXTDATE
 782     case Qt::TextDate:
 783         {
 784             return QString::fromLatin1("%0 %1 %2 %3")
 785                 .arg(shortDayName(dayOfWeek()))
 786                 .arg(shortMonthName(m))
 787                 .arg(d)
 788                 .arg(y);
 789         }
 790 #endif
 791     case Qt::ISODate:
 792         {
 793             if (year() < 0 || year() > 9999)
 794                 return QString();
 795             QString month(QString::number(m).rightJustified(2, QLatin1Char('0')));
 796             QString day(QString::number(d).rightJustified(2, QLatin1Char('0')));
 797             return QString::number(y) + QLatin1Char('-') + month + QLatin1Char('-') + day;
 798         }
 799     }
 800 }
 801
 802 /*!
 803     Returns the date as a string. The \a format parameter determines
 804     the format of the result string.
 805
 806     These expressions may be used:
 807
 808     \table
 809     \header \i Expression \i Output
 810     \row \i d \i the day as number without a leading zero (1 to 31)
 811     \row \i dd \i the day as number with a leading zero (01 to 31)
 812     \row \i ddd
 813          \i the abbreviated localized day name (e.g. 'Mon' to 'Sun').
 814             Uses QDate::shortDayName().
 815     \row \i dddd
 816          \i the long localized day name (e.g. 'Monday' to 'Sunday').
 817             Uses QDate::longDayName().
 818     \row \i M \i the month as number without a leading zero (1 to 12)
 819     \row \i MM \i the month as number with a leading zero (01 to 12)
 820     \row \i MMM
 821          \i the abbreviated localized month name (e.g. 'Jan' to 'Dec').
 822             Uses QDate::shortMonthName().
 823     \row \i MMMM
 824          \i the long localized month name (e.g. 'January' to 'December').
 825             Uses QDate::longMonthName().
 826     \row \i yy \i the year as two digit number (00 to 99)
 827     \row \i yyyy \i the year as four digit number. If the year is negative,
 828             a minus sign is prepended in addition.
 829     \endtable
 830
 831     All other input characters will be ignored. Any sequence of characters that
 832     are enclosed in singlequotes will be treated as text and not be used as an
 833     expression. Two consecutive singlequotes ("''") are replaced by a singlequote
 834     in the output.
 835
 836     Example format strings (assuming that the QDate is the 20 July
 837     1969):
 838
 839     \table
 840     \header \o Format            \o Result
 841     \row    \o dd.MM.yyyy        \o 20.07.1969
 842     \row    \o ddd MMMM d yy     \o Sun July 20 69
 843     \row    \o 'The day is' dddd \o The day is Sunday
 844     \endtable
 845
 846     If the datetime is invalid, an empty string will be returned.
 847
 848     \warning The Qt::ISODate format is only valid for years in the
 849     range 0 to 9999. This restriction may apply to locale-aware
 850     formats as well, depending on the locale settings.
 851
 852     \sa QDateTime::toString() QTime::toString()
 853
 854 */
 855 QString QDate::toString(const QString& format) const
 856 {
 857     if (year() > 9999)
 858         return QString();
 859     return fmtDateTime(format, 0, this);
 860 }
 861 #endif //QT_NO_DATESTRING
 862
 863 /*!
 864     \obsolete
 865
 866     Sets the date's year \a y, month \a m, and day \a d.
 867
 868     If \a y is in the range 0 to 99, it is interpreted as 1900 to
 869     1999.
 870
 871     Use setDate() instead.
 872 */
 873
 874 bool QDate::setYMD(int y, int m, int d)
 875 {
 876     if (uint(y) <= 99)
 877         y += 1900;
 878     return setDate(y, m, d);
 879 }
 880
 881 /*!
 882     \since 4.2
 883
 884     Sets the date's \a year, \a month, and \a day. Returns true if
 885     the date is valid; otherwise returns false.
 886
 887     If the specified date is invalid, the QDate object is set to be
 888     invalid. Any date before 2 January 4713 B.C. is considered
 889     invalid.
 890
 891     \sa isValid()
 892 */
 893 bool QDate::setDate(int year, int month, int day)
 894 {
 895     if (!isValid(year, month, day)) {
 896         jd = 0;
 897     } else {
 898         jd = julianDayFromDate(year, month, day);
 899     }
 900     return jd != 0;
 901 }
 902
 903 /*!
 904     \since 4.5
 905
 906     Extracts the date's year, month, and day, and assigns them to
 907     *\a year, *\a month, and *\a day. The pointers may be null.
 908
 909     \sa year(), month(), day(), isValid()
 910 */
 911 void QDate::getDate(int *year, int *month, int *day)
 912 {
 913     getDateFromJulianDay(jd, year, month, day);
 914 }
 915
 916 /*!
 917     Returns a QDate object containing a date \a ndays later than the
 918     date of this object (or earlier if \a ndays is negative).
 919
 920     \sa addMonths() addYears() daysTo()
 921 */
 922
 923 QDate QDate::addDays(int ndays) const
 924 {
 925     QDate d;
 926     // this is basically "d.jd = jd + ndays" with checks for integer overflow
 927     if (ndays >= 0)
 928         d.jd = (jd + ndays >= jd) ? jd + ndays : 0;
 929     else
 930         d.jd = (jd + ndays < jd) ? jd + ndays : 0;
 931     return d;
 932 }
 933
 934 /*!
 935     Returns a QDate object containing a date \a nmonths later than the
 936     date of this object (or earlier if \a nmonths is negative).
 937
 938     \note If the ending day/month combination does not exist in the
 939     resulting month/year, this function will return a date that is the
 940     latest valid date.
 941
 942     \warning QDate has a date hole around the days introducing the
 943     Gregorian calendar (the days 5 to 14 October 1582, inclusive, do
 944     not exist). If the calculation ends in one of those days, QDate
 945     will return either October 4 or October 15.
 946
 947     \sa addDays() addYears()
 948 */
 949
 950 QDate QDate::addMonths(int nmonths) const
 951 {
 952     if (!isValid())
 953         return QDate();
 954     if (!nmonths)
 955         return *this;
 956
 957     int old_y, y, m, d;
 958     getDateFromJulianDay(jd, &y, &m, &d);
 959     old_y = y;
 960
 961     bool increasing = nmonths > 0;
 962
 963     while (nmonths != 0) {
 964         if (nmonths < 0 && nmonths + 12 <= 0) {
 965             y--;
 966             nmonths+=12;
 967         } else if (nmonths < 0) {
 968             m+= nmonths;
 969             nmonths = 0;
 970             if (m <= 0) {
 971                 --y;
 972                 m += 12;
 973             }
 974         } else if (nmonths - 12 >= 0) {
 975             y++;
 976             nmonths -= 12;
 977         } else if (m == 12) {
 978             y++;
 979             m = 0;
 980         } else {
 981             m += nmonths;
 982             nmonths = 0;
 983             if (m > 12) {
 984                 ++y;
 985                 m -= 12;
 986             }
 987         }
 988     }
 989
 990     // was there a sign change?
 991     if ((old_y > 0 && y <= 0) ||
 992         (old_y < 0 && y >= 0))
 993         // yes, adjust the date by +1 or -1 years
 994         y += increasing ? +1 : -1;
 995
 996     // did we end up in the Gregorian/Julian conversion hole?
 997     if (y == 1582 && m == 10 && d > 4 && d < 15)
 998         d = increasing ? 15 : 4;
 999
1000     return fixedDate(y, m, d);
1001 }
1002
1003 /*!
1004     Returns a QDate object containing a date \a nyears later than the
1005     date of this object (or earlier if \a nyears is negative).
1006
1007     \note If the ending day/month combination does not exist in the
1008     resulting year (i.e., if the date was Feb 29 and the final year is
1009     not a leap year), this function will return a date that is the
1010     latest valid date (that is, Feb 28).
1011
1012     \sa addDays(), addMonths()
1013 */
1014
1015 QDate QDate::addYears(int nyears) const
1016 {
1017     if (!isValid())
1018         return QDate();
1019
1020     int y, m, d;
1021     getDateFromJulianDay(jd, &y, &m, &d);
1022
1023     int old_y = y;
1024     y += nyears;
1025
1026     // was there a sign change?
1027     if ((old_y > 0 && y <= 0) ||
1028         (old_y < 0 && y >= 0))
1029         // yes, adjust the date by +1 or -1 years
1030         y += nyears > 0 ? +1 : -1;
1031
1032     return fixedDate(y, m, d);
1033 }
1034
1035 /*!
1036     Returns the number of days from this date to \a d (which is
1037     negative if \a d is earlier than this date).
1038
1039     Example:
1040     \snippet doc/src/snippets/code/src_corelib_tools_qdatetime.cpp 0
1041
1042     \sa addDays()
1043 */
1044
1045 int QDate::daysTo(const QDate &d) const
1046 {
1047     return d.jd - jd;
1048 }
1049
1050
1051 /*!
1052     \fn bool QDate::operator==(const QDate &d) const
1053
1054     Returns true if this date is equal to \a d; otherwise returns
1055     false.
1056
1057 */
1058
1059 /*!
1060     \fn bool QDate::operator!=(const QDate &d) const
1061
1062     Returns true if this date is different from \a d; otherwise
1063     returns false.
1064 */
1065
1066 /*!
1067     \fn bool QDate::operator<(const QDate &d) const
1068
1069     Returns true if this date is earlier than \a d; otherwise returns
1070     false.
1071 */
1072
1073 /*!
1074     \fn bool QDate::operator<=(const QDate &d) const
1075
1076     Returns true if this date is earlier than or equal to \a d;
1077     otherwise returns false.
1078 */
1079
1080 /*!
1081     \fn bool QDate::operator>(const QDate &d) const
1082
1083     Returns true if this date is later than \a d; otherwise returns
1084     false.
1085 */
1086
1087 /*!
1088     \fn bool QDate::operator>=(const QDate &d) const
1089
1090     Returns true if this date is later than or equal to \a d;
1091     otherwise returns false.
1092 */
1093
1094 /*!
1095     \fn QDate::currentDate()
1096     Returns the current date, as reported by the system clock.
1097
1098     \sa QTime::currentTime(), QDateTime::currentDateTime()
1099 */
1100
1101 #ifndef QT_NO_DATESTRING
1102 /*!
1103     \fn QDate QDate::fromString(const QString &string, Qt::DateFormat format)
1104
1105     Returns the QDate represented by the \a string, using the
1106     \a format given, or an invalid date if the string cannot be
1107     parsed.
1108
1109     Note for Qt::TextDate: It is recommended that you use the
1110     English short month names (e.g. "Jan"). Although localized month
1111     names can also be used, they depend on the user's locale settings.
1112 */
1113 QDate QDate::fromString(const QString& s, Qt::DateFormat f)
1114 {
1115     if (s.isEmpty())
1116         return QDate();
1117
1118     switch (f) {
1119     case Qt::ISODate:
1120         {
1121             int year(s.mid(0, 4).toInt());
1122             int month(s.mid(5, 2).toInt());
1123             int day(s.mid(8, 2).toInt());
1124             if (year && month && day)
1125                 return QDate(year, month, day);
1126         }
1127         break;
1128     case Qt::SystemLocaleDate:
1129     case Qt::SystemLocaleShortDate:
1130     case Qt::SystemLocaleLongDate:
1131         return fromString(s, QLocale::system().dateFormat(f == Qt::SystemLocaleLongDate ? QLocale::LongFormat
1132                                                                                         : QLocale::ShortFormat));
1133     case Qt::LocaleDate:
1134     case Qt::DefaultLocaleShortDate:
1135     case Qt::DefaultLocaleLongDate:
1136         return fromString(s, QLocale().dateFormat(f == Qt::DefaultLocaleLongDate ? QLocale::LongFormat
1137                                                                                  : QLocale::ShortFormat));
1138     default:
1139 #ifndef QT_NO_TEXTDATE
1140     case Qt::TextDate: {
1141         QStringList parts = s.split(QLatin1Char(' '), QString::SkipEmptyParts);
1142
1143         if (parts.count() != 4) {
1144             return QDate();
1145         }
1146
1147         QString monthName = parts.at(1);
1148         int month = -1;
1149         // Assume that English monthnames are the default
1150         for (int i = 0; i < 12; ++i) {
1151             if (monthName == QLatin1String(qt_shortMonthNames[i])) {
1152                 month = i + 1;
1153                 break;
1154             }
1155         }
1156         // If English names can't be found, search the localized ones
1157         if (month == -1) {
1158             for (int i = 1; i <= 12; ++i) {
1159                 if (monthName == QDate::shortMonthName(i)) {
1160                     month = i;
1161                     break;
1162                 }
1163             }
1164         }
1165         if (month < 1 || month > 12) {
1166             return QDate();
1167         }
1168
1169         bool ok;
1170         int day = parts.at(2).toInt(&ok);
1171         if (!ok) {
1172             return QDate();
1173         }
1174
1175         int year = parts.at(3).toInt(&ok);
1176         if (!ok) {
1177             return QDate();
1178         }
1179
1180         return QDate(year, month, day);
1181     }
1182 #else
1183         break;
1184 #endif
1185     }
1186     return QDate();
1187 }
1188
1189 /*!
1190     \fn QDate::fromString(const QString &string, const QString &format)
1191
1192     Returns the QDate represented by the \a string, using the \a
1193     format given, or an invalid date if the string cannot be parsed.
1194
1195     These expressions may be used for the format:
1196
1197     \table
1198     \header \i Expression \i Output
1199     \row \i d \i The day as a number without a leading zero (1 to 31)
1200     \row \i dd \i The day as a number with a leading zero (01 to 31)
1201     \row \i ddd
1202          \i The abbreviated localized day name (e.g. 'Mon' to 'Sun').
1203             Uses QDate::shortDayName().
1204     \row \i dddd
1205          \i The long localized day name (e.g. 'Monday' to 'Sunday').
1206             Uses QDate::longDayName().
1207     \row \i M \i The month as a number without a leading zero (1 to 12)
1208     \row \i MM \i The month as a number with a leading zero (01 to 12)
1209     \row \i MMM
1210          \i The abbreviated localized month name (e.g. 'Jan' to 'Dec').
1211             Uses QDate::shortMonthName().
1212     \row \i MMMM
1213          \i The long localized month name (e.g. 'January' to 'December').
1214             Uses QDate::longMonthName().
1215     \row \i yy \i The year as two digit number (00 to 99)
1216     \row \i yyyy \i The year as four digit number. If the year is negative,
1217             a minus sign is prepended in addition.
1218     \endtable
1219
1220     All other input characters will be treated as text. Any sequence
1221     of characters that are enclosed in single quotes will also be
1222     treated as text and will not be used as an expression. For example:
1223
1224     \snippet doc/src/snippets/code/src_corelib_tools_qdatetime.cpp 1
1225
1226     If the format is not satisfied, an invalid QDate is returned. The
1227     expressions that don't expect leading zeroes (d, M) will be
1228     greedy. This means that they will use two digits even if this
1229     will put them outside the accepted range of values and leaves too
1230     few digits for other sections. For example, the following format
1231     string could have meant January 30 but the M will grab two
1232     digits, resulting in an invalid date:
1233
1234     \snippet doc/src/snippets/code/src_corelib_tools_qdatetime.cpp 2
1235
1236     For any field that is not represented in the format the following
1237     defaults are used:
1238
1239     \table
1240     \header \i Field  \i Default value
1241     \row    \i Year   \i 1900
1242     \row    \i Month  \i 1
1243     \row    \i Day    \i 1
1244     \endtable
1245
1246     The following examples demonstrate the default values:
1247
1248     \snippet doc/src/snippets/code/src_corelib_tools_qdatetime.cpp 3
1249
1250     \sa QDateTime::fromString(), QTime::fromString(), QDate::toString(),
1251         QDateTime::toString(), QTime::toString()
1252 */
1253
1254 QDate QDate::fromString(const QString &string, const QString &format)
1255 {
1256     QDate date;
1257 #ifndef QT_BOOTSTRAPPED
1258     QDateTimeParser dt(QVariant::Date, QDateTimeParser::FromString);
1259     if (dt.parseFormat(format))
1260         dt.fromString(string, &date, 0);
1261 #else
1262     Q_UNUSED(string);
1263     Q_UNUSED(format);
1264 #endif
1265     return date;
1266 }
1267 #endif // QT_NO_DATESTRING
1268
1269 /*!
1270     \overload
1271
1272     Returns true if the specified date (\a year, \a month, and \a
1273     day) is valid; otherwise returns false.
1274
1275     Example:
1276     \snippet doc/src/snippets/code/src_corelib_tools_qdatetime.cpp 4
1277
1278     \sa isNull(), setDate()
1279 */
1280
1281 bool QDate::isValid(int year, int month, int day)
1282 {
1283     if (year < FIRST_YEAR
1284         || (year == FIRST_YEAR &&
1285             (month < FIRST_MONTH
1286              || (month == FIRST_MONTH && day < FIRST_DAY)))
1287         || year == 0) // there is no year 0 in the Julian calendar
1288         return false;
1289
1290     // passage from Julian to Gregorian calendar
1291     if (year == 1582 && month == 10 && day > 4 && day < 15)
1292         return 0;
1293
1294     return (day > 0 && month > 0 && month <= 12) &&
1295            (day <= monthDays[month] || (day == 29 && month == 2 && isLeapYear(year)));
1296 }
1297
1298 /*!
1299     \fn bool QDate::isLeapYear(int year)
1300
1301     Returns true if the specified \a year is a leap year; otherwise
1302     returns false.
1303 */
1304
1305 bool QDate::isLeapYear(int y)
1306 {
1307     if (y < 1582) {
1308         if ( y < 1) {  // No year 0 in Julian calendar, so -1, -5, -9 etc are leap years
1309             ++y;
1310         }
1311         return y % 4 == 0;
1312     } else {
1313         return (y % 4 == 0 && y % 100 != 0) || y % 400 == 0;
1314     }
1315 }
1316
1317 /*!
1318     \internal
1319
1320     This function has a confusing name and shouldn't be part of the
1321     API anyway, since we have toJulian() and fromJulian().
1322     ### Qt 5: remove it
1323 */
1324 uint QDate::gregorianToJulian(int y, int m, int d)
1325 {
1326     return julianDayFromDate(y, m, d);
1327 }
1328
1329 /*!
1330     \internal
1331
1332     This function has a confusing name and shouldn't be part of the
1333     API anyway, since we have toJulian() and fromJulian().
1334     ### Qt 5: remove it
1335 */
1336 void QDate::julianToGregorian(uint jd, int &y, int &m, int &d)
1337 {
1338     getDateFromJulianDay(jd, &y, &m, &d);
1339 }
1340
1341 /*! \fn static QDate QDate::fromJulianDay(int jd)
1342
1343     Converts the Julian day \a jd to a QDate.
1344
1345     \sa toJulianDay()
1346 */
1347
1348 /*! \fn int QDate::toJulianDay() const
1349
1350     Converts the date to a Julian day.
1351
1352     \sa fromJulianDay()
1353 */
1354
1355 /*****************************************************************************
1356   QTime member functions
1357  *****************************************************************************/
1358
1359 /*!
1360     \class QTime
1361     \reentrant
1362
1363     \brief The QTime class provides clock time functions.
1364
1365
1366     A QTime object contains a clock time, i.e. the number of hours,
1367     minutes, seconds, and milliseconds since midnight. It can read the
1368     current time from the system clock and measure a span of elapsed
1369     time. It provides functions for comparing times and for
1370     manipulating a time by adding a number of milliseconds.
1371
1372     QTime uses the 24-hour clock format; it has no concept of AM/PM.
1373     Unlike QDateTime, QTime knows nothing about time zones or
1374     daylight savings time (DST).
1375
1376     A QTime object is typically created either by giving the number
1377     of hours, minutes, seconds, and milliseconds explicitly, or by
1378     using the static function currentTime(), which creates a QTime
1379     object that contains the system's local time. Note that the
1380     accuracy depends on the accuracy of the underlying operating
1381     system; not all systems provide 1-millisecond accuracy.
1382
1383     The hour(), minute(), second(), and msec() functions provide
1384     access to the number of hours, minutes, seconds, and milliseconds
1385     of the time. The same information is provided in textual format by
1386     the toString() function.
1387
1388     QTime provides a full set of operators to compare two QTime
1389     objects. One time is considered smaller than another if it is
1390     earlier than the other.
1391
1392     The time a given number of seconds or milliseconds later than a
1393     given time can be found using the addSecs() or addMSecs()
1394     functions. Correspondingly, the number of seconds or milliseconds
1395     between two times can be found using secsTo() or msecsTo().
1396
1397     QTime can be used to measure a span of elapsed time using the
1398     start(), restart(), and elapsed() functions.
1399
1400     \sa QDate, QDateTime
1401 */
1402
1403 /*!
1404     \fn QTime::QTime()
1405
1406     Constructs a null time object. A null time can be a QTime(0, 0, 0, 0)
1407     (i.e., midnight) object, except that isNull() returns true and isValid()
1408     returns false.
1409
1410     \sa isNull(), isValid()
1411 */
1412
1413 /*!
1414     Constructs a time with hour \a h, minute \a m, seconds \a s and
1415     milliseconds \a ms.
1416
1417     \a h must be in the range 0 to 23, \a m and \a s must be in the
1418     range 0 to 59, and \a ms must be in the range 0 to 999.
1419
1420     \sa isValid()
1421 */
1422
1423 QTime::QTime(int h, int m, int s, int ms)
1424 {
1425     setHMS(h, m, s, ms);
1426 }
1427
1428
1429 /*!
1430     \fn bool QTime::isNull() const
1431
1432     Returns true if the time is null (i.e., the QTime object was
1433     constructed using the default constructor); otherwise returns
1434     false. A null time is also an invalid time.
1435
1436     \sa isValid()
1437 */
1438
1439 /*!
1440     Returns true if the time is valid; otherwise returns false. For example,
1441     the time 23:30:55.746 is valid, but 24:12:30 is invalid.
1442
1443     \sa isNull()
1444 */
1445
1446 bool QTime::isValid() const
1447 {
1448     return mds > NullTime && mds < MSECS_PER_DAY;
1449 }
1450
1451
1452 /*!
1453     Returns the hour part (0 to 23) of the time.
1454
1455     \sa minute(), second(), msec()
1456 */
1457
1458 int QTime::hour() const
1459 {
1460     return ds() / MSECS_PER_HOUR;
1461 }
1462
1463 /*!
1464     Returns the minute part (0 to 59) of the time.
1465
1466     \sa hour(), second(), msec()
1467 */
1468
1469 int QTime::minute() const
1470 {
1471     return (ds() % MSECS_PER_HOUR) / MSECS_PER_MIN;
1472 }
1473
1474 /*!
1475     Returns the second part (0 to 59) of the time.
1476
1477     \sa hour(), minute(), msec()
1478 */
1479
1480 int QTime::second() const
1481 {
1482     return (ds() / 1000)%SECS_PER_MIN;
1483 }
1484
1485 /*!
1486     Returns the millisecond part (0 to 999) of the time.
1487
1488     \sa hour(), minute(), second()
1489 */
1490
1491 int QTime::msec() const
1492 {
1493     return ds() % 1000;
1494 }
1495
1496 #ifndef QT_NO_DATESTRING
1497 /*!
1498     \overload
1499
1500     Returns the time as a string. Milliseconds are not included. The
1501     \a format parameter determines the format of the string.
1502
1503     If \a format is Qt::TextDate, the string format is HH:mm:ss; e.g. 1
1504     second before midnight would be "23:59:59".
1505
1506     If \a format is Qt::ISODate, the string format corresponds to the
1507     ISO 8601 extended specification for representations of dates,
1508     which is also HH:mm:ss. (However, contrary to ISO 8601, dates
1509     before 15 October 1582 are handled as Julian dates, not Gregorian
1510     dates. See \l{QDate G and J} {Use of Gregorian and Julian
1511     Calendars}. This might change in a future version of Qt.)
1512
1513     If the \a format is Qt::SystemLocaleShortDate or
1514     Qt::SystemLocaleLongDate, the string format depends on the locale
1515     settings of the system. Identical to calling
1516     QLocale::system().toString(time, QLocale::ShortFormat) or
1517     QLocale::system().toString(time, QLocale::LongFormat).
1518
1519     If the \a format is Qt::DefaultLocaleShortDate or
1520     Qt::DefaultLocaleLongDate, the string format depends on the
1521     default application locale. This is the locale set with
1522     QLocale::setDefault(), or the system locale if no default locale
1523     has been set. Identical to calling QLocale().toString(time,
1524     QLocale::ShortFormat) or QLocale().toString(time,
1525     QLocale::LongFormat).
1526
1527     If the time is invalid, an empty string will be returned.
1528 */
1529
1530 QString QTime::toString(Qt::DateFormat format) const
1531 {
1532     if (!isValid())
1533         return QString();
1534
1535     switch (format) {
1536     case Qt::SystemLocaleDate:
1537     case Qt::SystemLocaleShortDate:
1538     case Qt::SystemLocaleLongDate:
1539         return QLocale::system().toString(*this, format == Qt::SystemLocaleLongDate ? QLocale::LongFormat
1540                                           : QLocale::ShortFormat);
1541     case Qt::LocaleDate:
1542     case Qt::DefaultLocaleShortDate:
1543     case Qt::DefaultLocaleLongDate:
1544         return QLocale().toString(*this, format == Qt::DefaultLocaleLongDate ? QLocale::LongFormat
1545                                   : QLocale::ShortFormat);
1546
1547     default:
1548     case Qt::ISODate:
1549     case Qt::TextDate:
1550         return QString::fromLatin1("%1:%2:%3")
1551             .arg(hour(), 2, 10, QLatin1Char('0'))
1552             .arg(minute(), 2, 10, QLatin1Char('0'))
1553             .arg(second(), 2, 10, QLatin1Char('0'));
1554     }
1555 }
1556
1557 /*!
1558     Returns the time as a string. The \a format parameter determines
1559     the format of the result string.
1560
1561     These expressions may be used:
1562
1563     \table
1564     \header \i Expression \i Output
1565     \row \i h
1566          \i the hour without a leading zero (0 to 23 or 1 to 12 if AM/PM display)
1567     \row \i hh
1568          \i the hour with a leading zero (00 to 23 or 01 to 12 if AM/PM display)
1569     \row \i H
1570          \i the hour without a leading zero (0 to 23, even with AM/PM display)
1571     \row \i HH
1572          \i the hour with a leading zero (00 to 23, even with AM/PM display)
1573     \row \i m \i the minute without a leading zero (0 to 59)
1574     \row \i mm \i the minute with a leading zero (00 to 59)
1575     \row \i s \i the second without a leading zero (0 to 59)
1576     \row \i ss \i the second with a leading zero (00 to 59)
1577     \row \i z \i the milliseconds without leading zeroes (0 to 999)
1578     \row \i zzz \i the milliseconds with leading zeroes (000 to 999)
1579     \row \i AP or A
1580          \i use AM/PM display. \e AP will be replaced by either "AM" or "PM".
1581     \row \i ap or a
1582          \i use am/pm display. \e ap will be replaced by either "am" or "pm".
1583     \row \i t \i the timezone (for example "CEST")
1584     \endtable
1585
1586     All other input characters will be ignored. Any sequence of characters that
1587     are enclosed in singlequotes will be treated as text and not be used as an
1588     expression. Two consecutive singlequotes ("''") are replaced by a singlequote
1589     in the output.
1590
1591     Example format strings (assuming that the QTime is 14:13:09.042)
1592
1593     \table
1594     \header \i Format \i Result
1595     \row \i hh:mm:ss.zzz \i 14:13:09.042
1596     \row \i h:m:s ap     \i 2:13:9 pm
1597     \row \i H:m:s a      \i 14:13:9 pm
1598     \endtable
1599
1600     If the datetime is invalid, an empty string will be returned.
1601     If \a format is empty, the default format "hh:mm:ss" is used.
1602
1603     \sa QDate::toString() QDateTime::toString()
1604 */
1605 QString QTime::toString(const QString& format) const
1606 {
1607     return fmtDateTime(format, this, 0);
1608 }
1609 #endif //QT_NO_DATESTRING
1610 /*!
1611     Sets the time to hour \a h, minute \a m, seconds \a s and
1612     milliseconds \a ms.
1613
1614     \a h must be in the range 0 to 23, \a m and \a s must be in the
1615     range 0 to 59, and \a ms must be in the range 0 to 999.
1616     Returns true if the set time is valid; otherwise returns false.
1617
1618     \sa isValid()
1619 */
1620
1621 bool QTime::setHMS(int h, int m, int s, int ms)
1622 {
1623 #if defined(Q_OS_WINCE)
1624     startTick = NullTime;
1625 #endif
1626     if (!isValid(h,m,s,ms)) {
1627         mds = NullTime;                // make this invalid
1628         return false;
1629     }
1630     mds = (h*SECS_PER_HOUR + m*SECS_PER_MIN + s)*1000 + ms;
1631     return true;
1632 }
1633
1634 /*!
1635     Returns a QTime object containing a time \a s seconds later
1636     than the time of this object (or earlier if \a s is negative).
1637
1638     Note that the time will wrap if it passes midnight.
1639
1640     Example:
1641
1642     \snippet doc/src/snippets/code/src_corelib_tools_qdatetime.cpp 5
1643
1644     \sa addMSecs(), secsTo(), QDateTime::addSecs()
1645 */
1646
1647 QTime QTime::addSecs(int s) const
1648 {
1649     return addMSecs(s * 1000);
1650 }
1651
1652 /*!
1653     Returns the number of seconds from this time to \a t.
1654     If \a t is earlier than this time, the number of seconds returned
1655     is negative.
1656
1657     Because QTime measures time within a day and there are 86400
1658     seconds in a day, the result is always between -86400 and 86400.
1659
1660     secsTo() does not take into account any milliseconds.
1661
1662     \sa addSecs(), QDateTime::secsTo()
1663 */
1664
1665 int QTime::secsTo(const QTime &t) const
1666 {
1667     return (t.ds() - ds()) / 1000;
1668 }
1669
1670 /*!
1671     Returns a QTime object containing a time \a ms milliseconds later
1672     than the time of this object (or earlier if \a ms is negative).
1673
1674     Note that the time will wrap if it passes midnight. See addSecs()
1675     for an example.
1676
1677     \sa addSecs(), msecsTo(), QDateTime::addMSecs()
1678 */
1679
1680 QTime QTime::addMSecs(int ms) const
1681 {
1682     QTime t;
1683     if (ms < 0) {
1684         // % not well-defined for -ve, but / is.
1685         int negdays = (MSECS_PER_DAY - ms) / MSECS_PER_DAY;
1686         t.mds = (ds() + ms + negdays * MSECS_PER_DAY) % MSECS_PER_DAY;
1687     } else {
1688         t.mds = (ds() + ms) % MSECS_PER_DAY;
1689     }
1690 #if defined(Q_OS_WINCE)
1691     if (startTick > NullTime)
1692         t.startTick = (startTick + ms) % MSECS_PER_DAY;
1693 #endif
1694     return t;
1695 }
1696
1697 /*!
1698     Returns the number of milliseconds from this time to \a t.
1699     If \a t is earlier than this time, the number of milliseconds returned
1700     is negative.
1701
1702     Because QTime measures time within a day and there are 86400
1703     seconds in a day, the result is always between -86400000 and
1704     86400000 ms.
1705
1706     \sa secsTo(), addMSecs(), QDateTime::msecsTo()
1707 */
1708
1709 int QTime::msecsTo(const QTime &t) const
1710 {
1711 #if defined(Q_OS_WINCE)
1712     // GetLocalTime() for Windows CE has no milliseconds resolution
1713     if (t.startTick > NullTime && startTick > NullTime)
1714         return t.startTick - startTick;
1715     else
1716 #endif
1717         return t.ds() - ds();
1718 }
1719
1720
1721 /*!
1722     \fn bool QTime::operator==(const QTime &t) const
1723
1724     Returns true if this time is equal to \a t; otherwise returns false.
1725 */
1726
1727 /*!
1728     \fn bool QTime::operator!=(const QTime &t) const
1729
1730     Returns true if this time is different from \a t; otherwise returns false.
1731 */
1732
1733 /*!
1734     \fn bool QTime::operator<(const QTime &t) const
1735
1736     Returns true if this time is earlier than \a t; otherwise returns false.
1737 */
1738
1739 /*!
1740     \fn bool QTime::operator<=(const QTime &t) const
1741
1742     Returns true if this time is earlier than or equal to \a t;
1743     otherwise returns false.
1744 */
1745
1746 /*!
1747     \fn bool QTime::operator>(const QTime &t) const
1748
1749     Returns true if this time is later than \a t; otherwise returns false.
1750 */
1751
1752 /*!
1753     \fn bool QTime::operator>=(const QTime &t) const
1754
1755     Returns true if this time is later than or equal to \a t;
1756     otherwise returns false.
1757 */
1758
1759 /*!
1760     \fn QTime::currentTime()
1761
1762     Returns the current time as reported by the system clock.
1763
1764     Note that the accuracy depends on the accuracy of the underlying
1765     operating system; not all systems provide 1-millisecond accuracy.
1766 */
1767
1768 #ifndef QT_NO_DATESTRING
1769 /*!
1770     \fn QTime QTime::fromString(const QString &string, Qt::DateFormat format)
1771
1772     Returns the time represented in the \a string as a QTime using the
1773     \a format given, or an invalid time if this is not possible.
1774
1775     Note that fromString() uses a "C" locale encoded string to convert
1776     milliseconds to a float value. If the default locale is not "C",
1777     this may result in two conversion attempts (if the conversion
1778     fails for the default locale). This should be considered an
1779     implementation detail.
1780 */
1781 QTime QTime::fromString(const QString& s, Qt::DateFormat f)
1782 {
1783     if (s.isEmpty()) {
1784         QTime t;
1785         t.mds = NullTime;
1786         return t;
1787     }
1788
1789     switch (f) {
1790     case Qt::SystemLocaleDate:
1791     case Qt::SystemLocaleShortDate:
1792     case Qt::SystemLocaleLongDate:
1793         return fromString(s, QLocale::system().timeFormat(f == Qt::SystemLocaleLongDate ? QLocale::LongFormat
1794                                                                                         : QLocale::ShortFormat));
1795     case Qt::LocaleDate:
1796     case Qt::DefaultLocaleShortDate:
1797     case Qt::DefaultLocaleLongDate:
1798         return fromString(s, QLocale().timeFormat(f == Qt::DefaultLocaleLongDate ? QLocale::LongFormat
1799                                                                                  : QLocale::ShortFormat));
1800     default:
1801         {
1802             bool ok = true;
1803             const int hour(s.mid(0, 2).toInt(&ok));
1804             if (!ok)
1805                 return QTime();
1806             const int minute(s.mid(3, 2).toInt(&ok));
1807             if (!ok)
1808                 return QTime();
1809             const int second(s.mid(6, 2).toInt(&ok));
1810             if (!ok)
1811                 return QTime();
1812             const QString msec_s(QLatin1String("0.") + s.mid(9, 4));
1813             const float msec(msec_s.toFloat(&ok));
1814             if (!ok)
1815                 return QTime(hour, minute, second, 0);
1816             return QTime(hour, minute, second, qMin(qRound(msec * 1000.0), 999));
1817         }
1818     }
1819 }
1820
1821 /*!
1822     \fn QTime::fromString(const QString &string, const QString &format)
1823
1824     Returns the QTime represented by the \a string, using the \a
1825     format given, or an invalid time if the string cannot be parsed.
1826
1827     These expressions may be used for the format:
1828
1829     \table
1830     \header \i Expression \i Output
1831     \row \i h
1832          \i the hour without a leading zero (0 to 23 or 1 to 12 if AM/PM display)
1833     \row \i hh
1834          \i the hour with a leading zero (00 to 23 or 01 to 12 if AM/PM display)
1835     \row \i m \i the minute without a leading zero (0 to 59)
1836     \row \i mm \i the minute with a leading zero (00 to 59)
1837     \row \i s \i the second without a leading zero (0 to 59)
1838     \row \i ss \i the second with a leading zero (00 to 59)
1839     \row \i z \i the milliseconds without leading zeroes (0 to 999)
1840     \row \i zzz \i the milliseconds with leading zeroes (000 to 999)
1841     \row \i AP
1842          \i interpret as an AM/PM time. \e AP must be either "AM" or "PM".
1843     \row \i ap
1844          \i Interpret as an AM/PM time. \e ap must be either "am" or "pm".
1845     \endtable
1846
1847     All other input characters will be treated as text. Any sequence
1848     of characters that are enclosed in single quotes will also be
1849     treated as text and not be used as an expression.
1850
1851     \snippet doc/src/snippets/code/src_corelib_tools_qdatetime.cpp 6
1852
1853     If the format is not satisfied an invalid QTime is returned.
1854     Expressions that do not expect leading zeroes to be given (h, m, s
1855     and z) are greedy. This means that they will use two digits even if
1856     this puts them outside the range of accepted values and leaves too
1857     few digits for other sections. For example, the following string
1858     could have meant 00:07:10, but the m will grab two digits, resulting
1859     in an invalid time:
1860
1861     \snippet doc/src/snippets/code/src_corelib_tools_qdatetime.cpp 7
1862
1863     Any field that is not represented in the format will be set to zero.
1864     For example:
1865
1866     \snippet doc/src/snippets/code/src_corelib_tools_qdatetime.cpp 8
1867
1868     \sa QDateTime::fromString() QDate::fromString() QDate::toString()
1869     QDateTime::toString() QTime::toString()
1870 */
1871
1872 QTime QTime::fromString(const QString &string, const QString &format)
1873 {
1874     QTime time;
1875 #ifndef QT_BOOTSTRAPPED
1876     QDateTimeParser dt(QVariant::Time, QDateTimeParser::FromString);
1877     if (dt.parseFormat(format))
1878         dt.fromString(string, 0, &time);
1879 #else
1880     Q_UNUSED(string);
1881     Q_UNUSED(format);
1882 #endif
1883     return time;
1884 }
1885
1886 #endif // QT_NO_DATESTRING
1887
1888
1889 /*!
1890     \overload
1891
1892     Returns true if the specified time is valid; otherwise returns
1893     false.
1894
1895     The time is valid if \a h is in the range 0 to 23, \a m and
1896     \a s are in the range 0 to 59, and \a ms is in the range 0 to 999.
1897
1898     Example:
1899
1900     \snippet doc/src/snippets/code/src_corelib_tools_qdatetime.cpp 9
1901 */
1902
1903 bool QTime::isValid(int h, int m, int s, int ms)
1904 {
1905     return (uint)h < 24 && (uint)m < 60 && (uint)s < 60 && (uint)ms < 1000;
1906 }
1907
1908
1909 /*!
1910     Sets this time to the current time. This is practical for timing:
1911
1912     \snippet doc/src/snippets/code/src_corelib_tools_qdatetime.cpp 10
1913
1914     \sa restart(), elapsed(), currentTime()
1915 */
1916
1917 void QTime::start()
1918 {
1919     *this = currentTime();
1920 }
1921
1922 /*!
1923     Sets this time to the current time and returns the number of
1924     milliseconds that have elapsed since the last time start() or
1925     restart() was called.
1926
1927     This function is guaranteed to be atomic and is thus very handy
1928     for repeated measurements. Call start() to start the first
1929     measurement, and restart() for each later measurement.
1930
1931     Note that the counter wraps to zero 24 hours after the last call
1932     to start() or restart().
1933
1934     \warning If the system's clock setting has been changed since the
1935     last time start() or restart() was called, the result is
1936     undefined. This can happen when daylight savings time is turned on
1937     or off.
1938
1939     \sa start(), elapsed(), currentTime()
1940 */
1941
1942 int QTime::restart()
1943 {
1944     QTime t = currentTime();
1945     int n = msecsTo(t);
1946     if (n < 0)                                // passed midnight
1947         n += 86400*1000;
1948     *this = t;
1949     return n;
1950 }
1951
1952 /*!
1953     Returns the number of milliseconds that have elapsed since the
1954     last time start() or restart() was called.
1955
1956     Note that the counter wraps to zero 24 hours after the last call
1957     to start() or restart.
1958
1959     Note that the accuracy depends on the accuracy of the underlying
1960     operating system; not all systems provide 1-millisecond accuracy.
1961
1962     \warning If the system's clock setting has been changed since the
1963     last time start() or restart() was called, the result is
1964     undefined. This can happen when daylight savings time is turned on
1965     or off.
1966
1967     \sa start(), restart()
1968 */
1969
1970 int QTime::elapsed() const
1971 {
1972     int n = msecsTo(currentTime());
1973     if (n < 0)                                // passed midnight
1974         n += 86400 * 1000;
1975     return n;
1976 }
1977
1978
1979 /*****************************************************************************
1980   QDateTime member functions
1981  *****************************************************************************/
1982
1983 /*!
1984     \class QDateTime
1985     \reentrant
1986     \brief The QDateTime class provides date and time functions.
1987
1988
1989     A QDateTime object contains a calendar date and a clock time (a
1990     "datetime"). It is a combination of the QDate and QTime classes.
1991     It can read the current datetime from the system clock. It
1992     provides functions for comparing datetimes and for manipulating a
1993     datetime by adding a number of seconds, days, months, or years.
1994
1995     A QDateTime object is typically created either by giving a date
1996     and time explicitly in the constructor, or by using the static
1997     function currentDateTime() that returns a QDateTime object set
1998     to the system clock's time. The date and time can be changed with
1999     setDate() and setTime(). A datetime can also be set using the
2000     setTime_t() function that takes a POSIX-standard "number of
2001     seconds since 00:00:00 on January 1, 1970" value. The fromString()
2002     function returns a QDateTime, given a string and a date format
2003     used to interpret the date within the string.
2004
2005     The date() and time() functions provide access to the date and
2006     time parts of the datetime. The same information is provided in
2007     textual format by the toString() function.
2008
2009     QDateTime provides a full set of operators to compare two
2010     QDateTime objects where smaller means earlier and larger means
2011     later.
2012
2013     You can increment (or decrement) a datetime by a given number of
2014     milliseconds using addMSecs(), seconds using addSecs(), or days
2015     using addDays(). Similarly you can use addMonths() and addYears().
2016     The daysTo() function returns the number of days between two datetimes,
2017     secsTo() returns the number of seconds between two datetimes, and
2018     msecsTo() returns the number of milliseconds between two datetimes.
2019
2020     QDateTime can store datetimes as \l{Qt::LocalTime}{local time} or
2021     as \l{Qt::UTC}{UTC}. QDateTime::currentDateTime() returns a
2022     QDateTime expressed as local time; use toUTC() to convert it to
2023     UTC. You can also use timeSpec() to find out if a QDateTime
2024     object stores a UTC time or a local time. Operations such as
2025     addSecs() and secsTo() are aware of daylight saving time (DST).
2026
2027     \note QDateTime does not account for leap seconds.
2028
2029     \section1
2030
2031     \target QDateTime G and J
2032     \section2 Use of Gregorian and Julian Calendars
2033
2034     QDate uses the Gregorian calendar in all locales, beginning
2035     on the date 15 October 1582. For dates up to and including 4
2036     October 1582, the Julian calendar is used.  This means there is a
2037     10-day gap in the internal calendar between the 4th and the 15th
2038     of October 1582. When you use QDateTime for dates in that epoch,
2039     the day after 4 October 1582 is 15 October 1582, and the dates in
2040     the gap are invalid.
2041
2042     The Julian to Gregorian changeover date used here is the date when
2043     the Gregorian calendar was first introduced, by Pope Gregory
2044     XIII. That change was not universally accepted and some localities
2045     only executed it at a later date (if at all).  QDateTime
2046     doesn't take any of these historical facts into account. If an
2047     application must support a locale-specific dating system, it must
2048     do so on its own, remembering to convert the dates using the
2049     Julian day.
2050
2051     \section2 No Year 0
2052
2053     There is no year 0. Dates in that year are considered invalid. The
2054     year -1 is the year "1 before Christ" or "1 before current era."
2055     The day before 0001-01-01 is December 31st, 1 BCE.
2056
2057     \section2 Range of Valid Dates
2058
2059     The range of valid dates is from January 2nd, 4713 BCE, to
2060     sometime in the year 11 million CE. The Julian Day returned by
2061     QDate::toJulianDay() is a number in the contiguous range from 1 to
2062     \e{overflow}, even across QDateTime's "date holes". It is suitable
2063     for use in applications that must convert a QDateTime to a date in
2064     another calendar system, e.g., Hebrew, Islamic or Chinese.
2065
2066     The Gregorian calendar was introduced in different places around
2067     the world on different dates. QDateTime uses QDate to store the
2068     date, so it uses the Gregorian calendar for all locales, beginning
2069     on the date 15 October 1582. For dates up to and including 4
2070     October 1582, QDateTime uses the Julian calendar.  This means
2071     there is a 10-day gap in the QDateTime calendar between the 4th
2072     and the 15th of October 1582. When you use QDateTime for dates in
2073     that epoch, the day after 4 October 1582 is 15 October 1582, and
2074     the dates in the gap are invalid.
2075
2076     \section2
2077     Use of System Timezone
2078
2079     QDateTime uses the system's time zone information to determine the
2080     offset of local time from UTC. If the system is not configured
2081     correctly or not up-to-date, QDateTime will give wrong results as
2082     well.
2083
2084     \section2 Daylight Savings Time (DST)
2085
2086     QDateTime takes into account the system's time zone information
2087     when dealing with DST. On modern Unix systems, this means it
2088     applies the correct historical DST data whenever possible. On
2089     Windows and Windows CE, where the system doesn't support
2090     historical DST data, historical accuracy is not maintained with
2091     respect to DST.
2092
2093     The range of valid dates taking DST into account is 1970-01-01 to
2094     the present, and rules are in place for handling DST correctly
2095     until 2037-12-31, but these could change. For dates falling
2096     outside that range, QDateTime makes a \e{best guess} using the
2097     rules for year 1970 or 2037, but we can't guarantee accuracy. This
2098     means QDateTime doesn't take into account changes in a locale's
2099     time zone before 1970, even if the system's time zone database
2100     supports that information.
2101
2102     \sa QDate QTime QDateTimeEdit
2103 */
2104
2105 /*!
2106     Constructs a null datetime (i.e. null date and null time). A null
2107     datetime is invalid, since the date is invalid.
2108
2109     \sa isValid()
2110 */
2111 QDateTime::QDateTime()
2112     : d(new QDateTimePrivate)
2113 {
2114 }
2115
2116
2117 /*!
2118     Constructs a datetime with the given \a date, a valid
2119     time(00:00:00.000), and sets the timeSpec() to Qt::LocalTime.
2120 */
2121
2122 QDateTime::QDateTime(const QDate &date)
2123     : d(new QDateTimePrivate)
2124 {
2125     d->date = date;
2126     d->time = QTime(0, 0, 0);
2127 }
2128
2129 /*!
2130     Constructs a datetime with the given \a date and \a time, using
2131     the time specification defined by \a spec.
2132
2133     If \a date is valid and \a time is not, the time will be set to midnight.
2134 */
2135
2136 QDateTime::QDateTime(const QDate &date, const QTime &time, Qt::TimeSpec spec)
2137     : d(new QDateTimePrivate)
2138 {
2139     d->date = date;
2140     d->time = date.isValid() && !time.isValid() ? QTime(0, 0, 0) : time;
2141     d->spec = (spec == Qt::UTC) ? QDateTimePrivate::UTC : QDateTimePrivate::LocalUnknown;
2142 }
2143
2144 /*!
2145     Constructs a copy of the \a other datetime.
2146 */
2147
2148 QDateTime::QDateTime(const QDateTime &other)
2149     : d(other.d)
2150 {
2151 }
2152
2153 /*!
2154     Destroys the datetime.
2155 */
2156 QDateTime::~QDateTime()
2157 {
2158 }
2159
2160 /*!
2161     Makes a copy of the \a other datetime and returns a reference to the
2162     copy.
2163 */
2164
2165 QDateTime &QDateTime::operator=(const QDateTime &other)
2166 {
2167     d = other.d;
2168     return *this;
2169 }
2170
2171 /*!
2172     Returns true if both the date and the time are null; otherwise
2173     returns false. A null datetime is invalid.
2174
2175     \sa QDate::isNull(), QTime::isNull(), isValid()
2176 */
2177
2178 bool QDateTime::isNull() const
2179 {
2180     return d->date.isNull() && d->time.isNull();
2181 }
2182
2183 /*!
2184     Returns true if both the date and the time are valid; otherwise
2185     returns false.
2186
2187     \sa QDate::isValid(), QTime::isValid()
2188 */
2189
2190 bool QDateTime::isValid() const
2191 {
2192     return d->date.isValid() && d->time.isValid();
2193 }
2194
2195 /*!
2196     Returns the date part of the datetime.
2197
2198     \sa setDate(), time(), timeSpec()
2199 */
2200
2201 QDate QDateTime::date() const
2202 {
2203     return d->date;
2204 }
2205
2206 /*!
2207     Returns the time part of the datetime.
2208
2209     \sa setTime(), date(), timeSpec()
2210 */
2211
2212 QTime QDateTime::time() const
2213 {
2214     return d->time;
2215 }
2216
2217 /*!
2218     Returns the time specification of the datetime.
2219
2220     \sa setTimeSpec(), date(), time(), Qt::TimeSpec
2221 */
2222
2223 Qt::TimeSpec QDateTime::timeSpec() const
2224 {
2225     switch(d->spec)
2226     {
2227         case QDateTimePrivate::UTC:
2228             return Qt::UTC;
2229         case QDateTimePrivate::OffsetFromUTC:
2230             return Qt::OffsetFromUTC;
2231         default:
2232             return Qt::LocalTime;
2233     }
2234 }
2235
2236 /*!
2237     Sets the date part of this datetime to \a date.
2238     If no time is set, it is set to midnight.
2239
2240     \sa date(), setTime(), setTimeSpec()
2241 */
2242
2243 void QDateTime::setDate(const QDate &date)
2244 {
2245     detach();
2246     d->date = date;
2247     if (d->spec == QDateTimePrivate::LocalStandard
2248         || d->spec == QDateTimePrivate::LocalDST)
2249         d->spec = QDateTimePrivate::LocalUnknown;
2250     if (date.isValid() && !d->time.isValid())
2251         d->time = QTime(0, 0, 0);
2252 }
2253
2254 /*!
2255     Sets the time part of this datetime to \a time.
2256
2257     \sa time(), setDate(), setTimeSpec()
2258 */
2259
2260 void QDateTime::setTime(const QTime &time)
2261 {
2262     detach();
2263     if (d->spec == QDateTimePrivate::LocalStandard
2264         || d->spec == QDateTimePrivate::LocalDST)
2265         d->spec = QDateTimePrivate::LocalUnknown;
2266     d->time = time;
2267 }
2268
2269 /*!
2270     Sets the time specification used in this datetime to \a spec.
2271
2272     \sa timeSpec(), setDate(), setTime(), Qt::TimeSpec
2273 */
2274
2275 void QDateTime::setTimeSpec(Qt::TimeSpec spec)
2276 {
2277     detach();
2278
2279     switch(spec)
2280     {
2281         case Qt::UTC:
2282             d->spec = QDateTimePrivate::UTC;
2283             break;
2284         case Qt::OffsetFromUTC:
2285             d->spec = QDateTimePrivate::OffsetFromUTC;
2286             break;
2287         default:
2288             d->spec = QDateTimePrivate::LocalUnknown;
2289             break;
2290     }
2291 }
2292
2293 qint64 toMSecsSinceEpoch_helper(qint64 jd, int msecs)
2294 {
2295     qint64 days = jd - JULIAN_DAY_FOR_EPOCH;
2296     qint64 retval = (days * MSECS_PER_DAY) + msecs;
2297     return retval;
2298 }
2299
2300 /*!
2301     \since 4.7
2302
2303     Returns the datetime as the number of milliseconds that have passed
2304     since 1970-01-01T00:00:00.000, Coordinated Universal Time (Qt::UTC).
2305
2306     On systems that do not support time zones, this function will
2307     behave as if local time were Qt::UTC.
2308
2309     The behavior for this function is undefined if the datetime stored in
2310     this object is not valid. However, for all valid dates, this function
2311     returns a unique value.
2312
2313     \sa toTime_t(), setMSecsSinceEpoch()
2314 */
2315 qint64 QDateTime::toMSecsSinceEpoch() const
2316 {
2317     QDate utcDate;
2318     QTime utcTime;
2319     d->getUTC(utcDate, utcTime);
2320
2321     return toMSecsSinceEpoch_helper(utcDate.jd, utcTime.ds());
2322 }
2323
2324 /*!
2325     Returns the datetime as the number of seconds that have passed
2326     since 1970-01-01T00:00:00, Coordinated Universal Time (Qt::UTC).
2327
2328     On systems that do not support time zones, this function will
2329     behave as if local time were Qt::UTC.
2330
2331     \note This function returns a 32-bit unsigned integer, so it does not
2332     support dates before 1970, but it does support dates after
2333     2038-01-19T03:14:06, which may not be valid time_t values. Be careful
2334     when passing those time_t values to system functions, which could
2335     interpret them as negative dates.
2336
2337     If the date is outside the range 1970-01-01T00:00:00 to
2338     2106-02-07T06:28:14, this function returns -1 cast to an unsigned integer
2339     (i.e., 0xFFFFFFFF).
2340
2341     To get an extended range, use toMSecsSinceEpoch().
2342
2343     \sa toMSecsSinceEpoch(), setTime_t()
2344 */
2345
2346 uint QDateTime::toTime_t() const
2347 {
2348     qint64 retval = toMSecsSinceEpoch() / 1000;
2349     if (quint64(retval) >= Q_UINT64_C(0xFFFFFFFF))
2350         return uint(-1);
2351     return uint(retval);
2352 }
2353
2354 /*!
2355     \since 4.7
2356
2357     Sets the date and time given the number of milliseconds,\a msecs, that have
2358     passed since 1970-01-01T00:00:00.000, Coordinated Universal Time
2359     (Qt::UTC). On systems that do not support time zones this function
2360     will behave as if local time were Qt::UTC.
2361
2362     Note that there are possible values for \a msecs that lie outside the
2363     valid range of QDateTime, both negative and positive. The behavior of
2364     this function is undefined for those values.
2365
2366     \sa toMSecsSinceEpoch(), setTime_t()
2367 */
2368 void QDateTime::setMSecsSinceEpoch(qint64 msecs)
2369 {
2370     detach();
2371
2372     QDateTimePrivate::Spec oldSpec = d->spec;
2373
2374     int ddays = msecs / MSECS_PER_DAY;
2375     msecs %= MSECS_PER_DAY;
2376     if (msecs < 0) {
2377         // negative
2378         --ddays;
2379         msecs += MSECS_PER_DAY;
2380     }
2381
2382     d->date = QDate(1970, 1, 1).addDays(ddays);
2383     d->time = QTime().addMSecs(msecs);
2384     d->spec = QDateTimePrivate::UTC;
2385
2386     if (oldSpec != QDateTimePrivate::UTC)
2387         d->spec = d->getLocal(d->date, d->time);
2388 }
2389
2390 /*!
2391     \fn void QDateTime::setTime_t(uint seconds)
2392
2393     Sets the date and time given the number of \a seconds that have
2394     passed since 1970-01-01T00:00:00, Coordinated Universal Time
2395     (Qt::UTC). On systems that do not support time zones this function
2396     will behave as if local time were Qt::UTC.
2397
2398     \sa toTime_t()
2399 */
2400
2401 void QDateTime::setTime_t(uint secsSince1Jan1970UTC)
2402 {
2403     detach();
2404
2405     QDateTimePrivate::Spec oldSpec = d->spec;
2406
2407     d->date = QDate(1970, 1, 1).addDays(secsSince1Jan1970UTC / SECS_PER_DAY);
2408     d->time = QTime().addSecs(secsSince1Jan1970UTC % SECS_PER_DAY);
2409     d->spec = QDateTimePrivate::UTC;
2410
2411     if (oldSpec != QDateTimePrivate::UTC)
2412         d->spec = d->getLocal(d->date, d->time);
2413 }
2414
2415 #ifndef QT_NO_DATESTRING
2416 /*!
2417     \fn QString QDateTime::toString(Qt::DateFormat format) const
2418
2419     \overload
2420
2421     Returns the datetime as a string in the \a format given.
2422
2423     If the \a format is Qt::TextDate, the string is formatted in
2424     the default way. QDate::shortDayName(), QDate::shortMonthName(),
2425     and QTime::toString() are used to generate the string, so the
2426     day and month names will be localized names. An example of this
2427     formatting is "Wed May 20 03:40:13 1998".
2428
2429     If the \a format is Qt::ISODate, the string format corresponds
2430     to the ISO 8601 extended specification for representations of
2431     dates and times, taking the form YYYY-MM-DDTHH:mm:ss[Z|[+|-]HH:mm],
2432     depending on the timeSpec() of the QDateTime. If the timeSpec()
2433     is Qt::UTC, Z will be appended to the string; if the timeSpec() is
2434     Qt::OffsetFromUTC the offset in hours and minutes from UTC will
2435     be appended to the string.
2436
2437     If the \a format is Qt::SystemLocaleShortDate or
2438     Qt::SystemLocaleLongDate, the string format depends on the locale
2439     settings of the system. Identical to calling
2440     QLocale::system().toString(datetime, QLocale::ShortFormat) or
2441     QLocale::system().toString(datetime, QLocale::LongFormat).
2442
2443     If the \a format is Qt::DefaultLocaleShortDate or
2444     Qt::DefaultLocaleLongDate, the string format depends on the
2445     default application locale. This is the locale set with
2446     QLocale::setDefault(), or the system locale if no default locale
2447     has been set. Identical to calling QLocale().toString(datetime,
2448     QLocale::ShortFormat) or QLocale().toString(datetime,
2449     QLocale::LongFormat).
2450
2451     If the datetime is invalid, an empty string will be returned.
2452
2453     \warning The Qt::ISODate format is only valid for years in the
2454     range 0 to 9999. This restriction may apply to locale-aware
2455     formats as well, depending on the locale settings.
2456
2457     \sa QDate::toString() QTime::toString() Qt::DateFormat
2458 */
2459
2460 QString QDateTime::toString(Qt::DateFormat f) const
2461 {
2462     QString buf;
2463     if (!isValid())
2464         return buf;
2465
2466     if (f == Qt::ISODate) {
2467         buf = d->date.toString(Qt::ISODate);
2468         if (buf.isEmpty())
2469             return QString();   // failed to convert
2470         buf += QLatin1Char('T');
2471         buf += d->time.toString(Qt::ISODate);
2472         switch (d->spec) {
2473         case QDateTimePrivate::UTC:
2474             buf += QLatin1Char('Z');
2475             break;
2476         case QDateTimePrivate::OffsetFromUTC: {
2477             int sign = d->utcOffset >= 0 ? 1: -1;
2478             buf += QString::fromLatin1("%1%2:%3").
2479                 arg(sign == 1 ? QLatin1Char('+') : QLatin1Char('-')).
2480                 arg(d->utcOffset * sign / SECS_PER_HOUR, 2, 10, QLatin1Char('0')).
2481                 arg((d->utcOffset / 60) % 60, 2, 10, QLatin1Char('0'));
2482             break;
2483         }
2484         default:
2485             break;
2486         }
2487     }
2488 #ifndef QT_NO_TEXTDATE
2489     else if (f == Qt::TextDate) {
2490 #ifndef Q_WS_WIN
2491         buf = d->date.shortDayName(d->date.dayOfWeek());
2492         buf += QLatin1Char(' ');
2493         buf += d->date.shortMonthName(d->date.month());
2494         buf += QLatin1Char(' ');
2495         buf += QString::number(d->date.day());
2496 #else
2497         wchar_t out[255];
2498         GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_ILDATE, out, 255);
2499         QString winstr = QString::fromWCharArray(out);
2500         switch (winstr.toInt()) {
2501         case 1:
2502             buf = d->date.shortDayName(d->date.dayOfWeek());
2503             buf += QLatin1Char(' ');
2504             buf += QString::number(d->date.day());
2505             buf += QLatin1String(". ");
2506             buf += d->date.shortMonthName(d->date.month());
2507             break;
2508         default:
2509             buf = d->date.shortDayName(d->date.dayOfWeek());
2510             buf += QLatin1Char(' ');
2511             buf += d->date.shortMonthName(d->date.month());
2512             buf += QLatin1Char(' ');
2513             buf += QString::number(d->date.day());
2514         }
2515 #endif
2516         buf += QLatin1Char(' ');
2517         buf += d->time.toString();
2518         buf += QLatin1Char(' ');
2519         buf += QString::number(d->date.year());
2520     }
2521 #endif
2522     else {
2523         buf = d->date.toString(f);
2524         if (buf.isEmpty())
2525             return QString();   // failed to convert
2526         buf += QLatin1Char(' ');
2527         buf += d->time.toString(f);
2528     }
2529
2530     return buf;
2531 }
2532
2533 /*!
2534     Returns the datetime as a string. The \a format parameter
2535     determines the format of the result string.
2536
2537     These expressions may be used for the date:
2538
2539     \table
2540     \header \i Expression \i Output
2541     \row \i d \i the day as number without a leading zero (1 to 31)
2542     \row \i dd \i the day as number with a leading zero (01 to 31)
2543     \row \i ddd
2544             \i the abbreviated localized day name (e.g. 'Mon' to 'Sun').
2545             Uses QDate::shortDayName().
2546     \row \i dddd
2547             \i the long localized day name (e.g. 'Monday' to 'Qt::Sunday').
2548             Uses QDate::longDayName().
2549     \row \i M \i the month as number without a leading zero (1-12)
2550     \row \i MM \i the month as number with a leading zero (01-12)
2551     \row \i MMM
2552             \i the abbreviated localized month name (e.g. 'Jan' to 'Dec').
2553             Uses QDate::shortMonthName().
2554     \row \i MMMM
2555             \i the long localized month name (e.g. 'January' to 'December').
2556             Uses QDate::longMonthName().
2557     \row \i yy \i the year as two digit number (00-99)
2558     \row \i yyyy \i the year as four digit number
2559     \endtable
2560
2561     These expressions may be used for the time:
2562
2563     \table
2564     \header \i Expression \i Output
2565     \row \i h
2566          \i the hour without a leading zero (0 to 23 or 1 to 12 if AM/PM display)
2567     \row \i hh
2568          \i the hour with a leading zero (00 to 23 or 01 to 12 if AM/PM display)
2569     \row \i m \i the minute without a leading zero (0 to 59)
2570     \row \i mm \i the minute with a leading zero (00 to 59)
2571     \row \i s \i the second without a leading zero (0 to 59)
2572     \row \i ss \i the second with a leading zero (00 to 59)
2573     \row \i z \i the milliseconds without leading zeroes (0 to 999)
2574     \row \i zzz \i the milliseconds with leading zeroes (000 to 999)
2575     \row \i AP
2576             \i use AM/PM display. \e AP will be replaced by either "AM" or "PM".
2577     \row \i ap
2578             \i use am/pm display. \e ap will be replaced by either "am" or "pm".
2579     \endtable
2580
2581     All other input characters will be ignored. Any sequence of characters that
2582     are enclosed in singlequotes will be treated as text and not be used as an
2583     expression. Two consecutive singlequotes ("''") are replaced by a singlequote
2584     in the output.
2585
2586     Example format strings (assumed that the QDateTime is 21 May 2001
2587     14:13:09):
2588
2589     \table
2590     \header \i Format       \i Result
2591     \row \i dd.MM.yyyy      \i 21.05.2001
2592     \row \i ddd MMMM d yy   \i Tue May 21 01
2593     \row \i hh:mm:ss.zzz    \i 14:13:09.042
2594     \row \i h:m:s ap        \i 2:13:9 pm
2595     \endtable
2596
2597     If the datetime is invalid, an empty string will be returned.
2598
2599     \sa QDate::toString() QTime::toString()
2600 */
2601 QString QDateTime::toString(const QString& format) const
2602 {
2603     return fmtDateTime(format, &d->time, &d->date);
2604 }
2605 #endif //QT_NO_DATESTRING
2606
2607 /*!
2608     Returns a QDateTime object containing a datetime \a ndays days
2609     later than the datetime of this object (or earlier if \a ndays is
2610     negative).
2611
2612     \sa daysTo(), addMonths(), addYears(), addSecs()
2613 */
2614
2615 QDateTime QDateTime::addDays(int ndays) const
2616 {
2617     return QDateTime(d->date.addDays(ndays), d->time, timeSpec());
2618 }
2619
2620 /*!
2621     Returns a QDateTime object containing a datetime \a nmonths months
2622     later than the datetime of this object (or earlier if \a nmonths
2623     is negative).
2624
2625     \sa daysTo(), addDays(), addYears(), addSecs()
2626 */
2627
2628 QDateTime QDateTime::addMonths(int nmonths) const
2629 {
2630     return QDateTime(d->date.addMonths(nmonths), d->time, timeSpec());
2631 }
2632
2633 /*!
2634     Returns a QDateTime object containing a datetime \a nyears years
2635     later than the datetime of this object (or earlier if \a nyears is
2636     negative).
2637
2638     \sa daysTo(), addDays(), addMonths(), addSecs()
2639 */
2640
2641 QDateTime QDateTime::addYears(int nyears) const
2642 {
2643     return QDateTime(d->date.addYears(nyears), d->time, timeSpec());
2644 }
2645
2646 QDateTime QDateTimePrivate::addMSecs(const QDateTime &dt, qint64 msecs)
2647 {
2648     QDate utcDate;
2649     QTime utcTime;
2650     dt.d->getUTC(utcDate, utcTime);
2651
2652     addMSecs(utcDate, utcTime, msecs);
2653
2654     return QDateTime(utcDate, utcTime, Qt::UTC).toTimeSpec(dt.timeSpec());
2655 }
2656
2657 /*!
2658  Adds \a msecs to utcDate and \a utcTime as appropriate. It is assumed that
2659  utcDate and utcTime are adjusted to UTC.
2660
2661  \since 4.5
2662  \internal
2663  */
2664 void QDateTimePrivate::addMSecs(QDate &utcDate, QTime &utcTime, qint64 msecs)
2665 {
2666     uint dd = utcDate.jd;
2667     int tt = utcTime.ds();
2668     int sign = 1;
2669     if (msecs < 0) {
2670         msecs = -msecs;
2671         sign = -1;
2672     }
2673     if (msecs >= int(MSECS_PER_DAY)) {
2674         dd += sign * (msecs / MSECS_PER_DAY);
2675         msecs %= MSECS_PER_DAY;
2676     }
2677
2678     tt += sign * msecs;
2679     if (tt < 0) {
2680         tt = MSECS_PER_DAY - tt - 1;
2681         dd -= tt / MSECS_PER_DAY;
2682         tt = tt % MSECS_PER_DAY;
2683         tt = MSECS_PER_DAY - tt - 1;
2684     } else if (tt >= int(MSECS_PER_DAY)) {
2685         dd += tt / MSECS_PER_DAY;
2686         tt = tt % MSECS_PER_DAY;
2687     }
2688
2689     utcDate.jd = dd;
2690     utcTime.mds = tt;
2691 }
2692
2693 /*!
2694     Returns a QDateTime object containing a datetime \a s seconds
2695     later than the datetime of this object (or earlier if \a s is
2696     negative).
2697
2698     \sa addMSecs(), secsTo(), addDays(), addMonths(), addYears()
2699 */
2700
2701 QDateTime QDateTime::addSecs(int s) const
2702 {
2703     return d->addMSecs(*this, qint64(s) * 1000);
2704 }
2705
2706 /*!
2707     Returns a QDateTime object containing a datetime \a msecs miliseconds
2708     later than the datetime of this object (or earlier if \a msecs is
2709     negative).
2710
2711     \sa addSecs(), msecsTo(), addDays(), addMonths(), addYears()
2712 */
2713 QDateTime QDateTime::addMSecs(qint64 msecs) const
2714 {
2715     return d->addMSecs(*this, msecs);
2716 }
2717
2718 /*!
2719     Returns the number of days from this datetime to the \a other
2720     datetime. If the \a other datetime is earlier than this datetime,
2721     the value returned is negative.
2722
2723     \sa addDays(), secsTo(), msecsTo()
2724 */
2725
2726 int QDateTime::daysTo(const QDateTime &other) const
2727 {
2728     return d->date.daysTo(other.d->date);
2729 }
2730
2731 /*!
2732     Returns the number of seconds from this datetime to the \a other
2733     datetime. If the \a other datetime is earlier than this datetime,
2734     the value returned is negative.
2735
2736     Before performing the comparison, the two datetimes are converted
2737     to Qt::UTC to ensure that the result is correct if one of the two
2738     datetimes has daylight saving time (DST) and the other doesn't.
2739
2740     Example:
2741     \snippet doc/src/snippets/code/src_corelib_tools_qdatetime.cpp 11
2742
2743     \sa addSecs(), daysTo(), QTime::secsTo()
2744 */
2745
2746 int QDateTime::secsTo(const QDateTime &other) const
2747 {
2748     QDate date1, date2;
2749     QTime time1, time2;
2750
2751     d->getUTC(date1, time1);
2752     other.d->getUTC(date2, time2);
2753
2754     return (date1.daysTo(date2) * SECS_PER_DAY) + time1.secsTo(time2);
2755 }
2756
2757 /*!
2758     \since 4.7
2759
2760     Returns the number of milliseconds from this datetime to the \a other
2761     datetime. If the \a other datetime is earlier than this datetime,
2762     the value returned is negative.
2763
2764     Before performing the comparison, the two datetimes are converted
2765     to Qt::UTC to ensure that the result is correct if one of the two
2766     datetimes has daylight saving time (DST) and the other doesn't.
2767
2768     \sa addMSecs(), daysTo(), QTime::msecsTo()
2769 */
2770
2771 qint64 QDateTime::msecsTo(const QDateTime &other) const
2772 {
2773     QDate selfDate;
2774     QDate otherDate;
2775     QTime selfTime;
2776     QTime otherTime;
2777
2778     d->getUTC(selfDate, selfTime);
2779     other.d->getUTC(otherDate, otherTime);
2780
2781     return (static_cast<qint64>(selfDate.daysTo(otherDate)) * static_cast<qint64>(MSECS_PER_DAY))
2782            + static_cast<qint64>(selfTime.msecsTo(otherTime));
2783 }
2784
2785
2786 /*!
2787     \fn QDateTime QDateTime::toTimeSpec(Qt::TimeSpec specification) const
2788
2789     Returns a copy of this datetime configured to use the given time
2790     \a specification.
2791
2792     \sa timeSpec(), toUTC(), toLocalTime()
2793 */
2794
2795 QDateTime QDateTime::toTimeSpec(Qt::TimeSpec spec) const
2796 {
2797     if ((d->spec == QDateTimePrivate::UTC) == (spec == Qt::UTC))
2798         return *this;
2799
2800     QDateTime ret;
2801     if (spec == Qt::UTC) {
2802         d->getUTC(ret.d->date, ret.d->time);
2803         ret.d->spec = QDateTimePrivate::UTC;
2804     } else {
2805         ret.d->spec = d->getLocal(ret.d->date, ret.d->time);
2806     }
2807     return ret;
2808 }
2809
2810 /*!
2811     Returns true if this datetime is equal to the \a other datetime;
2812     otherwise returns false.
2813
2814     \sa operator!=()
2815 */
2816
2817 bool QDateTime::operator==(const QDateTime &other) const
2818 {
2819     if (d->spec == other.d->spec && d->utcOffset == other.d->utcOffset)
2820         return d->time == other.d->time && d->date == other.d->date;
2821     else {
2822         QDate date1, date2;
2823         QTime time1, time2;
2824
2825         d->getUTC(date1, time1);
2826         other.d->getUTC(date2, time2);
2827         return time1 == time2 && date1 == date2;
2828     }
2829 }
2830
2831 /*!
2832     \fn bool QDateTime::operator!=(const QDateTime &other) const
2833
2834     Returns true if this datetime is different from the \a other
2835     datetime; otherwise returns false.
2836
2837     Two datetimes are different if either the date, the time, or the
2838     time zone components are different.
2839
2840     \sa operator==()
2841 */
2842
2843 /*!
2844     Returns true if this datetime is earlier than the \a other
2845     datetime; otherwise returns false.
2846 */
2847
2848 bool QDateTime::operator<(const QDateTime &other) const
2849 {
2850     if (d->spec == other.d->spec && d->spec != QDateTimePrivate::OffsetFromUTC) {
2851         if (d->date != other.d->date)
2852             return d->date < other.d->date;
2853         return d->time < other.d->time;
2854     } else {
2855         QDate date1, date2;
2856         QTime time1, time2;
2857         d->getUTC(date1, time1);
2858         other.d->getUTC(date2, time2);
2859         if (date1 != date2)
2860             return date1 < date2;
2861         return time1 < time2;
2862     }
2863 }
2864
2865 /*!
2866     \fn bool QDateTime::operator<=(const QDateTime &other) const
2867
2868     Returns true if this datetime is earlier than or equal to the
2869     \a other datetime; otherwise returns false.
2870 */
2871
2872 /*!
2873     \fn bool QDateTime::operator>(const QDateTime &other) const
2874
2875     Returns true if this datetime is later than the \a other datetime;
2876     otherwise returns false.
2877 */
2878
2879 /*!
2880     \fn bool QDateTime::operator>=(const QDateTime &other) const
2881
2882     Returns true if this datetime is later than or equal to the
2883     \a other datetime; otherwise returns false.
2884 */
2885
2886 /*!
2887     \fn QDateTime QDateTime::currentDateTime()
2888     Returns the current datetime, as reported by the system clock, in
2889     the local time zone.
2890
2891     \sa currentDateTimeUtc(), QDate::currentDate(), QTime::currentTime(), toTimeSpec()
2892 */
2893
2894 /*!
2895     \fn QDateTime QDateTime::currentDateTimeUtc()
2896     \since 4.7
2897     Returns the current datetime, as reported by the system clock, in
2898     UTC.
2899
2900     \sa currentDateTime(), QDate::currentDate(), QTime::currentTime(), toTimeSpec()
2901 */
2902
2903 /*!
2904     \fn qint64 QDateTime::currentMSecsSinceEpoch()
2905     \since 4.7
2906
2907     Returns the number of milliseconds since 1970-01-01T00:00:00 Universal
2908     Coordinated Time. This number is like the POSIX time_t variable, but
2909     expressed in milliseconds instead.
2910
2911     \sa currentDateTime(), currentDateTimeUtc(), toTime_t(), toTimeSpec()
2912 */
2913
2914 static inline uint msecsFromDecomposed(int hour, int minute, int sec, int msec = 0)
2915 {
2916     return MSECS_PER_HOUR * hour + MSECS_PER_MIN * minute + 1000 * sec + msec;
2917 }
2918
2919 #if defined(Q_OS_WIN)
2920 QDate QDate::currentDate()
2921 {
2922     QDate d;
2923     SYSTEMTIME st;
2924     memset(&st, 0, sizeof(SYSTEMTIME));
2925     GetLocalTime(&st);
2926     d.jd = julianDayFromDate(st.wYear, st.wMonth, st.wDay);
2927     return d;
2928 }
2929
2930 QTime QTime::currentTime()
2931 {
2932     QTime ct;
2933     SYSTEMTIME st;
2934     memset(&st, 0, sizeof(SYSTEMTIME));
2935     GetLocalTime(&st);
2936     ct.mds = msecsFromDecomposed(st.wHour, st.wMinute, st.wSecond, st.wMilliseconds);
2937 #if defined(Q_OS_WINCE)
2938     ct.startTick = GetTickCount() % MSECS_PER_DAY;
2939 #endif
2940     return ct;
2941 }
2942
2943 QDateTime QDateTime::currentDateTime()
2944 {
2945     QDate d;
2946     QTime t;
2947     SYSTEMTIME st;
2948     memset(&st, 0, sizeof(SYSTEMTIME));
2949     GetLocalTime(&st);
2950     d.jd = julianDayFromDate(st.wYear, st.wMonth, st.wDay);
2951     t.mds = msecsFromDecomposed(st.wHour, st.wMinute, st.wSecond, st.wMilliseconds);
2952     return QDateTime(d, t);
2953 }
2954
2955 QDateTime QDateTime::currentDateTimeUtc()
2956 {
2957     QDate d;
2958     QTime t;
2959     SYSTEMTIME st;
2960     memset(&st, 0, sizeof(SYSTEMTIME));
2961     GetSystemTime(&st);
2962     d.jd = julianDayFromDate(st.wYear, st.wMonth, st.wDay);
2963     t.mds = msecsFromDecomposed(st.wHour, st.wMinute, st.wSecond, st.wMilliseconds);
2964     return QDateTime(d, t, Qt::UTC);
2965 }
2966
2967 qint64 QDateTime::currentMSecsSinceEpoch()
2968 {
2969     QDate d;
2970     QTime t;
2971     SYSTEMTIME st;
2972     memset(&st, 0, sizeof(SYSTEMTIME));
2973     GetSystemTime(&st);
2974
2975     return msecsFromDecomposed(st.wHour, st.wMinute, st.wSecond, st.wMilliseconds) +
2976             qint64(julianDayFromGregorianDate(st.wYear, st.wMonth, st.wDay)
2977                    - julianDayFromGregorianDate(1970, 1, 1)) * Q_INT64_C(86400000);
2978 }
2979
2980 #elif defined(Q_OS_SYMBIAN)
2981 QDate QDate::currentDate()
2982 {
2983     QDate d;
2984     TTime localTime;
2985     localTime.HomeTime();
2986     TDateTime localDateTime = localTime.DateTime();
2987     // months and days are zero indexed
2988     d.jd = julianDayFromDate(localDateTime.Year(), localDateTime.Month() + 1, localDateTime.Day() + 1 );
2989     return d;
2990 }
2991
2992 QTime QTime::currentTime()
2993 {
2994     QTime ct;
2995     TTime localTime;
2996     localTime.HomeTime();
2997     TDateTime localDateTime = localTime.DateTime();
2998     ct.mds = msecsFromDecomposed(localDateTime.Hour(), localDateTime.Minute(),
2999                                  localDateTime.Second(), localDateTime.MicroSecond() / 1000);
3000     return ct;
3001 }
3002
3003 QDateTime QDateTime::currentDateTime()
3004 {
3005     QDate d;
3006     QTime ct;
3007     TTime localTime;
3008     localTime.HomeTime();
3009     TDateTime localDateTime = localTime.DateTime();
3010     // months and days are zero indexed
3011     d.jd = julianDayFromDate(localDateTime.Year(), localDateTime.Month() + 1, localDateTime.Day() + 1);
3012     ct.mds = msecsFromDecomposed(localDateTime.Hour(), localDateTime.Minute(),
3013                                  localDateTime.Second(), localDateTime.MicroSecond() / 1000);
3014     return QDateTime(d, ct);
3015 }
3016
3017 QDateTime QDateTime::currentDateTimeUtc()
3018 {
3019     QDate d;
3020     QTime ct;
3021     TTime gmTime;
3022     gmTime.UniversalTime();
3023     TDateTime gmtDateTime = gmTime.DateTime();
3024     // months and days are zero indexed
3025     d.jd = julianDayFromDate(gmtDateTime.Year(), gmtDateTime.Month() + 1, gmtDateTime.Day() + 1);
3026     ct.mds = msecsFromDecomposed(gmtDateTime.Hour(), gmtDateTime.Minute(),
3027                                  gmtDateTime.Second(), gmtDateTime.MicroSecond() / 1000);
3028     return QDateTime(d, ct, Qt::UTC);
3029 }
3030
3031 qint64 QDateTime::currentMSecsSinceEpoch()
3032 {
3033     QDate d;
3034     QTime ct;
3035     TTime gmTime;
3036     gmTime.UniversalTime();
3037     TDateTime gmtDateTime = gmTime.DateTime();
3038
3039     // according to the documentation, the value is:
3040     // "a date and time as a number of microseconds since midnight, January 1st, 0 AD nominal Gregorian"
3041     qint64 value = gmTime.Int64();
3042
3043     // whereas 1970-01-01T00:00:00 is (in the same representation):
3044     //   ((1970 * 365) + (1970 / 4) - (1970 / 100) + (1970 / 400) - 13) * 86400 * 1000000
3045     static const qint64 unixEpoch = Q_INT64_C(0xdcddb30f2f8000);
3046
3047     return (value - unixEpoch) / 1000;
3048 }
3049
3050 #elif defined(Q_OS_UNIX)
3051 QDate QDate::currentDate()
3052 {
3053     QDate d;
3054     // posix compliant system
3055     time_t ltime;
3056     time(&ltime);
3057     struct tm *t = 0;
3058
3059 #if !defined(QT_NO_THREAD) && defined(_POSIX_THREAD_SAFE_FUNCTIONS)
3060     // use the reentrant version of localtime() where available
3061     tzset();
3062     struct tm res;
3063     t = localtime_r(&ltime, &res);
3064 #else
3065     t = localtime(&ltime);
3066 #endif // !QT_NO_THREAD && _POSIX_THREAD_SAFE_FUNCTIONS
3067
3068     d.jd = julianDayFromDate(t->tm_year + 1900, t->tm_mon + 1, t->tm_mday);
3069     return d;
3070 }
3071
3072 QTime QTime::currentTime()
3073 {
3074     QTime ct;
3075     // posix compliant system
3076     struct timeval tv;
3077     gettimeofday(&tv, 0);
3078     time_t ltime = tv.tv_sec;
3079     struct tm *t = 0;
3080
3081 #if !defined(QT_NO_THREAD) && defined(_POSIX_THREAD_SAFE_FUNCTIONS)
3082     // use the reentrant version of localtime() where available
3083     tzset();
3084     struct tm res;
3085     t = localtime_r(&ltime, &res);
3086 #else
3087     t = localtime(&ltime);
3088 #endif
3089     Q_CHECK_PTR(t);
3090
3091     ct.mds = msecsFromDecomposed(t->tm_hour, t->tm_min, t->tm_sec, tv.tv_usec / 1000);
3092     return ct;
3093 }
3094
3095 QDateTime QDateTime::currentDateTime()
3096 {
3097     // posix compliant system
3098     // we have milliseconds
3099     struct timeval tv;
3100     gettimeofday(&tv, 0);
3101     time_t ltime = tv.tv_sec;
3102     struct tm *t = 0;
3103
3104 #if !defined(QT_NO_THREAD) && defined(_POSIX_THREAD_SAFE_FUNCTIONS)
3105     // use the reentrant version of localtime() where available
3106     tzset();
3107     struct tm res;
3108     t = localtime_r(&ltime, &res);
3109 #else
3110     t = localtime(&ltime);
3111 #endif
3112
3113     QDateTime dt;
3114     dt.d->time.mds = msecsFromDecomposed(t->tm_hour, t->tm_min, t->tm_sec, tv.tv_usec / 1000);
3115
3116     dt.d->date.jd = julianDayFromDate(t->tm_year + 1900, t->tm_mon + 1, t->tm_mday);
3117     dt.d->spec = t->tm_isdst > 0  ? QDateTimePrivate::LocalDST :
3118                  t->tm_isdst == 0 ? QDateTimePrivate::LocalStandard :
3119                  QDateTimePrivate::LocalUnknown;
3120     return dt;
3121 }
3122
3123 QDateTime QDateTime::currentDateTimeUtc()
3124 {
3125     // posix compliant system
3126     // we have milliseconds
3127     struct timeval tv;
3128     gettimeofday(&tv, 0);
3129     time_t ltime = tv.tv_sec;
3130     struct tm *t = 0;
3131
3132 #if !defined(QT_NO_THREAD) && defined(_POSIX_THREAD_SAFE_FUNCTIONS)
3133     // use the reentrant version of localtime() where available
3134     struct tm res;
3135     t = gmtime_r(&ltime, &res);
3136 #else
3137     t = gmtime(&ltime);
3138 #endif
3139
3140     QDateTime dt;
3141     dt.d->time.mds = msecsFromDecomposed(t->tm_hour, t->tm_min, t->tm_sec, tv.tv_usec / 1000);
3142
3143     dt.d->date.jd = julianDayFromDate(t->tm_year + 1900, t->tm_mon + 1, t->tm_mday);
3144     dt.d->spec = QDateTimePrivate::UTC;
3145     return dt;
3146 }
3147
3148 qint64 QDateTime::currentMSecsSinceEpoch()
3149 {
3150     // posix compliant system
3151     // we have milliseconds
3152     struct timeval tv;
3153     gettimeofday(&tv, 0);
3154     return qint64(tv.tv_sec) * Q_INT64_C(1000) + tv.tv_usec / 1000;
3155 }
3156
3157 #else
3158 #error "What system is this?"
3159 #endif
3160
3161 /*!
3162   \since 4.2
3163
3164   Returns a datetime whose date and time are the number of \a seconds
3165   that have passed since 1970-01-01T00:00:00, Coordinated Universal
3166   Time (Qt::UTC). On systems that do not support time zones, the time
3167   will be set as if local time were Qt::UTC.
3168
3169   \sa toTime_t(), setTime_t()
3170 */
3171 QDateTime QDateTime::fromTime_t(uint seconds)
3172 {
3173     QDateTime d;
3174     d.setTime_t(seconds);
3175     return d;
3176 }
3177
3178 /*!
3179   \since 4.7
3180
3181   Returns a datetime whose date and time are the number of milliseconds, \a msecs,
3182   that have passed since 1970-01-01T00:00:00.000, Coordinated Universal
3183   Time (Qt::UTC). On systems that do not support time zones, the time
3184   will be set as if local time were Qt::UTC.
3185
3186   Note that there are possible values for \a msecs that lie outside the valid
3187   range of QDateTime, both negative and positive. The behavior of this
3188   function is undefined for those values.
3189
3190   \sa toTime_t(), setTime_t()
3191 */
3192 QDateTime QDateTime::fromMSecsSinceEpoch(qint64 msecs)
3193 {
3194     QDateTime d;
3195     d.setMSecsSinceEpoch(msecs);
3196     return d;
3197 }
3198
3199 /*!
3200  \since 4.4
3201  \internal
3202
3203  Sets the offset from UTC to \a seconds, and also sets timeSpec() to
3204  Qt::OffsetFromUTC.
3205
3206  The maximum and minimum offset is 14 positive or negative hours.  If
3207  \a seconds is larger or smaller than that, the result is undefined.
3208
3209  0 as offset is identical to UTC. Therefore, if \a seconds is 0, the
3210  timeSpec() will be set to Qt::UTC. Hence the UTC offset always
3211  relates to UTC, and can never relate to local time.
3212
3213  \sa isValid(), utcOffset()
3214  */
3215 void QDateTime::setUtcOffset(int seconds)
3216 {
3217     detach();
3218
3219     /* The motivation to also setting d->spec is to ensure that the QDateTime
3220      * instance stay in well-defined states all the time, instead of that
3221      * we instruct the user to ensure it. */
3222     if(seconds == 0)
3223         d->spec = QDateTimePrivate::UTC;
3224     else
3225         d->spec = QDateTimePrivate::OffsetFromUTC;
3226
3227     /* Even if seconds is 0 we assign it to utcOffset. */
3228     d->utcOffset = seconds;
3229 }
3230
3231 /*!
3232  \since 4.4
3233  \internal
3234
3235  Returns the UTC offset in seconds. If the timeSpec() isn't
3236  Qt::OffsetFromUTC, 0 is returned. However, since 0 is a valid UTC
3237  offset the return value of this function cannot be used to determine
3238  whether a utcOffset() is used or is valid, timeSpec() must be
3239  checked.
3240
3241  Likewise, if this QDateTime() is invalid or if timeSpec() isn't
3242  Qt::OffsetFromUTC, 0 is returned.
3243
3244  The UTC offset only applies if the timeSpec() is Qt::OffsetFromUTC.
3245
3246  \sa isValid(), setUtcOffset()
3247  */
3248 int QDateTime::utcOffset() const
3249 {
3250     if(isValid() && d->spec == QDateTimePrivate::OffsetFromUTC)
3251         return d->utcOffset;
3252     else
3253         return 0;
3254 }
3255
3256 #ifndef QT_NO_DATESTRING
3257
3258 static int fromShortMonthName(const QString &monthName)
3259 {
3260     // Assume that English monthnames are the default
3261     for (int i = 0; i < 12; ++i) {
3262         if (monthName == QLatin1String(qt_shortMonthNames[i]))
3263             return i + 1;
3264     }
3265     // If English names can't be found, search the localized ones
3266     for (int i = 1; i <= 12; ++i) {
3267         if (monthName == QDate::shortMonthName(i))
3268             return i;
3269     }
3270     return -1;
3271 }
3272
3273 /*!
3274     \fn QDateTime QDateTime::fromString(const QString &string, Qt::DateFormat format)
3275
3276     Returns the QDateTime represented by the \a string, using the
3277     \a format given, or an invalid datetime if this is not possible.
3278
3279     Note for Qt::TextDate: It is recommended that you use the
3280     English short month names (e.g. "Jan"). Although localized month
3281     names can also be used, they depend on the user's locale settings.
3282 */
3283 QDateTime QDateTime::fromString(const QString& s, Qt::DateFormat f)
3284 {
3285     if (s.isEmpty()) {
3286         return QDateTime();
3287     }
3288
3289     switch (f) {
3290     case Qt::ISODate: {
3291         QString tmp = s;
3292         Qt::TimeSpec ts = Qt::LocalTime;
3293         const QDate date = QDate::fromString(tmp.left(10), Qt::ISODate);
3294         if (tmp.size() == 10)
3295             return QDateTime(date);
3296
3297         tmp = tmp.mid(11);
3298
3299         // Recognize UTC specifications
3300         if (tmp.endsWith(QLatin1Char('Z'))) {
3301             ts = Qt::UTC;
3302             tmp.chop(1);
3303         }
3304
3305         // Recognize timezone specifications
3306         QRegExp rx(QLatin1String("[+-]"));
3307         if (tmp.contains(rx)) {
3308             int idx = tmp.indexOf(rx);
3309             QString tmp2 = tmp.mid(idx);
3310             tmp = tmp.left(idx);
3311             bool ok = true;
3312             int ntzhour = 1;
3313             int ntzminute = 3;
3314             if ( tmp2.indexOf(QLatin1Char(':')) == 3 )
3315                ntzminute = 4;
3316             const int tzhour(tmp2.mid(ntzhour, 2).toInt(&ok));
3317             const int tzminute(tmp2.mid(ntzminute, 2).toInt(&ok));
3318             QTime tzt(tzhour, tzminute);
3319             int utcOffset = (tzt.hour() * 60 + tzt.minute()) * 60;
3320             if ( utcOffset != 0 ) {
3321                 ts = Qt::OffsetFromUTC;
3322                 QDateTime dt(date, QTime::fromString(tmp, Qt::ISODate), ts);
3323                 dt.setUtcOffset( utcOffset * (tmp2.startsWith(QLatin1Char('-')) ? -1 : 1) );
3324                 return dt;
3325             }
3326         }
3327         return QDateTime(date, QTime::fromString(tmp, Qt::ISODate), ts);
3328     }
3329     case Qt::SystemLocaleDate:
3330     case Qt::SystemLocaleShortDate:
3331     case Qt::SystemLocaleLongDate:
3332         return fromString(s, QLocale::system().dateTimeFormat(f == Qt::SystemLocaleLongDate ? QLocale::LongFormat
3333                                                                                             : QLocale::ShortFormat));
3334     case Qt::LocaleDate:
3335     case Qt::DefaultLocaleShortDate:
3336     case Qt::DefaultLocaleLongDate:
3337         return fromString(s, QLocale().dateTimeFormat(f == Qt::DefaultLocaleLongDate ? QLocale::LongFormat
3338                                                                                      : QLocale::ShortFormat));
3339 #if !defined(QT_NO_TEXTDATE)
3340     case Qt::TextDate: {
3341         QStringList parts = s.split(QLatin1Char(' '), QString::SkipEmptyParts);
3342
3343         if ((parts.count() < 5) || (parts.count() > 6)) {
3344             return QDateTime();
3345         }
3346
3347         // Accept "Sun Dec 1 13:02:00 1974" and "Sun 1. Dec 13:02:00 1974"
3348         int month = -1, day = -1;
3349         bool ok;
3350
3351         month = fromShortMonthName(parts.at(1));
3352         if (month != -1) {
3353             day = parts.at(2).toInt(&ok);
3354             if (!ok)
3355                 day = -1;
3356         }
3357
3358         if (month == -1 || day == -1) {
3359             // first variant failed, lets try the other
3360             month = fromShortMonthName(parts.at(2));
3361             if (month != -1) {
3362                 QString dayStr = parts.at(1);
3363                 if (dayStr.endsWith(QLatin1Char('.'))) {
3364                     dayStr.chop(1);
3365                     day = dayStr.toInt(&ok);
3366                     if (!ok)
3367                         day = -1;
3368                 } else {
3369                     day = -1;
3370                 }
3371             }
3372         }
3373
3374         if (month == -1 || day == -1) {
3375             // both variants failed, give up
3376             return QDateTime();
3377         }
3378
3379         int year;
3380         QStringList timeParts = parts.at(3).split(QLatin1Char(':'));
3381         if ((timeParts.count() == 3) || (timeParts.count() == 2)) {
3382             year = parts.at(4).toInt(&ok);
3383             if (!ok)
3384                 return QDateTime();
3385         } else {
3386             timeParts = parts.at(4).split(QLatin1Char(':'));
3387             if ((timeParts.count() != 3) && (timeParts.count() != 2))
3388                 return QDateTime();
3389             year = parts.at(3).toInt(&ok);
3390             if (!ok)
3391                 return QDateTime();
3392         }
3393
3394         int hour = timeParts.at(0).toInt(&ok);
3395         if (!ok) {
3396             return QDateTime();
3397         }
3398
3399         int minute = timeParts.at(1).toInt(&ok);
3400         if (!ok) {
3401             return QDateTime();
3402         }
3403
3404         int second = (timeParts.count() > 2) ? timeParts.at(2).toInt(&ok) : 0;
3405         if (!ok) {
3406             return QDateTime();
3407         }
3408
3409         QDate date(year, month, day);
3410         QTime time(hour, minute, second);
3411
3412         if (parts.count() == 5)
3413             return QDateTime(date, time, Qt::LocalTime);
3414
3415         QString tz = parts.at(5);
3416         if (!tz.startsWith(QLatin1String("GMT"), Qt::CaseInsensitive))
3417             return QDateTime();
3418         QDateTime dt(date, time, Qt::UTC);
3419         if (tz.length() > 3) {
3420             int tzoffset = 0;
3421             QChar sign = tz.at(3);
3422             if ((sign != QLatin1Char('+'))
3423                 && (sign != QLatin1Char('-'))) {
3424                 return QDateTime();
3425             }
3426             int tzhour = tz.mid(4, 2).toInt(&ok);
3427             if (!ok)
3428                 return QDateTime();
3429             int tzminute = tz.mid(6).toInt(&ok);
3430             if (!ok)
3431                 return QDateTime();
3432             tzoffset = (tzhour*60 + tzminute) * 60;
3433             if (sign == QLatin1Char('-'))
3434                 tzoffset = -tzoffset;
3435             dt.setUtcOffset(tzoffset);
3436         }
3437         return dt.toLocalTime();
3438     }
3439 #endif //QT_NO_TEXTDATE
3440     }
3441
3442     return QDateTime();
3443 }
3444
3445 /*!
3446     \fn QDateTime::fromString(const QString &string, const QString &format)
3447
3448     Returns the QDateTime represented by the \a string, using the \a
3449     format given, or an invalid datetime if the string cannot be parsed.
3450
3451     These expressions may be used for the date part of the format string:
3452
3453     \table
3454     \header \i Expression \i Output
3455     \row \i d \i the day as number without a leading zero (1 to 31)
3456     \row \i dd \i the day as number with a leading zero (01 to 31)
3457     \row \i ddd
3458             \i the abbreviated localized day name (e.g. 'Mon' to 'Sun').
3459             Uses QDate::shortDayName().
3460     \row \i dddd
3461             \i the long localized day name (e.g. 'Monday' to 'Sunday').
3462             Uses QDate::longDayName().
3463     \row \i M \i the month as number without a leading zero (1-12)
3464     \row \i MM \i the month as number with a leading zero (01-12)
3465     \row \i MMM
3466             \i the abbreviated localized month name (e.g. 'Jan' to 'Dec').
3467             Uses QDate::shortMonthName().
3468     \row \i MMMM
3469             \i the long localized month name (e.g. 'January' to 'December').
3470             Uses QDate::longMonthName().
3471     \row \i yy \i the year as two digit number (00-99)
3472     \row \i yyyy \i the year as four digit number
3473     \endtable
3474
3475     \note Unlike the other version of this function, day and month names must
3476     be given in the user's local language. It is only possible to use the English
3477     names if the user's language is English.
3478
3479     These expressions may be used for the time part of the format string:
3480
3481     \table
3482     \header \i Expression \i Output
3483     \row \i h
3484             \i the hour without a leading zero (0 to 23 or 1 to 12 if AM/PM display)
3485     \row \i hh
3486             \i the hour with a leading zero (00 to 23 or 01 to 12 if AM/PM display)
3487     \row \i H
3488             \i the hour without a leading zero (0 to 23, even with AM/PM display)
3489     \row \i HH
3490             \i the hour with a leading zero (00 to 23, even with AM/PM display)
3491     \row \i m \i the minute without a leading zero (0 to 59)
3492     \row \i mm \i the minute with a leading zero (00 to 59)
3493     \row \i s \i the second without a leading zero (0 to 59)
3494     \row \i ss \i the second with a leading zero (00 to 59)
3495     \row \i z \i the milliseconds without leading zeroes (0 to 999)
3496     \row \i zzz \i the milliseconds with leading zeroes (000 to 999)
3497     \row \i AP or A
3498          \i interpret as an AM/PM time. \e AP must be either "AM" or "PM".
3499     \row \i ap or a
3500          \i Interpret as an AM/PM time. \e ap must be either "am" or "pm".
3501     \endtable
3502
3503     All other input characters will be treated as text. Any sequence
3504     of characters that are enclosed in singlequotes will also be
3505     treated as text and not be used as an expression.
3506
3507     \snippet doc/src/snippets/code/src_corelib_tools_qdatetime.cpp 12
3508
3509     If the format is not satisfied an invalid QDateTime is returned.
3510     The expressions that don't have leading zeroes (d, M, h, m, s, z) will be
3511     greedy. This means that they will use two digits even if this will
3512     put them outside the range and/or leave too few digits for other
3513     sections.
3514
3515     \snippet doc/src/snippets/code/src_corelib_tools_qdatetime.cpp 13
3516
3517     This could have meant 1 January 00:30.00 but the M will grab
3518     two digits.
3519
3520     For any field that is not represented in the format the following
3521     defaults are used:
3522
3523     \table
3524     \header \i Field  \i Default value
3525     \row    \i Year   \i 1900
3526     \row    \i Month  \i 1 (January)
3527     \row    \i Day    \i 1
3528     \row    \i Hour   \i 0
3529     \row    \i Minute \i 0
3530     \row    \i Second \i 0
3531     \endtable
3532
3533     For example:
3534
3535     \snippet doc/src/snippets/code/src_corelib_tools_qdatetime.cpp 14
3536
3537     \sa QDate::fromString() QTime::fromString() QDate::toString()
3538     QDateTime::toString() QTime::toString()
3539 */
3540
3541 QDateTime QDateTime::fromString(const QString &string, const QString &format)
3542 {
3543 #ifndef QT_BOOTSTRAPPED
3544     QTime time;
3545     QDate date;
3546
3547     QDateTimeParser dt(QVariant::DateTime, QDateTimeParser::FromString);
3548     if (dt.parseFormat(format) && dt.fromString(string, &date, &time))
3549         return QDateTime(date, time);
3550 #else
3551     Q_UNUSED(string);
3552     Q_UNUSED(format);
3553 #endif
3554     return QDateTime(QDate(), QTime(-1, -1, -1));
3555 }
3556
3557 #endif // QT_NO_DATESTRING
3558 /*!
3559     \fn QDateTime QDateTime::toLocalTime() const
3560
3561     Returns a datetime containing the date and time information in
3562     this datetime, but specified using the Qt::LocalTime definition.
3563
3564     \sa toTimeSpec()
3565 */
3566
3567 /*!
3568     \fn QDateTime QDateTime::toUTC() const
3569
3570     Returns a datetime containing the date and time information in
3571     this datetime, but specified using the Qt::UTC definition.
3572
3573     \sa toTimeSpec()
3574 */
3575
3576 /*! \internal
3577  */
3578 void QDateTime::detach()
3579 {
3580     d.detach();
3581 }
3582
3583 /*****************************************************************************
3584   Date/time stream functions
3585  *****************************************************************************/
3586
3587 #ifndef QT_NO_DATASTREAM
3588 /*!
3589     \relates QDate
3590
3591     Writes the \a date to stream \a out.
3592
3593     \sa {Serializing Qt Data Types}
3594 */
3595
3596 QDataStream &operator<<(QDataStream &out, const QDate &date)
3597 {
3598     return out << (quint32)(date.jd);
3599 }
3600
3601 /*!
3602     \relates QDate
3603
3604     Reads a date from stream \a in into the \a date.
3605
3606     \sa {Serializing Qt Data Types}
3607 */
3608
3609 QDataStream &operator>>(QDataStream &in, QDate &date)
3610 {
3611     quint32 jd;
3612     in >> jd;
3613     date.jd = jd;
3614     return in;
3615 }
3616
3617 /*!
3618     \relates QTime
3619
3620     Writes \a time to stream \a out.
3621
3622     \sa {Serializing Qt Data Types}
3623 */
3624
3625 QDataStream &operator<<(QDataStream &out, const QTime &time)
3626 {
3627     return out << quint32(time.mds);
3628 }
3629
3630 /*!
3631     \relates QTime
3632
3633     Reads a time from stream \a in into the given \a time.
3634
3635     \sa {Serializing Qt Data Types}
3636 */
3637
3638 QDataStream &operator>>(QDataStream &in, QTime &time)
3639 {
3640     quint32 ds;
3641     in >> ds;
3642     time.mds = int(ds);
3643     return in;
3644 }
3645
3646 /*!
3647     \relates QDateTime
3648
3649     Writes \a dateTime to the \a out stream.
3650
3651     \sa {Serializing Qt Data Types}
3652 */
3653 QDataStream &operator<<(QDataStream &out, const QDateTime &dateTime)
3654 {
3655     out << dateTime.d->date << dateTime.d->time;
3656     if (out.version() >= 7)
3657         out << (qint8)dateTime.d->spec;
3658     return out;
3659 }
3660
3661 /*!
3662     \relates QDateTime
3663
3664     Reads a datetime from the stream \a in into \a dateTime.
3665
3666     \sa {Serializing Qt Data Types}
3667 */
3668
3669 QDataStream &operator>>(QDataStream &in, QDateTime &dateTime)
3670 {
3671     dateTime.detach();
3672
3673     qint8 ts = (qint8)QDateTimePrivate::LocalUnknown;
3674     in >> dateTime.d->date >> dateTime.d->time;