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()) {
-                         return SqpRange{m_XAxisData->cdata().first(), m_XAxisData->cdata().last()};
+                     if (!m_XAxisData->cdata().empty()) {
+                         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,
-                                       QVector<double> yValuesData, QVector<double> zValuesData,
+                 explicit VectorSeries(std::vector<double> xAxisData, std::vector<double> xValuesData,
+                                       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 subValuesData = QVector<double>();
+                 auto subXAxisData = std::vector<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());
-                         subValuesData.append(it->value());
+                         subXAxisData.push_back(it->x());
+                         subValuesData.push_back(it->value());
                      }
                  }
                  this->unlock();
-                 return std::make_shared<ScalarSeries>(subXAxisData, subValuesData, this->xAxisUnit(),
-                                                       this->valuesUnit());
+                 return std::make_shared<ScalarSeries>(std::move(subXAxisData), std::move(subValuesData),
+                                                       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()) {
-                     result.append({xValues.takeFirst(), yValues.takeFirst(), zValues.takeFirst()});
+                 while (!xValues.empty()) {
+                     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,
-                                        QVector<double> yValuesData, QVector<double> zValuesData,
+             VectorSeries::VectorSeries(std::vector<double> xAxisData, std::vector<double> xValuesData,
+                                        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 subXValuesData = QVector<double>();
-                 auto subYValuesData = QVector<double>();
-                 auto subZValuesData = QVector<double>();
+                 auto subXAxisData = std::vector<double>();
+                 auto subXValuesData = std::vector<double>();
+                 auto subYValuesData = std::vector<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());
-                         subXValuesData.append(it->value(0));
-                         subYValuesData.append(it->value(1));
-                         subZValuesData.append(it->value(2));
+                         subXAxisData.push_back(it->x());
+                         subXValuesData.push_back(it->value(0));
+                         subYValuesData.push_back(it->value(1));
+                         subZValuesData.push_back(it->value(2));
                      }
                  }
                  this->unlock();
-                 return std::make_shared<VectorSeries>(subXAxisData, subXValuesData, subYValuesData,
-                                                       subZValuesData, this->xAxisUnit(), this->valuesUnit());
+                 return std::make_shared<VectorSeries>(std::move(subXAxisData), std::move(subXValuesData),
+                                                       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 yValues = results.second.takeFirst();
-                         auto zValues = results.second.takeFirst();
-                         return std::make_shared<VectorSeries>(std::move(results.first), std::move(xValues),
-                                                               std::move(yValues), std::move(zValues), xAxisUnit,
-                                                               Unit{});
+                         auto xValues = results.second.takeFirst().toStdVector();
+                         auto yValues = results.second.takeFirst().toStdVector();
+                         auto zValues = results.second.takeFirst().toStdVector();
+                         return std::make_shared<VectorSeries>(std::move(results.first.toStdVector()),
+                                                               std::move(xValues), std::move(yValues),
+                                                               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);
-                         valuesData.replace(dataIndex, std::cos(timeOnFreq));
+                         xAxisData[dataIndex] = 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