merged from trunk

[SVN r49607]
merged from trunk
2026-01-21 05:02:17 +00:00 · 2008-11-06 00:15:47 +00:00 · 2008-10-05 01:47:33 +00:00 · 2008-09-08 21:00:49 +00:00 · 2008-08-05 05:39:57 +00:00 · 2008-06-05 05:50:03 +00:00
143 changed files with 1000 additions and 259 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -0,0 +1,64 @@
 if (PYTHON_LIBRARIES)
  include_directories(${PYTHON_INCLUDE_PATH})
  # Determine extra libraries we need to link against to build Python
  # extension modules.
  if(CMAKE_SYSTEM_NAME STREQUAL "SunOS")
    set(PYTHON_LIBRARIES ${PYTHON_LIBRARIES} "dl")
    if(CMAKE_COMPILER_IS_GNUCXX)
      set(PYTHON_LIBRARIES ${PYTHON_LIBRARIES} "rt")
    endif(CMAKE_COMPILER_IS_GNUCXX)
  elseif(CMAKE_SYSTEM_NAME MATCHES ".*BSD")
    set(PYTHON_LIBRARIES ${PYTHON_LIBRARIES} "pthread")
  elseif(CMAKE_SYSTEM_NAME STREQUAL "DragonFly")
    # DragonFly is a variant of FreeBSD
    set(PYTHON_LIBRARIES ${PYTHON_LIBRARIES} "pthread")
  elseif(CMAKE_SYSTEM_NAME STREQUAL "OSF")
    set(PYTHON_LIBRARIES ${PYTHON_LIBRARIES} "pthread" "dl")
    if(CMAKE_COMPILER_IS_GNUCXX)
      set(PYTHON_LIBRARIES ${PYTHON_LIBRARIES} "rt")
    endif(CMAKE_COMPILER_IS_GNUCXX)    
  elseif(CMAKE_SYSTEM_NAME STREQUAL "QNX")
    # No options necessary for QNX
  elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
    # No options necessary for Mac OS X
  elseif(CMAKE_SYSTEM_NAME STREQUAL "HP-UX")
    set(PYTHON_LIBRARIES ${PYTHON_LIBRARIES} "rt")
  elseif(UNIX)
    # Assume -pthread and -ldl on all other variants
    set(PYTHON_LIBRARIES ${PYTHON_LIBRARIES} "pthread" "dl")
    if(CMAKE_COMPILER_IS_GNUCXX)
      set(PYTHON_LIBRARIES ${PYTHON_LIBRARIES} "util")
    endif(CMAKE_COMPILER_IS_GNUCXX)    
  endif(CMAKE_SYSTEM_NAME STREQUAL "SunOS")
  # Macro for building Boost.Python extension modules
  macro(boost_python_extension MODULE_NAME)
    parse_arguments(BPL_EXT 
      "" 
      "" 
      ${ARGN})
    # Create the library target itself
    add_library(${MODULE_NAME} MODULE ${BPL_EXT_DEFAULT_ARGS} )
    # Miscellaneous target properties
    set_target_properties(${MODULE_NAME} PROPERTIES PREFIX "")
    # Link against Boost.Python library
    target_link_libraries(${MODULE_NAME} boost_python-shared)
    # Link against Python libraries
    target_link_libraries(${MODULE_NAME} ${PYTHON_LIBRARIES})
  endmacro(boost_python_extension)
  boost_library_project(
    Python
    SRCDIRS src
    TESTDIRS test
    HEADERS python.hpp python
    MODULARIZED
    DESCRIPTION "A framework for interfacing Python and C++. It allows you to quickly and seamlessly expose C++ classes functions and objects to Python, and vice-versa, using no special tools -- just your C++ compiler."
    AUTHORS "David Abrahams <dave -at- boostpro.com>"
    )
 endif (PYTHON_LIBRARIES)
--- a/doc/PyConDC_2003/bpl.html
+++ b/doc/PyConDC_2003/bpl.html
--- a/doc/PyConDC_2003/bpl.pdf
+++ b/doc/PyConDC_2003/bpl.pdf
--- a/doc/PyConDC_2003/python_cpp_mix.jpg
+++ b/doc/PyConDC_2003/python_cpp_mix.jpg
--- a/doc/PyConDC_2003/python_cpp_mix.png
+++ b/doc/PyConDC_2003/python_cpp_mix.png
--- a/doc/building.html
+++ b/doc/building.html
@@ -9,7 +9,7 @@
 </head>
 <body>
 <div class="document" id="logo-boost-python-build-and-test-howto">
-<h1 class="title"><a class="reference external" href="../index.htm"><img alt="Boost C++ Libraries:" class="boost-logo" src="../../../boost.png" /></a> Boost.Python Build and Test HOWTO</h1>
+<h1 class="title"><a class="reference external" href="../index.html"><img alt="Boost C++ Libraries:" class="boost-logo" src="../../../boost.png" /></a> Boost.Python Build and Test HOWTO</h1>
 <!-- Copyright David Abrahams 2006. Distributed under the Boost -->
 <!-- Software License, Version 1.0. (See accompanying -->
--- a/doc/building.rst
+++ b/doc/building.rst
@@ -11,7 +11,7 @@
   :alt: Boost C++ Libraries:
   :class: boost-logo
-__ ../index.htm
+__ ../index.html
 .. section-numbering::
--- a/doc/internals.html
+++ b/doc/internals.html
--- a/doc/internals.rst
+++ b/doc/internals.rst
--- a/doc/projects.html
+++ b/doc/projects.html
@@ -375,6 +375,27 @@
      application modules, including GUI and post-processing of results.</p>
    </dd>
    <dt><b><a href="http://polybori.sourceforge.net/">PolyBoRi</a></b></dt>
    <dd>
      <p><a href="mailto:brickenstein@mfo.de"
        >Michael Brickenstein</a> writes:</p>
      <blockquote>
        <p>The core of PolyBoRi is a C++ library, which provides
        high-level data types for Boolean polynomials and monomials,
        exponent vectors, as well as for the underlying polynomial
        rings and subsets of the powerset of the Boolean variables. As
        a unique approach, binary decision diagrams are used as
        internal storage type for polynomial structures. On top of
        this C++-library we provide a Python interface. This allows
        parsing of complex polynomial systems, as well as sophisticated
        and extendable strategies for Gr&ouml;bner basis computation.
        Boost.Python has helped us to create this interface in a
        very clean way.</p>
      </blockquote>
    </dd>
    <dt><b><a href="http://www.rationaldiscovery.com">Rational Discovery
    LLC</a></b></dt>
@@ -435,11 +456,11 @@
  </dl>
  <hr>
-  <p>Revised 
+  <p>Revised
  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-   15 July, 2003</p>
+   29 May, 2008</p>
  <p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave
-  Abrahams</a> 2002-2003.</i></p>
+  Abrahams</a> 2002-2008.</i></p>
 </body>
 </html>
--- a/doc/tutorial/doc/html/images/alert.png
+++ b/doc/tutorial/doc/html/images/alert.png
--- a/doc/tutorial/doc/html/images/home.png
+++ b/doc/tutorial/doc/html/images/home.png
--- a/doc/tutorial/doc/html/images/next.png
+++ b/doc/tutorial/doc/html/images/next.png
--- a/doc/tutorial/doc/html/images/note.png
+++ b/doc/tutorial/doc/html/images/note.png
--- a/doc/tutorial/doc/html/images/prev.png
+++ b/doc/tutorial/doc/html/images/prev.png
--- a/doc/tutorial/doc/html/images/tip.png
+++ b/doc/tutorial/doc/html/images/tip.png
--- a/doc/tutorial/doc/html/images/up.png
+++ b/doc/tutorial/doc/html/images/up.png
--- a/doc/tutorial/doc/tutorial.qbk
+++ b/doc/tutorial/doc/tutorial.qbk
@@ -186,6 +186,10 @@ And so on... Finally:
 Or something similar. If all is well, you should now have built the DLLs and
 run the Python program.
 [note Starting from Boost 1.35, bjam erases the generated executables
 (e.g. pyd file) after the test has concluded to conserve disk space.
 To keep bjam from doing that, pass --preserve-test-targets to bjam.]
 [:[*There you go... Have fun!]]
 [endsect]
@@ -1381,9 +1385,9 @@ interpreter. This may be fixed in a future version of boost.python.]
 [section Using the interpreter]
 As you probably already know, objects in Python are reference-counted.
