qcalendar.cpp

Go to the documentation of this file.

// Copyright (C) 2021 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:significant reason:default
#include "qcalendar.h"
#include "qcalendarbackend_p.h"
#include "qgregoriancalendar_p.h"
#ifndef QT_BOOTSTRAPPED
#include "qjuliancalendar_p.h"
#include "qmilankoviccalendar_p.h"
#endif
#if QT_CONFIG(jalalicalendar)
#include "qjalalicalendar_p.h"
#endif
#if QT_CONFIG(islamiccivilcalendar)
#include "qislamiccivilcalendar_p.h"
#endif
 
#include <private/qflatmap_p.h>
#include "qatomic.h"
#include "qdatetime.h"
#include "qcalendarmath_p.h"
#include <qhash.h>
#include <qreadwritelock.h>
 
#include <vector>
 
QT_BEGIN_NAMESPACE
 
struct QCalendarRegistryCaseInsensitiveAnyStringViewLessThan
{
    struct is_transparent {};
    bool operator()(QAnyStringView lhs, QAnyStringView rhs) const
    {
        return QAnyStringView::compare(lhs, rhs, Qt::CaseInsensitive) < 0;
    }
};
 
namespace QtPrivate {
 
/*
    \internal
    Handles calendar backend registration.
*/
class QCalendarRegistry
{
    Q_DISABLE_COPY_MOVE(QCalendarRegistry); // This is a singleton.
 
    static constexpr qsizetype ExpectedNumberOfBackends = qsizetype(QCalendar::System::Last) + 1;
 
    /*
        Lock protecting the registry from concurrent modification.
    */
    QReadWriteLock lock;
 
    /*
        Vector containing all registered backends.
 
        The indices 0 to \c QCalendar::System::Last inclusive are allocated
        for system backends and always present (but may be null).
    */
    std::vector<QCalendarBackend *> byId;
 
    /*
        Backends registered by name.
 
        Each backend may be registered with several names associated with it.
        The names are case-insensitive.
    */
    QFlatMap<
        QString, QCalendarBackend *,
        QCalendarRegistryCaseInsensitiveAnyStringViewLessThan,
        QStringList,
        std::vector<QCalendarBackend *>
    > byName;
 
    /*
        Pointer to the Gregorian backend for faster lockless access to it.
 
        This pointer may be null if the Gregorian backend is not yet registered.
        This pointer may only be set once and only when write lock is held on
        the registry.
    */
    QAtomicPointer<const QCalendarBackend> gregorianCalendar = nullptr;
 
    enum : int {
        Unpopulated, // The standard backends may not yet be created
        Populated, // All standard backends were created
        IsBeingDestroyed, // The registry and the backends are being destroyed
    };
 
    /*
        Fast way to check whether the standard calendars were populated.
 
        The status should only be changed while the write lock is held.
    */
    QAtomicInt status = Unpopulated;
 
    void ensurePopulated();
    QCalendarBackend *registerSystemBackendLockHeld(QCalendar::System system);
    void registerBackendLockHeld(QCalendarBackend *backend, const QStringList &names,
                                 QCalendar::System system);
 
public:
    QCalendarRegistry()
    {
        byId.resize(ExpectedNumberOfBackends);
        byName.reserve(ExpectedNumberOfBackends * 2); // assume one alias on average
    }
 
    ~QCalendarRegistry();
 
    bool isBeingDestroyed() const { return status.loadRelaxed() == IsBeingDestroyed; }
 
    void registerCustomBackend(QCalendarBackend *backend, const QStringList &names);
 
    QStringList availableCalendars();
 
    /*
        Returns backend for Gregorian calendar.
 
        The backend is returned without locking the registry if possible.
    */
    const QCalendarBackend *gregorian()
    {
        const QCalendarBackend *backend = gregorianCalendar.loadAcquire();
        if (Q_LIKELY(backend != nullptr))
            return backend;
        return fromEnum(QCalendar::System::Gregorian);
    }
 
    /*
        Returns \a true if the argument matches the registered Gregorian backend.
 
        \a backend should not be \nullptr.
    */
    bool isGregorian(const QCalendarBackend *backend) const
    {
        return backend == gregorianCalendar.loadRelaxed();
    }
 
    const QCalendarBackend *fromName(QAnyStringView name);
    const QCalendarBackend *fromIndex(size_t index);
    const QCalendarBackend *fromEnum(QCalendar::System system);
 
