Create branches/filesystem-v3 for v2 removal

[SVN r77385]

doc/Jamfile.v2

@@ -5,16 +5,35 @@
 
 using quickbook ;
 
+path-constant boost-images : ../../../doc/src/images ;
+
 xml static_assert : static_assert.qbk ;
 boostbook standalone
     :
         static_assert
     :
+        <xsl:param>boost.root=../../../..
         <xsl:param>nav.layout=none
         <xsl:param>navig.graphics=0
+        # PDF Options:
+        # TOC Generation: this is needed for FOP-0.9 and later:
+        <xsl:param>fop1.extensions=0
+        # Or enable this if you're using XEP:
+        <xsl:param>xep.extensions=1
+        # TOC generation: this is needed for FOP 0.2, but must not be set to zero for FOP-0.9!
+        <xsl:param>fop.extensions=0
+        # No indent on body text:
+        <xsl:param>body.start.indent=0pt
+        # Margin size:
+        <xsl:param>page.margin.inner=0.5in
+        # Margin size:
+        <xsl:param>page.margin.outer=0.5in
+        # Yes, we want graphics for admonishments:
+        <xsl:param>admon.graphics=1
+        # Set this one for PDF generation *only*:
+        # default pnd graphics are awful in PDF form,
+        # better use SVG's instead:
+        <format>pdf:<xsl:param>admon.graphics.extension=".svg"
+        <format>pdf:<xsl:param>admon.graphics.path=$(boost-images)/
+        <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/doc/html
     ;
-
-install html : ../../../doc/html/boostbook.css ;
-install ../ : ../../../boost.png ;
-
-

doc/static_assert.qbk

@@ -15,17 +15,34 @@
     [last-revision $Date$]
 ]
 
+This manual is also available in 
+[@http://sourceforge.net/projects/boost/files/boost-docs/ 
+printer friendly PDF format].
+
 [section:intro Overview and Tutorial]
 
-The header `<boost/static_assert.hpp>` supplies a single macro `BOOST_STATIC_ASSERT(x)`, 
-which generates a compile time error message if the integral-constant-expression `x`
-is not true. In other words it is the compile time equivalent of the assert macro; 
+The header `<boost/static_assert.hpp>` supplies two macros:
+
+   BOOST_STATIC_ASSERT(x)
+   BOOST_STATIC_ASSERT_MSG(x, msg)
+   
+Both generate a compile time error message if the integral-constant-expression `x`
+is not true. In other words, they are the compile time equivalent of the assert macro; 
 this is sometimes known as a "compile-time-assertion", but will be called a 
 "static assertion" throughout these docs. Note that if the condition is `true`, 
-then the macro will generate neither code nor data - and the macro can also 
+then the macros will generate neither code nor data - and the macros can also 
 be used at either namespace, class or function scope. When used in a template, 
 the static assertion will be evaluated at the time the template is instantiated; 
-this is particularly useful for validating template parameters. 
+this is particularly useful for validating template parameters.
+
+If the C++0x `static_assert` feature is available, both macros will use it.
+For `BOOST_STATIC_ASSERT(x)`, the error message with be a stringized version of `x`.
+For `BOOST_STATIC_ASSERT_MSG(x, msg)`, the error message will be the `msg` string.
+
+If the C++0x `static_assert` feature is not available, `BOOST_STATIC_ASSERT_MSG(x, msg)`
+will be treated as `BOOST_STATIC_ASSERT(x)`.
+
+The material that follows assumes the C++0x `static_assert` feature is not available.
 
 One of the aims of `BOOST_STATIC_ASSERT` is to generate readable error messages. 
 These immediately tell the user that a library is being used in a manner that 
@@ -94,12 +111,17 @@ the user that the template is being misused.
    #include <boost/type_traits.hpp>
 
    template <class RandomAccessIterator >
