Note remove_reference is necessary, because you cannot extract the iterator type from
row_reference directly in case: row_reference == row_type&

IteratorFacades::Pointer is assumed to be T* which is not the case for row_reference != row_type&.

Add additional template parameter R (default T&) to handle the case row_reference != row_type&.

This fixes FS#1398 for dune-common.

Use conditional instead.

These headers were moved in Dune 2.3.

The last patch missed a change in the comparison operators. Allocators
compare as equal if memory allocated with one can be deallocate with
the other. With this allocators compare equal only if they are share
the same address.

Cherry-pick from branch eature/FS1429-shared-lib-fixes where it ended up
by accident.

Due to its desgin of using one static memory pool. The allocator
could not be used in different threads at the same time without
side effects. With this revision each instance will hold its own private
instance of the pool.

There should be no issues with this patch and poolallocator seems to be
mostly used in AMG anyway.

when we try to send data, it might happen, that for some reason we don't want to any data.
This happens, when the dynamic size of our CommPolicy is 0. In that case we must not add a
MessageInformation, otherwise we get an MPI error.

Somehow, the vector version of CollectiveCommunication< MPI_Comm >::prod
passed std::plus to allreduce (instead of std::multiplies). This patch
corrects this flaw.

Make type of std::site_t an additional template parameter to avoid the
warning. While this is conceptually redunant its OK since we only use
it in a helper struct.

VariableSizeCommunicator now appears in doxyen and the parallel
index sets are a subsection of the parallel section.

There entries in doxyerror.log about undocumented function
parameters and parameters that had a wrong name in the documentation.
This patch fixes this.

This patch introduces a new macro DUNE_UNUSED_PARAMETER(parm) for marking
unused parameters that are there for a purpose (e.g. the prescribed interfac
The macro simply performs a cast to void. In addition all unused parameter w
that I found were removed.

Thanks, Oliver!

The new YaspGrid constructors require an array with the number of cells
in each direction. Unfortunately, there is no array constructor that
takes a single element and copies it to all array elements.

This patch adds a simple function Dune::fill_array() to do just that.

With this patch VariableSizeCommunicator now really supports a varying number of data entries
per index during communication.

[parallel,release] Adds a new buffered communicator that does not need to know the data amount per index when receiving.

During communication of data with a parallel DUNE grid the amount of data items
received at an index is not known at the receiving side. With this communicator
it is possible to build such a communication based on index lists at the sending
and receiving side. With this patch only fixed size of data items per index is
supported.

This fixes a Clang warning.

Make more precise statement to the user if no template specialization
of DenseMatrixAssigner is found. Also use dune_static_assert instead of
static_assert.

This implementation of an IdentityMatrix does not hold any data. It
implements a reduced version of the DenseMatrix interface including a
standard C++ cast operator to a Dune::FieldMatrix. This code illustrates
the new forward capabilities of DenseMatrixAssigner.

The default implementation of DenseMatrixAssigner replaces redundant
code in dense matrix constructors taking a primitive data type.

[DenseMatrix] Introduce DenseMatrixAssigner for initializing dense matrices from arbitrary right hand sides

In order to overcome the deficiencies of istl_assign_to_fmatrix() we
propose to always use a struct DenseMatrixAssigner for initializing a
dense matrix. This class can be specialized by users for any right hand
side to be used in an assignment.  The new mechanism can bei default
implemented using existing implementations of istl_assign_to_fmatrix()
as well.