    QStringList backendNames(const QCalendarBackend *backend);
};
 
/*
    Destroy the registry.
 
    This destroys all registered backends. This destructor should only be called
    in a single-threaded context at program exit.
*/
QCalendarRegistry::~QCalendarRegistry()
{
    QWriteLocker locker(&lock);
 
    status.storeRelaxed(IsBeingDestroyed);
 
    qDeleteAll(byId);
}
 
/*
    Registers a custom backend.
 
    A new unique ID is allocated for the \a backend. The registry takes
    ownership of the \a backend.
 
    The \a names of the backend are also registered. Already registered
    names are not updated.
 
    The \a backend should not be already registered.
 
    The \a backend should be fully initialized. It becomes available
    to other threads before this function returns.
*/
void QCalendarRegistry::registerCustomBackend(QCalendarBackend *backend, const QStringList &names)
{
    Q_ASSERT(!backend->calendarId().isValid());
 
    ensurePopulated();
 
    QWriteLocker locker(&lock);
    registerBackendLockHeld(backend, names, QCalendar::System::User);
}
 
/*
    Ensures all system calendars have been instantiated.
 
    This arranges for each system backend to be registered. The method only
    does anything on its first call, which ensures that name-based lookups can
    always find all the calendars available via the \c QCalendar::System other
    than \c QCalendar::System::User.
*/
void QCalendarRegistry::ensurePopulated()
{
    if (Q_LIKELY(status.loadAcquire() != Unpopulated))
        return;
 
    QWriteLocker locker(&lock);
    if (status.loadAcquire() != Unpopulated)
        return;
 
    for (int i = 0; i <= int(QCalendar::System::Last); ++i) {
        if (byId[i] == nullptr)
            registerSystemBackendLockHeld(QCalendar::System(i));
    }
 
#if defined(QT_FORCE_ASSERTS) || !defined(QT_NO_DEBUG)
    auto oldValue = status.fetchAndStoreRelease(Populated);
    Q_ASSERT(oldValue == Unpopulated);
#else
    status.storeRelease(Populated);
#endif
}
 
/*
    Helper functions for system backend registration.
 
    This function must be called with write lock held on the registry.
 
    \sa registerSystemBackend
*/
QCalendarBackend *QCalendarRegistry::registerSystemBackendLockHeld(QCalendar::System system)
{
    Q_ASSERT(system != QCalendar::System::User);
 
    QCalendarBackend *backend = nullptr;
    QStringList names;
 
    switch (system) {
    case QCalendar::System::Gregorian:
        backend = new QGregorianCalendar;
        names = QGregorianCalendar::nameList();
        break;
#ifndef QT_BOOTSTRAPPED
    case QCalendar::System::Julian:
        backend = new QJulianCalendar;
        names = QJulianCalendar::nameList();
        break;
    case QCalendar::System::Milankovic:
        backend = new QMilankovicCalendar;
        names = QMilankovicCalendar::nameList();
        break;
#endif
#if QT_CONFIG(jalalicalendar)
    case QCalendar::System::Jalali:
        backend = new QJalaliCalendar;
        names = QJalaliCalendar::nameList();
        break;
#endif
#if QT_CONFIG(islamiccivilcalendar)
    case QCalendar::System::IslamicCivil:
        backend = new QIslamicCivilCalendar;
        names = QIslamicCivilCalendar::nameList();
        break;
#else // When highest-numbered system isn't enabled, ensure we have a case for Last:
    case QCalendar::System::Last:
#endif
    case QCalendar::System::User:
        Q_UNREACHABLE();
    }
    if (!backend)
        return nullptr;
 
    registerBackendLockHeld(backend, names, system);
    Q_ASSERT(backend == byId[size_t(system)]);
 
    return backend;
}
 
/*
    Helper function for backend registration.
 
    This function must be called with write lock held on the registry.
 
    \sa registerBackend
*/
void QCalendarRegistry::registerBackendLockHeld(QCalendarBackend *backend, const QStringList &names,
                                                QCalendar::System system)
{
    Q_ASSERT(!backend->calendarId().isValid());
 
    auto index = size_t(system);
 
    // Note: it is important to update the calendar ID before making
    // the calendar available for queries.
    if (system == QCalendar::System::User) {
        backend->setIndex(byId.size());
        byId.push_back(backend);
    } else if (byId[index] == nullptr) {
        backend->setIndex(index);
        if (system == QCalendar::System::Gregorian) {
#if defined(QT_FORCE_ASSERTS) || !defined(QT_NO_DEBUG)
            auto oldValue = gregorianCalendar.fetchAndStoreRelease(backend);
            Q_ASSERT(oldValue == nullptr);
#else
            gregorianCalendar.storeRelease(backend);
#endif
        }
 
        Q_ASSERT(byId.size() > index);
        Q_ASSERT(byId[index] == nullptr);
        byId[index] = backend;
    }
 
    // Register any names.
    for (const auto &name : names) {
        auto [it, inserted] = byName.try_emplace(name, backend);
        if (!inserted) {
            Q_ASSERT(system == QCalendar::System::User);
            qWarning("Cannot register name %ls (already in use) for %ls",
                     qUtf16Printable(name), qUtf16Printable(backend->name()));
        }
    }
}
 
/*
    Returns a list of names of the available calendar systems.
 
    Any QCalendarBackend sub-class must be registered before being exposed to Date
    and Time APIs.
 
    \sa fromName()
*/
QStringList QCalendarRegistry::availableCalendars()
{
    ensurePopulated();
 
    QReadLocker locker(&lock);
    return byName.keys();
}
 
/*
    Returns a pointer to a named calendar backend.
 
    If the given \a name is present in availableCalendars(), the backend
    matching it is returned. Otherwise, \nullptr is returned. Matching of
    names ignores case.
 
    \sa availableCalendars(), fromEnum(), fromIndex()
*/
const QCalendarBackend *QCalendarRegistry::fromName(QAnyStringView name)
{
    ensurePopulated();
 
    QReadLocker locker(&lock);
    return byName.value(name, nullptr);
}
 
/*
    Returns a pointer to a calendar backend, specified by index.
 
    If a calendar with ID \a index is known to the calendar registry, the backend
    with this ID is returned. Otherwise, \nullptr is returned.
 
    \sa fromEnum(), calendarId()
*/
const QCalendarBackend *QCalendarRegistry::fromIndex(size_t index)
{
    {
        QReadLocker locker(&lock);
 
        if (index >= byId.size())
            return nullptr;
 
        if (auto backend = byId[index])
            return backend;
    }
 
    if (index <= size_t(QCalendar::System::Last))
        return fromEnum(QCalendar::System(index));
 
    return nullptr;
}
 
/*
    Returns a pointer to a calendar backend, specified by \a system.
 
    This will instantiate the indicated calendar (which will enable fromName()
    to return it subsequently), but only for the Qt-supported calendars for
    which (where relevant) the appropriate feature has been enabled.
 
    \a system should be a member of \a QCalendar::System other than
    \a QCalendar::System::User.
 
    \sa fromName(), fromId()
*/
const QCalendarBackend *QCalendarRegistry::fromEnum(QCalendar::System system)
{
    Q_ASSERT(system <= QCalendar::System::Last);
    auto index = size_t(system);
 
    {
        QReadLocker locker(&lock);
        Q_ASSERT(byId.size() > index);
        if (auto backend = byId[index])
            return backend;
    }
 
    QWriteLocker locker(&lock);
 
    // Check if the backend was registered after releasing the read lock above.
    if (auto backend = byId[index])
        return backend;
 
    return registerSystemBackendLockHeld(system);
}
 
/*
    Returns a list of names \a backend was registered with.
*/
QStringList QCalendarRegistry::backendNames(const QCalendarBackend *backend)
{
    QStringList l;
    l.reserve(byName.size()); // too large, but never really large, so ok
 
    QT_WARNING_PUSH
    // Clang complains about the reference still causing a copy. The reference is idiomatic, but
    // runs afoul of QFlatMap's iterators which return a pair of references instead of a reference
    // to pair. Suppress the warning, because `const auto [key, value]` would look wrong.
    QT_WARNING_DISABLE_CLANG("-Wrange-loop-analysis")
    for (const auto &[key, value] : byName) {
        if (value == backend)
            l.push_back(key);
    }
    QT_WARNING_POP
 
    return l;
}
 
} // namespace QtPrivate
 
Q_GLOBAL_STATIC(QtPrivate::QCalendarRegistry, calendarRegistry);
 
