GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r692:6c665d58d405

Merge branch 'feature/ImprovePerfs2' into develop

Alexandre Leroux -

r692:6c665d58d405

parent child

Context file:

r692:6c665d58d405

Collapse all files

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

                      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);
                      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); }

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

                  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;
                  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

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

                      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);
                      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;
                  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());
                  }
                  // ///////// //

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

                  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;
                  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

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

              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 *;
                      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;

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

                  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();

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

                  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();

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

              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)

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