HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r310:9a5cb57f1573

core/include/Data/DataSeries.h +24 -1

             public:
                 /// @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() const { return m_ValuesData; }
+                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; }
                 {
                 }
+                /// 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}
+                {
+                }
+                /// 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:
                 std::shared_ptr<ArrayData<1> > m_XAxisData;
                 Unit m_XAxisUnit;

core/include/Data/IDataProvider.h +1 -1

             public:
                 virtual ~IDataProvider() noexcept = default;
-                virtual std::unique_ptr<IDataSeries>
+                virtual std::shared_ptr<IDataSeries>
                 retrieveData(const DataProviderParameters &parameters) const = 0;

core/include/Data/IDataSeries.h +5 0

                 /// Returns the x-axis dataset
                 virtual std::shared_ptr<ArrayData<1> > xAxisData() = 0;
+                /// Returns the x-axis dataset (as const)
+                virtual const std::shared_ptr<ArrayData<1> > xAxisData() const = 0;
                 virtual Unit xAxisUnit() const = 0;
                 virtual Unit valuesUnit() const = 0;
                 virtual void merge(IDataSeries *dataSeries) = 0;
+                virtual std::unique_ptr<IDataSeries> clone() const = 0;
             };
             // Required for using shared_ptr in signals/slots

core/include/Data/ScalarSeries.h +2 0

                  * @param value the value data
                  */
                 void setData(int index, double x, double value) noexcept;
+                std::unique_ptr<IDataSeries> clone() const;
             };
             #endif // SCIQLOP_SCALARSERIES_H

core/include/Variable/Variable.h +1 -2

                 bool contains(const SqpDateTime &dateTime);
                 bool intersect(const SqpDateTime &dateTime);
-                void setDataSeries(std::unique_ptr<IDataSeries> dataSeries) noexcept;
             public slots:
-                void onAddDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept;
+                void setDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept;
             signals:
                 void updated();

core/include/Variable/VariableModel.h +1 -1

                  */
                 std::shared_ptr<Variable>
                 createVariable(const QString &name, const SqpDateTime &dateTime,
-                               std::unique_ptr<IDataSeries> defaultDataSeries) noexcept;
+                               std::shared_ptr<IDataSeries> defaultDataSeries) noexcept;
                 std::shared_ptr<Variable> variable(int index) const;

core/src/Data/ScalarSeries.cpp +5 0

@@ -11,3 +11,8 void ScalarSeries::setData(int index, double x, double value) noexcept
11	xAxisData()->setData(index, x);	11	xAxisData()->setData(index, x);
12	valuesData()->setData(index, value);	12	valuesData()->setData(index, value);
13	}	13	}
		14
		15	std::unique_ptr<IDataSeries> ScalarSeries::clone() const
		16	{
		17	return std::make_unique<ScalarSeries>(*this);
		18	}

core/src/Variable/Variable.cpp +9 -7

                 impl->m_DateTime = dateTime;
             }
