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,
-                                             std::shared_ptr<DBCatalogue> catalogue) const;
+                 retrieveEventsFromCatalogue(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,
-                                                              std::shared_ptr<DBCatalogue> catalogue) const
+             CatalogueController::retrieveEventsFromCatalogue(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);
-                 DBEvent getEvent(int row) const;
+                 void setEvents(const QVector<std::shared_ptr<DBEvent> > &events);
+                 std::shared_ptr<DBEvent> getEvent(int row) const;
-                 void addEvent(const DBEvent &events);
-                 void removeEvent(const DBEvent &events);
+                 void addEvent(const std::shared_ptr<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 setCatalogue(const DBCatalogue &catalogue);
+                 void setEvent(const std::shared_ptr<DBEvent> &event);
+                 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_TEnd = event.getTEnd();
+                             firstTimeRange.m_TStart = event->getTStart();
+                             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_TEnd = event.getTEnd();
+                                         eventRange.m_TStart = event->getTStart();
+                                         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->leEventMission->setText(event.getMission());
-                 ui->leEventProduct->setText(event.getProduct());
+                 ui->leEventName->setText(event->getName());
+                 ui->leEventMission->setText(event->getMission());
+                 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->dateTimeEventTEnd->setDateTime(DateUtils::dateTime(event.getTEnd()));
+                 ui->dateTimeEventTStart->setDateTime(DateUtils::dateTime(event->getTStart()));
+                 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->leCatalogueAuthor->setText(catalogue.getAuthor());
+                 ui->leCatalogueName->setText(catalogue->getName());
+                 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