-   RandomAccessIterator foo(RandomAccessIterator from, RandomAccessIterator to)
+   RandomAccessIterator foo(RandomAccessIterator from, 
+                            RandomAccessIterator to)
    {
       // this template can only be used with
       // random access iterators...
-      typedef typename std::iterator_traits< RandomAccessIterator >::iterator_category cat;
-      BOOST_STATIC_ASSERT((boost::is_convertible<cat, const std::random_access_iterator_tag&>::value));
+      typedef typename std::iterator_traits< 
+            RandomAccessIterator >::iterator_category cat;
+      BOOST_STATIC_ASSERT(
+         (boost::is_convertible<
+            cat, 
+            const std::random_access_iterator_tag&>::value));
       //
       // detail goes here...
       return from;
@@ -122,7 +144,7 @@ Suppose we have a template-class that requires an unsigned integral type with
 at least 16-bits of precision as a template argument, we can achieve this 
 using something like this:
 
-   #include <climits>
+   #include <limits>
    #include <boost/static_assert.hpp>
 
    template <class UnsignedInt>

include/boost/static_assert.hpp

@@ -17,6 +17,12 @@
 #include <boost/config.hpp>
 #include <boost/detail/workaround.hpp>
 
+#ifndef BOOST_NO_STATIC_ASSERT
+#  define BOOST_STATIC_ASSERT_MSG( B, Msg ) static_assert(B, Msg)
+#else
+#  define BOOST_STATIC_ASSERT_MSG( B, Msg ) BOOST_STATIC_ASSERT( B )
+#endif
+
 #ifdef __BORLANDC__
 //
 // workaround for buggy integral-constant expression support:
@@ -28,7 +34,17 @@
 #  define BOOST_SA_GCC_WORKAROUND
 #endif
 
-#ifdef BOOST_HAS_STATIC_ASSERT
+//
+// If the compiler issues warnings about old C style casts,
+// then enable this:
+//
+#if defined(__GNUC__) && ((__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4)))
+#  define BOOST_STATIC_ASSERT_BOOL_CAST( x ) ((x) == 0 ? false : true)
+#else
+#  define BOOST_STATIC_ASSERT_BOOL_CAST(x) (bool)(x)
+#endif
+
+#ifndef BOOST_NO_STATIC_ASSERT
 #  define BOOST_STATIC_ASSERT( B ) static_assert(B, #B)
 #else
 
@@ -78,14 +94,14 @@ template<int x> struct static_assert_test{};
 #elif defined(BOOST_MSVC)
 #define BOOST_STATIC_ASSERT( B ) \
    typedef ::boost::static_assert_test<\
-      sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( B ) >)>\
+      sizeof(::boost::STATIC_ASSERTION_FAILURE< BOOST_STATIC_ASSERT_BOOL_CAST ( B ) >)>\
          BOOST_JOIN(boost_static_assert_typedef_, __COUNTER__)
 #elif defined(BOOST_INTEL_CXX_VERSION) || defined(BOOST_SA_GCC_WORKAROUND)
 // agurt 15/sep/02: a special care is needed to force Intel C++ issue an error 
 // instead of warning in case of failure
 # define BOOST_STATIC_ASSERT( B ) \
     typedef char BOOST_JOIN(boost_static_assert_typedef_, __LINE__) \
-        [ ::boost::STATIC_ASSERTION_FAILURE< (bool)( B ) >::value ]
+        [ ::boost::STATIC_ASSERTION_FAILURE< BOOST_STATIC_ASSERT_BOOL_CAST( B ) >::value ]
 #elif defined(__sgi)
 // special version for SGI MIPSpro compiler
 #define BOOST_STATIC_ASSERT( B ) \
@@ -100,12 +116,12 @@ template<int x> struct static_assert_test{};
 #define BOOST_STATIC_ASSERT( B ) \
    BOOST_STATIC_CONSTANT(int, \
      BOOST_JOIN(boost_static_assert_test_, __LINE__) = \
-       sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( B ) >) )
+       sizeof(::boost::STATIC_ASSERTION_FAILURE< BOOST_STATIC_ASSERT_BOOL_CAST( B ) >) )
 #else
 // generic version
 #define BOOST_STATIC_ASSERT( B ) \
    typedef ::boost::static_assert_test<\
-      sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( B ) >)>\
+      sizeof(::boost::STATIC_ASSERTION_FAILURE< BOOST_STATIC_ASSERT_BOOL_CAST( B ) >)>\
          BOOST_JOIN(boost_static_assert_typedef_, __LINE__)
 #endif
 
