[patch] Boost.Parameter should not depend on Boost.Python (upstream bug 3490)

parameter-needs-python-1.40.patch (text/plain), 2.97 KB, created by Sebastian Luther (few) on 2009-11-10 21:07:29 UTC

--- boost/parameter/aux_/maybe.hpp	2008-03-22 21:45:55.000000000 +0000
+++ boost/parameter/aux_/maybe.hpp.new	2009-10-22 03:55:24.000000000 +0000
@@ -2,20 +2,41 @@
 // 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)
 
-#ifndef BOOST_PARAMETER_MAYBE_060211_HPP
-# define BOOST_PARAMETER_MAYBE_060211_HPP
+//
+// 2009.10.21 TDS remove depenency on boost::python::detail::referent_storage
+//
+#ifndef BOOST_PARAMETER_MAYBE_091021_HPP
+# define BOOST_PARAMETER_MAYBE_091021_HPP
 
 # include <boost/mpl/if.hpp>
 # include <boost/mpl/identity.hpp>
 # include <boost/type_traits/is_reference.hpp>
 # include <boost/type_traits/add_reference.hpp>
 # include <boost/optional.hpp>
-# include <boost/python/detail/referent_storage.hpp>
+# include <boost/aligned_storage.hpp>
 # include <boost/type_traits/remove_cv.hpp>
 # include <boost/type_traits/add_const.hpp>
 
 namespace boost { namespace parameter { namespace aux {
 
+template <class T> struct referent_size;
+
+template <class T>
+struct referent_size<T&>
+{
+  BOOST_STATIC_CONSTANT(std::size_t, value = sizeof(T));
+};
+
+// A metafunction returning a POD type which can store U, where T ==
+// U&. If T is not a reference type, returns a POD which can store T.
+template <class T>
+struct referent_storage
+{
+  typedef typename boost::aligned_storage<
+    referent_size<T>::value
+    >::type type;
+};
+
 struct maybe_base {};
 
 template <class T>
@@ -33,8 +54,8 @@
         BOOST_DEDUCED_TYPENAME remove_reference<reference>::type
     >::type non_cv_value;
         
-    explicit maybe(T value)
-      : value(value)
+    explicit maybe(T value_)
+      : value(value_)
       , constructed(false)
     {}
 
@@ -48,28 +69,28 @@
             this->destroy();
     }
 
-    reference construct(reference value) const
+    reference construct(reference value_) const
     {
-        return value;
+        return value_;
     }
 
     template <class U>
-    reference construct2(U const& value) const
+    reference construct2(U const& value_) const
     {
-        new (m_storage.bytes) non_cv_value(value);
+        new (m_storage.address()) non_cv_value(value_);
         constructed = true;
-        return *(non_cv_value*)m_storage.bytes;
+        return *(non_cv_value*)m_storage.address();
     }
 
     template <class U>
-    reference construct(U const& value) const
+    reference construct(U const& value_) const
     {
-        return this->construct2(value);
+        return this->construct2(value_);
     }
 
     void destroy()
     {
-        ((non_cv_value*)m_storage.bytes)->~non_cv_value();
+        ((non_cv_value*)m_storage.address())->~non_cv_value();
     }
 
     typedef reference(maybe<T>::*safe_bool)() const;
@@ -87,7 +108,9 @@
 private:
     boost::optional<T> value;
     mutable bool constructed;
-    mutable typename boost::python::detail::referent_storage<
+
+
+    mutable typename referent_storage<
         reference
     >::type m_storage;
 };