-Naturally, the [^PyObject]s of the Python/C API are also reference-counted.
+Naturally, the [^PyObject]s of the Python\/C API are also reference-counted.
 There is a difference however. While the reference-counting is fully
-automatic in Python, the Python/C API requires you to do it
+automatic in Python, the Python\/C API requires you to do it
 [@http://www.python.org/doc/current/api/refcounts.html by hand]. This is
 messy and especially hard to get right in the presence of C++ exceptions.
 Fortunately Boost.Python provides the [@../../../v2/handle.html handle] and
--- a/doc/tutorial/index.html
+++ b/doc/tutorial/index.html
@@ -11,8 +11,8 @@
    <a href="doc/html/index.html">link</a> &nbsp;<hr>
    <p>© Copyright Beman Dawes, 2001</p>
    <p>Distributed under the Boost Software License, Version 1.0. (See 
-    accompanying file <a href="../../../LICENSE_1_0.txt">
+    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>
  </body>
-</html>
+</html>
--- a/doc/v2/CallPolicies.html
+++ b/doc/v2/CallPolicies.html
@@ -137,7 +137,7 @@
        <td valign="top"><code>P::extract_return_type</code></td>
        <td>A model of <a href=
-          "../../../doc/refmanual/metafunction.html">Metafunction</a>.</td>
+          "../../../mpl/doc/refmanual/metafunction.html">Metafunction</a>.</td>
        <td>An MPL unary <a href=
          "../../../mpl/doc/refmanual/metafunction.html">Metafunction</a> used extract the return type from a given signature. By default it is derived from mpl::front.</td>
--- a/doc/v2/Dereferenceable.html
+++ b/doc/v2/Dereferenceable.html
@@ -4,7 +4,7 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link rel="stylesheet" type="text/css" href=../../../../boost.css>
+<link rel="stylesheet" type="text/css" href="../../../../boost.css">
 <title>Boost.Python - Dereferenceable Concept</title>
 </head>
 <body link="#0000ff" vlink="#800080">
--- a/doc/v2/Extractor.html
+++ b/doc/v2/Extractor.html
@@ -4,7 +4,7 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link rel="stylesheet" type="text/css" href=../../../../boost.css>
+<link rel="stylesheet" type="text/css" href="../../../../boost.css">
 <title>Boost.Python - Extractor Concept</title>
 </head>
 <body link="#0000ff" vlink="#800080">
--- a/doc/v2/HolderGenerator.html
+++ b/doc/v2/HolderGenerator.html
@@ -4,7 +4,7 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link rel="stylesheet" type="text/css" href=../../../../boost.css>
+<link rel="stylesheet" type="text/css" href="../../../../boost.css">
 <title>Boost.Python - Holder Concept</title>
 </head>
 <body link="#0000ff" vlink="#800080">
--- a/doc/v2/instance_holder.html
+++ b/doc/v2/instance_holder.html
--- a/doc/v2/lvalue_from_pytype.html
+++ b/doc/v2/lvalue_from_pytype.html
--- a/doc/v2/object.html
+++ b/doc/v2/object.html
@@ -74,6 +74,32 @@
            </dl>
          </dd>
          <dt><a href="#const_objattribute_policies-spec">Class
          <code>const_objattribute_policies</code></a></dt>
          <dd>
            <dl class="page-index">
              <dt><a href="#const_objattribute_policies-spec-synopsis">Class
              <code>const_objattribute_policies</code> synopsis</a></dt>
              <dt><a href="#const_objattribute_policies-spec-statics">Class
              <code>const_objattribute_policies</code> static functions</a></dt>
            </dl>
          </dd>
          <dt><a href="#objattribute_policies-spec">Class
          <code>objattribute_policies</code></a></dt>
          <dd>
            <dl class="page-index">
              <dt><a href="#objattribute_policies-spec-synopsis">Class
              <code>objattribute_policies</code> synopsis</a></dt>
              <dt><a href="#objattribute_policies-spec-statics">Class
              <code>objattribute_policies</code> static functions</a></dt>
            </dl>
          </dd>
          <dt><a href="#const_item_policies-spec">Class
          <code>const_item_policies</code></a></dt>
@@ -328,6 +354,102 @@ static void del(object const&amp;target, char const* key);
    <!-- end -->
    <!-- begin -->
    <h3><a name="const_objattribute_policies-spec"></a>Class
    <code>const_objattribute_policies</code></h3>
    <p>The policies which are used for proxies representing an attribute
    access to a <code>const&nbsp;object</code> when the attribute name is
    given as a <code>const&nbsp;object</code>.</p>
    <h4><a name="const_objattribute_policies-spec-synopsis"></a>Class
    <code>const_objattribute_policies</code> synopsis</h4>
 <pre>
 namespace boost { namespace python { namespace api
 {
  struct const_objattribute_policies
  {
      typedef object const& key_type;
      static object get(object const&amp; target, object const& key);
  };
 }}}
 </pre>
    <h4><a name="const_objattribute_policies-spec-statics"></a>Class
    <code>const_objattribute_policies</code> static functions</h4>
 <pre>
 static object get(object const&amp; target, object const& key);
 </pre>
    <dl class="function-semantics">
      <dt><b>Requires:</b> <code>key</code> is an <code>object</code>
      holding a string.</dt>
      <dt><b>Effects:</b> accesses the attribute of <code>target</code> named
      by <code>key</code>.</dt>
      <dt><b>Returns:</b> An <code>object</code> managing the result of the
      attribute access.</dt>
      <dt><b>Throws:</b> <code><a href=
      "errors.html#error_already_set-spec">error_already_set</a></code> if a
      Python exception is raised.</dt>
    </dl>
    <h3><a name="objattribute_policies-spec"></a>Class
    <code>objattribute_policies</code></h3>
    <p>The policies which are used for proxies representing an attribute
    access to a mutable <code>object</code> when the attribute name is
    given as a <code>const&nbsp;object</code>.</p>
    <h4><a name="objattribute_policies-spec-synopsis"></a>Class
    <code>objattribute_policies</code> synopsis</h4>
 <pre>
 namespace boost { namespace python { namespace api
 {
  struct objattribute_policies : const_objattribute_policies
  {
      static object const&amp; set(object const&amp; target, object const& key, object const&amp; value);
      static void del(object const&amp;target, object const& key);
  };
 }}}
 </pre>
    <h4><a name="objattribute_policies-spec-statics"></a>Class
    <code>objattribute_policies</code> static functions</h4>
 <pre>
 static object const&amp; set(object const&amp; target, object const& key, object const&amp; value);
 </pre>
    <dl class="function-semantics">
      <dt><b>Requires:</b> <code>key</code> is an <code>object</code>
      holding a string.</dt>
      <dt><b>Effects:</b> sets the attribute of <code>target</code> named by
      <code>key</code> to <code>value</code>.</dt>
      <dt><b>Throws:</b> <code><a href=
      "errors.html#error_already_set-spec">error_already_set</a></code> if a
      Python exception is raised.</dt>
    </dl>
 <pre>
 static void del(object const&amp;target, object const& key);
 </pre>
    <dl class="function-semantics">
      <dt><b>Requires:</b> <code>key</code> is an <code>object</code>
      holding a string.</dt>
      <dt><b>Effects:</b> deletes the attribute of <code>target</code> named
      by <code>key</code>.</dt>
      <dt><b>Throws:</b> <code><a href=
      "errors.html#error_already_set-spec">error_already_set</a></code> if a
      Python exception is raised.</dt>
    </dl>
    <!-- end -->
    <!-- begin -->
    <h3><a name="const_item_policies-spec"></a>Class
    <code>const_item_policies</code></h3>
@@ -533,6 +655,11 @@ namespace boost { namespace python { namespace api
      template &lt;class A0, class A1,...class An&gt;
      object operator()(A0 const&amp;, A1 const&amp;,...An const&amp;) const;
      detail::args_proxy operator* () const; 
      object operator()(detail::args_proxy const &amp;args) const; 
      object operator()(detail::args_proxy const &amp;args, 
                        detail::kwds_proxy const &amp;kwds) const; 
      // truth value testing
      //
      typedef unspecified bool_type;
@@ -542,6 +669,8 @@ namespace boost { namespace python { namespace api
      //
      proxy&lt;const_object_attribute&gt; attr(char const*) const;
      proxy&lt;object_attribute&gt; attr(char const*);
      proxy&lt;const_object_objattribute&gt; attr(object const&) const;
      proxy&lt;object_objattribute&gt; attr(object const&);
      // item access
      //
@@ -580,6 +709,25 @@ object operator()(A0 const&amp; a1, A1 const&amp; a2,...An const&amp; aN) const;
      call&lt;object&gt;(object(*static_cast&lt;U*&gt;(this)).ptr(), a1,
      a2,...aN)</dt>
    </dl>
 <pre>
 object operator()(detail::args_proxy const &amp;args) const; 
 </pre>
 <dl class="function-semantics">
  <dt><b>Effects:</b>
  call object with arguments given by the tuple <varname>args</varname></dt>
 </dl>
 <pre>
 object operator()(detail::args_proxy const &amp;args, 
                  detail::kwds_proxy const &amp;kwds) const; 
 </pre>
 <dl class="function-semantics">
  <dt><b>Effects:</b>
  call object with arguments given by the tuple <varname>args</varname>, and named
  arguments given by the dictionary <varname>kwds</varname></dt>
 </dl>
 <pre>
 operator bool_type() const;
 </pre>
@@ -608,6 +756,21 @@ proxy&lt;object_attribute&gt; attr(char const* name);
      <code>name</code> as its key.</dt>
    </dl>
 <pre>
 proxy&lt;const_object_objattribute&gt; attr(const object& name) const;
 proxy&lt;object_objattribute&gt; attr(const object& name);
 </pre>
    <dl class="function-semantics">
      <dt><b>Requires:</b> name is a <code>object</code> holding a string.</dt>
      <dt><b>Effects:</b> accesses the named attribute of
      <code>*this</code>.</dt>
      <dt><b>Returns:</b> a proxy object which binds
      <code>object(*static_cast&lt;U*&gt;(this))</code> as its target, and
      <code>name</code> as its key.</dt>
    </dl>
 <pre>
 template &lt;class T&gt;
 proxy&lt;const_object_item&gt; operator[](T const&amp; key) const;
 template &lt;class T&gt;
@@ -938,11 +1101,11 @@ object sum_items(object seq)
 </pre>
    <p>Revised 
    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-  13 January, 2006
+  27 May, 2008
  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
    </p>
    <p><i>&copy; Copyright <a href=
-    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2006.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2008.</i></p>
  </body>
 </html>
--- a/doc/v2/operators.html
+++ b/doc/v2/operators.html
--- a/doc/v2/pickle.html
+++ b/doc/v2/pickle.html
@@ -1,112 +1,93 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0//EN"
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
-"http://www.w3.org/TR/REC-html40/strict.dtd">
+    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<title>Boost.Python Pickle Support</title>
+<html xmlns="http://www.w3.org/1999/xhtml">
 <head>
  <title>Boost.Python Pickle Support</title>
 </head>
-<div>
+<body>
  <div>
    <img src="../../../../boost.png" alt="boost.png (6897 bytes)" align=
    "center" width="277" height="86" />
    <hr />
-<img src="../../../../boost.png"
+    <h1>Boost.Python Pickle Support</h1>Pickle is a Python module for object
-     alt="boost.png (6897 bytes)"
+    serialization, also known as persistence, marshalling, or flattening.
     align="center"
     width="277" height="86">
-<hr>
+    <p>It is often necessary to save and restore the contents of an object to
-<h1>Boost.Python Pickle Support</h1>
+    a file. One approach to this problem is to write a pair of functions that
    read and write data from a file in a special format. A powerful
    alternative approach is to use Python's pickle module. Exploiting
    Python's ability for introspection, the pickle module recursively
    converts nearly arbitrary Python objects into a stream of bytes that can
    be written to a file.</p>
-Pickle is a Python module for object serialization, also known
+    <p>The Boost Python Library supports the pickle module through the
-as persistence, marshalling, or flattening.
+    interface as described in detail in the <a href=
    "http://www.python.org/doc/current/lib/module-pickle.html">Python Library
    Reference for pickle.</a> This interface involves the special methods
    <tt>__getinitargs__</tt>, <tt>__getstate__</tt> and <tt>__setstate__</tt>
    as described in the following. Note that Boost.Python is also fully
    compatible with Python's cPickle module.</p>
    <hr />
-<p>
+    <h2>The Boost.Python Pickle Interface</h2>At the user level, the
-It is often necessary to save and restore the contents of an object to
+    Boost.Python pickle interface involves three special methods:
 a file. One approach to this problem is to write a pair of functions
 that read and write data from a file in a special format. A powerful
 alternative approach is to use Python's pickle module. Exploiting
 Python's ability for introspection, the pickle module recursively
 converts nearly arbitrary Python objects into a stream of bytes that
 can be written to a file.
-<p>
+    <dl>
-The Boost Python Library supports the pickle module
+      <dt><strong><tt>__getinitargs__</tt></strong></dt>
 through the interface as described in detail in the
 <a href="http://www.python.org/doc/current/lib/module-pickle.html"
 >Python Library Reference for pickle.</a> This interface
 involves the special methods <tt>__getinitargs__</tt>,
 <tt>__getstate__</tt> and <tt>__setstate__</tt> as described
 in the following. Note that Boost.Python is also fully compatible
 with Python's cPickle module.
-<hr>
+      <dd>
-<h2>The Boost.Python Pickle Interface</h2>
+        When an instance of a Boost.Python extension class is pickled, the
        pickler tests if the instance has a <tt>__getinitargs__</tt> method.
        This method must return a Python tuple (it is most convenient to use
        a boost::python::tuple). When the instance is restored by the
        unpickler, the contents of this tuple are used as the arguments for
        the class constructor.
-At the user level, the Boost.Python pickle interface involves three special
+        <p>If <tt>__getinitargs__</tt> is not defined, <tt>pickle.load</tt>
-methods:
+        will call the constructor (<tt>__init__</tt>) without arguments;
        i.e., the object must be default-constructible.</p>
      </dd>
-<dl>
+      <dt><strong><tt>__getstate__</tt></strong></dt>
 <dt>
 <strong><tt>__getinitargs__</tt></strong>
 <dd>
  When an instance of a Boost.Python extension class is pickled, the
  pickler tests if the instance has a <tt>__getinitargs__</tt> method.
  This method must return a Python tuple (it is most convenient to use
  a boost::python::tuple). When the instance is restored by the
  unpickler, the contents of this tuple are used as the arguments for
  the class constructor.
-  <p>
+      <dd>When an instance of a Boost.Python extension class is pickled, the
-  If <tt>__getinitargs__</tt> is not defined, <tt>pickle.load</tt>
+      pickler tests if the instance has a <tt>__getstate__</tt> method. This
-  will call the constructor (<tt>__init__</tt>) without arguments;
+      method should return a Python object representing the state of the
-  i.e., the object must be default-constructible.
+      instance.</dd>
-<p>
+      <dt><strong><tt>__setstate__</tt></strong></dt>
 <dt>
 <strong><tt>__getstate__</tt></strong>
-<dd>
+      <dd>When an instance of a Boost.Python extension class is restored by
-  When an instance of a Boost.Python extension class is pickled, the
+      the unpickler (<tt>pickle.load</tt>), it is first constructed using the
-  pickler tests if the instance has a <tt>__getstate__</tt> method.
+      result of <tt>__getinitargs__</tt> as arguments (see above).
-  This method should return a Python object representing the state of
+      Subsequently the unpickler tests if the new instance has a
-  the instance.
+      <tt>__setstate__</tt> method. If so, this method is called with the
      result of <tt>__getstate__</tt> (a Python object) as the argument.</dd>
    </dl>The three special methods described above may be <tt>.def()</tt>'ed
    individually by the user. However, Boost.Python provides an easy to use
    high-level interface via the
    <strong><tt>boost::python::pickle_suite</tt></strong> class that also
    enforces consistency: <tt>__getstate__</tt> and <tt>__setstate__</tt>
    must be defined as pairs. Use of this interface is demonstrated by the
    following examples.
    <hr />
-<p>
+    <h2>Examples</h2>There are three files in <tt>boost/libs/python/test</tt>
-<dt>
+    that show how to provide pickle support.
-<strong><tt>__setstate__</tt></strong>
+    <hr />
-<dd>
+    <h3><a href="../../test/pickle1.cpp"><tt>pickle1.cpp</tt></a></h3>The C++
-  When an instance of a Boost.Python extension class is restored by the
+    class in this example can be fully restored by passing the appropriate
-  unpickler (<tt>pickle.load</tt>), it is first constructed using the
+    argument to the constructor. Therefore it is sufficient to define the
-  result of <tt>__getinitargs__</tt> as arguments (see above). Subsequently
+    pickle interface method <tt>__getinitargs__</tt>. This is done in the
-  the unpickler tests if the new instance has a <tt>__setstate__</tt>
+    following way:
  method. If so, this method is called with the result of
  <tt>__getstate__</tt> (a Python object) as the argument.
-</dl>
+    <ul>
-
+      <li>1. Definition of the C++ pickle function:
-The three special methods described above may be <tt>.def()</tt>'ed
+        <pre>
 individually by the user. However, Boost.Python provides an easy to use
 high-level interface via the
 <strong><tt>boost::python::pickle_suite</tt></strong> class that also
 enforces consistency: <tt>__getstate__</tt> and <tt>__setstate__</tt>
 must be defined as pairs. Use of this interface is demonstrated by the
 following examples.
 <hr>
 <h2>Examples</h2>
 There are three files in 
 <tt>boost/libs/python/test</tt> that show how to
 provide pickle support.
 <hr>
 <h3><a href="../../test/pickle1.cpp"><tt>pickle1.cpp</tt></a></h3>
    The C++ class in this example can be fully restored by passing the
    appropriate argument to the constructor. Therefore it is sufficient
    to define the pickle interface method <tt>__getinitargs__</tt>.
    This is done in the following way:
 <ul>
 <li>1. Definition of the C++ pickle function:
 <pre>
  struct world_pickle_suite : boost::python::pickle_suite
  {
    static
@@ -117,26 +98,28 @@ provide pickle support.
    }
  };
 </pre>
-<li>2. Establishing the Python binding:
+      </li>
-<pre>
+
      <li>2. Establishing the Python binding:
        <pre>
  class_&lt;world&gt;("world", args&lt;const std::string&amp;&gt;())
      // ...
      .def_pickle(world_pickle_suite())
      // ...
 </pre>
-</ul>
+      </li>
    </ul>
    <hr />
-<hr>
+    <h3><a href="../../test/pickle2.cpp"><tt>pickle2.cpp</tt></a></h3>The C++
-<h3><a href="../../test/pickle2.cpp"><tt>pickle2.cpp</tt></a></h3>
+    class in this example contains member data that cannot be restored by any
    of the constructors. Therefore it is necessary to provide the
    <tt>__getstate__</tt>/<tt>__setstate__</tt> pair of pickle interface
    methods:
-    The C++ class in this example contains member data that cannot be
+    <ul>
-    restored by any of the constructors. Therefore it is necessary to
+      <li>1. Definition of the C++ pickle functions:
-    provide the <tt>__getstate__</tt>/<tt>__setstate__</tt> pair of
+        <pre>
    pickle interface methods:
 <ul>
 <li>1. Definition of the C++ pickle functions:
 <pre>
  struct world_pickle_suite : boost::python::pickle_suite
  {
    static
@@ -161,92 +144,76 @@ provide pickle support.
    }
  };
 </pre>
-<li>2. Establishing the Python bindings for the entire suite:
+      </li>
-<pre>
+
      <li>2. Establishing the Python bindings for the entire suite:
        <pre>
  class_&lt;world&gt;("world", args&lt;const std::string&amp;&gt;())
      // ...
      .def_pickle(world_pickle_suite())
      // ...
 </pre>
-</ul>
+      </li>
    </ul>
-    <p>
+    <p>For simplicity, the <tt>__dict__</tt> is not included in the result of
-    For simplicity, the <tt>__dict__</tt> is not included in the result
+    <tt>__getstate__</tt>. This is not generally recommended, but a valid
-    of <tt>__getstate__</tt>. This is not generally recommended, but a
+    approach if it is anticipated that the object's <tt>__dict__</tt> will
-    valid approach if it is anticipated that the object's
+    always be empty. Note that the safety guard described below will catch
-    <tt>__dict__</tt> will always be empty. Note that the safety guard
+    the cases where this assumption is violated.</p>
-    described below will catch the cases where this assumption is violated.
+    <hr />
-<hr>
+    <h3><a href="../../test/pickle3.cpp"><tt>pickle3.cpp</tt></a></h3>This
-<h3><a href="../../test/pickle3.cpp"><tt>pickle3.cpp</tt></a></h3>
+    example is similar to <a href=
    "../../test/pickle2.cpp"><tt>pickle2.cpp</tt></a>. However, the object's
    <tt>__dict__</tt> is included in the result of <tt>__getstate__</tt>.
    This requires a little more code but is unavoidable if the object's
    <tt>__dict__</tt> is not always empty.
    <hr />
-    This example is similar to <a
+    <h2>Pitfall and Safety Guard</h2>The pickle protocol described above has
-    href="../../test/pickle2.cpp"><tt>pickle2.cpp</tt></a>. However, the
+    an important pitfall that the end user of a Boost.Python extension module
-    object's <tt>__dict__</tt> is included in the result of
+    might not be aware of:
    <tt>__getstate__</tt>.  This requires a little more code but is
    unavoidable if the object's <tt>__dict__</tt> is not always empty.
-<hr>
+    <p><strong><tt>__getstate__</tt> is defined and the instance's
-<h2>Pitfall and Safety Guard</h2>
+    <tt>__dict__</tt> is not empty.</strong></p>
-The pickle protocol described above has an important pitfall that the
+    <p>The author of a Boost.Python extension class might provide a
-end user of a Boost.Python extension module might not be aware of:
+    <tt>__getstate__</tt> method without considering the possibilities
-<p>
+    that:</p>
 <strong>
 <tt>__getstate__</tt> is defined and the instance's <tt>__dict__</tt>
 is not empty.
 </strong>
 <p>
-  The author of a Boost.Python extension class might provide a
+    <ul>
-  <tt>__getstate__</tt> method without considering the possibilities
+      <li>his class is used in Python as a base class. Most likely the
-  that:
+      <tt>__dict__</tt> of instances of the derived class needs to be pickled
      in order to restore the instances correctly.</li>
-  <p>
+      <li>the user adds items to the instance's <tt>__dict__</tt> directly.
-  <ul>
+      Again, the <tt>__dict__</tt> of the instance then needs to be
-  <li>
+      pickled.</li>
-    his class is used in Python as a base class. Most likely the
+    </ul>
    <tt>__dict__</tt> of instances of the derived class needs to be
    pickled in order to restore the instances correctly.
-  <p>
+    <p>To alert the user to this highly unobvious problem, a safety guard is
-  <li>
+    provided. If <tt>__getstate__</tt> is defined and the instance's
-    the user adds items to the instance's <tt>__dict__</tt> directly.
+    <tt>__dict__</tt> is not empty, Boost.Python tests if the class has an
-    Again, the <tt>__dict__</tt> of the instance then needs to be
+    attribute <tt>__getstate_manages_dict__</tt>. An exception is raised if
-    pickled.
+    this attribute is not defined:</p>
-
+    <pre>
  </ul>
  <p>
  To alert the user to this highly unobvious problem, a safety guard is
  provided. If <tt>__getstate__</tt> is defined and the instance's
  <tt>__dict__</tt> is not empty, Boost.Python tests if the class has
  an attribute <tt>__getstate_manages_dict__</tt>. An exception is
  raised if this attribute is not defined:
 <pre>
    RuntimeError: Incomplete pickle support (__getstate_manages_dict__ not set)
-</pre>
+</pre>To resolve this problem, it should first be established that the <tt>
-
+    __getstate__</tt> and <tt>__setstate__</tt> methods manage the
-  To resolve this problem, it should first be established that the
+    instances's <tt>__dict__</tt> correctly. Note that this can be done
-  <tt>__getstate__</tt> and <tt>__setstate__</tt> methods manage the
+    either at the C++ or the Python level. Finally, the safety guard should
-  instances's <tt>__dict__</tt> correctly. Note that this can be done
+    intentionally be overridden. E.g. in C++ (from <a href=
-  either at the C++ or the Python level. Finally, the safety guard
+    "../../test/pickle3.cpp"><tt>pickle3.cpp</tt></a>):
-  should intentionally be overridden. E.g. in C++ (from
+    <pre>
  <a href="../../test/pickle3.cpp"><tt>pickle3.cpp</tt></a>):
 <pre>
  struct world_pickle_suite : boost::python::pickle_suite
  {
    // ...
    static bool getstate_manages_dict() { return true; }
  };
-</pre>
+</pre>Alternatively in Python:
-
+    <pre>
  Alternatively in Python:
 <pre>
    import your_bpl_module
    class your_class(your_bpl_module.your_class):
      __getstate_manages_dict__ = 1
@@ -255,54 +222,41 @@ is not empty.
      def __setstate__(self, state):
        # your code here
 </pre>
    <hr />
-<hr>
+    <h2>Practical Advice</h2>
 <h2>Practical Advice</h2>
-<ul>
+    <ul>
-<li>
+      <li>In Boost.Python extension modules with many extension classes,
-  In Boost.Python extension modules with many extension classes,
+      providing complete pickle support for all classes would be a
-  providing complete pickle support for all classes would be a
+      significant overhead. In general complete pickle support should only be
-  significant overhead. In general complete pickle support should
+      implemented for extension classes that will eventually be pickled.</li>
  only be implemented for extension classes that will eventually
  be pickled.
-<p>
+      <li>Avoid using <tt>__getstate__</tt> if the instance can also be
-<li>
+      reconstructed by way of <tt>__getinitargs__</tt>. This automatically
-  Avoid using <tt>__getstate__</tt> if the instance can also be
+      avoids the pitfall described above.</li>
  reconstructed by way of <tt>__getinitargs__</tt>. This automatically
  avoids the pitfall described above.
-<p>
+      <li>If <tt>__getstate__</tt> is required, include the instance's
-<li>
+      <tt>__dict__</tt> in the Python object that is returned.</li>
-  If <tt>__getstate__</tt> is required, include the instance's
+    </ul>
-  <tt>__dict__</tt> in the Python object that is returned.
+    <hr />
-</ul>
+    <h2>Light-weight alternative: pickle support implemented in Python</h2>
-<hr>
+    <h3><a href="../../test/pickle4.cpp"><tt>pickle4.cpp</tt></a></h3>The
-<h2>Light-weight alternative: pickle support implemented in Python</h2>
+    <tt>pickle4.cpp</tt> example demonstrates an alternative technique for
-
+    implementing pickle support. First we direct Boost.Python via the
-<h3><a href="../../test/pickle4.cpp"><tt>pickle4.cpp</tt></a></h3>
+    <tt>class_::enable_pickling()</tt> member function to define only the
-
+    basic attributes required for pickling:
-The <tt>pickle4.cpp</tt> example demonstrates an alternative technique
+    <pre>
 for implementing pickle support. First we direct Boost.Python via
 the <tt>class_::enable_pickling()</tt> member function to define only
 the basic attributes required for pickling:
 <pre>
  class_&lt;world&gt;("world", args&lt;const std::string&amp;&gt;())
      // ...
      .enable_pickling()
      // ...
-</pre>
+</pre>This enables the standard Python pickle interface as described in the
-
+Python documentation. By "injecting" a <tt>__getinitargs__</tt> method into
-This enables the standard Python pickle interface as described
+the definition of the wrapped class we make all instances pickleable:
-in the Python documentation. By &quot;injecting&quot; a
+    <pre>
 <tt>__getinitargs__</tt> method into the definition of the wrapped
 class we make all instances pickleable:
 <pre>
  # import the wrapped world class
  from pickle4_ext import world
@@ -312,18 +266,15 @@ class we make all instances pickleable:
  # now inject __getinitargs__ (Python is a dynamic language!)
  world.__getinitargs__ = world_getinitargs
-</pre>
+</pre>See also the <a href=
 "../tutorial/doc/html/python/techniques.html#python.extending_wrapped_objects_in_python">
    tutorial section</a> on injecting additional methods from Python.
    <hr />
    © Copyright Ralf W. Grosse-Kunstleve 2001-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)
-See also the
+    <p>Updated: Feb 2004.</p>
-<a href="../tutorial/doc/html/python/techniques.html#python.extending_wrapped_objects_in_python"
+  </div>
->tutorial section</a> on injecting additional methods from Python.
+</body>
-
+</html>
 <hr>
 &copy; Copyright Ralf W. Grosse-Kunstleve 2001-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)
 <p>
 Updated: Feb 2004.
 </div>
--- a/doc/v2/raw_function.html
+++ b/doc/v2/raw_function.html
--- a/doc/v2/return_arg.html
+++ b/doc/v2/return_arg.html
--- a/doc/v2/stl_iterator.html
+++ b/doc/v2/stl_iterator.html
--- a/doc/v2/type_id.html
+++ b/doc/v2/type_id.html
--- a/doc/v2/wrapper.html
+++ b/doc/v2/wrapper.html
--- a/example/Jamroot
+++ b/example/Jamroot
--- a/example/boost-build.jam
+++ b/example/boost-build.jam
--- a/example/quickstart/Jamroot
+++ b/example/quickstart/Jamroot
--- a/example/tutorial/Jamroot
+++ b/example/tutorial/Jamroot
--- a/include/boost/python/arg_from_python.hpp
+++ b/include/boost/python/arg_from_python.hpp
--- a/include/boost/python/base_type_traits.hpp
+++ b/include/boost/python/base_type_traits.hpp
--- a/include/boost/python/borrowed.hpp
+++ b/include/boost/python/borrowed.hpp
--- a/include/boost/python/call.hpp
+++ b/include/boost/python/call.hpp
@@ -38,7 +38,10 @@ namespace boost { namespace python {
 # endif // CALL_DWA2002411_HPP
-#elif BOOST_PP_ITERATION_DEPTH() == 1
+// For gcc 4.4 compatability, we must include the
 // BOOST_PP_ITERATION_DEPTH test inside an #else clause.
 #else // BOOST_PP_IS_ITERATING
 #if BOOST_PP_ITERATION_DEPTH() == 1
 # if !(BOOST_WORKAROUND(__MWERKS__, > 0x3100)                      \
        && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3201)))
 #  line BOOST_PP_LINE(__LINE__, call.hpp)
@@ -76,4 +79,5 @@ call(PyObject* callable
 # undef N
 #endif // BOOST_PP_ITERATION_DEPTH()
 #endif
--- a/include/boost/python/call_method.hpp
+++ b/include/boost/python/call_method.hpp
@@ -37,7 +37,10 @@ namespace boost { namespace python {
 # endif // CALL_METHOD_DWA2002411_HPP
-#elif BOOST_PP_ITERATION_DEPTH() == 1
+// For gcc 4.4 compatability, we must include the
 // BOOST_PP_ITERATION_DEPTH test inside an #else clause.
 #else // BOOST_PP_IS_ITERATING
 #if BOOST_PP_ITERATION_DEPTH() == 1
 # if !(BOOST_WORKAROUND(__MWERKS__, > 0x3100)                      \
        && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3201)))
 #  line BOOST_PP_LINE(__LINE__, call_method.hpp)
@@ -76,4 +79,5 @@ call_method(PyObject* self, char const* name
 # undef N
 #endif // BOOST_PP_ITERATION_DEPTH()
 #endif // BOOST_PP_IS_ITERATING
--- a/include/boost/python/cast.hpp
+++ b/include/boost/python/cast.hpp
--- a/include/boost/python/converter/arg_from_python.hpp
+++ b/include/boost/python/converter/arg_from_python.hpp
--- a/include/boost/python/converter/arg_to_python.hpp
+++ b/include/boost/python/converter/arg_to_python.hpp
--- a/include/boost/python/converter/arg_to_python_base.hpp
+++ b/include/boost/python/converter/arg_to_python_base.hpp
--- a/include/boost/python/converter/context_result_converter.hpp
+++ b/include/boost/python/converter/context_result_converter.hpp
--- a/include/boost/python/converter/object_manager.hpp
+++ b/include/boost/python/converter/object_manager.hpp
--- a/include/boost/python/converter/pytype_function.hpp
+++ b/include/boost/python/converter/pytype_function.hpp
--- a/include/boost/python/converter/return_from_python.hpp
+++ b/include/boost/python/converter/return_from_python.hpp
--- a/include/boost/python/def_visitor.hpp
+++ b/include/boost/python/def_visitor.hpp
--- a/include/boost/python/detail/borrowed_ptr.hpp
+++ b/include/boost/python/detail/borrowed_ptr.hpp
--- a/include/boost/python/detail/convertible.hpp
+++ b/include/boost/python/detail/convertible.hpp
--- a/include/boost/python/detail/copy_ctor_mutates_rhs.hpp
+++ b/include/boost/python/detail/copy_ctor_mutates_rhs.hpp
--- a/include/boost/python/detail/decorated_type_id.hpp
+++ b/include/boost/python/detail/decorated_type_id.hpp
--- a/include/boost/python/detail/def_helper_fwd.hpp
+++ b/include/boost/python/detail/def_helper_fwd.hpp
--- a/include/boost/python/detail/enable_if.hpp
+++ b/include/boost/python/detail/enable_if.hpp
--- a/include/boost/python/detail/force_instantiate.hpp
+++ b/include/boost/python/detail/force_instantiate.hpp
--- a/include/boost/python/detail/is_shared_ptr.hpp
+++ b/include/boost/python/detail/is_shared_ptr.hpp
--- a/include/boost/python/detail/is_wrapper.hpp
+++ b/include/boost/python/detail/is_wrapper.hpp
--- a/include/boost/python/detail/nullary_function_adaptor.hpp
+++ b/include/boost/python/detail/nullary_function_adaptor.hpp
--- a/include/boost/python/detail/operator_id.hpp
+++ b/include/boost/python/detail/operator_id.hpp
--- a/include/boost/python/detail/prefix.hpp
+++ b/include/boost/python/detail/prefix.hpp
--- a/include/boost/python/detail/python_type.hpp
+++ b/include/boost/python/detail/python_type.hpp
--- a/include/boost/python/detail/result.hpp
+++ b/include/boost/python/detail/result.hpp
@@ -86,7 +86,10 @@ result(X const&, short = 0) { return 0; }
 # endif // RESULT_DWA2002521_HPP
 /* --------------- function pointers --------------- */
-#elif BOOST_PP_ITERATION_DEPTH() == 1 && BOOST_PP_ITERATION_FLAGS() == BOOST_PYTHON_FUNCTION_POINTER
+// For gcc 4.4 compatability, we must include the
 // BOOST_PP_ITERATION_DEPTH test inside an #else clause.
 #else // BOOST_PP_IS_ITERATING
 #if BOOST_PP_ITERATION_DEPTH() == 1 && BOOST_PP_ITERATION_FLAGS() == BOOST_PYTHON_FUNCTION_POINTER
 # if !(BOOST_WORKAROUND(__MWERKS__, > 0x3100)                      \
        && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3201)))
 #  line BOOST_PP_LINE(__LINE__, result.hpp(function pointers))
