GIT_REPOSITORIES/LPP/Users/mperrinel/SCIQLOP-Initialisation Commit - r646:cb05b478d08e

Updates merge method...

Alexandre Leroux -

r646:cb05b478d08e

parent child

Context file:

r646:cb05b478d08e

Collapse all files

core/include/Data/ArrayData.h +10 -19

             #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 = std::vector<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) {
+                    insert(other.cbegin(), other.cend(), 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
+                void insert(ArrayDataIterator first, ArrayDataIterator last, bool prepend = false)
-                /// 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);
+                    auto firstImpl = dynamic_cast<arraydata_detail::IteratorValue<Dim, true> *>(first->impl());
-                    m_Data.append(values);
+                    auto lastImpl = dynamic_cast<arraydata_detail::IteratorValue<Dim, true> *>(last->impl());
+                    if (firstImpl && lastImpl) {
+                        auto insertIt = prepend ? m_Data.begin() : m_Data.end();
+                        m_Data.insert(insertIt, firstImpl->m_It, lastImpl->m_It);
+                    }
                 }
                 /**
                  * @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> >
                 DataContainer cdata() const noexcept
                 {
                     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/DataSeries.h +12 -21

             #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().empty()) {
                         return SqpRange{m_XAxisData->cdata().front(), m_XAxisData->cdata().back()};
                     }
                     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);
                     }
                     // 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;
                     }
                     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);
                     }
                 }
+                void insert(DataSeriesIterator first, DataSeriesIterator last, bool prepend = false)
+                {
+                    auto firstImpl = dynamic_cast<dataseries_detail::IteratorValue<Dim, true> *>(first->impl());
+                    auto lastImpl = dynamic_cast<dataseries_detail::IteratorValue<Dim, true> *>(last->impl());
+                    if (firstImpl && lastImpl) {
+                        m_XAxisData->insert(firstImpl->m_XIt, lastImpl->m_XIt, prepend);
+                        m_ValuesData->insert(firstImpl->m_ValuesIt, lastImpl->m_ValuesIt, prepend);
+                    }
+                }
                 /// @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,
+                        lowerIt, 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/DataSeriesMergeHelper.h +22 -71

             #ifndef SCIQLOP_DATASERIESMERGEHELPER_H
             #define SCIQLOP_DATASERIESMERGEHELPER_H
             template <int Dim>
             class DataSeries;
             namespace detail {
             /**
              * Scope that can be used for a merge operation
              * @tparam FEnd the type of function that will be executed at the end of the scope
              */
             template <typename FEnd>
             struct MergeScope {
                 explicit MergeScope(FEnd end) : m_End{end} {}
                 virtual ~MergeScope() noexcept { m_End(); }
                 FEnd m_End;
             };
             /**
              * Creates a scope for merge operation
              * @tparam end the function executed at the end of the scope
              */
             template <typename FEnd>
             MergeScope<FEnd> scope(FEnd end)
             {
                 return MergeScope<FEnd>{end};
             }
