This commit was manufactured by cvs2svn to create branch

'function_signature_patches_1_31'. [SVN r22633]
2004-04-13 12:19:16 +00:00
78 changed files with 1416 additions and 1170 deletions
--- a/Assignable.html
+++ b/Assignable.html
@@ -15,7 +15,7 @@
 </HEAD>
 <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
        ALINK="#ff0000"> 
-<IMG SRC="../../boost.png" 
+<IMG SRC="../../c++boost.gif" 
     ALT="C++ Boost" width="277" height="86"> 
 <!--end header-->
 <BR Clear>
--- a/Collection.html
+++ b/Collection.html
@@ -17,7 +17,7 @@
 <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
 	ALINK="#ff0000"> 
 <h1>
-   <img src="../../boost.png" alt="boost logo"
+   <img src="../../c++boost.gif" alt="boost logo"
    width="277" align="middle" height="86">
   <br>Collection
 </h1>
--- a/CopyConstructible.html
+++ b/CopyConstructible.html
@@ -15,7 +15,7 @@
 </HEAD>
 <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
        ALINK="#ff0000"> 
-<IMG SRC="../../boost.png" 
+<IMG SRC="../../c++boost.gif" 
     ALT="C++ Boost" width="277" height="86"> 
 <!--end header-->
 <BR Clear>
--- a/LessThanComparable.html
+++ b/LessThanComparable.html
@@ -39,7 +39,7 @@
 </Head>
 <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
        ALINK="#ff0000"> 
-<IMG SRC="../../boost.png" 
+<IMG SRC="../../c++boost.gif" 
     ALT="C++ Boost" width="277" height="86"> 
 <!--end header-->
 <BR Clear>
--- a/MultiPassInputIterator.html
+++ b/MultiPassInputIterator.html
@@ -14,7 +14,7 @@
 <Title>MultiPassInputIterator</Title>
 <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
 	ALINK="#ff0000"> 
-<IMG SRC="../../boost.png" 
+<IMG SRC="../../c++boost.gif" 
     ALT="C++ Boost" width="277" height="86"> 

 <BR Clear>
--- a/OptionalPointee.html
+++ b/OptionalPointee.html
@@ -4,7 +4,7 @@
 </HEAD>
 <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
        ALINK="#ff0000"> 
-<IMG SRC="../../boost.png" 
+<IMG SRC="../../c++boost.gif" 
     ALT="C++ Boost" width="277" height="86"> 
 <!--end header-->
 <BR Clear>
--- a/addressof_test.cpp
+++ b/addressof_test.cpp
@@ -1,9 +1,14 @@
 // Copyright (C) 2002 Brad King (brad.king@kitware.com) 
-//                    Douglas Gregor (gregod@cs.rpi.edu)
+//                    Doug Gregor (gregod@cs.rpi.edu)
 //
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+// Permission to copy, use, sell and distribute this software is granted
+// provided this copyright notice appears in all copies.
+// Permission to modify the code and to distribute modified code is granted
+// provided this copyright notice appears in all copies, and a notice
+// that the code was modified is included with the copyright notice.
+//
+// This software is provided "as is" without express or implied warranty,
+// and with no claim as to its suitability for any purpose.

 // For more information, see http://www.boost.org

--- a/assert.html
+++ b/assert.html
@@ -8,7 +8,7 @@
 		<table border="0" width="100%">
 			<tr>
 				<td width="277">
-					<img src="../../boost.png" alt="boost.png (6897 bytes)" width="277" height="86">
+					<img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" width="277" height="86">
 				</td>
 				<td align="middle">
 					<h1>assert.hpp</h1>
--- a/assert_test.cpp
+++ b/assert_test.cpp
@@ -3,9 +3,10 @@
 //
 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
 //
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+//  Permission to copy, use, modify, sell and distribute this software
+//  is granted provided this copyright notice appears in all copies.
+//  This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
 //

 #include <boost/detail/lightweight_test.hpp>
@@ -51,18 +52,13 @@ void test_disabled()

 #define BOOST_ENABLE_ASSERT_HANDLER
 #include <boost/assert.hpp>
-#include <boost/config.hpp>
 #include <cstdio>

 int handler_invoked = 0;

 void boost::assertion_failed(char const * expr, char const * function, char const * file, long line)
 {
-#if !defined(BOOST_NO_STDC_NAMESPACE)
-    using std::printf;
-#endif
-
-    printf("Expression: %s\nFunction: %s\nFile: %s\nLine: %ld\n\n", expr, function, file, line);
+    std::printf("Expression: %s\nFunction: %s\nFile: %s\nLine: %ld\n\n", expr, function, file, line);
    ++handler_invoked;
 }

--- a/base_from_member.html
+++ b/base_from_member.html
@@ -5,14 +5,15 @@
 </head>

 <body bgcolor="white" link="blue" text="black" vlink="purple" alink="red"> 
-<h1><img src="../../boost.png" alt="C++ Boost" align="middle"
+<h1><img src="../../c++boost.gif" alt="C++ Boost" align="middle"
 width="277" height="86">Base-from-Member Idiom</h1>

 <p>The class template <code>boost::base_from_member</code> provides
 a workaround for a class that needs to initialize a base class with a
 member.  The class template is in <cite><a
 href="../../boost/utility/base_from_member.hpp">boost/utility/base_from_member.hpp</a></cite>
-which is included in <i><a href="../../boost/utility.hpp">boost/utility.hpp</a></i>.</p>
+which is included in <i><a href="../../boost/utility.hpp">boost/utility.hpp</a></i>.
+The class template is forward declared in <i><a href="../../boost/utility_fwd.hpp">boost/utility_fwd.hpp</a></i>.</p>

 <p>There is test/example code in <cite><a
 href="base_from_member_test.cpp">base_from_member_test.cpp</a></cite>.</p>
@@ -129,10 +130,6 @@ particular member type does not need to concern itself with the integer.</p>
 <h2><a name="synopsis">Synopsis</a></h2>

 <blockquote><pre>
-#ifndef BOOST_BASE_FROM_MEMBER_MAX_ARITY
-#define BOOST_BASE_FROM_MEMBER_MAX_ARITY  10
-#endif
-
 template &lt; typename MemberType, int UniqueID = 0 &gt;
 class boost::base_from_member
 {
@@ -174,14 +171,6 @@ the template parameters of a templated constructor, make sure that
 the arguments are already close as possible to the actual type used in
 the data member's desired constructor.</p>

-<p>The <var>BOOST_BASE_FROM_MEMBER_MAX_ARITY</var> macro constant specifies
-the maximum argument length for the constructor templates.  The constant
-may be overridden if more (or less) argument configurations are needed.  The
-constant may be read for code that is expandable like the class template and
-needs to maintain the same maximum size.  (Example code would be a class that
-uses this class template as a base class for a member with a flexible set of
-constructors.)</p>
-
 <h2><a name="usage">Usage</a></h2>

 <p>With the starting example, the <code>fdoutbuf</code> sub-object needs
@@ -348,11 +337,6 @@ with the exact pointer type used in <code>switcher</code>'s constructor.</p>
 		<a href="http://www.informatik.uni-konstanz.de/~kuehl/c++/iostream/">IOStream
 		example classes</a>.

-	<dt>Jonathan Turkanis
-	<dd>Supplied an implementation of generating the constructor templates that
-		can be controlled and automated with macros.  The implementation uses
-		the <a href="../preprocessor/">Preprocessor library</a>.
-
 	<dt><a href="../../people/daryle_walker.html">Daryle Walker</a>
 	<dd>Started the library.  Contributed the test file <cite><a
 		href="base_from_member_test.cpp">base_from_member_test.cpp</a></cite>.
@@ -360,9 +344,9 @@ with the exact pointer type used in <code>switcher</code>'s constructor.</p>

 <hr>

-<p>Revised: 28 August 2004</p>
+<p>Revised: 14 June 2003</p>

-<p>Copyright 2001, 2003, 2004 Daryle Walker.  Use, modification, and distribution
+<p>Copyright 2001, 2003 Daryle Walker.  Use, modification, and distribution
 are subject to the Boost Software License, Version 1.0.  (See accompanying
 file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or a copy at &lt;<a
 href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>&gt;.)</p>
--- a/binary_search_test.cpp
+++ b/binary_search_test.cpp
@@ -1,7 +1,8 @@
-// (C) Copyright David Abrahams 2000.
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+// (C) Copyright David Abrahams 2000. Permission to copy, use, modify,
+// sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.

 #include <vector>
 #include <string>
@@ -14,7 +15,6 @@
 #include <algorithm>
 #include <boost/detail/binary_search.hpp>
 #include <boost/detail/workaround.hpp>
-#include <cstddef>

 #if defined(__SGI_STL_PORT) ? defined(__SGI_STL_OWN_IOSTREAMS) : (!defined(__GNUC__) || __GNUC__ > 2)
 # define USE_SSTREAM
--- a/call_traits.htm
+++ b/call_traits.htm
@@ -12,7 +12,7 @@ content="C:\PROGRAM FILES\MICROSOFT OFFICE\OFFICE\html.dot">
 <body bgcolor="#FFFFFF" text="#000000" link="#0000FF"
 vlink="#800080">

-<h1><img src="../../boost.png" width="276" height="86">Header
+<h1><img src="../../c++boost.gif" width="276" height="86">Header
 &lt;<a href="../../boost/detail/call_traits.hpp">boost/call_traits.hpp</a>&gt;</h1>

 <p>All of the contents of &lt;boost/call_traits.hpp&gt; are
--- a/checked_delete.html
+++ b/checked_delete.html
@@ -8,7 +8,7 @@
 		<table border="0" width="100%">
 			<tr>
 				<td width="277">
-					<img src="../../boost.png" alt="boost.png (6897 bytes)" width="277" height="86">
+					<img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" width="277" height="86">
 				</td>
 				<td align="middle">
 					<h1>checked_delete.hpp</h1>
--- a/checked_delete_test.cpp
+++ b/checked_delete_test.cpp
@@ -1,8 +1,7 @@
 //  Boost checked_delete test program  ---------------------------------------//

-//  Copyright Beman Dawes 2001.  Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//  Copyright Beman Dawes 2001.
+//  See accompanying license for terms and conditions of use.

 //  See http://www.boost.org/libs/utility for documentation.

--- a/compressed_pair.htm
+++ b/compressed_pair.htm
@@ -13,7 +13,7 @@ content="C:\PROGRAM FILES\MICROSOFT OFFICE\OFFICE\html.dot">
 <body bgcolor="#FFFFFF" text="#000000" link="#0000FF"
 vlink="#800080">

-<h2><img src="../../boost.png" width="276" height="86">Header
+<h2><img src="../../c++boost.gif" width="276" height="86">Header
 &lt;<a href="../../boost/detail/compressed_pair.hpp">boost/compressed_pair.hpp</a>&gt;</h2>

 <p>All of the contents of &lt;boost/compressed_pair.hpp&gt; are
--- a/counting_iterator_example.cpp
+++ b/counting_iterator_example.cpp
@@ -0,0 +1,60 @@
+// (C) Copyright Jeremy Siek 2000. Permission to copy, use, modify, sell and
+// distribute this software is granted provided this copyright notice appears
+// in all copies. This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+
+
+#include <boost/config.hpp>
+#include <algorithm>
+#include <iostream>
+#include <iterator>
+#include <vector>
+#include <boost/iterator/counting_iterator.hpp>
+#include <boost/iterator/indirect_iterator.hpp>
+
+int main(int, char*[])
+{
+  // Example of using counting_iterator_generator
+  std::cout << "counting from 0 to 4:" << std::endl;
+  boost::counting_iterator<int> first(0), last(4);
+  std::copy(first, last, std::ostream_iterator<int>(std::cout, " "));
+  std::cout << std::endl;
+
+  // Example of using make_counting_iterator()
+  std::cout << "counting from -5 to 4:" << std::endl;
+  std::copy(boost::make_counting_iterator(-5),
+            boost::make_counting_iterator(5),
+            std::ostream_iterator<int>(std::cout, " "));
+  std::cout << std::endl;
+
+  // Example of using counting iterator to create an array of pointers.
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
+  const
+#endif 
+      int N = 7;
+  std::vector<int> numbers;
+  // Fill "numbers" array with [0,N)
+  std::copy(
+      boost::make_counting_iterator(0)
+      , boost::make_counting_iterator(N)
+      , std::back_inserter(numbers));
+
+  std::vector<std::vector<int>::iterator> pointers;
+
+  // Use counting iterator to fill in the array of pointers.
+  // causes an ICE with MSVC6
+  std::copy(boost::make_counting_iterator(numbers.begin()),
+            boost::make_counting_iterator(numbers.end()),
+            std::back_inserter(pointers));
+
+  // Use indirect iterator to print out numbers by accessing
+  // them through the array of pointers.
+  std::cout << "indirectly printing out the numbers from 0 to " 
+            << N << std::endl;
+  std::copy(boost::make_indirect_iterator(pointers.begin()),
+            boost::make_indirect_iterator(pointers.end()),
+            std::ostream_iterator<int>(std::cout, " "));
+  std::cout << std::endl;
+  
+  return 0;
+}
--- a/current_function.html
+++ b/current_function.html
@@ -8,7 +8,7 @@
 		<table border="0" width="100%">
 			<tr>
 				<td width="277">
-					<img src="../../boost.png" alt="boost.png (6897 bytes)" width="277" height="86">
+					<img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" width="277" height="86">
 				</td>
 				<td align="middle">
 					<h1>current_function.hpp</h1>
--- a/current_function_test.cpp
+++ b/current_function_test.cpp
@@ -12,22 +12,18 @@
 //
 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
 //
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+//  Permission to copy, use, modify, sell and distribute this software
+//  is granted provided this copyright notice appears in all copies.
+//  This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
 //

 #include <boost/current_function.hpp>
-#include <boost/config.hpp>
 #include <cstdio>

 void message(char const * file, long line, char const * func, char const * msg)
 {
-#if !defined(BOOST_NO_STDC_NAMESPACE)
-    using std::printf;
-#endif
-
-    printf("%s(%ld): %s in function '%s'\n", file, line, msg, func);
+    std::printf("%s(%ld): %s in function '%s'\n", file, line, msg, func);
 }

 #define MESSAGE(msg) message(__FILE__, __LINE__, BOOST_CURRENT_FUNCTION, msg)
@@ -35,6 +31,4 @@ void message(char const * file, long line, char const * func, char const * msg)
 int main()
 {
    MESSAGE("assertion failed");
-
-    return 0;
 }
--- a/enable_if.html
+++ b/enable_if.html
@@ -17,7 +17,7 @@


 <h1>
-<img border="0" src="../../boost.png" align="center" width="277" height="86">enable_if</h1>
+<img border="0" src="../../c++boost.gif" align="center" width="277" height="86">enable_if</h1>
 <BR>
 <BR>
 Copyright 2003 Jaakko J&auml;rvi, Jeremiah Willcock, Andrew Lumsdaine.<BR>
@@ -128,7 +128,7 @@ When valid, <TT>enable_if_c&lt;B, T&gt;::type</TT> equals <TT>T</TT>.
 The <TT>enable_if_c</TT> template can thus be used for controlling when functions are considered for
 overload resolution and when they are not. 
 For example, the following function is defined for all arithmetic types (according to the
-classification of the <A HREF="../type_traits/index.html">Boost type_traits library</A>):
+classification of the <A HREF="http://www.boost.org/libs/type_traits">Boost type_traits library</A>):
 <PRE>template &lt;class T&gt;
 typename enable_if_c&lt;boost::is_arithmetic&lt;T&gt;::value, T&gt;::type 
 foo(T t) { return t; }
