GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r331:d786589b2e4c

Variable deletion (2)...

Alexandre Leroux -

r331:d786589b2e4c

parent child

Context file:

r331:d786589b2e4c

Collapse all files

core/include/Variable/VariableCacheController.h +6 0

             #ifndef SCIQLOP_VARIABLECACHECONTROLLER_H
             #define SCIQLOP_VARIABLECACHECONTROLLER_H
+            #include <QLoggingCategory>
             #include <QObject>
             #include <Data/SqpDateTime.h>
             #include <QLoggingCategory>
             #include <Common/spimpl.h>
+            Q_DECLARE_LOGGING_CATEGORY(LOG_VariableCacheController)
             class Variable;
             Q_DECLARE_LOGGING_CATEGORY(LOG_VariableCacheController)
             /// This class aims to store in the cache all of the dateTime already requested to the variable.
             class VariableCacheController : public QObject {
                 Q_OBJECT
             public:
                 explicit VariableCacheController(QObject *parent = 0);
                 void addDateTime(std::shared_ptr<Variable> variable, const SqpDateTime &dateTime);
+                /// Clears cache concerning a variable
+                void clear(std::shared_ptr<Variable> variable) noexcept;
                 /// Return all of the SqpDataTime part of the dateTime whose are not in the cache
                 QVector<SqpDateTime> provideNotInCacheDateTimeList(std::shared_ptr<Variable> variable,
                                                                    const SqpDateTime &dateTime);
                 QVector<SqpDateTime> dateCacheList(std::shared_ptr<Variable> variable) const noexcept;
                 void displayCache(std::shared_ptr<Variable> variable) const;
             private:
                 class VariableCacheControllerPrivate;
                 spimpl::unique_impl_ptr<VariableCacheControllerPrivate> impl;
             };
             #endif // SCIQLOP_VARIABLECACHECONTROLLER_H

core/include/Variable/VariableController.h +1 0

             #ifndef SCIQLOP_VARIABLECONTROLLER_H
             #define SCIQLOP_VARIABLECONTROLLER_H
             #include <Data/SqpDateTime.h>
             #include <QLoggingCategory>
             #include <QObject>
             #include <Common/spimpl.h>
             class IDataProvider;
             class QItemSelectionModel;
             class TimeController;
             class Variable;
             class VariableModel;
             Q_DECLARE_LOGGING_CATEGORY(LOG_VariableController)
             /**
              * @brief The VariableController class aims to handle the variables in SciQlop.
              */
             class VariableController : public QObject {
                 Q_OBJECT
             public:
                 explicit VariableController(QObject *parent = 0);
                 virtual ~VariableController();
                 VariableModel *variableModel() noexcept;
                 QItemSelectionModel *variableSelectionModel() noexcept;
                 void setTimeController(TimeController *timeController) noexcept;
                 /**
                  * Deletes from the controller the variable passed in parameter.
                  *
                  * Delete a variable includes:
                  * - the deletion of the provider associated with the variable
+                 * - removing the cache associated with the variable
                  *
                  * @param variable the variable to delete from the controller.
                  */
                 void deleteVariable(std::shared_ptr<Variable> variable) noexcept;
                 /**
                  * Deletes from the controller the variables passed in parameter.
                  * @param variables the variables to delete from the controller.
                  * @sa deleteVariable()
                  */
                 void deleteVariables(const QVector<std::shared_ptr<Variable> > &variables) noexcept;
             signals:
                 /// Signal emitted when a variable has been created
                 void variableCreated(std::shared_ptr<Variable> variable);
             public slots:
                 /// Request the data loading of the variable whithin dateTime
                 void onRequestDataLoading(std::shared_ptr<Variable> variable, const SqpDateTime &dateTime);
                 /**
                  * Creates a new variable and adds it to the model
                  * @param name the name of the new variable
                  * @param provider the data provider for the new variable
                  */
                 void createVariable(const QString &name, std::shared_ptr<IDataProvider> provider) noexcept;
                 /// Update the temporal parameters of every selected variable to dateTime
                 void onDateTimeOnSelection(const SqpDateTime &dateTime);
                 void initialize();
                 void finalize();
             private:
                 void waitForFinish();
                 class VariableControllerPrivate;
                 spimpl::unique_impl_ptr<VariableControllerPrivate> impl;
             };
             #endif // SCIQLOP_VARIABLECONTROLLER_H