/*!
    \since 5.14
 
    \class QCalendarBackend
    \inmodule QtCore
    \internal
    \reentrant
    \brief The QCalendarBackend class provides basic calendaring functions.
 
    QCalendarBackend provides the base class on which all calendar types are
    implemented. The backend must be registered before it is available via
    QCalendar API. The registration for system backends is arranged by
    the calendar registry. Custom backends may be registered using the
    \c registerCustomBackend() method.
 
    A backend may also be registered by one or more names. Registering with the
    name used by CLDR (the Unicode consortium's Common Locale Data Repository)
    is recommended, particularly when interacting with third-party software.
    Once a backend is registered for a name, QCalendar can be constructed using
    that name to select the backend.
 
    Each built-in backend has a distinct primary name and all built-in backends
    are instantiated before any custom backend is registered, to prevent custom
    backends with conflicting names from replacing built-in backends.
 
    Each calendar backend must inherit from QCalendarBackend and implement its
    pure virtual methods. It may also override some other virtual methods, as
    needed.
 
    Most backends are pure code, with only one data element (this base-classe's
    \c m_id). Such backends should normally be implemented as singletons.
 
    The backends may be used by multiple threads simultaneously. The virtual
    methods must be implemented in a \l {thread-safe} way.
 
    \section1 Instantiating backends
 
    Backends may be defined by third-party, plugin or user code. When such
    custom backends are registered they shall be allocated a unique ID, by
    which client code may access it. A custom backend instance can have no names
    if access by name is not needed, or impractical (e.g. because the backend
    is not a singleton and constructing names for each instance would not make
    sense). If a custom backend has names that are already registered for
    another backend, those names are ignored.
 
    A backend class that has instance variables as well as code may be
    instantiated many times, each with a distinct set of names, to implement
    distinct backends - presumably variants on some parameterized calendar.
    Each instance is then a distinct backend. A pure code backend class shall
    typically only be instantiated once, as it is only capable of representing
    one backend.
 
    Each backend should be instantiated exactly once, on the heap (using the C++
    \c new operator), so that the registry can take ownership of it after
    registration.
 
    Built-in backends, identified by \c QCalendar::System values other than
    \c{User}, should only be registered by \c{QCalendarRegistry::fromEnum()};
    no other code should ever register one, this guarantees that such a backend
    will be a singleton.
 
    The shareable base-classes for backends, QRomanCalendar and QHijriCalendar,
    are not themselves identified by QCalendar::System and may be used as
    base-classes for custom calendar backends, but cannot be instantiated
    themselves.
 
    \sa calendarId(), QDate, QDateTime, QDateEdit, QDateTimeEdit,
        QCalendarWidget, {The Low-Level API: Extending Qt Applications}
*/
 
/*!
    Destroys the calendar backend.
 
    Each calendar backend, once instantiated and successfully registered by ID,
    shall exist until it is destroyed by the registry. Destroying a
    successfully-registered backend otherwise may leave existing QCalendar
    instances referencing the destroyed calendar, with undefined results.
 
    If a backend has not been registered it may safely be deleted.
 
    \sa calendarId()
*/
QCalendarBackend::~QCalendarBackend()
{
    Q_ASSERT(!m_id.isValid() || calendarRegistry.isDestroyed()
             || calendarRegistry->isBeingDestroyed());
}
 
/*!
    \fn QString QCalendarBackend::name() const
    Returns the primary name of the calendar.
 */
 
/*!
    Returns list of names this backend was registered with.
 
    The list is a subset of the names passed to \c registerCustomBackend().
    Some names passed during the registration may not be associated
    with a backend if they were claimed by another backend first.
 
    \sa registerCustomBackend()
*/
QStringList QCalendarBackend::names() const
{
    if (Q_UNLIKELY(calendarRegistry.isDestroyed()))
        return {};
 
    return calendarRegistry->backendNames(this);
}
 
/*!
    Set the internal index of the backed to the specified value.
 
    This method exists to allow QCalendarRegistry to update the backend ID
    after registration without exposing it in public API for QCalendar.
 */
void QCalendarBackend::setIndex(size_t index)
{
    Q_ASSERT(!m_id.isValid());
    m_id.id = index;
}
 
/*!
    Register this backend as a custom backend.
 
    The backend should not already be registered. This method should only be
    called on objects that are completely initialized because they become
    available to other threads immediately. In particular, this function should
    not be called from backend constructors.
 
    The backend is also registered by names passed in \a names. Only the names
    that are not already registered are associated with the backend. The name
    matching is case-insensitive. The list of names associated with the backend
    can be queried using \c names() method after successful registration.
 
    Returns the new ID assigned to this backend. If its isValid() is \c true,
    the calendar registry has taken ownership of the object; this ID can then
    be used to create \c QCalendar instances. Otherwise, registration failed
    and the caller is responsible for destruction of the backend, which shall
    not be available for use by \c QCalendar. Failure should normally only
    happen if registration is attempted during program termination.
 
    \sa names()
*/
QCalendar::SystemId QCalendarBackend::registerCustomBackend(const QStringList &names)
{
    Q_ASSERT(!m_id.isValid());
 
    if (Q_LIKELY(!calendarRegistry.isDestroyed()))
        calendarRegistry->registerCustomBackend(this, names);
 
    return m_id;
}
 
bool QCalendarBackend::isGregorian() const
{
    if (Q_UNLIKELY(calendarRegistry.isDestroyed()))
        return false;
 
    return calendarRegistry->isGregorian(this);
}
 
/*!
    \since 6.2
    \fn QCalendar::SystemId QCalendarBackend::calendarId() const
 
    Each backend is allocated an ID when successfully registered. A backend whose
    calendarId() has isValid() \c{false} has not been registered; it also cannot
    be used, as it is not known to any of the available ways to create a QCalendar.
 
    \sa calendarSystem(), fromId()
*/
 
/*!
    The calendar system of this calendar.
 
    \sa fromEnum(), calendarId()
*/
QCalendar::System QCalendarBackend::calendarSystem() const
{
    return m_id.isInEnum() ? QCalendar::System(m_id.index()) : QCalendar::System::User;
}
 
/*
    Create local variable d containing the backend associated with a QCalendar
    instance unless the calendar registry is destroyed together with all backends,
    then return nullptr.
 
    This assumes that the registry is only destroyed in single threaded context.
*/
#define SAFE_D() const auto d = Q_UNLIKELY(calendarRegistry.isDestroyed()) ? nullptr : d_ptr
 
/*!
    The primary name of this calendar.
 
    The calendar may also be known by some aliases. A calendar instantiated by
    name may use such an alias, in which case its name() need not match the
    alias by which it was instantiated.
*/
QString QCalendar::name() const
{
    SAFE_D();
    return d ? d->name() : QString();
}
 
// date queries
/*!
   \fn int QCalendarBackend::daysInMonth(int month, int year) const
 
   Returns number of days in the month number \a month, in year \a year.
 
   An implementation should return 0 if the given year had no such month. If
   year is QCalendar::Unspecified, return the greatest number of days for the
   month, in any year.
 
   Calendars with intercalary days may represent these as extra days of the
   preceding month, or as short months separate from the usual ones. In the
   former case, daysInMonth(month, year) should be the number of ordinary days
   in the month, although \c{isDateValid(year, month, day)} might return \c true
   for some larger values of \c day.
 
   \sa daysInYear(), monthsInYear(), minimumDaysInMonth(), maximumDaysInMonth()
*/
 
// properties of the calendar
 
