elementscollectioncache.cpp

Go to the documentation of this file.

/*
    Copyright 2006-2019 The QElectroTech Team
    This file is part of QElectroTech.
    
    QElectroTech 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.
    
    QElectroTech 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 General Public License for more details.
    
    You should have received a copy of the GNU General Public License
    along with QElectroTech.  If not, see <http://www.gnu.org/licenses/>.
*/
#include "elementscollectioncache.h"
#include "factory/elementfactory.h"
#include "element.h"
#include "qet.h"

#include <QImageWriter>
#include <QSqlQuery>
#include <QSqlError>

ElementsCollectionCache::ElementsCollectionCache(const QString &database_path, QObject *parent) :
    QObject(parent),
    locale_("en"),
    pixmap_storage_format_("PNG")
{
    // initialize the cache SQLite database
    static int cache_instances = 0;
    QString connection_name = QString("ElementsCollectionCache-%1").arg(cache_instances++);
    cache_db_ = QSqlDatabase::addDatabase("QSQLITE", connection_name);
    cache_db_.setDatabaseName(database_path);

    if (!cache_db_.open())
        qDebug() << "Unable to open the SQLite database " << database_path << " as " << connection_name << ": " << cache_db_.lastError();
    else
    {
        cache_db_.exec("PRAGMA temp_store = MEMORY");
        cache_db_.exec("PRAGMA journal_mode = MEMORY");
        cache_db_.exec("PRAGMA page_size = 4096");
        cache_db_.exec("PRAGMA cache_size = 16384");
        cache_db_.exec("PRAGMA locking_mode = EXCLUSIVE");
        cache_db_.exec("PRAGMA synchronous = OFF");

            //TODO This code remove old table with mtime for create table with uuid, created at version 0,5
            //see to remove this code at version 0,6 or 0,7 when all users will table with uuid.
        QSqlQuery table_name(cache_db_);
        if (table_name.exec("PRAGMA table_info(names)"))
        {
            if (table_name.seek(2))
            {
                QString str = table_name.value(1).toString();
                table_name.finish();
                if (str == "mtime")
                {
                    QSqlQuery error;
                    error = cache_db_.exec("DROP TABLE names");
                    error = cache_db_.exec("DROP TABLE pixmaps");
                }
            }
            else
                table_name.finish();
        }

            //@TODO the tables could already exist, handle that case.
        cache_db_.exec("CREATE TABLE names"
                       "("
                       "path VARCHAR(512) NOT NULL,"
                       "locale VARCHAR(2) NOT NULL,"
                       "uuid VARCHAR(512) NOT NULL,"
                       "name VARCHAR(128),"
                       "PRIMARY KEY(path, locale)"
                       ");");

        cache_db_.exec("CREATE TABLE pixmaps"
                       "("
                       "path VARCHAR(512) NOT NULL UNIQUE,"
                       "uuid VARCHAR(512) NOT NULL,"
                       "pixmap BLOB, PRIMARY KEY(path),"
                       "FOREIGN KEY(path) REFERENCES names (path) ON DELETE CASCADE);");

            // prepare queries
        select_name_   = new QSqlQuery(cache_db_);
        select_pixmap_ = new QSqlQuery(cache_db_);
        insert_name_   = new QSqlQuery(cache_db_);
        insert_pixmap_ = new QSqlQuery(cache_db_);
        select_name_   -> prepare("SELECT name FROM names WHERE path = :path AND locale = :locale AND uuid = :uuid");
        select_pixmap_ -> prepare("SELECT pixmap FROM pixmaps WHERE path = :path AND uuid = :uuid");
        insert_name_   -> prepare("REPLACE INTO names (path, locale, uuid, name) VALUES (:path, :locale, :uuid, :name)");
        insert_pixmap_ -> prepare("REPLACE INTO pixmaps (path, uuid, pixmap) VALUES (:path, :uuid, :pixmap)");
    }
}

ElementsCollectionCache::~ElementsCollectionCache() {
    delete select_name_;
    delete select_pixmap_;
    delete insert_name_;
    delete insert_pixmap_;
    cache_db_.close();
}

void ElementsCollectionCache::setLocale(const QString &locale) {
    locale_ = locale;
}

QString ElementsCollectionCache::locale() const {
    return(locale_);
}