core/src/Variable/VariableCacheController.cpp +16 0

             #include "Variable/VariableCacheController.h"
             #include "Variable/Variable.h"
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VariableCacheController, "VariableCacheController")
             struct VariableCacheController::VariableCacheControllerPrivate {
                 std::unordered_map<std::shared_ptr<Variable>, QVector<SqpDateTime> >
                     m_VariableToSqpDateTimeListMap;
                 void addInCacheDataByEnd(const SqpDateTime &dateTime, QVector<SqpDateTime> &dateTimeList,
                                          QVector<SqpDateTime> &notInCache, int cacheIndex,
                                          double currentTStart);
                 void addInCacheDataByStart(const SqpDateTime &dateTime, QVector<SqpDateTime> &dateTimeList,
                                            QVector<SqpDateTime> &notInCache, int cacheIndex,
                                            double currentTStart);
                 void addDateTimeRecurse(const SqpDateTime &dateTime, QVector<SqpDateTime> &dateTimeList,
                                         int cacheIndex);
             };
             VariableCacheController::VariableCacheController(QObject *parent)
                     : QObject{parent}, impl{spimpl::make_unique_impl<VariableCacheControllerPrivate>()}
             {
             }
             void VariableCacheController::addDateTime(std::shared_ptr<Variable> variable,
                                                       const SqpDateTime &dateTime)
             {
                 if (variable) {
                     auto findVariableIte = impl->m_VariableToSqpDateTimeListMap.find(variable);
                     if (findVariableIte == impl->m_VariableToSqpDateTimeListMap.end()) {
                         impl->m_VariableToSqpDateTimeListMap[variable].push_back(dateTime);
                     }
                     else {
                         // addDateTime modify the list<SqpDateTime> of the variable in a way to ensure
                         // that the list is ordered : l(0) < l(1). We assume also a < b
                         // (with a & b of type SqpDateTime) means ts(b) > te(a)
                         // The algorithm will try the merge of two interval:
                         // - dateTime will be compare with the first interval of the list:
                         //   A: if it is inferior, it will be inserted and it's finished.
                         //   B: if it is in intersection, it will be merge then the merged one
                         //      will be compared to the next interval. The old one is remove from the list
                         //   C: if it is superior, we do the same with the next interval of the list
                         try {
                             impl->addDateTimeRecurse(dateTime,
                                                      impl->m_VariableToSqpDateTimeListMap.at(variable), 0);
                         }
                         catch (const std::out_of_range &e) {
                             qCWarning(LOG_VariableCacheController()) << "addDateTime" << e.what();
                         }
                     }
                 }
             }
