[static_assert] move AlwaysTrue and AlwaysFalse to typetraits.hh

dune/common/static_assert.hh

@@ -17,106 +17,13 @@
 
 /**
     \brief Helper template so that compilation fails if condition is not true.
-
-    \code
-   #include <dune/common/static_assert.hh>
-    dune_static_assert(CONDITION, ERRORMSG);
-    \endcode
-
-    If CONDITION is not true, dune_static_assert fails.
-
-    If the C++0x language feature static_assert is available, dune_static_assert
-    forwards everything to static_assert. Otherwise dune_static_assert implements a
-    test that triggers a compile time error if the condition is false.
-
-    Example:
-
-    \code
-    dune_static_assert(1<=2, "error");
-    dune_static_assert((is_same<int,int>::value),  "error msg");
-    dune_static_assert((is_same<bool,int>::value), "error msg"); // false, will trigger a compile time error
-    \endcode
-
-    \note
-    \code
-    dune_static_assert(false, "error");
-    \endcode
-    will usually not do what was intended, see Dune::AlwaysFalse for a way to
-    achieve the desired result.
-
-    Be aware that...
-    <ol>
-    <li>dune_static_assert is not in the namespace Dune</li>
-    <li>you must use extra parentheses if your condition contains ','.
-    This is because dune_static_assert is a preprocessor macro</li>
-    </ol>
-
     \deprecated Use static_assert from C++11 instead.
  */
 
 #define dune_static_assert(COND,MSG) \
   static_assert(COND,MSG)
 
-namespace Dune {
-  /**
-     \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;
-     };
-     \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;
-     };
-     \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 {
-    //! always a false value
-    static const bool value = false;
-  };
-
-  /**
-     \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 {
-    //! always a true value
-    static const bool value = true;
-  };
-} // namespace Dune
+#include "typetraits.hh"
 
 /* @} */
 

dune/common/typetraits.hh

@@ -455,6 +455,65 @@ namespace Dune
     : public __remove_pointer_helper<typename remove_const<_Tp>::type >
     { };
 
+  /**
+     \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 {
+       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 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 {
+       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 static_assert() until the
+     type of T is known, that is, until Traits<T> is instantiated.
+   */
+  template<typename T>
+  struct AlwaysFalse {
+    //! always a false value
+    static const bool value = false;
+  };
+
+  /**
+     \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 {
+    //! always a true value
+    static const bool value = true;
+  };
+
   /** @} */
 }
 #endif