-            void Variable::setDataSeries(std::unique_ptr<IDataSeries> dataSeries) noexcept
+            void Variable::setDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept
             {
-                if (!impl->m_DataSeries) {
+                if (!dataSeries) {
-                    impl->m_DataSeries = std::move(dataSeries);
+                    /// @todo ALX : log
+                    return;
                 }
-            void Variable::onAddDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept
+                // Inits the data series of the variable
+                if (!impl->m_DataSeries) {
-                if (impl->m_DataSeries) {
+                    impl->m_DataSeries = dataSeries->clone();
+                }
+                else {
                     impl->m_DataSeries->merge(dataSeries.get());
                     emit updated();

core/src/Variable/VariableController.cpp +2 -2

             /// @todo Generates default dataseries, according to the provider passed in parameter. This method
             /// will be deleted when the timerange is recovered from SciQlop
-            std::unique_ptr<IDataSeries> generateDefaultDataSeries(const IDataProvider &provider,
+            std::shared_ptr<IDataSeries> generateDefaultDataSeries(const IDataProvider &provider,
                                                                    const SqpDateTime &dateTime) noexcept
             {
                 auto parameters = DataProviderParameters{dateTime};
                     // store the provider
                     impl->m_VariableToProviderMap[newVariable] = provider;
                     connect(provider.get(), &IDataProvider::dataProvided, newVariable.get(),
-                            &Variable::onAddDataSeries);
+                            &Variable::setDataSeries);
                     // store in cache

core/src/Variable/VariableModel.cpp +1 -1

             std::shared_ptr<Variable>
             VariableModel::createVariable(const QString &name, const SqpDateTime &dateTime,
-                                          std::unique_ptr<IDataSeries> defaultDataSeries) noexcept
+                                          std::shared_ptr<IDataSeries> defaultDataSeries) noexcept
             {
                 auto insertIndex = rowCount();
                 beginInsertRows({}, insertIndex, insertIndex);

plugins/mockplugin/include/CosinusProvider.h +1 -1

             class CosinusProvider : public IDataProvider {
             public:
                 /// @sa IDataProvider::retrieveData()
-                std::unique_ptr<IDataSeries>
+                std::shared_ptr<IDataSeries>
                 retrieveData(const DataProviderParameters &parameters) const override;
                 void requestDataLoading(const QVector<SqpDateTime> &dateTimeList) override;

plugins/mockplugin/src/CosinusProvider.cpp +10 -37

@@ -9,47 +9,11
9		9
10	Q_LOGGING_CATEGORY(LOG_CosinusProvider, "CosinusProvider")	10	Q_LOGGING_CATEGORY(LOG_CosinusProvider, "CosinusProvider")
11		11
12	std::~~unique~~_ptr<IDataSeries>	12	std::shared_ptr<IDataSeries>
13	CosinusProvider::retrieveData(const DataProviderParameters &parameters) const	13	CosinusProvider::retrieveData(const DataProviderParameters &parameters) const
14	{	14	{
15	auto dateTime = parameters.m_Time;	15	auto dateTime = parameters.m_Time;
16		16
17	// Gets the timerange from the parameters
18	auto start = dateTime.m_TStart;
19	auto end = dateTime.m_TEnd;
20
21
22	// We assure that timerange is valid
23	if (end < start) {
24	std::swap(start, end);
25	}
26
27	// Generates scalar series containing cosinus values (one value per second)
28	auto scalarSeries
29	= std::make_unique<ScalarSeries>(end - start, Unit{QStringLiteral("t"), true}, Unit{});
30
31	auto dataIndex = 0;
32	for (auto time = start; time < end; ++time, ++dataIndex) {
33	scalarSeries->setData(dataIndex, time, std::cos(time));
34	}
35
36	return scalarSeries;
37	}
38
39	void CosinusProvider::requestDataLoading(const QVector<SqpDateTime> &dateTimeList)
40	{
41	// NOTE: Try to use multithread if possible
42	for (const auto &dateTime : dateTimeList) {
43
44	auto scalarSeries = this->retrieveDataSeries(dateTime);
45
46	emit dataProvided(scalarSeries, dateTime);
47	}
48	}
49
50
51	std::shared_ptr<IDataSeries> CosinusProvider::retrieveDataSeries(const SqpDateTime &dateTime)
52	{
53	auto dataIndex = 0;	17	auto dataIndex = 0;
54		18
55	// Gets the timerange from the parameters	19	// Gets the timerange from the parameters
@@ -72,3 +36,12 std::shared_ptr<IDataSeries> CosinusProvider::retrieveDataSeries(const SqpDateTi
72	}	36	}
73	return scalarSeries;	37	return scalarSeries;
74	}	38	}
		39
		40	void CosinusProvider::requestDataLoading(const QVector<SqpDateTime> &dateTimeList)
		41	{
		42	// NOTE: Try to use multithread if possible
		43	for (const auto &dateTime : dateTimeList) {
		44	auto scalarSeries = this->retrieveData(DataProviderParameters{dateTime});
		45	emit dataProvided(scalarSeries, dateTime);
		46	}
		47	}

	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