Branch for development of boost.system related changes

[SVN r40931]

include/boost/utility/value_init.hpp

@@ -6,108 +6,161 @@
 //
 // 21 Ago 2002 (Created) Fernando Cacciola
 // 07 Set 2007 (Worked around MSVC++ bug) Fernando Cacciola, Niels Dekker
-// 16 Nov 2007 (Refactoring: removed private base classes) Fernando Cacciola, Niels Dekker
-// 09 Dec 2007 (Worked around various compiler bugs) Fernando Cacciola, Niels Dekker
 //
 #ifndef BOOST_UTILITY_VALUE_INIT_21AGO2002_HPP
 #define BOOST_UTILITY_VALUE_INIT_21AGO2002_HPP
 
-// Note: The implementation of boost::value_initialized had to deal with the
-// fact that various compilers haven't fully implemented value-initialization:
-// Microsoft Feedback ID 100744 - Value-initialization in new-expression
-// Reported by Pavel Kuznetsov (MetaCommunications Engineering), 2005-07-28
-// https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=100744
-// GCC Bug 30111 - Value-initialization of POD base class doesn't initialize members
-// Reported by Jonathan Wakely, 2006-12-07 
-// http://gcc.gnu.org/bugzilla/show_bug.cgi?id=30111
-// GCC Bug 33916 - Default constructor fails to initialize array members
-// Reported by Michael Elizabeth Chastain, 2007-10-26
-// http://gcc.gnu.org/bugzilla/show_bug.cgi?id=33916
-// Borland Report 51854 - Value-initialization: POD struct should be zero-initialized
-// Reported by Niels Dekker (LKEB, Leiden University Medical Center), 2007-11-09
-// http://qc.codegear.com/wc/qcmain.aspx?d=51854
-// The constructor of boost::value_initialized<T> works around these issues, by
-// clearing the bytes of T, before constructing the T object it contains. 
-
-#include <boost/aligned_storage.hpp>
 #include <boost/detail/select_type.hpp>
-#include <boost/detail/workaround.hpp>
 #include <boost/type_traits/cv_traits.hpp>
+#include <boost/detail/workaround.hpp>
+
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500) )
+// Microsoft Visual C++ does not correctly support value initialization, as reported by
+// Pavel Kuznetsov (MetaCommunications Engineering), 7/28/2005, Feedback ID 100744,
+// Feedback Title: Value-initialization in new-expression
+// https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=100744
+// The report was closed at 11/14/2006, and its status was set to "Closed (Won't Fix)".
+// Luckily, even in the presence of this compiler bug, boost::value_initialized will still
+// do its job correctly, when using the following workaround:
+#define BOOST_UTILITY_VALUE_INIT_WORKAROUND
+#endif
+
+#ifdef BOOST_UTILITY_VALUE_INIT_WORKAROUND
+#include <boost/aligned_storage.hpp>
 #include <boost/type_traits/alignment_of.hpp>
 #include <cstring>
 #include <new>
 