+            void VariableCacheController::clear(std::shared_ptr<Variable> variable) noexcept
+            {
+                if (!variable) {
+                    qCCritical(LOG_VariableCacheController()) << "Can't clear variable cache: variable is null";
+                    return;
+                }
+                auto nbEntries = impl->m_VariableToSqpDateTimeListMap.erase(variable);
+                auto clearCacheMessage
+                    = (nbEntries != 0)
+                          ? tr("Variable cache cleared for variable %1").arg(variable->name())
+                          : tr("No deletion of variable cache: no cache was associated with the variable");
+                qCDebug(LOG_VariableCacheController()) << clearCacheMessage;
+            }
             QVector<SqpDateTime>
             VariableCacheController::provideNotInCacheDateTimeList(std::shared_ptr<Variable> variable,
                                                                    const SqpDateTime &dateTime)
             {
                 auto notInCache = QVector<SqpDateTime>{};
                 // This algorithm is recursif. The idea is to localise the start time then the end time in the
                 // list of date time request associated to the variable
                 // We assume that the list is ordered in a way that l(0) < l(1). We assume also a < b
                 // (with a & b of type SqpDateTime) means ts(b) > te(a)
                 auto it = impl->m_VariableToSqpDateTimeListMap.find(variable);
                 if (it != impl->m_VariableToSqpDateTimeListMap.end()) {
                     impl->addInCacheDataByStart(dateTime, it->second, notInCache, 0, dateTime.m_TStart);
                 }
                 else {
                     notInCache << dateTime;
                 }
                 return notInCache;
             }
             QVector<SqpDateTime>
             VariableCacheController::dateCacheList(std::shared_ptr<Variable> variable) const noexcept
             {
                 try {
                     return impl->m_VariableToSqpDateTimeListMap.at(variable);
                 }
                 catch (const std::out_of_range &e) {
                     qCWarning(LOG_VariableCacheController()) << e.what();
                     return QVector<SqpDateTime>{};
                 }
             }
             void VariableCacheController::VariableCacheControllerPrivate::addDateTimeRecurse(
                 const SqpDateTime &dateTime, QVector<SqpDateTime> &dateTimeList, int cacheIndex)
             {
                 const auto dateTimeListSize = dateTimeList.count();
                 if (cacheIndex >= dateTimeListSize) {
                     dateTimeList.push_back(dateTime);
                     // there is no anymore interval to compore, we can just push_back it
                     return;
                 }
                 auto currentDateTime = dateTimeList[cacheIndex];
                 if (dateTime.m_TEnd < currentDateTime.m_TStart) {
                     // The compared one is < to current one compared, we can insert it
                     dateTimeList.insert(cacheIndex, dateTime);
                 }
                 else if (dateTime.m_TStart > currentDateTime.m_TEnd) {
                     // The compared one is > to current one compared  we can comparet if to the next one
                     addDateTimeRecurse(dateTime, dateTimeList, ++cacheIndex);
                 }
                 else {
                     // Merge cases: we need to merge the two interval, remove the old one from the list then
                     // rerun the algo from this index with the merged interval
                     auto mTStart = std::min(dateTime.m_TStart, currentDateTime.m_TStart);
                     auto mTEnd = std::max(dateTime.m_TEnd, currentDateTime.m_TEnd);
                     auto mergeDateTime = SqpDateTime{mTStart, mTEnd};
                     dateTimeList.remove(cacheIndex);
                     addDateTimeRecurse(mergeDateTime, dateTimeList, cacheIndex);
                 }
             }
             void VariableCacheController::VariableCacheControllerPrivate::addInCacheDataByEnd(
                 const SqpDateTime &dateTime, QVector<SqpDateTime> &dateTimeList,
                 QVector<SqpDateTime> &notInCache, int cacheIndex, double currentTStart)
             {
                 const auto dateTimeListSize = dateTimeList.count();
                 if (cacheIndex >= dateTimeListSize) {
                     if (currentTStart < dateTime.m_TEnd) {
                         // te localised after all other interval: The last interval is [currentTsart, te]
                         notInCache.push_back(SqpDateTime{currentTStart, dateTime.m_TEnd});
                     }
                     return;
                 }
                 auto currentDateTimeJ = dateTimeList[cacheIndex];
                 if (dateTime.m_TEnd <= currentDateTimeJ.m_TStart) {
                     // te localised between to interval: The last interval is [currentTsart, te]
                     notInCache.push_back(SqpDateTime{currentTStart, dateTime.m_TEnd});
                 }
                 else {
                     notInCache.push_back(SqpDateTime{currentTStart, currentDateTimeJ.m_TStart});
                     if (dateTime.m_TEnd > currentDateTimeJ.m_TEnd) {
                         // te not localised before the current interval: we need to look at the next interval
                         addInCacheDataByEnd(dateTime, dateTimeList, notInCache, ++cacheIndex,
                                             currentDateTimeJ.m_TEnd);
                     }
                 }
             }
             void VariableCacheController::VariableCacheControllerPrivate::addInCacheDataByStart(
                 const SqpDateTime &dateTime, QVector<SqpDateTime> &dateTimeList,
                 QVector<SqpDateTime> &notInCache, int cacheIndex, double currentTStart)
             {
                 const auto dateTimeListSize = dateTimeList.count();
                 if (cacheIndex >= dateTimeListSize) {
                     // ts localised after all other interval: The last interval is [ts, te]
                     notInCache.push_back(SqpDateTime{currentTStart, dateTime.m_TEnd});
                     return;
                 }
                 auto currentDateTimeI = dateTimeList[cacheIndex];
                 if (currentTStart < currentDateTimeI.m_TStart) {
                     // ts localised between to interval: let's localized te
                     addInCacheDataByEnd(dateTime, dateTimeList, notInCache, cacheIndex, currentTStart);
                 }
                 else if (currentTStart < currentDateTimeI.m_TEnd) {
                     if (dateTime.m_TEnd > currentDateTimeI.m_TEnd) {
                         // ts not localised before the current interval: we need to look at the next interval
                         // We can assume now current tstart is the last interval tend, because data between them
                         // are
                         // in the cache
                         addInCacheDataByStart(dateTime, dateTimeList, notInCache, ++cacheIndex,
                                               currentDateTimeI.m_TEnd);
                     }
                 }
                 else {
                     // ts not localised before the current interval: we need to look at the next interval
                     addInCacheDataByStart(dateTime, dateTimeList, notInCache, ++cacheIndex, currentTStart);
                 }
             }
             void VariableCacheController::displayCache(std::shared_ptr<Variable> variable) const
             {
                 auto variableDateTimeList = impl->m_VariableToSqpDateTimeListMap.find(variable);
                 if (variableDateTimeList != impl->m_VariableToSqpDateTimeListMap.end()) {
                     qCInfo(LOG_VariableCacheController()) << tr("VariableCacheController::displayCache")
                                                           << variableDateTimeList->second;
                 }
                 else {
                     qCWarning(LOG_VariableCacheController())
                         << tr("Cannot display a variable that is not in the cache");
                 }
             }