@@ -303,7 +303,7 @@ foo(T t);
 <UL><LI>
 Use an extra dummy parameter which disambiguates the functions. Use a default value for
 it to hide the parameter from the caller. For example:
-<PRE>template &lt;int&gt; struct dummy { dummy(int) {} };
+<PRE>template &lt;class T&gt; struct dummy { dummy(int) {} };

 template &lt;class T&gt;
 typename enable_if&lt;boost::is_arithmetic&lt;T&gt;, T&gt;::type 
--- a/enable_if/test/Jamfile
+++ b/enable_if/test/Jamfile
@@ -1,33 +0,0 @@
-# Copyright David Abrahams 2003.
-# Distributed under the Boost Software License, Version 1.0. 
-# (See accompanying file LICENSE_1_0.txt or copy at 
-# http://www.boost.org/LICENSE_1_0.txt)
-
-# For more information, see http://www.boost.org/
-
-subproject libs/utility/enable_if/test ;
-
-# bring in rules for testing
-import testing ;
-
-# Make tests run by default.
-DEPENDS all : test ;
-
-{
-    local test_monitor = <lib>@boost/libs/test/build/boost_test_exec_monitor ;
-
-    # look in BOOST_ROOT for sources first, just in this Jamfile
-    local SEARCH_SOURCE = $(BOOST_ROOT) $(SEARCH_SOURCE) ;
-
-    test-suite utility/enable_if
-        :
-        [ run libs/utility/enable_if/test/constructors.cpp $(test_monitor) ]
-        [ run libs/utility/enable_if/test/dummy_arg_disambiguation.cpp $(test_monitor) ]
-        [ run libs/utility/enable_if/test/lazy.cpp $(test_monitor) ]
-        [ run libs/utility/enable_if/test/lazy_test.cpp $(test_monitor) ]
-        [ run libs/utility/enable_if/test/member_templates.cpp $(test_monitor) ]
-        [ run libs/utility/enable_if/test/namespace_disambiguation.cpp $(test_monitor) ]
-        [ run libs/utility/enable_if/test/no_disambiguation.cpp $(test_monitor) ]
-        [ run libs/utility/enable_if/test/partial_specializations.cpp $(test_monitor) ]
-    ;
-}
--- a/enable_if/test/constructors.cpp
+++ b/enable_if/test/constructors.cpp
--- a/enable_if/test/dummy_arg_disambiguation.cpp
+++ b/enable_if/test/dummy_arg_disambiguation.cpp
--- a/enable_if/test/lazy.cpp
+++ b/enable_if/test/lazy.cpp
--- a/enable_if/test/lazy_test.cpp
+++ b/enable_if/test/lazy_test.cpp
--- a/enable_if/test/member_templates.cpp
+++ b/enable_if/test/member_templates.cpp
--- a/enable_if/test/namespace_disambiguation.cpp
+++ b/enable_if/test/namespace_disambiguation.cpp
--- a/enable_if/test/no_disambiguation.cpp
+++ b/enable_if/test/no_disambiguation.cpp
--- a/enable_if/test/partial_specializations.cpp
+++ b/enable_if/test/partial_specializations.cpp
--- a/filter_iterator_example.cpp
+++ b/filter_iterator_example.cpp
@@ -0,0 +1,62 @@
+// Example of using the filter iterator adaptor from
+// boost/iterator_adaptors.hpp.
+
+//  (C) Copyright Jeremy Siek 1999. Permission to copy, use, modify,
+//  sell and distribute this software is granted provided this
+//  copyright notice appears in all copies. This software is provided
+//  "as is" without express or implied warranty, and with no claim as
+//  to its suitability for any purpose.
+
+#include <boost/config.hpp>
+#include <algorithm>
+#include <functional>
+#include <iostream>
+#include <boost/iterator/filter_iterator.hpp>
+
+struct is_positive_number {
+  bool operator()(int x) { return 0 < x; }
+};
+
+int main()
+{
+  int numbers_[] = { 0, -1, 4, -3, 5, 8, -2 };
+  const int N = sizeof(numbers_)/sizeof(int);
+  
+  typedef int* base_iterator;
+  base_iterator numbers(numbers_);
+  
+  // Example using make_filter_iterator()
+  std::copy(boost::make_filter_iterator<is_positive_number>(numbers, numbers + N),
+            boost::make_filter_iterator<is_positive_number>(numbers + N, numbers + N),
+            std::ostream_iterator<int>(std::cout, " "));
+  std::cout << std::endl;
+
+  // Example using filter_iterator
+  typedef boost::filter_iterator<is_positive_number, base_iterator>
+    FilterIter;
+  
+  is_positive_number predicate;
+  FilterIter filter_iter_first(predicate, numbers, numbers + N);
+  FilterIter filter_iter_last(predicate, numbers + N, numbers + N);
+
+  std::copy(filter_iter_first, filter_iter_last, std::ostream_iterator<int>(std::cout, " "));
+  std::cout << std::endl;
+
+  // Another example using make_filter_iterator()
+  std::copy(
+      boost::make_filter_iterator(
+          std::bind2nd(std::greater<int>(), -2)
+        , numbers, numbers + N)
+            
+    , boost::make_filter_iterator(
+          std::bind2nd(std::greater<int>(), -2)
+        , numbers + N, numbers + N)
+      
+    , std::ostream_iterator<int>(std::cout, " ")
+  );
+  
+  std::cout << std::endl;
+  
+  
+  return 0;
+}
--- a/fun_out_iter_example.cpp
+++ b/fun_out_iter_example.cpp
@@ -0,0 +1,47 @@
+// (C) Copyright Jeremy Siek 2001. Permission to copy, use, modify,
+// sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+
+// Revision History:
+
+// 27 Feb 2001   Jeremy Siek
+//      Initial checkin.
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+#include <boost/function_output_iterator.hpp>
+
+struct string_appender
+{
+    string_appender(std::string& s)
+        : m_str(&s)
+    {}
+    
+    void operator()(const std::string& x) const
+    {
+        *m_str += x;
+    }
+
+    std::string* m_str;
+};
+
+int main(int, char*[])
+{
+  std::vector<std::string> x;
+  x.push_back("hello");
+  x.push_back(" ");
+  x.push_back("world");
+  x.push_back("!");
+
+  std::string s = "";
+  std::copy(x.begin(), x.end(), 
+            boost::make_function_output_iterator(string_appender(s)));
+  
+  std::cout << s << std::endl;
+
+  return 0;
+}
--- a/generator_iterator.htm
+++ b/generator_iterator.htm
@@ -7,7 +7,7 @@

 <body bgcolor="#FFFFFF" text="#000000">
        
-<img src="../../boost.png" alt="boost.png (6897 bytes)" align="center" width="277" height="86"> 
+<img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="center" width="277" height="86"> 

 <h1>Generator Iterator Adaptor</h1>
 Defined in header <a href="../../boost/generator_iterator.hpp">boost/generator_iterator.hpp</a> 