/*!
    \fn bool QCalendarBackend::isLeapYear(int year) const
 
    Returns \c true if the specified \a year is a leap year for this calendar.
 
    \sa daysInYear(), isDateValid()
*/
 
/*!
    \fn bool QCalendarBackend::isLunar() const
 
    Returns \c true if this calendar is a lunar calendar. Otherwise returns \c
    false.
 
    A lunar calendar is a calendar based upon the monthly cycles of the Moon's
    phases (synodic months). This contrasts with solar calendars, whose annual
    cycles are based only upon the solar year.
 
    \sa isLuniSolar(), isSolar(), isProleptic()
*/
 
/*!
    \fn bool QCalendarBackend::isLuniSolar() const
 
    Returns \c true if this calendar is a lunisolar calendar. Otherwise returns
    \c false.
 
    A lunisolar calendar is a calendar whose date indicates both the moon phase
    and the time of the solar year.
 
    \sa isLunar(), isSolar(), isProleptic()
*/
 
/*!
    \fn bool QCalendarBackend::isSolar() const
 
    Returns \c true if this calendar is a solar calendar. Otherwise returns
    \c false.
 
    A solar calendar is a calendar whose dates indicate the season or almost
    equivalently the apparent position of the sun relative to the fixed stars.
    The Gregorian calendar, widely accepted as standard in the world,
    is an example of solar calendar.
 
    \sa isLuniSolar(), isLunar(), isProleptic()
*/
 
/*!
    Returns the total number of days in the year number \a year.
    Returns zero if there is no such year in this calendar.
 
    This base implementation returns 366 for leap years and 365 for ordinary
    years.
 
    \sa monthsInYear(), daysInMonth(), isLeapYear()
*/
int QCalendarBackend::daysInYear(int year) const
{
    return monthsInYear(year) ? isLeapYear(year) ? 366 : 365 : 0;
}
 
/*!
    Returns the total number of months in the year number \a year.
    Returns zero if there is no such year in this calendar.
 
    This base implementation returns 12 for any valid year.
 
    \sa daysInYear(), maximumMonthsInYear(), isDateValid()
*/
int QCalendarBackend::monthsInYear(int year) const
{
    return year > 0 || (year < 0 ? isProleptic() : hasYearZero()) ? 12 : 0;
}
 
/*!
    Returns \c true if the date specified by \a year, \a month, and \a day is
    valid for this calendar; otherwise returns \c false. For example,
    the date 2018-04-19 is valid for the Gregorian calendar, but 2018-16-19 and
    2018-04-38 are invalid.
 
    Calendars with intercalary days may represent these as extra days of the
    preceding month or as short months separate from the usual ones. In the
    former case, a \a day value greater than \c{daysInMonth(\a{month},
    \a{year})} may be valid.
 
    \sa daysInMonth(), monthsInYear()
*/
bool QCalendarBackend::isDateValid(int year, int month, int day) const
{
    return day > 0 && day <= daysInMonth(month, year);
}
 
/*!
    Returns \c true if this calendar is a proleptic calendar. Otherwise returns
    \c false.
 
    A proleptic calendar results from allowing negative year numbers to indicate
    years before the nominal start of the calendar system.
 
    \sa isLuniSolar(), isSolar(), isLunar(), hasYearZero()
*/
 
bool QCalendarBackend::isProleptic() const
{
    return true;
}
 
/*!
    Returns \c true if year number \c 0 is considered a valid year in this
    calendar. Otherwise returns \c false.
 
    \sa isDateValid(), isProleptic()
*/
 
bool QCalendarBackend::hasYearZero() const
{
    return false;
}
 
/*!
    Returns the maximum number of days in a month for any year.
 
    This base implementation returns 31, as this is a common case.
 
    For calendars with intercalary days, although daysInMonth() doesn't include
    the intercalary days in its count for an individual month,
    maximumDaysInMonth() should include intercalary days, so that it is the
    maximum value of \c day for which \c{isDateValid(year, month, day)} can be
    true.
 
    \sa maximumMonthsInYear(), daysInMonth()
*/
int QCalendarBackend::maximumDaysInMonth() const
{
    return 31;
}
 
/*!
    Returns the minimum number of days in any valid month of any valid year.
 
    This base implementation returns 29, as this is a common case.
 
    \sa maximumMonthsInYear(), daysInMonth()
*/
int QCalendarBackend::minimumDaysInMonth() const
{
    return 29;
}
 
/*!
    Returns the maximum number of months possible in any year.
 
    This base implementation returns 12, as this is a common case.
 
    \sa maximumDaysInMonth(), monthsInYear()
*/
int QCalendarBackend::maximumMonthsInYear() const
{
    return 12;
}
 
// Julian day number calculations
 
/*!
    \fn bool QCalendarBackend::dateToJulianDay(int year, int month, int day, qint64 *jd) const
 
    Computes the Julian day number corresponding to the specified \a year, \a
    month, and \a day. Returns true and sets \a jd if there is such a date in
    this calendar; otherwise, returns false. (Its caller will deal with any case
    where the result falls outside the range that QDate can represnt.)
 
    \sa QCalendar::partsFromDate(), julianDayToDate()
*/
 
/*!
    \fn QCalendar::YearMonthDay QCalendarBackend::julianDayToDate(qint64 jd) const
 
    Computes the year, month, and day in this calendar for the given Julian day
    number \a jd. If the given day falls outside this calendar's scope
    (e.g. before the start-date of a non-proleptic calendar, or outside the
    range in which \c int can represent all fields), the returned structure's
    isValid() is false; otherwise, its year, month, and day fields provide this
    calendar's description of the date.
 
    \sa QCalendar::dateFromParts(), dateToJulianDay()
*/
 
/*!
   Returns the day of the week for the given Julian Day Number \a jd.
 
   This is 1 for Monday through 7 for Sunday.
 
   Calendars with intercalary days may return larger values for these
   intercalary days. They should avoid using 0 for any special purpose (it is
   already used in QDate::dayOfWeek() to mean an invalid date). The calendar
   should treat the numbers used as an \c enum, whose values need not be
   contiguous, nor need they follow closely from the 1 through 7 of the usual
   returns. It suffices that;
   \list
     \li weekDayName() can recognize each such number as identifying a distinct
         name, that it returns to identify the particular intercalary day; and
     \li matchCenturyToWeekday() can determine what century adjustment aligns a
         given date within a century to a given day of the week, where this is
         relevant and possible.
   \endlist
 
   This base implementation uses the day-numbering that various calendars have
   borrowed off the Hebrew calendar.
 
   \sa weekDayName(), standaloneWeekDayName(), QDate::dayOfWeek(), Qt::DayOfWeek
*/
int QCalendarBackend::dayOfWeek(qint64 jd) const
{
    return QRoundingDown::qMod<7>(jd) + 1;
}
 