core/src/Variable/VariableController.cpp +3 0

             #include <Variable/Variable.h>
             #include <Variable/VariableCacheController.h>
             #include <Variable/VariableController.h>
             #include <Variable/VariableModel.h>
             #include <Data/DataProviderParameters.h>
             #include <Data/IDataProvider.h>
             #include <Data/IDataSeries.h>
             #include <Time/TimeController.h>
             #include <QDateTime>
             #include <QMutex>
             #include <QThread>
             #include <QtCore/QItemSelectionModel>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
             namespace {
             /// @todo Generates default dataseries, according to the provider passed in parameter. This method
             /// will be deleted when the timerange is recovered from SciQlop
             std::shared_ptr<IDataSeries> generateDefaultDataSeries(const IDataProvider &provider,
                                                                    const SqpDateTime &dateTime) noexcept
             {
                 auto parameters = DataProviderParameters{dateTime};
                 return provider.retrieveData(parameters);
             }
             } // namespace
             struct VariableController::VariableControllerPrivate {
                 explicit VariableControllerPrivate(VariableController *parent)
                         : m_WorkingMutex{},
                           m_VariableModel{new VariableModel{parent}},
                           m_VariableSelectionModel{new QItemSelectionModel{m_VariableModel, parent}},
                           m_VariableCacheController{std::make_unique<VariableCacheController>()}
                 {
                 }
                 QMutex m_WorkingMutex;
                 /// Variable model. The VariableController has the ownership
                 VariableModel *m_VariableModel;
                 QItemSelectionModel *m_VariableSelectionModel;
                 TimeController *m_TimeController{nullptr};
                 std::unique_ptr<VariableCacheController> m_VariableCacheController;
                 std::unordered_map<std::shared_ptr<Variable>, std::shared_ptr<IDataProvider> >
                     m_VariableToProviderMap;
             };
             VariableController::VariableController(QObject *parent)
                     : QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>(this)}
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController construction")
                                                   << QThread::currentThread();
             }
             VariableController::~VariableController()
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController destruction")
                                                   << QThread::currentThread();
                 this->waitForFinish();
             }
             VariableModel *VariableController::variableModel() noexcept
             {
                 return impl->m_VariableModel;
             }
             QItemSelectionModel *VariableController::variableSelectionModel() noexcept
             {
                 return impl->m_VariableSelectionModel;
             }
             void VariableController::setTimeController(TimeController *timeController) noexcept
             {
                 impl->m_TimeController = timeController;
             }
             void VariableController::deleteVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 if (!variable) {
                     qCCritical(LOG_VariableController()) << "Can't delete variable: variable is null";
                     return;
                 }
                 // Deletes provider
                 auto nbProvidersDeleted = impl->m_VariableToProviderMap.erase(variable);
                 qCDebug(LOG_VariableController())
                     << tr("Number of providers deleted for variable %1: %2")
                            .arg(variable->name(), QString::number(nbProvidersDeleted));