@@ -128,4 +131,5 @@ boost::type<R>* result(R (T::*)(BOOST_PP_ENUM_PARAMS_Z(1, N, A)) Q, int = 0)
 # undef N
 # undef Q
 #endif // BOOST_PP_ITERATION_DEPTH()
 #endif
--- a/include/boost/python/detail/sfinae.hpp
+++ b/include/boost/python/detail/sfinae.hpp
--- a/include/boost/python/detail/target.hpp
+++ b/include/boost/python/detail/target.hpp
@@ -37,7 +37,10 @@ T& (* target(R (T::*)) )() { return 0; }
 # endif // TARGET_DWA2002521_HPP
 /* --------------- function pointers --------------- */
-#elif BOOST_PP_ITERATION_DEPTH() == 1 && BOOST_PP_ITERATION_FLAGS() == BOOST_PYTHON_FUNCTION_POINTER
+// For gcc 4.4 compatability, we must include the
 // BOOST_PP_ITERATION_DEPTH test inside an #else clause.
 #else // BOOST_PP_IS_ITERATING
 #if BOOST_PP_ITERATION_DEPTH() == 1 && BOOST_PP_ITERATION_FLAGS() == BOOST_PYTHON_FUNCTION_POINTER
 # if !(BOOST_WORKAROUND(__MWERKS__, > 0x3100)                      \
        && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3201)))
 #  line BOOST_PP_LINE(__LINE__, target.hpp(function_pointers))