--- a/half_open_range_test.cpp
+++ b/half_open_range_test.cpp
@@ -0,0 +1,366 @@
+// (C) Copyright David Abrahams 2001. Permission to copy, use, modify, sell and
+// distribute this software is granted provided this copyright notice appears in
+// all copies. This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//  See http://www.boost.org for most recent version including documentation.
+//
+// Revision History
+// 11 Feb 2001  Compile with Borland, re-enable failing tests (David Abrahams)
+// 29 Jan 2001  Initial revision (David Abrahams)
+
+#include <boost/half_open_range.hpp>
+#include <boost/utility.hpp>
+#include <iterator>
+#include <stdlib.h>
+#include <vector>
+#include <list>
+#include <cassert>
+#include <stdexcept>
+#ifndef BOOST_NO_LIMITS
+# include <limits>
+#endif
+#ifndef BOOST_NO_SLIST
+# include <slist>
+#endif
+
+inline unsigned unsigned_random(unsigned max)
+{
+    return (max > 0) ? (unsigned)rand() % max : 0;
+}
+
+// Special tests for ranges supporting random access
+template <class T>
+void category_test_1(
+    const boost::half_open_range<T>& r, std::random_access_iterator_tag)
+{
+    typedef boost::half_open_range<T> range;
+    typedef typename range::size_type size_type;
+    size_type size = r.size();
+
+    // pick a random offset
+    size_type offset = unsigned_random(size);
+
+    typename range::value_type x = *(r.begin() + offset);
+    // test contains(value_type)
+    assert(r.contains(r.start()) == !r.empty());
+    assert(!r.contains(r.finish()));
+    assert(r.contains(x) == (offset != size));
+
+    range::const_iterator p = r.find(x);
+    assert((p == r.end()) == (x == r.finish()));
+    assert(r.find(r.finish()) == r.end());
+
+    if (offset != size)
+    {
+        assert(x == r[offset]);
+        assert(x == r.at(offset));
+    }
+
+    bool caught_out_of_range = false;
+    try {
+        bool never_initialized = x == r.at(size);
+        (void)never_initialized;
+    }
+    catch(std::out_of_range&)
+    {
+        caught_out_of_range = true;
+    }
+    catch(...)
+    {
+    }
+    assert(caught_out_of_range);
+}
+
+// Those tests must be skipped for other ranges
+template <class T>
+void category_test_1(
+    const boost::half_open_range<T>&, std::forward_iterator_tag)
+{
+}
+
+unsigned indices[][2] = { {0,0},{0,1},{0,2},{0,3},
+                                {1,1},{1,2},{1,3},
+                                      {2,2},{2,3},
+                                            {3,3}};
+
+template <class Range>
+void category_test_2(
+    const std::vector<Range>& ranges, unsigned i, unsigned j, std::random_access_iterator_tag)
+{
+    typedef Range range;
+    const range& ri = ranges[i];
+    const range& rj = ranges[j];
+
+    if (indices[i][0] <= indices[j][0] && indices[i][1] >= indices[j][1])
+        assert(ri.contains(rj));
+
+    if (ri.contains(rj))
+        assert((ri & rj) == rj);
+    assert(boost::intersects(ri, rj) == !(ri & rj).empty());
+
+    range t1(ri);
+    t1 &= rj;
+    assert(t1 == range(indices[i][0] > indices[j][0] ? ri.start() : rj.start(),
+                       indices[i][1] < indices[j][1] ? ri.finish() : rj.finish()));
+    assert(t1 == (ri & rj));
+    
+    range t2(ri);
+    t2 |= rj;
+    
+    if (ri.empty())
+        assert(t2 == rj);
+    else if (rj.empty())
+        assert(t2 == ri);
+    else
+        assert(t2 == range(indices[i][0] < indices[j][0] ? ri.start() : rj.start(),
+                           indices[i][1] > indices[j][1] ? ri.finish() : rj.finish()));
+    assert(t2 == (ri | rj));
+    if (i == j)
+        assert(ri == rj);
+    
+    if (ri.empty() || rj.empty())
+        assert((ri == rj) == (ri.empty() && rj.empty()));
+    else
+        assert((ri == rj) == (ri.start() == rj.start() && ri.finish() == rj.finish()));
+
+    assert((ri == rj) == !(ri != rj));
+
+    bool same = ri == rj;
+    bool one_empty = ri.empty() != rj.empty();
+
+    std::less<range> less;
+    std::less_equal<range> less_equal;
+    std::greater<range> greater;
+    std::greater_equal<range> greater_equal;
+    
+    if (same)
+    {
+        assert(greater_equal(ri,rj));
+        assert(less_equal(ri,rj));
+        assert(!greater(ri,rj));
+        assert(!less(ri,rj));
+    }
+    else if (one_empty)
+    {
+        const range& empty = ri.empty() ? ri : rj;
+        const range& non_empty = rj.empty() ? ri : rj;
+        
+        assert(less(empty,non_empty));
+        assert(less_equal(empty,non_empty));
+        assert(!greater(empty,non_empty));
+        assert(!greater_equal(empty,non_empty));
+        assert(!less(non_empty,empty));
+        assert(!less_equal(non_empty,empty));
+        assert(greater(non_empty,empty));
+        assert(greater_equal(non_empty,empty));
+    }
+    else {
+        if (indices[i][0] < indices[j][0] ||
+            indices[i][0] == indices[j][0] && indices[i][1] < indices[j][1])
+        {
+            assert(!greater_equal(ri,rj));
+            assert(less(ri,rj));
+        }
+
+        if (indices[i][0] < indices[j][0] ||
+            indices[i][0] == indices[j][0] && indices[i][1] <= indices[j][1])
+        {
+            assert(!greater(ri,rj));
+            assert(less_equal(ri,rj));
+        }
+
+        if (indices[i][0] > indices[j][0] ||
+            indices[i][0] == indices[j][0] && indices[i][1] > indices[j][1])
+        {
+            assert(!less_equal(ri,rj));
+            assert(greater(ri,rj));
+        }
+
+        if (indices[i][0] > indices[j][0] ||
+            indices[i][0] == indices[j][0] && indices[i][1] >= indices[j][1])
+        {
+            assert(!less(ri,rj));
+            assert(greater_equal(ri,rj));
+        }
+    }
+}
+
+
+template <class Range>
+void category_test_2(
+    const std::vector<Range>&, unsigned, unsigned, std::forward_iterator_tag)
+{
+}
+
+template <class T>
+void category_test_2(
+    const std::vector<boost::half_open_range<T> >&, unsigned, unsigned, std::bidirectional_iterator_tag)
+{
+}
+
+template <class Range>
+void test_back(Range& x, std::bidirectional_iterator_tag)
+{
+    assert(x.back() == boost::prior(x.finish()));
+}
+
+template <class Range>
+void test_back(Range& x, std::forward_iterator_tag)
+{
+}
+
+template <class T>
+boost::half_open_range<T> range_identity(const boost::half_open_range<T>& x)
+{
+    return x;
+}
+
+template <class T>
+void test(T x0, T x1, T x2, T x3)
+{
+    std::vector<boost::half_open_range<T> > ranges;
+    typedef boost::half_open_range<T> range;
+
+    T bounds[4] = { x0, x1, x2, x3 };
+
+    const std::size_t num_ranges = sizeof(indices)/sizeof(*indices);
+    // test construction
+    for (std::size_t n = 0; n < num_ranges;++n)
+    {
+        T start = bounds[indices[n][0]];
+        T finish = bounds[indices[n][1]];
+        boost::half_open_range<T> r(start, finish);
+        ranges.push_back(r);
+    }
+    
+    // test implicit conversion from std::pair<T,T>
+    range converted = std::pair<T,T>(x0,x0);
+    (void)converted;
+
+    // test assignment, equality and inequality
+    range r00 = range(x0, x0);
+    assert(r00 == range(x0,x0));
+    assert(r00 == range(x1,x1)); // empty ranges are all equal
+    if (x3 != x0)
+        assert(r00 != range(x0, x3));
+    r00 = range(x0, x3);
+    assert(r00 == range(x0, x3));
+    if (x3 != x0)
+        assert(r00 != range(x0, x0));
+
+    typedef typename range::iterator iterator;
+    typedef typename iterator::iterator_category category;
+    
+    for (unsigned i = 0; i < num_ranges; ++i)
+    {
+        const range& r = ranges[i];
+            
+        // test begin(), end(), basic iteration.
+        unsigned count = 0;
+        for (range::const_iterator p = r.begin(), finish = r.end();
+             p != finish;
+             ++p, ++count)
+        {
+            assert(count < 2100);
+        }
+
+        // test size(), empty(), front(), back()
+        assert((unsigned)r.size() == count);
+        if (indices[i][0] == indices[i][1])
+            assert(r.empty());
+        if (r.empty())
+            assert(r.size() == 0);
+        if (!r.empty())
+        {
+            assert(r.front() == r.start());
+            test_back(r, category());
+        }
+
+            // test swap
+        range r1(r);
+        range r2(x0,x3);
+        const bool same = r1 == r2;
+        r1.swap(r2);
+        assert(r1 == range(x0,x3));
+        assert(r2 == r);
+        if (!same) {
+            assert(r1 != r);
+            assert(r2 != range(x0,x3));
+        }
+
+        // do individual tests for random-access iterators
+        category_test_1(r, category());
+    }
+
+    for (unsigned j = 0; j < num_ranges; ++j) {
+        for (unsigned k = 0; k < num_ranges; ++k) {
+            category_test_2(ranges, j, k, category());
+        }
+    }
+    
+}
+
+template <class Integer>
+void test_integer(Integer* = 0) // default arg works around MSVC bug
+{
+    Integer a = 0;
+    Integer b = a + unsigned_random(128 - a);
+    Integer c = b + unsigned_random(128 - b);
+    Integer d = c + unsigned_random(128 - c);
+
+    test(a, b, c, d);
+}
+
+template <class Container>
+void test_container(Container* = 0)  // default arg works around MSVC bug
+{
+    Container c(unsigned_random(1673));
+
+    const typename Container::size_type offset1 = unsigned_random(c.size());
+    const typename Container::size_type offset2 = unsigned_random(c.size() - offset1);
+    typename Container::iterator internal1 = c.begin();
+    std::advance(internal1, offset1);
+    typename Container::iterator internal2 = internal1;
+    std::advance(internal2, offset2);
+    
+    test(c.begin(), internal1, internal2, c.end());
+
+    typedef typename Container::const_iterator const_iterator;
+    test(const_iterator(c.begin()),
+         const_iterator(internal1),
+         const_iterator(internal2),
+         const_iterator(c.end()));
+}
+
+int main()
+{
+    // Test the built-in integer types.
+    test_integer<char>();
+    test_integer<unsigned char>();
+    test_integer<signed char>();
+    test_integer<wchar_t>();
+    test_integer<short>();
+    test_integer<unsigned short>();
+    test_integer<int>();
+    test_integer<unsigned int>();
+    test_integer<long>();
+    test_integer<unsigned long>();
+#if defined(BOOST_HAS_LONG_LONG)
+    test_integer<long long>();
+    test_integer<unsigned long long>();
+#endif
+    // Some tests on container iterators, to prove we handle a few different categories
+    test_container<std::vector<int> >();
+    test_container<std::list<int> >();
+#ifndef BOOST_NO_SLIST
+    test_container<BOOST_STD_EXTENSION_NAMESPACE::slist<int> >();
+#endif
+    // Also prove that we can handle raw pointers.
+    int array[2000];
+    const std::size_t a = 0;
+    const std::size_t b = a + unsigned_random(2000 - a);
+    const std::size_t c = b + unsigned_random(2000 - b);
+    test(array, array+b, array+c, array+2000);
+    return 0;
+}
--- a/in_place_factories.html
+++ b/in_place_factories.html
@@ -1,296 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//SoftQuad Software//DTD HoTMetaL PRO 5.0::19981217::extensions to HTML 4.0//EN" "hmpro5.dtd">
-
-<HTML>
-
-<HEAD>
-<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso-8859-1">
-<LINK REL="stylesheet" TYPE="text/css" HREF="../../boost.css">
-<TITLE>Header </TITLE>
-</HEAD>
-
-<BODY BGCOLOR="#FFFFFF" TEXT="#000000" LINK="#0000FF" VLINK="#800080">
-<H2 align="left"><IMG SRC="../../boost.png" WIDTH="276" HEIGHT="86"></H2>
-
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <blockquote>
-        <blockquote>
-          <blockquote>
-<H2 align="left">Header &lt;<A
-HREF="../../boost/utility/in_place_factory.hpp">boost/utility/in_place_factory.hpp</A>&gt; </H2>
-
-<H2 align="left">Header &lt;<A
-HREF="../../boost/utility/typed_in_place_factory.hpp">boost/utility/typed_in_place_factory.hpp</A>&gt; </H2>
-
-          </blockquote>
-        </blockquote>
-      </blockquote>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>&nbsp;</p>
-
-<H2>Contents</H2>
-<DL CLASS="page-index">
-  <DT><A HREF="#mot">Motivation</A></DT>
-  <DT><A HREF="#framework">Framework</A></DT>
-  <DT><A HREF="#specification">Specification</A></DT>
-  <DT><A HREF="#container-usage">Container-side Usage</A></DT>
-  <DT><A HREF="#user-usage">User-side Usage</A></DT>
-</DL>
-
-<HR>
-
-<H2><A NAME="mot"></A>Motivation</H2>
-
-<p>Suppose we have a class</p>
-<pre>struct X
-{
-  X ( int, std:::string ) ;
-} ;</pre>
-<p>And a container for it which supports an empty state (that is, which can contain zero objects):</p>
-<pre>struct C
-{
-   C() : contained_(0) {}
-  ~C() { delete contained_ ; }
-  X* contained_ ;
-} ;</pre>
-<p>A container designed to support an empty state typically doesn't require the contained type to be DefaultConstructible,
-but it typically requires it to be CopyConstructible as a mechanism to
-initialize the object to store:</p>
-<pre>struct C
-{
-   C() : contained_(0) {}
-   C ( X const& v ) : contained_ ( new X(v) ) {}
-  ~C() { delete contained_ ; }
-  X* contained_ ;
-} ;</pre>
-<p>There is a subtle problem with this: since the mechanism used to initialize the stored object is copy construction,
-there must exist a previously constructed source object to copy from. This
-object is likely to be temporary and serve no purpose besides being the source</p>
-<pre>void foo()
-{
-  // Temporary object created.
-  C c( X(123,"hello") ) ;
-}
-</pre>
-<p>A solution to this problem is to support direct construction of the contained
-object right in the container's storage.<br>
-In this shceme, the user supplies the arguments for the X constructor
-directly to the container:</p>
-<pre>struct C
-{
-   C() : contained_(0) {}
-   C ( X const& v ) : contained_ ( new X(v) ) {}
-   C ( int a0, std::string a1 ) : contained_ ( new X(a0,a1) ) {}
-  ~C() { delete contained_ ; }
-  X* contained_ ;
-} ;</pre>
-<pre>void foo()
-{
-  // Wrapped object constructed in-place
-  // No temporary created.
-  C c(123,"hello") ;
-}
-</pre>
-<p>Clearly, this solution doesn't scale well since the container must duplicate all the constructor overloads from the contained type
-(at least all those which are to be supported directly in the container).</p>
-
-<H2><A NAME="framework"></A>Framework</H2>
-<p>
-This library proposes a framework to allow some containers to directly contruct contained objects in-place without requiring
-the entire set of constructor overloads ftom the contained type. It also allows the container to remove the CopyConstuctible
-requirement from the contained type since objects can be directly constructed in-place without need of a copy.<br>
-The only requirement on the container is that it must provide proper storage (that is, correctly aligned and sized).
-Naturally, the container will typically support uninitialized storage to avoid the in-place construction to override
-a fully-constructed object (as this would defeat the purpose of in-place construction)
-</p>
-<p>For this purpose, the framework provides two families of classes collectively called: InPlaceFactories and TypedInPlaceFactories.<br>
-Essentially, these classes hold a sequence of actual parameters and a method to contruct an object in place using these parameters.
-Each member of the family differs only in the number (and type) of the parameter list. The first family
-takes the type of the object to construct directly in method provided for that
-purpose, whereas the second family incorporates that type in the factory class
-itself..</p>
-<p>From the container POV, using the framework amounts to calling the factory's method to contruct the object in place.
-From the user POV, it amounts to creating the right factory object to hold the parameters and pass it to the container.<br>
-The following simplified example shows the basic idea. A complete example follows the formal specification of the framework:</p>
-<pre>struct C
-{
-   C() : contained_(0) {}
-   C ( X const& v ) : contained_ ( new X(v) ) {}
-
-   template&lt;class InPlaceFactory&gt;
-   C ( InPlaceFactory const& aFactoty )
-    :
-    contained_ ( uninitialized_storage() )
-   {
-     aFactory.template apply&lt;X&gt;(contained_);
-   }
-
-  ~C() { delete contained_ ; }
-
-  X* uninitialized_storage() { return static_cast&lt;X*&gt;(new char[sizeof(X)]) ; }
-
-  X* contained_ ;
-} ;
-
-void foo()
-{
-  C c( in_place(123,"hello" ) ;
-}
-</pre>
-
-<HR>
-
-<H2><A NAME="specification">Specification</A></H2>
-
-<p>The following is the first member of the family of 'in_place_factory' classes, along with its corresponding helper template function.
-The rest of the family varies only in the number and type of template (and constructor) parameters.</p>
-<PRE>namespace boost {
-
-struct in_place_factory_base {} ;
-
-template&lt;class A0&gt;
-class in_place_factory : public in_place_factory_base
-{
-  public:</PRE>
-
-<PRE>    in_place_factory ( A0 const& a0 ) : m_a0(a0) {}
-
-    template&lt; class T &gt;
-    void apply ( void* address ) const
-    {
-      new (address) T(m_a0);
-    }
-
-  private:</PRE>
-
-<PRE>    A0 const& m_a0 ;
-} ;
-
-template&lt;class A0&gt;
-in_place_factory&lt;A0&gt; in_place ( A0 const& a0 )
-{
-  return in_place_factory&lt;A0&gt;(a0);
-}
-</PRE>
-
-<p>Similarly, the following is the first member of the family of 'typed_in_place_factory' classes, along with its corresponding
-helper template function. The rest of the family varies only in the number and type of template (and constructor) parameters.</p>
-<PRE>namespace boost {
-
-struct typed_in_place_factory_base {} ;
-
-template&lt;class T, class A0&gt;
-class typed_in_place_factory : public typed_in_place_factory_base
-{
-  public:</PRE>
-
-<PRE>    typed_in_place_factory ( A0 const& a0 ) : m_a0(a0) {}
-
-    void apply ( void* address ) const
-    {
-      new (address) T(m_a0);
-    }
-
-  private:</PRE>
-
-<PRE>    A0 const& m_a0 ;
-} ;
-
-template&lt;class T, class A0&gt;
-typed_in_place_factory&lt;A0&gt; in_place ( A0 const& a0 )
-{
-  return typed_in_place_factory&lt;T,A0&gt;(a0);
-}</PRE>
-
-<PRE>}
-</PRE>
-
-<p>As you can see, the 'in_place_factory' and 'typed_in_place_factory' template classes varies only in the way they specify
-the target type: in the first family, the type is given as a template argument to the apply member function while in the
-second it is given directly as part of the factory class.<br>
-When the container holds a unique non-polymorphic type (such as the case of Boost.Optional), it knows the exact dynamic-type
-of the contained object and can pass it to the apply() method of a (non-typed) factory.
-In this case, end users can use an 'in_place_factory' instance which can be constructed without the type of the object to construct.<br>
-However, if the container holds heterogeneous or polymorphic objects (such as the case of Boost.Variant), the dynamic-type
-of the object to be constructed must be known by the factory itslef. In this case, end users must use a 'typed_in_place_factory'
-instead.</p>
-
-<HR>
-
-<h2><A NAME="container-usage">Container-side Usage</a></h2>
-
-<p>As shown in the introductory simplified example, the container class must
-contain methods that accept an instance of
-these factories and pass the object's storage to the factory's apply method.<br>
-However, the type of the factory class cannot be completly specified in the container class because that would
-defeat the whole purpose of the factories which is to allow the container to accept a variadic argument list
-for the constructor of its contained object.<br>
-The correct function overload must be based on the only distinctive and common
-characteristic of all the classes in each family, the base class.<br>
-Depending on the container class, you can use 'enable_if' to generate the right overload, or use the following
-dispatch technique (used in the Boost.Optional class):
-</p>
-<pre>struct C
-{
-   C() : contained_(0) {}
-   C ( X const& v ) : contained_ ( new X(v) ) {}
-
-   template&lt;class Expr&gt
-   C ( Expr const& expr )
-    :
-    contained_ ( uninitialized_storage() )
-   {
-    construct(expr,&expr)
-   }
-
-  ~C() { delete contained_ ; }
-
-  template&lt;class InPlaceFactory&gt;
-  void construct ( InPlaceFactory const& aFactory, boost::in_place_factory_base* )
-  {
-    aFactory.template apply&lt;X&gt;(contained_);
-  }
-
-  template&lt;class TypedInPlaceFactory&gt;
-  void construct ( TypedInPlaceFactory const& aFactory, boost::typed_in_place_factory_base* )
-  {
-    aFactory.apply(contained_);
-  }
-
-  X* uninitialized_storage() { return static_cast&lt;X*&gt;(new char[sizeof(X)]) ; }
-
-  X* contained_ ;
-} ;
-</pre>
-
-<hr>
-
-<h2><A NAME="user-usage">User-side Usage</a></h2>
-
-<p>End users pass to the container an instance of a factory object holding the actual parameters needed to construct the
-contained object directly within the container. For this, the helper template function 'in_place' is used.<br>
-The call 'in_place(a0,a1,a2,...,an)' constructs a (non-typed) 'in_place_factory' instance with the given argument list.<br>
-The call 'in_place&lt;T&gt;(a0,a1,a2,...,an)' constructs a 'typed_in_place_factory' instance with the given argument list for the
-type 'T'.</p>
-<pre>void foo()
-{
-  C a( in_place(123,"hello") ) ;    // in_place_factory passed
-  C b( in_place&lt;X&gt;(456,"world") ) ; // typed_in_place_factory passed
-}
-</pre>
-
-<P>Revised September 17, 2004</P>
-<p><EFBFBD> Copyright Fernando Luis Cacciola Carballal, 2004</p>
-<p> Use, modification, and distribution are subject to the Boost Software
-License, Version 1.0. (See accompanying file <a href="../../LICENSE_1_0.txt">
-LICENSE_1_0.txt</a> or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">
-www.boost.org/LICENSE_1_0.txt</a>)</p>
-<P>Developed by <A HREF="mailto:fernando_cacciola@hotmail.com">Fernando Cacciola</A>,
-the latest version of this file can be found at <A
-HREF="http://www.boost.org">www.boost.org</A>, and the boost
-<A HREF="http://www.boost.org/more/mailing_lists.htm#main">discussion lists</A></P>
-</BODY>
-</HTML>
--- a/include/boost/assert.hpp
+++ b/include/boost/assert.hpp
@@ -3,9 +3,10 @@
 //
 //  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
 //
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+//  Permission to copy, use, modify, sell and distribute this software
+//  is granted provided this copyright notice appears in all copies.
+//  This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
 //
 //  Note: There are no include guards. This is intentional.
 //
--- a/include/boost/checked_delete.hpp
+++ b/include/boost/checked_delete.hpp
@@ -10,13 +10,15 @@
 //
 //  boost/checked_delete.hpp
 //
+//  Copyright (c) 1999, 2000, 2001, 2002 boost.org
 //  Copyright (c) 2002, 2003 Peter Dimov
 //  Copyright (c) 2003 Daniel Frey
 //  Copyright (c) 2003 Howard Hinnant
 //
-//  Distributed under the Boost Software License, Version 1.0. (See
-//  accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
+//  Permission to copy, use, modify, sell and distribute this software
+//  is granted provided this copyright notice appears in all copies.
+//  This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
 //
 //  See http://www.boost.org/libs/utility/checked_delete.html for documentation.
 //
--- a/include/boost/current_function.hpp
+++ b/include/boost/current_function.hpp
@@ -12,9 +12,10 @@
 //
 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
 //
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+//  Permission to copy, use, modify, sell and distribute this software
+//  is granted provided this copyright notice appears in all copies.
+//  This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
 //
 //  http://www.boost.org/libs/utility/current_function.html
 //
--- a/include/boost/generator_iterator.hpp
+++ b/include/boost/generator_iterator.hpp
@@ -1,7 +1,8 @@
-// (C) Copyright Jens Maurer 2001.
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+// (C) Copyright Jens Maurer 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
 //
 // Revision History:

--- a/include/boost/next_prior.hpp
+++ b/include/boost/next_prior.hpp
@@ -1,8 +1,10 @@
 //  Boost next_prior.hpp header file  ---------------------------------------//

-//  (C) Copyright Dave Abrahams and Daniel Walker 1999-2003. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//  (C) Copyright Boost.org 1999-2003. Permission to copy, use, modify, sell
+//  and distribute this software is granted provided this copyright
+//  notice appears in all copies. This software is provided "as is" without
+//  express or implied warranty, and with no claim as to its suitability for
+//  any purpose.

 //  See http://www.boost.org/libs/utility for documentation.

--- a/include/boost/noncopyable.hpp
+++ b/include/boost/noncopyable.hpp
@@ -1,8 +1,10 @@
 //  Boost noncopyable.hpp header file  --------------------------------------//

-//  (C) Copyright Beman Dawes 1999-2003. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//  (C) Copyright Boost.org 1999-2003. Permission to copy, use, modify, sell
+//  and distribute this software is granted provided this copyright
+//  notice appears in all copies. This software is provided "as is" without
+//  express or implied warranty, and with no claim as to its suitability for
+//  any purpose.

 //  See http://www.boost.org/libs/utility for documentation.

@@ -16,20 +18,15 @@ namespace boost {

 //  Contributed by Dave Abrahams

-namespace noncopyable_  // protection from unintended ADL
+class noncopyable
 {
-  class noncopyable
-  {
-   protected:
-      noncopyable() {}
-      ~noncopyable() {}
-   private:  // emphasize the following members are private
-      noncopyable( const noncopyable& );
-      const noncopyable& operator=( const noncopyable& );
-  };
-}
-
-typedef noncopyable_::noncopyable noncopyable;
+ protected:
+    noncopyable() {}
+    ~noncopyable() {}
+ private:  // emphasize the following members are private
+    noncopyable( const noncopyable& );
+    const noncopyable& operator=( const noncopyable& );
+};

 } // namespace boost

--- a/include/boost/operators.hpp
+++ b/include/boost/operators.hpp
@@ -1,9 +1,10 @@
 //  Boost operators.hpp header file  ----------------------------------------//

-//  (C) Copyright David Abrahams, Jeremy Siek, Daryle Walker 1999-2001.
-//  Distributed under the Boost Software License, Version 1.0. (See
-//  accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
+//  (C) Copyright David Abrahams, Jeremy Siek, and Daryle Walker 1999-2001.
+//  Permission to copy, use, modify, sell and distribute this software is
+//  granted provided this copyright notice appears in all copies.  This
+//  software is provided "as is" without express or implied warranty, and
+//  with no claim as to its suitability for any purpose.

 //  See http://www.boost.org/libs/utility/operators.htm for documentation.

--- a/include/boost/ref.hpp
+++ b/include/boost/ref.hpp
@@ -18,9 +18,10 @@
 //  Copyright (C) 2001, 2002 Peter Dimov
 //  Copyright (C) 2002 David Abrahams
 //
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+//  Permission to copy, use, modify, sell and distribute this software
+//  is granted provided this copyright notice appears in all copies.
+//  This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
 //
 //  See http://www.boost.org/libs/bind/ref.html for documentation.
 //
@@ -73,13 +74,18 @@ template<class T> inline reference_wrapper<T const> BOOST_REF_CONST cref(T const
 # undef BOOST_REF_CONST

 # ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
 template<typename T>
 class is_reference_wrapper
    : public mpl::false_
 {
 };

+template<typename T>
+class is_reference_wrapper<reference_wrapper<T> >
+    : public mpl::true_
+{
+};
+
 template<typename T>
 class unwrap_reference
 {
@@ -87,30 +93,12 @@ class unwrap_reference
    typedef T type;
 };

-#  define AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(X) \
-template<typename T> \
-class is_reference_wrapper< X > \
-    : public mpl::true_ \
-{ \
-}; \
-\
-template<typename T> \
-class unwrap_reference< X > \
-{ \
- public: \
-    typedef T type; \
-}; \
-/**/
-
-AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(reference_wrapper<T>)
-#if !defined(BOOST_NO_CV_SPECIALIZATIONS)
-AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(reference_wrapper<T> const)
-AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(reference_wrapper<T> volatile)
-AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(reference_wrapper<T> const volatile)
-#endif
-
-#  undef AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF
-
+template<typename T>
+class unwrap_reference<reference_wrapper<T> >
+{
+ public:
+    typedef T type;
+};
 # else // no partial specialization

 } // namespace boost
--- a/include/boost/utility.hpp
+++ b/include/boost/utility.hpp
@@ -1,6 +1,6 @@
 //  Boost utility.hpp header file  -------------------------------------------//

-//  Copyright 1999-2003 Aleksey Gurtovoy.  Use, modification, and distribution are
+//  Copyright 1999-2003 Boost.org.  Use, modification, and distribution are
 //  subject to the Boost Software License, Version 1.0.  (See accompanying file
 //  LICENSE_1_0.txt or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)

@@ -11,7 +11,6 @@

 #include <boost/utility/addressof.hpp>
 #include <boost/utility/base_from_member.hpp>  
-#include <boost/utility/enable_if.hpp>
 #include <boost/checked_delete.hpp>
 #include <boost/next_prior.hpp>
 #include <boost/noncopyable.hpp>
--- a/include/boost/utility/addressof.hpp
+++ b/include/boost/utility/addressof.hpp
@@ -1,10 +1,15 @@
 // Copyright (C) 2002 Brad King (brad.king@kitware.com) 
-//                    Douglas Gregor (gregod@cs.rpi.edu)
+//                    Doug Gregor (gregod@cs.rpi.edu)
 //                    Peter Dimov
 //
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+// Permission to copy, use, sell and distribute this software is granted
+// provided this copyright notice appears in all copies.
+// Permission to modify the code and to distribute modified code is granted
+// provided this copyright notice appears in all copies, and a notice
+// that the code was modified is included with the copyright notice.
+//
+// This software is provided "as is" without express or implied warranty,
+// and with no claim as to its suitability for any purpose.

 // For more information, see http://www.boost.org

--- a/include/boost/utility/base_from_member.hpp
+++ b/include/boost/utility/base_from_member.hpp
@@ -1,53 +1,15 @@
 //  boost utility/base_from_member.hpp header file  --------------------------//

-//  Copyright 2001, 2003, 2004 Daryle Walker.  Use, modification, and
-//  distribution are subject to the Boost Software License, Version 1.0.  (See
-//  accompanying file LICENSE_1_0.txt or a copy at
-//  <http://www.boost.org/LICENSE_1_0.txt>.)
+//  Copyright 2001, 2003 Daryle Walker.  Use, modification, and distribution are
+//  subject to the Boost Software License, Version 1.0.  (See accompanying file
+//  LICENSE_1_0.txt or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)

 //  See <http://www.boost.org/libs/utility/> for the library's home page.

 #ifndef BOOST_UTILITY_BASE_FROM_MEMBER_HPP
 #define BOOST_UTILITY_BASE_FROM_MEMBER_HPP

-#include <boost/preprocessor/arithmetic/inc.hpp>
-#include <boost/preprocessor/repetition/enum_binary_params.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/repetition/repeat_from_to.hpp>
-
-
-//  Base-from-member arity configuration macro  ------------------------------//
-
-// The following macro determines how many arguments will be in the largest
-// constructor template of base_from_member.  Constructor templates will be
-// generated from one argument to this maximum.  Code from other files can read
-// this number if they need to always match the exact maximum base_from_member
-// uses.  The maximum constructor length can be changed by overriding the
-// #defined constant.  Make sure to apply the override, if any, for all source
-// files during project compiling for consistency.
-
-// Contributed by Jonathan Turkanis
-
-#ifndef BOOST_BASE_FROM_MEMBER_MAX_ARITY
-#define BOOST_BASE_FROM_MEMBER_MAX_ARITY  10
-#endif
-
-
-//  An iteration of a constructor template for base_from_member  -------------//
-
-// A macro that should expand to:
-//     template < typename T1, ..., typename Tn >
-//     base_from_member( T1 x1, ..., Tn xn )
-//         : member( x1, ..., xn )
-//         {}
-// This macro should only persist within this file.
-
-#define BOOST_PRIVATE_CTR_DEF( z, n, data )                            \
-    template < BOOST_PP_ENUM_PARAMS(n, typename T) >                   \
-    explicit base_from_member( BOOST_PP_ENUM_BINARY_PARAMS(n, T, x) )  \
-        : member( BOOST_PP_ENUM_PARAMS(n, x) )                         \
-        {}                                                             \
-    /**/
+#include <boost/utility_fwd.hpp>  // required for parameter defaults


 namespace boost
@@ -62,7 +24,7 @@ namespace boost

 // Contributed by Daryle Walker

-template < typename MemberType, int UniqueID = 0 >
+template < typename MemberType, int UniqueID >
 class base_from_member
 {
 protected:
@@ -72,16 +34,66 @@ protected:
        : member()
        {}

-    BOOST_PP_REPEAT_FROM_TO( 1, BOOST_PP_INC(BOOST_BASE_FROM_MEMBER_MAX_ARITY),
-     BOOST_PRIVATE_CTR_DEF, _ )
+    template< typename T1 >
+    explicit base_from_member( T1 x1 )
+        : member( x1 )
+        {}
+
+    template< typename T1, typename T2 >
+    base_from_member( T1 x1, T2 x2 )
+        : member( x1, x2 )
+        {}
+
+    template< typename T1, typename T2, typename T3 >
+    base_from_member( T1 x1, T2 x2, T3 x3 )
+        : member( x1, x2, x3 ) 
+        {}
+
+    template< typename T1, typename T2, typename T3, typename T4 >
+    base_from_member( T1 x1, T2 x2, T3 x3, T4 x4 )
+        : member( x1, x2, x3, x4 ) 
+        {}
+
+    template< typename T1, typename T2, typename T3, typename T4, typename T5 >
+    base_from_member( T1 x1, T2 x2, T3 x3, T4 x4, T5 x5 )
+        : member( x1, x2, x3, x4, x5 ) 
+        {}
+
+    template< typename T1, typename T2, typename T3, typename T4, typename T5,
+     typename T6 >
+    base_from_member( T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6 )
+        : member( x1, x2, x3, x4, x5, x6 ) 
+        {}
+
+    template< typename T1, typename T2, typename T3, typename T4, typename T5,
+     typename T6, typename T7 >
+    base_from_member( T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6, T7 x7 )
+        : member( x1, x2, x3, x4, x5, x6, x7 ) 
+        {}
+
+    template< typename T1, typename T2, typename T3, typename T4, typename T5,
+     typename T6, typename T7, typename T8 >
+    base_from_member( T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6, T7 x7, T8 x8 )
+        : member( x1, x2, x3, x4, x5, x6, x7, x8 ) 
+        {}
+
+    template< typename T1, typename T2, typename T3, typename T4, typename T5,
+     typename T6, typename T7, typename T8, typename T9 >
+    base_from_member( T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6, T7 x7, T8 x8,
+     T9 x9 )
+        : member( x1, x2, x3, x4, x5, x6, x7, x8, x9 ) 
+        {}
+
+    template< typename T1, typename T2, typename T3, typename T4, typename T5,
+     typename T6, typename T7, typename T8, typename T9, typename T10 >
+    base_from_member( T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6, T7 x7, T8 x8,
+     T9 x9, T10 x10 )
+        : member( x1, x2, x3, x4, x5, x6, x7, x8, x9, x10 ) 
+        {}

 };  // boost::base_from_member

 }  // namespace boost