/*!
    \since 6.7
    Adjusts century of \a parts to match \a dow.
 
    Preserves parts.month and parts.day while adjusting parts.year by a multiple
    of 100 (taking the absence of year zero into account, when relevant) to
    obtain a date for which dayOfWeek() is \a dow. Prefers smaller changes over
    larger and increases to the century over decreases of the same
    magnitude. Returns the Julian Day number for the selected date or
    std::numeric_limits<qint64>::min(), a.k.a. QDate::nullJd(), if there is no
    date matching these requirements.
 
    The base-class provides a brute-force implementation that steps outwards
    from the given date by centures, above and below by up to 14 centuries, in
    search of a matching date. This is neither computationally efficient nor
    elegant but should work as advertised for calendars in which every month-day
    combination does appear on all days of the week, across sufficiently many
    centuries.
*/
qint64 QCalendarBackend::matchCenturyToWeekday(const QCalendar::YearMonthDay &parts, int dow) const
{
    Q_ASSERT(parts.isValid());
    // Brute-force solution as fall-back.
    const auto checkOffset = [parts, dow, this](int centuries) -> std::optional<qint64> {
        // Offset parts.year by the given number of centuries:
        int year = parts.year + centuries * 100;
        // but take into account the effect of crossing zero, if we did:
        if (!hasYearZero() && (parts.year > 0) != (year > 0))
            year += parts.year > 0 ? -1 : +1;
        qint64 jd;
        if (isDateValid(year, parts.month, parts.day)
            && dateToJulianDay(year, parts.month, parts.day, &jd)
            && dayOfWeek(jd) == dow) {
            return jd;
        }
        return std::nullopt;
    };
    // Empirically, aside from Gregorian, each calendar finds every dow within
    // any 29-century run, so 14 centuries is the biggest offset we ever need.
    for (int offset = 0; offset < 15; ++offset) {
        if (auto jd = checkOffset(offset))
            return *jd;
        if (offset) {
            if (auto jd = checkOffset(-offset))
                return *jd;
        }
    }
    return (std::numeric_limits<qint64>::min)();
}
 
// Month and week-day name look-ups (implemented in qlocale.cpp):
/*!
    \fn QString QCalendarBackend::monthName(const QLocale &locale, int month, int year,
                                            QLocale::FormatType format) const
 
    Returns the name of the specified \a month in the given \a year for the
    chosen \a locale, using the given \a format to determine how complete the
    name is.
 
    If \a year is Unspecified, return the name for the month that usually has
    this number within a typical year. Calendars with a leap month that isn't
    always the last may need to take account of the year to map the month number
    to the particular year's month with that number.
 
    \note Backends for which CLDR provides data can configure the default
    implementation of the two month name look-up methods by arranging for
    localeMonthIndexData() and localeMonthData() to provide access to the CLDR
    data (see cldr2qlocalexml.py, qlocalexml2cpp.py and existing backends).
    Conversely, backends that override both month name look-up methods need not
    return anything meaningful from localeMonthIndexData() or localeMonthData().
 
    \sa standaloneMonthName(), QLocale::monthName()
*/
 
/*!
    \fn QString QCalendarBackend::standaloneMonthName(const QLocale &locale, int month, int year,
                                                      QLocale::FormatType format) const
 
    Returns the standalone name of the specified \a month in the chosen \a
    locale, using the specified \a format to determine how complete the name is.
 
    If \a year is Unspecified, return the standalone name for the month that
    usually has this number within a typical year. Calendars with a leap month
    that isn't always the last may need to take account of the year to map the
    month number to the particular year's month with that number.
 
    \sa monthName(), QLocale::standaloneMonthName()
*/
 
/*!
    \fn QString QCalendarBackend::weekDayName(const QLocale &locale, int day,
                                              QLocale::FormatType format) const
 
    Returns the name of the specified \a day of the week in the chosen \a
    locale, using the specified \a format to determine how complete the name is.
 
    The base implementation handles \a day values from 1 to 7 using the day
    names CLDR provides, which are suitable for calendards that use the same
    (Hebrew-derived) week as the Gregorian calendar.
 
    Calendars whose dayOfWeek() returns a value outside the range from 1 to 7
    need to reimplement this method to handle such extra week-day values. They
    can assume that \a day is a value returned by the same calendar's
    dayOfWeek().
 
    \sa dayOfWeek(), standaloneWeekDayName(), QLocale::dayName()
*/
 
/*!
    \fn QString QCalendarBackend::standaloneWeekDayName(const QLocale &locale, int day,
                                                        QLocale::FormatType format) const
 
    Returns the standalone name of the specified \a day of the week in the
    chosen \a locale, using the specified \a format to determine how complete
    the name is.
 
    The base implementation handles \a day values from 1 to 7 using the
    standalone day names CLDR provides, which are suitable for calendards that
    use the same (Hebrew-derived) week as the Gregorian calendar.
 
    Calendars whose dayOfWeek() returns a value outside the range from 1 to 7
    need to reimplement this method to handle such extra week-day values. They
    can assume that \a day is a value returned by the same calendar's
    dayOfWeek().
 
    \sa dayOfWeek(), weekDayName(), QLocale::standaloneDayName()
*/
 
/*!
    \fn QString QCalendarBackend::dateTimeToString(QStringView format, const QDateTime &datetime,
                                                   QDate dateOnly, QTime timeOnly,
                                                   const QLocale &locale) const
 
    Returns a string representing a given date, time or date-time.
 
    If \a datetime is specified and valid, it is used and both date and time
    format tokens are converted to appropriate representations of the parts of
    the datetime. Otherwise, if \a dateOnly is valid, only date format tokens
    are converted; else, if \a timeOnly is valid, only time format tokens are
    converted. If none are valid, an empty string is returned.
 
    The specified \a locale influences how some format tokens are converted; for
    example, when substituting day and month names and their short-forms. For
    the supported formatting tokens, see QDate::toString() and
    QTime::toString(). As described above, the provided date, time and date-time
    determine which of these tokens are recognized: where these appear in \a
    format they are replaced by data. Any text in \a format not recognized as a
    format token is copied verbatim into the result string.
 
    \sa QDate::toString(), QTime::toString(), QDateTime::toString()
*/
// End of methods implemented in qlocale.cpp
 
/*!
    Returns a list of names of the available calendar systems. Any
    QCalendarBackend sub-class must be registered before being exposed to Date
    and Time APIs.
 
    \sa fromName()
*/
QStringList QCalendarBackend::availableCalendars()
{
    if (Q_UNLIKELY(calendarRegistry.isDestroyed()))
        return {};
 
    return calendarRegistry->availableCalendars();
}
 
/*!
    \internal
    Returns a pointer to a named calendar backend.
 
    If the given \a name is present in availableCalendars(), the backend
    matching it is returned; otherwise, \nullptr is returned. Matching of
    names ignores case.
 
    \sa availableCalendars(), fromEnum(), fromId()
*/
const QCalendarBackend *QCalendarBackend::fromName(QAnyStringView name)
{
    if (Q_UNLIKELY(calendarRegistry.isDestroyed()))
        return nullptr;
 
    return calendarRegistry->fromName(name);
}
 