@@ -79,4 +82,5 @@ T& (* target(R (T::*)(BOOST_PP_ENUM_PARAMS_Z(1, N, A)) Q) )()
 # undef N
 # undef Q
 #endif // BOOST_PP_ITERATION_DEPTH()
 #endif
--- a/include/boost/python/detail/unwind_type.hpp
+++ b/include/boost/python/detail/unwind_type.hpp
--- a/include/boost/python/detail/unwrap_type_id.hpp
+++ b/include/boost/python/detail/unwrap_type_id.hpp
--- a/include/boost/python/detail/unwrap_wrapper.hpp
+++ b/include/boost/python/detail/unwrap_wrapper.hpp
--- a/include/boost/python/detail/value_arg.hpp
+++ b/include/boost/python/detail/value_arg.hpp
--- a/include/boost/python/detail/wrapper_base.hpp
+++ b/include/boost/python/detail/wrapper_base.hpp
--- a/include/boost/python/docstring_options.hpp
+++ b/include/boost/python/docstring_options.hpp
--- a/include/boost/python/handle.hpp
+++ b/include/boost/python/handle.hpp
--- a/include/boost/python/handle_fwd.hpp
+++ b/include/boost/python/handle_fwd.hpp
--- a/include/boost/python/instance_holder.hpp
+++ b/include/boost/python/instance_holder.hpp
--- a/include/boost/python/lvalue_from_pytype.hpp
+++ b/include/boost/python/lvalue_from_pytype.hpp
--- a/include/boost/python/make_constructor.hpp
+++ b/include/boost/python/make_constructor.hpp
--- a/include/boost/python/object.hpp
+++ b/include/boost/python/object.hpp
--- a/include/boost/python/object/class_metadata.hpp
+++ b/include/boost/python/object/class_metadata.hpp
--- a/include/boost/python/object/function_doc_signature.hpp
+++ b/include/boost/python/object/function_doc_signature.hpp
--- a/include/boost/python/object/inheritance_query.hpp
+++ b/include/boost/python/object/inheritance_query.hpp
--- a/include/boost/python/object/make_holder.hpp
+++ b/include/boost/python/object/make_holder.hpp
@@ -47,7 +47,10 @@ template <int nargs> struct make_holder;
 # endif // MAKE_HOLDER_DWA20011215_HPP
