Unify invokeables in series

Add exposed QML methods between series if not shared.

Task-number: QTBUG-124828
Change-Id: If9fed5f94aaa38f0da42b887192c0fd8941a08ed
Reviewed-by: Kaj Grönholm <kaj.gronholm@qt.io>

11 files changed, 779 insertions, 40 deletions

diff --git a/src/graphs2d/barchart/qbarseries.cpp b/src/graphs2d/barchart/qbarseries.cpp
index 458974f..82c14f1 100644
--- a/src/graphs2d/barchart/qbarseries.cpp
+++ b/src/graphs2d/barchart/qbarseries.cpp
@@ -530,6 +530,48 @@ QT_BEGIN_NAMESPACE
 */
 
 /*!
+    \qmlmethod bool BarSeries::replace(int index, BarSet barset)
+    Replaces the bar set at the position specified by \a index from the series and replaces it
+    with \a barset. Returns \c true if successful, \c false otherwise.
+*/
+
+/*!
+    \qmlmethod Barset BarSeries::at(int index)
+    Returns the bar set specified by \a index from the series. Returns \c null otherwise.
+*/
+
+/*!
+    \qmlmethod int BarSeries::find(BarSet barset)
+    Returns the index of the bar set specified by \a barset from the series. Returns \c -1 if
+    not found.
+*/
+
+/*!
+    \qmlmethod void BarSeries::removeMultiple(int index, int count)
+    Removes a range of bar sets as specified by the \a index and \a count. The call
+    traverses over all sets even if removal of one fails.
+*/
+
+/*!
+    \qmlmethod bool BarSeries::remove(int index)
+    Removes the bar set specified by \a index from the series. Returns \c true if the
+    removal was successful, \c false otherwise.
+*/
+
+/*!
+    \qmlmethod bool BarSeries::replace(BarSet oldSet, BarSet newSet)
+    Replaces the bar set specified by \a oldSet with newSet. Returns \c true if the
+    removal was successful, \c false otherwise. \a oldSet is destroyed if this 
+    is successful.
+*/
+
+/*!
+    \qmlmethod bool BarSeries::replace(list<BarSet> sets)
+    Completely replaces all current bar set with \a sets. The size does not need
+    to match. Returns false if any of the bar set in \a sets are invalid.
+*/
+
+/*!
     \internal
 */
 
@@ -715,6 +757,126 @@ void QBarSeries::clear()
     }
 }
 