/*!
    \internal
    Returns a pointer to a calendar backend, specified by ID.
 
    If a calendar with ID \a id is known to the calendar registry, the backend
    with this ID is returned; otherwise, \nullptr is returned.
 
    \sa fromEnum(), calendarId()
*/
const QCalendarBackend *QCalendarBackend::fromId(QCalendar::SystemId id)
{
    if (Q_UNLIKELY(calendarRegistry.isDestroyed() || !id.isValid()))
        return nullptr;
 
    return calendarRegistry->fromIndex(id.index());
}
 
/*!
    \internal
    Returns a pointer to a calendar backend, specified by \c enum.
 
    This will instantiate the indicated calendar (which will enable fromName()
    to return it subsequently), but only for the Qt-supported calendars for
    which (where relevant) the appropriate feature has been enabled.
 
    \sa fromName(), fromId()
*/
const QCalendarBackend *QCalendarBackend::fromEnum(QCalendar::System system)
{
    if (Q_UNLIKELY(calendarRegistry.isDestroyed() || system == QCalendar::System::User))
        return nullptr;
 
    return calendarRegistry->fromEnum(system);
}
 
/*!
    \internal
    Returns backend for Gregorian calendar.
 
    The backend is returned without locking the registry if possible.
*/
const QCalendarBackend *QCalendarBackend::gregorian()
{
    if (Q_UNLIKELY(calendarRegistry.isDestroyed()))
        return nullptr;
 
    return calendarRegistry->gregorian();
}
 
/*!
    \since 5.14
 
    \class QCalendar
    \inmodule QtCore
    \reentrant
    \brief The QCalendar class describes calendar systems.
 
    A QCalendar object maps a year, month, and day-number to a specific day
    (ultimately identified by its Julian day number), using the rules of a
    particular system.
 
    The default QCalendar() is a proleptic Gregorian calendar, which has no year
    zero. Other calendars may be supported by enabling suitable features or
    loading plugins. Calendars supported as features can be constructed by
    passing the QCalendar::System enumeration to the constructor. All supported
    calendars may be constructed by name, once they have been constructed. (Thus
    plugins instantiate their calendar backend to register it.) Built-in
    backends, accessible via QCalendar::System, are also always available by
    name. Calendars using custom backends may also be constructed using a unique
    ID allocated to the backend on construction.
 
    A QCalendar value is immutable.
 
    \sa QDate, QDateTime
*/
 
/*!
    \enum QCalendar::System
 
    This enumerated type is used to specify a choice of calendar system.
 
    \value Gregorian The default calendar, used internationally.
    \value Julian An ancient Roman calendar.
    \value Milankovic A revised Julian calendar used by some Orthodox churches.
    \value Jalali The Solar Hijri calendar (also called Persian).
    \value IslamicCivil The (tabular) Islamic Civil calendar.
    \omitvalue Last
    \omitvalue User
 
    \sa QCalendar, QCalendar::SystemId
*/
 
/*!
    \class QCalendar::SystemId
    \inmodule QtCore
    \since 6.2
 
    This is an opaque type used to identify custom calendar implementations. The
    only supported source for values of this type is the backend's \c
    calendarId() method. A value of this type whose isValid() is false does not
    identify a successfully-registered backend. The only valid consumer of
    values of this type is a QCalendar constructor, which will only produce a
    valid QCalendar instance if the ID passed to it is valid.
 
    \sa QCalendar, QCalendar::System
*/
 
/*!
    \fn QCalendar::SystemId::isValid() const
 
    Returns \c true if this is a valid calendar implementation identifier,
    \c false otherwise.
 
    \sa QCalendar
*/
 
/*!
    \internal
    \fn QCalendar::SystemId::SystemId()
 
    Constructs an invalid calendar system identifier.
*/
 
/*!
    \internal
    \fn QCalendar::SystemId::index()
 
    Returns the internal representation of the identifier.
*/
 
/*!
    \fn QCalendar::QCalendar()
    \fn QCalendar::QCalendar(QCalendar::System system)
    \fn QCalendar::QCalendar(QAnyStringView name)
 
    Constructs a calendar object.
 
    The choice of calendar to use may be indicated by \a system, using the
    enumeration QCalendar::System, or by \a name, using a string (either Unicode
    or Latin 1). Construction by name may depend on an instance of the given
    calendar being constructed by other means first. With no argument, the
    default constructor returns the Gregorian calendar.
 
    \note In Qt versions before 6.4, the constructor by \a name accepted only
    QStringView and QLatin1String, not QAnyStringView.
 
    \sa QCalendar, System, isValid()
*/
 
QCalendar::QCalendar()
    : d_ptr(QCalendarBackend::gregorian())
{
    Q_ASSERT(!d_ptr || d_ptr->calendarId().isValid());
}
 
QCalendar::QCalendar(QCalendar::System system) : d_ptr(QCalendarBackend::fromEnum(system))
{
    // If system is valid, we should get a valid d for that system.
    Q_ASSERT(!d_ptr || (uint(system) > uint(QCalendar::System::Last))
             || (d_ptr->calendarId().index() == size_t(system)));
}
 
/*!
  \overload
  \since 6.2
 
  Constructs a calendar object.
 
  When using a custom calendar implementation, its backend is allocated a unique
  ID when created; passing that as \a id to this constructor will get a
  QCalendar using that backend. This can be useful when the backend is not
  registered by name.
*/
QCalendar::QCalendar(QCalendar::SystemId id)
    : d_ptr(QCalendarBackend::fromId(id))
{
    Q_ASSERT(!d_ptr || d_ptr->calendarId().index() == id.index());
}
 
QCalendar::QCalendar(QAnyStringView name)
    : d_ptr(QCalendarBackend::fromName(name))
{
    Q_ASSERT(!d_ptr || d_ptr->calendarId().isValid());
}
 
/*!
    \fn bool QCalendar::isValid() const
 
    Returns true if this is a valid calendar object.
 
    Constructing a calendar with an unrecognised calendar name may result in an
    invalid object. Use this method to check after creating a calendar by name.
*/
 
// Date queries:
 
/*!
    Returns the number of days in the given \a month of the given \a year.
 
    Months are numbered consecutively, starting with 1 for the first month of
    each year. If \a year is \c Unspecified (its default, if not passed), the
    month's greatest length in any year is returned.
 
    \sa maximumDaysInMonth(), minimumDaysInMonth()
*/
int QCalendar::daysInMonth(int month, int year) const
{
    SAFE_D();
    return d ? d->daysInMonth(month, year) : 0;
}
 