-#elif BOOST_PP_ITERATION_DEPTH() == 1
+// For gcc 4.4 compatability, we must include the
 // BOOST_PP_ITERATION_DEPTH test inside an #else clause.
 #else // BOOST_PP_IS_ITERATING
 #if BOOST_PP_ITERATION_DEPTH() == 1
 # if !(BOOST_WORKAROUND(__MWERKS__, > 0x3100)                      \
        && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3201)))
 #  line BOOST_PP_LINE(__LINE__, make_holder.hpp)
@@ -102,4 +105,5 @@ struct make_holder<N>
 # undef N
 #endif // BOOST_PP_ITERATION_DEPTH()
 #endif
--- a/include/boost/python/object/pointer_holder.hpp
+++ b/include/boost/python/object/pointer_holder.hpp
@@ -170,7 +170,10 @@ void* pointer_holder_back_reference<Pointer, Value>::holds(type_info dst_t, bool
 # endif // POINTER_HOLDER_DWA20011215_HPP
 /* --------------- pointer_holder --------------- */
-#elif BOOST_PP_ITERATION_DEPTH() == 1 && BOOST_PP_ITERATION_FLAGS() == 1
+// For gcc 4.4 compatability, we must include the
 // BOOST_PP_ITERATION_DEPTH test inside an #else clause.
 #else // BOOST_PP_IS_ITERATING
 #if BOOST_PP_ITERATION_DEPTH() == 1 && BOOST_PP_ITERATION_FLAGS() == 1
 # if !(BOOST_WORKAROUND(__MWERKS__, > 0x3100)                      \
        && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3201)))
 #  line BOOST_PP_LINE(__LINE__, pointer_holder.hpp)
