#include <tuple>#include <utility>#include <dune/common/typetraits.hh>#include <dune/common/typeutilities.hh>#include <dune/common/fvector.hh>#include <dune/common/indices.hh>#include <dune/common/assertandreturn.hh>#include <dune/common/rangeutilities.hh>Documentation related stuff. │ │ │ │ +More...
│ │ │ │ + │ │ │ │Go to the source code of this file.
│ │ │ ││ │ │ │ +Classes | |
| struct | Dune::ImplementationDefined |
| Dummy struct used for documentation purposes. More... | |
│ │ │ │ Namespaces | |
| namespace | Dune |
| Dune namespace. | |
| namespace | Dune::Hybrid |
│ │ │ │ -Functions | |
| template<class T > | |
| constexpr auto | Dune::Hybrid::size (const T &t) |
| Size query. | |
| template<class Container , class Index > | |
| constexpr decltype(auto) | Dune::Hybrid::elementAt (Container &&c, Index &&i) |
| Get element at given position from container. | |
| template<class Begin , class End > | |
| constexpr auto | Dune::Hybrid::integralRange (const Begin &begin, const End &end) |
| Create an integral range. | |
| template<class End > | |
| constexpr auto | Dune::Hybrid::integralRange (const End &end) |
| Create an integral range starting from 0. | |
| template<class Range , class F > | |
| constexpr void | Dune::Hybrid::forEach (Range &&range, F &&f) |
| Range based for loop. | |
| template<class Range , class T , class F > | |
| constexpr T | Dune::Hybrid::accumulate (Range &&range, T value, F &&f) |
| Accumulate values. | |
| template<class Condition , class IfFunc , class ElseFunc > | |
| decltype(auto) | Dune::Hybrid::ifElse (const Condition &condition, IfFunc &&ifFunc, ElseFunc &&elseFunc) |
| A conditional expression. | |
| template<class Condition , class IfFunc > | |
| void | Dune::Hybrid::ifElse (const Condition &condition, IfFunc &&ifFunc) |
| A conditional expression. | |
| template<class T1 , class T2 > | |
| constexpr auto | Dune::Hybrid::equals (T1 &&t1, T2 &&t2) |
| Equality comparison. | |
| template<class Cases , class Value , class Branches , class ElseBranch > | |
| constexpr decltype(auto) | Dune::Hybrid::switchCases (const Cases &cases, const Value &value, Branches &&branches, ElseBranch &&elseBranch) |
| Switch statement. | |
| template<class Cases , class Value , class Branches > | |
| constexpr void | Dune::Hybrid::switchCases (const Cases &cases, const Value &value, Branches &&branches) |
| Switch statement. | |
│ │ │ │ +Enumerations | |
| enum | { Dune::implementationDefined │ │ │ │ + } |
Documentation related stuff.
│ │ │ │ + 1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,77 +1,25 @@
│ │ │ │ │ dune-common 2.9.0
│ │ │ │ │ Loading...
│ │ │ │ │ Searching...
│ │ │ │ │ No Matches
│ │ │ │ │ * _d_u_n_e
│ │ │ │ │ * _c_o_m_m_o_n
│ │ │ │ │ -_N_a_m_e_s_p_a_c_e_s | _F_u_n_c_t_i_o_n_s
│ │ │ │ │ -hybridutilities.hh File Reference
│ │ │ │ │ -#include 1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,433 +1,38 @@
│ │ │ │ │ dune-common 2.9.0
│ │ │ │ │ Loading...
│ │ │ │ │ Searching...
│ │ │ │ │ No Matches
│ │ │ │ │ * _d_u_n_e
│ │ │ │ │ * _c_o_m_m_o_n
│ │ │ │ │ -hybridutilities.hh
│ │ │ │ │ +documentation.hh
│ │ │ │ │ _G_o_ _t_o_ _t_h_e_ _d_o_c_u_m_e_n_t_a_t_i_o_n_ _o_f_ _t_h_i_s_ _f_i_l_e_.
│ │ │ │ │ 1// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
│ │ │ │ │ 2// vi: set et ts=4 sw=2 sts=2:
│ │ │ │ │ 3// SPDX-FileCopyrightInfo: Copyright (C) DUNE Project contributors, see file
│ │ │ │ │ LICENSE.md in module root
│ │ │ │ │ 4// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
│ │ │ │ │ -5#ifndef DUNE_COMMON_HYBRIDUTILITIES_HH
│ │ │ │ │ -6#define DUNE_COMMON_HYBRIDUTILITIES_HH
│ │ │ │ │ -7
│ │ │ │ │ -8#include Compatibility header for including <Vc/Vc> │ │ │ │ +
Useful wrapper for creating singletons. │ │ │ │ More...
│ │ │ │ - │ │ │ │ +#include <dune/common/visibility.hh>Go to the source code of this file.
│ │ │ │ +│ │ │ │ +Classes | |
| class | Dune::Singleton< T > |
| An adapter to turn a class into a singleton. More... | |
│ │ │ │ +Namespaces | |
| namespace | Dune |
| Dune namespace. | |
Compatibility header for including <Vc/Vc>
│ │ │ │ -Certain versions (1.3.2) of Vc (https://github.com/VcDevel/Vc) have a problem with certain compiler versions (g++ 7.2.0) in c++17 mode, see #88.
│ │ │ │ +Useful wrapper for creating singletons.
│ │ │ │ +Inspired by the article CodeGuru: A Leak-Free Singleton class
│ │ │ │ 1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,15 +1,24 @@
│ │ │ │ │ dune-common 2.9.0
│ │ │ │ │ Loading...
│ │ │ │ │ Searching...
│ │ │ │ │ No Matches
│ │ │ │ │ * _d_u_n_e
│ │ │ │ │ * _c_o_m_m_o_n
│ │ │ │ │ -vc.hh File Reference
│ │ │ │ │ -Compatibility header for including 1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,32 +1,66 @@
│ │ │ │ │ dune-common 2.9.0
│ │ │ │ │ Loading...
│ │ │ │ │ Searching...
│ │ │ │ │ No Matches
│ │ │ │ │ * _d_u_n_e
│ │ │ │ │ * _c_o_m_m_o_n
│ │ │ │ │ -vc.hh
│ │ │ │ │ +singleton.hh
│ │ │ │ │ _G_o_ _t_o_ _t_h_e_ _d_o_c_u_m_e_n_t_a_t_i_o_n_ _o_f_ _t_h_i_s_ _f_i_l_e_.
│ │ │ │ │ -1// SPDX-FileCopyrightInfo: Copyright (C) DUNE Project contributors, see file
│ │ │ │ │ +1// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
│ │ │ │ │ +2// vi: set et ts=4 sw=2 sts=2:
│ │ │ │ │ +3// SPDX-FileCopyrightInfo: Copyright (C) DUNE Project contributors, see file
│ │ │ │ │ LICENSE.md in module root
│ │ │ │ │ -2// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
│ │ │ │ │ -3#ifndef DUNE_COMMON_VC_HH
│ │ │ │ │ -4#define DUNE_COMMON_VC_HH
│ │ │ │ │ -5
│ │ │ │ │ -15#if HAVE_VC
│ │ │ │ │ -16
│ │ │ │ │ -17// include Vc's macro definitions
│ │ │ │ │ -18#include This file implements iterator facade classes for writing stl conformant iterators. │ │ │ │ -More...
│ │ │ │ -#include <iterator>#include <type_traits>#include "typetraits.hh"#include <type_traits>#include <functional>Go to the source code of this file.
│ │ │ ││ │ │ │ -Classes | |
| class | Dune::ForwardIteratorFacade< T, V, R, D > |
| Base class for stl conformant forward iterators. More... | |
| class | Dune::BidirectionalIteratorFacade< T, V, R, D > |
| Facade class for stl conformant bidirectional iterators. More... | |
| class | Dune::RandomAccessIteratorFacade< T, V, R, D > |
| Base class for stl conformant forward iterators. More... | |
│ │ │ │ Namespaces | |
| namespace | Dune |
| Dune namespace. | |
│ │ │ │ +Typedefs | |
| template<class T > | |
| using | Dune::ResolveRef_t = std::remove_reference_t< decltype(Dune::resolveRef(std::declval< T & >()))> |
| Type trait to resolve std::reference_wrapper. | |
│ │ │ │ Functions | |
| template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 > | |
| EnableIfInterOperable< T1, T2, bool >::type | Dune::operator== (const ForwardIteratorFacade< T1, V1, R1, D > &lhs, const ForwardIteratorFacade< T2, V2, R2, D > &rhs) |
| Checks for equality. | |
| template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 > | |
| EnableIfInterOperable< T1, T2, bool >::type | Dune::operator!= (const ForwardIteratorFacade< T1, V1, R1, D > &lhs, const ForwardIteratorFacade< T2, V2, R2, D > &rhs) |
| Checks for inequality. | |
| template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 > | |
| std::enable_if< std::is_convertible< T2, T1 >::value, bool >::type | Dune::operator== (const BidirectionalIteratorFacade< T1, V1, R1, D > &lhs, const BidirectionalIteratorFacade< T2, V2, R2, D > &rhs) |
| Checks for equality. | |
| template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 > | |
| std::enable_if< std::is_convertible< T1, T2 >::value &&!std::is_convertible< T2, T1 >::value, bool >::type | Dune::operator== (const BidirectionalIteratorFacade< T1, V1, R1, D > &lhs, const BidirectionalIteratorFacade< T2, V2, R2, D > &rhs) |
| Checks for equality. | |
| template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 > | |
| EnableIfInterOperable< T1, T2, bool >::type | Dune::operator!= (const BidirectionalIteratorFacade< T1, V1, R1, D > &lhs, const BidirectionalIteratorFacade< T2, V2, R2, D > &rhs) |
| Checks for inequality. | |
| template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 > | |
| EnableIfInterOperable< T1, T2, bool >::type | Dune::operator== (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs) |
| Checks for equality. | |
| template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 > | |
| EnableIfInterOperable< T1, T2, bool >::type | Dune::operator!= (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs) |
| Checks for inequality. | |
| template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 > | |
| EnableIfInterOperable< T1, T2, bool >::type | Dune::operator< (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs) |
| Comparison operator. | |
| template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 > | |
| EnableIfInterOperable< T1, T2, bool >::type | Dune::operator<= (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs) |
| Comparison operator. | |
| template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 > | |
| EnableIfInterOperable< T1, T2, bool >::type | Dune::operator> (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs) |
| Comparison operator. | |
| template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 > | |
| EnableIfInterOperable< T1, T2, bool >::type | Dune::operator>= (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs) |
| Comparison operator. | |
| template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 > | |
| EnableIfInterOperable< T1, T2, D >::type | Dune::operator- (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs) |
| Calculates the difference between two pointers. | |
| template<class T > | |
| constexpr T & | Dune::resolveRef (T &gf) noexcept |
| Helper function to resolve std::reference_wrapper. | |
| template<class T > | |
| const auto & | Dune::resolveRef (T &&gf)=delete |
| template<class T > | |
| constexpr T & | Dune::resolveRef (std::reference_wrapper< T > gf) noexcept |
| Helper function to resolve std::reference_wrapper. | |
│ │ │ │ +Variables | |
| template<class T > | |
| constexpr bool | Dune::IsReferenceWrapper_v = Impl::IsReferenceWrapper<T>::value |
| Helper to detect if given type is a std::reference_wrapper. | |
This file implements iterator facade classes for writing stl conformant iterators.
│ │ │ │ -With using these facades writing iterators for arbitrary containers becomes much less cumbersome as only few functions have to be implemented. All other functions needed by the stl are provided by the facades using the Barton-Nackman trick (also known as curiously recurring template pattern.
│ │ │ │ - 1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,145 +1,40 @@
│ │ │ │ │ dune-common 2.9.0
│ │ │ │ │ Loading...
│ │ │ │ │ Searching...
│ │ │ │ │ No Matches
│ │ │ │ │ * _d_u_n_e
│ │ │ │ │ * _c_o_m_m_o_n
│ │ │ │ │ -_C_l_a_s_s_e_s | _N_a_m_e_s_p_a_c_e_s | _F_u_n_c_t_i_o_n_s
│ │ │ │ │ -iteratorfacades.hh File Reference
│ │ │ │ │ -This file implements iterator facade classes for writing stl conformant
│ │ │ │ │ -iterators. _M_o_r_e_._._.
│ │ │ │ │ -#include 1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,614 +1,98 @@
│ │ │ │ │ dune-common 2.9.0
│ │ │ │ │ Loading...
│ │ │ │ │ Searching...
│ │ │ │ │ No Matches
│ │ │ │ │ * _d_u_n_e
│ │ │ │ │ * _c_o_m_m_o_n
│ │ │ │ │ -iteratorfacades.hh
│ │ │ │ │ +referencehelper.hh
│ │ │ │ │ _G_o_ _t_o_ _t_h_e_ _d_o_c_u_m_e_n_t_a_t_i_o_n_ _o_f_ _t_h_i_s_ _f_i_l_e_.
│ │ │ │ │ 1// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
│ │ │ │ │ 2// vi: set et ts=4 sw=2 sts=2:
│ │ │ │ │ 3// SPDX-FileCopyrightInfo: Copyright (C) DUNE Project contributors, see file
│ │ │ │ │ LICENSE.md in module root
│ │ │ │ │ 4// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
│ │ │ │ │ -5#ifndef DUNE_ITERATORFACADES_HH
│ │ │ │ │ -6#define DUNE_ITERATORFACADES_HH
│ │ │ │ │ +5#ifndef DUNE_COMMON_REFERENCE_HELPER_HH
│ │ │ │ │ +6#define DUNE_COMMON_REFERENCE_HELPER_HH
│ │ │ │ │ 7
│ │ │ │ │ -8#include Documentation of the traits classes you need to write for each implementation of DenseVector or DenseMatrix. │ │ │ │ +
Utilities for reduction like operations on ranges. │ │ │ │ More...
│ │ │ │ - │ │ │ │ +#include <dune/common/typetraits.hh>#include <algorithm>#include <utility>#include <type_traits>#include <bitset>Go to the source code of this file.
│ │ │ ││ │ │ │ Classes | |
| struct | Dune::DenseMatVecTraits< T > |
| class | Dune::IntegralRange< T > |
| dynamic integer range for use in range-based for loops More... | |
| class | Dune::StaticIntegralRange< T, to, from > |
| static integer range for use in range-based for loops More... | |
| struct | Dune::ValueTransformationTag |
| Tag to enable value based transformations in TransformedRangeView. More... | |
| struct | Dune::IteratorTransformationTag |
| Tag to enable iterator based transformations in TransformedRangeView. More... | |
| class | Dune::TransformedRangeView< R, F, T > |
| A range transforming the values of another range on-the-fly. More... | |
│ │ │ │ Namespaces | |
| namespace | Dune |
| Dune namespace. | |
│ │ │ │ +Functions | |
| template<typename T , typename std::enable_if< IsIterable< T >::value, int >::type = 0> | |
| T::value_type | Dune::max_value (const T &v) |
| compute the maximum value over a range | |
| template<typename T , typename std::enable_if<!IsIterable< T >::value, int >::type = 0> | |
| const T & | Dune::max_value (const T &v) |
| template<typename T , typename std::enable_if< IsIterable< T >::value, int >::type = 0> | |
| T::value_type | Dune::min_value (const T &v) |
| compute the minimum value over a range | |
| template<typename T , typename std::enable_if<!IsIterable< T >::value, int >::type = 0> | |
| const T & | Dune::min_value (const T &v) |
| template<typename T , typename std::enable_if< IsIterable< T >::value, int >::type = 0> | |
| bool | Dune::any_true (const T &v) |
| similar to std::bitset<N>::any() return true, if any entries is true | |
| template<std::size_t N> | |
| bool | Dune::any_true (const std::bitset< N > &b) |
| template<typename T , typename std::enable_if< IsIterable< T >::value, int >::type = 0> | |
| bool | Dune::all_true (const T &v) |
| similar to std::bitset<N>::all() return true, if any entries is true | |
| template<std::size_t N> | |
| bool | Dune::all_true (const std::bitset< N > &b) |
| template<class T , class U , std::enable_if_t< std::is_same< std::decay_t< T >, std::decay_t< U > >::value, int > = 0, std::enable_if_t< std::is_integral< std::decay_t< T > >::value, int > = 0> | |
| static IntegralRange< std::decay_t< T > > | Dune::range (T &&from, U &&to) noexcept |
| free standing function for setting up a range based for loop over an integer range for (auto i: range(0,10)) // 0,1,2,3,4,5,6,7,8,9 or for (auto i: range(-10,10)) // -10,-9,..,8,9 or for (auto i: range(10)) // 0,1,2,3,4,5,6,7,8,9 | |
| template<class T , std::enable_if_t< std::is_integral< std::decay_t< T > >::value, int > = 0> | |
| static IntegralRange< std::decay_t< T > > | Dune::range (T &&to) noexcept |
| template<class T , std::enable_if_t< std::is_enum< std::decay_t< T > >::value, int > = 0> | |
| static IntegralRange< std::underlying_type_t< std::decay_t< T > > > | Dune::range (T &&to) noexcept |
| template<class T , T to> | |
| static StaticIntegralRange< T, to > | Dune::range (std::integral_constant< T, to >) noexcept |
| template<class R , class F > | |
| auto | Dune::transformedRangeView (R &&range, const F &f) |
| Create a TransformedRangeView. | |
| template<class R , class F > | |
| auto | Dune::iteratorTransformedRangeView (R &&range, const F &f) |
| Create a TransformedRangeView using an iterator transformation. | |
| template<class Range > | |
| auto | Dune::sparseRange (Range &&range) |
| Allow structured-binding for-loops for sparse iterators. | |
│ │ │ │ +Variables | |
| template<class T , T from, T to> | |
| static StaticIntegralRange< T, to, from > | Dune::range (std::integral_constant< T, from >, std::integral_constant< T, to >) noexcept |
Documentation of the traits classes you need to write for each implementation of DenseVector or DenseMatrix.
│ │ │ │ +Utilities for reduction like operations on ranges.
│ │ │ │ + │ │ │ │ 1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,23 +1,132 @@
│ │ │ │ │ dune-common 2.9.0
│ │ │ │ │ Loading...
│ │ │ │ │ Searching...
│ │ │ │ │ No Matches
│ │ │ │ │ * _d_u_n_e
│ │ │ │ │ * _c_o_m_m_o_n
│ │ │ │ │ -_C_l_a_s_s_e_s | _N_a_m_e_s_p_a_c_e_s
│ │ │ │ │ -matvectraits.hh File Reference
│ │ │ │ │ -Documentation of the traits classes you need to write for each implementation
│ │ │ │ │ -of DenseVector or DenseMatrix. _M_o_r_e_._._.
│ │ │ │ │ +_C_l_a_s_s_e_s | _N_a_m_e_s_p_a_c_e_s | _F_u_n_c_t_i_o_n_s | _V_a_r_i_a_b_l_e_s
│ │ │ │ │ +rangeutilities.hh File Reference
│ │ │ │ │ +Utilities for reduction like operations on ranges. _M_o_r_e_._._.
│ │ │ │ │ +#include <_d_u_n_e_/_c_o_m_m_o_n_/_t_y_p_e_t_r_a_i_t_s_._h_h>
│ │ │ │ │ +#include 1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,34 +1,880 @@
│ │ │ │ │ dune-common 2.9.0
│ │ │ │ │ Loading...
│ │ │ │ │ Searching...
│ │ │ │ │ No Matches
│ │ │ │ │ * _d_u_n_e
│ │ │ │ │ * _c_o_m_m_o_n
│ │ │ │ │ -matvectraits.hh
│ │ │ │ │ +rangeutilities.hh
│ │ │ │ │ _G_o_ _t_o_ _t_h_e_ _d_o_c_u_m_e_n_t_a_t_i_o_n_ _o_f_ _t_h_i_s_ _f_i_l_e_.
│ │ │ │ │ 1// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
│ │ │ │ │ 2// vi: set et ts=4 sw=2 sts=2:
│ │ │ │ │ 3// SPDX-FileCopyrightInfo: Copyright (C) DUNE Project contributors, see file
│ │ │ │ │ LICENSE.md in module root
│ │ │ │ │ 4// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
│ │ │ │ │ -5#ifndef DUNE_MATVECTRAITS_HH
│ │ │ │ │ -6#define DUNE_MATVECTRAITS_HH
│ │ │ │ │ +5#ifndef DUNE_COMMON_RANGE_UTILITIES_HH
│ │ │ │ │ +6#define DUNE_COMMON_RANGE_UTILITIES_HH
│ │ │ │ │ 7
│ │ │ │ │ -12namespace _D_u_n_e {
│ │ │ │ │ +8#include <_d_u_n_e_/_c_o_m_m_o_n_/_t_y_p_e_t_r_a_i_t_s_._h_h>
│ │ │ │ │ +9#include