scimagecachemanager.h

/*
For general Scribus (>=1.3.2) copyright and licensing information please refer
to the COPYING file provided with the program. Following this notice may exist
a copyright and/or license notice that predates the release of Scribus 1.3.2
for which a new license (GPL+exception) is in place.
*/
/***************************************************************************
    copyright            : (C) 2010 by Marcus Holland-Moritz
    email                : scribus@mhxnet.de
***************************************************************************/

/***************************************************************************
*                                                                         *
*   This program is free software; you can redistribute it and/or modify  *
*   it under the terms of the GNU General Public License as published by  *
*   the Free Software Foundation; either version 2 of the License, or     *
*   (at your option) any later version.                                   *
*                                                                         *
***************************************************************************/

#ifndef SCIMAGECACHEMANAGER_H
#define SCIMAGECACHEMANAGER_H

#include <QList>
#include <QString>
#include <QDebug>

#include "scribusapi.h"
#include "scimagecachedir.h"

class QTemporaryFile;
class QFileInfo;
class ScImageCacheFile;

class SCRIBUS_API ScImageCacheManager : public QObject
{
    Q_OBJECT

public:
    typedef ScImageCacheDir::AccessCounter AccessCounter;

    static ScImageCacheManager & instance();
    static QString absolutePath(const QString & fn);

    void setEnabled(bool enableCache);
    bool enabled(void) const { return m_isEnabled; }
    bool setMaxCacheSizeMiB(int maxCacheSizeMiB);
    bool setMaxCacheEntries(int maxCacheEntries);
    bool setCompressionLevel(int level);
    int compressionLevel() const;

    void initialize();
    void tryCleanup();
    bool acquireWriteLock();
    bool releaseWriteLock();
    void removeMasterLock();

    bool updateAccess(const QString & dir, AccessCounter from, AccessCounter to);
    bool updateFile(const QString & file);

private slots:
    void fileCreated(ScImageCacheFile * file, const QFileInfo & info);
    void fileChanged(ScImageCacheFile * file, const QFileInfo & info);
    void fileRemoved(ScImageCacheFile * file);

private:
    class MetaAgeList
    {
    public:
        MetaAgeList();
        void insert(ScImageCacheFile *p);
        void update(ScImageCacheFile *p, const QFileInfo & newInfo);
        void remove(ScImageCacheFile *p);
        ScImageCacheFile *getOldest();
        int count() const { return m_fa.size(); }

    private:
        typedef QList<ScImageCacheFile *> FAL;
        FAL m_fa;

        static bool ageLessThan(const ScImageCacheFile *a, const ScImageCacheFile *b);
    };

    ScImageCacheManager();
    ~ScImageCacheManager();

    static void create();
    static void cleanupLockDir();
    static bool createLockDir();
    static QString lockDir();
    static QString masterLockFile();
    static QString writeLockTemplate();

    void sanitizeCache();
    void updateCache();
    void cleanupCache();
    ScImageCacheFile *getOldestCacheEntry();

    bool acquireMasterLock();
    bool releaseMasterLock();

    bool m_isEnabled;
    bool m_haveMasterLock;
    bool m_inCleanup;
    int m_writeLockCount;
    int m_compressionLevel;
    int m_maxEntries;
    int m_maxSizeMiB;
    qint64 m_maxTotalSize;
    qint64 m_totalCacheSize;

    MetaAgeList m_metaAge;

    QTemporaryFile *m_writeLockFile;
    ScImageCacheDir *m_root;
};

#endif