@@ -212,4 +215,5 @@ void* pointer_holder_back_reference<Pointer, Value>::holds(type_info dst_t, bool
 # undef N
 #endif // BOOST_PP_ITERATION_DEPTH()
 #endif
--- a/include/boost/python/object/stl_iterator_core.hpp
+++ b/include/boost/python/object/stl_iterator_core.hpp
--- a/include/boost/python/object/value_holder.hpp
+++ b/include/boost/python/object/value_holder.hpp
@@ -117,7 +117,10 @@ void* value_holder_back_reference<Value,Held>::holds(
 // --------------- value_holder ---------------
-#elif BOOST_PP_ITERATION_DEPTH() == 1 && BOOST_PP_ITERATION_FLAGS() == 1
+// For gcc 4.4 compatability, we must include the
 // BOOST_PP_ITERATION_DEPTH test inside an #else clause.
 #else // BOOST_PP_IS_ITERATING
 #if BOOST_PP_ITERATION_DEPTH() == 1 && BOOST_PP_ITERATION_FLAGS() == 1
 # if !(BOOST_WORKAROUND(__MWERKS__, > 0x3100)                      \
        && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3201)))
 #  line BOOST_PP_LINE(__LINE__, value_holder.hpp(value_holder))
@@ -163,4 +166,5 @@ void* value_holder_back_reference<Value,Held>::holds(
 # undef N
 #endif // BOOST_PP_ITERATION_DEPTH()
 #endif
--- a/include/boost/python/object_attributes.hpp
+++ b/include/boost/python/object_attributes.hpp
@@ -17,6 +17,7 @@ struct const_attribute_policies
 {
    typedef char const* key_type;
    static object get(object const& target, char const* key);
    static object get(object const& target, object const& key);
 };
 struct attribute_policies : const_attribute_policies
@@ -25,6 +26,18 @@ struct attribute_policies : const_attribute_policies
    static void del(object const&target, char const* key);
 };
 struct const_objattribute_policies
 {
    typedef object const key_type;
    static object get(object const& target, object const& key);
 };
 struct objattribute_policies : const_objattribute_policies
 {
    static object const& set(object const& target, object const& key, object const& value);
    static void del(object const&target, object const& key);
 };
 //
 // implementation
 //
