Branch for adding initializer list support (only in the unreleased gcc 4.4 at the moment).

[SVN r48931]
Fixes #2341 .
2025-10-12 08:35:21 +02:00 · 2008-09-23 19:45:43 +00:00 · 2008-09-20 15:39:47 +00:00 · 2008-09-17 01:08:03 +00:00 · 2008-09-06 21:51:53 +00:00 · 2008-09-06 21:49:49 +00:00
18 changed files with 330 additions and 101 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,31 +0,0 @@
-#----------------------------------------------------------------------------
-# This file was automatically generated from the original CMakeLists.txt file
-# Add a variable to hold the headers for the library
-set (lib_headers
-    assert.hpp
-    call_traits.hpp
-    checked_delete.hpp
-    compressed_pair.hpp
-    current_function.hpp
-    operators.hpp
-    throw_exception.hpp
-    utility.hpp
-    utility
-)
-
-# Add a library target to the build system
-boost_library_project(
-  utility
-  #  SRCDIRS 
-  TESTDIRS  test
-  HEADERS ${lib_headers}
-  #  DOCDIRS 
-  DESCRIPTION  "Various small utilities for C++ programming."
-  MODULARIZED 
-  AUTHORS  "David Abrahams <dave -at- boostpro.com>"
-           "Brad King"
-           "Douglas Gregor <doug.gregor -at- gmail.com>"
-  #  MAINTAINERS 
-)
-
-
--- a/include/boost/swap.hpp
+++ b/include/boost/swap.hpp
@@ -0,0 +1,12 @@
+// Copyright (C) 2007 Joseph Gauterin
+//
+// 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)
+
+#ifndef BOOST_SWAP_HPP
+#define BOOST_SWAP_HPP
+
+#include "./utility/swap.hpp"
+
+#endif
--- a/include/boost/utility/swap.hpp
+++ b/include/boost/utility/swap.hpp
@@ -0,0 +1,55 @@
+// Copyright (C) 2007, 2008 Steven Watanabe, Joseph Gauterin, Niels Dekker
+//
+// 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
+
+
+#ifndef BOOST_UTILITY_SWAP_HPP
+#define BOOST_UTILITY_SWAP_HPP
+
+// Note: the implementation of this utility contains various workarounds:
+// - swap_impl is put outside the boost namespace, to avoid infinite
+// recursion (causing stack overflow) when swapping objects of a primitive
+// type.
+// - swap_impl has a using-directive, rather than a using-declaration,
+// because some compilers (including MSVC 7.1, Borland 5.9.3, and
+// Intel 8.1) don't do argument-dependent lookup when it has a
+// using-declaration instead.
+// - boost::swap has two template arguments, instead of one, to
+// avoid ambiguity when swapping objects of a Boost type that does
+// not have its own boost::swap overload.
+
+#include <algorithm> //for std::swap
+#include <cstddef> //for std::size_t
+
+namespace boost_swap_impl
+{
+  template<class T>
+  void swap_impl(T& left, T& right)
+  {
+    using namespace std;//use std::swap if argument dependent lookup fails
+    swap(left,right);
+  }
+
+  template<class T, std::size_t N>
+  void swap_impl(T (& left)[N], T (& right)[N])
+  {
+    for (std::size_t i = 0; i < N; ++i)
+    {
+      ::boost_swap_impl::swap_impl(left[i], right[i]);
+    }
+  }
+}
+
+namespace boost
+{
+  template<class T1, class T2>
+  void swap(T1& left, T2& right)
+  {
+    ::boost_swap_impl::swap_impl(left, right);
+  }
+}
+
+#endif
--- a/module.cmake
+++ b/module.cmake
@@ -1 +0,0 @@
-boost_module(utility DEPENDS iterator exception detail )
--- a/operators.htm
+++ b/operators.htm
@@ -2030,7 +2030,7 @@ public:
 </pre>
    </blockquote>

-    <p>Check the <a href="http://www.boost.org/development/testing.html">compiler status
+    <p>Check the <a href="../../status/compiler_status.html">compiler status
    report</a> for the test results with selected platforms.</p>
    <hr>

