clang-tidy GUI/Model/*/*

GUI/Model/Component/ComponentProxyModel.h

@@ -44,15 +44,15 @@ public:
 
     void setProxyStrategy(ProxyModelStrategy* strategy);
 
-    QModelIndex mapToSource(const QModelIndex& proxyIndex) const;
-    QModelIndex mapFromSource(const QModelIndex& sourceIndex) const;
+    QModelIndex mapToSource(const QModelIndex& proxyIndex) const override;
+    QModelIndex mapFromSource(const QModelIndex& sourceIndex) const override;
 
-    QModelIndex index(int row, int column, const QModelIndex& parent = {}) const;
-    QModelIndex parent(const QModelIndex& child) const;
-    int rowCount(const QModelIndex& parent = {}) const;
-    int columnCount(const QModelIndex& parent = {}) const;
+    QModelIndex index(int row, int column, const QModelIndex& parent = {}) const override;
+    QModelIndex parent(const QModelIndex& child) const override;
+    int rowCount(const QModelIndex& parent = {}) const override;
+    int columnCount(const QModelIndex& parent = {}) const override;
 
-    bool hasChildren(const QModelIndex& parent) const;
+    bool hasChildren(const QModelIndex& parent) const override;
 
 private slots:
     void sourceDataChanged(const QModelIndex& topLeft, const QModelIndex& bottomRight,

GUI/Model/Component/ComponentProxyStrategy.cpp

@@ -92,11 +92,7 @@ void ComponentProxyStrategy::processRootItem(SessionItem* item,
 bool ComponentProxyStrategy::isSubGroup(SessionItem* item)
 {
     const SessionItem* ancestor = GUI::Model::Path::ancestor(item->parent(), GroupItem::M_TYPE);
-    if (item->hasModelType<GroupItem>() && ancestor && ancestor->hasModelType<GroupItem>()) {
-        return true;
-    }
-
-    return false;
+    return item->hasModelType<GroupItem>() && ancestor && ancestor->hasModelType<GroupItem>();
 }
 
 //! Returns true if item is a children/grandchildrent of some group item.
@@ -123,7 +119,7 @@ void ComponentProxyStrategy::processGroupItem(SessionItem* item,
         if (ancestor == item)
             return;
 
-        auto groupItem = dynamic_cast<const GroupItem*>(ancestor);
+        const auto *groupItem = dynamic_cast<const GroupItem*>(ancestor);
         if (item->parent() == groupItem->currentItem()) {
             QPersistentModelIndex proxyIndex = createProxyIndex(
                 parentVisibleRow(*item), sourceIndex.column(), sourceIndex.internalPointer());
@@ -141,7 +137,7 @@ void ComponentProxyStrategy::processSubGroupItem(SessionItem* item,
 {
     if (const SessionItem* ancestor =
             GUI::Model::Path::ancestor(item->parent(), GroupItem::M_TYPE)) {
-        auto groupItem = dynamic_cast<const GroupItem*>(ancestor);
+        const auto *groupItem = dynamic_cast<const GroupItem*>(ancestor);
 
         if (item->parent() == groupItem->currentItem()) {
             QPersistentModelIndex proxyIndex = createProxyIndex(
@@ -179,7 +175,7 @@ int ComponentProxyStrategy::parentVisibleRow(const SessionItem& item)
     if (!item.parent() || !item.isVisible())
         return result;
 
-    for (auto child : item.parent()->children()) {
+    for (auto *child : item.parent()->children()) {
         if (child->isVisible() && isPropertyRelated(child))
             ++result;
 

GUI/Model/Component/ComponentProxyStrategy.h

@@ -21,10 +21,10 @@
 
 class ComponentProxyStrategy : public ProxyModelStrategy {
 public:
-    void onDataChanged(SessionModel* source, ComponentProxyModel* proxy);
+    void onDataChanged(SessionModel* source, ComponentProxyModel* proxy) override;
 
 protected:
-    bool processSourceIndex(const QModelIndex& index);
+    bool processSourceIndex(const QModelIndex& index) override;
 
 private:
     bool isPropertyRelated(SessionItem* item);

GUI/Model/Component/ComponentUtils.cpp

@@ -24,7 +24,7 @@ namespace {
 QList<const SessionItem*> groupItems(const GroupItem& item)
 {
     QList<const SessionItem*> result;
-    for (auto grandchild : item.children())
+    for (auto *grandchild : item.children())
         if (grandchild->isVisible())
             result += GUI::Model::ComponentUtils::componentItems(*grandchild);
     return result;
@@ -56,7 +56,7 @@ QList<const SessionItem*> GUI::Model::ComponentUtils::componentItems(const Sessi
 
     } else {
 
-        for (auto child : item.children()) {
+        for (auto *child : item.children()) {
             if (!child->isVisible())
                 continue;
 

GUI/Model/Component/ProxyModelStrategy.h

@@ -56,7 +56,7 @@ protected:
 
 class IndentityProxyStrategy : public ProxyModelStrategy {
 protected:
-    bool processSourceIndex(const QModelIndex& index);
+    bool processSourceIndex(const QModelIndex& index) override;
 };
 
 #endif // BORNAGAIN_GUI_MODEL_COMPONENT_PROXYMODELSTRATEGY_H

GUI/Model/Data/ApplicationModels.cpp

@@ -104,14 +104,14 @@ void ApplicationModels::resetModels()
 
 void ApplicationModels::writeTo(QXmlStreamWriter* writer)
 {
-    for (auto model : modelList())
+    for (auto *model : modelList())
         model->writeTo(writer);
 }
 
 void ApplicationModels::readFrom(QXmlStreamReader* reader, MessageService* messageService)
 {
     try {
-        for (auto model : modelList()) {
+        for (auto *model : modelList()) {
             if (model->getModelTag() == reader->name()) {
                 model->readFrom(reader, messageService);
                 break;

GUI/Model/Data/ApplicationModels.h

@@ -31,7 +31,7 @@ class ApplicationModels : public QObject {
     Q_OBJECT
 public:
     explicit ApplicationModels(QObject* parent = nullptr);
-    ~ApplicationModels();
+    ~ApplicationModels() override;
 
     DocumentModel* documentModel() const;
     MaterialModel* materialModel() const;

GUI/Model/Data/AxesItems.h

@@ -33,7 +33,7 @@ public:
     static constexpr auto M_TYPE{"BasicAxis"};
 
     BasicAxisItem();
-    virtual ~BasicAxisItem();
+    ~BasicAxisItem() override;
 
     int binCount() const;
     void setBinCount(int value);

GUI/Model/Data/Data1DViewItem.cpp

@@ -34,10 +34,10 @@ Data1DViewItem::Data1DViewItem() : SessionItem(M_TYPE), m_job_item(nullptr)
 {
     addProperty(P_TITLE, QString())->setVisible(false);
 
-    auto basicAxis = addProperty<BasicAxisItem>(P_XAXIS);
+    auto *basicAxis = addProperty<BasicAxisItem>(P_XAXIS);
     basicAxis->binsItem()->setVisible(false);
 
-    auto amplitudeAxis = addProperty<AmplitudeAxisItem>(P_YAXIS);
+    auto *amplitudeAxis = addProperty<AmplitudeAxisItem>(P_YAXIS);
     amplitudeAxis->binsItem()->setVisible(false);
     amplitudeAxis->titleItem()->setVisible(true);
     amplitudeAxis->visibilityItem()->setValue(true);
@@ -176,7 +176,7 @@ JobItem* Data1DViewItem::jobItem()
     if (m_job_item != nullptr)
         return m_job_item; // returning preset job item
 
-    auto item = parent();
+    auto *item = parent();
     do {
         if (item->modelType() == JobItem::M_TYPE) {
             m_job_item = dynamic_cast<JobItem*>(item);

GUI/Model/Data/DataItem.cpp

@@ -29,7 +29,7 @@ void DataItem::setRawDataVector(std::vector<double> data)
         throw Error("DataItem::setRawDataVector() -> Error. "
                     "Different data size.");
     std::unique_lock<std::mutex> lock(m_update_data_mutex);
-    m_data->setRawDataVector(std::move(data));
+    m_data->setRawDataVector(data);
     emitDataChanged();
 }
 
@@ -56,7 +56,7 @@ bool DataItem::containsNonXMLData() const
 bool DataItem::loadData(const QString& projectDir)
 {
     QString filename = fileName(projectDir);
-    auto data = IntensityDataIOFactory::readOutputData(filename.toStdString());
+    auto *data = IntensityDataIOFactory::readOutputData(filename.toStdString());
     if (!data)
         return false;
     setOutputData(data);
@@ -82,7 +82,7 @@ void DataItem::setLastModified(const QDateTime& dtime)
 
 QString DataItem::selectedCoords() const
 {
-    ComboProperty combo = getItemValue(DataItem::P_AXES_UNITS).value<ComboProperty>();
+    auto combo = getItemValue(DataItem::P_AXES_UNITS).value<ComboProperty>();
     return combo.getValue();
 }
 

GUI/Model/Data/DataItemUtils.cpp

@@ -25,9 +25,9 @@ template <class DataItemType> DataItemType* dataItem(SessionItem* parent)
 
     if (parent->modelType() == JobItem::M_TYPE)
         return dynamic_cast<DataItemType*>(dynamic_cast<JobItem*>(parent)->dataItem());
-    if (auto real_data = dynamic_cast<RealDataItem*>(parent))
+    if (auto *real_data = dynamic_cast<RealDataItem*>(parent))
         return dynamic_cast<DataItemType*>(real_data->dataItem());
-    if (auto self = dynamic_cast<DataItemType*>(parent))
+    if (auto *self = dynamic_cast<DataItemType*>(parent))
         return self;
     ASSERT(0);
 }

GUI/Model/Data/DataProperties.cpp

@@ -19,6 +19,7 @@
 #include "GUI/Util/ComboProperty.h"
 #include "GUI/Util/Error.h"
 #include <QColor>
+#include <utility>
 
 namespace {
 // set of simple colors for representation of 1D graphs
@@ -28,7 +29,7 @@ const std::vector<std::pair<QString, Qt::GlobalColor>> color_queue = {
     {"Gray", Qt::GlobalColor::darkGray}, {"Magenta", Qt::GlobalColor::darkMagenta}};
 
 struct ColorNameComparator {
-    ColorNameComparator(const QString& value_to_comp) : m_value_to_comp(value_to_comp) {}
+    ColorNameComparator(QString  value_to_comp) : m_value_to_comp(std::move(value_to_comp)) {}
     bool operator()(const std::pair<QString, Qt::GlobalColor>& value) const
     {
         return value.first == m_value_to_comp;
@@ -62,7 +63,7 @@ DataItem* DataProperties::dataItem()
         os << path.toStdString() << " is invalid" << std::endl;
         throw Error(QString::fromStdString(os.str()));
     }
-    auto item = hosting_model->itemForIndex(item_index);
+    auto *item = hosting_model->itemForIndex(item_index);
     return dynamic_cast<DataItem*>(item);
 }
 
@@ -109,7 +110,7 @@ namespace {
 ComboProperty defaultColorCombo()
 {
     ComboProperty result;
-    for (auto& color : color_queue)
+    for (const auto& color : color_queue)
         result << color.first;
     result.setValue(color_queue.front().first);
     return result;

GUI/Model/Data/DataPropertyContainer.cpp

@@ -37,14 +37,14 @@ Data1DProperties* DataPropertyContainer::propertyItem(size_t i) const
     auto children = getItems();
     if (children.empty())
         return nullptr;
-    auto property_item = dynamic_cast<Data1DProperties*>(children[static_cast<int>(i)]);
+    auto *property_item = dynamic_cast<Data1DProperties*>(children[static_cast<int>(i)]);
     ASSERT(property_item);
     return property_item;
 }
 
 DataItem* DataPropertyContainer::basicDataItem() const
 {
-    auto basic_property_item = propertyItem(0);
+    auto *basic_property_item = propertyItem(0);
     if (!basic_property_item)
         return nullptr;
     return basic_property_item->dataItem();
@@ -60,7 +60,7 @@ void DataPropertyContainer::addItem(DataItem* data_item)
     if (!propertyItems().empty())
         previous_item = dynamic_cast<Data1DProperties*>(propertyItems().back());
 
-    auto property_item = new Data1DProperties();
+    auto *property_item = new Data1DProperties();
     insertItem(-1, property_item);
     property_item->setDataItem(data_item);
     property_item->setColorProperty(Data1DProperties::nextColorName(previous_item));
@@ -72,7 +72,7 @@ std::vector<DataItem*> DataPropertyContainer::dataItems()
     auto items = propertyItems();
     std::transform(items.begin(), items.end(), std::back_inserter(result),
                    [](Data1DProperties* item) {
-                       auto data_item = item->dataItem();
+                       auto *data_item = item->dataItem();
                        ASSERT(data_item);
                        return data_item;
                    });

GUI/Model/Data/DataViewUtils.cpp

@@ -24,7 +24,7 @@ namespace {
 
 ICoordSystem* getConverter(Data1DViewItem* view_item)
 {
-    auto job_item = view_item->jobItem();
+    auto *job_item = view_item->jobItem();
     ASSERT(job_item->instrumentItem());
 
     return job_item->instrumentItem()->createCoordSystem();
@@ -57,7 +57,7 @@ GUI::Model::DataViewUtils::getTranslatedData(Data1DViewItem* view_item, DataItem
     if (!data_item || !data_item->getOutputData())
         return result;
 
-    auto converter = getConverter(view_item);
+    auto *converter = getConverter(view_item);
     auto current_units = selectedUnits(view_item);
 
     result = converter->createOutputData(current_units);

GUI/Model/Data/ImportDataInfo.cpp

@@ -13,6 +13,8 @@
 //  ************************************************************************************************
 
 #include "GUI/Model/Data/ImportDataInfo.h"
+
+#include <memory>
 #include "Device/Coord/AxisNames.h"
 #include "Device/Data/OutputData.h"
 #include "GUI/Model/IO/OutputDataUtils.h"
@@ -23,7 +25,7 @@ namespace {
 std::vector<Axes::Coords> specularUnits()
 {
     std::vector<Axes::Coords> result;
-    for (auto& pair : DataUtils::AxisNames::specAxis)
+    for (const auto& pair : DataUtils::AxisNames::specAxis)
         result.push_back(pair.first);
     return result;
 }
@@ -34,7 +36,7 @@ std::map<size_t, std::vector<Axes::Coords>> available_units = {{1u, specularUnit
 } // namespace
 
 ImportDataInfo::ImportDataInfo(ImportDataInfo&& other)
-    : m_data(std::move(other.m_data)), m_coords(other.m_coords)
+ noexcept     : m_data(std::move(other.m_data)), m_coords(other.m_coords)
 {
 }
 
@@ -53,7 +55,7 @@ ImportDataInfo::ImportDataInfo(std::unique_ptr<OutputData<double>> data, const Q
 }
 
 ImportDataInfo::ImportDataInfo(OutputData<double>&& data, Axes::Coords units)
-    : ImportDataInfo(std::unique_ptr<OutputData<double>>(new OutputData<double>(std::move(data))),
+    : ImportDataInfo(std::make_unique<OutputData<double>>(std::move(data)),
                      units)
 {
 }

GUI/Model/Data/ImportDataInfo.h

@@ -28,7 +28,7 @@ public:
     ImportDataInfo(std::unique_ptr<OutputData<double>> data, Axes::Coords units);
     ImportDataInfo(OutputData<double>&& data, Axes::Coords units);
     ImportDataInfo(std::unique_ptr<OutputData<double>> data, const QString& units);
-    ImportDataInfo(ImportDataInfo&& other);
+    ImportDataInfo(ImportDataInfo&& other) noexcept ;
     ~ImportDataInfo();
 
     //! True if the contained data is not nullptr (no info about empty data)

GUI/Model/Data/IntensityDataItem.cpp

@@ -54,13 +54,13 @@ IntensityDataItem::IntensityDataItem() : DataItem(M_TYPE)
     addProperty(P_IS_INTERPOLATED, true);
     addProperty(P_GRADIENT, gradientCombo().variant());
 
-    auto basicAxis = addProperty<BasicAxisItem>(P_XAXIS);
+    auto *basicAxis = addProperty<BasicAxisItem>(P_XAXIS);
     basicAxis->binsItem()->setVisible(false);
 
     basicAxis = addProperty<BasicAxisItem>(P_YAXIS);
     basicAxis->binsItem()->setVisible(false);
 
-    auto amplitudeAxis = addProperty<AmplitudeAxisItem>(P_ZAXIS);
+    auto *amplitudeAxis = addProperty<AmplitudeAxisItem>(P_ZAXIS);
     amplitudeAxis->binsItem()->setVisible(false);
 
     setXaxisTitle(x_axis_default_name);

GUI/Model/Data/MaskItems.cpp

@@ -146,7 +146,7 @@ RegionOfInterestItem::RegionOfInterestItem() : RectangleItem(M_TYPE)
 std::unique_ptr<IShape2D> RegionOfInterestItem::createShape(double scale) const
 {
     auto shape = RectangleItem::createShape(scale);
-    static_cast<Rectangle*>(shape.get())->setInverted(true);
+    dynamic_cast<Rectangle*>(shape.get())->setInverted(true);
     return shape;
 }
 
@@ -193,7 +193,7 @@ PolygonItem::PolygonItem() : MaskItem(M_TYPE)
 std::unique_ptr<IShape2D> PolygonItem::createShape(double scale) const
 {
     std::vector<double> x, y;
-    for (auto item : this->childrenOfType<PolygonPointItem>()) {
+    for (auto *item : this->childrenOfType<PolygonPointItem>()) {
         x.push_back(scale * item->posX());
         y.push_back(scale * item->posY());
     }

GUI/Model/Data/MaskItems.h

@@ -62,7 +62,7 @@ public:
     static constexpr auto M_TYPE{"RectangleMask"};
 
     explicit RectangleItem();
-    virtual std::unique_ptr<IShape2D> createShape(double scale) const override;
+    std::unique_ptr<IShape2D> createShape(double scale) const override;
 
     double xLow() const;
     void setXLow(double x_low);
@@ -82,7 +82,7 @@ public:
     static constexpr auto M_TYPE{"RegionOfInterest"};
 
     RegionOfInterestItem();
-    virtual std::unique_ptr<IShape2D> createShape(double scale) const override;
+    std::unique_ptr<IShape2D> createShape(double scale) const override;
 };
 
 class PolygonPointItem : public SessionItem {
@@ -109,7 +109,7 @@ public:
     static constexpr auto M_TYPE{"PolygonMask"};
 
     PolygonItem();
-    virtual std::unique_ptr<IShape2D> createShape(double scale) const override;
+    std::unique_ptr<IShape2D> createShape(double scale) const override;
 
     bool isClosed() const;
     void setIsClosed(bool closed);
@@ -123,7 +123,7 @@ public:
     static constexpr auto M_TYPE{"VerticalLineMask"};
 
     VerticalLineItem();
-    virtual std::unique_ptr<IShape2D> createShape(double scale) const override;
+    std::unique_ptr<IShape2D> createShape(double scale) const override;
 
     double posX() const;
     void setPosX(double pos_x);
@@ -138,7 +138,7 @@ public:
     static constexpr auto M_TYPE{"HorizontalLineMask"};
 
     HorizontalLineItem();
-    virtual std::unique_ptr<IShape2D> createShape(double scale) const override;
+    std::unique_ptr<IShape2D> createShape(double scale) const override;
 
     double posY() const;
     void setPosY(double pos_y);
@@ -157,7 +157,7 @@ public:
     static constexpr auto M_TYPE{"EllipseMask"};
 
     EllipseItem();
-    virtual std::unique_ptr<IShape2D> createShape(double scale) const override;
+    std::unique_ptr<IShape2D> createShape(double scale) const override;
 
     double xCenter() const;
     void setXCenter(double x_center);
@@ -185,7 +185,7 @@ public:
     static constexpr auto M_TYPE{"MaskAllMask"};
 
     MaskAllItem();
-    virtual std::unique_ptr<IShape2D> createShape(double scale) const override;
+    std::unique_ptr<IShape2D> createShape(double scale) const override;
 };
 
 #endif // BORNAGAIN_GUI_MODEL_DATA_MASKITEMS_H

GUI/Model/Data/MaskUnitsConverter.cpp

@@ -64,7 +64,7 @@ void MaskUnitsConverter::convertMask(SessionItem* maskItem)
 {
     if (maskItem->modelType() == RectangleItem::M_TYPE
         || maskItem->modelType() == RegionOfInterestItem::M_TYPE) {
-        RectangleItem* rectItem = polymorphic_downcast<RectangleItem*>(maskItem);
+        auto* rectItem = polymorphic_downcast<RectangleItem*>(maskItem);
         rectItem->setXLow(convert(rectItem->xLow(), Axis::X));
         rectItem->setYLow(convert(rectItem->yLow(), Axis::Y));
         rectItem->setXUp(convert(rectItem->xUp(), Axis::X));
@@ -75,13 +75,13 @@ void MaskUnitsConverter::convertMask(SessionItem* maskItem)
             pointItem->setPosY(convert(pointItem->posY(), Axis::Y));
         }
     } else if (maskItem->modelType() == VerticalLineItem::M_TYPE) {
-        VerticalLineItem* vlineItem = polymorphic_downcast<VerticalLineItem*>(maskItem);
+        auto* vlineItem = polymorphic_downcast<VerticalLineItem*>(maskItem);
         vlineItem->setPosX(convert(vlineItem->posX(), Axis::X));
     } else if (maskItem->modelType() == HorizontalLineItem::M_TYPE) {
-        HorizontalLineItem* hlineItem = polymorphic_downcast<HorizontalLineItem*>(maskItem);
+        auto* hlineItem = polymorphic_downcast<HorizontalLineItem*>(maskItem);
         hlineItem->setPosY(convert(hlineItem->posY(), Axis::Y));
     } else if (maskItem->modelType() == EllipseItem::M_TYPE) {
-        EllipseItem* ellItem = polymorphic_downcast<EllipseItem*>(maskItem);
+        auto* ellItem = polymorphic_downcast<EllipseItem*>(maskItem);
         double xc = ellItem->xCenter();
         double yc = ellItem->yCenter();
         double xR = ellItem->xRadius();
@@ -124,7 +124,7 @@ void MaskUnitsConverter::convertCoordinate(SessionItem* maskItem, const QString&
 
 double MaskUnitsConverter::convert(double value, Axis axis)
 {
-    size_t axis_index = static_cast<size_t>(axis);
+    auto axis_index = static_cast<size_t>(axis);
 
     ASSERT(m_data);
     ASSERT(axis_index == 0 || axis_index == 1);