GIT_REPOSITORIES/LPP/Users/mperrinel/SCIQLOP-Initialisation Commit - r643:6c665d58d405

Merge branch 'feature/ImprovePerfs2' into develop

Alexandre Leroux -

r643:6c665d58d405

parent child

Context file:

r643:6c665d58d405

Collapse all files

core/include/Data/ArrayData.h +26 0

              #ifndef SCIQLOP_ARRAYDATA_H
              #define SCIQLOP_ARRAYDATA_H
              #include "Data/ArrayDataIterator.h"
              #include <Common/SortUtils.h>
              #include <QReadLocker>
              #include <QReadWriteLock>
              #include <QVector>
              #include <memory>
              template <int Dim>
              class ArrayData;
              using DataContainer = QVector<double>;
              namespace arraydata_detail {
              /// Struct used to sort ArrayData
              template <int Dim>
              struct Sort {
                  static std::shared_ptr<ArrayData<Dim> > sort(const DataContainer &data, int nbComponents,
                                                               const std::vector<int> &sortPermutation)
                  {
                      return std::make_shared<ArrayData<Dim> >(
                          SortUtils::sort(data, nbComponents, sortPermutation), nbComponents);
                  }
              };
              /// Specialization for uni-dimensional ArrayData
              template <>
              struct Sort<1> {
                  static std::shared_ptr<ArrayData<1> > sort(const DataContainer &data, int nbComponents,
                                                             const std::vector<int> &sortPermutation)
                  {
                      Q_UNUSED(nbComponents)
                      return std::make_shared<ArrayData<1> >(SortUtils::sort(data, 1, sortPermutation));
                  }
              };
              template <int Dim, bool IsConst>
              class IteratorValue;
              template <int Dim, bool IsConst>
              struct IteratorValueBuilder {
              };
              template <int Dim>
              struct IteratorValueBuilder<Dim, true> {
                  using DataContainerIterator = DataContainer::const_iterator;
                  static void swap(IteratorValue<Dim, true> &o1, IteratorValue<Dim, true> &o2) {}
              };
              template <int Dim>
              struct IteratorValueBuilder<Dim, false> {
                  using DataContainerIterator = DataContainer::iterator;
                  static void swap(IteratorValue<Dim, false> &o1, IteratorValue<Dim, false> &o2)
                  {
                      for (auto i = 0; i < o1.m_NbComponents; ++i) {
                          std::iter_swap(o1.m_It + i, o2.m_It + i);
                      }
                  }
              };
              template <int Dim, bool IsConst>
              class IteratorValue : public ArrayDataIteratorValue::Impl {
              public:
                  friend class ArrayData<Dim>;
                  friend class IteratorValueBuilder<Dim, IsConst>;
                  using DataContainerIterator =
                      typename IteratorValueBuilder<Dim, IsConst>::DataContainerIterator;
                  template <bool IC = IsConst, typename = std::enable_if_t<IC == true> >
                  explicit IteratorValue(const DataContainer &container, int nbComponents, bool begin)
                          : m_It{begin ? container.cbegin() : container.cend()}, m_NbComponents{nbComponents}
                  {
                  }
                  template <bool IC = IsConst, typename = std::enable_if_t<IC == false> >
                  explicit IteratorValue(DataContainer &container, int nbComponents, bool begin)
                          : m_It{begin ? container.begin() : container.end()}, m_NbComponents{nbComponents}
                  {
                  }
                  IteratorValue(const IteratorValue &other) = default;
                  std::unique_ptr<ArrayDataIteratorValue::Impl> clone() const override
                  {
                      return std::make_unique<IteratorValue<Dim, IsConst> >(*this);
                  }
+                 int distance(const ArrayDataIteratorValue::Impl &other) const override try {
+                     /// @todo ALX : validate
+                     const auto &otherImpl = dynamic_cast<const IteratorValue &>(other);
+                     return std::distance(otherImpl.m_It, m_It) / m_NbComponents;
+                 }
+                 catch (const std::bad_cast &) {
+                     return 0;
+                 }
                  bool equals(const ArrayDataIteratorValue::Impl &other) const override try {
                      const auto &otherImpl = dynamic_cast<const IteratorValue &>(other);
                      return std::tie(m_It, m_NbComponents) == std::tie(otherImpl.m_It, otherImpl.m_NbComponents);
                  }
                  catch (const std::bad_cast &) {
                      return false;
                  }
+                 bool lowerThan(const ArrayDataIteratorValue::Impl &other) const override try {
+                     const auto &otherImpl = dynamic_cast<const IteratorValue &>(other);
+                     return m_It < otherImpl.m_It;
+                 }
+                 catch (const std::bad_cast &) {
+                     return false;
+                 }
+                 std::unique_ptr<ArrayDataIteratorValue::Impl> advance(int offset) const override
+                 {
+                     auto result = clone();
+                     while (offset--) {
+                         result->next();
+                     }
+                     return result;
+                 }
                  void next() override { std::advance(m_It, m_NbComponents); }
                  void prev() override { std::advance(m_It, -m_NbComponents); }
                  double at(int componentIndex) const override { return *(m_It + componentIndex); }
                  double first() const override { return *m_It; }
                  double min() const override
                  {
                      auto values = this->values();
                      auto end = values.cend();
                      auto it = std::min_element(values.cbegin(), end, [](const auto &v1, const auto &v2) {
                          return SortUtils::minCompareWithNaN(v1, v2);
                      });
                      return it != end ? *it : std::numeric_limits<double>::quiet_NaN();
                  }
                  double max() const override
                  {
                      auto values = this->values();
                      auto end = values.cend();
                      auto it = std::max_element(values.cbegin(), end, [](const auto &v1, const auto &v2) {
                          return SortUtils::maxCompareWithNaN(v1, v2);
                      });
                      return it != end ? *it : std::numeric_limits<double>::quiet_NaN();
                  }
                  QVector<double> values() const override
                  {
                      auto result = QVector<double>{};
                      for (auto i = 0; i < m_NbComponents; ++i) {
                          result.push_back(*(m_It + i));
                      }
                      return result;
                  }
                  void swap(ArrayDataIteratorValue::Impl &other) override
                  {
                      auto &otherImpl = dynamic_cast<IteratorValue &>(other);
                      IteratorValueBuilder<Dim, IsConst>::swap(*this, otherImpl);
                  }
              private:
                  DataContainerIterator m_It;
                  int m_NbComponents;
              };
              } // namespace arraydata_detail
              /**
               * @brief The ArrayData class represents a dataset for a data series.
               *
               * A dataset can be unidimensional or two-dimensional. This property is determined by the Dim
               * template-parameter. In a case of a two-dimensional dataset, each dataset component has the same
               * number of values
               *
               * @tparam Dim the dimension of the ArrayData (one or two)
               * @sa IDataSeries
               */
              template <int Dim>
              class ArrayData {
              public:
                  // ///// //
                  // Ctors //
                  // ///// //
                  /**
                   * Ctor for a unidimensional ArrayData
                   * @param data the data the ArrayData will hold
                   */
                  template <int D = Dim, typename = std::enable_if_t<D == 1> >
                  explicit ArrayData(DataContainer data) : m_Data{std::move(data)}, m_NbComponents{1}
                  {
                  }
                  /**
                   * Ctor for a two-dimensional ArrayData. The number of components (number of lines) must be
                   * greater than 2 and must be a divisor of the total number of data in the vector
                   * @param data the data the ArrayData will hold
                   * @param nbComponents the number of components
                   * @throws std::invalid_argument if the number of components is less than 2 or is not a divisor
                   * of the size of the data
                   */
                  template <int D = Dim, typename = std::enable_if_t<D == 2> >
                  explicit ArrayData(DataContainer data, int nbComponents)
                          : m_Data{std::move(data)}, m_NbComponents{nbComponents}
                  {
                      if (nbComponents < 2) {
                          throw std::invalid_argument{
                              QString{"A multidimensional ArrayData must have at least 2 components (found: %1)"}
                                  .arg(nbComponents)
                                  .toStdString()};
                      }
                      if (m_Data.size() % m_NbComponents != 0) {
                          throw std::invalid_argument{QString{
                              "The number of components (%1) is inconsistent with the total number of data (%2)"}
                                                          .arg(m_Data.size(), nbComponents)
                                                          .toStdString()};
                      }
                  }
                  /// Copy ctor
                  explicit ArrayData(const ArrayData &other)
                  {
                      QReadLocker otherLocker{&other.m_Lock};
                      m_Data = other.m_Data;
                      m_NbComponents = other.m_NbComponents;
                  }
                  // /////////////// //
                  // General methods //
                  // /////////////// //
                  /**
                   * Merges into the array data an other array data. The two array datas must have the same number
                   * of components so the merge can be done
                   * @param other the array data to merge with
                   * @param prepend if true, the other array data is inserted at the beginning, otherwise it is
                   * inserted at the end
                   */
                  void add(const ArrayData<Dim> &other, bool prepend = false)
                  {
                      QWriteLocker locker{&m_Lock};
                      QReadLocker otherLocker{&other.m_Lock};
                      if (m_NbComponents != other.componentCount()) {
                          return;
                      }
                      if (prepend) {
                          auto otherDataSize = other.m_Data.size();
                          m_Data.insert(m_Data.begin(), otherDataSize, 0.);
                          for (auto i = 0; i < otherDataSize; ++i) {
                              m_Data.replace(i, other.m_Data.at(i));
                          }
                      }
                      else {
                          m_Data.append(other.m_Data);
                      }
                  }
                  void clear()
                  {
                      QWriteLocker locker{&m_Lock};
                      m_Data.clear();
                  }
                  int componentCount() const noexcept { return m_NbComponents; }
                  /// @return the size (i.e. number of values) of a single component
                  /// @remarks in a case of a two-dimensional ArrayData, each component has the same size
                  int size() const
                  {
                      QReadLocker locker{&m_Lock};
                      return m_Data.size() / m_NbComponents;
                  }
                  std::shared_ptr<ArrayData<Dim> > sort(const std::vector<int> &sortPermutation)
                  {
                      QReadLocker locker{&m_Lock};
                      return arraydata_detail::Sort<Dim>::sort(m_Data, m_NbComponents, sortPermutation);
                  }
                  // ///////// //
                  // Iterators //
                  // ///////// //
                  ArrayDataIterator begin()
                  {
                      return ArrayDataIterator{
                          ArrayDataIteratorValue{std::make_unique<arraydata_detail::IteratorValue<Dim, false> >(
                              m_Data, m_NbComponents, true)}};
                  }
                  ArrayDataIterator end()
                  {
                      return ArrayDataIterator{
                          ArrayDataIteratorValue{std::make_unique<arraydata_detail::IteratorValue<Dim, false> >(
                              m_Data, m_NbComponents, false)}};
                  }
                  ArrayDataIterator cbegin() const
                  {
                      return ArrayDataIterator{
                          ArrayDataIteratorValue{std::make_unique<arraydata_detail::IteratorValue<Dim, true> >(
                              m_Data, m_NbComponents, true)}};
                  }
                  ArrayDataIterator cend() const
                  {
                      return ArrayDataIterator{
                          ArrayDataIteratorValue{std::make_unique<arraydata_detail::IteratorValue<Dim, true> >(
                              m_Data, m_NbComponents, false)}};
                  }
                  void erase(ArrayDataIterator first, ArrayDataIterator last)
                  {
                      auto firstImpl = dynamic_cast<arraydata_detail::IteratorValue<Dim, false> *>(first->impl());
                      auto lastImpl = dynamic_cast<arraydata_detail::IteratorValue<Dim, false> *>(last->impl());
                      if (firstImpl && lastImpl) {
                          m_Data.erase(firstImpl->m_It, lastImpl->m_It);
                      }
                  }
                  /// Inserts at the end of the array data the values passed as a parameter. This
                  /// method is intended to be used in the context of generating a back insert iterator, or only
                  /// if it's ensured that the total size of the vector is consistent with the number of
                  /// components of the array data
                  /// @param values the values to insert
                  /// @sa http://en.cppreference.com/w/cpp/iterator/back_inserter
                  void push_back(const QVector<double> &values)
                  {
                      Q_ASSERT(values.size() % m_NbComponents == 0);
                      m_Data.append(values);
                  }
                  /**
                   * @return the data at a specified index
                   * @remarks index must be a valid position
                   */
                  double at(int index) const noexcept
                  {
                      QReadLocker locker{&m_Lock};
                      return m_Data.at(index);
                  }
                  // ///////////// //
                  // 1-dim methods //
                  // ///////////// //
                  /**
                   * @return the data as a vector, as a const reference
                   * @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
                  {
                      QReadLocker locker{&m_Lock};
                      return m_Data;
                  }
              private:
                  DataContainer m_Data;
                  /// Number of components (lines). Is always 1 in a 1-dim ArrayData
                  int m_NbComponents;
                  mutable QReadWriteLock m_Lock;
              };
              #endif // SCIQLOP_ARRAYDATA_H

core/include/Data/ArrayDataIterator.h +6 0

              #ifndef SCIQLOP_ARRAYDATAITERATOR_H
              #define SCIQLOP_ARRAYDATAITERATOR_H
              #include "CoreGlobal.h"
              #include "Data/SqpIterator.h"
              #include <QVector>
              #include <memory>
              /**
               * @brief The ArrayDataIteratorValue class represents the current value of an array data iterator.
               * It offers standard access methods for the data in the series (at(), first()), but it is up to
               * each array data to define its own implementation of how to retrieve this data (one-dim or two-dim
               * array), by implementing the ArrayDataIteratorValue::Impl interface
               * @sa ArrayDataIterator
               */
              class SCIQLOP_CORE_EXPORT ArrayDataIteratorValue {
              public:
                  struct Impl {
                      virtual ~Impl() noexcept = default;
                      virtual std::unique_ptr<Impl> clone() const = 0;
+                     virtual int distance(const Impl &other) const = 0;
                      virtual bool equals(const Impl &other) const = 0;
+                     virtual bool lowerThan(const Impl &other) const = 0;
+                     virtual std::unique_ptr<Impl> advance(int offset) const = 0;
                      virtual void next() = 0;
                      virtual void prev() = 0;
                      virtual double at(int componentIndex) const = 0;
                      virtual double first() const = 0;
                      virtual double min() const = 0;
                      virtual double max() const = 0;
                      virtual QVector<double> values() const = 0;
                      virtual void swap(Impl &other) = 0;
                  };
                  explicit ArrayDataIteratorValue(std::unique_ptr<Impl> impl);
                  ArrayDataIteratorValue(const ArrayDataIteratorValue &other);
                  ArrayDataIteratorValue &operator=(ArrayDataIteratorValue other);
+                 int distance(const ArrayDataIteratorValue &other) const;
                  bool equals(const ArrayDataIteratorValue &other) const;
+                 bool lowerThan(const ArrayDataIteratorValue &other) const;
+                 ArrayDataIteratorValue advance(int offset) const;
                  /// Advances to the next value
                  void next();
                  /// Moves back to the previous value
                  void prev();
                  /// Gets value of a specified component
                  double at(int componentIndex) const;
                  /// Gets value of first component
                  double first() const;
                  /// Gets min value among all components
                  double min() const;
                  /// Gets max value among all components
                  double max() const;
                  /// Gets all values
                  QVector<double> values() const;
                  Impl *impl();
                  friend void swap(ArrayDataIteratorValue &lhs, ArrayDataIteratorValue &rhs)
                  {
                      std::swap(lhs.m_Impl, rhs.m_Impl);
                  }
              private:
                  std::unique_ptr<Impl> m_Impl;
              };
              using ArrayDataIterator = SqpIterator<ArrayDataIteratorValue>;
              #endif // SCIQLOP_ARRAYDATAITERATOR_H

core/include/Data/DataSeries.h +42 -6

              #ifndef SCIQLOP_DATASERIES_H
              #define SCIQLOP_DATASERIES_H
              #include "CoreGlobal.h"
              #include <Common/SortUtils.h>
              #include <Data/ArrayData.h>
              #include <Data/DataSeriesMergeHelper.h>
              #include <Data/IDataSeries.h>
              #include <QLoggingCategory>
              #include <QReadLocker>
              #include <QReadWriteLock>
              #include <memory>
              // We don't use the Qt macro since the log is used in the header file, which causes multiple log
              // definitions with inheritance. Inline method is used instead
              inline const QLoggingCategory &LOG_DataSeries()
              {
                  static const QLoggingCategory category{"DataSeries"};
                  return category;
              }
              template <int Dim>
              class DataSeries;
              namespace dataseries_detail {
              template <int Dim, bool IsConst>
              class IteratorValue : public DataSeriesIteratorValue::Impl {
              public:
                  friend class DataSeries<Dim>;
                  template <bool IC = IsConst, typename = std::enable_if_t<IC == false> >
                  explicit IteratorValue(DataSeries<Dim> &dataSeries, bool begin)
                          : m_XIt(begin ? dataSeries.xAxisData()->begin() : dataSeries.xAxisData()->end()),
                            m_ValuesIt(begin ? dataSeries.valuesData()->begin() : dataSeries.valuesData()->end())
                  {
                  }
                  template <bool IC = IsConst, typename = std::enable_if_t<IC == true> >
                  explicit IteratorValue(const DataSeries<Dim> &dataSeries, bool begin)
                          : m_XIt(begin ? dataSeries.xAxisData()->cbegin() : dataSeries.xAxisData()->cend()),
                            m_ValuesIt(begin ? dataSeries.valuesData()->cbegin()
                                             : dataSeries.valuesData()->cend())
                  {
                  }
                  IteratorValue(const IteratorValue &other) = default;
                  std::unique_ptr<DataSeriesIteratorValue::Impl> clone() const override
                  {
                      return std::make_unique<IteratorValue<Dim, IsConst> >(*this);
                  }
+                 int distance(const DataSeriesIteratorValue::Impl &other) const override try {
+                     const auto &otherImpl = dynamic_cast<const IteratorValue &>(other);
+                     return m_XIt->distance(*otherImpl.m_XIt);
+                 }
+                 catch (const std::bad_cast &) {
+                     return 0;
+                 }
                  bool equals(const DataSeriesIteratorValue::Impl &other) const override try {
                      const auto &otherImpl = dynamic_cast<const IteratorValue &>(other);
                      return std::tie(m_XIt, m_ValuesIt) == std::tie(otherImpl.m_XIt, otherImpl.m_ValuesIt);
                  }
                  catch (const std::bad_cast &) {
                      return false;
                  }
+                 bool lowerThan(const DataSeriesIteratorValue::Impl &other) const override try {
+                     const auto &otherImpl = dynamic_cast<const IteratorValue &>(other);
+                     return m_XIt->lowerThan(*otherImpl.m_XIt);
+                 }
+                 catch (const std::bad_cast &) {
+                     return false;
+                 }
+                 std::unique_ptr<DataSeriesIteratorValue::Impl> advance(int offset) const override
+                 {
+                     auto result = clone();
+                     while (offset--) {
+                         result->next();
+                     }
+                     return result;
+                 }
                  void next() override
                  {
                      ++m_XIt;
                      ++m_ValuesIt;
                  }
                  void prev() override
                  {
                      --m_XIt;
                      --m_ValuesIt;
                  }
                  double x() const override { return m_XIt->at(0); }
                  double value() const override { return m_ValuesIt->at(0); }
                  double value(int componentIndex) const override { return m_ValuesIt->at(componentIndex); }
                  double minValue() const override { return m_ValuesIt->min(); }
                  double maxValue() const override { return m_ValuesIt->max(); }
                  QVector<double> values() const override { return m_ValuesIt->values(); }
                  void swap(DataSeriesIteratorValue::Impl &other) override
                  {
                      auto &otherImpl = dynamic_cast<IteratorValue &>(other);
                      m_XIt->impl()->swap(*otherImpl.m_XIt->impl());
                      m_ValuesIt->impl()->swap(*otherImpl.m_ValuesIt->impl());
                  }
              private:
                  ArrayDataIterator m_XIt;
                  ArrayDataIterator m_ValuesIt;
              };
              } // namespace dataseries_detail
              /**
               * @brief The DataSeries class is the base (abstract) implementation of IDataSeries.
               *
               * It proposes to set a dimension for the values data.
               *
               * A DataSeries is always sorted on its x-axis data.
               *
               * @tparam Dim The dimension of the values data
               *
               */
              template <int Dim>
              class SCIQLOP_CORE_EXPORT DataSeries : public IDataSeries {
                  friend class DataSeriesMergeHelper;
              public:
                  /// Tag needed to define the push_back() method
                  /// @sa push_back()
                  using value_type = DataSeriesIteratorValue;
                  /// @sa IDataSeries::xAxisData()
                  std::shared_ptr<ArrayData<1> > xAxisData() override { return m_XAxisData; }
                  const std::shared_ptr<ArrayData<1> > xAxisData() const { return m_XAxisData; }
                  /// @sa IDataSeries::xAxisUnit()
                  Unit xAxisUnit() const override { return m_XAxisUnit; }
                  /// @return the values dataset
                  std::shared_ptr<ArrayData<Dim> > valuesData() { return m_ValuesData; }
                  const std::shared_ptr<ArrayData<Dim> > valuesData() const { return m_ValuesData; }
                  /// @sa IDataSeries::valuesUnit()
                  Unit valuesUnit() const override { return m_ValuesUnit; }
                  SqpRange range() const override
                  {
                      if (!m_XAxisData->cdata().isEmpty()) {
                          return SqpRange{m_XAxisData->cdata().first(), m_XAxisData->cdata().last()};
                      }
                      return SqpRange{};
                  }
                  void clear()
                  {
                      m_XAxisData->clear();
                      m_ValuesData->clear();
                  }
                  bool isEmpty() const noexcept { return m_XAxisData->size() == 0; }
                  /// Merges into the data series an other data series
                  /// @remarks the data series to merge with is cleared after the operation
                  void merge(IDataSeries *dataSeries) override
                  {
                      dataSeries->lockWrite();
                      lockWrite();
                      if (auto other = dynamic_cast<DataSeries<Dim> *>(dataSeries)) {
                          DataSeriesMergeHelper::merge(*other, *this);
                      }
                      else {
                          qCWarning(LOG_DataSeries())
                              << QObject::tr("Detection of a type of IDataSeries we cannot merge with !");
                      }
                      unlock();
                      dataSeries->unlock();
                  }
                  void purge(double min, double max) override
                  {
+                     // Nothing to purge if series is empty
+                     if (isEmpty()) {
+                         return;
+                     }
                      if (min > max) {
                          std::swap(min, max);
                      }
-                     lockWrite();
-                     auto it = std::remove_if(
-                         begin(), end(), [min, max](const auto &it) { return it.x() < min || it.x() > max; });
-                     erase(it, end());
+                     // Nothing to purge if series min/max are inside purge range
+                     auto xMin = cbegin()->x();
+                     auto xMax = (--cend())->x();
+                     if (xMin >= min && xMax <= max) {
+                         return;
+                     }
-                     unlock();
+                     auto lowerIt = std::lower_bound(
+                         begin(), end(), min, [](const auto &it, const auto &val) { return it.x() < val; });
+                     erase(begin(), lowerIt);
+                     auto upperIt = std::upper_bound(
+                         begin(), end(), max, [](const auto &val, const auto &it) { return val < it.x(); });
+                     erase(upperIt, end());
                  }
                  // ///////// //
                  // Iterators //
                  // ///////// //
                  DataSeriesIterator begin() override
                  {
                      return DataSeriesIterator{DataSeriesIteratorValue{
                          std::make_unique<dataseries_detail::IteratorValue<Dim, false> >(*this, true)}};
                  }
                  DataSeriesIterator end() override
                  {
                      return DataSeriesIterator{DataSeriesIteratorValue{
                          std::make_unique<dataseries_detail::IteratorValue<Dim, false> >(*this, false)}};
                  }
                  DataSeriesIterator cbegin() const override
                  {
                      return DataSeriesIterator{DataSeriesIteratorValue{
                          std::make_unique<dataseries_detail::IteratorValue<Dim, true> >(*this, true)}};
                  }
                  DataSeriesIterator cend() const override
                  {
                      return DataSeriesIterator{DataSeriesIteratorValue{
                          std::make_unique<dataseries_detail::IteratorValue<Dim, true> >(*this, false)}};
                  }
                  void erase(DataSeriesIterator first, DataSeriesIterator last)
                  {
                      auto firstImpl
                          = dynamic_cast<dataseries_detail::IteratorValue<Dim, false> *>(first->impl());
                      auto lastImpl = dynamic_cast<dataseries_detail::IteratorValue<Dim, false> *>(last->impl());
                      if (firstImpl && lastImpl) {
                          m_XAxisData->erase(firstImpl->m_XIt, lastImpl->m_XIt);
                          m_ValuesData->erase(firstImpl->m_ValuesIt, lastImpl->m_ValuesIt);
                      }
                  }
                  /// @sa IDataSeries::minXAxisData()
                  DataSeriesIterator minXAxisData(double minXAxisData) const override
                  {
                      return std::lower_bound(
                          cbegin(), cend(), minXAxisData,
                          [](const auto &itValue, const auto &value) { return itValue.x() < value; });
                  }
                  /// @sa IDataSeries::maxXAxisData()
                  DataSeriesIterator maxXAxisData(double maxXAxisData) const override
                  {
                      // Gets the first element that greater than max value
                      auto it = std::upper_bound(
                          cbegin(), cend(), maxXAxisData,
                          [](const auto &value, const auto &itValue) { return value < itValue.x(); });
                      return it == cbegin() ? cend() : --it;
                  }
                  std::pair<DataSeriesIterator, DataSeriesIterator> xAxisRange(double minXAxisData,
                                                                               double maxXAxisData) const override
                  {
                      if (minXAxisData > maxXAxisData) {
                          std::swap(minXAxisData, maxXAxisData);
                      }
                      auto begin = cbegin();
                      auto end = cend();
                      auto lowerIt = std::lower_bound(
                          begin, end, minXAxisData,
                          [](const auto &itValue, const auto &value) { return itValue.x() < value; });
                      auto upperIt = std::upper_bound(
                          begin, end, maxXAxisData,
                          [](const auto &value, const auto &itValue) { return value < itValue.x(); });
                      return std::make_pair(lowerIt, upperIt);
                  }
                  std::pair<DataSeriesIterator, DataSeriesIterator>
                  valuesBounds(double minXAxisData, double maxXAxisData) const override
                  {
                      // Places iterators to the correct x-axis range
                      auto xAxisRangeIts = xAxisRange(minXAxisData, maxXAxisData);
                      // Returns end iterators if the range is empty
                      if (xAxisRangeIts.first == xAxisRangeIts.second) {
                          return std::make_pair(cend(), cend());
                      }
                      // Gets the iterator on the min of all values data
                      auto minIt = std::min_element(
                          xAxisRangeIts.first, xAxisRangeIts.second, [](const auto &it1, const auto &it2) {
                              return SortUtils::minCompareWithNaN(it1.minValue(), it2.minValue());
                          });
                      // Gets the iterator on the max of all values data
                      auto maxIt = std::max_element(
                          xAxisRangeIts.first, xAxisRangeIts.second, [](const auto &it1, const auto &it2) {
                              return SortUtils::maxCompareWithNaN(it1.maxValue(), it2.maxValue());
                          });
                      return std::make_pair(minIt, maxIt);
                  }
                  // /////// //
                  // Mutexes //
                  // /////// //
                  virtual void lockRead() { m_Lock.lockForRead(); }
                  virtual void lockWrite() { m_Lock.lockForWrite(); }
                  virtual void unlock() { m_Lock.unlock(); }
                  // ///// //
                  // Other //
                  // ///// //
                  /// Inserts at the end of the data series the value of the iterator passed as a parameter. This
                  /// method is intended to be used in the context of generating a back insert iterator
                  /// @param iteratorValue the iterator value containing the values to insert
                  /// @sa http://en.cppreference.com/w/cpp/iterator/back_inserter
                  /// @sa merge()
                  /// @sa value_type
                  void push_back(const value_type &iteratorValue)
                  {
                      m_XAxisData->push_back(QVector<double>{iteratorValue.x()});
                      m_ValuesData->push_back(iteratorValue.values());
                  }
              protected:
                  /// Protected ctor (DataSeries is abstract). The vectors must have the same size, otherwise a
                  /// DataSeries with no values will be created.
                  /// @remarks data series is automatically sorted on its x-axis data
                  explicit DataSeries(std::shared_ptr<ArrayData<1> > xAxisData, const Unit &xAxisUnit,
                                      std::shared_ptr<ArrayData<Dim> > valuesData, const Unit &valuesUnit)
                          : m_XAxisData{xAxisData},
                            m_XAxisUnit{xAxisUnit},
                            m_ValuesData{valuesData},
                            m_ValuesUnit{valuesUnit}
                  {
                      if (m_XAxisData->size() != m_ValuesData->size()) {
                          clear();
                      }
                      // Sorts data if it's not the case
                      const auto &xAxisCData = m_XAxisData->cdata();
                      if (!std::is_sorted(xAxisCData.cbegin(), xAxisCData.cend())) {
                          sort();
                      }
                  }
                  /// Copy ctor
                  explicit DataSeries(const DataSeries<Dim> &other)
                          : m_XAxisData{std::make_shared<ArrayData<1> >(*other.m_XAxisData)},
                            m_XAxisUnit{other.m_XAxisUnit},
                            m_ValuesData{std::make_shared<ArrayData<Dim> >(*other.m_ValuesData)},
                            m_ValuesUnit{other.m_ValuesUnit}
                  {
                      // Since a series is ordered from its construction and is always ordered, it is not
                      // necessary to call the sort method here ('other' is sorted)
                  }
                  /// Assignment operator
                  template <int D>
                  DataSeries &operator=(DataSeries<D> other)
                  {
                      std::swap(m_XAxisData, other.m_XAxisData);
                      std::swap(m_XAxisUnit, other.m_XAxisUnit);
                      std::swap(m_ValuesData, other.m_ValuesData);
                      std::swap(m_ValuesUnit, other.m_ValuesUnit);
                      return *this;
                  }
              private:
                  /**
                   * Sorts data series on its x-axis data
                   */
                  void sort() noexcept
                  {
                      auto permutation = SortUtils::sortPermutation(*m_XAxisData, std::less<double>());
                      m_XAxisData = m_XAxisData->sort(permutation);
                      m_ValuesData = m_ValuesData->sort(permutation);
                  }
                  std::shared_ptr<ArrayData<1> > m_XAxisData;
                  Unit m_XAxisUnit;
                  std::shared_ptr<ArrayData<Dim> > m_ValuesData;
                  Unit m_ValuesUnit;
                  QReadWriteLock m_Lock;
              };
              #endif // SCIQLOP_DATASERIES_H

core/include/Data/DataSeriesIterator.h +6 0

              #ifndef SCIQLOP_DATASERIESITERATOR_H
              #define SCIQLOP_DATASERIESITERATOR_H
              #include "CoreGlobal.h"
              #include "Data/SqpIterator.h"
              #include <QVector>
              #include <memory>
              /**
               * @brief The DataSeriesIteratorValue class represents the current value of a data series iterator.
               * It offers standard access methods for the data in the series (x-axis, values), but it is up to
               * each series to define its own implementation of how to retrieve this data, by implementing the
               * DataSeriesIteratorValue::Impl interface
               *
               * @sa DataSeriesIterator
               */
              class SCIQLOP_CORE_EXPORT DataSeriesIteratorValue {
              public:
                  struct Impl {
                      virtual ~Impl() noexcept = default;
                      virtual std::unique_ptr<Impl> clone() const = 0;
+                     virtual int distance(const Impl &other) const = 0;
                      virtual bool equals(const Impl &other) const = 0;
+                     virtual bool lowerThan(const Impl &other) const = 0;
+                     virtual std::unique_ptr<Impl> advance(int offset) const = 0;
                      virtual void next() = 0;
                      virtual void prev() = 0;
                      virtual double x() const = 0;
                      virtual double value() const = 0;
                      virtual double value(int componentIndex) const = 0;
                      virtual double minValue() const = 0;
                      virtual double maxValue() const = 0;
                      virtual QVector<double> values() const = 0;
                      virtual void swap(Impl &other) = 0;
                  };
                  explicit DataSeriesIteratorValue(std::unique_ptr<Impl> impl);
                  DataSeriesIteratorValue(const DataSeriesIteratorValue &other);
                  DataSeriesIteratorValue &operator=(DataSeriesIteratorValue other);
+                 int distance(const DataSeriesIteratorValue &other) const;
                  bool equals(const DataSeriesIteratorValue &other) const;
+                 bool lowerThan(const DataSeriesIteratorValue &other) const;
+                 DataSeriesIteratorValue advance(int offset) const;
                  /// Advances to the next value
                  void next();
                  /// Moves back to the previous value
                  void prev();
                  /// Gets x-axis data
                  double x() const;
                  /// Gets value data
                  double value() const;
                  /// Gets value data depending on an index
                  double value(int componentIndex) const;
                  /// Gets min of all values data
                  double minValue() const;
                  /// Gets max of all values data
                  double maxValue() const;
                  /// Gets all values data
                  QVector<double> values() const;
                  Impl *impl();
                  friend void swap(DataSeriesIteratorValue &lhs, DataSeriesIteratorValue &rhs)
                  {
                      std::swap(lhs.m_Impl, rhs.m_Impl);
                  }
              private:
                  std::unique_ptr<Impl> m_Impl;
              };
              using DataSeriesIterator = SqpIterator<DataSeriesIteratorValue>;
              #endif // SCIQLOP_DATASERIESITERATOR_H

core/include/Data/SqpIterator.h +57 -1

              #ifndef SCIQLOP_SQPITERATOR_H
              #define SCIQLOP_SQPITERATOR_H
              #include "CoreGlobal.h"
              /**
               * @brief The SqpIterator class represents an iterator used in SciQlop. It defines all operators
               * needed for a standard forward iterator
               * @tparam T the type of object handled in iterator
               * @sa http://www.cplusplus.com/reference/iterator/
               */
              template <typename T>
              class SCIQLOP_CORE_EXPORT SqpIterator {
              public:
-                 using iterator_category = std::forward_iterator_tag;
+                 using iterator_category = std::random_access_iterator_tag;
                  using value_type = const T;
                  using difference_type = std::ptrdiff_t;
                  using pointer = value_type *;
                  using reference = value_type &;
                  explicit SqpIterator(T value) : m_CurrentValue{std::move(value)} {}
                  virtual ~SqpIterator() noexcept = default;
                  SqpIterator(const SqpIterator &) = default;
                  SqpIterator &operator=(SqpIterator other) { swap(m_CurrentValue, other.m_CurrentValue); }
                  SqpIterator &operator++()
                  {
                      m_CurrentValue.next();
                      return *this;
                  }
                  SqpIterator &operator--()
                  {
                      m_CurrentValue.prev();
                      return *this;
                  }
+                 SqpIterator operator++(int)const
+                 {
+                     auto result = *this;
+                     this->operator++();
+                     return result;
+                 }
+                 SqpIterator operator--(int)const
+                 {
+                     auto result = *this;
+                     this->operator--();
+                     return result;
+                 }
+                 SqpIterator &operator+=(int offset)
+                 {
+                     if (offset >= 0) {
+                         while (offset--) {
+                             m_CurrentValue.next();
+                         }
+                     }
+                     else {
+                         while (offset++) {
+                             m_CurrentValue.prev();
+                         }
+                     }
+                     return *this;
+                 }
+                 SqpIterator &operator-=(int offset) { return *this += -offset; }
+                 SqpIterator operator+(int offset) const
+                 {
+                     auto result = *this;
+                     result += offset;
+                     return result;
+                 }
+                 SqpIterator operator-(int offset) const
+                 {
+                     auto result = *this;
+                     result -= offset;
+                     return result;
+                 }
+                 int operator-(const SqpIterator &other) const
+                 {
+                     return m_CurrentValue.distance(other.m_CurrentValue);
+                 }
                  const T *operator->() const { return &m_CurrentValue; }
                  const T &operator*() const { return m_CurrentValue; }
                  T *operator->() { return &m_CurrentValue; }
                  T &operator*() { return m_CurrentValue; }
+                 T &operator[](int offset) const { return m_CurrentValue.advance(offset); }
                  bool operator==(const SqpIterator &other) const
                  {
                      return m_CurrentValue.equals(other.m_CurrentValue);
                  }
                  bool operator!=(const SqpIterator &other) const { return !(*this == other); }
+                 bool operator>(const SqpIterator &other) const { return other.m_CurrentValue.lowerThan(*this); }
+                 bool operator<(const SqpIterator &other) const
+                 {
+                     return m_CurrentValue.lowerThan(other.m_CurrentValue);
+                 }
+                 bool operator>=(const SqpIterator &other) const { return !(*this < other); }
+                 bool operator<=(const SqpIterator &other) const { return !(*this > other); }
              private:
                  T m_CurrentValue;
              };
              #endif // SCIQLOP_SQPITERATOR_H

core/src/Data/ArrayDataIterator.cpp +15 0

              #include "Data/ArrayDataIterator.h"
              ArrayDataIteratorValue::ArrayDataIteratorValue(std::unique_ptr<ArrayDataIteratorValue::Impl> impl)
                      : m_Impl{std::move(impl)}
              {
              }
              ArrayDataIteratorValue::ArrayDataIteratorValue(const ArrayDataIteratorValue &other)
                      : m_Impl{other.m_Impl->clone()}
              {
              }
              ArrayDataIteratorValue &ArrayDataIteratorValue::operator=(ArrayDataIteratorValue other)
              {
                  m_Impl->swap(*other.m_Impl);
                  return *this;
              }
+             int ArrayDataIteratorValue::distance(const ArrayDataIteratorValue &other) const
+             {
+                 return m_Impl->distance(*other.m_Impl);
+             }
              bool ArrayDataIteratorValue::equals(const ArrayDataIteratorValue &other) const
              {
                  return m_Impl->equals(*other.m_Impl);
              }
+             bool ArrayDataIteratorValue::lowerThan(const ArrayDataIteratorValue &other) const
+             {
+                 return m_Impl->lowerThan(*other.m_Impl);
+             }
+             ArrayDataIteratorValue ArrayDataIteratorValue::advance(int offset) const
+             {
+                 return ArrayDataIteratorValue{m_Impl->advance(offset)};
+             }
              void ArrayDataIteratorValue::next()
              {
                  m_Impl->next();
              }
              void ArrayDataIteratorValue::prev()
              {
                  m_Impl->prev();
              }
              double ArrayDataIteratorValue::at(int componentIndex) const
              {
                  return m_Impl->at(componentIndex);
              }
              double ArrayDataIteratorValue::first() const
              {
                  return m_Impl->first();
              }
              double ArrayDataIteratorValue::min() const
              {
                  return m_Impl->min();
              }
              double ArrayDataIteratorValue::max() const
              {
                  return m_Impl->max();
              }
              QVector<double> ArrayDataIteratorValue::values() const
              {
                  return m_Impl->values();
              }
              ArrayDataIteratorValue::Impl *ArrayDataIteratorValue::impl()
              {
                  return m_Impl.get();
              }

core/src/Data/DataSeriesIterator.cpp +16 0

              #include "Data/DataSeriesIterator.h"
              DataSeriesIteratorValue::DataSeriesIteratorValue(
                  std::unique_ptr<DataSeriesIteratorValue::Impl> impl)
                      : m_Impl{std::move(impl)}
              {
              }
              DataSeriesIteratorValue::DataSeriesIteratorValue(const DataSeriesIteratorValue &other)
                      : m_Impl{other.m_Impl->clone()}
              {
              }
              DataSeriesIteratorValue &DataSeriesIteratorValue::operator=(DataSeriesIteratorValue other)
              {
                  m_Impl->swap(*other.m_Impl);
                  return *this;
              }
+             int DataSeriesIteratorValue::distance(const DataSeriesIteratorValue &other) const
+             {
+                 auto dist = m_Impl->distance(*other.m_Impl);
+                 return m_Impl->distance(*other.m_Impl);
+             }
              bool DataSeriesIteratorValue::equals(const DataSeriesIteratorValue &other) const
              {
                  return m_Impl->equals(*other.m_Impl);
              }
+             bool DataSeriesIteratorValue::lowerThan(const DataSeriesIteratorValue &other) const
+             {
+                 return m_Impl->lowerThan(*other.m_Impl);
+             }
+             DataSeriesIteratorValue DataSeriesIteratorValue::advance(int offset) const
+             {
+                 return DataSeriesIteratorValue{m_Impl->advance(offset)};
+             }
              void DataSeriesIteratorValue::next()
              {
                  m_Impl->next();
              }
              void DataSeriesIteratorValue::prev()
              {
                  m_Impl->prev();
              }
              double DataSeriesIteratorValue::x() const
              {
                  return m_Impl->x();
              }
              double DataSeriesIteratorValue::value() const
              {
                  return m_Impl->value();
              }
              double DataSeriesIteratorValue::value(int componentIndex) const
              {
                  return m_Impl->value(componentIndex);
              }
              double DataSeriesIteratorValue::minValue() const
              {
                  return m_Impl->minValue();
              }
              double DataSeriesIteratorValue::maxValue() const
              {
                  return m_Impl->maxValue();
              }
              QVector<double> DataSeriesIteratorValue::values() const
              {
                  return m_Impl->values();
              }
              DataSeriesIteratorValue::Impl *DataSeriesIteratorValue::impl()
              {
                  return m_Impl.get();
              }

core/vera-exclusions/exclusions.txt +2 -2

              # On ignore toutes les règles vera++ pour le fichier spimpl
              Common/spimpl\.h:\d+:.*
              # Ignore false positive relative to two class definitions in a same file
              ArrayData\.h:\d+:.*IPSIS_S01.*
              ArrayDataIterator\.h:\d+:.*IPSIS_S01.*
              DataSourceItem\.h:\d+:.*IPSIS_S01.*
              DataSeries\.h:\d+:.*IPSIS_S01.*
              DataSeriesIterator\.h:\d+:.*IPSIS_S01.*
              DataSeriesMergeHelper\.h:\d+:.*IPSIS_S01.*
              # Ignore false positive relative to a template class
              ArrayData\.h:\d+:.*IPSIS_S04_METHOD.*found: push_back
              ArrayData\.h:\d+:.*IPSIS_S04_VARIABLE.*found: (const_iterator)
              ArrayData\.h:\d+:.*IPSIS_S04_VARIABLE.*found: (D)
              ArrayData\.h:\d+:.*IPSIS_S04_VARIABLE.*found: (IC)
              ArrayData\.h:\d+:.*IPSIS_S04_NAMESPACE.*found: (arraydata_detail)
              ArrayData\.h:\d+:.*IPSIS_S06.*found: (D)
              ArrayData\.h:\d+:.*IPSIS_S06.*found: (Dim)
              ArrayData\.h:\d+:.*IPSIS_S06.*found: (IC)
              ArrayData\.h:\d+:.*IPSIS_S06.*found: (IsConst)
              DataSeries\.h:\d+:.*IPSIS_S04_METHOD.*found: LOG_DataSeries
              DataSeries\.h:\d+:.*IPSIS_S04_METHOD.*found: push_back
              DataSeries\.h:\d+:.*IPSIS_S04_VARIABLE.*
              DataSeries\.h:\d+:.*IPSIS_S04_NAMESPACE.*found: (dataseries_detail)
              DataSeries\.h:\d+:.*IPSIS_S05.*
              DataSeries\.h:\d+:.*IPSIS_S06.*found: (value_type)
              DataSeries\.h:\d+:.*IPSIS_S06.*found: (DataSeriesIteratorValue)
              DataSeries\.h:\d+:.*IPSIS_S06.*found: (Dim)
              DataSeries\.h:\d+:.*IPSIS_S06.*found: (IC)
              DataSeries\.h:\d+:.*IPSIS_S06.*found: (IsConst)
              # Ignore false positive relative to iterators
-             SqpIterator\.h:\d+:.*IPSIS_S04_VARIABLE.*found: (forward_iterator_tag)
+             SqpIterator\.h:\d+:.*IPSIS_S04_VARIABLE.*found: (random_access_iterator_tag)
              SqpIterator\.h:\d+:.*IPSIS_S04_VARIABLE.*found: (T)
              SqpIterator\.h:\d+:.*IPSIS_S04_VARIABLE.*found: (ptrdiff_t)
              SqpIterator\.h:\d+:.*IPSIS_S04_VARIABLE.*found: (value_type)
              SqpIterator\.h:\d+:.*IPSIS_S06.*found: (iterator_category)
-             SqpIterator\.h:\d+:.*IPSIS_S06.*found: (forward_iterator_tag)
+             SqpIterator\.h:\d+:.*IPSIS_S06.*found: (random_access_iterator_tag)
              SqpIterator\.h:\d+:.*IPSIS_S06.*found: (value_type)
              SqpIterator\.h:\d+:.*IPSIS_S06.*found: (T)
              SqpIterator\.h:\d+:.*IPSIS_S06.*found: (difference_type)
              SqpIterator\.h:\d+:.*IPSIS_S06.*found: (ptrdiff_t)
              SqpIterator\.h:\d+:.*IPSIS_S06.*found: (pointer)
              SqpIterator\.h:\d+:.*IPSIS_S06.*found: (reference)
              SqpIterator\.h:\d+:.*IPSIS_S06.*found: (value_type)
              # Ignore false positive relative to an alias
              DataSourceItemAction\.h:\d+:.*IPSIS_S06.*found: (ExecuteFunction)
              # Ignore false positive relative to unnamed namespace
              VariableController\.cpp:\d+:.*IPSIS_F13.*

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