@@ -115,7 +131,7 @@ template<int x> struct static_assert_test{};
    enum { BOOST_JOIN(boost_static_assert_enum_, __LINE__) \
       = sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( B ) >) }
 #endif
-#endif // ndef BOOST_HAS_STATIC_ASSERT
+#endif // defined(BOOST_NO_STATIC_ASSERT)
 
 #endif // BOOST_STATIC_ASSERT_HPP
 

static_assert_example_2.cpp

@@ -12,7 +12,7 @@
 #include <boost/type_traits.hpp>
 
 template <class RandomAccessIterator >
-RandomAccessIterator foo(RandomAccessIterator from, RandomAccessIterator to)
+RandomAccessIterator foo(RandomAccessIterator from, RandomAccessIterator /*to*/)
 {
    // this template can only be used with
    // random access iterators...

static_assert_example_3.cpp

@@ -5,7 +5,7 @@
 
 //  See http://www.boost.org for most recent version including documentation.
 
-#include <climits>
+#include <limits>
 #include <boost/limits.hpp>
 #include <boost/static_assert.hpp>
 

static_assert_test.cpp

@@ -16,12 +16,16 @@
 // Namespace scope
 BOOST_STATIC_ASSERT(sizeof(int) >= sizeof(short));
 BOOST_STATIC_ASSERT(sizeof(char) == 1);
+BOOST_STATIC_ASSERT_MSG(sizeof(int) >= sizeof(short), "msg1");
+BOOST_STATIC_ASSERT_MSG(sizeof(char) == 1, "msg2");
 
 // Function (block) scope
 void f()
 {
   BOOST_STATIC_ASSERT(sizeof(int) >= sizeof(short));
   BOOST_STATIC_ASSERT(sizeof(char) == 1);
+  BOOST_STATIC_ASSERT_MSG(sizeof(int) >= sizeof(short), "msg3");
+  BOOST_STATIC_ASSERT_MSG(sizeof(char) == 1, "msg4");
 }
 
 struct Bob
@@ -29,6 +33,8 @@ struct Bob
   private:  // can be in private, to avoid namespace pollution
     BOOST_STATIC_ASSERT(sizeof(int) >= sizeof(short));
     BOOST_STATIC_ASSERT(sizeof(char) == 1);
+    BOOST_STATIC_ASSERT_MSG(sizeof(int) >= sizeof(short), "msg5");
+    BOOST_STATIC_ASSERT_MSG(sizeof(char) == 1, "msg6");
   public:
 
   // Member function scope: provides access to member variables
@@ -36,9 +42,11 @@ struct Bob
   char c;
   int f()
   {
-#ifndef _MSC_VER // broken sizeof in VC6
+#if defined(_MSC_VER) && _MSC_VER < 1300 // broken sizeof in VC6
     BOOST_STATIC_ASSERT(sizeof(x) >= sizeof(short));
     BOOST_STATIC_ASSERT(sizeof(c) == 1);
+    BOOST_STATIC_ASSERT_MSG(sizeof(x) >= sizeof(short), "msg7");
+    BOOST_STATIC_ASSERT_MSG(sizeof(c) == 1, "msg8");
 #endif
     return x;
   }
@@ -52,6 +60,7 @@ struct Bill
 {
   private:  // can be in private, to avoid namespace pollution
     BOOST_STATIC_ASSERT(sizeof(Int) > sizeof(char));
+    BOOST_STATIC_ASSERT_MSG(sizeof(Int) > sizeof(char), "msg9");
   public:
 
   // Template member function scope: provides access to member variables
@@ -62,10 +71,12 @@ struct Bill
   {
     BOOST_STATIC_ASSERT(sizeof(Int) == sizeof(Int2));
     BOOST_STATIC_ASSERT(sizeof(Char) == sizeof(Char2));
+    BOOST_STATIC_ASSERT_MSG(sizeof(Int) == sizeof(Int2), "msg10");
+    BOOST_STATIC_ASSERT_MSG(sizeof(Char) == sizeof(Char2), "msg11");
   }
 };
 
-void test_Bill() // BOOST_CT_ASSERTs are not triggerred until instantiated
+void test_Bill() // BOOST_STATIC_ASSERTs are not triggerred until instantiated
 {
   Bill<int, char> z;
   //Bill<int, int> bad; // will not compile