|
|
e3c6bf5 |
From 3debd23d47d1fcbef76033c739a0b7003824d4ca Mon Sep 17 00:00:00 2001
|
|
|
dbc71fa |
From: Noel Grandin <noel.grandin@collabora.co.uk>
|
|
|
dbc71fa |
Date: Sat, 11 Aug 2018 13:25:09 +0200
|
|
|
dbc71fa |
Subject: [PATCH] Update mdds to 1.4.1
|
|
|
dbc71fa |
|
|
|
dbc71fa |
loplugin:constantparam
|
|
|
dbc71fa |
|
|
|
dbc71fa |
Reviewed-on: https://gerrit.libreoffice.org/58875
|
|
|
dbc71fa |
Tested-by: Jenkins
|
|
|
dbc71fa |
Reviewed-by: Noel Grandin <noel.grandin@collabora.co.uk>
|
|
|
dbc71fa |
(cherry picked from commit bb6f2b12e8f0bbc99a5ca93141d35fd40b043e55)
|
|
|
dbc71fa |
|
|
|
dbc71fa |
Update mdds to 1.4.1.
|
|
|
dbc71fa |
|
|
|
dbc71fa |
The largest change in 1.4.x relevant to the calc code is that the
|
|
|
dbc71fa |
multi_type_matrix::walk() methods now take a copy of the function
|
|
|
dbc71fa |
object rather than a reference, to allow for it to take an inline
|
|
|
dbc71fa |
lambda function. Instead, it does return a instance of the input
|
|
|
dbc71fa |
function object, similar to how std::for_each() behaves.
|
|
|
dbc71fa |
|
|
|
dbc71fa |
In case the function object contains a large data member, try to
|
|
|
dbc71fa |
make it a moveable so that it will get moved rather than copied
|
|
|
dbc71fa |
when going through one of the walk() methods.
|
|
|
dbc71fa |
|
|
|
dbc71fa |
Reviewed-on: https://gerrit.libreoffice.org/59584
|
|
|
dbc71fa |
Tested-by: Jenkins
|
|
|
dbc71fa |
Reviewed-by: Kohei Yoshida <libreoffice@kohei.us>
|
|
|
dbc71fa |
(cherry picked from commit 51f73f35ea61dd81dd3194af50394b98ff1bf8e9)
|
|
|
dbc71fa |
|
|
|
dbc71fa |
mdds 1.4.1 is now a minimum requirement.
|
|
|
dbc71fa |
|
|
|
dbc71fa |
Reviewed-on: https://gerrit.libreoffice.org/59614
|
|
|
dbc71fa |
Tested-by: Jenkins
|
|
|
dbc71fa |
Reviewed-by: Kohei Yoshida <libreoffice@kohei.us>
|
|
|
dbc71fa |
(cherry picked from commit 4d1f735fcf064b18ef2848cc1f5a2a0616b0b33d)
|
|
|
dbc71fa |
|
|
|
dbc71fa |
fd08fc4a2ed75039e5292a35ff08726e0126c77f
|
|
|
dbc71fa |
647bcfbdd8e0417990ed93b25c1bca00f60df709
|
|
|
e3c6bf5 |
|
|
|
e3c6bf5 |
Change-Id: I676a8408e97cc8134009f764736cad68513c89ad
|
|
|
dbc71fa |
---
|
|
|
dbc71fa |
configure.ac | 2 +-
|
|
|
dbc71fa |
download.lst | 4 +-
|
|
|
dbc71fa |
external/mdds/UnpackedTarball_mdds.mk | 3 -
|
|
|
dbc71fa |
external/mdds/c++17.patch | 22 ---
|
|
|
e3c6bf5 |
sc/inc/scmatrix.hxx | 6 +-
|
|
|
dbc71fa |
sc/source/core/tool/interpr3.cxx | 4 +-
|
|
|
e3c6bf5 |
sc/source/core/tool/scmatrix.cxx | 208 +++++++++++++++++++-------
|
|
|
e3c6bf5 |
7 files changed, 161 insertions(+), 88 deletions(-)
|
|
|
dbc71fa |
delete mode 100644 external/mdds/c++17.patch
|
|
|
dbc71fa |
|
|
|
dbc71fa |
diff --git a/configure.ac b/configure.ac
|
|
|
dbc71fa |
index 735ebf2e360a..3ff574a3f24f 100644
|
|
|
dbc71fa |
--- a/configure.ac
|
|
|
dbc71fa |
+++ b/configure.ac
|
|
|
dbc71fa |
@@ -8883,7 +8883,7 @@ AC_SUBST(SYSTEM_BOOST)
|
|
|
dbc71fa |
dnl ===================================================================
|
|
|
dbc71fa |
dnl Check for system mdds
|
|
|
dbc71fa |
dnl ===================================================================
|
|
|
dbc71fa |
-libo_CHECK_SYSTEM_MODULE([mdds], [MDDS], [mdds-1.2 >= 1.2.3], ["-I${WORKDIR}/UnpackedTarball/mdds/include"])
|
|
|
dbc71fa |
+libo_CHECK_SYSTEM_MODULE([mdds], [MDDS], [mdds-1.4 >= 1.4.1], ["-I${WORKDIR}/UnpackedTarball/mdds/include"])
|
|
|
dbc71fa |
|
|
|
dbc71fa |
dnl ===================================================================
|
|
|
dbc71fa |
dnl Check for system glm
|
|
|
dbc71fa |
diff --git a/download.lst b/download.lst
|
|
|
dbc71fa |
index c40bece90e26..d4c145a0cfc9 100644
|
|
|
dbc71fa |
--- a/download.lst
|
|
|
dbc71fa |
+++ b/download.lst
|
|
|
dbc71fa |
@@ -166,8 +166,8 @@ export LXML_SHA256SUM := 940caef1ec7c78e0c34b0f6b94fe42d0f2022915ffc78643d28538a
|
|
|
dbc71fa |
export LXML_TARBALL := lxml-4.1.1.tgz
|
|
|
dbc71fa |
export MARIADB_CONNECTOR_C_SHA256SUM := fd2f751dea049c1907735eb236aeace1d811d6a8218118b00bbaa9b84dc5cd60
|
|
|
dbc71fa |
export MARIADB_CONNECTOR_C_TARBALL := a233181e03d3c307668b4c722d881661-mariadb_client-2.0.0-src.tar.gz
|
|
|
dbc71fa |
-export MDDS_SHA256SUM := dcb8cd2425567a5a5ec164afea475bce57784bca3e352ad4cbdd3d1a7e08e5a1
|
|
|
dbc71fa |
-export MDDS_TARBALL := mdds-1.3.1.tar.bz2
|
|
|
dbc71fa |
+export MDDS_SHA256SUM := 9ac690c37f5f06dc88551405d5daf9d9ad25edf65aae6325b59e905c2ba444c3
|
|
|
dbc71fa |
+export MDDS_TARBALL := mdds-1.4.1.tar.bz2
|
|
|
dbc71fa |
export MDNSRESPONDER_SHA256SUM := 4737cb51378377e11d0edb7bcdd1bec79cbdaa7b27ea09c13e3006e58f8d92c0
|
|
|
dbc71fa |
export MDNSRESPONDER_TARBALL := mDNSResponder-576.30.4.tar.gz
|
|
|
dbc71fa |
export MSPUB_SHA256SUM := ef36c1a1aabb2ba3b0bedaaafe717bf4480be2ba8de6f3894be5fd3702b013ba
|
|
|
dbc71fa |
diff --git a/external/mdds/UnpackedTarball_mdds.mk b/external/mdds/UnpackedTarball_mdds.mk
|
|
|
dbc71fa |
index 4f6db6b24e7b..c015f4c13f5a 100644
|
|
|
dbc71fa |
--- a/external/mdds/UnpackedTarball_mdds.mk
|
|
|
dbc71fa |
+++ b/external/mdds/UnpackedTarball_mdds.mk
|
|
|
dbc71fa |
@@ -13,10 +13,7 @@ $(eval $(call gb_UnpackedTarball_set_tarball,mdds,$(MDDS_TARBALL)))
|
|
|
dbc71fa |
|
|
|
dbc71fa |
$(eval $(call gb_UnpackedTarball_set_patchlevel,mdds,0))
|
|
|
dbc71fa |
|
|
|
dbc71fa |
-# c++17.patch upstreamed as <https://gitlab.com/mdds/mdds/merge_requests/11> "Remove some
|
|
|
dbc71fa |
-# unnecessary uses of obsolete std::unary_function":
|
|
|
dbc71fa |
$(eval $(call gb_UnpackedTarball_add_patches,mdds,\
|
|
|
dbc71fa |
- external/mdds/c++17.patch \
|
|
|
dbc71fa |
))
|
|
|
dbc71fa |
|
|
|
dbc71fa |
# vim: set noet sw=4 ts=4:
|
|
|
dbc71fa |
diff --git a/external/mdds/c++17.patch b/external/mdds/c++17.patch
|
|
|
dbc71fa |
deleted file mode 100644
|
|
|
dbc71fa |
index d96910f34e68..000000000000
|
|
|
dbc71fa |
--- a/external/mdds/c++17.patch
|
|
|
dbc71fa |
+++ /dev/null
|
|
|
dbc71fa |
@@ -1,22 +0,0 @@
|
|
|
dbc71fa |
---- include/mdds/multi_type_matrix.hpp
|
|
|
dbc71fa |
-+++ include/mdds/multi_type_matrix.hpp
|
|
|
dbc71fa |
-@@ -149,7 +149,7 @@
|
|
|
dbc71fa |
-
|
|
|
dbc71fa |
- private:
|
|
|
dbc71fa |
- template<typename _Func>
|
|
|
dbc71fa |
-- struct walk_func : std::unary_function<typename store_type::const_iterator::value_type, void>
|
|
|
dbc71fa |
-+ struct walk_func
|
|
|
dbc71fa |
- {
|
|
|
dbc71fa |
- _Func& m_func;
|
|
|
dbc71fa |
- walk_func(_Func& func) : m_func(func) {}
|
|
|
dbc71fa |
---- include/mdds/multi_type_vector.hpp
|
|
|
dbc71fa |
-+++ include/mdds/multi_type_vector.hpp
|
|
|
dbc71fa |
-@@ -139,7 +139,7 @@
|
|
|
dbc71fa |
- block& operator=(block);
|
|
|
dbc71fa |
- };
|
|
|
dbc71fa |
-
|
|
|
dbc71fa |
-- struct element_block_deleter : public std::unary_function<void, const element_block_type*>
|
|
|
dbc71fa |
-+ struct element_block_deleter
|
|
|
dbc71fa |
- {
|
|
|
dbc71fa |
- void operator() (const element_block_type* p)
|
|
|
dbc71fa |
- {
|
|
|
dbc71fa |
diff --git a/sc/inc/scmatrix.hxx b/sc/inc/scmatrix.hxx
|
|
|
e3c6bf5 |
index 9be335fbc06b..b1bc5e0e3047 100644
|
|
|
dbc71fa |
--- a/sc/inc/scmatrix.hxx
|
|
|
dbc71fa |
+++ b/sc/inc/scmatrix.hxx
|
|
|
dbc71fa |
@@ -399,7 +399,7 @@ public:
|
|
|
dbc71fa |
virtual void DivOp(bool bFlag, double fVal, ScMatrix& rMat) = 0;
|
|
|
dbc71fa |
virtual void PowOp(bool bFlag, double fVal, ScMatrix& rMat) = 0;
|
|
|
dbc71fa |
|
|
|
dbc71fa |
- virtual std::vector<ScMatrix::IterateResult> Collect(bool bTextAsZero, const std::vector<std::unique_ptr<sc::op::Op>>& aOp) = 0;
|
|
|
dbc71fa |
+ virtual std::vector<ScMatrix::IterateResult> Collect(const std::vector<std::unique_ptr<sc::op::Op>>& aOp) = 0;
|
|
|
dbc71fa |
|
|
|
dbc71fa |
virtual void ExecuteOperation(const std::pair<size_t, size_t>& rStartPos, const std::pair<size_t, size_t>& rEndPos,
|
|
|
dbc71fa |
DoubleOpFunction aDoubleFunc, BoolOpFunction aBoolFunc, StringOpFunction aStringFunc,
|
|
|
dbc71fa |
@@ -617,7 +617,7 @@ public:
|
|
|
dbc71fa |
virtual void DivOp(bool bFlag, double fVal, ScMatrix& rMat) override;
|
|
|
dbc71fa |
virtual void PowOp(bool bFlag, double fVal, ScMatrix& rMat) override;
|
|
|
dbc71fa |
|
|
|
dbc71fa |
- virtual std::vector<ScMatrix::IterateResult> Collect(bool bTextAsZero, const std::vector<std::unique_ptr<sc::op::Op>>& aOp) override;
|
|
|
dbc71fa |
+ virtual std::vector<ScMatrix::IterateResult> Collect(const std::vector<std::unique_ptr<sc::op::Op>>& aOp) override;
|
|
|
dbc71fa |
|
|
|
dbc71fa |
virtual void ExecuteOperation(const std::pair<size_t, size_t>& rStartPos, const std::pair<size_t, size_t>& rEndPos,
|
|
|
dbc71fa |
DoubleOpFunction aDoubleFunc, BoolOpFunction aBoolFunc, StringOpFunction aStringFunc,
|
|
|
e3c6bf5 |
@@ -837,7 +837,7 @@ public:
|
|
|
e3c6bf5 |
virtual void DivOp(bool bFlag, double fVal, ScMatrix& rMat) override;
|
|
|
e3c6bf5 |
virtual void PowOp(bool bFlag, double fVal, ScMatrix& rMat) override;
|
|
|
e3c6bf5 |
|
|
|
e3c6bf5 |
- virtual std::vector<ScMatrix::IterateResult> Collect(bool bTextAsZero, const std::vector<std::unique_ptr<sc::op::Op>>& aOp) override;
|
|
|
e3c6bf5 |
+ virtual std::vector<ScMatrix::IterateResult> Collect(const std::vector<std::unique_ptr<sc::op::Op>>& aOp) override;
|
|
|
e3c6bf5 |
|
|
|
e3c6bf5 |
virtual void ExecuteOperation(const std::pair<size_t, size_t>& rStartPos, const std::pair<size_t, size_t>& rEndPos,
|
|
|
e3c6bf5 |
DoubleOpFunction aDoubleFunc, BoolOpFunction aBoolFunc, StringOpFunction aStringFunc,
|
|
|
dbc71fa |
diff --git a/sc/source/core/tool/interpr3.cxx b/sc/source/core/tool/interpr3.cxx
|
|
|
dbc71fa |
index 28e8cd9a9c48..88c0d8353783 100644
|
|
|
dbc71fa |
--- a/sc/source/core/tool/interpr3.cxx
|
|
|
dbc71fa |
+++ b/sc/source/core/tool/interpr3.cxx
|
|
|
dbc71fa |
@@ -2745,12 +2745,12 @@ void ScInterpreter::ScFTest()
|
|
|
dbc71fa |
aOp.emplace_back(new sc::op::Op(0.0, [](double& rAccum, double fVal){rAccum += fVal;}));
|
|
|
dbc71fa |
aOp.emplace_back(new sc::op::Op(0.0, [](double& rAccum, double fVal){rAccum += fVal * fVal;}));
|
|
|
dbc71fa |
|
|
|
dbc71fa |
- auto aVal1 = pMat1->Collect(false, aOp);
|
|
|
dbc71fa |
+ auto aVal1 = pMat1->Collect(aOp);
|
|
|
dbc71fa |
fSum1 = aVal1[0].mfFirst + aVal1[0].mfRest;
|
|
|
dbc71fa |
fSumSqr1 = aVal1[1].mfFirst + aVal1[1].mfRest;
|
|
|
dbc71fa |
fCount1 = aVal1[2].mnCount;
|
|
|
dbc71fa |
|
|
|
dbc71fa |
- auto aVal2 = pMat2->Collect(false, aOp);
|
|
|
dbc71fa |
+ auto aVal2 = pMat2->Collect(aOp);
|
|
|
dbc71fa |
fSum2 = aVal2[0].mfFirst + aVal2[0].mfRest;
|
|
|
dbc71fa |
fSumSqr2 = aVal2[1].mfFirst + aVal2[1].mfRest;
|
|
|
dbc71fa |
fCount2 = aVal2[2].mnCount;
|
|
|
dbc71fa |
diff --git a/sc/source/core/tool/scmatrix.cxx b/sc/source/core/tool/scmatrix.cxx
|
|
|
e3c6bf5 |
index 7f8c8767e917..7dadec9f0b57 100644
|
|
|
dbc71fa |
--- a/sc/source/core/tool/scmatrix.cxx
|
|
|
dbc71fa |
+++ b/sc/source/core/tool/scmatrix.cxx
|
|
|
dbc71fa |
@@ -160,6 +160,12 @@ public:
|
|
|
dbc71fa |
maNewMatValues.reserve(nRow*nCol);
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
|
|
|
dbc71fa |
+ CompareMatrixElemFunc( const CompareMatrixElemFunc& ) = delete;
|
|
|
dbc71fa |
+ CompareMatrixElemFunc& operator= ( const CompareMatrixElemFunc& ) = delete;
|
|
|
dbc71fa |
+
|
|
|
dbc71fa |
+ CompareMatrixElemFunc( CompareMatrixElemFunc&& ) = default;
|
|
|
dbc71fa |
+ CompareMatrixElemFunc& operator= ( CompareMatrixElemFunc&& ) = default;
|
|
|
dbc71fa |
+
|
|
|
dbc71fa |
void operator() (const MatrixImplType::element_block_node_type& node)
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
switch (node.type)
|
|
|
dbc71fa |
@@ -323,7 +329,7 @@ public:
|
|
|
dbc71fa |
const ScFullMatrix::EmptyOpFunction& aEmptyFunc) const;
|
|
|
dbc71fa |
|
|
|
dbc71fa |
template<typename T>
|
|
|
dbc71fa |
- std::vector<ScMatrix::IterateResult> ApplyCollectOperation(bool bTextAsZero, const std::vector<std::unique_ptr<T>>& aOp);
|
|
|
dbc71fa |
+ std::vector<ScMatrix::IterateResult> ApplyCollectOperation(const std::vector<std::unique_ptr<T>>& aOp);
|
|
|
dbc71fa |
|
|
|
dbc71fa |
void MatConcat(SCSIZE nMaxCol, SCSIZE nMaxRow, const ScMatrixRef& xMat1, const ScMatrixRef& xMat2,
|
|
|
dbc71fa |
SvNumberFormatter& rFormatter, svl::SharedStringPool& rPool);
|
|
|
dbc71fa |
@@ -979,7 +985,7 @@ void ScMatrixImpl::CompareEqual()
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
MatrixImplType::size_pair_type aSize = maMat.size();
|
|
|
dbc71fa |
CompareMatrixElemFunc<ElemEqualZero> aFunc(aSize.row, aSize.column);
|
|
|
dbc71fa |
- maMat.walk(aFunc);
|
|
|
dbc71fa |
+ aFunc = maMat.walk(std::move(aFunc));
|
|
|
dbc71fa |
aFunc.swap(maMat);
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
|
|
|
dbc71fa |
@@ -987,7 +993,7 @@ void ScMatrixImpl::CompareNotEqual()
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
MatrixImplType::size_pair_type aSize = maMat.size();
|
|
|
dbc71fa |
CompareMatrixElemFunc<ElemNotEqualZero> aFunc(aSize.row, aSize.column);
|
|
|
dbc71fa |
- maMat.walk(aFunc);
|
|
|
dbc71fa |
+ aFunc = maMat.walk(std::move(aFunc));
|
|
|
dbc71fa |
aFunc.swap(maMat);
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
|
|
|
dbc71fa |
@@ -995,7 +1001,7 @@ void ScMatrixImpl::CompareLess()
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
MatrixImplType::size_pair_type aSize = maMat.size();
|
|
|
dbc71fa |
CompareMatrixElemFunc<ElemLessZero> aFunc(aSize.row, aSize.column);
|
|
|
dbc71fa |
- maMat.walk(aFunc);
|
|
|
dbc71fa |
+ aFunc = maMat.walk(std::move(aFunc));
|
|
|
dbc71fa |
aFunc.swap(maMat);
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
|
|
|
dbc71fa |
@@ -1003,7 +1009,7 @@ void ScMatrixImpl::CompareGreater()
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
MatrixImplType::size_pair_type aSize = maMat.size();
|
|
|
dbc71fa |
CompareMatrixElemFunc<ElemGreaterZero> aFunc(aSize.row, aSize.column);
|
|
|
dbc71fa |
- maMat.walk(aFunc);
|
|
|
dbc71fa |
+ aFunc = maMat.walk(std::move(aFunc));
|
|
|
dbc71fa |
aFunc.swap(maMat);
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
|
|
|
dbc71fa |
@@ -1011,7 +1017,7 @@ void ScMatrixImpl::CompareLessEqual()
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
MatrixImplType::size_pair_type aSize = maMat.size();
|
|
|
dbc71fa |
CompareMatrixElemFunc<ElemLessEqualZero> aFunc(aSize.row, aSize.column);
|
|
|
dbc71fa |
- maMat.walk(aFunc);
|
|
|
dbc71fa |
+ aFunc = maMat.walk(std::move(aFunc));
|
|
|
dbc71fa |
aFunc.swap(maMat);
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
|
|
|
dbc71fa |
@@ -1019,7 +1025,7 @@ void ScMatrixImpl::CompareGreaterEqual()
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
MatrixImplType::size_pair_type aSize = maMat.size();
|
|
|
dbc71fa |
CompareMatrixElemFunc<ElemGreaterEqualZero> aFunc(aSize.row, aSize.column);
|
|
|
dbc71fa |
- maMat.walk(aFunc);
|
|
|
dbc71fa |
+ aFunc = maMat.walk(std::move(aFunc));
|
|
|
dbc71fa |
aFunc.swap(maMat);
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
|
|
|
dbc71fa |
@@ -1174,21 +1180,34 @@ public:
|
|
|
dbc71fa |
template<typename Op>
|
|
|
dbc71fa |
class WalkElementBlocksMultipleValues
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
- const std::vector<std::unique_ptr<Op>>& maOp;
|
|
|
dbc71fa |
+ const std::vector<std::unique_ptr<Op>>* mpOp;
|
|
|
dbc71fa |
std::vector<ScMatrix::IterateResult> maRes;
|
|
|
dbc71fa |
bool mbFirst:1;
|
|
|
dbc71fa |
- bool mbTextAsZero:1;
|
|
|
dbc71fa |
public:
|
|
|
dbc71fa |
- WalkElementBlocksMultipleValues(bool bTextAsZero, const std::vector<std::unique_ptr<Op>>& aOp) :
|
|
|
dbc71fa |
- maOp(aOp), mbFirst(true), mbTextAsZero(bTextAsZero)
|
|
|
dbc71fa |
+ WalkElementBlocksMultipleValues(const std::vector<std::unique_ptr<Op>>& aOp) :
|
|
|
dbc71fa |
+ mpOp(&aOp), mbFirst(true)
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
- for (const auto& rpOp : maOp)
|
|
|
dbc71fa |
+ for (const auto& rpOp : *mpOp)
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
maRes.emplace_back(rpOp->mInitVal, rpOp->mInitVal, 0);
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
maRes.emplace_back(0.0, 0.0, 0); // count
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
|
|
|
dbc71fa |
+ WalkElementBlocksMultipleValues( const WalkElementBlocksMultipleValues& ) = delete;
|
|
|
dbc71fa |
+ WalkElementBlocksMultipleValues& operator= ( const WalkElementBlocksMultipleValues& ) = delete;
|
|
|
dbc71fa |
+
|
|
|
dbc71fa |
+ WalkElementBlocksMultipleValues( WalkElementBlocksMultipleValues&& r ) :
|
|
|
dbc71fa |
+ mpOp(r.mpOp), maRes(std::move(r.maRes)), mbFirst(r.mbFirst) {}
|
|
|
dbc71fa |
+
|
|
|
dbc71fa |
+ WalkElementBlocksMultipleValues& operator= ( WalkElementBlocksMultipleValues&& r )
|
|
|
dbc71fa |
+ {
|
|
|
dbc71fa |
+ mpOp = r.mpOp;
|
|
|
dbc71fa |
+ maRes = std::move(r.maRes);
|
|
|
dbc71fa |
+ mbFirst = r.mbFirst;
|
|
|
dbc71fa |
+ return *this;
|
|
|
dbc71fa |
+ }
|
|
|
dbc71fa |
+
|
|
|
dbc71fa |
const std::vector<ScMatrix::IterateResult>& getResult() const { return maRes; }
|
|
|
dbc71fa |
|
|
|
dbc71fa |
void operator() (const MatrixImplType::element_block_node_type& node)
|
|
|
dbc71fa |
@@ -1205,17 +1224,17 @@ public:
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
if (mbFirst)
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
- for (auto i = 0u; i < maOp.size(); ++i)
|
|
|
dbc71fa |
+ for (auto i = 0u; i < mpOp->size(); ++i)
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
- (*maOp[i])(maRes[i].mfFirst, *it);
|
|
|
dbc71fa |
+ (*(*mpOp)[i])(maRes[i].mfFirst, *it);
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
mbFirst = false;
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
else
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
- for (auto i = 0u; i < maOp.size(); ++i)
|
|
|
dbc71fa |
+ for (auto i = 0u; i < mpOp->size(); ++i)
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
- (*maOp[i])(maRes[i].mfRest, *it);
|
|
|
dbc71fa |
+ (*(*mpOp)[i])(maRes[i].mfRest, *it);
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
@@ -1232,17 +1251,17 @@ public:
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
if (mbFirst)
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
- for (auto i = 0u; i < maOp.size(); ++i)
|
|
|
dbc71fa |
+ for (auto i = 0u; i < mpOp->size(); ++i)
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
- (*maOp[i])(maRes[i].mfFirst, *it);
|
|
|
dbc71fa |
+ (*(*mpOp)[i])(maRes[i].mfFirst, *it);
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
mbFirst = false;
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
else
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
- for (auto i = 0u; i < maOp.size(); ++i)
|
|
|
dbc71fa |
+ for (auto i = 0u; i < mpOp->size(); ++i)
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
- (*maOp[i])(maRes[i].mfRest, *it);
|
|
|
dbc71fa |
+ (*(*mpOp)[i])(maRes[i].mfRest, *it);
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
@@ -1250,9 +1269,6 @@ public:
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
break;
|
|
|
dbc71fa |
case mdds::mtm::element_string:
|
|
|
dbc71fa |
- if (mbTextAsZero)
|
|
|
dbc71fa |
- maRes.back().mnCount += node.size;
|
|
|
dbc71fa |
- break;
|
|
|
dbc71fa |
case mdds::mtm::element_empty:
|
|
|
dbc71fa |
default:
|
|
|
dbc71fa |
;
|
|
|
dbc71fa |
@@ -1310,8 +1326,8 @@ template<typename Type>
|
|
|
dbc71fa |
class WalkAndMatchElements
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
Type maMatchValue;
|
|
|
dbc71fa |
- const size_t mnStartIndex;
|
|
|
dbc71fa |
- const size_t mnStopIndex;
|
|
|
dbc71fa |
+ size_t mnStartIndex;
|
|
|
dbc71fa |
+ size_t mnStopIndex;
|
|
|
dbc71fa |
size_t mnResult;
|
|
|
dbc71fa |
size_t mnIndex;
|
|
|
dbc71fa |
|
|
|
dbc71fa |
@@ -1669,6 +1685,24 @@ public:
|
|
|
dbc71fa |
maResValues.reserve(nResSize);
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
|
|
|
dbc71fa |
+ CompareMatrixFunc( const CompareMatrixFunc& ) = delete;
|
|
|
dbc71fa |
+ CompareMatrixFunc& operator= ( const CompareMatrixFunc& ) = delete;
|
|
|
dbc71fa |
+
|
|
|
dbc71fa |
+ CompareMatrixFunc( CompareMatrixFunc&& r ) :
|
|
|
dbc71fa |
+ mrComp(r.mrComp),
|
|
|
dbc71fa |
+ mnMatPos(r.mnMatPos),
|
|
|
dbc71fa |
+ mpOptions(r.mpOptions),
|
|
|
dbc71fa |
+ maResValues(std::move(r.maResValues)) {}
|
|
|
dbc71fa |
+
|
|
|
dbc71fa |
+ CompareMatrixFunc& operator= ( CompareMatrixFunc&& r )
|
|
|
dbc71fa |
+ {
|
|
|
dbc71fa |
+ mrComp = r.mrComp;
|
|
|
dbc71fa |
+ mnMatPos = r.mnMatPos;
|
|
|
dbc71fa |
+ mpOptions = r.mpOptions;
|
|
|
dbc71fa |
+ maResValues = std::move(r.maResValues);
|
|
|
dbc71fa |
+ return *this;
|
|
|
dbc71fa |
+ }
|
|
|
dbc71fa |
+
|
|
|
dbc71fa |
void operator() (const MatrixImplType::element_block_node_type& node)
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
sc::Compare::Cell& rCell = mrComp.maCells[mnMatPos];
|
|
|
dbc71fa |
@@ -1777,6 +1811,24 @@ public:
|
|
|
dbc71fa |
maResValues.reserve(nResSize);
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
|
|
|
dbc71fa |
+ CompareMatrixToNumericFunc( const CompareMatrixToNumericFunc& ) = delete;
|
|
|
dbc71fa |
+ CompareMatrixToNumericFunc& operator= ( const CompareMatrixToNumericFunc& ) = delete;
|
|
|
dbc71fa |
+
|
|
|
dbc71fa |
+ CompareMatrixToNumericFunc( CompareMatrixToNumericFunc&& r ) :
|
|
|
dbc71fa |
+ mrComp(r.mrComp),
|
|
|
dbc71fa |
+ mfRightValue(r.mfRightValue),
|
|
|
dbc71fa |
+ mpOptions(r.mpOptions),
|
|
|
dbc71fa |
+ maResValues(std::move(r.maResValues)) {}
|
|
|
dbc71fa |
+
|
|
|
dbc71fa |
+ CompareMatrixToNumericFunc& operator= ( CompareMatrixToNumericFunc&& r )
|
|
|
dbc71fa |
+ {
|
|
|
dbc71fa |
+ mrComp = r.mrComp;
|
|
|
dbc71fa |
+ mfRightValue = r.mfRightValue;
|
|
|
dbc71fa |
+ mpOptions = r.mpOptions;
|
|
|
dbc71fa |
+ maResValues = std::move(r.maResValues);
|
|
|
dbc71fa |
+ return *this;
|
|
|
dbc71fa |
+ }
|
|
|
dbc71fa |
+
|
|
|
dbc71fa |
void operator() (const MatrixImplType::element_block_node_type& node)
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
sc::Compare::Cell& rCell = mrComp.maCells[0];
|
|
|
dbc71fa |
@@ -1840,6 +1892,17 @@ class ToDoubleArray
|
|
|
dbc71fa |
double mfNaN;
|
|
|
dbc71fa |
bool mbEmptyAsZero;
|
|
|
dbc71fa |
|
|
|
dbc71fa |
+ void moveArray( ToDoubleArray& r )
|
|
|
dbc71fa |
+ {
|
|
|
dbc71fa |
+ // Re-create the iterator from the new array after the array has been
|
|
|
dbc71fa |
+ // moved, to ensure that the iterator points to a valid array
|
|
|
dbc71fa |
+ // position.
|
|
|
dbc71fa |
+ size_t n = std::distance(r.maArray.begin(), r.miPos);
|
|
|
dbc71fa |
+ maArray = std::move(r.maArray);
|
|
|
dbc71fa |
+ miPos = maArray.begin();
|
|
|
dbc71fa |
+ std::advance(miPos, n);
|
|
|
dbc71fa |
+ }
|
|
|
dbc71fa |
+
|
|
|
dbc71fa |
public:
|
|
|
dbc71fa |
ToDoubleArray( size_t nSize, bool bEmptyAsZero ) :
|
|
|
dbc71fa |
maArray(nSize, 0.0), miPos(maArray.begin()), mbEmptyAsZero(bEmptyAsZero)
|
|
|
dbc71fa |
@@ -1847,6 +1910,23 @@ public:
|
|
|
dbc71fa |
mfNaN = CreateDoubleError( FormulaError::ElementNaN);
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
|
|
|
dbc71fa |
+ ToDoubleArray( const ToDoubleArray& ) = delete;
|
|
|
dbc71fa |
+ ToDoubleArray& operator= ( const ToDoubleArray& ) = delete;
|
|
|
dbc71fa |
+
|
|
|
dbc71fa |
+ ToDoubleArray( ToDoubleArray&& r ) :
|
|
|
dbc71fa |
+ mfNaN(r.mfNaN), mbEmptyAsZero(r.mbEmptyAsZero)
|
|
|
dbc71fa |
+ {
|
|
|
dbc71fa |
+ moveArray(r);
|
|
|
dbc71fa |
+ }
|
|
|
dbc71fa |
+
|
|
|
dbc71fa |
+ ToDoubleArray& operator= ( ToDoubleArray&& r )
|
|
|
dbc71fa |
+ {
|
|
|
dbc71fa |
+ mfNaN = r.mfNaN;
|
|
|
dbc71fa |
+ mbEmptyAsZero = r.mbEmptyAsZero;
|
|
|
dbc71fa |
+ moveArray(r);
|
|
|
dbc71fa |
+ return *this;
|
|
|
dbc71fa |
+ }
|
|
|
dbc71fa |
+
|
|
|
dbc71fa |
void operator() (const MatrixImplType::element_block_node_type& node)
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
using namespace mdds::mtv;
|
|
|
dbc71fa |
@@ -1917,6 +1997,12 @@ public:
|
|
|
dbc71fa |
mfNaN = CreateDoubleError( FormulaError::ElementNaN);
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
|
|
|
dbc71fa |
+ MergeDoubleArrayFunc( const MergeDoubleArrayFunc& ) = delete;
|
|
|
dbc71fa |
+ MergeDoubleArrayFunc& operator= ( const MergeDoubleArrayFunc& ) = delete;
|
|
|
dbc71fa |
+
|
|
|
dbc71fa |
+ MergeDoubleArrayFunc( MergeDoubleArrayFunc&& ) = default;
|
|
|
dbc71fa |
+ MergeDoubleArrayFunc& operator= ( MergeDoubleArrayFunc&& ) = default;
|
|
|
dbc71fa |
+
|
|
|
dbc71fa |
void operator() (const MatrixImplType::element_block_node_type& node)
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
using namespace mdds::mtv;
|
|
|
dbc71fa |
@@ -1982,7 +2068,7 @@ template<typename TOp>
|
|
|
dbc71fa |
ScMatrix::IterateResult GetValueWithCount(bool bTextAsZero, const MatrixImplType& maMat)
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
WalkElementBlocks<TOp> aFunc(bTextAsZero);
|
|
|
dbc71fa |
- maMat.walk(aFunc);
|
|
|
dbc71fa |
+ aFunc = maMat.walk(aFunc);
|
|
|
dbc71fa |
return aFunc.getResult();
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
|
|
|
dbc71fa |
@@ -2006,49 +2092,49 @@ ScMatrix::IterateResult ScMatrixImpl::Product(bool bTextAsZero) const
|
|
|
dbc71fa |
size_t ScMatrixImpl::Count(bool bCountStrings, bool bCountErrors) const
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
CountElements aFunc(bCountStrings, bCountErrors);
|
|
|
dbc71fa |
- maMat.walk(aFunc);
|
|
|
dbc71fa |
+ aFunc = maMat.walk(aFunc);
|
|
|
dbc71fa |
return aFunc.getCount();
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
|
|
|
dbc71fa |
size_t ScMatrixImpl::MatchDoubleInColumns(double fValue, size_t nCol1, size_t nCol2) const
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
WalkAndMatchElements<double> aFunc(fValue, maMat.size(), nCol1, nCol2);
|
|
|
dbc71fa |
- maMat.walk(aFunc);
|
|
|
dbc71fa |
+ aFunc = maMat.walk(aFunc);
|
|
|
dbc71fa |
return aFunc.getMatching();
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
|
|
|
dbc71fa |
size_t ScMatrixImpl::MatchStringInColumns(const svl::SharedString& rStr, size_t nCol1, size_t nCol2) const
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
WalkAndMatchElements<svl::SharedString> aFunc(rStr, maMat.size(), nCol1, nCol2);
|
|
|
dbc71fa |
- maMat.walk(aFunc);
|
|
|
dbc71fa |
+ aFunc = maMat.walk(aFunc);
|
|
|
dbc71fa |
return aFunc.getMatching();
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
|
|
|
dbc71fa |
double ScMatrixImpl::GetMaxValue( bool bTextAsZero ) const
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
CalcMaxMinValue<MaxOp> aFunc(bTextAsZero);
|
|
|
dbc71fa |
- maMat.walk(aFunc);
|
|
|
dbc71fa |
+ aFunc = maMat.walk(aFunc);
|
|
|
dbc71fa |
return aFunc.getValue();
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
|
|
|
dbc71fa |
double ScMatrixImpl::GetMinValue( bool bTextAsZero ) const
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
CalcMaxMinValue<MinOp> aFunc(bTextAsZero);
|
|
|
dbc71fa |
- maMat.walk(aFunc);
|
|
|
dbc71fa |
+ aFunc = maMat.walk(aFunc);
|
|
|
dbc71fa |
return aFunc.getValue();
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
|
|
|
dbc71fa |
double ScMatrixImpl::GetGcd() const
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
CalcGcdLcm<Gcd> aFunc;
|
|
|
dbc71fa |
- maMat.walk(aFunc);
|
|
|
dbc71fa |
+ aFunc = maMat.walk(aFunc);
|
|
|
dbc71fa |
return aFunc.getResult();
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
|
|
|
dbc71fa |
double ScMatrixImpl::GetLcm() const
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
CalcGcdLcm<Lcm> aFunc;
|
|
|
dbc71fa |
- maMat.walk(aFunc);
|
|
|
dbc71fa |
+ aFunc = maMat.walk(aFunc);
|
|
|
dbc71fa |
return aFunc.getResult();
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
|
|
|
dbc71fa |
@@ -2065,7 +2151,7 @@ ScMatrixRef ScMatrixImpl::CompareMatrix(
|
|
|
dbc71fa |
// function object that has much less branching for much better
|
|
|
dbc71fa |
// performance.
|
|
|
dbc71fa |
CompareMatrixToNumericFunc aFunc(nSize, rComp, rComp.maCells[1].mfValue, pOptions);
|
|
|
dbc71fa |
- maMat.walk(aFunc);
|
|
|
dbc71fa |
+ aFunc = maMat.walk(std::move(aFunc));
|
|
|
dbc71fa |
|
|
|
dbc71fa |
// We assume the result matrix has the same dimension as this matrix.
|
|
|
dbc71fa |
const std::vector<double>& rResVal = aFunc.getValues();
|
|
|
dbc71fa |
@@ -2077,7 +2163,7 @@ ScMatrixRef ScMatrixImpl::CompareMatrix(
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
|
|
|
dbc71fa |
CompareMatrixFunc aFunc(nSize, rComp, nMatPos, pOptions);
|
|
|
dbc71fa |
- maMat.walk(aFunc);
|
|
|
dbc71fa |
+ aFunc = maMat.walk(std::move(aFunc));
|
|
|
dbc71fa |
|
|
|
dbc71fa |
// We assume the result matrix has the same dimension as this matrix.
|
|
|
dbc71fa |
const std::vector<double>& rResVal = aFunc.getValues();
|
|
|
dbc71fa |
@@ -2091,7 +2177,7 @@ void ScMatrixImpl::GetDoubleArray( std::vector<double>& rArray, bool bEmptyAsZer
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
MatrixImplType::size_pair_type aSize = maMat.size();
|
|
|
dbc71fa |
ToDoubleArray aFunc(aSize.row*aSize.column, bEmptyAsZero);
|
|
|
dbc71fa |
- maMat.walk(aFunc);
|
|
|
dbc71fa |
+ aFunc = maMat.walk(std::move(aFunc));
|
|
|
dbc71fa |
aFunc.swap(rArray);
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
|
|
|
dbc71fa |
@@ -2107,7 +2193,7 @@ void ScMatrixImpl::MergeDoubleArray( std::vector<double>& rArray, ScFullMatrix::
|
|
|
dbc71fa |
case ScFullMatrix::Mul:
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
MergeDoubleArrayFunc<ArrayMul> aFunc(rArray);
|
|
|
dbc71fa |
- maMat.walk(aFunc);
|
|
|
dbc71fa |
+ aFunc = maMat.walk(std::move(aFunc));
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
break;
|
|
|
dbc71fa |
default:
|
|
|
dbc71fa |
@@ -2329,16 +2415,26 @@ struct MatrixOpWrapper
|
|
|
dbc71fa |
private:
|
|
|
dbc71fa |
MatrixImplType& mrMat;
|
|
|
dbc71fa |
MatrixImplType::position_type pos;
|
|
|
dbc71fa |
- T maOp;
|
|
|
dbc71fa |
+ const T* mpOp;
|
|
|
dbc71fa |
|
|
|
dbc71fa |
public:
|
|
|
dbc71fa |
- MatrixOpWrapper(MatrixImplType& rMat, T const & aOp):
|
|
|
dbc71fa |
+ MatrixOpWrapper(MatrixImplType& rMat, const T& aOp):
|
|
|
dbc71fa |
mrMat(rMat),
|
|
|
dbc71fa |
pos(rMat.position(0,0)),
|
|
|
dbc71fa |
- maOp(aOp)
|
|
|
dbc71fa |
+ mpOp(&aOp)
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
|
|
|
dbc71fa |
+ MatrixOpWrapper( const MatrixOpWrapper& r ) : mrMat(r.mrMat), pos(r.pos), mpOp(r.mpOp) {}
|
|
|
dbc71fa |
+
|
|
|
dbc71fa |
+ MatrixOpWrapper& operator= ( const MatrixOpWrapper& r )
|
|
|
dbc71fa |
+ {
|
|
|
dbc71fa |
+ mrMat = r.mrMat;
|
|
|
dbc71fa |
+ pos = r.pos;
|
|
|
dbc71fa |
+ mpOp = r.mpOp;
|
|
|
dbc71fa |
+ return *this;
|
|
|
dbc71fa |
+ }
|
|
|
dbc71fa |
+
|
|
|
dbc71fa |
void operator()(const MatrixImplType::element_block_node_type& node)
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
switch (node.type)
|
|
|
dbc71fa |
@@ -2349,7 +2445,7 @@ public:
|
|
|
dbc71fa |
|
|
|
dbc71fa |
block_type::const_iterator it = block_type::begin(*node.data);
|
|
|
dbc71fa |
block_type::const_iterator itEnd = block_type::end(*node.data);
|
|
|
dbc71fa |
- MatrixIteratorWrapper<block_type, T, typename T::number_value_type> aFunc(it, itEnd, maOp);
|
|
|
dbc71fa |
+ MatrixIteratorWrapper<block_type, T, typename T::number_value_type> aFunc(it, itEnd, *mpOp);
|
|
|
dbc71fa |
pos = mrMat.set(pos,aFunc.begin(), aFunc.end());
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
break;
|
|
|
dbc71fa |
@@ -2360,7 +2456,7 @@ public:
|
|
|
dbc71fa |
block_type::const_iterator it = block_type::begin(*node.data);
|
|
|
dbc71fa |
block_type::const_iterator itEnd = block_type::end(*node.data);
|
|
|
dbc71fa |
|
|
|
dbc71fa |
- MatrixIteratorWrapper<block_type, T, typename T::number_value_type> aFunc(it, itEnd, maOp);
|
|
|
dbc71fa |
+ MatrixIteratorWrapper<block_type, T, typename T::number_value_type> aFunc(it, itEnd, *mpOp);
|
|
|
dbc71fa |
pos = mrMat.set(pos, aFunc.begin(), aFunc.end());
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
break;
|
|
|
dbc71fa |
@@ -2371,17 +2467,17 @@ public:
|
|
|
dbc71fa |
block_type::const_iterator it = block_type::begin(*node.data);
|
|
|
dbc71fa |
block_type::const_iterator itEnd = block_type::end(*node.data);
|
|
|
dbc71fa |
|
|
|
dbc71fa |
- MatrixIteratorWrapper<block_type, T, typename T::number_value_type> aFunc(it, itEnd, maOp);
|
|
|
dbc71fa |
+ MatrixIteratorWrapper<block_type, T, typename T::number_value_type> aFunc(it, itEnd, *mpOp);
|
|
|
dbc71fa |
pos = mrMat.set(pos, aFunc.begin(), aFunc.end());
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
break;
|
|
|
dbc71fa |
case mdds::mtm::element_empty:
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
- if (maOp.useFunctionForEmpty())
|
|
|
dbc71fa |
+ if (mpOp->useFunctionForEmpty())
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
std::vector<char> aVec(node.size);
|
|
|
dbc71fa |
MatrixIteratorWrapper<std::vector<char>, T, typename T::number_value_type>
|
|
|
dbc71fa |
- aFunc(aVec.begin(), aVec.end(), maOp);
|
|
|
dbc71fa |
+ aFunc(aVec.begin(), aVec.end(), *mpOp);
|
|
|
dbc71fa |
pos = mrMat.set(pos, aFunc.begin(), aFunc.end());
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
@@ -2397,14 +2493,14 @@ template<typename T>
|
|
|
dbc71fa |
void ScMatrixImpl::ApplyOperation(T aOp, ScMatrixImpl& rMat)
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
MatrixOpWrapper<T> aFunc(rMat.maMat, aOp);
|
|
|
dbc71fa |
- maMat.walk(aFunc);
|
|
|
dbc71fa |
+ aFunc = maMat.walk(aFunc);
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
|
|
|
dbc71fa |
template<typename T>
|
|
|
dbc71fa |
-std::vector<ScMatrix::IterateResult> ScMatrixImpl::ApplyCollectOperation(bool bTextAsZero, const std::vector<std::unique_ptr<T>>& aOp)
|
|
|
dbc71fa |
+std::vector<ScMatrix::IterateResult> ScMatrixImpl::ApplyCollectOperation(const std::vector<std::unique_ptr<T>>& aOp)
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
- WalkElementBlocksMultipleValues<T> aFunc(bTextAsZero, aOp);
|
|
|
dbc71fa |
- maMat.walk(aFunc);
|
|
|
dbc71fa |
+ WalkElementBlocksMultipleValues<T> aFunc(aOp);
|
|
|
dbc71fa |
+ aFunc = maMat.walk(std::move(aFunc));
|
|
|
dbc71fa |
return aFunc.getResult();
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
|
|
|
dbc71fa |
@@ -2544,8 +2640,10 @@ void ScMatrixImpl::ExecuteOperation(const std::pair<size_t, size_t>& rStartPos,
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
WalkElementBlockOperation aFunc(maMat.size().row,
|
|
|
dbc71fa |
aDoubleFunc, aBoolFunc, aStringFunc, aEmptyFunc);
|
|
|
dbc71fa |
- maMat.walk(aFunc, MatrixImplType::size_pair_type(rStartPos.first, rStartPos.second),
|
|
|
dbc71fa |
- MatrixImplType::size_pair_type(rEndPos.first, rEndPos.second));
|
|
|
dbc71fa |
+ aFunc = maMat.walk(
|
|
|
dbc71fa |
+ aFunc,
|
|
|
dbc71fa |
+ MatrixImplType::size_pair_type(rStartPos.first, rStartPos.second),
|
|
|
dbc71fa |
+ MatrixImplType::size_pair_type(rEndPos.first, rEndPos.second));
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
|
|
|
dbc71fa |
#if DEBUG_MATRIX
|
|
|
dbc71fa |
@@ -3452,9 +3550,9 @@ void ScFullMatrix::ExecuteOperation(const std::pair<size_t, size_t>& rStartPos,
|
|
|
dbc71fa |
pImpl->ExecuteOperation(rStartPos, rEndPos, aDoubleFunc, aBoolFunc, aStringFunc, aEmptyFunc);
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
|
|
|
dbc71fa |
-std::vector<ScMatrix::IterateResult> ScFullMatrix::Collect(bool bTextAsZero, const std::vector<std::unique_ptr<sc::op::Op>>& aOp)
|
|
|
dbc71fa |
+std::vector<ScMatrix::IterateResult> ScFullMatrix::Collect(const std::vector<std::unique_ptr<sc::op::Op>>& aOp)
|
|
|
dbc71fa |
{
|
|
|
dbc71fa |
- return pImpl->ApplyCollectOperation(bTextAsZero, aOp);
|
|
|
dbc71fa |
+ return pImpl->ApplyCollectOperation(aOp);
|
|
|
dbc71fa |
}
|
|
|
dbc71fa |
|
|
|
dbc71fa |
ScFullMatrix& ScFullMatrix::operator+= ( const ScFullMatrix& r )
|
|
|
e3c6bf5 |
@@ -4216,10 +4314,10 @@ void ScVectorRefMatrix::PowOp(bool bFlag, double fVal, ScMatrix& rMat)
|
|
|
e3c6bf5 |
mpFullMatrix->PowOp(bFlag, fVal, rMat);
|
|
|
e3c6bf5 |
}
|
|
|
e3c6bf5 |
|
|
|
e3c6bf5 |
-std::vector<ScMatrix::IterateResult> ScVectorRefMatrix::Collect(bool bTextAsZero, const std::vector<std::unique_ptr<sc::op::Op>>& aOp)
|
|
|
e3c6bf5 |
+std::vector<ScMatrix::IterateResult> ScVectorRefMatrix::Collect(const std::vector<std::unique_ptr<sc::op::Op>>& aOp)
|
|
|
e3c6bf5 |
{
|
|
|
e3c6bf5 |
ensureFullMatrix();
|
|
|
e3c6bf5 |
- return mpFullMatrix->Collect(bTextAsZero, aOp);
|
|
|
e3c6bf5 |
+ return mpFullMatrix->Collect(aOp);
|
|
|
e3c6bf5 |
}
|
|
|
e3c6bf5 |
|
|
|
e3c6bf5 |
void ScVectorRefMatrix::ExecuteOperation(const std::pair<size_t, size_t>& rStartPos,
|
|
|
dbc71fa |
--
|
|
|
dbc71fa |
2.17.1
|
|
|
dbc71fa |
|