--- a/swap.html
+++ b/swap.html
@@ -0,0 +1,94 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US" lang="en-US">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <title>Boost: Swap Documentation</title>
+   </head>
+  <body>
+    <!-- Page header -->
+    <img src="../../boost.png" alt="C++ Boost" align="middle" width="277" height="86"/>
+    <h1>Swap</h1>
+    
+    <p>
+      <tt>template&lt;class T&gt; void swap(T&amp; <em>left</em>, T&amp; <em>right</em>);</tt>
+    </p>
+     
+    <!-- Intoduction -->
+    <p>
+      The template function <tt>boost::swap</tt> allows the values of two variables to be swapped, using argument dependent lookup to select a specialized swap function if available. If no specialized swap function is available, <tt>std::swap</tt> is used.
+    </p>
+    
+    <!-- Rationale -->
+    <h2>Rationale</h2>
+    <p>
+      The generic <tt>std::swap</tt> function requires that the elements to be swapped are assignable and copy constructible. It is usually implemented using one copy construction and two assignments - this is often both unnecessarily restrictive and unnecessarily slow. In addition, where the generic swap implementation provides only the basic guarantee, specialized swap functions are often able to provide the no-throw exception guarantee (and it is considered best practice to do so where possible<sup><a href="#ref1">1</a></sup>).</p>
+    <p>
+      The alternative to using argument dependent lookup in this situation is to provide a template specialization of std::swap for every type that requires a specialized swap. Although this is legal C++, no Boost libraries use this method, whereas many Boost libraries provide specialized swap functions in their own namespaces.
+    </p>
+    <p>
+      <tt>boost::swap</tt> also supports swapping built-in arrays. Note that <tt>std::swap</tt> doesn't yet do so, but a request to add an overload of <tt>std::swap</tt> for built-in arrays has been well-received by the Library Working Group of the C++ Standards Committee<sup><a href="#ref2">2</a></sup>.      
+    </p>
+    
+    <!-- Exception Safety -->
+    <h2>Exception Safety</h2>
+    <p>
+      <tt>boost::swap</tt> provides the same exception guarantee as the underlying swap function used, with one exception; for an array of type <tt>T[n]</tt>, where <tt>n > 1</tt> and the underlying swap function for <tt>T</tt> provides the strong exception guarantee, <tt>boost::swap</tt> provides only the basic exception guarantee.
+    </p>
+    
+    <!-- Requirements -->
+    <h2>Requirements</h2>
+    <p>Either:</p>
+    <ul>      
+      <li>T must be assignable</li>
+      <li>T must be copy constructible</li>
+    </ul>
+    <p>Or:</p>
+    <ul>
+      <li>A function with the signature <tt>swap(T&,T&)</tt> is available via argument dependent lookup</li>
+    </ul>
+    <p>Or:</p>
+    <ul>
+      <li>A template specialization of std::swap exists for T</li>
+    </ul>
+    <p>Or:</p>
+    <ul>
+      <li>T is a built-in array of swappable elements</li>
+    </ul>
+
+    
+    <!-- Portability -->
+    <h2>Portability</h2>
+    <p>
+      Several older compilers do not support argument dependent lookup &#x2012; on these compilers <tt>boost::swap</tt> will call <tt>std::swap</tt>, ignoring any specialized swap functions that could be found as a result of argument dependent lookup.
+    </p>
+    
+    <!-- Credits -->
+    <h2>Credits</h2>
+    <ul>
+      <li>
+        <em>Niels Dekker</em> - for implementing and documenting support for built-in arrays
+      </li>
+      <li>
+        <em><a href="mailto:Joseph.Gauterin@googlemail.com">Joseph Gauterin</a></em> - for the initial idea, implementation, tests, and documentation
+      </li>
+      <li>
+        <em>Steven Wanatabe</em> - for the idea to make boost::swap less specialized than std::swap, thereby allowing the function to have the name 'swap' without introducing ambiguity
+      </li>      
+    </ul>
+
+    <!-- References -->
+    <hr/>
+    <p><sup><a id="ref1"/>[1]</sup>Scott Meyers, Effective C++ Third Edition, Item 25: "Consider support for a non-throwing swap"</p>
+    <p><sup><a id="ref2"/>[2]</sup><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#809">LWG issue 809 (std::swap should be overloaded for array types)</a></p>
+
+    <!-- Copyright info -->    
+    <hr/>
+    <p>Revised: 4 August 2008</p>
+    <p>
+      Copyright 2007, 2008 Joseph Gauterin. 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>
+    
+  </body>
+</html>
--- a/swap/test/no_ambiguity_in_boost.cpp
+++ b/swap/test/no_ambiguity_in_boost.cpp
@@ -25,10 +25,17 @@ namespace boost

 int test_main(int, char*[])
 {
-  boost::swap_test_class object1;
-  boost::swap_test_class object2;
+  const boost::swap_test_class initial_value1(1);
+  const boost::swap_test_class initial_value2(2);
+
+  boost::swap_test_class object1 = initial_value1;
+  boost::swap_test_class object2 = initial_value2;
+
+  boost::swap_test_class::reset();
  boost::swap(object1,object2);

+  BOOST_CHECK(object1 == initial_value2);
+  BOOST_CHECK(object2 == initial_value1);
  BOOST_CHECK_EQUAL(boost::swap_test_class::swap_count(),0);
  BOOST_CHECK_EQUAL(boost::swap_test_class::copy_count(),3);

--- a/swap/test/specialized_in_boost.cpp
+++ b/swap/test/specialized_in_boost.cpp
@@ -25,10 +25,18 @@ namespace boost

 int test_main(int, char*[])
 {
-  boost::swap_test_class object1;
-  boost::swap_test_class object2;
+  const boost::swap_test_class initial_value1(1);
+  const boost::swap_test_class initial_value2(2);
+
+  boost::swap_test_class object1 = initial_value1;
+  boost::swap_test_class object2 = initial_value2;
+  
+  boost::swap_test_class::reset();
  boost::swap(object1,object2);

+  BOOST_CHECK(object1 == initial_value2);
+  BOOST_CHECK(object2 == initial_value1);
+
  BOOST_CHECK_EQUAL(boost::swap_test_class::swap_count(),1);
  BOOST_CHECK_EQUAL(boost::swap_test_class::copy_count(),0);

--- a/swap/test/specialized_in_boost_and_other.cpp
+++ b/swap/test/specialized_in_boost_and_other.cpp
@@ -44,10 +44,18 @@ namespace other

 int test_main(int, char*[])
 {
-  other::swap_test_class object1;
-  other::swap_test_class object2;
+  const other::swap_test_class initial_value1(1);
+  const other::swap_test_class initial_value2(2);
+
+  other::swap_test_class object1 = initial_value1;
+  other::swap_test_class object2 = initial_value2;
+  
+  other::swap_test_class::reset();
  boost::swap(object1,object2);

+  BOOST_CHECK(object1 == initial_value2);
+  BOOST_CHECK(object2 == initial_value1);
+  
  BOOST_CHECK_EQUAL(other::swap_test_class::swap_count(),1);
  BOOST_CHECK_EQUAL(other::swap_test_class::copy_count(),0);

--- a/swap/test/specialized_in_global.cpp
+++ b/swap/test/specialized_in_global.cpp
@@ -19,10 +19,18 @@ void swap(swap_test_class& left, swap_test_class& right)

 int test_main(int, char*[])
 {
-  swap_test_class object1;
-  swap_test_class object2;
+  const swap_test_class initial_value1(1);
+  const swap_test_class initial_value2(2);
+
+  swap_test_class object1 = initial_value1;
+  swap_test_class object2 = initial_value2;
+  
+  swap_test_class::reset();
  boost::swap(object1,object2);

+  BOOST_CHECK(object1 == initial_value2);
+  BOOST_CHECK(object2 == initial_value1);
+  
  BOOST_CHECK_EQUAL(swap_test_class::swap_count(),1);
  BOOST_CHECK_EQUAL(swap_test_class::copy_count(),0);

--- a/swap/test/specialized_in_other.cpp
+++ b/swap/test/specialized_in_other.cpp
@@ -25,10 +25,18 @@ namespace other

 int test_main(int, char*[])
 {
-  other::swap_test_class object1;
-  other::swap_test_class object2;
+  const other::swap_test_class initial_value1(1);
+  const other::swap_test_class initial_value2(2);
+
+  other::swap_test_class object1 = initial_value1;
+  other::swap_test_class object2 = initial_value2;
+  
+  other::swap_test_class::reset();
  boost::swap(object1,object2);

+  BOOST_CHECK(object1 == initial_value2);
+  BOOST_CHECK(object2 == initial_value1);
+  
  BOOST_CHECK_EQUAL(other::swap_test_class::swap_count(),1);
  BOOST_CHECK_EQUAL(other::swap_test_class::copy_count(),0);

--- a/swap/test/specialized_in_std.cpp
+++ b/swap/test/specialized_in_std.cpp
@@ -24,10 +24,18 @@ namespace std

 int test_main(int, char*[])
 {
-  swap_test_class object1;
-  swap_test_class object2;
+  const swap_test_class initial_value1(1);
+  const swap_test_class initial_value2(2);
+
+  swap_test_class object1 = initial_value1;
+  swap_test_class object2 = initial_value2;
+  
+  swap_test_class::reset();
  boost::swap(object1,object2);

+  BOOST_CHECK(object1 == initial_value2);
+  BOOST_CHECK(object2 == initial_value1);
+  
  BOOST_CHECK_EQUAL(swap_test_class::swap_count(),1);
  BOOST_CHECK_EQUAL(swap_test_class::copy_count(),0);

--- a/swap/test/std_vector_of_boost.cpp
+++ b/swap/test/std_vector_of_boost.cpp
@@ -36,8 +36,11 @@ int test_main(int, char*[])
  const vector_type::size_type initial_size1 = 1;
  const vector_type::size_type initial_size2 = 2;

-  vector_type object1(initial_size1);
-  vector_type object2(initial_size2);
+  const vector_type initial_value1(initial_size1, swap_test_class_type(1));
+  const vector_type initial_value2(initial_size2, swap_test_class_type(2));
+  
+  vector_type object1 = initial_value1;
+  vector_type object2 = initial_value2;

  swap_test_class_type::reset();
  
@@ -46,6 +49,9 @@ int test_main(int, char*[])
  BOOST_CHECK_EQUAL(object1.size(),initial_size2);
  BOOST_CHECK_EQUAL(object2.size(),initial_size1);

+  BOOST_CHECK(object1 == initial_value2);
+  BOOST_CHECK(object2 == initial_value1);
+  
  BOOST_CHECK_EQUAL(swap_test_class_type::swap_count(),0);
  BOOST_CHECK_EQUAL(swap_test_class_type::copy_count(),0);

--- a/swap/test/std_vector_of_global.cpp
+++ b/swap/test/std_vector_of_global.cpp
@@ -29,8 +29,11 @@ int test_main(int, char*[])
  const vector_type::size_type initial_size1 = 1;
  const vector_type::size_type initial_size2 = 2;

-  vector_type object1(initial_size1);
-  vector_type object2(initial_size2);
+  const vector_type initial_value1(initial_size1, swap_test_class(1));
+  const vector_type initial_value2(initial_size2, swap_test_class(2));
+  
+  vector_type object1 = initial_value1;
+  vector_type object2 = initial_value2;

  swap_test_class::reset();
  
@@ -39,6 +42,9 @@ int test_main(int, char*[])
  BOOST_CHECK_EQUAL(object1.size(),initial_size2);
  BOOST_CHECK_EQUAL(object2.size(),initial_size1);

+  BOOST_CHECK(object1 == initial_value2);
+  BOOST_CHECK(object2 == initial_value1);
+
  BOOST_CHECK_EQUAL(swap_test_class::swap_count(),0);
  BOOST_CHECK_EQUAL(swap_test_class::copy_count(),0);

--- a/swap/test/std_vector_of_other.cpp
+++ b/swap/test/std_vector_of_other.cpp
@@ -36,8 +36,11 @@ int test_main(int, char*[])
  const vector_type::size_type initial_size1 = 1;
  const vector_type::size_type initial_size2 = 2;

-  vector_type object1(initial_size1);
-  vector_type object2(initial_size2);
+  const vector_type initial_value1(initial_size1, swap_test_class_type(1));
+  const vector_type initial_value2(initial_size2, swap_test_class_type(2));
+  
+  vector_type object1 = initial_value1;
+  vector_type object2 = initial_value2;

  swap_test_class_type::reset();
  
@@ -46,6 +49,9 @@ int test_main(int, char*[])
  BOOST_CHECK_EQUAL(object1.size(),initial_size2);
  BOOST_CHECK_EQUAL(object2.size(),initial_size1);

+  BOOST_CHECK(object1 == initial_value2);
+  BOOST_CHECK(object2 == initial_value1);
+
  BOOST_CHECK_EQUAL(swap_test_class_type::swap_count(),0);
  BOOST_CHECK_EQUAL(swap_test_class_type::copy_count(),0);

--- a/swap/test/swap_arrays.cpp
+++ b/swap/test/swap_arrays.cpp
@@ -11,6 +11,9 @@
 //Put test class in the global namespace
 #include "./swap_test_class.hpp"

+#include <algorithm> //for std::copy and std::equal
+#include <cstddef> //for std::size_t
+
 //Provide swap function in both the namespace of swap_test_class
 //(which is the global namespace), and the std namespace.
 //It's common to provide a swap function for a class in both
@@ -30,29 +33,67 @@ namespace std
  }
 }

-
-int test_main(int, char*[])
+// Tests swapping 1-dimensional arrays.
+void test_swapping_1D_arrays()
 {
-  const std::size_t dimension = 7;
-
+  const std::size_t dimension = 2;
+  const swap_test_class initial_array1[dimension] = { swap_test_class(1), swap_test_class(2) };
+  const swap_test_class initial_array2[dimension] = { swap_test_class(3), swap_test_class(4) };
+  
  swap_test_class array1[dimension];
  swap_test_class array2[dimension];
+
+  std::copy(initial_array1, initial_array1 + dimension, array1);
+  std::copy(initial_array2, initial_array2 + dimension, array2);
+  
+  swap_test_class::reset();
  boost::swap(array1, array2);

+  BOOST_CHECK(std::equal(array1, array1 + dimension, initial_array2));
+  BOOST_CHECK(std::equal(array2, array2 + dimension, initial_array1));
+
  BOOST_CHECK_EQUAL(swap_test_class::swap_count(), dimension);
  BOOST_CHECK_EQUAL(swap_test_class::copy_count(), 0);
+}
+
+
+// Tests swapping 2-dimensional arrays.
+void test_swapping_2D_arrays()
+{
+  const std::size_t first_dimension = 3;
+  const std::size_t second_dimension = 4;
+  const std::size_t number_of_elements = first_dimension * second_dimension;
+
+  swap_test_class array1[first_dimension][second_dimension];
+  swap_test_class array2[first_dimension][second_dimension];
+
+  swap_test_class* const ptr1 = array1[0];
+  swap_test_class* const ptr2 = array2[0];
+
+  for (std::size_t i = 0; i < number_of_elements; ++i)
+  {
+    ptr1[i].set_data( static_cast<int>(i) );
+    ptr2[i].set_data( static_cast<int>(i + number_of_elements) );
+  }

  swap_test_class::reset();
+  boost::swap(array1, array2);

-  const std::size_t firstDimension = 3;
-  const std::size_t secondDimension = 4;
+  for (std::size_t i = 0; i < number_of_elements; ++i)
+  {
+    BOOST_CHECK_EQUAL(ptr1[i].get_data(), static_cast<int>(i + number_of_elements) );
+    BOOST_CHECK_EQUAL(ptr2[i].get_data(), static_cast<int>(i) );
+  }

-  swap_test_class two_d_array1[firstDimension][secondDimension];
-  swap_test_class two_d_array2[firstDimension][secondDimension];
-  boost::swap(two_d_array1, two_d_array2);
-
-  BOOST_CHECK_EQUAL(swap_test_class::swap_count(), firstDimension*secondDimension);
+  BOOST_CHECK_EQUAL(swap_test_class::swap_count(), number_of_elements);
  BOOST_CHECK_EQUAL(swap_test_class::copy_count(), 0);
+}
+
+
+int test_main(int, char*[])
+{
+  test_swapping_1D_arrays();
+  test_swapping_2D_arrays();

  return 0;
 }
--- a/swap/test/swap_test_class.hpp
+++ b/swap/test/swap_test_class.hpp
@@ -12,8 +12,11 @@

 class swap_test_class
 {
+  int m_data;	
 public:
-  swap_test_class()
+  explicit swap_test_class(int arg = 0)
+  :
+  m_data(arg)
  {
    ++constructCount();
  }
@@ -23,24 +26,40 @@ public:
    ++destructCount();
  }

-  swap_test_class(const swap_test_class&)
+  swap_test_class(const swap_test_class& arg)
+  :
+  m_data(arg.m_data)
  {
    ++copyCount();
    ++destructCount();
  }

-  swap_test_class& operator=(const swap_test_class&)
+  swap_test_class& operator=(const swap_test_class& arg)
  {
+    m_data = arg.m_data;
    ++copyCount();
    return *this;
  }

  void swap(swap_test_class& other)
  {
+    const int temp = m_data;
+    m_data = other.m_data;
+    other.m_data = temp;
+
    ++swapCount();
  }

+  int get_data() const
+  {
+    return m_data;
+  }

+  void set_data(int arg)
+  {
+    m_data = arg;
+  }
+  
  static unsigned int swap_count(){ return swapCount(); }
  static unsigned int copy_count(){ return copyCount(); }
  static unsigned int construct_count(){ return constructCount(); }
@@ -81,4 +100,15 @@ private:

 };

+
+inline bool operator==(const swap_test_class & lhs, const swap_test_class & rhs)
+{
+  return lhs.get_data() == rhs.get_data();
+}
+
+inline bool operator!=(const swap_test_class & lhs, const swap_test_class & rhs)
+{
+  return !(lhs == rhs);
+}
+
 #endif
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -1,36 +0,0 @@
-boost_test_run(addressof_test ../addressof_test.cpp)
-boost_test_run(assert_test ../assert_test.cpp)
-boost_test_run(base_from_member_test ../base_from_member_test.cpp)
-boost_test_run(binary_search_test ../binary_search_test.cpp)
-boost_test_run(call_traits_test ../call_traits_test.cpp ARGS -u)
-boost_test_compile_fail(checked_delete_test ../checked_delete_test.cpp)
-boost_test_run(compressed_pair_test 
-  ../compressed_pair_test 
-  DEPENDS boost_test_exec_monitor)
-boost_test_run(current_function_test ../current_function_test.cpp)
-boost_test_run(iterators_test 
-  ../iterators_test.cpp 
-  DEPENDS boost_test_exec_monitor)
-boost_test_run(next_prior_test DEPENDS boost_test_exec_monitor)
-boost_test_compile_fail(noncopyable_test ../noncopyable_test.cpp)
-boost_test_run(numeric_traits_test ../numeric_traits_test.cpp)
-if (${CMAKE_SYSTEM} MATCHES "FreeBSD-.*")
-boost_test_compile_fail("operators_test_compilerbug")
-elseif(${CMAKE_SYSTEM} MATCHES "FreeBSD-.*")
-boost_test_run(operators_test 
-  ../operators_test.cpp
-  DEPENDS boost_test_exec_monitor)
-endif(${CMAKE_SYSTEM} MATCHES "FreeBSD-.*")
-boost_test_compile(ref_ct_test ../ref_ct_test.cpp)
-boost_test_run(ref_test 
-  ../ref_test.cpp
-  DEPENDS boost_test_exec_monitor)
-boost_test_compile(result_of_test)
-boost_test_run(shared_iterator_test ../shared_iterator_test.cpp)
-boost_test_run(value_init_test ../value_init_test.cpp)
-boost_test_compile_fail(value_init_test_fail1 
-  ../value_init_test_fail1.cpp)
-boost_test_compile_fail(value_init_test_fail2
-  ../value_init_test_fail2.cpp)
-boost_test_compile_fail(value_init_test_fail3
-  ../value_init_test_fail3.cpp)
Author	SHA1	Message	Date
Daniel James	79e3887b4e	Branch for adding initializer list support (only in the unreleased gcc 4.4 at the moment). [SVN r48931]	2008-09-23 19:45:43 +00:00
John Maddock	ddd8a58ae0	Fixes #2341 . [SVN r48910]	2008-09-20 15:39:47 +00:00
Matthew Calabrese	28061ba3a8	Removed boost directory binary.hpp. [SVN r48804]	2008-09-17 01:08:03 +00:00
Matthew Calabrese	5d53e3f837	Changed BOOST_BINARY docs. [SVN r48641]	2008-09-06 21:51:53 +00:00
Matthew Calabrese	e86ce1cb1f	Changed wording for BOOST_BINARY docs. [SVN r48640]	2008-09-06 21:49:49 +00:00
Matthew Calabrese	f15c96ffb0	Adding binary literal utility. [SVN r48637]	2008-09-06 21:11:48 +00:00
Douglas Gregor	a487f72329	Fix result_of to work with const-qualified function pointers. Fixes #1310 [SVN r48620]	2008-09-05 19:58:30 +00:00
Emil Dotchevski	9f08ed6de0	minor change in boost/exception.hpp [SVN r48546]	2008-09-02 21:25:47 +00:00
Emil Dotchevski	2077d0dace	simplified further [SVN r48485]	2008-08-31 02:40:42 +00:00
Emil Dotchevski	7f2348269b	Boost Exception now works with BOOST_NO_RTTI and/or BOOST_NO_TYPEID. [SVN r48429]	2008-08-28 23:49:55 +00:00
Niels Dekker	6b6e1c3252	Added value_initialized::swap documentation + test [SVN r48425]	2008-08-28 19:00:20 +00:00
Niels Dekker	55f303baec	Added value_initialized::swap according to ticket #2243 , as agreed with Fernando Cacciola :-) [SVN r48424]	2008-08-28 18:37:45 +00:00
Niels Dekker	d264005c11	Extended swap_arrays test, checking that boost::swap does correctly exchange the values of its arguments. [SVN r48247]	2008-08-20 08:29:54 +00:00
Niels Dekker	2cde009bb1	Added extra checks, checking that boost::swap does correctly exchange the values of its arguments, as I mentioned at "Re: [boost] [swap] Renaming boost_swap_impl::swap_impl and/or its namespace?", http://lists.boost.org/Archives/boost/2008/08/141027.php [SVN r48246]	2008-08-20 08:28:35 +00:00
Niels Dekker	7bfb7c8a61	Added a data member to swap_test_class and made it EqualityComparable, as I mentioned at "Re: [boost] [swap] Renaming boost_swap_impl::swap_impl and/or its namespace?", http://lists.boost.org/Archives/boost/2008/08/141027.php [SVN r48245]	2008-08-20 08:25:23 +00:00
Niels Dekker	5c42397244	Added explanatory comments, requested by Isaac Dupree, "Re: [boost] [swap] Renaming boost_swap_impl::swap_impl and/or its namespace?", http://lists.boost.org/Archives/boost/2008/08/141007.php [SVN r48171]	2008-08-16 08:56:19 +00:00
Daniel James	782c132d99	Fix Windows-1252 dash in UTF-8 document. [SVN r48133]	2008-08-13 22:00:35 +00:00
Daniel Frey	36899afa3f	added/switched "euclidean" spelling [SVN r48025]	2008-08-07 20:47:58 +00:00
				`@@ -1 +0,0 @@`
				`boost_module(utility DEPENDS iterator exception detail )`