-// Undo any private macros
-#undef BOOST_PRIVATE_CTR_DEF
-
-
 #endif  // BOOST_UTILITY_BASE_FROM_MEMBER_HPP
--- a/include/boost/utility/detail/in_place_factory_prefix.hpp
+++ b/include/boost/utility/detail/in_place_factory_prefix.hpp
@@ -1,33 +0,0 @@
-// Copyright (C) 2003, Fernando Luis Cacciola Carballal.
-//
-// Use, modification, and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-// See http://www.boost.org/lib/optional for documentation.
-//
-// You are welcome to contact the author at:
-//  fernando_cacciola@hotmail.com
-//
-#ifndef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_PREFIX_25AGO2003_HPP
-#define BOOST_UTILITY_DETAIL_INPLACE_FACTORY_PREFIX_25AGO2003_HPP
-
-#include <boost/config.hpp>
-#include <boost/preprocessor/repetition/enum.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/repetition/enum_binary_params.hpp>
-#include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/arithmetic/inc.hpp>
-#include <boost/preprocessor/punctuation/paren.hpp>
-#include <boost/preprocessor/facilities/empty.hpp>
-
-#define BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_INIT(z,n,_) BOOST_PP_CAT(m_a,n) BOOST_PP_LPAREN() BOOST_PP_CAT(a,n) BOOST_PP_RPAREN()
-#define BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_DECL(z,n,_) BOOST_PP_CAT(A,n) const& BOOST_PP_CAT(m_a,n);
-#define BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_ARG(z,n,_)  BOOST_PP_CAT(m_a,n)
-
-#define BOOST_MAX_INPLACE_FACTORY_ARITY 10
-
-#undef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_SUFFIX_25AGO2003_HPP
-
-#endif
-
--- a/include/boost/utility/detail/in_place_factory_suffix.hpp
+++ b/include/boost/utility/detail/in_place_factory_suffix.hpp
@@ -1,23 +0,0 @@
-// Copyright (C) 2003, Fernando Luis Cacciola Carballal.
-//
-// Use, modification, and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-// See http://www.boost.org/lib/optional for documentation.
-//
-// You are welcome to contact the author at:
-//  fernando_cacciola@hotmail.com
-//
-#ifndef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_SUFFIX_25AGO2003_HPP
-#define BOOST_UTILITY_DETAIL_INPLACE_FACTORY_SUFFIX_25AGO2003_HPP
-
-#undef BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_INIT
-#undef BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_DECL
-#undef BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_ARG
-#undef BOOST_MAX_INPLACE_FACTORY_ARITY
-
-#undef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_PREFIX_25AGO2003_HPP
-
-#endif
-
--- a/include/boost/utility/detail/result_of_iterate.hpp
+++ b/include/boost/utility/detail/result_of_iterate.hpp
@@ -1,86 +0,0 @@
-// Boost result_of library
-
-//  Copyright Douglas Gregor 2004. Use, modification and
-//  distribution is subject to the Boost Software License, Version
-//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
-
-// For more information, see http://www.boost.org/libs/utility
-#if !defined(BOOST_PP_IS_ITERATING)
-# error Boost result_of - do not include this file!
-#endif
-
-// CWPro8 requires an argument in a function type specialization
-#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3002)) && BOOST_PP_ITERATION() == 0
-# define BOOST_RESULT_OF_ARGS void
-#else
-# define BOOST_RESULT_OF_ARGS BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)
-#endif
-
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
-template<typename F BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
-         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
-struct result_of<F(BOOST_RESULT_OF_ARGS)>
-    : detail::result_of<F, F(BOOST_RESULT_OF_ARGS)> {};
-#endif
-
-namespace detail {
-
-template<typename R,  typename FArgs BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
-         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
-struct result_of<R (*)(BOOST_RESULT_OF_ARGS), FArgs>
-{
-  typedef R type;
-};
-
-template<typename R,  typename FArgs BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
-         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
-struct result_of<R (&)(BOOST_RESULT_OF_ARGS), FArgs>
-{
-  typedef R type;
-};
-
-#undef BOOST_RESULT_OF_ARGS
-
-#if BOOST_PP_ITERATION() > 1 && !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
-template<typename R, typename FArgs BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
-         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
-struct result_of<R (T0::*)
-                     (BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_ITERATION(),T)),
-                 FArgs>
-{
-  typedef R type;
-};
-
-template<typename R, typename FArgs BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
-         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
-struct result_of<R (T0::*)
-                     (BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_ITERATION(),T))
-                     const,
-                 FArgs>
-{
-  typedef R type;
-};
-
-template<typename R, typename FArgs BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
-         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
-struct result_of<R (T0::*)
-                     (BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_ITERATION(),T))
-                     volatile,
-                 FArgs>
-{
-  typedef R type;
-};
-
-template<typename R, typename FArgs BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
-         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
-struct result_of<R (T0::*)
-                     (BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_ITERATION(),T))
-                     const volatile,
-                 FArgs>
-{
-  typedef R type;
-};
-#endif
-
-}
--- a/include/boost/utility/in_place_factory.hpp
+++ b/include/boost/utility/in_place_factory.hpp
@@ -1,58 +0,0 @@
-// Copyright (C) 2003, Fernando Luis Cacciola Carballal.
-//
-// Use, modification, and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-// See http://www.boost.org/lib/optional for documentation.
-//
-// You are welcome to contact the author at:
-//  fernando_cacciola@hotmail.com
-//
-#ifndef BOOST_UTILITY_INPLACE_FACTORY_25AGO2003_HPP
-#define BOOST_UTILITY_INPLACE_FACTORY_25AGO2003_HPP
-
-#include <boost/utility/detail/in_place_factory_prefix.hpp>
-
-#include <boost/type.hpp>
-
-namespace boost {
-
-class in_place_factory_base {} ;
-
-#define BOOST_DEFINE_INPLACE_FACTORY_CLASS(z,n,_) \
-template< BOOST_PP_ENUM_PARAMS(BOOST_PP_INC(n),class A) > \
-class BOOST_PP_CAT(in_place_factory, BOOST_PP_INC(n) ) : public in_place_factory_base \
-{ \
-public: \
-\
-  BOOST_PP_CAT(in_place_factory, BOOST_PP_INC(n) ) ( BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_INC(n),A,const& a) ) \
-    : \
-    BOOST_PP_ENUM( BOOST_PP_INC(n), BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_INIT, _ ) \
-  {} \
-\
-  template<class T> \
-  void apply ( void* address BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(T) ) const \
-  { \
-    new ( address ) T ( BOOST_PP_ENUM_PARAMS( BOOST_PP_INC(n), m_a ) ) ; \
-  } \
-\
-  BOOST_PP_REPEAT( BOOST_PP_INC(n), BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_DECL, _) \
-} ; \
-\
-template< BOOST_PP_ENUM_PARAMS(BOOST_PP_INC(n),class A) > \
-BOOST_PP_CAT(in_place_factory, BOOST_PP_INC(n) ) < BOOST_PP_ENUM_PARAMS( BOOST_PP_INC(n), A ) > \
-in_place ( BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_INC(n),A, const& a) ) \
-{ \
-  return BOOST_PP_CAT(in_place_factory, BOOST_PP_INC(n) ) < BOOST_PP_ENUM_PARAMS( BOOST_PP_INC(n), A ) > \
-           ( BOOST_PP_ENUM_PARAMS( BOOST_PP_INC(n), a ) ) ; \
-} ; \
-
-BOOST_PP_REPEAT( BOOST_MAX_INPLACE_FACTORY_ARITY, BOOST_DEFINE_INPLACE_FACTORY_CLASS, BOOST_PP_EMPTY() )
-
-} // namespace boost
-
-#include <boost/utility/detail/in_place_factory_suffix.hpp>
-
-#endif
-
--- a/include/boost/utility/result_of.hpp
+++ b/include/boost/utility/result_of.hpp
@@ -1,65 +0,0 @@
-// Boost result_of library
-
-//  Copyright Douglas Gregor 2004. Use, modification and
-//  distribution is subject to the Boost Software License, Version
-//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
-
-// For more information, see http://www.boost.org/libs/utility
-#ifndef BOOST_RESULT_OF_HPP
-#define BOOST_RESULT_OF_HPP
-
-#include <boost/config.hpp>
-#include <boost/type_traits/ice.hpp>
-#include <boost/type.hpp>
-#include <boost/preprocessor.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/mpl/has_xxx.hpp>
-
-#ifndef BOOST_RESULT_OF_NUM_ARGS
-#  define BOOST_RESULT_OF_NUM_ARGS 10
-#endif
-
-namespace boost {
-
-template<typename F> struct result_of;
-
-#if !defined(BOOST_NO_SFINAE) && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-namespace detail {
-
-BOOST_MPL_HAS_XXX_TRAIT_DEF(result_type)
-
-template<typename F, typename FArgs, bool HasResultType> struct get_result_of;
-
-template<typename F, typename FArgs>
-struct get_result_of<F, FArgs, true>
-{
-  typedef typename F::result_type type;
-};
-
-template<typename F, typename FArgs>
-struct get_result_of<F, FArgs, false>
-{
-  typedef typename F::template result<FArgs>::type type;
-};
-
-template<typename F>
-struct get_result_of<F, F(void), false>
-{
-  typedef void type;
-};
-
-template<typename F, typename FArgs>
-struct result_of : get_result_of<F, FArgs, (has_result_type<F>::value)> {};
-
-} // end namespace detail
-
-#define BOOST_PP_ITERATION_PARAMS_1 (3,(0,BOOST_RESULT_OF_NUM_ARGS,<boost/utility/detail/result_of_iterate.hpp>))
-#include BOOST_PP_ITERATE()
-
-}
-#else
-#  error Your compiler cannot support class template result_of
-#endif
-
-#endif // BOOST_RESULT_OF_HPP
--- a/include/boost/utility/typed_in_place_factory.hpp
+++ b/include/boost/utility/typed_in_place_factory.hpp
@@ -1,57 +0,0 @@
-// Copyright (C) 2003, Fernando Luis Cacciola Carballal.
-//
-// Use, modification, and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-// See http://www.boost.org/lib/optional for documentation.
-//
-// You are welcome to contact the author at:
-//  fernando_cacciola@hotmail.com
-//
-#ifndef BOOST_UTILITY_TYPED_INPLACE_FACTORY_25AGO2003_HPP
-#define BOOST_UTILITY_TYPED_INPLACE_FACTORY_25AGO2003_HPP
-
-#include <boost/utility/detail/in_place_factory_prefix.hpp>
-
-namespace boost {
-
-class typed_in_place_factory_base {} ;
-
-#define BOOST_DEFINE_TYPED_INPLACE_FACTORY_CLASS(z,n,_) \
-template< class T, BOOST_PP_ENUM_PARAMS(BOOST_PP_INC(n),class A) > \
-class BOOST_PP_CAT(typed_in_place_factory, BOOST_PP_INC(n) ) : public typed_in_place_factory_base \
-{ \
-public: \
-\
-  typedef T value_type ; \
-\
-  BOOST_PP_CAT(typed_in_place_factory, BOOST_PP_INC(n) ) ( BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_INC(n),A,const& a) ) \
-    : \
-    BOOST_PP_ENUM( BOOST_PP_INC(n), BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_INIT, _ ) \
-  {} \
-\
-  void apply ( void* address ) const \
-  { \
-    new ( address ) T ( BOOST_PP_ENUM_PARAMS( BOOST_PP_INC(n), m_a ) ) ; \
-  } \
-\
-  BOOST_PP_REPEAT( BOOST_PP_INC(n), BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_DECL, _) \
-} ; \
-\
-template< class T, BOOST_PP_ENUM_PARAMS(BOOST_PP_INC(n),class A) > \
-BOOST_PP_CAT(typed_in_place_factory, BOOST_PP_INC(n) ) < T , BOOST_PP_ENUM_PARAMS( BOOST_PP_INC(n), A ) > \
-in_place ( BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_INC(n),A, const& a) ) \
-{ \
-  return BOOST_PP_CAT(typed_in_place_factory, BOOST_PP_INC(n) ) < T, BOOST_PP_ENUM_PARAMS( BOOST_PP_INC(n), A ) > \
-           ( BOOST_PP_ENUM_PARAMS( BOOST_PP_INC(n), a ) ) ; \
-} ; \
-
-BOOST_PP_REPEAT( BOOST_MAX_INPLACE_FACTORY_ARITY, BOOST_DEFINE_TYPED_INPLACE_FACTORY_CLASS, BOOST_PP_EMPTY() )
-
-} // namespace boost
-
-#include <boost/utility/detail/in_place_factory_suffix.hpp>
-
-#endif
-
--- a/include/boost/utility/value_init.hpp
+++ b/include/boost/utility/value_init.hpp
@@ -1,8 +1,13 @@
 // (C) 2002, Fernando Luis Cacciola Carballal.
 //
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+// This material is provided "as is", with absolutely no warranty expressed
+// or implied. Any use is at your own risk.
+//
+// Permission to use or copy this software for any purpose is hereby granted
+// without fee, provided the above notices are retained on all copies.
+// Permission to modify the code and to distribute modified code is granted,
+// provided the above notices are retained, and a notice that the code was
+// modified is included with the above copyright notice.
 //
 // 21 Ago 2002 (Created) Fernando Cacciola
 //
