This very old gcc bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=10200 is fixed in clang but not in icc or gcc, see FS#1505.

In order to simplify fallback handling between code with and without MPI
support, this patch makes the specialization of CollectiveCommunication
for MPI communicators default-constructible by defaulting the underlying
MPI communicator to MPI_COMM_WORLD, which should be reasonable for most
scenarios.

As the non-specialized version for sequential code is already
default-constructible, this allows grid constructors to accept a
CollectiveCommunication object regardless of whether MPI support is
enabled or not and to provide a default value for this parameter.

This patch resolves FS#1497.

CollectiveCommunication serves as a fallback implementation, when
code that is written for parallel computations is executed in sequential.
The template parameters BinaryFunctions are no-op then, but they are
still there to define the interface. However, in a generic (parallel)
implementation these will be given. Including binaryfunctions.hh here
avoids error messages due to no-op template parameters whose names
could not be found by the compiler.

C++14 will introduce integer/index sequences in the header <utility>.
This patch introduces a backwards compatible implementation similar in
use. However, the implementation differs in the following technical
details:

  - index_sequence is not a template alias for integer_sequence but
  inherits from it

  - make_{integer, index}_sequence are not a template aliases but free
  standing functions

Both differences stem from the absence of template aliases introduced in
GCC aa late as gcc-4.7. This implementation will work in gcc-4.4 and
later.

When using DUNE_EXPORT, you need to include visibility.hh. This was
omitted when adding this flag to the Singleton class in singleton.hh.
This patch adds the missing include.

for details see FS#1398

nullptr-test.cc: Move semicolon to own line to prevent
Clang warning.
typetraitstest.cc: Exclude use of deprecated types
PointeeType and ReferredType with
DISABLE_DEPRECATED_METHOD_CHECKS defined.

funnily enough, this usually worked (i.e. it returned some garbage
which was not recognized by the switch statement that followed), and
was not detected by valgrind (on my machine at least, I suppose this
was because the address to which the string pointed was still a valid
memory location created by some previous user). The libstdc++ debug
mode (-D_GLIBCXX_DEBUG=1 -D_GLIBCXX_DEBUG_PEDANTIC=1) did find it
though...

IteratorRange is a cheap, throwaway container to implement support for
range-based for loops if the underlying containers doesn't provide
standard begin() / end () methods.

Test (almost) all methods requested by the STL
(as documented on http://www.cplusplus.com/reference/iterator/ForwardIterator/ )

Test whether std::iterator_traits is properly specialized.

There is more macro magic to be removed.

Maybe we can deprecate the complete header type_traits.hh.

Gcc 4.6 cannot generate default move constructor for classes containing a
DynamicVector because there is no move constructor and the copy constructor
is non-trivial.
This patch fixes this, by adding move semantics.

NDEBUG is undefined (allows to tests asserts without doubling call to all
interface methods).

NDEBUG needs to be undefined and DUNE_INTERFACECHECK needs to be defined
to check the correct implementation of CRT interface methods.

Steffen Persvold authored 10 years ago and Markus Blatt committed 10 years ago

getrusage() is a very expensive system call and involves several
kernel locks. This prevents multithreaded applications from scaling
effectively. Using std:chrono::high_resolution_clock is portable
and very low cost in most cases.

This avoids compiler warning about implicitly rounded to zero

This reverts commit cf4bf4d8.

The epxlicit cast isn't needed anymore as we have a fix for the
ambiguous operator overload.

The bug affected operators: +=, -=, *=, /=. It has been fixed by using:
enable_if<is_convertible<ParamType, FieldVector::valueType>, ...>

oelements stores longs which need to be converted to pointers before freeing.
Previously we actually free the entries of the array oelements and not the
stored pointers.

There might be liftime issues with the allocated memory when copying
a pool. Therefore I added a check whether the memory was actually
allocated by the pool when freeing it.

(the problem are operators of the type FieldVector<double,1> *= int)
clang fails and gcc (4.7) warns about
ISO C++ saying that these operators are aambiguous

With g++-4.4 I got the following errors:

fmatrix.hh:106: error: no type named ‘const_iterator’ in ‘class std::initializer_list<std::initializer_list<int> >’

Looking into the header there is indeed the const_iterator (demanded by the standard)
missing. Therefore I refactored the code to use std::copy_n and thus am omitting the iterator
type.

At the same time I made the actual copying safer for the case that the initializer_list
is of different size and people compile with -DNDEBUG. The assertion for the size is still
left in there. Remove the assert or the size computation at your discretion.

We simply return a reference to the internal memory instead of copying the object.
This should save some copying when using FieldVector/FieldMatrix with non-trivial
types.  Also, it fixes crashes I have experienced with the ADOL-C automatic
differentiation toolbox [0].

I hope that this patch doesn't have any nasty side effects.  I didn't see any
so far.  Comments for this patch had been requested in FS 1449, and there have
been no objections.

[0] I have contacted the ADOL-C maintainer about this and he said the crashes
are not really bugs in ADOL-C, but that it is simply very difficult to write
a good operator-overloading AD program that can handle operator K returning
values.

The classes AlwaysFalse, AlwaysTrue reside in the deprecated header
dune/common/static_assert, yet they are frequently used to document
template code (see FS#1435 for details). As the C++11 standard library
does not provide a straight forward replacement for theses classes, we
offer C++11 style reimplementations. The replacements to_false_type,
to_true_type reside in the namespace Std and are thus easily
identifiable as Dune specifis.

Add template parameter for the allocator of the internal std::vector.
All constructors are adadpted to forward a user chosen allocator
to the internal data stroage (std::vector).