-namespace boost {
-
-template<class T>
-class value_initialized
-{
-  private :
-    struct wrapper
-    {
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
-      typename
-#endif 
-      remove_const<T>::type data;
-    };
-
-    mutable
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
-      typename
-#endif
-      ::boost::aligned_storage<sizeof(wrapper), ::boost::alignment_of<wrapper>::value>::type x;
-
-  public :
-
-    value_initialized()
-    {
-      std::memset(&x, 0, sizeof(x));
 #ifdef BOOST_MSVC
 #pragma warning(push)
 #if _MSC_VER >= 1310
-// When using MSVC 7.1 or higher, the following placement new expression may trigger warning C4345:
+// When using MSVC 7.1 or higher, placement new, "new (&x) T()", may trigger warning C4345:
 // "behavior change: an object of POD type constructed with an initializer of the form ()
 // will be default-initialized".  There is no need to worry about this, though.
 #pragma warning(disable: 4345)
 #endif
 #endif
-      new (&x) wrapper();
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-    }
 
-    value_initialized(value_initialized const & arg)
+namespace boost {
+
+namespace vinit_detail {
+
+template<class T>
+class const_T_base
+{
+  protected :
+
+    const_T_base()
     {
-      void const * const ptr = &(arg.x);
-      new (&x) wrapper( *static_cast<wrapper const *>(ptr) );
+      std::memset(&x, 0, sizeof(x));
+      new (&x) T();
     }
 
-    value_initialized & operator=(value_initialized const & arg)
+    ~const_T_base()
     {
-      T & this_data = this->data();
-      T const & arg_data = arg.data();
-      this_data = arg_data;
-      return *this;
+      void const * ptr = &x;
+      static_cast<T*>(ptr)->T::~T();
     }
 
-    ~value_initialized()
+    T & get() const
     {
-      void * const ptr = &x; 
-      static_cast<wrapper *>(ptr)->wrapper::~wrapper();
+      void const * ptr = &x;
+      return *static_cast<T*>(ptr);
     }
 
-    T& data() const
-    {
-      void * const ptr = &x;
-      return static_cast<wrapper *>(ptr)->data;
-    }
-
-    operator T&() const { return this->data(); }
-
+  private :
+    typename ::boost::aligned_storage<sizeof(T), ::boost::alignment_of<T>::value>::type x;
 } ;
 
+template<class T>
+class non_const_T_base
+{
+  protected :
 
+    non_const_T_base()
+    {
+      std::memset(&x, 0, sizeof(x));
+      new (&x) T();
+    }
+
+    ~non_const_T_base()
+    {
+      void * ptr = &x;
+      static_cast<T*>(ptr)->T::~T();
+    }
+
+    T & get() const
+    { 
+      void * ptr = &x;
+      return *static_cast<T*>(ptr);
+    }
+
+  private :
+    mutable typename ::boost::aligned_storage<sizeof(T), ::boost::alignment_of<T>::value>::type x;
+} ;
+
+#ifdef BOOST_MSVC
+// Restores the state of warning C4345.
+#pragma warning(pop)
+#endif
+
+#else
+
+namespace boost {
+
+namespace vinit_detail {
+
+template<class T>
+class const_T_base
+{
+  protected :
+
+   const_T_base() : x() {}
+   T & get() const { return x; }
+
+  private :
+   T x ;
+} ;
+
+template<class T>
+class non_const_T_base
+{
+  protected :
+
+   non_const_T_base() : x() {}
+   T & get() const { return x; }
+
+  private :
+   mutable T x ;
+} ;
+
+#endif
+
+template<class T>
+struct select_base
+{
+  typedef
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+  typename
+#endif 
+    ::boost::detail::if_true< ::boost::is_const<T>::value >
+      ::template then< const_T_base<T>, non_const_T_base<T> >::type type ;
+} ;
+
+} // namespace vinit_detail
+
+template<class T>
+class value_initialized : private vinit_detail::select_base<T>::type
+{
+  public :
+
+    value_initialized() {}
+
+    operator T&() const { return this->get(); }
+
+    T& data() const { return this->get(); }
+
+} ;
 
 template<class T>
 T const& get ( value_initialized<T> const& x )
@@ -124,3 +177,4 @@ T& get ( value_initialized<T>& x )
 
 
 #endif
+

value_init_test.cpp

@@ -8,12 +8,10 @@
 //
 // Initial: 21 Agu 2002
 
-#include <cstring>  // For memcmp.
 #include <iostream>
 #include <string>
 
 #include "boost/utility/value_init.hpp"
-#include <boost/shared_ptr.hpp>
 
 #ifdef __BORLANDC__
 #pragma hdrstop
@@ -64,9 +62,6 @@ struct NonPOD : NonPODBase
 
 //
 // Sample aggregate POD struct type
-// Some compilers do not correctly value-initialize such a struct, for example:
-// Borland C++ Report #51854, "Value-initialization: POD struct should be zero-initialized "
-// http://qc.codegear.com/wc/qcmain.aspx?d=51854
 //
 struct AggregatePODStruct
 {
@@ -78,116 +73,10 @@ struct AggregatePODStruct
 bool operator == ( AggregatePODStruct const& lhs, AggregatePODStruct const& rhs )
 { return lhs.f == rhs.f && lhs.c == rhs.c && lhs.i == rhs.i ; }
 
-//
-// An aggregate struct that contains an std::string and an int.
-// Pavel Kuznetsov (MetaCommunications Engineering) used a struct like
-// this to reproduce the Microsoft Visual C++ compiler bug, reported as
-// Feedback ID 100744, "Value-initialization in new-expression"
-// https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=100744
-//
-struct StringAndInt
-{
-  std::string s;
-  int i;
-};
 
-bool operator == ( StringAndInt const& lhs, StringAndInt const& rhs )
-{ return lhs.s == rhs.s && lhs.i == rhs.i ; }
-
-
-//
-// A struct that has an explicit (user defined) destructor.
-// Some compilers do not correctly value-initialize such a struct, for example:
-// Microsoft Visual C++, Feedback ID 100744, "Value-initialization in new-expression"
-// https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=100744
-//
-struct StructWithDestructor
-{
-  int i;
-  ~StructWithDestructor() {}
-};
-
-bool operator == ( StructWithDestructor const& lhs, StructWithDestructor const& rhs )
-{ return lhs.i == rhs.i ; }
-
-
-//
-// A struct that has a virtual function.
-// Some compilers do not correctly value-initialize such a struct either, for example:
-// Microsoft Visual C++, Feedback ID 100744, "Value-initialization in new-expression"
-// https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=100744
-//
-struct StructWithVirtualFunction
-{
-  int i;
-  virtual void VirtualFunction(); 
-};
-
-void StructWithVirtualFunction::VirtualFunction()
-{
-}
-
-bool operator == ( StructWithVirtualFunction const& lhs, StructWithVirtualFunction const& rhs )
-{ return lhs.i == rhs.i ; }
-
-
-//
-// A struct that is derived from an aggregate POD struct.
-// Some compilers do not correctly value-initialize such a struct, for example:
-// GCC Bugzilla Bug 30111,  "Value-initialization of POD base class doesn't initialize members",
-// reported by Jonathan Wakely, http://gcc.gnu.org/bugzilla/show_bug.cgi?id=30111
-//
-struct DerivedFromAggregatePODStruct : AggregatePODStruct
-{
-  DerivedFromAggregatePODStruct() : AggregatePODStruct() {}
-};
-
-//
-// A struct that wraps an aggregate POD struct as data member.
-//
-struct AggregatePODStructWrapper
-{
-  AggregatePODStructWrapper() : dataMember() {}
-  AggregatePODStruct dataMember;
-};
-
-bool operator == ( AggregatePODStructWrapper const& lhs, AggregatePODStructWrapper const& rhs )
-{ return lhs.dataMember == rhs.dataMember ; }
-
-typedef unsigned char ArrayOfBytes[256];
-
-
-//
-// A struct that allows testing whether the appropriate copy functions are called.
-//
-struct CopyFunctionCallTester
-{
-  bool is_copy_constructed;
-  bool is_assignment_called;
-
-  CopyFunctionCallTester()
-  : is_copy_constructed(false), is_assignment_called(false) {}
-
-  CopyFunctionCallTester(const CopyFunctionCallTester & )
-  : is_copy_constructed(true), is_assignment_called(false) {}
-
-  CopyFunctionCallTester & operator=(const CopyFunctionCallTester & )
-  {
-    is_assignment_called = true ;
-    return *this ;
-  }
-};
-
-
-//
-// This test function tests boost::value_initialized<T> for a specific type T.
-// The first argument (y) is assumed have the value of a value-initialized object.
-// Returns true on success.
-//
 template<class T>
-bool test ( T const& y, T const& z )
+void test ( T const& y, T const& z )
 {
-  const boost::unit_test::counter_t counter_before_test = boost::minimal_test::errors_counter();
   boost::value_initialized<T> x ;
   BOOST_CHECK ( y == x ) ;
   BOOST_CHECK ( y == boost::get(x) ) ;
@@ -202,9 +91,6 @@ bool test ( T const& y, T const& z )
   x_c_ref = z ;
   BOOST_CHECK ( x_c == z ) ;
 
-  boost::shared_ptr<boost::value_initialized<T> > ptr( new boost::value_initialized<T> );
-  BOOST_CHECK ( y == *ptr ) ;
-
 #if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
   boost::value_initialized<T const> cx ;
   BOOST_CHECK ( y == cx ) ;
@@ -214,71 +100,21 @@ bool test ( T const& y, T const& z )
   BOOST_CHECK ( y == cx_c ) ;
   BOOST_CHECK ( y == boost::get(cx_c) ) ;
 #endif
-
-  return boost::minimal_test::errors_counter() == counter_before_test ;
 }
 
 int test_main(int, char **)
 {
-  BOOST_CHECK ( test( 0,1234 ) ) ;
-  BOOST_CHECK ( test( 0.0,12.34 ) ) ;
-  BOOST_CHECK ( test( POD(0,0,0.0), POD('a',1234,56.78) ) ) ;
-  BOOST_CHECK ( test( NonPOD( std::string() ), NonPOD( std::string("something") ) ) ) ;
+  test( 0,1234 ) ;
+  test( 0.0,12.34 ) ;
+  test( POD(0,0,0.0), POD('a',1234,56.78) ) ;
+  test( NonPOD( std::string() ), NonPOD( std::string("something") ) ) ;
 
   NonPOD NonPOD_object( std::string("NonPOD_object") );
-  BOOST_CHECK ( test<NonPOD *>( 0, &NonPOD_object ) ) ;
+  test<NonPOD *>( 0, &NonPOD_object ) ;
 
   AggregatePODStruct zeroInitializedAggregatePODStruct = { 0.0f, '\0', 0 };
   AggregatePODStruct nonZeroInitializedAggregatePODStruct = { 1.25f, 'a', -1 };
-  BOOST_CHECK ( test(zeroInitializedAggregatePODStruct, nonZeroInitializedAggregatePODStruct) );
-
-  StringAndInt stringAndInt0;
-  StringAndInt stringAndInt1;
-  stringAndInt0.i = 0;
-  stringAndInt1.i = 1;
-  stringAndInt1.s = std::string("1");
-  BOOST_CHECK ( test(stringAndInt0, stringAndInt1) );
-
-  StructWithDestructor structWithDestructor0;
-  StructWithDestructor structWithDestructor1;
-  structWithDestructor0.i = 0;
-  structWithDestructor1.i = 1;
-  BOOST_CHECK ( test(structWithDestructor0, structWithDestructor1) );
-
-  StructWithVirtualFunction structWithVirtualFunction0;
-  StructWithVirtualFunction structWithVirtualFunction1;
-  structWithVirtualFunction0.i = 0;
-  structWithVirtualFunction1.i = 1;
-  BOOST_CHECK ( test(structWithVirtualFunction0, structWithVirtualFunction1) );
-
-  DerivedFromAggregatePODStruct derivedFromAggregatePODStruct0;
-  DerivedFromAggregatePODStruct derivedFromAggregatePODStruct1;
-  static_cast<AggregatePODStruct &>(derivedFromAggregatePODStruct0) = zeroInitializedAggregatePODStruct;
-  static_cast<AggregatePODStruct &>(derivedFromAggregatePODStruct1) = nonZeroInitializedAggregatePODStruct;
-  BOOST_CHECK ( test(derivedFromAggregatePODStruct0, derivedFromAggregatePODStruct1) );
-
-  AggregatePODStructWrapper aggregatePODStructWrapper0;
-  AggregatePODStructWrapper aggregatePODStructWrapper1;
-  aggregatePODStructWrapper0.dataMember = zeroInitializedAggregatePODStruct;
-  aggregatePODStructWrapper1.dataMember = nonZeroInitializedAggregatePODStruct;
-  BOOST_CHECK ( test(aggregatePODStructWrapper0, aggregatePODStructWrapper1) );
-
-  ArrayOfBytes zeroInitializedArrayOfBytes = { 0 };
-  boost::value_initialized<ArrayOfBytes> valueInitializedArrayOfBytes;
-  BOOST_CHECK (std::memcmp(get(valueInitializedArrayOfBytes), zeroInitializedArrayOfBytes, sizeof(ArrayOfBytes)) == 0);
-
-  boost::value_initialized<CopyFunctionCallTester> copyFunctionCallTester1;
-  BOOST_CHECK ( ! get(copyFunctionCallTester1).is_copy_constructed);
-  BOOST_CHECK ( ! get(copyFunctionCallTester1).is_assignment_called);
-
-  boost::value_initialized<CopyFunctionCallTester> copyFunctionCallTester2 = boost::value_initialized<CopyFunctionCallTester>(copyFunctionCallTester1);
-  BOOST_CHECK ( get(copyFunctionCallTester2).is_copy_constructed);
-  BOOST_CHECK ( ! get(copyFunctionCallTester2).is_assignment_called);
-
-  boost::value_initialized<CopyFunctionCallTester> copyFunctionCallTester3;
-  copyFunctionCallTester3 = boost::value_initialized<CopyFunctionCallTester>(copyFunctionCallTester1);
-  BOOST_CHECK ( ! get(copyFunctionCallTester3).is_copy_constructed);
-  BOOST_CHECK ( get(copyFunctionCallTester3).is_assignment_called);
+  test(zeroInitializedAggregatePODStruct, nonZeroInitializedAggregatePODStruct);
 
   return 0;
 }
@@ -286,3 +122,7 @@ int test_main(int, char **)
 
 unsigned int expected_failures = 0;
 
+
+
+
+