From a332bd4a26b53470fb4f7fca7f1f90a849fbbcdb Mon Sep 17 00:00:00 2001
From: Christian Engwer <christi@dune-project.org>
Date: Fri, 5 Oct 2012 09:12:07 +0000
Subject: [PATCH] [doc] fix \code blocks in static_assert.hh
[[Imported from SVN: r7023]]
---
dune/common/static_assert.hh | 76 ++++++++++++++++++------------------
1 file changed, 38 insertions(+), 38 deletions(-)
diff --git a/dune/common/static_assert.hh b/dune/common/static_assert.hh
index 6c66ed31b..510cf8c79 100644
--- a/dune/common/static_assert.hh
+++ b/dune/common/static_assert.hh
@@ -58,7 +58,7 @@ template<int x> struct static_assert_test {};
\note
\code
- dune_static_assert(false, "error");
+ dune_static_assert(false, "error");
\endcode
will usually not do what was intended, see Dune::AlwaysFalse for a way to
achieve the desired result.
@@ -83,45 +83,45 @@ template<int x> struct static_assert_test {};
#endif
namespace Dune {
- //! template which always yields a false value
/**
- * \tparam T Some type. It sould be a type expression involving template
- * parameters of the class or function using AlwaysFalse.
- *
- * Suppose you have a template class. You want to document the required
- * members of this class in the non-specialized template, but you know that
- * actually instantiating the non-specialized template is an error. You
- * can try something like this:
- * \code
+ \brief template which always yields a false value
+ \tparam T Some type. It sould be a type expression involving template
+ parameters of the class or function using AlwaysFalse.
+
+ Suppose you have a template class. You want to document the required
+ members of this class in the non-specialized template, but you know that
+ actually instantiating the non-specialized template is an error. You
+ can try something like this:
+ \code
template<typename T>
struct Traits {
- dune_static_assert(false,
- "Instanciating this non-specialized template is an "
- "error. You should use one of the specializations "
- "instead.");
- //! The type used to frobnicate T
- typedef void FrobnicateType;
+ dune_static_assert(false,
+ "Instanciating this non-specialized template is an "
+ "error. You should use one of the specializations "
+ "instead.");
+ //! The type used to frobnicate T
+ typedef void FrobnicateType;
};
- * \endcode
- * This will trigger dune_static_assert() as soon as the compiler reads the
- * definition for the Traits template, since it knows that "false" can
- * never become true, no matter what the template parameters of Traits are.
- * As a workaround you can use AlwaysFalse: replace <tt>false</tt> by
- * <tt>AlwaysFalse<T>::value</tt>, like this:
- * \code
+ \endcode
+ This will trigger dune_static_assert() as soon as the compiler reads the
+ definition for the Traits template, since it knows that "false" can
+ never become true, no matter what the template parameters of Traits are.
+ As a workaround you can use AlwaysFalse: replace <tt>false</tt> by
+ <tt>AlwaysFalse<T>::value</tt>, like this:
+ \code
template<typename T>
struct Traits {
- dune_static_assert(AlwaysFalse<T>::value,
- "Instanciating this non-specialized template is an "
- "error. You should use one of the specializations "
- "instead.");
- //! The type used to frobnicate T
- typedef void FrobnicateType;
+ dune_static_assert(AlwaysFalse<T>::value,
+ "Instanciating this non-specialized template is an "
+ "error. You should use one of the specializations "
+ "instead.");
+ //! The type used to frobnicate T
+ typedef void FrobnicateType;
};
- * \endcode
- * Since there might be an specialization of AlwaysFalse for template
- * parameter T, the compiler cannot trigger dune_static_assert() until the
- * type of T is known, that is, until Traits<T> is instantiated.
+ \endcode
+ Since there might be an specialization of AlwaysFalse for template
+ parameter T, the compiler cannot trigger dune_static_assert() until the
+ type of T is known, that is, until Traits<T> is instantiated.
*/
template<typename T>
struct AlwaysFalse {
@@ -129,12 +129,12 @@ namespace Dune {
static const bool value = false;
};
- //! template which always yields a true value
/**
- * \tparam T Some type. It sould be a type expression involving template
- * parameters of the class or function using AlwaysTrue.
- *
- * \note This class exists mostly for consistency with AlwaysFalse.
+ \brief template which always yields a true value
+ \tparam T Some type. It sould be a type expression involving template
+ parameters of the class or function using AlwaysTrue.
+
+ \note This class exists mostly for consistency with AlwaysFalse.
*/
template<typename T>
struct AlwaysTrue {
--
GitLab