--- a/include/boost/utility_fwd.hpp
+++ b/include/boost/utility_fwd.hpp
@@ -0,0 +1,33 @@
+//  Boost utility_fwd.hpp header file  ---------------------------------------//
+
+//  Copyright 2001, 2003 Boost.org.  Use, modification, and distribution are
+//  subject to the Boost Software License, Version 1.0.  (See accompanying file
+//  LICENSE_1_0.txt or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
+
+//  See <http://www.boost.org/libs/utility/> for the library's home page.
+
+#ifndef BOOST_UTILITY_FWD_HPP
+#define BOOST_UTILITY_FWD_HPP
+
+
+namespace boost
+{
+
+
+//  From <boost/utility/base_from_member.hpp>  -------------------------------//
+
+template < typename MemberType, int UniqueID = 0 >
+    class base_from_member;
+
+
+//  From <boost/noncopyable.hpp>  --------------------------------------------//
+
+class noncopyable;
+
+// Also has a few function templates
+
+
+}  // namespace boost
+
+
+#endif  // BOOST_UTILITY_FWD_HPP
--- a/index.html
+++ b/index.html
@@ -7,7 +7,7 @@
 		<title>Boost Utility Library</title>
 	</head>
 	<body bgcolor="#FFFFFF">
-		<h1><IMG SRC="../../boost.png" WIDTH="276" HEIGHT="86" align="center">Boost 
+		<h1><IMG SRC="../../c++boost.gif" WIDTH="276" HEIGHT="86" align="center">Boost 
 			Utility Library</h1>
 		<p>The Boost Utility Library isn't really a single library at all. It is just a 
 			collection for components too small to be called libraries in their own right.</p>
