File indexing completed on 2023-09-24 04:04:48

 /*
     Copyright (c) 2010 John Layt <john@layt.net>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     Boston, MA 02110-1301, USA.
 */
 
 #include "kdayperiod_p.h"
 
 #include <QSharedData>
 #include <QString>
 #include <QTime>
 
 class KDayPeriodPrivate : public QSharedData
 {
 public:
     KDayPeriodPrivate(const QString &periodCode,
                       const QString &longName,
                       const QString &shortName,
                       const QString &narrowName,
                       const QTime &periodStart,
                       const QTime &periodEnd,
                       int offsetFromStart,
                       int offsetIfZero);
     KDayPeriodPrivate(const KDayPeriodPrivate &other);
     ~KDayPeriodPrivate();
 
     QString m_periodCode, m_longName, m_shortName, m_narrowName;
     QTime m_periodStart, m_periodEnd;
     int m_offsetFromStart, m_offsetIfZero;
 };
 
 KDayPeriodPrivate::KDayPeriodPrivate(const QString &periodCode,
                                      const QString &longName,
                                      const QString &shortName,
                                      const QString &narrowName,
                                      const QTime &periodStart,
                                      const QTime &periodEnd,
                                      int offsetFromStart,
                                      int offsetIfZero)
     : QSharedData(),
       m_periodCode(periodCode),
       m_longName(longName),
       m_shortName(shortName),
       m_narrowName(narrowName),
       m_periodStart(periodStart),
       m_periodEnd(periodEnd),
       m_offsetFromStart(offsetFromStart),
       m_offsetIfZero(offsetIfZero)
 {
 }
 
 KDayPeriodPrivate::KDayPeriodPrivate(const KDayPeriodPrivate &other)
     : QSharedData(other),
       m_periodCode(other.m_periodCode),
       m_longName(other.m_longName),
       m_shortName(other.m_shortName),
       m_narrowName(other.m_narrowName),
       m_periodStart(other.m_periodStart),
       m_periodEnd(other.m_periodEnd),
       m_offsetFromStart(other.m_offsetFromStart),
       m_offsetIfZero(other.m_offsetIfZero)
 {
 }
 
 KDayPeriodPrivate::~KDayPeriodPrivate()
 {
 }
 
 KDayPeriod::KDayPeriod(const QString &periodCode,
                        const QString &longName,
                        const QString &shortName,
                        const QString &narrowName,
                        const QTime &periodStart,
                        const QTime &periodEnd,
                        int offsetFromStart,
                        int offsetIfZero)
     : d(new KDayPeriodPrivate(periodCode,
                               longName,
                               shortName,
                               narrowName,
                               periodStart,
                               periodEnd,
                               offsetFromStart,
                               offsetIfZero))
 {
 }
 
 KDayPeriod::KDayPeriod()
     : d(new KDayPeriodPrivate(QString(), QString(), QString(), QString(), QTime(), QTime(), -1, -1))
 {
 }
 
 KDayPeriod::KDayPeriod(const KDayPeriod &rhs)
     : d(rhs.d)
 {
 }
 
 KDayPeriod::~KDayPeriod()
 {
 }
 
 KDayPeriod &KDayPeriod::operator=(const KDayPeriod &rhs)
 {
     if (&rhs != this) {
         d = rhs.d;
     }
     return *this;
 }
 
 QString KDayPeriod::periodCode() const
 {
     return d->m_periodCode;
 }
 
 QTime KDayPeriod::periodStart() const
 {
     return d->m_periodStart;
 }
 
 QTime KDayPeriod::periodEnd() const
 {
     return d->m_periodEnd;
 }
 
 QString KDayPeriod::periodName(KLocale::DateTimeComponentFormat format) const
 {
     if (format == KLocale::LongName) {
         return d->m_longName;
     } else if (format == KLocale::NarrowName) {
         return d->m_narrowName;
     } else {
         return d->m_shortName;
     }
 }
 
 int KDayPeriod::hourInPeriod(const QTime &time) const
 {
     int hourInPeriod = -1;
     if (time.isValid() && isValid(time)) {
         hourInPeriod = time.hour() - periodStart().hour() + d->m_offsetFromStart;
         while (d->m_offsetIfZero > 0 && hourInPeriod <= 0) {
             hourInPeriod = hourInPeriod + d->m_offsetIfZero;
         }
     }
     return hourInPeriod;
 }
 
 QTime KDayPeriod::time(int hip, int minute, int second, int millisecond) const
 {
     QTime time;
     if (isValid()) {
         if (hip == d->m_offsetIfZero) {
             hip = 0;
         }
         int hour;
         if (periodStart() <= periodEnd() ||
                 (hip >= hourInPeriod(periodStart()) &&
                  hip <= hourInPeriod(QTime(23, 59, 59, 999)))) {
             hour = hip + periodStart().hour() - d->m_offsetFromStart;
         } else {
             hour = hip;
         }
         time =  QTime(hour, minute, second, millisecond);
         if (time.isValid() && isValid(time)) {
             return time;
         } else {
             return QTime();
         }
     }
     return time;
 }
 
 bool KDayPeriod::isValid() const
 {
     return !d->m_periodCode.isEmpty() &&
            d->m_periodStart.isValid() &&
            d->m_periodEnd.isValid();
 }
 
 bool KDayPeriod::isValid(const QTime &time) const
 {
     if (isValid()) {
         if (periodStart() <= periodEnd()) {
             return time >= periodStart() && time <= periodEnd();
         } else {
             return ((time >= periodStart() && time <= QTime(23, 59, 59, 999)) ||
                     (time >= QTime(0, 0, 0) && time <= periodEnd()));
         }
     } else {
         return false;
     }
 }