extendedstorage.h

Go to the documentation of this file.

/*
  This file is part of the mkcal library.
 
  Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.
  Contact: Alvaro Manera <alvaro.manera@nokia.com>
 
  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 MKCAL_EXTENDEDSTORAGE_H
#define MKCAL_EXTENDEDSTORAGE_H
 
#include "mkcal_export.h"
#include "extendedcalendar.h"
#include "extendedstorageobserver.h"
#include "notebook.h"
 
#include <KCalendarCore/CalStorage>
#include <KCalendarCore/Calendar>
 
namespace KCalendarCore {
class Incidence;
}
 
class MkcalTool;
class tst_load;
 
namespace mKCal {

class MKCAL_EXPORT ExtendedStorage
    : public QObject, public KCalendarCore::Calendar::CalendarObserver
{
    Q_OBJECT
 
public:

    enum DeleteAction {
        MarkDeleted,
        PurgeDeleted
    };

    typedef QSharedPointer<ExtendedStorage> Ptr;

    explicit ExtendedStorage(const ExtendedCalendar::Ptr &cal, bool validateNotebooks = true);

    virtual ~ExtendedStorage();

    ExtendedCalendar::Ptr calendar() const;

    virtual bool open() = 0;

    virtual bool load() = 0;

    virtual bool load(const QString &uid) = 0;

    bool loadSeries(const QString &uid);

    bool load(const QString &uid, const QDateTime &recurrenceId);

    virtual bool load(const QDate &date);

    virtual bool load(const QDate &start, const QDate &end) = 0;

    virtual bool loadIncidenceInstance(const QString &instanceIdentifier);

    virtual bool loadNotebookIncidences(const QString &notebookUid) = 0;

    virtual bool purgeDeletedIncidences(const KCalendarCore::Incidence::List &list,
                                        const QString &notebook = QString()) = 0;

    virtual bool save() = 0;

    virtual bool save(DeleteAction deleteAction) = 0;

    virtual bool close();
 
    // Internal Calendar Listener Methods //

    virtual void calendarModified(bool modified, KCalendarCore::Calendar *calendar) = 0;

    virtual void calendarIncidenceAdded(const KCalendarCore::Incidence::Ptr &incidence) = 0;

    virtual void calendarIncidenceChanged(const KCalendarCore::Incidence::Ptr &incidence) = 0;

    virtual void calendarIncidenceDeleted(const KCalendarCore::Incidence::Ptr &incidence, const KCalendarCore::Calendar *calendar) = 0;

    virtual void calendarIncidenceAdditionCanceled(const KCalendarCore::Incidence::Ptr &incidence) = 0;
 
    // Synchronization Specific Methods //

    virtual bool insertedIncidences(KCalendarCore::Incidence::List *list,
                                    const QDateTime &after = QDateTime(),
                                    const QString &notebookUid = QString()) = 0;

    virtual bool modifiedIncidences(KCalendarCore::Incidence::List *list,
                                    const QDateTime &after = QDateTime(),
                                    const QString &notebookUid = QString()) = 0;

    virtual bool deletedIncidences(KCalendarCore::Incidence::List *list,
                                   const QDateTime &after = QDateTime(),
                                   const QString &notebookUid = QString()) = 0;

    virtual bool allIncidences(KCalendarCore::Incidence::List *list,
                               const QString &notebookUid = QString()) = 0;

    virtual bool search(const QString &key, QStringList *identifiers, int limit = 0) = 0;

    virtual QDateTime incidenceDeletedDate(const KCalendarCore::Incidence::Ptr &incidence) = 0;
 
    // Observer Specific Methods //

    void registerObserver(ExtendedStorageObserver *observer);

    void unregisterObserver(ExtendedStorageObserver *observer);
 
    // Notebook Methods //

    bool addNotebook(const Notebook::Ptr &nb);

    bool updateNotebook(const Notebook::Ptr &nb);

    bool deleteNotebook(const Notebook::Ptr &nb);

    bool setDefaultNotebook(const Notebook::Ptr &nb);

    Notebook::Ptr defaultNotebook();

    Notebook::Ptr notebook(const QString &uid) const;

    Notebook::List notebooks();

    void setValidateNotebooks(bool validateNotebooks);

    bool validateNotebooks() const;

    bool isValidNotebook(const QString &notebookUid) const;

    Notebook::Ptr createDefaultNotebook(QString name = QString(),
                                        QString color = QString());

    virtual void virtual_hook(int id, void *data) = 0;
 
protected:
    virtual bool loadNotebooks() = 0;
    virtual bool insertNotebook(const Notebook::Ptr &nb) = 0;
    virtual bool modifyNotebook(const Notebook::Ptr &nb) = 0;
    virtual bool eraseNotebook(const Notebook::Ptr &nb) = 0;
 
    bool getLoadDates(const QDate &start, const QDate &end,
                      QDateTime *loadStart, QDateTime *loadEnd) const;
 
    void addLoadedRange(const QDate &start, const QDate &end) const;
    bool isRecurrenceLoaded() const;
    void setIsRecurrenceLoaded(bool loaded);
 
    void emitStorageModified(const QString &info);
    void emitStorageFinished(bool error, const QString &info);
    void emitStorageUpdated(const KCalendarCore::Incidence::List &added,
                            const KCalendarCore::Incidence::List &modified,
                            const KCalendarCore::Incidence::List &deleted);
 
private:
    //@cond PRIVATE
    Q_DISABLE_COPY(ExtendedStorage)
    class Private;
    Private *const d;
    //@endcond
 
    friend class ::MkcalTool;
    friend class ::tst_load;
};
 
}
 
#endif