@@ -42,11 +55,30 @@ inline const_object_attribute object_operators<U>::attr(char const* name) const
    return const_object_attribute(x, name);
 }
 template <class U>
 inline object_objattribute object_operators<U>::attr(object const& name)
 {
    object_cref2 x = *static_cast<U*>(this);
    return object_objattribute(x, name);
 }
 template <class U>
 inline const_object_objattribute object_operators<U>::attr(object const& name) const
 {
    object_cref2 x = *static_cast<U const*>(this);
    return const_object_objattribute(x, name);
 }
 inline object const_attribute_policies::get(object const& target, char const* key)
 {
    return python::getattr(target, key);
 }
 inline object const_objattribute_policies::get(object const& target, object const& key)
 {
    return python::getattr(target, key);
 }
 inline object const& attribute_policies::set(
    object const& target
    , char const* key
@@ -56,6 +88,15 @@ inline object const& attribute_policies::set(
    return value;
 }
 inline object const& objattribute_policies::set(
    object const& target
    , object const& key
    , object const& value)
 {
    python::setattr(target, key, value);
    return value;
 }
 inline void attribute_policies::del(
    object const& target
    , char const* key)
@@ -63,6 +104,13 @@ inline void attribute_policies::del(
    python::delattr(target, key);
 }
 inline void objattribute_policies::del(
    object const& target
    , object const& key)
 {
    python::delattr(target, key);
 }
 }}} // namespace boost::python::api
 #endif // OBJECT_ATTRIBUTES_DWA2002615_HPP
