These classes are deprecated, and some of the tests cause
problems with ctest due to a destructor throwing an exception.
It seems easier to remove the tests directly, as the tested code
is deprecated anyway.

See FS1508. C++11 initializer lists should be used instead.

testdebugallocator_fail{1..5} are a very special sort of tests,
as in order to pass they are expected to fail with a signal like
SIGABRT or SIGSEGV. While autotools, dont distinguish much
about how a test failed, if it is supposed to fail, ctest
handles signals from the test and distinguishes this from
normal termination with nonzero exit code.

This commit introduces a signal handling in the test itself,
that causes the program to terminate "normally" with a nonzero exit
code instead of passing the signal to the fathering process
(ctest). The signal, which is expected to be received can be set
from CMakeLists.txt via a preprocessor variable.

This basically wraps the raw snprintf in order to provide
overflow-save printf functionality while hiding the details
like buffers handling, multiple calls to snprintf, ...

Note that snprintf is a c++11 feature that is, however,
present in gcc-4.4.

Conflicts:
	cmake/modules/CheckCXX11Features.cmake
	dune/common/std/CMakeLists.txt
	dune/common/std/Makefile.am
	m4/Makefile.am
	m4/dune_common.m4

Dominic Kempf authored 10 years ago and Dominic Kempf committed 10 years ago

Autotools users kept complaining, that it is conceptionally
disappointing that targets cannot be build with flags set upon
entering make (e.g. make CXXFLAGS+="-myflag" mytarget). This
patch introduces a small hack, that allows for such feature
in cmake. It is, however, (at least) questionable whether we
want to include it. Still, for your information and convenience:

To use the feature you must:
- be using a CMake generator that is based on Makefiles (defaults to true)
- set the define ALLOW_EXTRA_CXXFLAGS to true, e.g. by including
  CMAKE_FLAGS="-DALLOW_EXTRA_CXXFLAGS=1" in your optsfile.
- reconfigure your project

cmake will then wrap a small shell script around your compiler
and allow you to append the content of an environment variable
to yout compiler flags. Run for above example:
EXTRA_CXXFLAGS="-myflag" make mytarget

The additional flags will be visually confirmed if and only if
you set the verbosity (as always):
EXTRA_CXXFLAGS="-myflag" make VERBOSE=1 mytarget

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.

This branch contains required infrastructure for the new iterator ranges
in dune-grid. In particular, it adds a configuration test that checks
whether the compiler supports range-based for loops and a small utility
class that serves as a container for a pair of begin and end iterators.

* feature/FS1042-range-based-for-loops-test-and-iteratorrange:
  [buildsystem] Check for range-based for.
  [Iterators] Add IteratorRange helper class

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.

Macro to use C++11 feature noexcept specifier.
Add test for CMake and autotools.

dunecontrol is capable of doing out of source builds, that are
not nested within the source directory by giving an absolute path
to the --builddir option. Unfortuantely, this (nice) feature was
not documented.

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.

There is no need to limit it to 2 min. For larger modules
like DuMuX this is not enough. Increased timeout to 5 min.

Remove checks and fall-back code for hashing,
type_traits, and the remaining tr1 stuff.

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.

With GCC 4.4 or newer HAVE_INTEGRL_CONSTANT, HAVE_STD_HASH, and
HAVE_TYPE_TRAITS is always 1, no further testing necessary.
The test defines will be removed after the next Dune release.

Andreas Nüßing authored 10 years ago and Christoph Grüninger committed 10 years ago

When creating a project and generating the config.h.cmake file, duneproject
surrounds the inserted text with {begin,end} $NAME. $NAME is set to $PROJECT
without a leading "dune[-_]" and $PROJECT is the module name specified by the
user (e.g. $PROJECT==dune-grid, $NAME==grid).
When DuneMacro.cmake generates the config.h.cmake for the created project in
the build-directory, it searches the config.h.cmake file in the source
directory of the project for {begin,end} $ProjectName which is set to
DUNE_MOD_NAME, which is the module name specified in the corresponding
dune.module file (e.g. dune-grid).
This leads to DuneMacro not finding and therefore ignoring the block in the
source config.h.cmake of the new project.

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.

If duncontrol detects an installed dune-common module, then it always
assumed that it contains a lib/dunecontrol
subdirectory. Unfortunately, this does not hold for older dune-common
modules and dunecontrol will error out later with a message like

/usr/local/lib/dunecontrol: file not found
Execution of dunecontrol terminated due to errors!

With this commit we fix this by actually checking whether the
lib/dunecontrol subdirectoy exists before adding it to
DUNE_CONTROL_PATH.

Thanks a lot to wuhao sife for reporting this problem.

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.