--- a/indirect_iterator_example.cpp
+++ b/indirect_iterator_example.cpp
@@ -0,0 +1,59 @@
+// (C) Copyright Jeremy Siek 2000. Permission to copy, use, modify, sell and
+// distribute this software is granted provided this copyright notice appears
+// in all copies. This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+
+#include <boost/config.hpp>
+#include <vector>
+#include <iostream>
+#include <iterator>
+#include <functional>
+#include <algorithm>
+#include <boost/iterator/indirect_iterator.hpp>
+
+int main(int, char*[])
+{
+  char characters[] = "abcdefg";
+  const int N = sizeof(characters)/sizeof(char) - 1; // -1 since characters has a null char
+  char* pointers_to_chars[N];                        // at the end.
+  for (int i = 0; i < N; ++i)
+    pointers_to_chars[i] = &characters[i];
+
+  // Example of using indirect_iterator_generator
+  
+  boost::indirect_iterator<char**, char>
+    indirect_first(pointers_to_chars), indirect_last(pointers_to_chars + N);
+
+  std::copy(indirect_first, indirect_last, std::ostream_iterator<char>(std::cout, ","));
+  std::cout << std::endl;
+  
+
+  // Example of using indirect_iterator_pair_generator
+
+  char mutable_characters[N];
+  char* pointers_to_mutable_chars[N];
+  for (int j = 0; j < N; ++j)
+    pointers_to_mutable_chars[j] = &mutable_characters[j];
+
+  boost::indirect_iterator<char* const*> mutable_indirect_first(pointers_to_mutable_chars),
+    mutable_indirect_last(pointers_to_mutable_chars + N);
+  boost::indirect_iterator<char* const*, char const> const_indirect_first(pointers_to_chars),
+    const_indirect_last(pointers_to_chars + N);
+
+  std::transform(const_indirect_first, const_indirect_last,
+                 mutable_indirect_first, std::bind1st(std::plus<char>(), 1));
+
+  std::copy(mutable_indirect_first, mutable_indirect_last,
+            std::ostream_iterator<char>(std::cout, ","));
+  std::cout << std::endl;
+
+  
+  // Example of using make_indirect_iterator()
+
+  std::copy(boost::make_indirect_iterator(pointers_to_chars), 
+            boost::make_indirect_iterator(pointers_to_chars + N),
+            std::ostream_iterator<char>(std::cout, ","));
+  std::cout << std::endl;
+  
+  return 0;
+}
--- a/iterator_adaptor_examples.cpp
+++ b/iterator_adaptor_examples.cpp
@@ -0,0 +1,46 @@
+// (C) Copyright Jeremy Siek 2000. Permission to copy, use, modify, sell and
+// distribute this software is granted provided this copyright notice appears
+// in all copies. This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+
+
+#include <functional>
+#include <algorithm>
+#include <iostream>
+#include <boost/iterator/transform_iterator.hpp>
+#include <boost/pending/integer_range.hpp>
+
+int
+main(int, char*[])
+{
+  // This is a simple example of using the transform_iterators class to
+  // generate iterators that multiply the value returned by dereferencing
+  // the iterator. In this case we are multiplying by 2.
+  // Would be cooler to use lambda library in this example.
+
+  int x[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
+
+  typedef std::binder1st< std::multiplies<int> > Function;
+  
+  typedef boost::transform_iterator<Function, int*> doubling_iterator;
+
+  doubling_iterator i(x, std::bind1st(std::multiplies<int>(), 2)),
+    i_end(x + sizeof(x)/sizeof(int), std::bind1st(std::multiplies<int>(), 2));
+
+  std::cout << "multiplying the array by 2:" << std::endl;
+  while (i != i_end)
+    std::cout << *i++ << " ";
+  std::cout << std::endl;
+
+  // Here is an example of counting from 0 to 5 using the integer_range class.
+
+  boost::integer_range<int> r(0,5);
+
+  std::cout << "counting to from 0 to 4:" << std::endl;
+  std::copy(r.begin(), r.end(), std::ostream_iterator<int>(std::cout, " "));
+  std::cout << std::endl;
+
+  return 0;
+}
+
+
--- a/iterator_adaptors.htm
+++ b/iterator_adaptors.htm
@@ -1,11 +0,0 @@
-<!-- Copyright David Abrahams 2004. Distributed under the Boost -->
-<!-- Software License, Version 1.0. (See accompanying -->
-<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
-<html>
-<head>
-<meta http-equiv="refresh" content="0; URL=../iterator/doc/index.html">
-</head>
-<body>
-This documentation moved to <a href="../iterator/doc/index.html">../iterator/doc/index.html</a>.
-</body>
-</html>
--- a/iterator_traits_test.cpp
+++ b/iterator_traits_test.cpp
@@ -0,0 +1,215 @@
+//  (C) Copyright David Abrahams 2002. Permission to copy, use, modify,
+//  sell and distribute this software is granted provided this
+//  copyright notice appears in all copies. This software is provided
+//  "as is" without express or implied warranty, and with no claim as
+//  to its suitability for any purpose.
+
+//  See http://www.boost.org for most recent version including documentation.
+
+//  Revision History
+//  04 Mar 2001 Patches for Intel C++ (Dave Abrahams)
+//  19 Feb 2001 Take advantage of improved iterator_traits to do more tests
+//              on MSVC. Reordered some #ifdefs for coherency.
+//              (David Abrahams)
+//  13 Feb 2001 Test new VC6 workarounds (David Abrahams)
+//  11 Feb 2001 Final fixes for Borland (David Abrahams)
+//  11 Feb 2001 Some fixes for Borland get it closer on that compiler
+//              (David Abrahams)
+//  07 Feb 2001 More comprehensive testing; factored out static tests for
+//              better reuse (David Abrahams)
+//  21 Jan 2001 Quick fix to my_iterator, which wasn't returning a
+//              reference type from operator* (David Abrahams)
+//  19 Jan 2001 Initial version with iterator operators (David Abrahams)
+
+#include <boost/detail/iterator.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/operators.hpp>
+#include <boost/static_assert.hpp>
+#include <iterator>
+#include <vector>
+#include <list>
+#include <cassert>
+#include <iostream>
+
+// A UDT for which we can specialize std::iterator_traits<element*> on
+// compilers which don't support partial specialization. There's no
+// other reasonable way to test pointers on those compilers.
+struct element {};
+
+// An iterator for which we can get traits.
+struct my_iterator1
+    : boost::forward_iterator_helper<my_iterator1, char, long, const char*, const char&>
+{
+    my_iterator1(const char* p) : m_p(p) {}
+    
+    bool operator==(const my_iterator1& rhs) const
+        { return this->m_p == rhs.m_p; }
+
+    my_iterator1& operator++() { ++this->m_p; return *this; }
+    const char& operator*() { return *m_p; }
+ private:
+    const char* m_p;
+};
+
+// Used to prove that we don't require std::iterator<> in the hierarchy under
+// MSVC6, and that we can compute all the traits for a standard-conforming UDT
+// iterator.
+struct my_iterator2
+    : boost::equality_comparable<my_iterator2
+    , boost::incrementable<my_iterator2
+    , boost::dereferenceable<my_iterator2,const char*> > >
+{
+    typedef char value_type;
+    typedef long difference_type;
+    typedef const char* pointer;
+    typedef const char& reference;
+    typedef std::forward_iterator_tag iterator_category;
+    
+    my_iterator2(const char* p) : m_p(p) {}
+    
+    bool operator==(const my_iterator2& rhs) const
+        { return this->m_p == rhs.m_p; }
+
+    my_iterator2& operator++() { ++this->m_p; return *this; }
+    const char& operator*() { return *m_p; }
+ private:
+    const char* m_p;
+};
+
+// Used to prove that we're not overly confused by the existence of
+// std::iterator<> in the hierarchy under MSVC6 - we should find that
+// boost::detail::iterator_traits<my_iterator3>::difference_type is int.
+struct my_iterator3 : my_iterator1
+{
+    typedef int difference_type;
+    my_iterator3(const char* p)
+        : my_iterator1(p) {}
+};
+
+//
+// Assertion tools.  Used instead of BOOST_STATIC_ASSERT because that
+// doesn't give us a nice stack backtrace
+//
+template <bool = false> struct assertion;
+
+template <> struct assertion<true>
+{
+    typedef char type;
+};
+
+template <class T, class U>
+struct assert_same
+    : assertion<(::boost::is_same<T,U>::value)>
+{
+};
+
+
+// Iterator tests
+template <class Iterator,
+    class value_type, class difference_type, class pointer, class reference, class category>
+struct non_portable_tests
+{
+    typedef typename boost::detail::iterator_traits<Iterator>::pointer test_pt;
+    typedef typename boost::detail::iterator_traits<Iterator>::reference test_rt;
+    typedef typename assert_same<test_pt, pointer>::type a1;
+    typedef typename assert_same<test_rt, reference>::type a2;
+};
+
+template <class Iterator,
+    class value_type, class difference_type, class pointer, class reference, class category>
+struct portable_tests
+{
+    typedef typename boost::detail::iterator_traits<Iterator>::difference_type test_dt;
+    typedef typename boost::detail::iterator_traits<Iterator>::iterator_category test_cat;
+    typedef typename assert_same<test_dt, difference_type>::type a1;
+    typedef typename assert_same<test_cat, category>::type a2;
+};
+
+// Test iterator_traits
+template <class Iterator,
+    class value_type, class difference_type, class pointer, class reference, class category>
+struct input_iterator_test
+    : portable_tests<Iterator,value_type,difference_type,pointer,reference,category>
+{
+    typedef typename boost::detail::iterator_traits<Iterator>::value_type test_vt;
+    typedef typename assert_same<test_vt, value_type>::type a1;
+};
+
+template <class Iterator,
+    class value_type, class difference_type, class pointer, class reference, class category>
+struct non_pointer_test
+    : input_iterator_test<Iterator,value_type,difference_type,pointer,reference,category>
+      , non_portable_tests<Iterator,value_type,difference_type,pointer,reference,category>
+{
+};
+
+template <class Iterator,
+    class value_type, class difference_type, class pointer, class reference, class category>
+struct maybe_pointer_test
+    : portable_tests<Iterator,value_type,difference_type,pointer,reference,category>
+      , non_portable_tests<Iterator,value_type,difference_type,pointer,reference,category>
+{
+};
+
+input_iterator_test<std::istream_iterator<int>, int, std::ptrdiff_t, int*, int&, std::input_iterator_tag>
+        istream_iterator_test;
+
+#if defined(__BORLANDC__) && !defined(__SGI_STL_PORT)
+typedef ::std::char_traits<char>::off_type distance;
+non_pointer_test<std::ostream_iterator<int>,int,
+    distance,int*,int&,std::output_iterator_tag> ostream_iterator_test;
+#elif defined(BOOST_MSVC_STD_ITERATOR)
+non_pointer_test<std::ostream_iterator<int>,
+    int, void, int*, int&, std::output_iterator_tag>
+        ostream_iterator_test;
+#else
+non_pointer_test<std::ostream_iterator<int>,
+    void, void, void, void, std::output_iterator_tag>
+        ostream_iterator_test;
+#endif
+
+
+#ifdef __KCC
+  typedef long std_list_diff_type;
+#else
+  typedef std::ptrdiff_t std_list_diff_type;
+#endif
+
+non_pointer_test<std::list<int>::iterator, int, std_list_diff_type, int*, int&, std::bidirectional_iterator_tag>
+        list_iterator_test;
+
+maybe_pointer_test<std::vector<int>::iterator, int, std::ptrdiff_t, int*, int&, std::random_access_iterator_tag>
+        vector_iterator_test;
+
+maybe_pointer_test<int*, int, std::ptrdiff_t, int*, int&, std::random_access_iterator_tag>
+        int_pointer_test;
+
+non_pointer_test<my_iterator1, char, long, const char*, const char&, std::forward_iterator_tag>
+       my_iterator1_test;
+                    
+non_pointer_test<my_iterator2, char, long, const char*, const char&, std::forward_iterator_tag>
+       my_iterator2_test;
+
+non_pointer_test<my_iterator3, char, int, const char*, const char&, std::forward_iterator_tag>
+       my_iterator3_test;
+
+int main()
+{
+    char chars[100];
+    int ints[100];
+
+    for (int length = 3; length < 100; length += length / 3)
+    {
+        std::list<int> l(length);
+        assert(boost::detail::distance(l.begin(), l.end()) == length);
+        
+        std::vector<int> v(length);
+        assert(boost::detail::distance(v.begin(), v.end()) == length);
+
+        assert(boost::detail::distance(&ints[0], ints + length) == length);
+        assert(boost::detail::distance(my_iterator1(chars), my_iterator1(chars + length)) == length);
+        assert(boost::detail::distance(my_iterator2(chars), my_iterator2(chars + length)) == length);
+        assert(boost::detail::distance(my_iterator3(chars), my_iterator3(chars + length)) == length);
+    }
+    return 0;
+}
--- a/iterators_test.cpp
+++ b/iterators_test.cpp
@@ -1,9 +1,10 @@
 //  Demonstrate and test boost/operators.hpp on std::iterators  --------------//

-//  (C) Copyright Jeremy Siek 1999.
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+//  (C) Copyright Jeremy Siek 1999. Permission to copy, use, modify,
+//  sell and distribute this software is granted provided this
+//  copyright notice appears in all copies. This software is provided
+//  "as is" without express or implied warranty, and with no claim as
+//  to its suitability for any purpose.

 //  See http://www.boost.org for most recent version including documentation.

@@ -23,7 +24,7 @@
 #include <cstring>    // for std::strcmp
 #include <iostream>   // for std::cout (std::endl, ends, and flush indirectly)
 #include <string>     // for std::string
-#include <sstream>    // for std::stringstream
+#include <strstream>  // for std::ostrstream

 # ifdef BOOST_NO_STDC_NAMESPACE
    namespace std { using ::strcmp; }
@@ -64,16 +65,20 @@ class test_opr_base
 protected:
    // Test data and types
    BOOST_STATIC_CONSTANT( std::size_t, fruit_length = 6u );
+    BOOST_STATIC_CONSTANT( std::size_t, scratch_length = 40u );

    typedef std::string  fruit_array_type[ fruit_length ];
+    typedef char         scratch_array_type[ scratch_length ];

    static  fruit_array_type    fruit;
+    static  scratch_array_type  scratch;

 };  // test_opr_base

 #ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
 //  A definition is required even for integral static constants
 const std::size_t test_opr_base::fruit_length;
+const std::size_t test_opr_base::scratch_length;
 #endif

 template <typename T, typename R = T&, typename P = T*>
@@ -115,6 +120,9 @@ private:
 test_opr_base::fruit_array_type
 test_opr_base::fruit = { "apple", "orange", "pear", "peach", "grape", "plum" };

+test_opr_base::scratch_array_type
+ test_opr_base::scratch = "";
+
 template <typename T, typename R, typename P>
  typename test_opr<T, R, P>::iter_type const
 test_opr<T, R, P>::fruit_begin = test_iter<T,R,P>( fruit );
@@ -168,13 +176,15 @@ test_opr<T, R, P>::post_increment_test
 {
    std::cout << "\tDoing post-increment test." << std::endl;

-    std::stringstream oss;
+    std::ostrstream  oss( scratch, scratch_length );
    for ( iter_type i = fruit_begin ; i != fruit_end ; )
    {
        oss << *i++ << ' ';
    }

-    BOOST_TEST( oss.str() == "apple orange pear peach grape plum ");
+    oss << std::ends;
+    BOOST_TEST( std::strcmp(oss.str(), "apple orange pear peach grape plum ")
+     == 0 );
 }

 // Test post-decrement
@@ -186,14 +196,16 @@ test_opr<T, R, P>::post_decrement_test
 {
    std::cout << "\tDoing post-decrement test." << std::endl;

-    std::stringstream oss;
+    std::ostrstream  oss( scratch, scratch_length );
    for ( iter_type i = fruit_end ; i != fruit_begin ; )
    {
        i--;
        oss << *i << ' ';
    }

-    BOOST_TEST( oss.str() == "plum grape peach pear orange apple ");
+    oss << std::ends;
+    BOOST_TEST( std::strcmp(oss.str(), "plum grape peach pear orange apple ")
+     == 0 );
 }

 // Test indirect structure referral
@@ -205,13 +217,14 @@ test_opr<T, R, P>::indirect_referral_test
 {
    std::cout << "\tDoing indirect reference test." << std::endl;

-    std::stringstream oss;
+    std::ostrstream  oss( scratch, scratch_length );
    for ( iter_type i = fruit_begin ; i != fruit_end ; ++i )
    {
        oss << i->size() << ' ';
    }

-    BOOST_TEST( oss.str() == "5 6 4 5 5 4 ");
+    oss << std::ends;
+    BOOST_TEST( std::strcmp(oss.str(), "5 6 4 5 5 4 ") == 0 );
 }

 // Test offset addition
@@ -224,13 +237,14 @@ test_opr<T, R, P>::offset_addition_test
    std::cout << "\tDoing offset addition test." << std::endl;

    std::ptrdiff_t const  two = 2;
-    std::stringstream oss;
+    std::ostrstream       oss( scratch, scratch_length );
    for ( iter_type i = fruit_begin ; i != fruit_end ; i = i + two )
    {
        oss << *i << ' ';
    }

-    BOOST_TEST( oss.str() == "apple pear grape ");
+    oss << std::ends;
+    BOOST_TEST( std::strcmp(oss.str(), "apple pear grape ") == 0 );
 }

 // Test offset addition, in reverse order
@@ -243,13 +257,14 @@ test_opr<T, R, P>::reverse_offset_addition_test
    std::cout << "\tDoing reverse offset addition test." << std::endl;

    std::ptrdiff_t const  two = 2;
-    std::stringstream oss;
+    std::ostrstream       oss( scratch, scratch_length );
    for ( iter_type i = fruit_begin ; i != fruit_end ; i = two + i )
    {
        oss << *i << ' ';
    }

-    BOOST_TEST( oss.str() == "apple pear grape ");
+    oss << std::ends;
+    BOOST_TEST( std::strcmp(oss.str(), "apple pear grape ") == 0 );
 }

 // Test offset subtraction
@@ -262,7 +277,7 @@ test_opr<T, R, P>::offset_subtraction_test
    std::cout << "\tDoing offset subtraction test." << std::endl;

    std::ptrdiff_t const  two = 2;
-    std::stringstream oss;
+    std::ostrstream       oss( scratch, scratch_length );
    for ( iter_type i = fruit_end ; fruit_begin < i ; )
    {
        i = i - two;
@@ -272,7 +287,8 @@ test_opr<T, R, P>::offset_subtraction_test
        }
    }

-    BOOST_TEST( oss.str() == "grape pear apple ");
+    oss << std::ends;
+    BOOST_TEST( std::strcmp(oss.str(), "grape pear apple ") == 0 );
 }

 // Test comparisons