--- a/include/boost/python/object_core.hpp
+++ b/include/boost/python/object_core.hpp
@@ -42,6 +42,12 @@
 namespace boost { namespace python { 
 namespace detail
 {
  class kwds_proxy; 
  class args_proxy; 
 } 
 namespace converter
 {
  template <class T> struct arg_to_python;
@@ -59,6 +65,8 @@ namespace api
  struct const_attribute_policies;
  struct attribute_policies;
  struct const_objattribute_policies;
  struct objattribute_policies;
  struct const_item_policies;
  struct item_policies;
  struct const_slice_policies;
@@ -67,6 +75,8 @@ namespace api
  typedef proxy<const_attribute_policies> const_object_attribute;
  typedef proxy<attribute_policies> object_attribute;
  typedef proxy<const_objattribute_policies> const_object_objattribute;
  typedef proxy<objattribute_policies> object_objattribute;
  typedef proxy<const_item_policies> const_object_item;
  typedef proxy<item_policies> object_item;
  typedef proxy<const_slice_policies> const_object_slice;
@@ -98,6 +108,11 @@ namespace api
 # define BOOST_PP_ITERATION_PARAMS_1 (3, (1, BOOST_PYTHON_MAX_ARITY, <boost/python/object_call.hpp>))
 # include BOOST_PP_ITERATE()
      detail::args_proxy operator* () const; 
      object operator()(detail::args_proxy const &args) const; 
      object operator()(detail::args_proxy const &args, 
                        detail::kwds_proxy const &kwds) const; 
      // truth value testing
      //
@@ -108,6 +123,8 @@ namespace api
      //
      const_object_attribute attr(char const*) const;
      object_attribute attr(char const*);
      const_object_objattribute attr(object const&) const;
      object_objattribute attr(object const&);
      // item access
      //
@@ -213,11 +230,11 @@ namespace api
      inline object_base(object_base const&);
      inline object_base(PyObject* ptr);
-      object_base& operator=(object_base const& rhs);
+      inline object_base& operator=(object_base const& rhs);
-      ~object_base();
+      inline ~object_base();
      // Underlying object access -- returns a borrowed reference
-      PyObject* ptr() const;
+      inline PyObject* ptr() const;
   private:
      PyObject* m_ptr;
@@ -387,7 +404,7 @@ namespace api
      static PyObject*
      get(T const& x, U)
      {
-          return python::incref(get_managed_object(x, tag));
+          return python::incref(get_managed_object(x, boost::python::tag));
      }
  };
@@ -410,6 +427,62 @@ template <class T> struct extract;
 // implementation
 //
 namespace detail 
 {
 class call_proxy 
 { 
 public: 
  call_proxy(object target) : m_target(target) {} 
  operator object() const { return m_target;} 
 private: 
    object m_target; 
 }; 
 class kwds_proxy : public call_proxy 
 { 
 public: 
  kwds_proxy(object o = object()) : call_proxy(o) {} 
 }; 
 class args_proxy : public call_proxy 
 { 
 public: 
  args_proxy(object o) : call_proxy(o) {} 
  kwds_proxy operator* () const { return kwds_proxy(*this);} 
 }; 
 } 
 template <typename U> 
 detail::args_proxy api::object_operators<U>::operator* () const 
 { 
  object_cref2 x = *static_cast<U const*>(this); 
  return boost::python::detail::args_proxy(x); 
 } 
 template <typename U> 
 object api::object_operators<U>::operator()(detail::args_proxy const &args) const 
 { 
  U const& self = *static_cast<U const*>(this); 
  PyObject *result = PyObject_Call(get_managed_object(self, boost::python::tag), 
                                   args.operator object().ptr(), 
                                   0); 
  return object(boost::python::detail::new_reference(result)); 
 } 
 template <typename U> 
 object api::object_operators<U>::operator()(detail::args_proxy const &args, 
                                            detail::kwds_proxy const &kwds) const 
 { 
  U const& self = *static_cast<U const*>(this); 
  PyObject *result = PyObject_Call(get_managed_object(self, boost::python::tag), 
                                   args.operator object().ptr(), 
                                   kwds.operator object().ptr()); 
  return object(boost::python::detail::new_reference(result)); 
 }  
 inline object::object()
    : object_base(python::incref(Py_None))
 {}
--- a/include/boost/python/object_items.hpp
+++ b/include/boost/python/object_items.hpp
--- a/include/boost/python/object_protocol.hpp
+++ b/include/boost/python/object_protocol.hpp
--- a/include/boost/python/object_protocol_core.hpp
+++ b/include/boost/python/object_protocol_core.hpp
--- a/include/boost/python/other.hpp
+++ b/include/boost/python/other.hpp
--- a/include/boost/python/override.hpp
+++ b/include/boost/python/override.hpp
--- a/include/boost/python/proxy.hpp
+++ b/include/boost/python/proxy.hpp
--- a/include/boost/python/ptr.hpp
+++ b/include/boost/python/ptr.hpp
@@ -8,7 +8,7 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 //
 // Based on boost/ref.hpp, thus:
-//  Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+//  Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 //  Copyright (C) 2001 Peter Dimov
 # if _MSC_VER+0 >= 1020
--- a/include/boost/python/pure_virtual.hpp
+++ b/include/boost/python/pure_virtual.hpp
--- a/include/boost/python/raw_function.hpp
+++ b/include/boost/python/raw_function.hpp
--- a/include/boost/python/refcount.hpp
+++ b/include/boost/python/refcount.hpp
--- a/include/boost/python/return_arg.hpp
+++ b/include/boost/python/return_arg.hpp
--- a/include/boost/python/self.hpp
+++ b/include/boost/python/self.hpp
--- a/Show More
+++ b/Show More