bool ElementsCollectionCache::setPixmapStorageFormat(const QString &format) {
    if (QImageWriter::supportedImageFormats().contains(format.toLatin1())) {
        pixmap_storage_format_= format;
        return(true);
    }
    return(false);
}

QString ElementsCollectionCache::pixmapStorageFormat() const {
    return(pixmap_storage_format_);
}

bool ElementsCollectionCache::fetchElement(ElementsLocation &location)
{
        // can we use the cache with this element?
    bool use_cache = cache_db_.isOpen() && !location.isProject();

        // attempt to fetch the element name from the cache database
    if (!use_cache) {
        return(fetchData(location));
    }
    else
    {
        QString element_path = location.toString();
        bool got_name   = fetchNameFromCache(element_path, location.uuid());
        bool got_pixmap = fetchPixmapFromCache(element_path, location.uuid());

        if (got_name && got_pixmap) {
            return(true);
        }

        if (fetchData(location))
        {
            cacheName(element_path, location.uuid());
            cachePixmap(element_path, location.uuid());
        }
        return(true);
    }
}

QString ElementsCollectionCache::name() const {
    return(current_name_);
}

QPixmap ElementsCollectionCache::pixmap() const {
    return(current_pixmap_);
}

bool ElementsCollectionCache::fetchData(const ElementsLocation &location) {
    int state;
    Element *custom_elmt = ElementFactory::Instance() -> createElement(location, nullptr, &state);
    if (state) {
        qDebug() << "ElementsCollectionCache::fetchData() : Le chargement du composant" << qPrintable(location.toString()) << "a echoue avec le code d'erreur" << state;
    } else {
        current_name_   = custom_elmt -> name();
        current_pixmap_ = custom_elmt -> pixmap();
    }
    delete custom_elmt;
    return(!state);
}

bool ElementsCollectionCache::fetchNameFromCache(const QString &path, const QUuid &uuid)
{
    select_name_ -> bindValue(":path", path);
    select_name_ -> bindValue(":locale", locale_);
    select_name_ -> bindValue(":uuid", uuid.toString());
    if (select_name_ -> exec())
    {
        if (select_name_ -> first())
        {
            current_name_ = select_name_ -> value(0).toString();
            select_name_ -> finish();
            return(true);
        }
    }
    else
        qDebug() << "select_name_->exec() failed";

    return(false);
}

bool ElementsCollectionCache::fetchPixmapFromCache(const QString &path, const QUuid &uuid)
{
    select_pixmap_ -> bindValue(":path", path);
    select_pixmap_ -> bindValue(":uuid", uuid.toString());
    if (select_pixmap_ -> exec())
    {
        if (select_pixmap_ -> first())
        {
            QByteArray ba = select_pixmap_ -> value(0).toByteArray();
            // avoid returning always the same pixmap (i.e. same cacheKey())
            current_pixmap_.detach();
            current_pixmap_.loadFromData(ba, qPrintable(pixmap_storage_format_));
            select_pixmap_ -> finish();
        }
        return(true);
    }
    else
        qDebug() << "select_pixmap_->exec() failed";

    return(false);
}

bool ElementsCollectionCache::cacheName(const QString &path, const QUuid &uuid)
{
    insert_name_ -> bindValue(":path",   path);
    insert_name_ -> bindValue(":locale", locale_);
    insert_name_ -> bindValue(":uuid",  uuid.toString());
    insert_name_ -> bindValue(":name",   current_name_);
    if (!insert_name_ -> exec())
    {
        qDebug() << cache_db_.lastError();
        return(false);
    }
    return(true);
}

bool ElementsCollectionCache::cachePixmap(const QString &path, const QUuid &uuid)
{
    QByteArray ba;
    QBuffer buffer(&ba);
    buffer.open(QIODevice::WriteOnly);
    current_pixmap_.save(&buffer, qPrintable(pixmap_storage_format_));
    insert_pixmap_ -> bindValue(":path", path);
    insert_pixmap_ -> bindValue(":uuid", uuid.toString());
    insert_pixmap_ -> bindValue(":pixmap", QVariant(ba));
    if (!insert_pixmap_->exec())
    {
        qDebug() << cache_db_.lastError();
        return(false);
    }
    return(true);
}