/*!
    Returns the number of days in the given \a year.
 
    Handling of \c Unspecified as \a year is undefined.
*/
int QCalendar::daysInYear(int year) const
{
    SAFE_D();
    return d ? d->daysInYear(year) : 0;
}
 
/*!
    Returns the number of months in the given \a year.
 
    If \a year is \c Unspecified, returns the maximum number of months in a
    year.
 
    \sa maximumMonthsInYear()
*/
int QCalendar::monthsInYear(int year) const
{
    SAFE_D();
    return d ? year == Unspecified ? d->maximumMonthsInYear() : d->monthsInYear(year) : 0;
}
 
/*!
    Returns \c true precisely if the given \a year, \a month, and \a day specify
    a valid date in this calendar.
 
    Usually this means 1 <= month <= monthsInYear(year) and 1 <= day <=
    daysInMonth(month, year). However, calendars with intercalary days or
    months may complicate that.
*/
bool QCalendar::isDateValid(int year, int month, int day) const
{
    SAFE_D();
    return d && d->isDateValid(year, month, day);
}
 
// properties of the calendar
 
/*!
    Returns \c true if this calendar object is the Gregorian calendar object
    used as default calendar by other Qt APIs, e.g. in QDate.
*/
bool QCalendar::isGregorian() const
{
    SAFE_D();
    return d && d->isGregorian();
}
 
/*!
    Returns \c true if the given \a year is a leap year.
 
    Since the year is not a whole number of days long, some years are longer
    than others. The difference may be a whole month or just a single day; the
    details vary between calendars.
 
    \sa isDateValid()
*/
bool QCalendar::isLeapYear(int year) const
{
    SAFE_D();
    return d && d->isLeapYear(year);
}
 
/*!
    Returns \c true if this calendar is a lunar calendar.
 
    A lunar calendar is one based primarily on the phases of the moon.
*/
bool QCalendar::isLunar() const
{
    SAFE_D();
    return d && d->isLunar();
}
 
/*!
    Returns \c true if this calendar is luni-solar.
 
    A luni-solar calendar expresses the phases of the moon but adapts itself to
    also keep track of the Sun's varying position in the sky, relative to the
    fixed stars.
*/
bool QCalendar::isLuniSolar() const
{
    SAFE_D();
    return d && d->isLuniSolar();
}
 
/*!
    Returns \c true if this calendar is solar.
 
    A solar calendar is based primarily on the Sun's varying position in the
    sky, relative to the fixed stars.
*/
bool QCalendar::isSolar() const
{
    SAFE_D();
    return d && d->isSolar();
}
 
/*!
    Returns \c true if this calendar is proleptic.
 
    A proleptic calendar is able to describe years arbitrarily long before its
    first. These are represented by negative year numbers and possibly by a year
    zero.
 
    \sa hasYearZero()
*/
bool QCalendar::isProleptic() const
{
    SAFE_D();
    return d && d->isProleptic();
}
 
/*!
    Returns \c true if this calendar has a year zero.
 
    A calendar may represent years from its first year onwards but provide no
    way to describe years before its first; such a calendar has no year zero and
    is not proleptic.
 
    A calendar which represents years before its first may number these years
    simply by following the usual integer counting, so that the year before the
    first is year zero, with negative-numbered years preceding this; such a
    calendar is proleptic and has a year zero. A calendar might also have a year
    zero (for example, the year of some great event, with subsequent years being
    the first year after that event, the second year after, and so on) without
    describing years before its year zero. Such a calendar would have a year
    zero without being proleptic.
 
    Some calendars, however, represent years before their first by an alternate
    numbering; for example, the proleptic Gregorian calendar's first year is 1
    CE and the year before it is 1 BCE, preceded by 2 BCE and so on. In this
    case, we use negative year numbers for this alternate numbering, with year
    -1 as the year before year 1, year -2 as the year before year -1 and so
    on. Such a calendar is proleptic but has no year zero.
 
    \sa isProleptic()
*/
bool QCalendar::hasYearZero() const
{
    SAFE_D();
    return d && d->hasYearZero();
}
 
/*!
    Returns the number of days in the longest month in the calendar, in any year.
 
    \sa daysInMonth(), minimumDaysInMonth()
*/
int QCalendar::maximumDaysInMonth() const
{
    SAFE_D();
    return d ? d->maximumDaysInMonth() : 0;
}
 
/*!
    Returns the number of days in the shortest month in the calendar, in any year.
 
    \sa daysInMonth(), maximumDaysInMonth()
*/
int QCalendar::minimumDaysInMonth() const
{
    SAFE_D();
    return d ? d->minimumDaysInMonth() : 0;
}
 
/*!
    Returns the largest number of months that any year may contain.
 
    \sa monthName(), standaloneMonthName(), monthsInYear()
*/
int QCalendar::maximumMonthsInYear() const
{
    SAFE_D();
    return d ? d->maximumMonthsInYear() : 0;
}
 
// Julian Day conversions:
 
/*!
    \fn QDate QCalendar::dateFromParts(int year, int month, int day) const
    \fn QDate QCalendar::dateFromParts(const QCalendar::YearMonthDay &parts) const
 
    Converts a year, month, and day to a QDate.
 
    The \a year, \a month, and \a day may be passed as separate numbers or
    packaged together as the members of \a parts. Returns a QDate with the given
    year, month, and day of the month in this calendar, if there is one.
    Otherwise, including the case where any of the values is
    QCalendar::Unspecified, returns a QDate whose isNull() is true. If the date
    represented falls outside QDate's supported range, the returned QDate's
    isValid() shall be false.
 
    \sa isDateValid(), partsFromDate()
*/
QDate QCalendar::dateFromParts(int year, int month, int day) const
{
    SAFE_D();
    qint64 jd;
    return d && d->dateToJulianDay(year, month, day, &jd)
        ? QDate::fromJulianDay(jd) : QDate();
}
 
QDate QCalendar::dateFromParts(const QCalendar::YearMonthDay &parts) const
{
    return parts.isValid() ? dateFromParts(parts.year, parts.month, parts.day) : QDate();
}
 
/*!
    \since 6.7
    Adjusts the century of a date to match a given day of the week.
 
    For use when given a date's day of week, day of month, month and last two
    digits of the year. Returns a QDate instance with the given \a dow as its \l
    {QDate::}{dayOfWeek()}, matching the given \a parts in month and day of the
    month. The returned QDate's \l {QDate::}{year()} shall differ from
    \c{parts.year} by a multiple of 100, preferring small multiples over larger
    and positive multiples over their negations.
 
    If no date matches these conditions, an invalid QDate is returned: the day
    of week is incompatible with the other data given. This arises, for example,
    with the Gregorian calendar, whose 400-year cycle is a whole number of weeks
    long, so any given month and day of that month only ever falls, in years
    with a given last two digits, on four days of the week. (In the special case
    of February 29th at the turn of a century, when that is a leap year, only
    one day of the week is possible: Tuesday.)
*/
QDate QCalendar::matchCenturyToWeekday(const QCalendar::YearMonthDay &parts, int dow) const
{
    SAFE_D();
    return d && parts.isValid()
        ? QDate::fromJulianDay(d->matchCenturyToWeekday(parts, dow)) : QDate();
}
 