-            /**
-             * Enum used to position a data series relative to another during a merge operation
-             */
-            enum class MergePosition { LOWER_THAN, GREATER_THAN, EQUAL, OVERLAP };
-            /**
-             * Computes the position of the first data series relative to the second data series
-             * @param lhs the first data series
-             * @param rhs the second data series
-             * @return the merge position computed
-             * @remarks the data series must not be empty
-             */
-            template <int Dim>
-            MergePosition mergePosition(DataSeries<Dim> &lhs, DataSeries<Dim> &rhs)
-                Q_ASSERT(!lhs.isEmpty() && !rhs.isEmpty());
-                // Case lhs < rhs
-                auto lhsLast = --lhs.cend();
-                auto rhsFirst = rhs.cbegin();
-                if (lhsLast->x() < rhsFirst->x()) {
-                    return MergePosition::LOWER_THAN;
-                // Case lhs > rhs
-                auto lhsFirst = lhs.cbegin();
-                auto rhsLast = --rhs.cend();
-                if (lhsFirst->x() > rhsLast->x()) {
-                    return MergePosition::GREATER_THAN;
-                // Other cases
-                auto equal = std::equal(lhs.cbegin(), lhs.cend(), rhs.cbegin(), rhs.cend(),
-                                        [](const auto &it1, const auto &it2) {
-                                            return it1.x() == it2.x() && it1.values() == it2.values();
-                                        });
-                return equal ? MergePosition::EQUAL : MergePosition::OVERLAP;
             } // namespace detail
             /// Helper used to merge two DataSeries
             /// @sa DataSeries
             struct DataSeriesMergeHelper {
                 /// Merges the source data series into the dest data series. Data of the source data series are
                 /// consumed
                 template <int Dim>
                 static void merge(DataSeries<Dim> &source, DataSeries<Dim> &dest)
                 {
                     // Creates a scope to clear source data series at the end of the merge
                     auto _ = detail::scope([&source]() { source.clear(); });
                     // Case : source data series is empty -> no merge is made
                     if (source.isEmpty()) {
                         return;
                     }
                     // Case : dest data series is empty -> we simply swap the data
                     if (dest.isEmpty()) {
                         std::swap(dest.m_XAxisData, source.m_XAxisData);
                         std::swap(dest.m_ValuesData, source.m_ValuesData);
                         return;
                     }
-                    // Gets the position of the source in relation to the destination
+                    auto destMin = dest.cbegin()->x();
-                    auto sourcePosition = detail::mergePosition(source, dest);
+                    auto destMax = (--dest.cend())->x();
+                    auto sourceBegin = source.cbegin();
+                    auto sourceEnd = source.cend();
+                    auto sourceMin = sourceBegin->x();
+                    auto sourceMax = (--source.cend())->x();
-                    switch (sourcePosition) {
+                    // Case : source bounds are inside dest bounds -> no merge is made
-                        case detail::MergePosition::LOWER_THAN:
+                    if (sourceMin >= destMin && sourceMax <= destMax) {
-                        case detail::MergePosition::GREATER_THAN: {
+                        return;
-                            auto prepend = sourcePosition == detail::MergePosition::LOWER_THAN;
-                            dest.m_XAxisData->add(*source.m_XAxisData, prepend);
-                            dest.m_ValuesData->add(*source.m_ValuesData, prepend);
-                            break;
-                        case detail::MergePosition::EQUAL:
-                            // the data series equal each other : no merge made
-                            break;
-                        case detail::MergePosition::OVERLAP: {
-                            // the two data series overlap : merge is made
-                            auto temp = dest.clone();
-                            if (auto tempSeries = dynamic_cast<DataSeries<Dim> *>(temp.get())) {
-                                // Makes the merge :
-                                // - Data are sorted by x-axis values
-                                // - If two entries are in the source range and the other range, only one entry
-                                // is retained as result
-                                // - The results are stored directly in the data series
-                                dest.clear();
-                                std::set_union(
-                                    tempSeries->cbegin(), tempSeries->cend(), source.cbegin(), source.cend(),
-                                    std::back_inserter(dest),
-                                    [](const auto &it1, const auto &it2) { return it1.x() < it2.x(); });
-                            break;
-                        default:
-                            Q_ASSERT(false);
                     }
+                    // Default case :
+                    // - prepend to dest the values of source that are lower than min value of dest
+                    // - append to dest the values of source that are greater than max value of dest
+                    auto lowerIt
+                        = std::lower_bound(sourceBegin, sourceEnd, destMin,
+                                           [](const auto &it, const auto &val) { return it.x() < val; });
+                    auto upperIt
+                        = std::upper_bound(lowerIt, sourceEnd, destMax,
+                                           [](const auto &val, const auto &it) { return val < it.x(); });
+                    dest.insert(sourceBegin, lowerIt, true);
+                    dest.insert(upperIt, sourceEnd);
                 }
             };
             #endif // SCIQLOP_DATASERIESMERGEHELPER_H

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