See https://reuse.software/ for a description.

Add option to install concrete python requirements

See merge request !1161

(cherry picked from commit 0a430ebe)

2d84eba7 Add option to optionally install concrete python requirements

Samuel Burbulla authored 3 years ago and Andreas Dedner committed 3 years ago

Add info command.g
Add `python -m dune info` command.

Add fix-dunepy command.

Check if 'cmake .' returns 0.

Add --ccfiles flag for listing .cc files.

[fix] issue with comment line in CMakeLists.txt being removed by fix command

add a --force to the fix-dunepy command which simply removes the whole dune-py

This adds three utilities (stolen from dune-functions) and a
corresponding test for working with `std::reference_wrapper`:

* `IsReferenceWrapper_v<T>` allows to check if `T` is an instantiation of `std::reference_wrapper`
* The function `resolveRef(t)` either returns `t.get()` or `t`
  depending on whether `t` is a `std::reference_wrapper` or a plain
  l-value reference.
* `ResolveRef_t<T>` provides the resolved type for `T`.

These utilities allow to support storing data members of classes by value _or_
reference transparently suing the following pattern. The class always stores
values, but supports passing `std::ref(...)` to opt-in store-by-reference.
Handling the latter can be done without boilerplate code using the
provided utilities:

```cpp
template<class StoredT>
struct SomeWrapper {

  using T = ResolveRef_t<StoredT>;

  SomeWrapper(const StoredT& t) : t_(t) {}

  void callFoo() const {
    resolveRef(t_).foo();
  }

  StoredT t_;
};

[...]

// Store t by value
auto w1 = SomeWrapper(t);
w1.callFoo();

// Store t by reference
auto w2 = SomeWrapper(std::cref(t));
w2.callFoo();
```

# Conflicts:
#	config.h.cmake

Using an enum has the side effect that you can't do arithmetic without explicitly casting to an integer type.
This also produced a compiler warning with clang 10 "arithmetic between different enumeration types is deprecated"
-Wdeprecated-anon-enum-enum-conversion

Install the export-set in finalize_dune_project

Register an EXPORT_SET variable

Replace DUNE_MODULE_LIBRARIES with <module>_LIBRARIES

Add Changelog entry

Include deprecation period

Timo Koch authored 3 years ago and Simon Praetorius committed 3 years ago

This is a type trait that checks whether some type has
a defined ()-operator that can be invoked with a given
list of arguments types and returns objects of a specified type.

Is is an improved implementation of Dune::Std::is_callable
which is deprecated.