HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1143:20294bb49a24

Adaptation to the shared pointers of catalogue controller

trabillard -

r1143:20294bb49a24

parent child

Context file:

r1143:20294bb49a24

core/include/Catalogue/CatalogueController.h +1 -2

                 std::list<std::shared_ptr<DBEvent> > retrieveEvents(const QString &repository) const;
                 std::list<std::shared_ptr<DBEvent> > retrieveAllEvents() const;
                 std::list<std::shared_ptr<DBEvent> >
-                retrieveEventsFromCatalogue(const QString &repository,
+                retrieveEventsFromCatalogue(std::shared_ptr<DBCatalogue> catalogue) const;
-                                            std::shared_ptr<DBCatalogue> catalogue) const;
                 //    void updateEvent(std::shared_ptr<DBEvent> event);
                 //    void trashEvent(std::shared_ptr<DBEvent> event);
                 //    void removeEvent(std::shared_ptr<DBEvent> event);

core/src/Catalogue/CatalogueController.cpp +1 -2

             }
             std::list<std::shared_ptr<DBEvent> >
-            CatalogueController::retrieveEventsFromCatalogue(const QString &repository,
+            CatalogueController::retrieveEventsFromCatalogue(std::shared_ptr<DBCatalogue> catalogue) const
-                                                             std::shared_ptr<DBCatalogue> catalogue) const
             {
                 auto eventsShared = std::list<std::shared_ptr<DBEvent> >{};
                 auto events = impl->m_CatalogueDao.getCatalogueEvents(*catalogue);

gui/include/Catalogue/CatalogueEventsTableModel.h +5 -5

             #include <Common/spimpl.h>
             #include <QAbstractTableModel>
-            #include <DBEvent.h>
+            class DBEvent;
             class CatalogueEventsTableModel : public QAbstractTableModel {
             public:
                 CatalogueEventsTableModel(QObject *parent = nullptr);
-                void setEvents(const QVector<DBEvent> &events);
+                void setEvents(const QVector<std::shared_ptr<DBEvent> > &events);
-                DBEvent getEvent(int row) const;
+                std::shared_ptr<DBEvent> getEvent(int row) const;
-                void addEvent(const DBEvent &events);
+                void addEvent(const std::shared_ptr<DBEvent> &events);
-                void removeEvent(const DBEvent &events);
+                void removeEvent(const std::shared_ptr<DBEvent> &events);
                 // Model
                 int rowCount(const QModelIndex &parent = QModelIndex()) const override;

gui/include/Catalogue/CatalogueEventsWidget.h +2 -2

                 Q_OBJECT
             signals:
-                void eventsSelected(const QVector<DBEvent> &event);
+                void eventsSelected(const QVector<std::shared_ptr<DBEvent> > &event);
             public:
                 explicit CatalogueEventsWidget(QWidget *parent = 0);
                 void setVisualizationWidget(VisualizationWidget *visualization);
             public slots:
-                void populateWithCatalogues(const QVector<DBCatalogue> &catalogues);
+                void populateWithCatalogues(const QVector<std::shared_ptr<DBCatalogue> > &catalogues);
             private:
                 Ui::CatalogueEventsWidget *ui;

gui/include/Catalogue/CatalogueInspectorWidget.h +3 -2

             #define SCIQLOP_CATALOGUEINSPECTORWIDGET_H
             #include <QWidget>
+            #include <memory>
             namespace Ui {
             class CatalogueInspectorWidget;
                 Page currentPage() const;
-                void setEvent(const DBEvent &event);
+                void setEvent(const std::shared_ptr<DBEvent> &event);
-                void setCatalogue(const DBCatalogue &catalogue);
+                void setCatalogue(const std::shared_ptr<DBCatalogue> &catalogue);
             public slots:
                 void showPage(Page page);

gui/include/Catalogue/CatalogueSideBarWidget.h +2 -2

             #include <QTreeWidgetItem>
             #include <QWidget>
-            #include <DBCatalogue.h>
+            class DBCatalogue;
             namespace Ui {
             class CatalogueSideBarWidget;
                 Q_OBJECT
             signals:
-                void catalogueSelected(const QVector<DBCatalogue> &catalogues);
+                void catalogueSelected(const QVector<std::shared_ptr<DBCatalogue> > &catalogues);
                 void databaseSelected(const QStringList &databases);
                 void allEventsSelected();
                 void trashSelected();

gui/include/Catalogue/CatalogueTreeWidgetItem.h +4 -3

             #include <Common/spimpl.h>
             #include <QTreeWidgetItem>
-            #include <DBCatalogue.h>
+            class DBCatalogue;
             class CatalogueTreeWidgetItem : public QTreeWidgetItem {
             public:
-                CatalogueTreeWidgetItem(DBCatalogue catalogue, int type = QTreeWidgetItem::Type);
+                CatalogueTreeWidgetItem(std::shared_ptr<DBCatalogue> catalogue,
+                                        int type = QTreeWidgetItem::Type);
                 QVariant data(int column, int role) const override;
                 void setData(int column, int role, const QVariant &value) override;
                 /// Returns the catalogue represented by the item
-                DBCatalogue catalogue() const;
+                std::shared_ptr<DBCatalogue> catalogue() const;
                 void setHasChanges(bool value);

gui/src/Catalogue/CatalogueEventsTableModel.cpp +14 -14

             #include <Time/TimeController.h>
             struct CatalogueEventsTableModel::CatalogueEventsTableModelPrivate {
-                QVector<DBEvent> m_Events;
+                QVector<std::shared_ptr<DBEvent> > m_Events;
                 enum class Column { Event, TStart, TEnd, Tags, Product, NbColumn };
                 QStringList columnNames()
                     return QStringList{tr("Event"), tr("TStart"), tr("TEnd"), tr("Tags"), tr("Product")};
                 }
-                QVariant eventData(int col, const DBEvent &event) const
+                QVariant eventData(int col, const std::shared_ptr<DBEvent> &event) const
                 {
                     switch (static_cast<Column>(col)) {
                         case Column::Event:
-                            return event.getName();
+                            return event->getName();
                         case Column::TStart:
-                            return DateUtils::dateTime(event.getTStart());
+                            return DateUtils::dateTime(event->getTStart());
                         case Column::TEnd:
-                            return DateUtils::dateTime(event.getTEnd());
+                            return DateUtils::dateTime(event->getTEnd());
                         case Column::Product:
-                            return event.getProduct();
+                            return event->getProduct();
                         case Column::Tags: {
                             QString tagList;
-                            auto tags = const_cast<DBEvent *>(&event)->getTags();
+                            auto tags = event->getTags();
                             for (auto tag : tags) {
                                 tagList += tag.getName();
                                 tagList += ' ';
             {
             }
-            void CatalogueEventsTableModel::setEvents(const QVector<DBEvent> &events)
+            void CatalogueEventsTableModel::setEvents(const QVector<std::shared_ptr<DBEvent> > &events)
             {
                 beginResetModel();
                 impl->m_Events = events;
                 endResetModel();
             }
-            DBEvent CatalogueEventsTableModel::getEvent(int row) const
+            std::shared_ptr<DBEvent> CatalogueEventsTableModel::getEvent(int row) const
             {
                 return impl->m_Events.value(row);
             }
-            void CatalogueEventsTableModel::addEvent(const DBEvent &events)
+            void CatalogueEventsTableModel::addEvent(const std::shared_ptr<DBEvent> &events)
             {
                 beginInsertRows(QModelIndex(), impl->m_Events.count() - 1, impl->m_Events.count() - 1);
                 // impl->m_Events.append(event); TODO
                 endInsertRows();
             }
-            void CatalogueEventsTableModel::removeEvent(const DBEvent &events)
+            void CatalogueEventsTableModel::removeEvent(const std::shared_ptr<DBEvent> &events)
             {
                 // TODO
                 auto index = -1; // impl->m_Events.indexOf(event);
             {
                 auto mimeData = new QMimeData;
-                QVector<DBEvent> eventList;
+                QVector<std::shared_ptr<DBEvent> > eventList;
                 SqpRange firstTimeRange;
                 for (const auto &index : indexes) {
                         auto event = getEvent(index.row());
                         if (eventList.isEmpty()) {
                             // Gets the range of the first variable
-                            firstTimeRange.m_TStart = event.getTStart();
+                            firstTimeRange.m_TStart = event->getTStart();
-                            firstTimeRange.m_TEnd = event.getTEnd();
+                            firstTimeRange.m_TEnd = event->getTEnd();
                         }
                         eventList << event;

gui/src/Catalogue/CatalogueEventsWidget.cpp +12 -13

                 VisualizationWidget *m_VisualizationWidget = nullptr;
-                void setEvents(const QVector<DBEvent> &events, QTableView *tableView)
+                void setEvents(const QVector<std::shared_ptr<DBEvent> > &events, QTableView *tableView)
                 {
                     tableView->setSortingEnabled(false);
                     m_Model->setEvents(events);
                     tableView->setSortingEnabled(true);
                 }
-                void addEvent(const DBEvent &event, QTableView *tableView)
+                void addEvent(const std::shared_ptr<DBEvent> &event, QTableView *tableView)
                 {
                     tableView->setSortingEnabled(false);
                     m_Model->addEvent(event);
                     tableView->setSortingEnabled(true);
                 }
-                void removeEvent(const DBEvent &event, QTableView *tableView)
+                void removeEvent(const std::shared_ptr<DBEvent> &event, QTableView *tableView)
                 {
                     tableView->setSortingEnabled(false);
                     m_Model->removeEvent(event);
                                 for (auto zoneName : m_ZonesForTimeMode) {
                                     if (auto zone = tab->getZoneWithName(zoneName)) {
                                         SqpRange eventRange;
-                                        eventRange.m_TStart = event.getTStart();
+                                        eventRange.m_TStart = event->getTStart();
-                                        eventRange.m_TEnd = event.getTEnd();
+                                        eventRange.m_TEnd = event->getTEnd();
                                         zone->setZoneRange(eventRange);
                                     }
                                 }
                 });
                 auto emitSelection = [this]() {
-                    QVector<DBEvent> events;
+                    QVector<std::shared_ptr<DBEvent> > events;
                     for (auto rowIndex : ui->tableView->selectionModel()->selectedRows()) {
                         events << impl->m_Model->getEvent(rowIndex.row());
                     }
                 impl->m_VisualizationWidget = visualization;
             }
-            void CatalogueEventsWidget::populateWithCatalogues(const QVector<DBCatalogue> &catalogues)
+            void CatalogueEventsWidget::populateWithCatalogues(
+                const QVector<std::shared_ptr<DBCatalogue> > &catalogues)
             {
-                auto &dao = sqpApp->catalogueController().getDao();
                 QSet<QUuid> eventIds;
-                QVector<DBEvent> events;
+                QVector<std::shared_ptr<DBEvent> > events;
                 for (auto catalogue : catalogues) {
-                    auto catalogueEvents = dao.getCatalogueEvents(catalogue);
+                    auto catalogueEvents = sqpApp->catalogueController().retrieveEventsFromCatalogue(catalogue);
                     for (auto event : catalogueEvents) {
-                        if (!eventIds.contains(event.getUniqId())) {
+                        if (!eventIds.contains(event->getUniqId())) {
                             events << event;
-                            eventIds.insert(event.getUniqId());
+                            eventIds.insert(event->getUniqId());
                         }
                     }
                 }

gui/src/Catalogue/CatalogueInspectorWidget.cpp +10 -10

                 return static_cast<Page>(ui->stackedWidget->currentIndex());
             }
-            void CatalogueInspectorWidget::setEvent(const DBEvent &event)
+            void CatalogueInspectorWidget::setEvent(const std::shared_ptr<DBEvent> &event)
             {
                 showPage(Page::EventProperties);
-                ui->leEventName->setText(event.getName());
+                ui->leEventName->setText(event->getName());
-                ui->leEventMission->setText(event.getMission());
+                ui->leEventMission->setText(event->getMission());
-                ui->leEventProduct->setText(event.getProduct());
+                ui->leEventProduct->setText(event->getProduct());
                 QString tagList;
-                auto tags = const_cast<DBEvent *>(&event)->getTags();
+                auto tags = event->getTags();
                 for (auto tag : tags) {
                     tagList += tag.getName();
                     tagList += ' ';
                 ui->leEventTags->setText(tagList);
-                ui->dateTimeEventTStart->setDateTime(DateUtils::dateTime(event.getTStart()));
+                ui->dateTimeEventTStart->setDateTime(DateUtils::dateTime(event->getTStart()));
-                ui->dateTimeEventTEnd->setDateTime(DateUtils::dateTime(event.getTEnd()));
+                ui->dateTimeEventTEnd->setDateTime(DateUtils::dateTime(event->getTEnd()));
             }
-            void CatalogueInspectorWidget::setCatalogue(const DBCatalogue &catalogue)
+            void CatalogueInspectorWidget::setCatalogue(const std::shared_ptr<DBCatalogue> &catalogue)
             {
                 showPage(Page::CatalogueProperties);
-                ui->leCatalogueName->setText(catalogue.getName());
+                ui->leCatalogueName->setText(catalogue->getName());
-                ui->leCatalogueAuthor->setText(catalogue.getAuthor());
+                ui->leCatalogueAuthor->setText(catalogue->getAuthor());
             }

gui/src/Catalogue/CatalogueSideBarWidget.cpp +5 -10

             struct CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate {
-                QHash<QTreeWidgetItem *, DBCatalogue> m_CatalogueMap;
                 void configureTreeWidget(QTreeWidget *treeWidget);
                 QTreeWidgetItem *addDatabaseItem(const QString &name, QTreeWidget *treeWidget);
                 QTreeWidgetItem *getDatabaseItem(const QString &name, QTreeWidget *treeWidget);
-                void addCatalogueItem(const DBCatalogue &catalogue, QTreeWidgetItem *parentDatabaseItem);
+                void addCatalogueItem(const std::shared_ptr<DBCatalogue> &catalogue,
+                                      QTreeWidgetItem *parentDatabaseItem);
             };
             CatalogueSideBarWidget::CatalogueSideBarWidget(QWidget *parent)
                         emit this->selectionCleared();
                     }
                     else {
-                        QVector<DBCatalogue> catalogues;
+                        QVector<std::shared_ptr<DBCatalogue> > catalogues;
                         QStringList databases;
                         int selectionType = selectedItems.first()->type();
                 treeWidget->addTopLevelItem(separatorItem);
                 treeWidget->setItemWidget(separatorItem, 0, separator);
-                auto &dao = sqpApp->catalogueController().getDao();
-                auto allPredicate = std::make_shared<ComparaisonPredicate>(QString{"uniqId"}, "-1",
-                                                                           ComparaisonOperation::DIFFERENT);
                 auto db = addDatabaseItem("Default", treeWidget);
-                auto catalogues = dao.getCatalogues(allPredicate);
+                auto catalogues = sqpApp->catalogueController().getCatalogues("Default");
                 for (auto catalogue : catalogues) {
                     addCatalogueItem(catalogue, db);
                 }
             }
             void CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::addCatalogueItem(
-                const DBCatalogue &catalogue, QTreeWidgetItem *parentDatabaseItem)
+                const std::shared_ptr<DBCatalogue> &catalogue, QTreeWidgetItem *parentDatabaseItem)
             {
                 auto catalogueItem = new CatalogueTreeWidgetItem{catalogue, CATALOGUE_ITEM_TYPE};
                 catalogueItem->setIcon(0, QIcon{":/icones/catalogue.png"});

gui/src/Catalogue/CatalogueTreeWidgetItem.cpp +10 -7

             #include <memory>
+            #include <DBCatalogue.h>
             #include <QBoxLayout>
             #include <QToolButton>
             struct CatalogueTreeWidgetItem::CatalogueTreeWidgetItemPrivate {
-                DBCatalogue m_Catalogue;
+                std::shared_ptr<DBCatalogue> m_Catalogue;
-                CatalogueTreeWidgetItemPrivate(DBCatalogue catalogue) : m_Catalogue(catalogue) {}
+                CatalogueTreeWidgetItemPrivate(std::shared_ptr<DBCatalogue> catalogue) : m_Catalogue(catalogue)
+                {
+                }
             };
-            CatalogueTreeWidgetItem::CatalogueTreeWidgetItem(DBCatalogue catalogue, int type)
+            CatalogueTreeWidgetItem::CatalogueTreeWidgetItem(std::shared_ptr<DBCatalogue> catalogue, int type)
                     : QTreeWidgetItem(type),
                       impl{spimpl::make_unique_impl<CatalogueTreeWidgetItemPrivate>(catalogue)}
             {
                     switch (role) {
                         case Qt::EditRole: // fallthrough
                         case Qt::DisplayRole:
-                            return impl->m_Catalogue.getName();
+                            return impl->m_Catalogue->getName();
                         default:
                             break;
                     }
             {
                 if (role == Qt::EditRole && column == 0) {
                     auto newName = value.toString();
-                    if (newName != impl->m_Catalogue.getName()) {
+                    if (newName != impl->m_Catalogue->getName()) {
                         setText(0, newName);
-                        impl->m_Catalogue.setName(newName);
+                        impl->m_Catalogue->setName(newName);
                         setHasChanges(true);
                     }
                 }
                 }
             }
-            DBCatalogue CatalogueTreeWidgetItem::catalogue() const
+            std::shared_ptr<DBCatalogue> CatalogueTreeWidgetItem::catalogue() const
             {
                 return impl->m_Catalogue;
             }

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