recurrence.h

/*
  This file is part of the kcalcore library.

  Copyright (c) 1998 Preston Brown <[email protected]>
  Copyright (c) 2001,2003 Cornelius Schumacher <[email protected]>
  Copyright (c) 2002,2006 David Jarvie <[email protected]>
  Copyright (C) 2005 Reinhold Kainhofer <[email protected]>

  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.
*/
#ifndef KCALCORE_RECURRENCE_H
#define KCALCORE_RECURRENCE_H

#include "kcalendarcore_export.h"
#include "recurrencerule.h"

class QBitArray;
class QTimeZone;

namespace KCalendarCore
{

class RecurrenceRule;

class KCALENDARCORE_EXPORT Recurrence : public RecurrenceRule::RuleObserver
{
public:
    class RecurrenceObserver
    {
    public:
        virtual ~RecurrenceObserver();
        virtual void recurrenceUpdated(Recurrence *r) = 0;
    };

    enum {
        rNone = 0,
        rMinutely = 0x001,
        rHourly = 0x0002,
        rDaily = 0x0003,
        rWeekly = 0x0004,
        rMonthlyPos = 0x0005,
        rMonthlyDay = 0x0006,
        rYearlyMonth = 0x0007,
        rYearlyDay = 0x0008,
        rYearlyPos = 0x0009,
        rOther = 0x000A,
        rMax = 0x00FF
    };

    Recurrence();

    Recurrence(const Recurrence &r);

    ~Recurrence() override;

    bool operator==(const Recurrence &r) const;

    bool operator!=(const Recurrence &r) const
    {
        return !operator==(r);
    }

#if KCALENDARCORE_BUILD_DEPRECATED_SINCE(5, 64)

    KCALENDARCORE_DEPRECATED_VERSION(5, 64, "Do not use")
    Recurrence &operator=(const Recurrence &r);
#else
    Recurrence &operator=(const Recurrence &r) = delete;
#endif

    Q_REQUIRED_RESULT QDateTime startDateTime() const;
    Q_REQUIRED_RESULT QDate startDate() const;
    void setStartDateTime(const QDateTime &start, bool isAllDay);

    Q_REQUIRED_RESULT bool allDay() const;
    void setAllDay(bool allDay);

    void setRecurReadOnly(bool readOnly);

    Q_REQUIRED_RESULT bool recurReadOnly() const;

    Q_REQUIRED_RESULT bool recurs() const;

    Q_REQUIRED_RESULT ushort recurrenceType() const;

    static ushort recurrenceType(const RecurrenceRule *rrule);

    bool recursOn(const QDate &date, const QTimeZone &timeZone) const;

    bool recursAt(const QDateTime &dt) const;

    void unsetRecurs();

    void clear();

    Q_REQUIRED_RESULT TimeList recurTimesOn(const QDate &date, const QTimeZone &timeZone) const;

    Q_REQUIRED_RESULT QList<QDateTime> timesInInterval(const QDateTime &start, const QDateTime &end) const;

    Q_REQUIRED_RESULT QDateTime getNextDateTime(const QDateTime &preDateTime) const;

    Q_REQUIRED_RESULT QDateTime getPreviousDateTime(const QDateTime &afterDateTime) const;

    Q_REQUIRED_RESULT int frequency() const;

    void setFrequency(int freq);

    Q_REQUIRED_RESULT int duration() const;

    void setDuration(int duration);

    Q_REQUIRED_RESULT int durationTo(const QDateTime &dt) const;

    Q_REQUIRED_RESULT int durationTo(const QDate &date) const;

    Q_REQUIRED_RESULT QDateTime endDateTime() const;

    Q_REQUIRED_RESULT QDate endDate() const;

    void setEndDate(const QDate &endDate);

    void setEndDateTime(const QDateTime &endDateTime);

    void shiftTimes(const QTimeZone &oldZone, const QTimeZone &newZone);

    void setMinutely(int freq);

    void setHourly(int freq);

    void setDaily(int freq);

    void setWeekly(int freq, int weekStart = 1);
    void setWeekly(int freq, const QBitArray &days, int weekStart = 1);

    void addWeeklyDays(const QBitArray &days);
    int weekStart() const;

    Q_REQUIRED_RESULT QBitArray days() const; // Emulate the old behavior

    void setMonthly(int freq);

    void addMonthlyPos(short pos, const QBitArray &days);
    void addMonthlyPos(short pos, ushort day);

    void setMonthlyPos(const QList<RecurrenceRule::WDayPos> &monthlyDays);

    void addMonthlyDate(short day);

    void setMonthlyDate(const QList<int> &monthlyDays);

    Q_REQUIRED_RESULT QList<RecurrenceRule::WDayPos> monthPositions() const;

    // Emulate old behavior
    Q_REQUIRED_RESULT QList<int> monthDays() const;

    void setYearly(int freq);

    void addYearlyDay(int day);

    void setYearlyDay(const QList<int> &days);

    void addYearlyDate(int date);

    void setYearlyDate(const QList<int> &dates);

    void addYearlyMonth(short _rNum);

    void setYearlyMonth(const QList< int > &months);

    void addYearlyPos(short pos, const QBitArray &days);

    void setYearlyPos(const QList<RecurrenceRule::WDayPos> &days);

    Q_REQUIRED_RESULT QList<int> yearDays() const;

    Q_REQUIRED_RESULT QList<int> yearDates() const;

    Q_REQUIRED_RESULT QList<int> yearMonths() const;

    Q_REQUIRED_RESULT QList<RecurrenceRule::WDayPos> yearPositions() const;

    static const QDate MAX_DATE;

    void dump() const;

    // RRULE
    Q_REQUIRED_RESULT RecurrenceRule::List rRules() const;
    void addRRule(RecurrenceRule *rrule);

    void removeRRule(RecurrenceRule *rrule);

    void deleteRRule(RecurrenceRule *rrule);

    // EXRULE
    Q_REQUIRED_RESULT RecurrenceRule::List exRules() const;

    void addExRule(RecurrenceRule *exrule);

    void removeExRule(RecurrenceRule *exrule);

    void deleteExRule(RecurrenceRule *exrule);

    // RDATE
    Q_REQUIRED_RESULT QList<QDateTime> rDateTimes() const;
    Q_REQUIRED_RESULT DateList rDates() const;
    void setRDateTimes(const QList<QDateTime> &rdates);
    void setRDates(const DateList &rdates);
    void addRDateTime(const QDateTime &rdate);
    void addRDate(const QDate &rdate);

    // ExDATE
    Q_REQUIRED_RESULT QList<QDateTime> exDateTimes() const;
    Q_REQUIRED_RESULT DateList exDates() const;
    void setExDateTimes(const QList<QDateTime> &exdates);
    void setExDates(const DateList &exdates);
    void addExDateTime(const QDateTime &exdate);
    void addExDate(const QDate &exdate);

    RecurrenceRule *defaultRRule(bool create = false) const;
    RecurrenceRule *defaultRRuleConst() const;
    void updated();

    void addObserver(RecurrenceObserver *observer);
    void removeObserver(RecurrenceObserver *observer);

    void recurrenceChanged(RecurrenceRule *) override;

protected:
    RecurrenceRule *setNewRecurrenceType(RecurrenceRule::PeriodType type, int freq);

private:
    //@cond PRIVATE
    class Private;
    Private *const d;
    //@endcond

    friend KCALENDARCORE_EXPORT QDataStream &operator<<(QDataStream &out, KCalendarCore::Recurrence *);
    friend KCALENDARCORE_EXPORT QDataStream &operator>>(QDataStream &in, KCalendarCore::Recurrence *);
};

KCALENDARCORE_EXPORT QDataStream &operator<<(QDataStream &out, KCalendarCore::Recurrence *);
KCALENDARCORE_EXPORT QDataStream &operator>>(QDataStream &in, KCalendarCore::Recurrence *);

}

#endif