[cleanup] Add FMatrix default copy constructor

See merge request !1477

Use std::fill for FVector's constructor with single scalar argument

See merge request !1485

Remove duplicates in ALL_DEPENDENCIES

See merge request !1489

Make DUNE_THROW usable in constexpr context

See merge request !1472

Found by Cppcheck (useStlAlgorithm).

Carsten Gräser authored 4 months ago and Christoph Grüninger committed 3 months ago

Instead of using a `do ... while` loop, this
extends the exception with `operator<<` such that
one can directly pipe in values. The extension is done
via the new class `Dune::ExceptionStream<E>` that
derives from `E` and implements `operator<<`.

As a by-product one can now also pipe values after `DUNE_THROW`
e.g. using
```cpp
DUNE_THROW(E, "foo" << 1) << 2 << 3;
```
For completeness this also adds support for
```cpp
DUNE_THROW(E) << 2 << 3;
```

Notice that `DUNE_THROW` exists for two main reasons:
For (a) conveniently add the error location to the message
and (b) providing the stream functionality. With this
patch the second reason is void and no longer reguires
a macro, because one can directly use:
```cpp
throw Dune::ExceptionStream<E>() << 2 << 3;
```

exc

Throw before reaching undefined behavior on AlignedNumber allocation

See merge request !1483

Santiago Ospina De Los Ríos authored 4 months ago and Simon Praetorius committed 3 months ago

With this commit, AlignedNumber throws an exception whenever a placement new is made with a misaligned address. This should effectively catches an undefined behavior on the library implementations of operator new() under misaligned addresses.

[CI] Remove the variable DUNE_RUNNING_IN_CI from the local gitlab-ci

See merge request !1488

Fix/cmake module path

See merge request !1486

Remove the variable DUNE_RUNNING_IN_CI from the local gitlab-ci, since already set in the docker image

[ci] Make .gitlab-ci.yml portable

See merge request !1482

Deprecate the MODULE_LIBRARIES argument to dune_enable_all_packages

Closes #387

See merge request !1475

Do not inherit global variables in a triggered pipeline

See merge request !1487

Currently the CI config requires that the `core/ci-config`
project exists on the same gitlab server. This prevents
the CI from working when pushing the repository to another
server. While one may argue, that one also has to push
`core/ci-config` then, it is a very strong restriction to
require that the gitlab group `core` is available.

This can be avoided by using a gitlab remote include for those
files with a link pointing to the dune server instead of a local
include.

Improve the error message in the DenseMatrixAssigner for DiagonalMatrix

See merge request !1480

Link all targets in a directory against Dune::Common

See merge request !1481

Deactivate transposetest for DiagonalMatrix

See merge request !1478

Use targets in duneproject

See merge request !1460

[bugfix] Don't implent operator<< templated wrt the stream

See merge request !1476

When implementing `operator<<(S& , const T&)` to provide character
stream support for a custom type `T`, the overload should be specific
to `S=std::ostream` and not be templated wrt `S`. Otherwise this may
lead to ambiguous overloads downstream.
To give two examples for problematic cases:

Here we defined an overload
```cpp
template<class Stream, class T, std::size_t N>
inline Stream& operator<<(Stream&, const std::array<T,N>&)
```
If a downstream module wants to defines an overload
```cpp
template<class A>
inline std::ostream& operator<<(std::ostream&, const A&)
```
for a custom type `A` derived from `std::array<T,N>`,
this leads to ambiguity.

If a custom class `S` that does not represent a character stream
wants to use the `s << t` syntax in anoter context, this cannot
be done for cases where `t` is an `std::array`. Furtermore
the overload that we provide here may in general not make any
sense in this context.

BTW: One may argue that defining overloads for `std::` types
is in general a very bad idea. Imagine that another library
does the same - then we cannot use it together with dune, because
both claim to be the authority over `std::`.

Fix wrong variable name to make target hash

See merge request !1469

Add precompiled code into the python module in the expensive test

See merge request !1465