@@ -314,11 +330,13 @@ test_opr<T, R, P>::indexing_test
 {
    std::cout << "\tDoing indexing test." << std::endl;

-    std::stringstream oss;
+    std::ostrstream  oss( scratch, scratch_length );
    for ( std::size_t k = 0u ; k < fruit_length ; ++k )
    {
        oss << fruit_begin[ k ] << ' ';
    }

-    BOOST_TEST( oss.str() == "apple orange pear peach grape plum ");
+    oss << std::ends;
+    BOOST_TEST( std::strcmp(oss.str(), "apple orange pear peach grape plum ")
+     == 0 );
 }
--- a/noncopyable_test.cpp
+++ b/noncopyable_test.cpp
@@ -1,8 +1,10 @@
 //  boost class noncopyable test program  ------------------------------------//

-//  (C) Copyright Beman Dawes 1999. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//  (C) Copyright boost.org 1999. Permission to copy, use, modify, sell
+//  and distribute this software is granted provided this copyright
+//  notice appears in all copies. This software is provided "as is" without
+//  express or implied warranty, and with no claim as to its suitability for
+//  any purpose.

 //  See http://www.boost.org for most recent version including documentation.

--- a/numeric_traits_test.cpp
+++ b/numeric_traits_test.cpp
@@ -1,7 +1,8 @@
-//  (C) Copyright David Abrahams 2001.
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+//  (C) Copyright David Abrahams 2001. Permission to copy, use, modify,
+//  sell and distribute this software is granted provided this
+//  copyright notice appears in all copies. This software is provided
+//  "as is" without express or implied warranty, and with no claim as
+//  to its suitability for any purpose.

 //  See http://www.boost.org for most recent version including documentation.

@@ -374,8 +375,8 @@ int main()
    test<long>();
    test<unsigned long>();
 #if defined(BOOST_HAS_LONG_LONG) && !defined(BOOST_NO_INTEGRAL_INT64_T)
-    test< ::boost::long_long_type>();
-    test< ::boost::ulong_long_type>();
+    test<long long>();
+    test<unsigned long long>();
 #elif defined(BOOST_MSVC)
    // The problem of not having compile-time static class constants other than
    // enums prevents this from working, since values get truncated.
--- a/operators.htm
+++ b/operators.htm
@@ -10,7 +10,7 @@
  </head>

  <body text="black" bgcolor="white" link="blue" vlink="purple" alink="red">
-    <h1><img src="../../boost.png" alt="boost.png (6897 bytes)" align=
+    <h1><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align=
    "middle" width="277" height="86">Header <cite>&lt;<a href=
    "../../boost/operators.hpp">boost/operators.hpp</a>&gt;</cite></h1>

@@ -1955,7 +1955,7 @@ T operator+( T lhs, const T&amp; rhs )
    output iterator to writing just two member functions - an appropriate
    constructor and a copy-assignment operator. For example, here is a
    possible implementation of <code><a href=
-    "../iterator/doc/function_output_iterator.html">boost::function_output_iterator</a></code>
+    "function_output_iterator.htm">boost::function_output_iterator</a></code>
    adaptor:</p>
 <pre>
 template&lt;class UnaryFunction&gt;
@@ -2119,10 +2119,10 @@ public:
    backward-compatible.</p>
    <hr>

-    <p>Revised: 29 Oct 2004</p>
+    <p>Revised: 03 Dec 2003</p>

    <p>Copyright &copy; Beman Dawes, David Abrahams, 1999-2001.</p>