/*!
    Converts a QDate to a year, month, and day of the month.
 
    The returned structure's isValid() shall be false if the calendar is unable
    to represent the given \a date (or its year would be outside the range that
    \c int can represent). Otherwise its year, month, and day members record the
    so-named parts of its representation.
 
    \sa dateFromParts(), isProleptic(), hasYearZero()
*/
QCalendar::YearMonthDay QCalendar::partsFromDate(QDate date) const
{
    SAFE_D();
    return d && date.isValid() ? d->julianDayToDate(date.toJulianDay()) : YearMonthDay();
}
 
/*!
    Returns the day of the week number for the given \a date.
 
    Returns zero if the calendar is unable to represent the indicated date.
    Returns 1 for Monday through 7 for Sunday. Calendars with intercalary days
    may use other numbers to represent these.
 
    \sa partsFromDate(), Qt::DayOfWeek
*/
int QCalendar::dayOfWeek(QDate date) const
{
    SAFE_D();
    return d && date.isValid() ? d->dayOfWeek(date.toJulianDay()) : 0;
}
 
// Locale data access
 
/*!
    Returns a suitably localised name for a month.
 
    The month is indicated by a number, with \a month = 1 meaning the first
    month of the year and subsequent months numbered accordingly. Returns an
    empty string if the \a month number is unrecognized.
 
    The \a year may be Unspecified, in which case the mapping from numbers to
    names for a typical year's months should be used. Some calendars have leap
    months that aren't always at the end of the year; their mapping of month
    numbers to names may then depend on the placement of a leap month. Thus the
    year should normally be specified, if known.
 
    The name is returned in the form that would normally be used in a full date,
    in the specified \a locale; the \a format determines how fully it shall be
    expressed (i.e. to what extent it is abbreviated).
 
    \sa standaloneMonthName(), maximumMonthsInYear(), dateTimeToString()
*/
QString QCalendar::monthName(const QLocale &locale, int month, int year,
                             QLocale::FormatType format) const
{
    SAFE_D();
    const int maxMonth = year == Unspecified ? maximumMonthsInYear() : monthsInYear(year);
    if (!d || month < 1 || month > maxMonth)
        return QString();
 
    return d->monthName(locale, month, year, format);
}
 
/*!
    Returns a suitably localised standalone name for a month.
 
    The month is indicated by a number, with \a month = 1 meaning the first
    month of the year and subsequent months numbered accordingly. Returns an
    empty string if the \a month number is unrecognized.
 
    The \a year may be Unspecified, in which case the mapping from numbers to
    names for a typical year's months should be used. Some calendars have leap
    months that aren't always at the end of the year; their mapping of month
    numbers to names may then depend on the placement of a leap month. Thus the
    year should normally be specified, if known.
 
    The name is returned in the form that would be used in isolation in the
    specified \a locale; the \a format determines how fully it shall be
    expressed (i.e. to what extent it is abbreviated).
 
    \sa monthName(), maximumMonthsInYear(), dateTimeToString()
*/
QString QCalendar::standaloneMonthName(const QLocale &locale, int month, int year,
                                       QLocale::FormatType format) const
{
    SAFE_D();
    const int maxMonth = year == Unspecified ? maximumMonthsInYear() : monthsInYear(year);
    if (!d || month < 1 || month > maxMonth)
        return QString();
 
    return d->standaloneMonthName(locale, month, year, format);
}
 
/*!
    Returns a suitably localised name for a day of the week.
 
    The days of the week are numbered from 1 for Monday through 7 for
    Sunday. Some calendars may support higher numbers for other days
    (e.g. intercalary days, that are not part of any week). Returns an empty
    string if the \a day number is unrecognized.
 
    The name is returned in the form that would normally be used in a full date,
    in the specified \a locale; the \a format determines how fully it shall be
    expressed (i.e. to what extent it is abbreviated).
 
    \sa standaloneWeekDayName(), dayOfWeek()
*/
QString QCalendar::weekDayName(const QLocale &locale, int day,
                               QLocale::FormatType format) const
{
    SAFE_D();
    return d ? d->weekDayName(locale, day, format) : QString();
}
 
/*!
    Returns a suitably localised standalone name for a day of the week.
 
    The days of the week are numbered from 1 for Monday through 7 for
    Sunday. Some calendars may support higher numbers for other days
    (e.g. intercalary days, that are not part of any week). Returns an empty
    string if the \a day number is unrecognized.
 
    The name is returned in the form that would be used in isolation (for
    example as a column heading in a calendar's tabular display of a month with
    successive weeks as rows) in the specified \a locale; the \a format
    determines how fully it shall be expressed (i.e. to what extent it is
    abbreviated).
 
    \sa weekDayName(), dayOfWeek()
*/
QString QCalendar::standaloneWeekDayName(const QLocale &locale, int day,
                                         QLocale::FormatType format) const
{
    SAFE_D();
    return d ? d->standaloneWeekDayName(locale, day, format) : QString();
}
 
/*!
    Returns a string representing a given date, time or date-time.
 
    If \a datetime is valid, it is represented and format specifiers for both
    date and time fields are recognized; otherwise, if \a dateOnly is valid, it
    is represented and only format specifiers for date fields are recognized;
    finally, if \a timeOnly is valid, it is represented and only format
    specifiers for time fields are recognized. If none of these is valid, an
    empty string is returned.
 
    See QDate::toString and QTime::toString() for the supported field
    specifiers.  Characters in \a format that are recognized as field specifiers
    are replaced by text representing appropriate data from the date and/or time
    being represented. The texts to represent them may depend on the \a locale
    specified. Other charagers in \a format are copied verbatim into the
    returned string.
 
    \sa monthName(), weekDayName(), QDate::toString(), QTime::toString()
*/
QString QCalendar::dateTimeToString(QStringView format, const QDateTime &datetime,
                                    QDate dateOnly, QTime timeOnly,
                                    const QLocale &locale) const
{
    SAFE_D();
    return d ? d->dateTimeToString(format, datetime, dateOnly, timeOnly, locale) : QString();
}
 
/*!
    Returns a list of names of the available calendar systems.
 
    These may be supplied by plugins or other code linked into an application,
    in addition to the ones provided by Qt, some of which are controlled by
    features.
*/
QStringList QCalendar::availableCalendars()
{
    return QCalendarBackend::availableCalendars();
}
 
QT_END_NAMESPACE
 
#ifndef QT_BOOTSTRAPPED
#include "moc_qcalendar.cpp"
#endif