GIT_REPOSITORIES/LPP/Users/mperrinel/SCIQLOP-Initialisation Commit - r644:c050c224f3de

Uses std::vector instead of QVector in ArrayData (1)...

Alexandre Leroux -

r644:c050c224f3de

parent child

Context file:

r644:c050c224f3de

Collapse all files

core/include/Common/SortUtils.h +1 -1

                     for (auto i = 0, componentIndex = 0, permutationIndex = 0; i < containerSize;
                          ++i, componentIndex = i % nbValues, permutationIndex = i / nbValues) {
                         auto insertIndex = sortPermutation.at(permutationIndex) * nbValues + componentIndex;
-                        sortedData.append(container.at(insertIndex));
+                        sortedData.push_back(container.at(insertIndex));
                     }
                     return sortedData;

core/include/Data/ArrayData.h +2 -3

             template <int Dim>
             class ArrayData;
-            using DataContainer = QVector<double>;
+            using DataContainer = std::vector<double>;
             namespace arraydata_detail {
                  * @remarks this method is only available for a unidimensional ArrayData
                  */
                 template <int D = Dim, typename = std::enable_if_t<D == 1> >
-                const QVector<double> &cdata() const noexcept
+                DataContainer cdata() const noexcept
                 {
-                    QReadLocker locker{&m_Lock};
                     return m_Data;
                 }

core/include/Data/DataSeries.h +2 -2

                 SqpRange range() const override
                 {
-                    if (!m_XAxisData->cdata().isEmpty()) {
+                    if (!m_XAxisData->cdata().empty()) {
-                        return SqpRange{m_XAxisData->cdata().first(), m_XAxisData->cdata().last()};
+                        return SqpRange{m_XAxisData->cdata().front(), m_XAxisData->cdata().back()};
                     }
                     return SqpRange{};

core/include/Data/ScalarSeries.h +1 -1

                  * @param xAxisData x-axis data
                  * @param valuesData values data
                  */
-                explicit ScalarSeries(QVector<double> xAxisData, QVector<double> valuesData,
+                explicit ScalarSeries(std::vector<double> xAxisData, std::vector<double> valuesData,
                                       const Unit &xAxisUnit, const Unit &valuesUnit);
                 std::unique_ptr<IDataSeries> clone() const override;

core/include/Data/VectorSeries.h +3 -3

                  * @param yvaluesData y-values data
                  * @param zvaluesData z-values data
                  */
-                explicit VectorSeries(QVector<double> xAxisData, QVector<double> xValuesData,
+                explicit VectorSeries(std::vector<double> xAxisData, std::vector<double> xValuesData,
-                                      QVector<double> yValuesData, QVector<double> zValuesData,
+                                      std::vector<double> yValuesData, std::vector<double> zValuesData,
                                       const Unit &xAxisUnit, const Unit &valuesUnit);
                 /// Default Ctor
-                explicit VectorSeries(QVector<double> xAxisData, QVector<double> valuesData,
+                explicit VectorSeries(std::vector<double> xAxisData, std::vector<double> valuesData,
                                       const Unit &xAxisUnit, const Unit &valuesUnit);
                 std::unique_ptr<IDataSeries> clone() const;

core/src/Data/ScalarSeries.cpp +7 -7

             #include <Data/ScalarSeries.h>
-            ScalarSeries::ScalarSeries(QVector<double> xAxisData, QVector<double> valuesData,
+            ScalarSeries::ScalarSeries(std::vector<double> xAxisData, std::vector<double> valuesData,
                                        const Unit &xAxisUnit, const Unit &valuesUnit)
                     : DataSeries{std::make_shared<ArrayData<1> >(std::move(xAxisData)), xAxisUnit,
                                  std::make_shared<ArrayData<1> >(std::move(valuesData)), valuesUnit}
             std::shared_ptr<IDataSeries> ScalarSeries::subDataSeries(const SqpRange &range)
             {
-                auto subXAxisData = QVector<double>();
+                auto subXAxisData = std::vector<double>();
-                auto subValuesData = QVector<double>();
+                auto subValuesData = std::vector<double>();
                 this->lockRead();
                 {
                     auto bounds = xAxisRange(range.m_TStart, range.m_TEnd);
                     for (auto it = bounds.first; it != bounds.second; ++it) {
-                        subXAxisData.append(it->x());
+                        subXAxisData.push_back(it->x());
-                        subValuesData.append(it->value());
+                        subValuesData.push_back(it->value());
                     }
                 }
                 this->unlock();
-                return std::make_shared<ScalarSeries>(subXAxisData, subValuesData, this->xAxisUnit(),
+                return std::make_shared<ScalarSeries>(std::move(subXAxisData), std::move(subValuesData),
-                                                      this->valuesUnit());
+                                                      this->xAxisUnit(), this->valuesUnit());
             }

core/src/Data/VectorSeries.cpp +22 -17

              * @remarks the three components are consumed
              * @sa ArrayData
              */
-            QVector<double> flatten(QVector<double> xValues, QVector<double> yValues, QVector<double> zValues)
+            std::vector<double> flatten(std::vector<double> xValues, std::vector<double> yValues,
+                                        std::vector<double> zValues)
             {
                 if (xValues.size() != yValues.size() || xValues.size() != zValues.size()) {
                     /// @todo ALX : log
                     return {};
                 }
-                auto result = QVector<double>{};
+                auto result = std::vector<double>();
                 result.reserve(xValues.size() * 3);
-                while (!xValues.isEmpty()) {
+                while (!xValues.empty()) {
-                    result.append({xValues.takeFirst(), yValues.takeFirst(), zValues.takeFirst()});
+                    result.insert(result.cend(), {xValues.front(), yValues.front(), zValues.front()});
+                    xValues.erase(xValues.begin());
+                    yValues.erase(yValues.begin());
+                    zValues.erase(zValues.begin());
                 }
                 return result;
             } // namespace
-            VectorSeries::VectorSeries(QVector<double> xAxisData, QVector<double> xValuesData,
+            VectorSeries::VectorSeries(std::vector<double> xAxisData, std::vector<double> xValuesData,
-                                       QVector<double> yValuesData, QVector<double> zValuesData,
+                                       std::vector<double> yValuesData, std::vector<double> zValuesData,
                                        const Unit &xAxisUnit, const Unit &valuesUnit)
                     : VectorSeries{std::move(xAxisData), flatten(std::move(xValuesData), std::move(yValuesData),
                                                                  std::move(zValuesData)),
             {
             }
-            VectorSeries::VectorSeries(QVector<double> xAxisData, QVector<double> valuesData,
+            VectorSeries::VectorSeries(std::vector<double> xAxisData, std::vector<double> valuesData,
                                        const Unit &xAxisUnit, const Unit &valuesUnit)
                     : DataSeries{std::make_shared<ArrayData<1> >(std::move(xAxisData)), xAxisUnit,
                                  std::make_shared<ArrayData<2> >(std::move(valuesData), 3), valuesUnit}
             std::shared_ptr<IDataSeries> VectorSeries::subDataSeries(const SqpRange &range)
             {
-                auto subXAxisData = QVector<double>();
+                auto subXAxisData = std::vector<double>();
-                auto subXValuesData = QVector<double>();
+                auto subXValuesData = std::vector<double>();
-                auto subYValuesData = QVector<double>();
+                auto subYValuesData = std::vector<double>();
-                auto subZValuesData = QVector<double>();
+                auto subZValuesData = std::vector<double>();
                 this->lockRead();
                 {
                     auto bounds = xAxisRange(range.m_TStart, range.m_TEnd);
                     for (auto it = bounds.first; it != bounds.second; ++it) {
-                        subXAxisData.append(it->x());
+                        subXAxisData.push_back(it->x());
-                        subXValuesData.append(it->value(0));
+                        subXValuesData.push_back(it->value(0));
-                        subYValuesData.append(it->value(1));
+                        subYValuesData.push_back(it->value(1));
-                        subZValuesData.append(it->value(2));
+                        subZValuesData.push_back(it->value(2));
                     }
                 }
                 this->unlock();
-                return std::make_shared<VectorSeries>(subXAxisData, subXValuesData, subYValuesData,
+                return std::make_shared<VectorSeries>(std::move(subXAxisData), std::move(subXValuesData),
-                                                      subZValuesData, this->xAxisUnit(), this->valuesUnit());
+                                                      std::move(subYValuesData), std::move(subZValuesData),
+                                                      this->xAxisUnit(), this->valuesUnit());
             }

plugins/amda/src/AmdaResultParser.cpp +8 -7

                     case ValueType::SCALAR:
                         Q_ASSERT(results.second.size() == 1);
                         return std::make_shared<ScalarSeries>(
-                            std::move(results.first), std::move(results.second.takeFirst()), xAxisUnit, Unit{});
+                            std::move(results.first.toStdVector()),
+                            std::move(results.second.takeFirst().toStdVector()), xAxisUnit, Unit{});
                     case ValueType::VECTOR: {
                         Q_ASSERT(results.second.size() == 3);
-                        auto xValues = results.second.takeFirst();
+                        auto xValues = results.second.takeFirst().toStdVector();
-                        auto yValues = results.second.takeFirst();
+                        auto yValues = results.second.takeFirst().toStdVector();
-                        auto zValues = results.second.takeFirst();
+                        auto zValues = results.second.takeFirst().toStdVector();
-                        return std::make_shared<VectorSeries>(std::move(results.first), std::move(xValues),
+                        return std::make_shared<VectorSeries>(std::move(results.first.toStdVector()),
-                                                              std::move(yValues), std::move(zValues), xAxisUnit,
+                                                              std::move(xValues), std::move(yValues),
-                                                              Unit{});
+                                                              std::move(zValues), xAxisUnit, Unit{});
                     }
                     case ValueType::UNKNOWN:
                         // Invalid case

plugins/mockplugin/src/CosinusProvider.cpp +5 -5

                 auto dataIndex = 0;
                 // Gets the timerange from the parameters
-                double freq = 1.0;
+                double freq = 100.0;
                 double start = std::ceil(dataRangeRequested.m_TStart * freq); // 100 htz
                 double end = std::floor(dataRangeRequested.m_TEnd * freq);    // 100 htz
                 // Generates scalar series containing cosinus values (one value per second)
                 auto dataCount = end - start;
-                auto xAxisData = QVector<double>{};
+                auto xAxisData = std::vector<double>{};
                 xAxisData.resize(dataCount);
-                auto valuesData = QVector<double>{};
+                auto valuesData = std::vector<double>{};
                 valuesData.resize(dataCount);
                 int progress = 0;
                     if (it != m_VariableToEnableProvider.end() && it.value()) {
                         const auto timeOnFreq = time / freq;
-                        xAxisData.replace(dataIndex, timeOnFreq);
+                        xAxisData[dataIndex] = timeOnFreq;
-                        valuesData.replace(dataIndex, std::cos(timeOnFreq));
+                        valuesData[dataIndex] = std::cos(timeOnFreq);
                         // progression
                         int currentProgress = (time - start) * 100.0 / progressEnd;

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