+                // Clears cache
+                impl->m_VariableCacheController->clear(variable);
             void VariableController::deleteVariables(
                 const QVector<std::shared_ptr<Variable> > &variables) noexcept
             {
                 for (auto variable : qAsConst(variables)) {
                     deleteVariable(variable);
                 }
             }
             void VariableController::createVariable(const QString &name,
                                                     std::shared_ptr<IDataProvider> provider) noexcept
             {
                 if (!impl->m_TimeController) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to create variable: The time controller is null");
                     return;
                 }
                 /// @todo : for the moment :
                 /// - the provider is only used to retrieve data from the variable for its initialization, but
                 /// it will be retained later
                 /// - default data are generated for the variable, without taking into account the timerange set
                 /// in sciqlop
                 auto dateTime = impl->m_TimeController->dateTime();
                 if (auto newVariable = impl->m_VariableModel->createVariable(name, dateTime)) {
                     // store the provider
                     impl->m_VariableToProviderMap[newVariable] = provider;
                     auto addDateTimeAcquired
                         = [this, newVariable](auto dataSeriesAcquired, auto dateTimeToPutInCache) {
                               impl->m_VariableCacheController->addDateTime(newVariable, dateTimeToPutInCache);
                               newVariable->setDataSeries(dataSeriesAcquired);
                           };
                     connect(provider.get(), &IDataProvider::dataProvided, addDateTimeAcquired);
                     this->onRequestDataLoading(newVariable, dateTime);
                     // notify the creation
                     emit variableCreated(newVariable);
                 }
             }
             void VariableController::onDateTimeOnSelection(const SqpDateTime &dateTime)
             {
                 auto selectedRows = impl->m_VariableSelectionModel->selectedRows();
                 for (const auto &selectedRow : qAsConst(selectedRows)) {
                     if (auto selectedVariable = impl->m_VariableModel->variable(selectedRow.row())) {
                         selectedVariable->setDateTime(dateTime);
                         this->onRequestDataLoading(selectedVariable, dateTime);
                     }
                 }
             }
             void VariableController::onRequestDataLoading(std::shared_ptr<Variable> variable,
                                                           const SqpDateTime &dateTime)
             {
                 // we want to load data of the variable for the dateTime.
                 // First we check if the cache contains some of them.
                 // For the other, we ask the provider to give them.
                 if (variable) {
                     auto dateTimeListNotInCache
                         = impl->m_VariableCacheController->provideNotInCacheDateTimeList(variable, dateTime);
                     if (!dateTimeListNotInCache.empty()) {
                         // Ask the provider for each data on the dateTimeListNotInCache
                         impl->m_VariableToProviderMap.at(variable)->requestDataLoading(
                             std::move(dateTimeListNotInCache));
                     }
                     else {
                         emit variable->updated();
                     }
                 }
                 else {
                     qCCritical(LOG_VariableController()) << tr("Impossible to load data of a variable null");
                 }
             }
             void VariableController::initialize()
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController init") << QThread::currentThread();
                 impl->m_WorkingMutex.lock();
                 qCDebug(LOG_VariableController()) << tr("VariableController init END");
             }
             void VariableController::finalize()
             {
                 impl->m_WorkingMutex.unlock();
             }
             void VariableController::waitForFinish()
             {
                 QMutexLocker locker{&impl->m_WorkingMutex};
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages