File indexing completed on 2024-04-21 03:52:45

 /*
   This file is part of the kcalcore library.
 
   SPDX-FileCopyrightText: 2001 Cornelius Schumacher <schumacher@kde.org>
   SPDX-FileCopyrightText: 2007 David Jarvie <djarvie@kde.org>
 
   SPDX-License-Identifier: LGPL-2.0-or-later
 */
 /**
   @file
   This file is part of the API for handling calendar data and
   defines the Duration class.
 
   @brief
   Represents a span of time measured in seconds.
 
   @author Cornelius Schumacher \<schumacher@kde.org\>
   @author David Jarvie \<djarvie@kde.org\>
 */
 #include "duration.h"
 
 #include <QDateTime>
 #include <QTimeZone>
 
 using namespace KCalendarCore;
 
 /**
   Private class that helps to provide binary compatibility between releases.
   @internal
 */
 //@cond PRIVATE
 class Q_DECL_HIDDEN KCalendarCore::Duration::Private
 {
 public:
     int seconds() const
     {
         return mDaily ? mDuration * 86400 : mDuration;
     }
     int mDuration; // number of seconds or days in the duration
     bool mDaily = false; // specified in terms of days rather than seconds
 };
 //@endcond
 
 Duration::Duration()
     : d(new KCalendarCore::Duration::Private())
 {
 }
 
 Duration::Duration(const QDateTime &start, const QDateTime &end)
     : d(new KCalendarCore::Duration::Private())
 {
     if (start.time() == end.time() && start.timeZone() == end.timeZone()) {
         d->mDuration = start.daysTo(end);
         d->mDaily = true;
     } else {
         d->mDuration = start.secsTo(end);
         d->mDaily = false;
     }
 }
 
 Duration::Duration(const QDateTime &start, const QDateTime &end, Type type)
     : d(new KCalendarCore::Duration::Private())
 {
     if (type == Days) {
         QDateTime endSt(end.toTimeZone(start.timeZone()));
         d->mDuration = start.daysTo(endSt);
         if (d->mDuration) {
             // Round down to whole number of days if necessary
             if (start < endSt) {
                 if (endSt.time() < start.time()) {
                     --d->mDuration;
                 }
             } else {
                 if (endSt.time() > start.time()) {
                     ++d->mDuration;
                 }
             }
         }
         d->mDaily = true;
     } else {
         d->mDuration = start.secsTo(end);
         d->mDaily = false;
     }
 }
 
 Duration::Duration(int duration, Type type)
     : d(new KCalendarCore::Duration::Private())
 {
     d->mDuration = duration;
     d->mDaily = (type == Days);
 }
 
 Duration::Duration(const Duration &duration)
     : d(new KCalendarCore::Duration::Private(*duration.d))
 {
 }
 
 Duration::~Duration()
 {
     delete d;
 }
 
 Duration &Duration::operator=(const Duration &duration)
 {
     // check for self assignment
     if (&duration == this) {
         return *this;
     }
 
     *d = *duration.d;
     return *this;
 }
 
 Duration::operator bool() const
 {
     return d->mDuration;
 }
 
 bool Duration::operator<(const Duration &other) const
 {
     if (d->mDaily == other.d->mDaily) {
         // guard against integer overflow for two daily durations
         return d->mDuration < other.d->mDuration;
     }
     return d->seconds() < other.d->seconds();
 }
 
 bool Duration::operator==(const Duration &other) const
 {
     // Note: daily and non-daily durations are always unequal, since a day's
     // duration may differ from 24 hours if it happens to span a daylight saving
     // time change.
     return d->mDuration == other.d->mDuration && d->mDaily == other.d->mDaily;
 }
 
 Duration &Duration::operator+=(const Duration &other)
 {
     if (d->mDaily == other.d->mDaily) {
         d->mDuration += other.d->mDuration;
     } else if (d->mDaily) {
         d->mDuration = d->mDuration * 86400 + other.d->mDuration;
         d->mDaily = false;
     } else {
         d->mDuration += other.d->mDuration + 86400;
     }
     return *this;
 }
 
 Duration Duration::operator-() const
 {
     return Duration(-d->mDuration, (d->mDaily ? Days : Seconds));
 }
 
 Duration &Duration::operator-=(const Duration &duration)
 {
     return operator+=(-duration);
 }
 
 Duration &Duration::operator*=(int value)
 {
     d->mDuration *= value;
     return *this;
 }
 
 Duration &Duration::operator/=(int value)
 {
     d->mDuration /= value;
     return *this;
 }
 
 QDateTime Duration::end(const QDateTime &start) const
 {
     return d->mDaily ? start.addDays(d->mDuration) : start.addSecs(d->mDuration);
 }
 
 Duration::Type Duration::type() const
 {
     return d->mDaily ? Days : Seconds;
 }
 
 bool Duration::isDaily() const
 {
     return d->mDaily;
 }
 
 int Duration::asSeconds() const
 {
     return d->seconds();
 }
 
 int Duration::asDays() const
 {
     return d->mDaily ? d->mDuration : d->mDuration / 86400;
 }
 
 int Duration::value() const
 {
     return d->mDuration;
 }
 
 bool Duration::isNull() const
 {
     return d->mDuration == 0;
 }
 
 QDataStream &KCalendarCore::operator<<(QDataStream &out, const KCalendarCore::Duration &duration)
 {
     out << duration.d->mDuration << duration.d->mDaily;
     return out;
 }
 
 QDataStream &KCalendarCore::operator>>(QDataStream &in, KCalendarCore::Duration &duration)
 {
     in >> duration.d->mDuration >> duration.d->mDaily;
     return in;
 }