From 5b636ee921775dd0dad362321a1c9b4207511fa3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carsten=20Gr=C3=A4ser?= <graeser@dune-project.org>
Date: Mon, 12 Dec 2022 12:22:53 +0100
Subject: [PATCH] Improve specializations of Hybrid::size()
The interfaces tested subsequently for `Hybrid::size(const T& t)` are now
* standard tuple-like interface `std::tuple_size<T>::value` (e.g. needed for `std::tuple`),
* static constexpr `T::size()` (e.g. needed for `Dune::TupleVector`),
* static constexpr `T::N()` (e.g. needed for `Dune::MultiTypeBlockMatrix`),
* dynamic member function `t.N()` (e.g. needed for `Dune::Matrix`),
* dynamic member function `t.size()` (e.g. needed for `std::vector`).
Unfortunately the matrix interface is rather inconsistent.
While `Dune::DenseMatrix` provides a dyanmic `size()` method, the dynamic dense matrix
`Dune::Matrix` does not. The only consistent interface to get the number of rows is the
`N()` method which exists in dynamic (e.g. `Dune::Matrix`) and constexpr static
(e.g. `Dune::MultiTypeBlockMatrix`) flavour.
Hence to support matrices consistently, we must add support for those cases, too.
For the static constexpr `N()`, this was made neccessary, because of the removal of
static consexpr `Dune::MultiTypeBlockMatrix::size()`. The dynamic case should be
added for consistency to also support `Dune::Matrix` and `Dune::BCRSMatrix`.
As a by-product, this allows to get rid of the `FieldMatrix` specialization.
---
dune/common/hybridutilities.hh | 26 +++++++++++++++++---------
1 file changed, 17 insertions(+), 9 deletions(-)
diff --git a/dune/common/hybridutilities.hh b/dune/common/hybridutilities.hh
index b40d6e1a2..e0cc906d6 100644
--- a/dune/common/hybridutilities.hh
+++ b/dune/common/hybridutilities.hh
@@ -23,30 +23,38 @@ namespace Hybrid {
namespace Impl {
// Try if tuple_size is implemented for class
- template<class T, int i>
- constexpr auto size(const Dune::FieldVector<T, i>&, const PriorityTag<5>&)
- -> decltype(std::integral_constant<std::size_t,i>())
+ template<class T>
+ constexpr auto size(const T&, const PriorityTag<4>&)
+ -> decltype(std::integral_constant<std::size_t,std::tuple_size<T>::value>())
{
return {};
}
- // Try if tuple_size is implemented for class
+ // Try if there's a static constexpr size()
template<class T>
constexpr auto size(const T&, const PriorityTag<3>&)
- -> decltype(std::integral_constant<std::size_t,std::tuple_size<T>::value>())
+ -> decltype(std::integral_constant<std::size_t,T::size()>())
{
return {};
}
- // Try if there's a static constexpr size()
+ // Try if there's a static constexpr N()
template<class T>
- constexpr auto size(const T&, const PriorityTag<1>&)
- -> decltype(std::integral_constant<std::size_t,T::size()>())
+ constexpr auto size(const T&, const PriorityTag<2>&)
+ -> decltype(std::integral_constant<std::size_t,T::N()>())
{
return {};
}
- // As a last resort try if there's a static constexpr size()
+ // Try if there's a non-static N()
+ template<class T>
+ constexpr auto size(const T& t, const PriorityTag<1>&)
+ -> decltype(t.N())
+ {
+ return t.N();
+ }
+
+ // As a last resort try if there's a non-static size()
template<class T>
constexpr auto size(const T& t, const PriorityTag<0>&)
{
--
GitLab