-    <p>Copyright &copy; Daniel Frey, 2002-2004.</p>
+    <p>Copyright &copy; Daniel Frey, 2002-2003.</p>
    <p>Use, modification, and distribution is subject to the Boost Software 
    License, Version 1.0. (See accompanying file
    <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy at
--- a/operators_test.cpp
+++ b/operators_test.cpp
@@ -1,8 +1,7 @@
 //  Demonstrate and test boost/operators.hpp  -------------------------------//

-//  Copyright Beman Dawes 1999.  Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//  Copyright Beman Dawes 1999.
+//  See accompanying license for terms and conditions of use.

 //  See http://www.boost.org/libs/utility for documentation.

--- a/projection_iterator_example.cpp
+++ b/projection_iterator_example.cpp
@@ -0,0 +1,103 @@
+// (C) Copyright Jeremy Siek 2000. Permission to copy, use, modify, sell and
+// distribute this software is granted provided this copyright notice appears
+// in all copies. This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+
+#include <boost/config.hpp>
+#include <list>
+#include <iostream>
+#include <iterator>
+#include <algorithm>
+#include <string>
+#include <boost/iterator/transform_iterator.hpp>
+
+struct personnel_record {
+  personnel_record(std::string n, int id) : m_name(n), m_ID(id) { }
+  std::string m_name;
+  int m_ID;
+};
+
+struct select_name {
+  typedef personnel_record argument_type;
+  typedef std::string const& result_type;
+  const std::string& operator()(const personnel_record& r) const {
+    return r.m_name;
+  }
+  std::string& operator()(personnel_record& r) const {
+    return r.m_name;
+  }
+};
+
+struct select_ID {
+  typedef personnel_record argument_type;
+  typedef int& result_type;
+  const int& operator()(const personnel_record& r) const {
+    return r.m_ID;
+  }
+  int& operator()(personnel_record& r) const {
+    return r.m_ID;
+  }
+};
+
+int main(int, char*[])
+{
+  std::list<personnel_record> personnel_list;
+
+  personnel_list.push_back(personnel_record("Barney", 13423));
+  personnel_list.push_back(personnel_record("Fred", 12343));
+  personnel_list.push_back(personnel_record("Wilma", 62454));
+  personnel_list.push_back(personnel_record("Betty", 20490));
+
+  // Example of using transform_iterator to print out the names in the
+  // personnel list using a projection.
+
+  boost::transform_iterator<
+      select_name
+    , std::list<personnel_record>::iterator
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    , std::string
+#endif 
+  >
+    personnel_first(personnel_list.begin()),
+    personnel_last(personnel_list.end());
+
+  std::copy(personnel_first, personnel_last,
+            std::ostream_iterator<std::string>(std::cout, "\n"));
+  std::cout << std::endl;
+  
+  // Example of using transform_iterator with const_iterators to
+  // assign new ID numbers to the personnel.
+  
+  boost::transform_iterator<
+      select_ID, std::list<personnel_record>::iterator
+ > ID_first(personnel_list.begin()),
+    ID_last(personnel_list.end());
+
+  int new_id = 0;
+  while (ID_first != ID_last) {
+    *ID_first = new_id++;
+    ++ID_first;
+  }
+
+    boost::transform_iterator<
+      select_ID, std::list<personnel_record>::const_iterator, int const&
+    >
+    const_ID_first(personnel_list.begin()),
+    const_ID_last(personnel_list.end());
+
+  std::copy(const_ID_first, const_ID_last,
+            std::ostream_iterator<int>(std::cout, " "));
+  std::cout << std::endl;
+  std::cout << std::endl;
+
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+  // Example of using make_const_projection_iterator()
+  // to print out the names in the personnel list again.
+  std::copy(
+      boost::make_transform_iterator<select_name>(personnel_list.begin())
+    , boost::make_transform_iterator<select_name>(personnel_list.end())
+    , std::ostream_iterator<std::string>(std::cout, "\n"));
+#endif
+  
+  return 0;
+}
--- a/ref_ct_test.cpp
+++ b/ref_ct_test.cpp
@@ -1,18 +1,9 @@
-// Copyright David Abrahams and Aleksey Gurtovoy
-// 2002-2004. Distributed under the Boost Software License, Version
-// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
 // compile-time test for "boost/ref.hpp" header content
 // see 'ref_test.cpp' for run-time part

 #include <boost/ref.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/same_traits.hpp>
 #include <boost/static_assert.hpp>
-#include <boost/detail/workaround.hpp>
-
-#include <boost/mpl/assert.hpp>

 namespace {

@@ -39,23 +30,13 @@ void is_reference_wrapper_test(T)
 template< typename R, typename Ref >
 void cxx_reference_test(Ref)
 {
-#if BOOST_WORKAROUND(__BORLANDC__, < 0x600)
-    typedef typename boost::remove_const<Ref>::type ref;
-    BOOST_STATIC_ASSERT((boost::is_same<R,ref>::value));
-#else
    BOOST_STATIC_ASSERT((boost::is_same<R,Ref>::value));
-#endif
 }

 template< typename R, typename Ref >
 void unwrap_reference_test(Ref)
 {
-#if BOOST_WORKAROUND(__BORLANDC__, < 0x600)
-    typedef typename boost::remove_const<Ref>::type ref;
-    typedef typename boost::unwrap_reference<ref>::type type;
-#else
    typedef typename boost::unwrap_reference<Ref>::type type;
-#endif
    BOOST_STATIC_ASSERT((boost::is_same<R,type>::value));
 }

--- a/ref_test.cpp
+++ b/ref_test.cpp
@@ -1,7 +1,3 @@
-// Copyright David Abrahams and Aleksey Gurtovoy
-// 2002-2004. Distributed under the Boost Software License, Version
-// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)

 // run-time test for "boost/ref.hpp" header content
 // see 'ref_ct_test.cpp' for compile-time part
--- a/reverse_iterator_example.cpp
+++ b/reverse_iterator_example.cpp
@@ -0,0 +1,47 @@
+// (C) Copyright Jeremy Siek 2000. Permission to copy, use, modify, sell and
+// distribute this software is granted provided this copyright notice appears
+// in all copies. This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+
+#include <boost/config.hpp>
+#include <iostream>
+#include <algorithm>
+#include <boost/iterator/reverse_iterator.hpp>
+#include <boost/detail/iterator.hpp>
+
+//boost::detail::iterator_traits
+int main(int, char*[])
+{
+  char letters_[] = "hello world!";
+  const int N = sizeof(letters_)/sizeof(char) - 1;
+  typedef char* base_iterator;
+  base_iterator letters(letters_);
+  
+  std::cout << "original sequence of letters:\t"
+            << letters_ << std::endl;
+
+  std::sort(letters, letters + N);
+
+  // Use reverse_iterator_generator to print a sequence
+  // of letters in reverse order.
+  
+  boost::reverse_iterator<base_iterator>
+    reverse_letters_first(letters + N),
+    reverse_letters_last(letters);
+
+  std::cout << "letters in descending order:\t";
+  std::copy(reverse_letters_first, reverse_letters_last,
+            std::ostream_iterator<char>(std::cout));
+  std::cout << std::endl;
+
+  // Use make_reverse_iterator() to print the sequence
+  // of letters in reverse-reverse order.
+
+  std::cout << "letters in ascending order:\t";
+  std::copy(boost::make_reverse_iterator(reverse_letters_last),
+            boost::make_reverse_iterator(reverse_letters_first),
+            std::ostream_iterator<char>(std::cout));
+  std::cout << std::endl;
+
+  return 0;
+}
--- a/shared_container_iterator.html
+++ b/shared_container_iterator.html
@@ -9,7 +9,7 @@

 <body bgcolor="#FFFFFF" text="#000000">

-<img src="../../boost.png" alt="boost.png (6897 bytes)"
+<img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)"
 align="center" width="277" height="86">

 <h1>Shared Container Iterator</h1>
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -6,6 +6,8 @@

 # For more information, see http://www.boost.org/

+
+# Testing Jamfile autogenerated from XML source
 subproject libs/utility/test ;

 # bring in rules for testing
@@ -16,28 +18,26 @@ DEPENDS all : test ;

 local test_monitor = <lib>@boost/libs/test/build/boost_test_exec_monitor ;

-# Please keep the tests ordered by filename
 test-suite utility
-    :
-        [ run ../addressof_test.cpp $(test_monitor) ]
-        [ run ../assert_test.cpp ]
-        [ run ../base_from_member_test.cpp ]
-        [ run ../binary_search_test.cpp ]
-        [ run ../call_traits_test.cpp : -u ]
-        [ compile-fail ../checked_delete_test.cpp ]
-        [ run ../compressed_pair_test.cpp $(test_monitor) : -u ]
-        [ run ../current_function_test.cpp : : : <test-info>always_show_run_output ]
+    : 
+        [ run ../iterator_traits_test.cpp ]
        [ run ../iterators_test.cpp $(test_monitor) ]
-        [ run next_prior_test.cpp $(test_monitor) ]
        [ compile-fail ../noncopyable_test.cpp ]
        [ run ../numeric_traits_test.cpp ]
        [ run ../operators_test.cpp $(test_monitor) ]
-        [ compile ../ref_ct_test.cpp  ]
+        [ run ../binary_search_test.cpp $(test_monitor) ]
+        [ run ../call_traits_test.cpp : -u ]
+        [ compile-fail ../checked_delete_test.cpp ]
+        [ run ../compressed_pair_test.cpp $(test_monitor) : -u ]
+        [ run ../addressof_test.cpp $(test_monitor) ]
        [ run ../ref_test.cpp $(test_monitor) ]
-        [ compile result_of_test.cpp ]
-        [ run ../shared_iterator_test.cpp ]
-        [ run ../value_init_test.cpp ]
-        [ compile-fail ../value_init_test_fail1.cpp ]
-        [ compile-fail ../value_init_test_fail2.cpp ]
-        [ compile-fail ../value_init_test_fail3.cpp ]
+        [ run ../enable_if_constructors.cpp $(test_monitor) ]
+        [ run ../enable_if_dummy_arg_disambiguation.cpp $(test_monitor) ]
+        [ run ../enable_if_lazy.cpp $(test_monitor) ]
+        [ run ../enable_if_lazy_test.cpp $(test_monitor) ]
+        [ run ../enable_if_member_templates.cpp $(test_monitor) ]
+        [ run ../enable_if_namespace_disambiguation.cpp $(test_monitor) ]
+        [ run ../enable_if_no_disambiguation.cpp $(test_monitor) ]
+        [ run ../enable_if_partial_specializations.cpp $(test_monitor) ]
+        [ run next_prior_test.cpp $(test_monitor) ]          
    ;
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -9,28 +9,25 @@
 # bring in rules for testing
 import testing ;

-# Please keep the tests ordered by filename
 test-suite utility
-    :
-        [ run ../addressof_test.cpp ../../test/build//boost_test_exec_monitor ]
-        [ run ../assert_test.cpp ]
-        [ run ../base_from_member_test.cpp ]
-        [ run ../binary_search_test.cpp ]
-        [ run ../call_traits_test.cpp : -u ]
-        [ compile-fail ../checked_delete_test.cpp ]
-        [ run ../compressed_pair_test.cpp ../../test/build//boost_test_exec_monitor : -u ]
-        [ run ../current_function_test.cpp : : : <test-info>always_show_run_output ]
+    : 
+        [ run ../iterator_traits_test.cpp ]
        [ run ../iterators_test.cpp ../../test/build//boost_test_exec_monitor ]
-        [ run next_prior_test.cpp ../../test/build//boost_test_exec_monitor ]
        [ compile-fail ../noncopyable_test.cpp ]
        [ run ../numeric_traits_test.cpp ]
        [ run ../operators_test.cpp ../../test/build//boost_test_exec_monitor ]
-        [ compile ../ref_ct_test.cpp  ]
+        [ run ../binary_search_test.cpp ../../test/build//boost_test_exec_monitor ]
+        [ run ../call_traits_test.cpp : -u ]
+        [ compile-fail ../checked_delete_test.cpp ]
+        [ run ../compressed_pair_test.cpp ../../test/build//boost_test_exec_monitor : -u ]
+        [ run ../addressof_test.cpp ../../test/build//boost_test_exec_monitor ]
        [ run ../ref_test.cpp ../../test/build//boost_test_exec_monitor ]
-        [ compile result_of_test.cpp ]
-        [ run ../shared_iterator_test.cpp ]
-        [ run ../value_init_test.cpp ]
-        [ compile-fail ../value_init_test_fail1.cpp ]
-        [ compile-fail ../value_init_test_fail2.cpp ]
-        [ compile-fail ../value_init_test_fail3.cpp ]
+        [ run ../enable_if_constructors.cpp ../../test/build//boost_test_exec_monitor ]
+        [ run ../enable_if_dummy_arg_disambiguation.cpp ../../test/build//boost_test_exec_monitor ]
+        [ run ../enable_if_lazy.cpp ../../test/build//boost_test_exec_monitor ]
+        [ run ../enable_if_lazy_test.cpp ../../test/build//boost_test_exec_monitor ]
+        [ run ../enable_if_member_templates.cpp ../../test/build//boost_test_exec_monitor ]
+        [ run ../enable_if_namespace_disambiguation.cpp ../../test/build//boost_test_exec_monitor ]
+        [ run ../enable_if_no_disambiguation.cpp ../../test/build//boost_test_exec_monitor ]
+        [ run ../enable_if_partial_specializations.cpp ../../test/build//boost_test_exec_monitor ]
    ;
--- a/test/result_of_test.cpp
+++ b/test/result_of_test.cpp
@@ -1,53 +0,0 @@
-// Boost result_of library
-
-//  Copyright Douglas Gregor 2003-2004. Use, modification and
-//  distribution is subject to the Boost Software License, Version
-//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
-
-// For more information, see http://www.boost.org/libs/utility
-#include <boost/utility/result_of.hpp>
-#include <utility>
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/is_same.hpp>
-
-struct int_result_type { typedef int result_type; };
-
-struct int_result_of
-{
-  template<typename F> struct result { typedef int type; };
-};
-
-struct int_result_type_and_float_result_of
-{
-  typedef int result_type;
-  template<typename F> struct result { typedef float type; };
-};
-
-struct X {};
-
-int main()
-{
-  using namespace boost;
-
-  typedef int (*func_ptr)(float, double);
-  typedef int (&func_ref)(float, double);
-  typedef int (X::*mem_func_ptr)(float);
-  typedef int (X::*mem_func_ptr_c)(float) const;
-  typedef int (X::*mem_func_ptr_v)(float) volatile;
-  typedef int (X::*mem_func_ptr_cv)(float) const volatile;
-
-  BOOST_STATIC_ASSERT((is_same<result_of<int_result_type(float)>::type, int>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<int_result_of(double)>::type, int>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<int_result_of(void)>::type, void>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<const int_result_of(double)>::type, int>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<volatile int_result_of(void)>::type, void>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<int_result_type_and_float_result_of(char)>::type, int>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<func_ptr(char, float)>::type, int>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<func_ref(char, float)>::type, int>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<mem_func_ptr(X,char)>::type, int>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<mem_func_ptr_c(X,char)>::type, int>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<mem_func_ptr_v(X,char)>::type, int>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<mem_func_ptr_cv(X,char)>::type, int>::value));
-  return 0;
-}
--- a/throw_exception.html
+++ b/throw_exception.html
@@ -8,7 +8,7 @@
 		<table border="0" width="100%">
 			<tr>
 				<td width="277">
-					<img src="../../boost.png" alt="boost.png (6897 bytes)" width="277" height="86">
+					<img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" width="277" height="86">
 				</td>
 				<td align="middle">
 					<h1>throw_exception.hpp</h1>
--- a/transform_iterator_example.cpp
+++ b/transform_iterator_example.cpp
@@ -0,0 +1,76 @@
+// (C) Copyright Jeremy Siek 2000. Permission to copy, use, modify, sell and
+// distribute this software is granted provided this copyright notice appears
+// in all copies. This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+
+
+#include <functional>
+#include <algorithm>
+#include <iostream>
+#include <boost/iterator/transform_iterator.hpp>
+
+// What a bummer. We can't use std::binder1st with transform iterator
+// because it does not have a default constructor. Here's a version
+// that does.
+
+namespace boost {
+
+  template <class Operation> 
+  class binder1st
+    : public std::unary_function<typename Operation::second_argument_type,
+                                 typename Operation::result_type> {
+  protected:
+    Operation op;
+    typename Operation::first_argument_type value;
+  public:
+    binder1st() { } // this had to be added!
+    binder1st(const Operation& x,
+              const typename Operation::first_argument_type& y)
+        : op(x), value(y) {}
+    typename Operation::result_type
+    operator()(const typename Operation::second_argument_type& x) const {
+      return op(value, x); 
+    }
+  };
+
+  template <class Operation, class T>
+  inline binder1st<Operation> bind1st(const Operation& op, const T& x) {
+    typedef typename Operation::first_argument_type arg1_type;
+    return binder1st<Operation>(op, arg1_type(x));
+  }
+
+} // namespace boost
+
+int
+main(int, char*[])
+{
+  // This is a simple example of using the transform_iterators class to
+  // generate iterators that multiply the value returned by dereferencing
+  // the iterator. In this case we are multiplying by 2.
+  // Would be cooler to use lambda library in this example.
+
+  int x[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
+  const int N = sizeof(x)/sizeof(int);
+
+  typedef boost::binder1st< std::multiplies<int> > Function;
+  typedef boost::transform_iterator<Function, int*> doubling_iterator;
+
+  doubling_iterator i(x, boost::bind1st(std::multiplies<int>(), 2)),
+    i_end(x + N, boost::bind1st(std::multiplies<int>(), 2));
+
+  std::cout << "multiplying the array by 2:" << std::endl;
+  while (i != i_end)
+    std::cout << *i++ << " ";
+  std::cout << std::endl;
+
+  std::cout << "adding 4 to each element in the array:" << std::endl;
+
+  std::copy(boost::make_transform_iterator(x, boost::bind1st(std::plus<int>(), 4)),
+            boost::make_transform_iterator(x + N, boost::bind1st(std::plus<int>(), 4)),
+            std::ostream_iterator<int>(std::cout, " "));
+  std::cout << std::endl;
+  
+  return 0;
+}
+
+
--- a/utility.htm
+++ b/utility.htm
@@ -4,7 +4,7 @@
 		<title>Header boost/utility.hpp Documentation</title>
 	</head>
 	<body bgcolor="#FFFFFF" text="#000000">
-		<h1><img src="../../boost.png" alt="boost.png (6897 bytes)" align="center" WIDTH="277" HEIGHT="86">Header
+		<h1><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="center" WIDTH="277" HEIGHT="86">Header
 			<a href="../../boost/utility.hpp">boost/utility.hpp</a></h1>
 		<p>The entire contents of the header <code><a href="../../boost/utility.hpp">&lt;boost/utility.hpp&gt;</a></code>
 			are in <code>namespace boost</code>.</p>
@@ -22,7 +22,6 @@
 				Class <a href="#Class_noncopyable">noncopyable</a></li>
 			<li>
 				Function template <a href="#addressof">addressof()</a></li>
-                        <li>Class template <a href="#result_of">result_of</a></li>
 		</ul>
 		<h2>
 			Function templates <a name="checked_delete">checked_delete</a>() and 
@@ -137,51 +136,11 @@ void f() {
  // nonaddressable* xpe = &amp;x; /* error */
 }</pre>
 		</blockquote>
-                <h2><a name="result_of">Class template
-                result_of</a></h2> <p>The class template
-                <code>result_of</code> helps determine the type of a
-                call expression. Given an lvalue <code>f</code> of
-                type <code>F</code> and lvalues <code>t1</code>,
-                <code>t2</code>, ..., <code>t<em>N</em></code> of
-                types <code>T1</code>, <code>T2</code>, ...,
-                <code>T<em>N</em></code>, respectively, the type
-                <code>result_of&lt;F(T1, T2, ...,
-                T<em>N</em>)&gt;::type</code> defines the result type
-                of the expression <code>f(t1, t2,
-                ...,t<em>N</em>)</code>. The implementation permits
-                the type <code>F</code> to be a function pointer,
-                function reference, member function pointer, or class
-                type. When <code>F</code> is a class type with a
-                member type <code>result_type</code>,
-                <code>result_of&lt;F(T1, T2, ...,
-                T<em>N</em>)&gt;</code> is
-                <code>F::result_type</code>. Otherwise,
-                <code>result_of&lt;F(T1, T2, ...,
-                T<em>N</em>)&gt;</code> is <code>F::result&lt;F(T1,
-                T2, ..., T<em>N</em>)&gt;::type</code> when
-                <code><em>N</em> &gt; 0</code> or <code>void</code>
-                when <code><em>N</em> = 0</code>. For additional
-                information about <code>result_of</code>, see the
-                current draft of the C++ Library TR, <a
-                href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2004/n1647.pdf">N1647</a>,
-                or the <code>result_of</code> <a
-                href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1454.html">proposal</a>.</p>
-
-                <p>Class template <code>result_of</code> resides in
-                the header <code>&lt;<a
-                href="../../boost/utility/result_of.hpp">boost/utility/result_of.hpp</a>&gt;</code>. By
-                default, <em>N</em> may be any value between 0 and
-                10. To change the upper limit, define the macro
-                <code>BOOST_RESULT_OF_NUM_ARGS</code> to the maximum
-                value for <em>N</em>.</p>
-
-                <p>This implementation of <code>result_of</code> requires class template partial specialization, the ability to parse function types properly, and support for SFINAE. Contributed by Doug Gregor.</p>
-
 		<h2>Class templates for the Base-from-Member Idiom</h2>
 		<p>See <a href="base_from_member.html">separate documentation</a>.</p>
 		<hr>
 		<p>Revised&nbsp; <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan
-->02 May, 2004<!--webbot bot="Timestamp" endspan i-checksum="38582"
+-->23 December, 2003<!--webbot bot="Timestamp" endspan i-checksum="38582"
 -->
 		</p>
 		<p>&copy; Copyright boost.org 1999-2003. Permission to copy, use, modify, sell and distribute 
--- a/value_init.htm
+++ b/value_init.htm
@@ -8,7 +8,7 @@
 </head>
  <body vlink="#800080" link="#0000ff" text="#000000" bgcolor="#ffffff">
                   
-<h2><img src="../../boost.png" width="276" height="86">
+<h2><img src="../../c++boost.gif" width="276" height="86">
         Header &lt;<a href="../../boost/utility/value_init.hpp">boost/utility/value_init.hpp</a>&gt;
     </h2>
                   
--- a/value_init_test.cpp
+++ b/value_init_test.cpp
@@ -1,8 +1,13 @@
 // (C) 2002, Fernando Luis Cacciola Carballal.
 //
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+// This material is provided "as is", with absolutely no warranty expressed
+// or implied. Any use is at your own risk.
+//
+// Permission to use or copy this software for any purpose is hereby granted
+// without fee, provided the above notices are retained on all copies.
+// Permission to modify the code and to distribute modified code is granted,
+// provided the above notices are retained, and a notice that the code was
+// modified is included with the above copyright notice.
 //
 // Test program for "boost/utility/value_init.hpp"
 //
@@ -17,7 +22,8 @@
 #pragma hdrstop
 #endif

-#include "boost/test/minimal.hpp"
+#define BOOST_INCLUDE_MAIN
+#include "boost/test/test_tools.hpp"

 //
 // Sample POD type
@@ -65,27 +71,33 @@ void test ( T const& y, T const& z )
 {
  boost::value_initialized<T> x ;
  BOOST_TEST ( y == x ) ;
-  BOOST_TEST ( y == boost::get(x) ) ;
+  BOOST_TEST ( y == get(x) ) ;
  static_cast<T&>(x) = z ;
-  boost::get(x) = z ;
+  get(x) = z ;
  BOOST_TEST ( x == z ) ;

  boost::value_initialized<T> const x_c ;
  BOOST_TEST ( y == x_c ) ;
-  BOOST_TEST ( y == boost::get(x_c) ) ;
-  T& x_c_ref = x_c ;
-  x_c_ref = z ;
+  BOOST_TEST ( y == get(x_c) ) ;
+  static_cast<T&>(x_c) = z ;
  BOOST_TEST ( x_c == z ) ;
+  #ifdef PRODUCE_ERROR_1
+  get(x_c) = z ; // this should produce an ERROR
+  #endif

-#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
  boost::value_initialized<T const> cx ;
  BOOST_TEST ( y == cx ) ;
-  BOOST_TEST ( y == boost::get(cx) ) ;
+  BOOST_TEST ( y == get(cx) ) ;
+  #ifdef PRODUCE_ERROR_2
+  get(cx) = z ; // this should produce an ERROR
+  #endif

  boost::value_initialized<T const> const cx_c ;
  BOOST_TEST ( y == cx_c ) ;
-  BOOST_TEST ( y == boost::get(cx_c) ) ;
-#endif
+  BOOST_TEST ( y == get(cx_c) ) ;
+  #ifdef PRODUCE_ERROR_3
+  get(cx_c) = z ; // this should produce an ERROR
+  #endif
 }

 int test_main(int, char **)
--- a/value_init_test_fail1.cpp
+++ b/value_init_test_fail1.cpp
@@ -1,37 +0,0 @@
-// (C) 2002, Fernando Luis Cacciola Carballal.
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-// Test program for "boost/utility/value_init.hpp"
-//
-// Initial: 21 Agu 2002
-
-#include <iostream>
-#include <string>
-
-#include "boost/utility/value_init.hpp"
-
-#ifdef __BORLANDC__
-#pragma hdrstop
-#endif
-
-#include "boost/test/minimal.hpp"
-
-int test_main(int, char **)
-{
-  boost::value_initialized<int> const x_c ;
-
-  get(x_c) = 1234 ; // this should produce an ERROR
-
-  return 0;
-}
-
-
-unsigned int expected_failures = 0;
-
-
-
-
-
--- a/value_init_test_fail2.cpp
+++ b/value_init_test_fail2.cpp
@@ -1,36 +0,0 @@
-// (C) 2002, Fernando Luis Cacciola Carballal.
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-// Test program for "boost/utility/value_init.hpp"
-//
-// Initial: 21 Agu 2002
-
-#include <iostream>
-#include <string>
-
-#include "boost/utility/value_init.hpp"
-
-#ifdef __BORLANDC__
-#pragma hdrstop
-#endif
-
-#include "boost/test/minimal.hpp"
-
-int test_main(int, char **)
-{
-  boost::value_initialized<int const> cx ;
-
-  get(cx) = 1234 ; // this should produce an ERROR
-
-  return 0;
-}
-
-unsigned int expected_failures = 0;
-
-
-
-
-
--- a/value_init_test_fail3.cpp
+++ b/value_init_test_fail3.cpp
@@ -1,37 +0,0 @@
-// (C) 2002, Fernando Luis Cacciola Carballal.
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-// Test program for "boost/utility/value_init.hpp"
-//
-// Initial: 21 Agu 2002
-
-#include <iostream>
-#include <string>
-
-#include "boost/utility/value_init.hpp"
-
-#ifdef __BORLANDC__
-#pragma hdrstop
-#endif
-
-#include "boost/test/minimal.hpp"
-
-int test_main(int, char **)
-{
-  boost::value_initialized<int const> const cx_c ;
-
-  get(cx_c) = 1234 ; // this should produce an ERROR
-
-  return 0;
-}
-
-
-unsigned int expected_failures = 0;
-
-
-
-
-