+void QBarSeries::replace(int index, QBarSet *set)
+{
+    Q_D(QBarSeries);
+
+    if (d->m_barSets.size() <= index)
+        return;
+    if (!set)
+        return;
+    if (index < 0)
+        index = 0;
+
+    delete d->m_barSets[index];
+    d->m_barSets[index] = set;
+
+    QList<QBarSet *> sets;
+    sets.append(set);
+    QObject::connect(set, &QBarSet::update, this, &QBarSeries::update);
+    emit barsetsReplaced(sets);
+}
+
+QBarSet *QBarSeries::at(int index)
+{
+    Q_D(QBarSeries);
+
+    if (d->m_barSets.size() <= index)
+        return nullptr;
+    if (index < 0)
+        return nullptr;
+
+    return d->m_barSets[index];
+}
+
+/*!
+    Returns the index of the first BarSet found as defined by \a set. Returns -1 if no BarSet was found.
+*/
+int QBarSeries::find(QBarSet *set) const
+{
+    Q_D(const QBarSeries);
+
+    for (int i = 0; i < d->m_barSets.size(); ++i) {
+        if (set == d->m_barSets[i])
+            return i;
+    }
+
+    return -1;
+}
+
+void QBarSeries::removeMultiple(int index, int count)
+{
+    Q_D(QBarSeries);
+
+    if (index + count >= d->m_barSets.size())
+        return;
+    if (index < 0 || count < 0)
+        return;
+
+    for (int i = index; i < index + count; ++i)
+        remove(d->m_barSets[index]);
+}
+
+bool QBarSeries::remove(int index)
+{
+    Q_D(QBarSeries);
+
+    if (index >= d->m_barSets.size())
+        return false;
+    if (index < 0)
+        return false;
+
+    return remove(d->m_barSets[index]);
+}
+
+bool QBarSeries::replace(QBarSet *oldValue, QBarSet *newValue)
+{
+    Q_D(QBarSeries);
+
+    if (!oldValue || !newValue)
+        return false;
+    if (oldValue == newValue)
+        return false;
+
+    for (int i = 0; i < d->m_barSets.size(); ++i) {
+        if (d->m_barSets[i] == oldValue) {
+            delete d->m_barSets[i];
+            d->m_barSets[i] = newValue;
+
+            QList<QBarSet *> sets;
+            sets.append(newValue);
+            QObject::connect(newValue, &QBarSet::update, this, &QBarSeries::update);
+            emit barsetsReplaced(sets);
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool QBarSeries::replace(const QList<QBarSet *> &sets)
+{
+    Q_D(QBarSeries);
+
+    for (const auto set : sets) {
+        if (!set)
+            return false;
+    }
+
+    for (const auto set : d->m_barSets) {
+        delete set;
+    }
+
+    for (const auto set : sets) {
+        QObject::connect(set, &QBarSet::update, this, &QBarSeries::update);
+    }
+
+    d->m_barSets = sets;
+    emit barsetsReplaced(sets);
+
+    return true;
+}
+
 /*!
     Returns the number of bar sets in a bar series.
 */
diff --git a/src/graphs2d/barchart/qbarseries.h b/src/graphs2d/barchart/qbarseries.h
index c47ecc1..4e743af 100644
--- a/src/graphs2d/barchart/qbarseries.h
+++ b/src/graphs2d/barchart/qbarseries.h
@@ -55,12 +55,20 @@ public:
     qreal barWidth() const;
 
     Q_INVOKABLE bool append(QBarSet *set);
-    Q_INVOKABLE bool remove(QBarSet *set);
     Q_INVOKABLE bool take(QBarSet *set);
+    Q_INVOKABLE int count() const;
     Q_INVOKABLE bool append(const QList<QBarSet *> &sets);
+    Q_INVOKABLE bool remove(QBarSet *set);
     Q_INVOKABLE bool insert(int index, QBarSet *set);
-    Q_INVOKABLE int count() const;
     Q_INVOKABLE void clear();
+    Q_INVOKABLE void replace(int index, QBarSet *set);
+    Q_INVOKABLE QBarSet *at(int index);
+    Q_INVOKABLE int find(QBarSet *set) const;
+    Q_INVOKABLE void removeMultiple(int index, int count);
+    Q_INVOKABLE bool remove(int index);
+    Q_INVOKABLE bool replace(QBarSet *oldValue, QBarSet *newValue);
+    Q_INVOKABLE bool replace(const QList<QBarSet *> &sets);
+
     QList<QBarSet *> barSets() const;
 
     void setLabelsVisible(bool visible = true);
@@ -113,6 +121,7 @@ Q_SIGNALS:
     void barComponentChanged();
 
     void barsetsAdded(const QList<QBarSet *> &sets);
+    void barsetsReplaced(const QList<QBarSet *> &sets);
     void barsetsRemoved(const QList<QBarSet *> &sets);
     void setValueChanged(int index, QBarSet *barset);
     void setValueAdded(int index, int count, QBarSet *barset);
diff --git a/src/graphs2d/piechart/qpieseries.cpp b/src/graphs2d/piechart/qpieseries.cpp
index 62e3e64..b8361a6 100644
--- a/src/graphs2d/piechart/qpieseries.cpp
+++ b/src/graphs2d/piechart/qpieseries.cpp
@@ -326,11 +326,48 @@ QT_BEGIN_NAMESPACE
 */
 
 /*!
+    \qmlmethod bool PieSeries::replace(int index, PieSlice slice)
+    Replaces the slice specified by \a slice from the pie at \a index. Returns \c true if the
+    replace was successful, \c false otherwise.
+*/
+
+/*!
     \qmlmethod PieSeries::clear()
     Removes all slices from the pie.
 */
 
 /*!
+    \qmlmethod void PieSeries::removeMultiple(int index, int count)
+    Removes a range of slices as specified by the \a index and \a count. The call
+    traverses over all slices even if removal of one fails.
+*/
+
+/*!
+    \qmlmethod bool PieSeries::remove(int index)
+    Removes the slice specified by \a index from the pie. Returns \c true if the
+    removal was successful, \c false otherwise.
+*/
+
+/*!
+    \qmlmethod bool PieSeries::replace(PieSlice oldSlice, PieSlice newSlice)
+    Replaces the slice specified by \a oldSlice with newSlice. Returns \c true if the
+    removal was successful, \c false otherwise. \a oldSlice is destroyed if this 
+    is successful.
+*/
+
+/*!
+    \qmlmethod bool PieSeries::replace(list<PieSlice> slices)
+    Completely replaces all current slices with \a slices. The size does not need
+    to match. Returns false if any of the PieSlice in \a slices is invalid.
+*/
+
+/*!
+    \qmlmethod bool PieSeries::take(PieSlice slice)
+    Takes a single slice, specified by \a slice, from the series. Does not delete
+    the slice object. Returns \c true if successful.
+*/
+
+/*!
     Constructs a series object that is a child of \a parent.
 */
 QPieSeries::QPieSeries(QObject *parent)
@@ -365,6 +402,145 @@ QPieSlice *QPieSeries::find(const QString &label)
     return 0;
 }
 
+bool QPieSeries::replace(int index, QPieSlice *slice)
+{
+    Q_D(QPieSeries);
+
+    if (index < 0)
+        index = 0;
+    if (!slice || d->m_slices.contains(slice))
+        return false;
+    if (slice->series()) // already added to some series
+        return false;
+    if (qIsNaN(slice->value()) || qIsInf(slice->value()))
+        return false;
+    if (d->m_slices.size() <= index)
+        return false;
+
+    emit removed(QList<QPieSlice *>() << d->m_slices[index]);
+    delete d->m_slices[index];
+
+    slice->setParent(this);
+    slice->d_func()->m_series = this;
+
+    d->m_slices[index] = slice;
+
+    d->updateData();
+
+    QObject::connect(slice, SIGNAL(sliceChanged()), this, SLOT(handleSliceChange()));
+    emit replaced(QList<QPieSlice *>() << slice);
+
+    return true;
+}
+
+void QPieSeries::removeMultiple(int index, int count)
+{
+    Q_D(QPieSeries);
+
+    if (index + count >= d->m_slices.size())
+        return;
+    if (index < 0 || count < 0)
+        return;
+
+    QList<QPieSlice *> removedList;
+
+    for (int i = index; i < index + count; ++i) {
+        auto slice = d->m_slices[index];
+        d->m_slices.removeOne(slice);
+        d->updateData();
+
+        removedList << slice;
+    }
+
+    emit removed(removedList);
+
+    for (auto slice : removedList) {
+        delete slice;
+    }
+
+    emit countChanged();
+}
+
+bool QPieSeries::remove(int index)
+{
+    Q_D(QPieSeries);
+
+    if (index >= d->m_slices.size())
+        return false;
+    if (index < 0)
+        return false;
+
+    return remove(d->m_slices[index]);
+}
+
+bool QPieSeries::replace(QPieSlice *oldSlice, QPieSlice *newSlice)
+{
+    Q_D(QPieSeries);
+
+    if (!oldSlice || !newSlice)
+        return false;
+    if (oldSlice == newSlice)
+        return false;
+    if (d->m_slices.contains(newSlice))
+        return false;
+    if (newSlice->series())
+        return false;
+    if (qIsNaN(newSlice->value()) || qIsInf(newSlice->value()))
+        return false;
+
+    for (int i = 0; i < d->m_slices.size(); ++i) {
+        if (d->m_slices[i] == oldSlice) {
+            emit removed(QList<QPieSlice *>() << d->m_slices[i]);
+            delete d->m_slices[i];
+
+            newSlice->setParent(this);
+            newSlice->d_func()->m_series = this;
+
+            d->m_slices[i] = newSlice;
+
+            d->updateData();
+
+            QObject::connect(newSlice, SIGNAL(sliceChanged()), this, SLOT(handleSliceChange()));
+            emit replaced(QList<QPieSlice *>() << newSlice);
+
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool QPieSeries::replace(const QList<QPieSlice *> &slices)
+{
+    Q_D(QPieSeries);
+
+    for (const auto slice : slices) {
+        if (!slice || d->m_slices.contains(slice))
+            return false;
+        if (slice->series())
+            return false;
+        if (qIsNaN(slice->value()) || qIsInf(slice->value()))
+            return false;
+    }
+
+    emit removed(d->m_slices);
+    for (auto &slice : d->m_slices) {
+        delete slice;
+        slice = nullptr;
+    }
+
+    for (auto &slice : slices) {
+        slice->setParent(this);
+        slice->d_func()->m_series = this;
+        QObject::connect(slice, SIGNAL(sliceChanged()), this, SLOT(handleSliceChange()));
+    }
+
+    d->m_slices = slices;
+    emit replaced(slices);
+
+    return true;
+}
+
 /*!
     Appends the slice specified by \a slice to the series.
     Slice ownership is passed to the series.
diff --git a/src/graphs2d/piechart/qpieseries.h b/src/graphs2d/piechart/qpieseries.h
index 1a21840..67a7561 100644
--- a/src/graphs2d/piechart/qpieseries.h
+++ b/src/graphs2d/piechart/qpieseries.h
@@ -31,18 +31,22 @@ public:
     explicit QPieSeries(QObject *parent = nullptr);
     QAbstractSeries::SeriesType type() const override;
 
+    Q_INVOKABLE bool append(QPieSlice *slice);
+    Q_INVOKABLE bool append(const QList<QPieSlice *> &slices);
+    Q_INVOKABLE bool insert(int index, QPieSlice *slice);
+    Q_INVOKABLE bool remove(QPieSlice *slice);
+    Q_INVOKABLE void clear();
+    Q_INVOKABLE QPieSlice *append(const QString &label, qreal value);
     Q_INVOKABLE QPieSlice *at(int index);
     Q_INVOKABLE QPieSlice *find(const QString &label);
-    bool append(QPieSlice *slice);
-    bool append(const QList<QPieSlice *> &slices);
-    QPieSeries &operator << (QPieSlice *slice);
-    Q_INVOKABLE QPieSlice *append(const QString &label, qreal value);
+    Q_INVOKABLE bool replace(int index, QPieSlice *slice);
+    Q_INVOKABLE void removeMultiple(int index, int count);
+    Q_INVOKABLE bool remove(int index);
+    Q_INVOKABLE bool replace(QPieSlice *oldSlice, QPieSlice *newSlice);
+    Q_INVOKABLE bool replace(const QList<QPieSlice *> &slices);
+    Q_INVOKABLE bool take(QPieSlice *slice);
 
-    bool insert(int index, QPieSlice *slice);
-
-    Q_INVOKABLE bool remove(QPieSlice *slice);
-    bool take(QPieSlice *slice);
-    Q_INVOKABLE void clear();
+    QPieSeries &operator<<(QPieSlice *slice);
 
     QList<QPieSlice *> slices() const;
     int count() const;
@@ -81,6 +85,7 @@ protected:
 Q_SIGNALS:
     void added(const QList<QPieSlice *> &slices);
     void removed(const QList<QPieSlice *> &slices);
+    void replaced(const QList<QPieSlice *> &slices);
     void countChanged();
     void sumChanged();
     void sizeChanged();
diff --git a/src/graphs2d/xychart/qxyseries.cpp b/src/graphs2d/xychart/qxyseries.cpp
index 2c9c127..7ded07f 100644
--- a/src/graphs2d/xychart/qxyseries.cpp
+++ b/src/graphs2d/xychart/qxyseries.cpp
@@ -327,7 +327,7 @@ void QXYSeries::remove(int index)
     Removes the number of points specified by \a count from the series starting
     at the position specified by \a index.
 */
-void QXYSeries::removePoints(int index, int count)
+void QXYSeries::removeMultiple(int index, int count)
 {
     // This function doesn't overload remove as there is chance for it to get mixed up with
     // remove(qreal, qreal) overload in some implicit casting cases.
@@ -358,6 +358,23 @@ void QXYSeries::removePoints(int index, int count)
             emit selectedPointsChanged();
     }
 }
+/*!
+    Takes a point, specified by \a point, out of the series if found. Returns \c true if
+    the operation is successful.
+*/
+bool QXYSeries::take(const QPointF &point)
+{
+    Q_D(QXYSeries);
+
+    for (int i = 0; i < d->m_points.size(); ++i) {
+        if (d->m_points[i] == point) {
+            d->m_points.removeAt(i);
+            return true;
+        }
+    }
+
+    return false;
+}
 
 /*!
     Inserts a point with the coordinates \a point to the position specified
@@ -401,7 +418,7 @@ void QXYSeries::insert(int index, const QPointF &point)
 void QXYSeries::clear()
 {
     Q_D(QXYSeries);
-    removePoints(0, d->m_points.size());
+    removeMultiple(0, d->m_points.size());
 }
 
 /*!
@@ -424,6 +441,22 @@ const QPointF &QXYSeries::at(int index) const
 }
 
 /*!
+    Finds and returns the index of the first matching point found as defined by \a point.
+    Returns -1 if the point is not found. 
+*/
+int QXYSeries::find(const QPointF &point) const
+{
+    Q_D(const QXYSeries);
+
+    for (int i = 0; i < d->m_points.size(); ++i) {
+        if (d->m_points[i] == point)
+            return i;
+    }
+
+    return -1;
+}
+
+/*!
     Returns the number of data points in a series.
 */
 int QXYSeries::count() const
diff --git a/src/graphs2d/xychart/qxyseries.h b/src/graphs2d/xychart/qxyseries.h
index 4bdba48..9bf14b1 100644
--- a/src/graphs2d/xychart/qxyseries.h
+++ b/src/graphs2d/xychart/qxyseries.h
@@ -29,25 +29,26 @@ protected:
     explicit QXYSeries(QXYSeriesPrivate &dd, QObject *parent = nullptr);
 
 public:
-    // TODO: Consider making these slots, available from QML.
     Q_INVOKABLE void append(qreal x, qreal y);
-    void append(const QPointF &point);
-    void append(const QList<QPointF> &points);
-    void replace(qreal oldX, qreal oldY, qreal newX, qreal newY);
-    void replace(const QPointF &oldPoint, const QPointF &newPoint);
+    Q_INVOKABLE void append(const QPointF &point);
+    Q_INVOKABLE void append(const QList<QPointF> &points);
+    Q_INVOKABLE void replace(qreal oldX, qreal oldY, qreal newX, qreal newY);
+    Q_INVOKABLE void replace(const QPointF &oldPoint, const QPointF &newPoint);
     Q_INVOKABLE void replace(int index, qreal newX, qreal newY);
-    void replace(int index, const QPointF &newPoint);
-    void replace(const QList<QPointF> &points);
-    void remove(qreal x, qreal y);
-    void remove(const QPointF &point);
+    Q_INVOKABLE void replace(int index, const QPointF &newPoint);
+    Q_INVOKABLE void replace(const QList<QPointF> &points);
+    Q_INVOKABLE void remove(qreal x, qreal y);
+    Q_INVOKABLE void remove(const QPointF &point);
     Q_INVOKABLE void remove(int index);
-    void removePoints(int index, int count);
-    void insert(int index, const QPointF &point);
-    void clear();
+    Q_INVOKABLE void insert(int index, const QPointF &point);
+    Q_INVOKABLE void clear();
+    Q_INVOKABLE const QPointF &at(int index) const;
+    Q_INVOKABLE int find(const QPointF &) const;
+    Q_INVOKABLE void removeMultiple(int index, int count);
+    Q_INVOKABLE bool take(const QPointF &point);
+    Q_INVOKABLE int count() const;
 
-    int count() const;
     QList<QPointF> points() const;
-    const QPointF &at(int index) const;
 
     QXYSeries &operator<<(const QPointF &point);
     QXYSeries &operator<<(const QList<QPointF> &points);
diff --git a/tests/auto/cpp2dtest/qgbars/tst_bars.cpp b/tests/auto/cpp2dtest/qgbars/tst_bars.cpp
index 58c3093..9da12e4 100644
--- a/tests/auto/cpp2dtest/qgbars/tst_bars.cpp
+++ b/tests/auto/cpp2dtest/qgbars/tst_bars.cpp
@@ -18,7 +18,7 @@ private slots:
     void cleanup();
 
     void construct();
-
+    void modifySeries();
     void initialProperties();
     void initializeProperties();
     void invalidProperties();
@@ -134,5 +134,121 @@ void tst_bars::invalidProperties()
     QCOMPARE(m_series->valuesMultiplier(), 0.0);
 }
 
+void tst_bars::modifySeries()
+{
+    QVERIFY(m_series);
+
+    auto set1 = new QBarSet("Set 1", m_series);
+    auto set2 = new QBarSet("Set 2", m_series);
+    auto set3 = new QBarSet("Set 3", m_series);
+    auto set4 = new QBarSet("Set 4", m_series);
+    auto set5 = new QBarSet("Set 5", m_series);
+    auto set6 = new QBarSet("Set 6", m_series);
+    auto set7 = new QBarSet("Set 7", m_series);
+    auto newSet = new QBarSet("New Set", m_series);
+    auto pointerBarset = new QBarSet("Set pointer", m_series);
+
+    // append
+    m_series->append(set1);
+    m_series->append(set2);
+    m_series->append(set3);
+    m_series->append(set4);
+    m_series->append(set5);
+    m_series->append(set6);
+    m_series->append(set7);
+
+    auto sets = m_series->barSets();
+
+    QCOMPARE(sets[0], set1);
+    QCOMPARE(sets[1], set2);
+    QCOMPARE(sets[2], set3);
+    QCOMPARE(sets[3], set4);
+    QCOMPARE(sets[4], set5);
+    QCOMPARE(sets[5], set6);
+    QCOMPARE(sets[6], set7);
+
+    // pointer remove
+    m_series->remove(set3);
+    sets = m_series->barSets();
+    QCOMPARE(sets[0], set1);
+    QCOMPARE(sets[1], set2);
+    QCOMPARE(sets[2], set4);
+    QCOMPARE(sets[3], set5);
+    QCOMPARE(sets[4], set6);
+    QCOMPARE(sets[5], set7);
+
+    // index remove
+    QVERIFY(!m_series->remove(-1));
+    QVERIFY(!m_series->remove(100));
+    QVERIFY(m_series->remove(2));
+    sets = m_series->barSets();
+    QCOMPARE(sets[0], set1);
+    QCOMPARE(sets[1], set2);
+    QCOMPARE(sets[2], set5);
+    QCOMPARE(sets[3], set6);
+    QCOMPARE(sets[4], set7);
+
+    // index replace
+    m_series->replace(2, newSet);
+    sets = m_series->barSets();
+    QCOMPARE(sets[0], set1);
+    QCOMPARE(sets[1], set2);
+    QCOMPARE(sets[2], newSet);
+    QCOMPARE(sets[3], set6);
+    QCOMPARE(sets[4], set7);
+
+    // multiple remove
+    m_series->removeMultiple(-1, -1);
+    m_series->removeMultiple(0, 100);
+    m_series->removeMultiple(1, 2);
+    sets = m_series->barSets();
+    QCOMPARE(sets.size(), 3);
+    QCOMPARE(sets[0], set1);
+    QCOMPARE(sets[1], set6);
+    QCOMPARE(sets[2], set7);
+
+    // pointer replace
+    QVERIFY(!m_series->replace(nullptr, nullptr));
+    QVERIFY(!m_series->replace(pointerBarset, pointerBarset));
+    QVERIFY(m_series->replace(set6, pointerBarset));
+    sets = m_series->barSets();
+    QCOMPARE(sets[0], set1);
+    QCOMPARE(sets[1], pointerBarset);
+    QCOMPARE(sets[2], set7);
+
+    //at
+    auto atSet1 = m_series->at(2);
+    auto atSet2 = m_series->at(-10);
+    auto atSet3 = m_series->at(100);
+    QCOMPARE(atSet1, set7);
+    QCOMPARE(atSet2, nullptr);
+    QCOMPARE(atSet3, nullptr);
+
+    //find
+    auto fSet1 = m_series->find(newSet);
+    auto fSet2 = m_series->find(set2);
+    auto fSet3 = m_series->find(pointerBarset);
+    auto fSet4 = m_series->find(set7);
+
+    QCOMPARE(fSet4, 2);
+    QCOMPARE(fSet1, -1);
+    QCOMPARE(fSet2, -1);
+    QCOMPARE(fSet3, 1);
+
+    // take
+    QVERIFY(m_series->take(pointerBarset));
+    QCOMPARE(m_series->count(), 2);
+
+    // full replace
+    QList<QBarSet *> bars = {new QBarSet("new set 1", m_series),
+                             new QBarSet("new set 2", m_series),
+                             new QBarSet("new set 3", m_series)};
+    QVERIFY(m_series->replace(bars));
+    sets = m_series->barSets();
+    QCOMPARE(sets[0], bars[0]);
+    QCOMPARE(sets[1], bars[1]);
+    QCOMPARE(sets[2], bars[2]);
+}
+
 QTEST_MAIN(tst_bars)
 #include "tst_bars.moc"
diff --git a/tests/auto/cpp2dtest/qgpieseries/tst_qgpieseries.cpp b/tests/auto/cpp2dtest/qgpieseries/tst_qgpieseries.cpp
index 6d70885..e3a76f3 100644
--- a/tests/auto/cpp2dtest/qgpieseries/tst_qgpieseries.cpp
+++ b/tests/auto/cpp2dtest/qgpieseries/tst_qgpieseries.cpp
@@ -21,6 +21,7 @@ private slots:
     void append();
     void insert();
     void remove();
+    void replace();
     void take();
     void calculatedValues();
     void sliceSeries();
@@ -267,34 +268,159 @@ void tst_qgpieseries::remove()
     QPieSlice *slice1 = m_series->append("slice 1", 1);
     QPieSlice *slice2 = m_series->append("slice 2", 2);
     QPieSlice *slice3 = m_series->append("slice 3", 3);
+    QPieSlice *slice4 = m_series->append("slice 4", 4);
+    QPieSlice *slice5 = m_series->append("slice 5", 5);
+    QPieSlice *slice6 = m_series->append("slice 6", 6);
     QSignalSpy spy1(slice1, SIGNAL(destroyed()));
     QSignalSpy spy2(slice2, SIGNAL(destroyed()));
     QSignalSpy spy3(slice3, SIGNAL(destroyed()));
-    QCOMPARE(m_series->count(), 3);
+    QCOMPARE(m_series->count(), 6);
 
     // null pointer remove
-    QVERIFY(!m_series->remove(0));
+    QVERIFY(!m_series->remove(nullptr));
 
     // remove first
     QVERIFY(m_series->remove(slice1));
     QVERIFY(!m_series->remove(slice1));
-    QCOMPARE(m_series->count(), 2);
+    QCOMPARE(m_series->count(), 5);
     QCOMPARE(m_series->slices().at(0)->label(), slice2->label());
     QCOMPARE(removedSpy.size(), 1);
     QList<QPieSlice *> removed = qvariant_cast<QList<QPieSlice *> >(removedSpy.at(0).at(0));
     QCOMPARE(removed.size(), 1);
     QCOMPARE(static_cast<const void *>(removed.first()), static_cast<const void *>(slice1));
 
+    // remove index
+    QVERIFY(!m_series->remove(-1));
+    QVERIFY(!m_series->remove(100));
+    QVERIFY(m_series->remove(4));
+    QCOMPARE(m_series->count(), 4);
+    QCOMPARE(removedSpy.size(), 2);
+    removed = qvariant_cast<QList<QPieSlice *>>(removedSpy.at(1).at(0));
+    QCOMPARE(removed.size(), 1);
+    QCOMPARE(static_cast<const void *>(removed.first()), static_cast<const void *>(slice6));
+
+    // remove multiple
+    m_series->removeMultiple(5, 0);
+    m_series->removeMultiple(-1, -1);
+    QCOMPARE(m_series->count(), 4);
+    m_series->removeMultiple(1, 2);
+    QCOMPARE(m_series->count(), 2);
+    QCOMPARE(removedSpy.size(), 3);
+    removed = qvariant_cast<QList<QPieSlice *>>(removedSpy.at(2).at(0));
+    QCOMPARE(removed.size(), 2);
+    QCOMPARE(static_cast<const void *>(removed[0]), static_cast<const void *>(slice3));
+    QCOMPARE(static_cast<const void *>(removed[1]), static_cast<const void *>(slice4));
+
     // remove all
     m_series->clear();
     QVERIFY(m_series->isEmpty());
     QVERIFY(m_series->slices().isEmpty());
     QCOMPARE(m_series->count(), 0);
-    QCOMPARE(removedSpy.size(), 2);
-    removed = qvariant_cast<QList<QPieSlice *> >(removedSpy.at(1).at(0));
+    QCOMPARE(removedSpy.size(), 4);
+    removed = qvariant_cast<QList<QPieSlice *>>(removedSpy.at(3).at(0));
     QCOMPARE(removed.size(), 2);
     QCOMPARE(static_cast<const void *>(removed.first()), static_cast<const void *>(slice2));
-    QCOMPARE(static_cast<const void *>(removed.last()), static_cast<const void *>(slice3));
+    QCOMPARE(static_cast<const void *>(removed.last()), static_cast<const void *>(slice5));
+}
+
+void tst_qgpieseries::replace()
+{
+    QVERIFY(m_series);
+
+    QSignalSpy removedSpy(m_series, SIGNAL(removed(QList<QPieSlice *>)));
+    QSignalSpy replacedSpy(m_series, SIGNAL(replaced(QList<QPieSlice *>)));
+
+    QPieSeries series2;
+    auto slice1 = new QPieSlice("slice 1", 1);
+    auto slice2 = new QPieSlice("slice 2", 1);
+    auto slice3 = new QPieSlice("slice 3", 1);
+    auto slice4 = new QPieSlice("slice 4", 1);
+    auto slice5 = new QPieSlice("slice 5", 1);
+    auto slice6 = new QPieSlice("slice 6", 1);
+
+    m_series->append(slice1);
+    m_series->append(slice2);
+    m_series->append(slice3);
+    m_series->append(slice4);
+    m_series->append(slice5);
+    m_series->append(slice6);
+
+    auto slices = m_series->slices();
+
+    QCOMPARE(static_cast<const void *>(slices[0]), static_cast<const void *>(slice1));
+    QCOMPARE(static_cast<const void *>(slices[1]), static_cast<const void *>(slice2));
+    QCOMPARE(static_cast<const void *>(slices[2]), static_cast<const void *>(slice3));
+    QCOMPARE(static_cast<const void *>(slices[3]), static_cast<const void *>(slice4));
+    QCOMPARE(static_cast<const void *>(slices[4]), static_cast<const void *>(slice5));
+    QCOMPARE(static_cast<const void *>(slices[5]), static_cast<const void *>(slice6));
+
+    // Index replace
+    auto indexSlice = new QPieSlice("slice index", 1);
+    QVERIFY(m_series->replace(1, indexSlice));
+    slices = m_series->slices();
+
+    QCOMPARE(static_cast<const void *>(slices[0]), static_cast<const void *>(slice1));
+    QCOMPARE(static_cast<const void *>(slices[1]), static_cast<const void *>(indexSlice));
+    QCOMPARE(static_cast<const void *>(slices[2]), static_cast<const void *>(slice3));
+    QCOMPARE(static_cast<const void *>(slices[3]), static_cast<const void *>(slice4));
+    QCOMPARE(static_cast<const void *>(slices[4]), static_cast<const void *>(slice5));
+    QCOMPARE(static_cast<const void *>(slices[5]), static_cast<const void *>(slice6));
+
+    QList<QPieSlice *> removed = qvariant_cast<QList<QPieSlice *>>(removedSpy.at(0).at(0));
+    QCOMPARE(static_cast<const void *>(removed.first()), static_cast<const void *>(slice2));
+
+    auto replaced = qvariant_cast<QList<QPieSlice *>>(replacedSpy.at(0).at(0));
+    QCOMPARE(replacedSpy.size(), 1);
+    QCOMPARE(replaced.size(), 1);
+    QCOMPARE(static_cast<const void *>(replaced.first()), static_cast<const void *>(indexSlice));
+
+    // check ownership
+    QVERIFY(!series2.append(indexSlice));
+
+    // pointer replace
+    auto pointerSlice = new QPieSlice("slice pointer", 1);
+    QVERIFY(!m_series->replace(nullptr, nullptr));
+    QVERIFY(!m_series->replace(pointerSlice, pointerSlice));
+    QVERIFY(m_series->replace(slice6, pointerSlice));
+    removed = qvariant_cast<QList<QPieSlice *>>(removedSpy.at(1).at(0));
+    QCOMPARE(static_cast<const void *>(removed.first()), static_cast<const void *>(slice6));
+
+    replaced = qvariant_cast<QList<QPieSlice *>>(replacedSpy.at(1).at(0));
+    QCOMPARE(static_cast<const void *>(replaced.first()), static_cast<const void *>(pointerSlice));
+
+    slices = m_series->slices();
+    QCOMPARE(static_cast<const void *>(slices[0]), static_cast<const void *>(slice1));
+    QCOMPARE(static_cast<const void *>(slices[1]), static_cast<const void *>(indexSlice));
+    QCOMPARE(static_cast<const void *>(slices[2]), static_cast<const void *>(slice3));
+    QCOMPARE(static_cast<const void *>(slices[3]), static_cast<const void *>(slice4));
+    QCOMPARE(static_cast<const void *>(slices[4]), static_cast<const void *>(slice5));
+    QCOMPARE(static_cast<const void *>(slices[5]), static_cast<const void *>(pointerSlice));
+
+    // check ownership
+    QVERIFY(!series2.append(pointerSlice));
+
+    // full replace
+    QList<QPieSlice *> newSlices = {new QPieSlice("slice 10", 1),
+                                    new QPieSlice("slice 20", 1),
+                                    new QPieSlice("slice 30", 1)};
+    QVERIFY(m_series->replace(newSlices));
+
+    removed = qvariant_cast<QList<QPieSlice *>>(removedSpy.at(2).at(0));
+    QVERIFY(removed.size() == 6);
+    QCOMPARE(static_cast<const void *>(removed[5]), static_cast<const void *>(pointerSlice));
+    QCOMPARE(static_cast<const void *>(removed[4]), static_cast<const void *>(slice5));
+    QCOMPARE(static_cast<const void *>(removed[3]), static_cast<const void *>(slice4));
+
+    replaced = qvariant_cast<QList<QPieSlice *>>(replacedSpy.at(2).at(0));
+    QVERIFY(replaced.size() == 3);
+    QCOMPARE(static_cast<const void *>(replaced[0]), static_cast<const void *>(newSlices[0]));
+    QCOMPARE(static_cast<const void *>(replaced[1]), static_cast<const void *>(newSlices[1]));
+    QCOMPARE(static_cast<const void *>(replaced[2]), static_cast<const void *>(newSlices[2]));
+
+    slices = m_series->slices();
+    QCOMPARE(static_cast<const void *>(slices[0]), static_cast<const void *>(newSlices[0]));
+    QCOMPARE(static_cast<const void *>(slices[1]), static_cast<const void *>(newSlices[1]));
+    QCOMPARE(static_cast<const void *>(slices[2]), static_cast<const void *>(newSlices[2]));
 }
 
 void tst_qgpieseries::take()
diff --git a/tests/auto/cpp2dtest/qgxychart/tst_xyseries.cpp b/tests/auto/cpp2dtest/qgxychart/tst_xyseries.cpp
index 9ccd0c6..dc897db 100644
--- a/tests/auto/cpp2dtest/qgxychart/tst_xyseries.cpp
+++ b/tests/auto/cpp2dtest/qgxychart/tst_xyseries.cpp
@@ -20,6 +20,8 @@ private slots:
     void selectDeselect();
     void appendInsertRemove();
     void replaceAtClear();
+    void find();
+    void take();
 
 private:
     // QXYSeries is uncreatable, so testing is done through QScatterSeries
@@ -128,7 +130,7 @@ void tst_xyseries::appendInsertRemove()
     QCOMPARE(m_series->points(), mixedpoints);
 
     // Remove first 3
-    m_series->removePoints(0, 3);
+    m_series->removeMultiple(0, 3);
 
     QCOMPARE(m_series->count(), 3);
 
@@ -168,5 +170,40 @@ void tst_xyseries::replaceAtClear()
     QCOMPARE(m_series->count(), 0);
 }
 
+void tst_xyseries::find()
+{
+    QVERIFY(m_series);
+    QList<QPointF> points = {{1, 4}, {9, 2}, {3, 7}, {9, 2}, {8, 8}};
+
+    m_series->append(points);
+    auto sPoints = m_series->points();
+
+    QCOMPARE(sPoints, points);
+
+    auto item1 = m_series->find({9, 2});
+    auto item2 = m_series->find({1, 4});
+    auto item3 = m_series->find({8, 8});
+    auto item4 = m_series->find({300, 8});
+
+    QCOMPARE(item1, 1);
+    QCOMPARE(item2, 0);
+    QCOMPARE(item3, 4);
+    QCOMPARE(item4, -1);
+}
+
+void tst_xyseries::take()
+{
+    QVERIFY(m_series);
+    QList<QPointF> points = {{1, 4}, {9, 2}, {3, 7}, {9, 2}, {8, 8}};
+
+    m_series->append(points);
+    QCOMPARE(m_series->count(), 5);
+
+    QVERIFY(!m_series->take({100, 100}));
+    QCOMPARE(m_series->count(), 5);
+    QVERIFY(m_series->take({3, 7}));
+    QCOMPARE(m_series->count(), 4);
+}
+
 QTEST_MAIN(tst_xyseries)
 #include "tst_xyseries.moc"
diff --git a/tests/auto/qml2dtest/bars/tst_barseries.qml b/tests/auto/qml2dtest/bars/tst_barseries.qml
index 73472d6..5c3c318 100644
--- a/tests/auto/qml2dtest/bars/tst_barseries.qml
+++ b/tests/auto/qml2dtest/bars/tst_barseries.qml
@@ -186,5 +186,49 @@ Item {
             compare(initialized.barWidth, 0.0)
             compare(initialized.valuesMultiplier, 0.0)
         }
+
+        BarSet {id:b1}
+        BarSet {id:b2}
+        BarSet {id:b3}
+        BarSet {id:b4}
+        BarSet {id:b5}
+        BarSet {id:b6}
+        BarSet {id:b7}
+
+        function test_5_modify_series() {
+            // append
+            let list = [b4, b5, b6]
+
+            initialized.append(b1)
+            initialized.append(b2)
+            initialized.append(b3)
+            initialized.append(list)
+            compare(initialized.count, 7)
+
+            // insert
+            initialized.insert(3, b7)
+            compare(initialized.count, 8)
+
+            // at
+            let atBar = initialized.at(5)
+            compare(atBar, b4)
+
+            // find
+            let findIndex = initialized.find(b6)
+            compare(findIndex, 7)
+
+            // remove
+            initialized.remove(b1)
+            initialized.remove(0)
+            compare(initialized.count, 6)
+
+            // remove multiple
+            initialized.removeMultiple(0,3)
+            compare(initialized.count, 3)
+
+            // take
+            verify(initialized.take(b5))
+            compare(initialized.count, 2)
+        }
     }
 }
diff --git a/tests/auto/qml2dtest/pies/tst_pieseries.qml b/tests/auto/qml2dtest/pies/tst_pieseries.qml
index 0db9216..2c4efe3 100644
--- a/tests/auto/qml2dtest/pies/tst_pieseries.qml
+++ b/tests/auto/qml2dtest/pies/tst_pieseries.qml
@@ -65,6 +65,18 @@ Item {
             compare(slice.percentage, 1.0);
             compare(slice.startAngle, 0.0);
             compare(slice.value, 10.0);
+
+            pieSeries.clear()
+        }
+
+        function test_take() {
+            var count = 20;
+            for (var i = 0; i < count; i++)
+                pieSeries.append("slice" + i, Math.random() + 0.01);
+
+            verify(pieSeries.take(pieSeries.find("slice" + 5)))
+            verify(pieSeries.take(pieSeries.find("slice" + 6)))
+            compare(pieSeries.count, 18)
         }
 
         function test_append() {
@@ -84,15 +96,33 @@ Item {
             removedSpy.clear();
             countChangedSpy.clear();
             sumChangedSpy.clear();
+
             var count = 50;
             for (var i = 0; i < count; i++)
                 pieSeries.append("slice" + i, Math.random() + 0.01); // Add 0.01 to avoid zero
-            for (var j = 0; j < count; j++)
+            for (var j = 0; j < 10; j++)
                 pieSeries.remove(pieSeries.at(0));
-            compare(removedSpy.count, count);
-            compare(countChangedSpy.count, 2 * count);
-            compare(sumChangedSpy.count, 2 * count);
-            compare(pieSeries.count, 0);
+
+            compare(removedSpy.count, 10);
+            compare(countChangedSpy.count, count + 10);
+            compare(sumChangedSpy.count, count + 10);
+            compare(pieSeries.count, 40);
+
+            for (var j = 0; j < 10; j++)
+                pieSeries.remove(0);
+
+            compare(removedSpy.count, 20);
+            compare(countChangedSpy.count, count + 20);
+            compare(sumChangedSpy.count, count + 20);
+            compare(pieSeries.count, 30);
+
+            pieSeries.removeMultiple(0,10)
+            compare(removedSpy.count, 21);
+            compare(countChangedSpy.count, count + 21);
+            compare(sumChangedSpy.count, count + 30);
+            compare(pieSeries.count, 20);
+
+            pieSeries.clear();
         }
 
         function test_find_and_at() {