This commit was manufactured by cvs2svn to create tag

'dwa-prelicense'.

[SVN r35235]

build/Jamfile.v2

@@ -9,7 +9,7 @@ if [ python.configured ] {
 project boost/python
     : source-location ../src
         : requirements 
-	#<include>$(PYTHON_PATH)/include
+        #<include>$(PYTHON_PATH)/include
         #  $(lib_condition)<library-path>$(PYTHON_PATH)/libs
         #    <link>shared:<library>$(PYTHON_LIB)
         #    <define>$(defines)
@@ -59,7 +59,16 @@ lib boost_python
     :   # requirements
         <link>static:<define>BOOST_PYTHON_STATIC_LIB 
         <define>BOOST_PYTHON_SOURCE
-     	<library>/python//python
+        # On Linux, we don't link to Python library itself. If
+        # Boost.Python is used for extension, all Python
+        # symbols are available in Python interpreter.
+        # If Boost.Python is used for extending, client
+        # is required to link to /python//python itself.
+        # On Windows, all code using Python has to link
+        # to python import library. The 'python_for_extension'
+        # is the target that's setup to provide either just
+        # include paths, or import library.  
+        <library>/python//python_for_extensions
     :   # default build
         <link>shared
     :   # usage requirements

doc/projects.html

@@ -304,7 +304,7 @@
       <p>The SourceForge cctbx project is organized in modules to facilitate
       use in non-crystallographic applications. The scitbx module implements
       a general purpose array family for scientific applications and pure C++
-      ports of FFTPACK and the LBFGS conjugate gradient minimizer.</p>
+      ports of FFTPACK and the L-BFGS quasi-Newton minimizer.</p>
     </dd>
 
     <dt><a href="http://www.llnl.gov/CASC/emsolve"><b>EMSolve</b></a></dt>

doc/tutorial/doc/html/boostbook.css

@@ -23,23 +23,24 @@
 
     p 
     {
-        text-align: justify;
-        font-size: 11pt; 
-        line-height: 1.2;
+        text-align: left;
+        font-size: 10pt; 
+        line-height: 1.15;
     }
 
 /*=============================================================================
     Program listings
 =============================================================================*/
 
-    tt.computeroutput
+    /* Code on paragraphs */
+    p tt.computeroutput
     {
-        font-size: 10pt;
+        font-size: 9pt;
     }
 
     pre.synopsis
     {
-        font-size: 10pt;
+        font-size: 90%;
         margin: 1pc 4% 0pc 4%;
         padding: 0.5pc 0.5pc 0.5pc 0.5pc;
     }
@@ -47,32 +48,36 @@
     .programlisting, 
     .screen
     {
-        font-size: 10pt;
+        font-size: 9pt;
         display: block;
         margin: 1pc 4% 0pc 4%;
         padding: 0.5pc 0.5pc 0.5pc 0.5pc;
     }
 
+    /* Program listings in tables don't get borders */
+    td .programlisting, 
+    td .screen
+    {
+        margin: 0pc 0pc 0pc 0pc;
+        padding:  0pc 0pc 0pc 0pc;
+    }
+
 /*=============================================================================
     Headings
 =============================================================================*/
 
-    h1, 
-    h2, 
-    h3, 
-    h4, 
-    h5, 
-    h6 
+    h1, h2, h3, h4, h5, h6 
     { 
         text-align: left; 
-        margin-top: 2pc; 
+        margin: 1em 0em 0.5em 0em;
+        font-weight: bold;
     }
 
-    h1 { font: 170% }
+    h1 { font: 140% }
     h2 { font: bold 140% }
-    h3 { font: bold 120% }
-    h4 { font: bold 100% }
-    h5 { font: italic 100% }
+    h3 { font: bold 130% }
+    h4 { font: bold 120% }
+    h5 { font: italic 110% }
     h6 { font: italic 100% }
 
     /* Top page titles */
@@ -89,12 +94,41 @@
         margin-bottom: 1pc;
     }
 
-    h1.title { font-size: 220% }
-    h2.title { font-size: 220% }
-    h3.title { font-size: 170% }
-    h4.title { font-size: 140% }
-    h5.title { font-size: 120% }
-    h6.title { font-size: 120% }
+    h1.title { font-size: 140% }
+    h2.title { font-size: 140% }
+    h3.title { font-size: 130% }
+    h4.title { font-size: 120% }
+    h5.title { font-size: 110% }
+    h6.title { font-size: 100% }
+
+    .section h1 
+    {
+        margin: 0em 0em 0.5em 0em;
+        font-size: 140%;
+    }
+
+    .section h2 { font-size: 140% }
+    .section h3 { font-size: 130% }
+    .section h4 { font-size: 120% }
+    .section h5 { font-size: 110% }
+    .section h6 { font-size: 100% }
+
+    /* Code on titles */
+    h1 tt.computeroutput { font-size: 140% }
+    h2 tt.computeroutput { font-size: 140% }
+    h3 tt.computeroutput { font-size: 130% }
+    h4 tt.computeroutput { font-size: 120% }
+    h5 tt.computeroutput { font-size: 110% }
+    h6 tt.computeroutput { font-size: 100% }
+
+/*=============================================================================
+    Author
+=============================================================================*/
+
+    h3.author 
+    { 
+        font-size: 100% 
+    }
 
 /*=============================================================================
     Lists
@@ -102,20 +136,20 @@
 
     li
     {
-        font-size: 11pt;
+        font-size: 10pt;
         line-height: 1.3;
     }
     
     /* Unordered lists */
     ul 
     {
-        text-align: justify;
+        text-align: left;
     }
     
     /* Ordered lists */
     ol 
     {
-        text-align: justify;
+        text-align: left;
     }
 
 /*=============================================================================
@@ -159,9 +193,9 @@
     .toc
     {
        margin: 1pc 4% 0pc 4%;
-       padding: 0.5pc;
-       font-size: 11pt; 
-       line-height: 1.3;
+       padding: 0.1pc 1pc 0.1pc 1pc;
+       font-size: 80%; 
+       line-height: 1.15;
     }
     
     .boost-toc
@@ -180,7 +214,6 @@
         margin-left: 4%;
         padding-right: 0.5em; 
         padding-left: 0.5em;
-        font-size: 120%;
     }
     
     .informaltable table, 
@@ -202,8 +235,8 @@
     div.table table tr td
     {
         padding: 0.5em;
-        text-align: justify;
-        font-size: 11pt;
+        text-align: left;
+        font-size: 9pt;
     }
 
     div.informaltable table tr th, 
@@ -211,51 +244,76 @@
     {
         padding: 0.5em 0.5em 0.5em 0.5em;
         border: 1pt solid white;
+        font-size: 80%;
     }
 
 /*=============================================================================
     Blurbs
 =============================================================================*/
 
-    div.informaltable table tr td.blurb
+    div.note,
+    div.tip,
+    div.important,
+    div.caution,
+    div.warning,
+    p.blurb
     {
-        font-size: 10pt; /* A little bit smaller than the main text */
+        font-size: 9pt; /* A little bit smaller than the main text */
         line-height: 1.2;
+        display: block;
+        margin: 1pc 4% 0pc 4%;
+        padding: 0.5pc 0.5pc 0.5pc 0.5pc;
     }
     
-    td.blurb img
+    p.blurb img
     {
         padding: 1pt;
     }
 
 /*=============================================================================
-    Misc
+    Variable Lists
 =============================================================================*/
 
-    /* Tone down the title of Parameter lists */
-    div.variablelist p.title
+    /* Make the terms in definition lists bold */
+    div.variablelist dl dt,
+    span.term
     {
         font-weight: bold;
-        font-size: 100%;
-        text-align: left;
+        font-size: 10pt;
     }
-    
-    /* Tabularize parameter lists */
+
+    div.variablelist table tbody tr td
+    {
+        text-align: left;
+        vertical-align: top;
+        padding: 0em 2em 0em 0em;
+        font-size: 10pt;
+        margin: 0em 0em 0.5em 0em;
+        line-height: 1;
+    }
+
     div.variablelist dl dt
     {
-        float: left;
-        clear: left;
-        display: block;
-        font-style: italic;
+        margin-bottom: 0.2em;
     }
-    
+
     div.variablelist dl dd
     {
-        display: block;
-        clear:   right;
-        padding-left: 8pc;
+        margin: 0em 0em 0.5em 2em;
+        font-size: 10pt;
     }
 
+    div.variablelist table tbody tr td p,
+    div.variablelist dl dd p
+    {
+        margin: 0em 0em 0.5em 0em;
+        line-height: 1;
+    }
+
+/*=============================================================================
+    Misc
+=============================================================================*/
+
     /* Title of books and articles in bibliographies */
     span.title
     {
@@ -294,6 +352,14 @@
         {
             color: #9c5a9c;
         }
+
+        h1 a, h2 a, h3 a, h4 a, h5 a, h6 a,
+        h1 a:hover, h2 a:hover, h3 a:hover, h4 a:hover, h5 a:hover, h6 a:hover,
+        h1 a:visited, h2 a:visited, h3 a:visited, h4 a:visited, h5 a:visited, h6 a:visited
+        {
+            text-decoration: none; /* no underline */
+            color: #000000;
+        }
     
     /* Syntax Highlighting */
         .keyword        { color: #0000AA; }
@@ -322,41 +388,50 @@
     /* Program listing */
         pre.synopsis
         {
-            background-color: #F3F3F3;
-            border: 1pt solid #C0C0C0;
+            border: 1px solid #DCDCDC;
         }
     
         .programlisting, 
         .screen
         {
-            background-color: #F3F3F3;
-            border: 1pt solid #C0C0C0;
+            border: 1px solid #DCDCDC;
+        }
+    
+        td .programlisting, 
+        td .screen
+        {
+            border: 0px solid #DCDCDC;
         }
     
     /* Blurbs */
-        div.informaltable table tr td.blurb
+        div.note,
+        div.tip,
+        div.important,
+        div.caution,
+        div.warning,
+        p.blurb
         {
-            background-color: #FFFFF0;
-            border: 1pt solid #707070;
+            border: 1px solid #DCDCDC;
         }
     
     /* Table of contents */
         .toc
         {
-            background-color: #F3F3F3;
+            border: 1px solid #DCDCDC;
         }
     
     /* Tables */
         div.informaltable table tr td, 
         div.table table tr td
         {
-            background-color: #F0F0F0;
+            border: 1px solid #DCDCDC;
         }
     
         div.informaltable table tr th, 
         div.table table tr th
         {
-            background-color: #E4E4E4;
+            background-color: #F0F0F0;
+            border: 1px solid #DCDCDC;
         }
     
     /* Misc */
@@ -396,6 +471,12 @@
             border: 1px solid gray;
         }
     
+        td .programlisting, 
+        td .screen
+        {
+            border: 0px solid #DCDCDC;
+        }
+    
     /* Table of contents */
         .toc
         {

doc/tutorial/doc/html/index.html

@@ -31,7 +31,7 @@
 <div><p class="copyright">Copyright © 2002-2005 Joel
       de Guzman, David Abrahams</p></div>
 <div><div class="legalnotice">
-<a name="id372676"></a><p>
+<a name="id376848"></a><p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">
         http://www.boost.org/LICENSE_1_0.txt </a>)
@@ -94,7 +94,7 @@
       (IDL).
     </p>
 <a name="quickstart.hello_world"></a><h2>
-<a name="id372867"></a>
+<a name="id447173"></a>
       Hello World
     </h2>
 <p>
@@ -139,7 +139,7 @@
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"><small><p>Last revised: February 14, 2006 at 02:23:06 GMT</p></small></td>
+<td align="left"><small><p>Last revised: August 31, 2006 at 05:59:58 GMT</p></small></td>
 <td align="right"><small></small></td>
 </tr></table>
 <hr>

doc/tutorial/doc/html/python/embedding.html

@@ -40,7 +40,7 @@
       Python/C API at all. So stay tuned... <span class="inlinemediaobject"><img src="../images/smiley.png" alt="smiley"></span>
     </p>
 <a name="embedding.building_embedded_programs"></a><h2>
-<a name="id458605"></a>
+<a name="id462650"></a>
       Building embedded programs
     </h2>
 <p>
@@ -84,7 +84,7 @@ exe embedded_program # name of the executable
     &lt;find-library&gt;$(PYTHON_EMBEDDED_LIBRARY) ;
 </pre>
 <a name="embedding.getting_started"></a><h2>
-<a name="id458703"></a>
+<a name="id462747"></a>
       Getting started
     </h2>
 <p>
@@ -93,9 +93,7 @@ exe embedded_program # name of the executable
     </p>
 <div class="orderedlist"><ol type="1">
 <li>
-        
-#include
-         <tt class="literal">&lt;boost/python.hpp&gt;</tt><br><br>
+        #include <tt class="literal">&lt;boost/python.hpp&gt;</tt><br><br>
 </li>
 <li>
         Call <a href="http://www.python.org/doc/current/api/initialization.html#l2h-652" target="_top">Py_Initialize</a>()
@@ -131,7 +129,7 @@ exe embedded_program # name of the executable
         automate the process.
       </p>
 <a name="using_the_interpreter.reference_counting_handles_and_objects"></a><h2>
-<a name="id458870"></a>
+<a name="id462914"></a>
         Reference-counting handles and objects
       </h2>
 <p>
@@ -165,20 +163,17 @@ exe embedded_program # name of the executable
         a new reference is <a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-55" target="_top">PyRun_String</a>
         which we'll discuss in the next section.
       </p>
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <span class="inlinemediaobject"><img src="../images/note.png" alt="note"></span> <span class="bold"><b>Handle is a class
-              <span class="emphasis"><em>template</em></span>, so why haven't we been using any template
-              parameters?</b></span><br> <br> <tt class="literal">handle</tt> has a
-              single template parameter specifying the type of the managed object.
-              This type is <tt class="literal">PyObject</tt> 99% of the time, so the parameter
-              was defaulted to <tt class="literal">PyObject</tt> for convenience. Therefore
-              we can use the shorthand <tt class="literal">handle&lt;&gt;</tt> instead
-              of the longer, but equivalent, <tt class="literal">handle&lt;PyObject&gt;</tt>.
-              </td></tr></tbody>
-</table></div>
+<p class="blurb">
+        <span class="inlinemediaobject"><img src="../images/note.png" alt="note"></span> <span class="bold"><b>Handle is a class <span class="emphasis"><em>template</em></span>,
+        so why haven't we been using any template parameters?</b></span><br> <br>
+        <tt class="literal">handle</tt> has a single template parameter specifying the
+        type of the managed object. This type is <tt class="literal">PyObject</tt> 99%
+        of the time, so the parameter was defaulted to <tt class="literal">PyObject</tt>
+        for convenience. Therefore we can use the shorthand <tt class="literal">handle&lt;&gt;</tt>
+        instead of the longer, but equivalent, <tt class="literal">handle&lt;PyObject&gt;</tt>.
+      </p>
 <a name="using_the_interpreter.running_python_code"></a><h2>
-<a name="id459217"></a>
+<a name="id463241"></a>
         Running Python code
       </h2>
 <p>
@@ -201,7 +196,7 @@ exe embedded_program # name of the executable
       </p>
 <div class="informaltable">
 <h4>
-<a name="id459396"></a>
+<a name="id463420"></a>
           <span class="table-title">Start symbols</span>
         </h4>
 <table class="table">
@@ -274,18 +269,16 @@ exe embedded_program # name of the executable
         This should create a file called 'hello.txt' in the current directory containing
         a phrase that is well-known in programming circles.
       </p>
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <span class="inlinemediaobject"><img src="../images/note.png" alt="note"></span> <span class="bold"><b>Note</b></span> that
-              we wrap the return value of <a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-55" target="_top">PyRun_String</a>
-              in a (nameless) <tt class="literal">handle</tt> even though we are not interested
-              in it. If we didn't do this, the the returned object would be kept
-              alive unnecessarily. Unless you want to be a Dr. Frankenstein, always
-              wrap <tt class="literal">PyObject*</tt>s in <tt class="literal">handle</tt>s.
-              </td></tr></tbody>
-</table></div>
+<p class="blurb">
+        <span class="inlinemediaobject"><img src="../images/note.png" alt="note"></span> <span class="bold"><b>Note</b></span> that we wrap
+        the return value of <a href="http://www.python.org/doc/current/api/veryhigh.html#l2h-55" target="_top">PyRun_String</a>
+        in a (nameless) <tt class="literal">handle</tt> even though we are not interested
+        in it. If we didn't do this, the the returned object would be kept alive
+        unnecessarily. Unless you want to be a Dr. Frankenstein, always wrap <tt class="literal">PyObject*</tt>s
+        in <tt class="literal">handle</tt>s.
+      </p>
 <a name="using_the_interpreter.beyond_handles"></a><h2>
-<a name="id459921"></a>
+<a name="id463926"></a>
         Beyond handles
       </h2>
 <p>
@@ -331,17 +324,15 @@ exe embedded_program # name of the executable
 
 <span class="keyword">int</span> <span class="identifier">five_squared</span> <span class="special">=</span> <span class="identifier">extract</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">result</span><span class="special">);</span>
 </pre>
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <span class="inlinemediaobject"><img src="../images/note.png" alt="note"></span> <span class="bold"><b>Note</b></span> that
-              <tt class="literal">object</tt>'s member function to return the wrapped
-              <tt class="literal">PyObject*</tt> is called <tt class="literal">ptr</tt> instead
-              of <tt class="literal">get</tt>. This makes sense if you take into account
-              the different functions that <tt class="literal">object</tt> and <tt class="literal">handle</tt>
-              perform. </td></tr></tbody>
-</table></div>
+<p class="blurb">
+        <span class="inlinemediaobject"><img src="../images/note.png" alt="note"></span> <span class="bold"><b>Note</b></span> that <tt class="literal">object</tt>'s
+        member function to return the wrapped <tt class="literal">PyObject*</tt> is called
+        <tt class="literal">ptr</tt> instead of <tt class="literal">get</tt>. This makes sense
+        if you take into account the different functions that <tt class="literal">object</tt>
+        and <tt class="literal">handle</tt> perform.
+      </p>
 <a name="using_the_interpreter.exception_handling"></a><h2>
-<a name="id460562"></a>
+<a name="id464549"></a>
         Exception handling
       </h2>
 <p>

doc/tutorial/doc/html/python/exposing.html

@@ -379,13 +379,10 @@
         The <tt class="computeroutput"><span class="identifier">wrapper</span></tt> template makes
         the job of wrapping classes that are meant to overridden in Python, easier.
       </p>
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <span class="inlinemediaobject"><img src="../images/alert.png" alt="alert"></span> <span class="bold"><b>MSVC6/7 Workaround</b></span><br>
-              <br> If you are using Microsoft Visual C++ 6 or 7, you have to write
-              <tt class="computeroutput"><span class="identifier">f</span></tt> as:<br> <br>
-              <tt class="computeroutput"><span class="keyword">return</span> <span class="identifier">call</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">get_override</span><span class="special">(</span><span class="string">"f"</span><span class="special">).</span><span class="identifier">ptr</span><span class="special">());</span></tt>.</td></tr></tbody>
-</table></div>
+<p class="blurb">
+        <span class="inlinemediaobject"><img src="../images/alert.png" alt="alert"></span> <span class="bold"><b>MSVC6/7 Workaround</b></span><br>
+        <br> If you are using Microsoft Visual C++ 6 or 7, you have to write <tt class="computeroutput"><span class="identifier">f</span></tt> as:<br> <br> <tt class="computeroutput"><span class="keyword">return</span> <span class="identifier">call</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">get_override</span><span class="special">(</span><span class="string">"f"</span><span class="special">).</span><span class="identifier">ptr</span><span class="special">());</span></tt>.
+      </p>
 <p>
         BaseWrap's overridden virtual member function <tt class="computeroutput"><span class="identifier">f</span></tt>
         in effect calls the corresponding method of the Python object through <tt class="computeroutput"><span class="identifier">get_override</span></tt>.
@@ -403,14 +400,10 @@
         that the function <tt class="computeroutput"><span class="identifier">f</span></tt> is a
         pure virtual function.
       </p>
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <span class="inlinemediaobject"><img src="../images/note.png" alt="note"></span> <span class="bold"><b>member function and
-              methods</b></span><br> <br> Python, like many object oriented languages
-              uses the term <span class="bold"><b>methods</b></span>. Methods correspond
-              roughly to C++'s <span class="bold"><b>member functions</b></span>
-</td></tr></tbody>
-</table></div>
+<p class="blurb">
+        <span class="inlinemediaobject"><img src="../images/note.png" alt="note"></span> <span class="bold"><b>member function and methods</b></span><br>
+        <br> Python, like many object oriented languages uses the term <span class="bold"><b>methods</b></span>. Methods correspond roughly to C++'s <span class="bold"><b>member functions</b></span>
+      </p>
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
@@ -464,12 +457,11 @@
         we have to check if there is an override for <tt class="computeroutput"><span class="identifier">f</span></tt>.
         If none, then we call <tt class="computeroutput"><span class="identifier">Base</span><span class="special">::</span><span class="identifier">f</span><span class="special">()</span></tt>.
       </p>
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <span class="inlinemediaobject"><img src="../images/alert.png" alt="alert"></span> <span class="bold"><b>MSVC6/7 Workaround</b></span><br>
-              <br> If you are using Microsoft Visual C++ 6 or 7, you have to rewrite
-              the line with the <tt class="computeroutput"><span class="special">*</span><span class="identifier">note</span><span class="special">*</span></tt> as:<br> <br> <tt class="computeroutput"><span class="keyword">return</span> <span class="identifier">call</span><span class="special">&lt;</span><span class="keyword">char</span> <span class="keyword">const</span><span class="special">*&gt;(</span><span class="identifier">f</span><span class="special">.</span><span class="identifier">ptr</span><span class="special">());</span></tt>.</td></tr></tbody>
-</table></div>
+<p class="blurb">
+        <span class="inlinemediaobject"><img src="../images/alert.png" alt="alert"></span> <span class="bold"><b>MSVC6/7 Workaround</b></span><br>
+        <br> If you are using Microsoft Visual C++ 6 or 7, you have to rewrite
+        the line with the <tt class="computeroutput"><span class="special">*</span><span class="identifier">note</span><span class="special">*</span></tt> as:<br> <br> <tt class="computeroutput"><span class="keyword">return</span> <span class="identifier">call</span><span class="special">&lt;</span><span class="keyword">char</span> <span class="keyword">const</span><span class="special">*&gt;(</span><span class="identifier">f</span><span class="special">.</span><span class="identifier">ptr</span><span class="special">());</span></tt>.
+      </p>
 <p>
         Finally, exposing:
       </p>
@@ -516,7 +508,7 @@
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.class_operators_special_functions"></a>Class Operators/Special Functions</h3></div></div></div>
 <a name="class_operators_special_functions.python_operators"></a><h2>
-<a name="id448928"></a>
+<a name="id453009"></a>
         Python Operators
       </h2>
 <p>
@@ -565,7 +557,7 @@
         expressions".
       </p>
 <a name="class_operators_special_functions.special_methods"></a><h2>
-<a name="id449680"></a>
+<a name="id453761"></a>
         Special Methods
       </h2>
 <p>
@@ -593,11 +585,12 @@
 <p>
         Need we say more?
       </p>
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <span class="inlinemediaobject"><img src="../images/note.png" alt="note"></span> What is the business of <tt class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></tt>? Well, the method <tt class="computeroutput"><span class="identifier">str</span></tt> requires the <tt class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></tt> to do its work (i.e. <tt class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></tt>
-              is used by the method defined by <tt class="computeroutput"><span class="identifier">def</span><span class="special">(</span><span class="identifier">str</span><span class="special">(</span><span class="identifier">self</span><span class="special">))</span></tt>.</td></tr></tbody>
-</table></div>
+<p class="blurb">
+        <span class="inlinemediaobject"><img src="../images/note.png" alt="note"></span> What is the business of <tt class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></tt>? Well, the method <tt class="computeroutput"><span class="identifier">str</span></tt>
+        requires the <tt class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></tt>
+        to do its work (i.e. <tt class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></tt> is used by the method defined by
+        <tt class="computeroutput"><span class="identifier">def</span><span class="special">(</span><span class="identifier">str</span><span class="special">(</span><span class="identifier">self</span><span class="special">))</span></tt>.
+      </p>
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>

doc/tutorial/doc/html/python/functions.html

@@ -206,7 +206,7 @@ Namespaces are one honking great idea -- let's do more of those!
 <li><span class="bold"><b>BOOM!</b></span></li>
 </ol></div>
 <a name="call_policies.call_policies"></a><h2>
-<a name="id451559"></a>
+<a name="id455614"></a>
         Call Policies
       </h2>
 <p>
@@ -287,13 +287,11 @@ Namespaces are one honking great idea -- let's do more of those!
           and hold the instance
         </li>
 </ul></div>
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <span class="inlinemediaobject"><img src="../images/smiley.png" alt="smiley"></span> <span class="bold"><b>Remember the Zen, Luke:</b></span><br>
-              <br> "Explicit is better than implicit"<br> "In
-              the face of ambiguity, refuse the temptation to guess"<br>
-              </td></tr></tbody>
-</table></div>
+<p class="blurb">
+        <span class="inlinemediaobject"><img src="../images/smiley.png" alt="smiley"></span> <span class="bold"><b>Remember the Zen, Luke:</b></span><br>
+        <br> "Explicit is better than implicit"<br> "In the face
+        of ambiguity, refuse the temptation to guess"<br>
+      </p>
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
@@ -404,7 +402,7 @@ Namespaces are one honking great idea -- let's do more of those!
         </li>
 </ul></div>
 <a name="default_arguments.boost_python_function_overloads"></a><h2>
-<a name="id453611"></a>
+<a name="id457647"></a>
         BOOST_PYTHON_FUNCTION_OVERLOADS
       </h2>
 <p>
@@ -434,7 +432,7 @@ Namespaces are one honking great idea -- let's do more of those!
 <span class="identifier">def</span><span class="special">(</span><span class="string">"foo"</span><span class="special">,</span> <span class="identifier">foo</span><span class="special">,</span> <span class="identifier">foo_overloads</span><span class="special">());</span>
 </pre>
 <a name="default_arguments.boost_python_member_function_overloads"></a><h2>
-<a name="id453927"></a>
+<a name="id457963"></a>
         BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS
       </h2>
 <p>
@@ -480,7 +478,7 @@ Namespaces are one honking great idea -- let's do more of those!
         reference</a> for details.
       </p>
 <a name="default_arguments.init_and_optional"></a><h2>
-<a name="id454288"></a>
+<a name="id458323"></a>
         init and optional
       </h2>
 <p>
@@ -547,14 +545,14 @@ Namespaces are one honking great idea -- let's do more of those!
         Then...
       </p>
 <pre class="programlisting">
-<span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"foo"</span><span class="special">,</span> <span class="identifier">foo</span><span class="special">,</span> <span class="identifier">foo_overloads</span><span class="special">());</span>
+<span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"foo"</span><span class="special">,</span> <span class="special">(</span><span class="keyword">void</span><span class="special">(*)(</span><span class="keyword">bool</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">char</span><span class="special">))</span><span class="number">0</span><span class="special">,</span> <span class="identifier">foo_overloads</span><span class="special">());</span>
 </pre>
 <p>
         Notice though that we have a situation now where we have a minimum of zero
         (0) arguments and a maximum of 3 arguments.
       </p>
 <a name="auto_overloading.manual_wrapping"></a><h2>
-<a name="id455013"></a>
+<a name="id459095"></a>
         Manual Wrapping
       </h2>
 <p>

doc/tutorial/doc/html/python/hello.html

@@ -26,7 +26,7 @@
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="python.hello"></a> Building Hello World</h2></div></div></div>
 <a name="hello.from_start_to_finish"></a><h2>
-<a name="id373240"></a>
+<a name="id377427"></a>
       From Start To Finish
     </h2>
 <p>
@@ -35,17 +35,16 @@
       necessary to achieve that. We shall use the build tool that comes bundled with
       every boost distribution: <span class="bold"><b>bjam</b></span>.
     </p>
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <span class="inlinemediaobject"><img src="../images/note.png" alt="note"></span> <span class="bold"><b>Building without bjam</b></span><br>
-            <br> Besides bjam, there are of course other ways to get your module
-            built. What's written here should not be taken as "the one and only
-            way". There are of course other build tools apart from <tt class="literal">bjam</tt>.<br>
-            <br> Take note however that the preferred build tool for Boost.Python
-            is bjam. There are so many ways to set up the build incorrectly. Experience
-            shows that 90% of the "I can't build Boost.Python" problems
-            come from people who had to use a different tool. </td></tr></tbody>
-</table></div>
+<p class="blurb">
+      <span class="inlinemediaobject"><img src="../images/note.png" alt="note"></span> <span class="bold"><b>Building without bjam</b></span><br>
+      <br> Besides bjam, there are of course other ways to get your module built.
+      What's written here should not be taken as "the one and only way".
+      There are of course other build tools apart from <tt class="literal">bjam</tt>.<br>
+      <br> Take note however that the preferred build tool for Boost.Python is
+      bjam. There are so many ways to set up the build incorrectly. Experience shows
+      that 90% of the "I can't build Boost.Python" problems come from people
+      who had to use a different tool.
+    </p>
 <p>
       We shall skip over the details. Our objective will be to simply create the
       hello world module and run it in Python. For a complete reference to building
@@ -99,7 +98,7 @@
       platforms. The complete list of Bjam executables can be found <a href="http://sourceforge.net/project/showfiles.php?group_id=7586" target="_top">here</a>.
     </p>
 <a name="hello.let_s_jam_"></a><h2>
-<a name="id373448"></a>
+<a name="id377613"></a>
       Let's Jam!
     </h2>
 <p>
@@ -150,7 +149,7 @@ extension hello                     # Declare a Python extension called hello
       The last part tells BJam that we are depending on the Boost Python Library.
     </p>
 <a name="hello.running_bjam"></a><h2>
-<a name="id373586"></a>
+<a name="id377751"></a>
       Running bjam
     </h2>
 <p>
@@ -178,11 +177,10 @@ set PYTHON_VERSION=2.2
       The above assumes that the Python installation is in <tt class="literal">c:/dev/tools/python</tt>
       and that we are using Python version 2.2. You'll have to tweak these appropriately.
     </p>
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <span class="inlinemediaobject"><img src="../images/tip.png" alt="tip"></span> Be sure not to include a third number, e.g. <span class="bold"><b>not</b></span> "2.2.1", even if that's the version
-            you have.</td></tr></tbody>
-</table></div>
+<p class="blurb">
+      <span class="inlinemediaobject"><img src="../images/tip.png" alt="tip"></span> Be sure not to include a third number, e.g. <span class="bold"><b>not</b></span> "2.2.1", even if that's the version you
+      have.
+    </p>
 <p>
       Take note that you may also do that through the Jamrules file we put in our
       project as detailed above. The file has <a href="../../../../../example/tutorial/Jamrules" target="_top">detailed

doc/tutorial/doc/html/python/object.html

@@ -176,12 +176,11 @@
         % x,y,z</tt> in Python, which is useful since there's no easy way to
         do that in std C++.
       </p>
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <span class="inlinemediaobject"><img src="../images/alert.png" alt="alert"></span> <span class="bold"><b>Beware</b></span> the
-              common pitfall of forgetting that the constructors of most of Python's
-              mutable types make copies, just as in Python. </td></tr></tbody>
-</table></div>
+<p class="blurb">
+        <span class="inlinemediaobject"><img src="../images/alert.png" alt="alert"></span> <span class="bold"><b>Beware</b></span> the common
+        pitfall of forgetting that the constructors of most of Python's mutable types
+        make copies, just as in Python.
+      </p>
 <p>
         Python:
       </p>
@@ -197,7 +196,7 @@
 </span><span class="identifier">d</span><span class="special">[</span><span class="char">'whatever'</span><span class="special">]</span> <span class="special">=</span> <span class="number">3</span><span class="special">;</span>           <span class="comment">// modifies the copy
 </span></pre>
 <a name="derived_object_types.class__lt_t_gt__as_objects"></a><h2>
-<a name="id457004"></a>
+<a name="id461067"></a>
         class_&lt;T&gt; as objects
       </h2>
 <p>
@@ -295,14 +294,12 @@
         above creates a Python class derived from Python's <tt class="literal">int</tt>
         type which is associated with the C++ type passed as its first parameter.
       </p>
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <span class="inlinemediaobject"><img src="../images/note.png" alt="note"></span> <span class="bold"><b>what is a scope?</b></span><br>
-              <br> The scope is a class that has an associated global Python object
-              which controls the Python namespace in which new extension classes
-              and wrapped functions will be defined as attributes. Details can be
-              found <a href="../../../../v2/scope.html" target="_top">here</a>.</td></tr></tbody>
-</table></div>
+<p class="blurb">
+        <span class="inlinemediaobject"><img src="../images/note.png" alt="note"></span> <span class="bold"><b>what is a scope?</b></span><br>
+        <br> The scope is a class that has an associated global Python object which
+        controls the Python namespace in which new extension classes and wrapped
+        functions will be defined as attributes. Details can be found <a href="../../../../v2/scope.html" target="_top">here</a>.
+      </p>
 <p>
         You can access those values in Python as
       </p>

doc/tutorial/doc/html/python/techniques.html

@@ -96,13 +96,12 @@
         Compiling these files will generate the following Python extensions: <tt class="literal">core.pyd</tt>,
         <tt class="literal">io.pyd</tt> and <tt class="literal">filters.pyd</tt>.
       </p>
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <span class="inlinemediaobject"><img src="../images/note.png" alt="note"></span> The extension <tt class="literal">.pyd</tt> is used
-              for python extension modules, which are just shared libraries. Using
-              the default for your system, like <tt class="literal">.so</tt> for Unix and
-              <tt class="literal">.dll</tt> for Windows, works just as well.</td></tr></tbody>
-</table></div>
+<p class="blurb">
+        <span class="inlinemediaobject"><img src="../images/note.png" alt="note"></span> The extension <tt class="literal">.pyd</tt> is used for python
+        extension modules, which are just shared libraries. Using the default for
+        your system, like <tt class="literal">.so</tt> for Unix and <tt class="literal">.dll</tt>
+        for Windows, works just as well.
+      </p>
 <p>
         Now, we create this directory structure for our Python package:
       </p>
@@ -425,19 +424,17 @@
         exporting it to Python at the same time: changes in a class will only demand
         the compilation of a single cpp, instead of the entire wrapper code.
       </p>
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <span class="inlinemediaobject"><img src="../images/note.png" alt="note"></span> If you're exporting your classes with <a href="../../../../../pyste/index.html" target="_top">Pyste</a>,
-              take a look at the <tt class="literal">--multiple</tt> option, that generates
-              the wrappers in various files as demonstrated here.</td></tr></tbody>
-</table></div>
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <span class="inlinemediaobject"><img src="../images/note.png" alt="note"></span> This method is useful too if you are getting the
-              error message <span class="emphasis"><em>"fatal error C1204:Compiler limit:internal
-              structure overflow"</em></span> when compiling a large source file,
-              as explained in the <a href="../../../../v2/faq.html#c1204" target="_top">FAQ</a>.</td></tr></tbody>
-</table></div>
+<p class="blurb">
+        <span class="inlinemediaobject"><img src="../images/note.png" alt="note"></span> If you're exporting your classes with <a href="../../../../../pyste/index.html" target="_top">Pyste</a>,
+        take a look at the <tt class="literal">--multiple</tt> option, that generates the
+        wrappers in various files as demonstrated here.
+      </p>
+<p class="blurb">
+        <span class="inlinemediaobject"><img src="../images/note.png" alt="note"></span> This method is useful too if you are getting the error
+        message <span class="emphasis"><em>"fatal error C1204:Compiler limit:internal structure
+        overflow"</em></span> when compiling a large source file, as explained
+        in the <a href="../../../../v2/faq.html#c1204" target="_top">FAQ</a>.
+      </p>
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>

doc/tutorial/doc/tutorial.qbk

@@ -1100,7 +1100,7 @@ overloaded functions in one-shot:
 
 Then...
 
-    .def("foo", foo, foo_overloads());
+    .def("foo", (void(*)(bool, int, char))0, foo_overloads());
 
 Notice though that we have a situation now where we have a minimum of zero
 (0) arguments and a maximum of 3 arguments.

include/boost/python.hpp

@@ -1,73 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 http://www.boost.org/libs/python for documentation.
-
-#ifndef PYTHON_DWA2002810_HPP
-# define PYTHON_DWA2002810_HPP
-
-# include <boost/python/args.hpp>
-# include <boost/python/args_fwd.hpp>
-# include <boost/python/back_reference.hpp>
-# include <boost/python/bases.hpp>
-# include <boost/python/borrowed.hpp>
-# include <boost/python/call.hpp>
-# include <boost/python/call_method.hpp>
-# include <boost/python/class.hpp>
-# include <boost/python/copy_const_reference.hpp>
-# include <boost/python/copy_non_const_reference.hpp>
-# include <boost/python/data_members.hpp>
-# include <boost/python/def.hpp>
-# include <boost/python/default_call_policies.hpp>
-# include <boost/python/dict.hpp>
-# include <boost/python/docstring_options.hpp>
-# include <boost/python/enum.hpp>
-# include <boost/python/errors.hpp>
-# include <boost/python/exception_translator.hpp>
-# include <boost/python/exec.hpp>
-# include <boost/python/extract.hpp>
-# include <boost/python/handle.hpp>
-# include <boost/python/has_back_reference.hpp>
-# include <boost/python/implicit.hpp>
-# include <boost/python/init.hpp>
-# include <boost/python/import.hpp>
-# include <boost/python/instance_holder.hpp>
-# include <boost/python/iterator.hpp>
-# include <boost/python/list.hpp>
-# include <boost/python/long.hpp>
-# include <boost/python/lvalue_from_pytype.hpp>
-# include <boost/python/make_constructor.hpp>
-# include <boost/python/make_function.hpp>
-# include <boost/python/manage_new_object.hpp>
-# include <boost/python/module.hpp>
-# include <boost/python/numeric.hpp>
-# include <boost/python/object.hpp>
-# include <boost/python/object_protocol.hpp>
-# include <boost/python/object_protocol_core.hpp>
-# include <boost/python/opaque_pointer_converter.hpp>
-# include <boost/python/operators.hpp>
-# include <boost/python/other.hpp>
-# include <boost/python/overloads.hpp>
-# include <boost/python/pointee.hpp>
-# include <boost/python/pure_virtual.hpp>
-# include <boost/python/ptr.hpp>
-# include <boost/python/reference_existing_object.hpp>
-# include <boost/python/register_ptr_to_python.hpp>
-# include <boost/python/return_arg.hpp>
-# include <boost/python/return_internal_reference.hpp>
-# include <boost/python/return_opaque_pointer.hpp>
-# include <boost/python/return_value_policy.hpp>
-# include <boost/python/scope.hpp>
-# include <boost/python/self.hpp>
-# include <boost/python/slice_nil.hpp>
-# include <boost/python/str.hpp>
-# include <boost/python/to_python_converter.hpp>
-# include <boost/python/to_python_indirect.hpp>
-# include <boost/python/to_python_value.hpp>
-# include <boost/python/tuple.hpp>
-# include <boost/python/type_id.hpp>
-# include <boost/python/with_custodian_and_ward.hpp>
-
-#endif // PYTHON_DWA2002810_HPP

include/boost/python/arg_from_python.hpp

@@ -1,76 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 ARG_FROM_PYTHON_DWA2002128_HPP
-# define ARG_FROM_PYTHON_DWA2002128_HPP
-
-# include <boost/python/detail/prefix.hpp>
-# include <boost/python/converter/arg_from_python.hpp>
-# if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400)) \
-    || BOOST_WORKAROUND(BOOST_INTEL_WIN, BOOST_TESTED_AT(800))
-# include <boost/type_traits/remove_cv.hpp>
-#endif
-
-namespace boost { namespace python { 
-
-template <class T>
-struct arg_from_python
-    : converter::select_arg_from_python<
-# if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400)) \
-    || BOOST_WORKAROUND(BOOST_INTEL_WIN, BOOST_TESTED_AT(800))
-          typename boost::remove_cv<T>::type
-# else
-          T
-# endif 
-      >::type
-{
-    typedef typename converter::select_arg_from_python<
-# if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400)) \
-    || BOOST_WORKAROUND(BOOST_INTEL_WIN, BOOST_TESTED_AT(800))
-          typename boost::remove_cv<T>::type
-# else
-          T
-# endif 
-        >::type base;
-    
-    arg_from_python(PyObject*);
-};
-
-// specialization for PyObject*
-template <>
-struct arg_from_python<PyObject*>
-{
-    typedef PyObject* result_type;
-    
-    arg_from_python(PyObject* p) : m_source(p) {}
-    bool convertible() const { return true; }
-    PyObject* operator()() const { return m_source; }
- private:
-    PyObject* m_source;
-};
-
-template <>
-struct arg_from_python<PyObject* const&>
-{
-    typedef PyObject* const& result_type;
-    
-    arg_from_python(PyObject* p) : m_source(p) {}
-    bool convertible() const { return true; }
-    PyObject*const& operator()() const { return m_source; }
- private:
-    PyObject* m_source;
-};
-
-//
-// implementations
-//
-template <class T>
-inline arg_from_python<T>::arg_from_python(PyObject* source)
-    : base(source)
-{
-}
-
-}} // namespace boost::python
-
-#endif // ARG_FROM_PYTHON_DWA2002128_HPP

include/boost/python/args.hpp

@@ -1,175 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 KEYWORDS_DWA2002323_HPP
-# define KEYWORDS_DWA2002323_HPP
-
-# include <boost/python/detail/prefix.hpp>
-
-# include <boost/python/args_fwd.hpp>
-# include <boost/config.hpp>
-# include <boost/python/detail/preprocessor.hpp>
-# include <boost/python/detail/type_list.hpp>
-
-# include <boost/type_traits/is_reference.hpp>
-# include <boost/type_traits/remove_reference.hpp>
-# include <boost/type_traits/remove_cv.hpp>
-
-# include <boost/preprocessor/enum_params.hpp>
-# include <boost/preprocessor/repeat.hpp>
-# include <boost/preprocessor/facilities/intercept.hpp>
-# include <boost/preprocessor/iteration/local.hpp>
-
-# include <boost/python/detail/mpl_lambda.hpp>
-# include <boost/python/object_core.hpp>
-
-# include <boost/mpl/bool.hpp>
-
-# include <cstddef>
-# include <algorithm>
-
-namespace boost { namespace python {
-
-typedef detail::keywords<1> arg;
-typedef arg arg_; // gcc 2.96 workaround
-
-namespace detail
-{
-  template <std::size_t nkeywords>
-  struct keywords_base
-  {
-      BOOST_STATIC_CONSTANT(std::size_t, size = nkeywords);
-      
-      keyword_range range() const
-      {
-          return keyword_range(elements, elements + nkeywords);
-      }
-
-      keyword elements[nkeywords];
-
-      keywords<nkeywords+1>
-      operator,(python::arg const &k) const;
-
-      keywords<nkeywords + 1>
-      operator,(char const *name) const;
-  };
-  
-  template <std::size_t nkeywords>
-  struct keywords : keywords_base<nkeywords>
-  {
-  };
-
-  template <>
-  struct keywords<1> : keywords_base<1>
-  {
-      explicit keywords(char const *name)
-      {
-          elements[0].name = name;
-      }
-    
-      template <class T>
-      python::arg& operator=(T const& value)
-      {
-          object z(value);
-          elements[0].default_value = handle<>(python::borrowed(object(value).ptr()));
-          return *this;
-      }
-    
-      operator detail::keyword const&() const
-      {
-          return elements[0];
-      }
-  };
-
-  template <std::size_t nkeywords>
-  inline
-  keywords<nkeywords+1>
-  keywords_base<nkeywords>::operator,(python::arg const &k) const
-  {
-      keywords<nkeywords> const& l = *static_cast<keywords<nkeywords> const*>(this);
-      python::detail::keywords<nkeywords+1> res;
-      std::copy(l.elements, l.elements+nkeywords, res.elements);
-      res.elements[nkeywords] = k.elements[0];
-      return res;
-  }
-
-  template <std::size_t nkeywords>
-  inline
-  keywords<nkeywords + 1>
-  keywords_base<nkeywords>::operator,(char const *name) const
-  {
-      return this->operator,(python::arg(name));
-  }
-
-# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-  template<typename T>
-  struct is_keywords
-  {
-      BOOST_STATIC_CONSTANT(bool, value = false); 
-  };
-
-  template<std::size_t nkeywords>
-  struct is_keywords<keywords<nkeywords> >
-  {
-      BOOST_STATIC_CONSTANT(bool, value = true);
-  };
-  template <class T>
-  struct is_reference_to_keywords
-  {
-      BOOST_STATIC_CONSTANT(bool, is_ref = is_reference<T>::value);
-      typedef typename remove_reference<T>::type deref;
-      typedef typename remove_cv<deref>::type key_t;
-      BOOST_STATIC_CONSTANT(bool, is_key = is_keywords<key_t>::value);
-      BOOST_STATIC_CONSTANT(bool, value = (is_ref & is_key));
-      
-      typedef mpl::bool_<value> type;
-      BOOST_PYTHON_MPL_LAMBDA_SUPPORT(1,is_reference_to_keywords,(T))
-  };
-# else 
-  typedef char (&yes_keywords_t)[1];
-  typedef char (&no_keywords_t)[2];
-      
-  no_keywords_t is_keywords_test(...);
-
-  template<std::size_t nkeywords>
-  yes_keywords_t is_keywords_test(void (*)(keywords<nkeywords>&));
-
-  template<std::size_t nkeywords>
-  yes_keywords_t is_keywords_test(void (*)(keywords<nkeywords> const&));
-
-  template<typename T>
-  class is_reference_to_keywords
-  {
-   public:
-      BOOST_STATIC_CONSTANT(
-          bool, value = (
-              sizeof(detail::is_keywords_test( (void (*)(T))0 ))
-              == sizeof(detail::yes_keywords_t)));
-
-      typedef mpl::bool_<value> type;
-      BOOST_PYTHON_MPL_LAMBDA_SUPPORT(1,is_reference_to_keywords,(T))
-  };
-# endif 
-}
-
-inline detail::keywords<1> args(char const* name)
-{ 
-    return detail::keywords<1>(name);
-}
-
-#  define BOOST_PYTHON_ASSIGN_NAME(z, n, _) result.elements[n].name = name##n;
-#  define BOOST_PP_LOCAL_MACRO(n)                                               \
-inline detail::keywords<n> args(BOOST_PP_ENUM_PARAMS_Z(1, n, char const* name)) \
-{                                                                               \
-    detail::keywords<n> result;                                                 \
-    BOOST_PP_REPEAT_1(n, BOOST_PYTHON_ASSIGN_NAME, _)                           \
-    return result;                                                              \
-}
-#  define BOOST_PP_LOCAL_LIMITS (2, BOOST_PYTHON_MAX_ARITY)
-#  include BOOST_PP_LOCAL_ITERATE()
-
-}} // namespace boost::python
-
-
-# endif // KEYWORDS_DWA2002323_HPP

include/boost/python/args_fwd.hpp

@@ -1,52 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 ARGS_FWD_DWA2002927_HPP
-# define ARGS_FWD_DWA2002927_HPP
-
-# include <boost/python/detail/prefix.hpp>
-
-# include <boost/python/handle.hpp>
-# include <boost/config.hpp>
-# include <cstddef>
-# include <utility>
-
-namespace boost { namespace python { 
-
-namespace detail
-{
-  struct keyword
-  {
-      keyword(char const* name_=0)
-       : name(name_)
-      {}
-      
-      char const* name;
-      handle<> default_value;
-  };
-  
-  template <std::size_t nkeywords = 0> struct keywords;
-  
-  typedef std::pair<keyword const*, keyword const*> keyword_range;
-  
-  template <>
-  struct keywords<0>
-  {
-      BOOST_STATIC_CONSTANT(std::size_t, size = 0);
-      static keyword_range range() { return keyword_range(); }
-  };
-
-  namespace error
-  {
-    template <int keywords, int function_args>
-    struct more_keywords_than_function_arguments
-    {
-        typedef char too_many_keywords[keywords > function_args ? -1 : 1];
-    };
-  }
-}
-
-}} // namespace boost::python
-
-#endif // ARGS_FWD_DWA2002927_HPP

include/boost/python/back_reference.hpp

@@ -1,102 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 BACK_REFERENCE_DWA2002510_HPP
-# define BACK_REFERENCE_DWA2002510_HPP
-
-# include <boost/python/detail/prefix.hpp>
-
-# include <boost/python/object_fwd.hpp>
-# include <boost/python/detail/dependent.hpp>
-# include <boost/python/detail/raw_pyobject.hpp>
-
-namespace boost { namespace python { 
-
-template <class T>
-struct back_reference
-{
- private: // types
-    typedef typename detail::dependent<object,T>::type source_t;
- public:
-    typedef T type;
-    
-    back_reference(PyObject*, T);
-    source_t const& source() const;
-    T get() const;
- private:
-    source_t m_source;
-    T m_value;
-};
-
-# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template<typename T>
-class is_back_reference
-{
- public:
-    BOOST_STATIC_CONSTANT(bool, value = false); 
-};
-
-template<typename T>
-class is_back_reference<back_reference<T> >
-{
- public:
-    BOOST_STATIC_CONSTANT(bool, value = true);
-};
-
-# else // no partial specialization
-
-}} // namespace boost::python
-
-#include <boost/type.hpp>
-
-namespace boost { namespace python {
-
-namespace detail
-{
-  typedef char (&yes_back_reference_t)[1];
-  typedef char (&no_back_reference_t)[2];
-      
-  no_back_reference_t is_back_reference_test(...);
-
-  template<typename T>
-  yes_back_reference_t is_back_reference_test(boost::type< back_reference<T> >);
-}
-
-template<typename T>
-class is_back_reference
-{
- public:
-    BOOST_STATIC_CONSTANT(
-        bool, value = (
-            sizeof(detail::is_back_reference_test(boost::type<T>()))
-            == sizeof(detail::yes_back_reference_t)));
-};
-
-# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-//
-// implementations
-//
-template <class T>
-back_reference<T>::back_reference(PyObject* p, T x)
-    : m_source(detail::borrowed_reference(p))
-      , m_value(x)
-{
-}
-
-template <class T>
-typename back_reference<T>::source_t const& back_reference<T>::source() const
-{
-    return m_source;
-}
-
-template <class T>
-T back_reference<T>::get() const
-{
-    return m_value;
-}
-
-}} // namespace boost::python
-
-#endif // BACK_REFERENCE_DWA2002510_HPP

include/boost/python/base_type_traits.hpp

@@ -1,43 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 BASE_TYPE_TRAITS_DWA2002614_HPP
-# define BASE_TYPE_TRAITS_DWA2002614_HPP
-
-# include <boost/python/detail/prefix.hpp>
-
-namespace boost { namespace python { 
-
-namespace detail
-{
-  struct unspecialized {};
-}
-
-// Derive from unspecialized so we can detect whether traits are
-// specialized
-template <class T> struct base_type_traits
-  : detail::unspecialized
-{};
-
-template <>
-struct base_type_traits<PyObject>
-{
-    typedef PyObject type;
-};
-
-template <>
-struct base_type_traits<PyTypeObject>
-{
-    typedef PyObject type;
-};
-
-template <>
-struct base_type_traits<PyMethodObject>
-{
-    typedef PyObject type;
-};
-
-}} // namespace boost::python
-
-#endif // BASE_TYPE_TRAITS_DWA2002614_HPP

include/boost/python/bases.hpp

@@ -1,68 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 BASES_DWA2002321_HPP
-# define BASES_DWA2002321_HPP
-
-# include <boost/python/detail/prefix.hpp>
-# include <boost/type_traits/object_traits.hpp>
-# include <boost/python/detail/type_list.hpp>
-# include <boost/mpl/if.hpp>
-# include <boost/mpl/bool.hpp>
-# include <boost/preprocessor/enum_params_with_a_default.hpp>
-# include <boost/preprocessor/enum_params.hpp>
-
-namespace boost { namespace python { 
-
-# define BOOST_PYTHON_BASE_PARAMS BOOST_PP_ENUM_PARAMS_Z(1, BOOST_PYTHON_MAX_BASES, Base)
-
-  // A type list for specifying bases
-  template < BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PYTHON_MAX_BASES, typename Base, mpl::void_) >
-  struct bases : detail::type_list< BOOST_PYTHON_BASE_PARAMS >::type
-  {};
-
-  namespace detail
-  {
-# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-    template <class T> struct specifies_bases
-        : mpl::false_
-    {
-    };
-    
-    template < BOOST_PP_ENUM_PARAMS_Z(1, BOOST_PYTHON_MAX_BASES, class Base) >
-    struct specifies_bases< bases< BOOST_PYTHON_BASE_PARAMS > >
-        : mpl::true_
-    {
-    };
-# else
-    template < BOOST_PP_ENUM_PARAMS(BOOST_PYTHON_MAX_BASES, class Base) >
-    static char is_bases_helper(bases< BOOST_PYTHON_BASE_PARAMS > const&);
-    
-    static char (& is_bases_helper(...) )[256];
-
-    template <class T>
-    struct specifies_bases
-    {
-     private:
-        static typename add_reference<T>::type make();
-        BOOST_STATIC_CONSTANT(bool, non_ref = !is_reference<T>::value);
-     public:
-        BOOST_STATIC_CONSTANT(bool, value = non_ref & (sizeof(is_bases_helper(make())) == 1));
-        typedef mpl::bool_<value> type;
-    };
-# endif
-    template <class T, class Prev = bases<> >
-    struct select_bases
-        : mpl::if_<
-                specifies_bases<T>
-                , T
-                , Prev
-          >
-    {
-    };
-  }
-# undef BOOST_PYTHON_BASE_PARAMS
-}} // namespace boost::python
-
-#endif // BASES_DWA2002321_HPP

include/boost/python/borrowed.hpp

@@ -1,21 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 BORROWED_DWA2002614_HPP
-# define BORROWED_DWA2002614_HPP
-
-# include <boost/python/detail/prefix.hpp>
-# include <boost/python/detail/borrowed_ptr.hpp>
-
-namespace boost { namespace python { 
-
-template <class T>
-inline python::detail::borrowed<T>* borrowed(T* p)
-{
-    return (detail::borrowed<T>*)p;
-}
-    
-}} // namespace boost::python
-
-#endif // BORROWED_DWA2002614_HPP

include/boost/python/call.hpp

@@ -1,79 +0,0 @@
-#if !defined(BOOST_PP_IS_ITERATING)
-
-// Copyright David Abrahams 2002.
-// 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 CALL_DWA2002411_HPP
-#  define CALL_DWA2002411_HPP
-
-# include <boost/python/detail/prefix.hpp>
-
-#  include <boost/type.hpp>
-
-#  include <boost/python/converter/arg_to_python.hpp>
-#  include <boost/python/converter/return_from_python.hpp>
-#  include <boost/python/detail/preprocessor.hpp>
-#  include <boost/python/detail/void_return.hpp>
-
-#  include <boost/preprocessor/comma_if.hpp>
-#  include <boost/preprocessor/iterate.hpp>
-#  include <boost/preprocessor/repeat.hpp>
-#  include <boost/preprocessor/debug/line.hpp>
-#  include <boost/preprocessor/repetition/enum_trailing_params.hpp>
-#  include <boost/preprocessor/repetition/enum_binary_params.hpp>
-
-namespace boost { namespace python {
-
-# define BOOST_PYTHON_FAST_ARG_TO_PYTHON_GET(z, n, _) \
-    , converter::arg_to_python<A##n>(a##n).get()
-
-#  define BOOST_PP_ITERATION_PARAMS_1 (3, (0, BOOST_PYTHON_MAX_ARITY, <boost/python/call.hpp>))
-#  include BOOST_PP_ITERATE()
-
-#  undef BOOST_PYTHON_FAST_ARG_TO_PYTHON_GET
-
-}} // namespace boost::python
-
-# endif // CALL_DWA2002411_HPP
-
-#elif BOOST_PP_ITERATION_DEPTH() == 1
-# if !(BOOST_WORKAROUND(__MWERKS__, > 0x3100)                      \
-        && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3201)))
-#  line BOOST_PP_LINE(__LINE__, call.hpp)
-# endif
-
-# define N BOOST_PP_ITERATION()
-
-template <
-    class R
-    BOOST_PP_ENUM_TRAILING_PARAMS_Z(1, N, class A)
-    >
-typename detail::returnable<R>::type
-call(PyObject* callable
-    BOOST_PP_COMMA_IF(N) BOOST_PP_ENUM_BINARY_PARAMS_Z(1, N, A, const& a)
-    , boost::type<R>* = 0
-    )
-{
-    PyObject* const result = 
-        PyEval_CallFunction(
-            callable
-            , const_cast<char*>("(" BOOST_PP_REPEAT_1ST(N, BOOST_PYTHON_FIXED, "O") ")")
-            BOOST_PP_REPEAT_1ST(N, BOOST_PYTHON_FAST_ARG_TO_PYTHON_GET, nil)
-            );
-    
-    // This conversion *must not* be done in the same expression as
-    // the call, because, in the special case where the result is a
-    // reference a Python object which was created by converting a C++
-    // argument for passing to PyEval_CallFunction, its reference
-    // count will be 2 until the end of the full expression containing
-    // the conversion, and that interferes with dangling
-    // pointer/reference detection.
-    converter::return_from_python<R> converter;
-    return converter(result);
-}
-
-# undef N
-
-#endif

include/boost/python/call_method.hpp

@@ -1,79 +0,0 @@
-#if !defined(BOOST_PP_IS_ITERATING)
-
-// Copyright David Abrahams 2002.
-// 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 CALL_METHOD_DWA2002411_HPP
-#  define CALL_METHOD_DWA2002411_HPP
-
-# include <boost/python/detail/prefix.hpp>
-
-#  include <boost/type.hpp>
-
-#  include <boost/python/converter/arg_to_python.hpp>
-#  include <boost/python/converter/return_from_python.hpp>
-#  include <boost/python/detail/preprocessor.hpp>
-#  include <boost/python/detail/void_return.hpp>
-
-#  include <boost/preprocessor/comma_if.hpp>
-#  include <boost/preprocessor/iterate.hpp>
-#  include <boost/preprocessor/repeat.hpp>
-#  include <boost/preprocessor/debug/line.hpp>
-#  include <boost/preprocessor/repetition/enum_trailing_params.hpp>
-#  include <boost/preprocessor/repetition/enum_binary_params.hpp>
-
-namespace boost { namespace python {
-
-# define BOOST_PYTHON_FAST_ARG_TO_PYTHON_GET(z, n, _) \
-    , converter::arg_to_python<A##n>(a##n).get()
-
-# define BOOST_PP_ITERATION_PARAMS_1 (3, (0, BOOST_PYTHON_MAX_ARITY, <boost/python/call_method.hpp>))
-# include BOOST_PP_ITERATE()
-
-# undef BOOST_PYTHON_FAST_ARG_TO_PYTHON_GET
-
-}} // namespace boost::python
-
-# endif // CALL_METHOD_DWA2002411_HPP
-
-#elif 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)
-# endif 
-
-# define N BOOST_PP_ITERATION()
-
-template <
-    class R
-    BOOST_PP_ENUM_TRAILING_PARAMS_Z(1, N, class A)
-    >
-typename detail::returnable<R>::type
-call_method(PyObject* self, char const* name
-    BOOST_PP_COMMA_IF(N) BOOST_PP_ENUM_BINARY_PARAMS_Z(1, N, A, const& a)
-    , boost::type<R>* = 0
-    )
-{
-    PyObject* const result = 
-        PyEval_CallMethod(
-            self
-            , const_cast<char*>(name)
-            , const_cast<char*>("(" BOOST_PP_REPEAT_1ST(N, BOOST_PYTHON_FIXED, "O") ")")
-            BOOST_PP_REPEAT_1ST(N, BOOST_PYTHON_FAST_ARG_TO_PYTHON_GET, nil)
-            );
-    
-    // This conversion *must not* be done in the same expression as
-    // the call, because, in the special case where the result is a
-    // reference a Python object which was created by converting a C++
-    // argument for passing to PyEval_CallFunction, its reference
-    // count will be 2 until the end of the full expression containing
-    // the conversion, and that interferes with dangling
-    // pointer/reference detection.
-    converter::return_from_python<R> converter;
-    return converter(result);
-}
-
-# undef N
-
-#endif // BOOST_PP_IS_ITERATING

include/boost/python/cast.hpp

@@ -1,106 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 CAST_DWA200269_HPP
-# define CAST_DWA200269_HPP
-
-# include <boost/python/detail/prefix.hpp>
-
-# include <boost/type_traits/same_traits.hpp>
-# include <boost/type_traits/cv_traits.hpp>
-# include <boost/type.hpp>
-# include <boost/python/base_type_traits.hpp>
-# include <boost/python/detail/convertible.hpp>
-
-namespace boost { namespace python { 
-
-namespace detail
-{
-  template <class Source, class Target> inline Target* upcast_impl(Source*, Target*);
-  
-  template <class Source, class Target>
-  inline Target* upcast(Source* p, yes_convertible, no_convertible, Target*)
-  {
-      return p;
-  }
-
-  template <class Source, class Target>
-  inline Target* upcast(Source* p, no_convertible, no_convertible, Target*)
-  {
-      typedef typename base_type_traits<Source>::type base;
-      
-      return detail::upcast_impl((base*)p, (Target*)0);
-  }
-
-  template <bool is_same = true>
-  struct upcaster
-  {
-      template <class T>
-      static inline T* execute(T* x, T*) { return x; }
-  };
-  
-  template <>
-  struct upcaster<false>
-  {
-      template <class Source, class Target>
-      static inline Target* execute(Source* x, Target*)
-      {
-          return detail::upcast(
-              x, detail::convertible<Target*>::check(x)
-              , detail::convertible<Source*>::check((Target*)0)
-              , (Target*)0);
-      }
-  };
-
-
-  template <class Target, class Source>
-  inline Target* downcast(Source* p, yes_convertible)
-  {
-      return static_cast<Target*>(p);
-  }
-
-  template <class Target, class Source>
-  inline Target* downcast(Source* p, no_convertible, boost::type<Target>* = 0)
-  {
-      typedef typename base_type_traits<Source>::type base;
-      return (Target*)detail::downcast<base>(p, convertible<Source*>::check((base*)0));
-  }
-
-  template <class T>
-  inline void assert_castable(boost::type<T>* = 0)
-  {
-      typedef char must_be_a_complete_type[sizeof(T)];
-  }
-
-  template <class Source, class Target>
-  inline Target* upcast_impl(Source* x, Target*)
-  {
-      typedef typename add_cv<Source>::type src_t;
-      typedef typename add_cv<Target>::type target_t;
-      bool const same = is_same<src_t,target_t>::value;
-      
-      return detail::upcaster<same>::execute(x, (Target*)0);
-  }
-}
-
-template <class Target, class Source>
-inline Target* upcast(Source* x, Target* = 0)
-{
-    detail::assert_castable<Source>();
-    detail::assert_castable<Target>();
-    return detail::upcast_impl(x, (Target*)0);
-    
-}
-
-template <class Target, class Source>
-inline Target* downcast(Source* x, Target* = 0)
-{
-    detail::assert_castable<Source>();
-    detail::assert_castable<Target>();
-    return detail::downcast<Target>(x, detail::convertible<Source*>::check((Target*)0));
-}
-
-}} // namespace boost::python
-
-#endif // CAST_DWA200269_HPP

include/boost/python/class.hpp

@@ -1,654 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 CLASS_DWA200216_HPP
-# define CLASS_DWA200216_HPP
-
-# include <boost/python/detail/prefix.hpp>
-
-# include <boost/noncopyable.hpp>
-
-# include <boost/python/class_fwd.hpp>
-# include <boost/python/object/class.hpp>
-
-# include <boost/python/object.hpp>
-# include <boost/python/type_id.hpp>
-# include <boost/python/data_members.hpp>
-# include <boost/python/make_function.hpp>
-# include <boost/python/signature.hpp>
-# include <boost/python/init.hpp>
-# include <boost/python/args_fwd.hpp>
-
-# include <boost/python/object/class_metadata.hpp>
-# include <boost/python/object/pickle_support.hpp>
-# include <boost/python/object/add_to_namespace.hpp>
-
-# include <boost/python/detail/overloads_fwd.hpp>
-# include <boost/python/detail/operator_id.hpp>
-# include <boost/python/detail/def_helper.hpp>
-# include <boost/python/detail/force_instantiate.hpp>
-# include <boost/python/detail/unwrap_type_id.hpp>
-# include <boost/python/detail/unwrap_wrapper.hpp>
-
-# include <boost/type_traits/is_same.hpp>
-# include <boost/type_traits/is_member_function_pointer.hpp>
-# include <boost/type_traits/is_polymorphic.hpp>
-
-# include <boost/mpl/size.hpp>
-# include <boost/mpl/for_each.hpp>
-# include <boost/mpl/bool.hpp>
-# include <boost/mpl/not.hpp>
-
-# include <boost/detail/workaround.hpp>
-
-# if BOOST_WORKAROUND(__MWERKS__, <= 0x3004)                        \
-    /* pro9 reintroduced the bug */                                 \
-    || (BOOST_WORKAROUND(__MWERKS__, > 0x3100)                      \
-        && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3201)))   \
-    || BOOST_WORKAROUND(__GNUC__, < 3)
-
-#  define BOOST_PYTHON_NO_MEMBER_POINTER_ORDERING 1
-
-# endif
-
-# ifdef BOOST_PYTHON_NO_MEMBER_POINTER_ORDERING
-#  include <boost/mpl/and.hpp>
-#  include <boost/type_traits/is_member_pointer.hpp>
-# endif
-
-namespace boost { namespace python {
-
-template <class DerivedVisitor> class def_visitor;
-
-enum no_init_t { no_init };
-
-namespace detail
-{
-  // This function object is used with mpl::for_each to write the id
-  // of the type a pointer to which is passed as its 2nd compile-time
-  // argument. into the iterator pointed to by its runtime argument
-  struct write_type_id
-  {
-      write_type_id(type_info**p) : p(p) {}
-
-      // Here's the runtime behavior
-      template <class T>
-      void operator()(T*) const
-      {
-          *(*p)++ = type_id<T>();
-      }
-
-      type_info** p;
-  };
-
-  template <class T>
-  struct is_data_member_pointer
-      : mpl::and_<
-            is_member_pointer<T>
-          , mpl::not_<is_member_function_pointer<T> >
-        >
-  {};
-  
-# ifdef BOOST_PYTHON_NO_MEMBER_POINTER_ORDERING
-#  define BOOST_PYTHON_DATA_MEMBER_HELPER(D) , detail::is_data_member_pointer<D>()
-#  define BOOST_PYTHON_YES_DATA_MEMBER , mpl::true_
-#  define BOOST_PYTHON_NO_DATA_MEMBER , mpl::false_
-# elif defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-#  define BOOST_PYTHON_DATA_MEMBER_HELPER(D) , 0
-#  define BOOST_PYTHON_YES_DATA_MEMBER , int
-#  define BOOST_PYTHON_NO_DATA_MEMBER , ...
-# else 
-#  define BOOST_PYTHON_DATA_MEMBER_HELPER(D)
-#  define BOOST_PYTHON_YES_DATA_MEMBER
-#  define BOOST_PYTHON_NO_DATA_MEMBER
-# endif
-  
-  namespace error
-  {
-    //
-    // A meta-assertion mechanism which prints nice error messages and
-    // backtraces on lots of compilers. Usage:
-    //
-    //      assertion<C>::failed
-    //
-    // where C is an MPL metafunction class
-    //
-    
-    template <class C> struct assertion_failed { };
-    template <class C> struct assertion_ok { typedef C failed; };
-
-    template <class C>
-    struct assertion
-        : mpl::if_<C, assertion_ok<C>, assertion_failed<C> >::type
-    {};
-
-    //
-    // Checks for validity of arguments used to define virtual
-    // functions with default implementations.
-    //
-    
-    template <class Default>
-    void not_a_derived_class_member(Default) {}
-    
-    template <class T, class Fn>
-    struct virtual_function_default
-    {
-        template <class Default>
-        static void
-        must_be_derived_class_member(Default const&)
-        {
-            typedef typename assertion<mpl::not_<is_same<Default,Fn> > >::failed test0;
-# if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407)
-            typedef typename assertion<is_polymorphic<T> >::failed test1;
-# endif 
-            typedef typename assertion<is_member_function_pointer<Fn> >::failed test2;
-            not_a_derived_class_member<Default>(Fn());
-        }
-    };
-  }
-}
-
-// This is the primary mechanism through which users will expose
-// C++ classes to Python.
-template <
-    class W // class being wrapped
-    , class X1 // = detail::not_specified
-    , class X2 // = detail::not_specified
-    , class X3 // = detail::not_specified
-    >
-class class_ : public objects::class_base
-{
- public: // types
-    typedef objects::class_base base;
-    typedef class_<W,X1,X2,X3> self;
-    typedef typename objects::class_metadata<W,X1,X2,X3> metadata;
-    typedef W wrapped_type;
-    
- private: // types
-
-    // A helper class which will contain an array of id objects to be
-    // passed to the base class constructor
-    struct id_vector
-    {
-        typedef typename metadata::bases bases;
-        
-        id_vector()
-        {
-            // Stick the derived class id into the first element of the array
-            ids[0] = detail::unwrap_type_id((W*)0, (W*)0);
-
-            // Write the rest of the elements into succeeding positions.
-            type_info* p = ids + 1;
-            mpl::for_each(detail::write_type_id(&p), (bases*)0, (add_pointer<mpl::_>*)0);
-        }
-
-        BOOST_STATIC_CONSTANT(
-            std::size_t, size = mpl::size<bases>::value + 1);
-        type_info ids[size];
-    };
-    friend struct id_vector;
-
- public: // constructors
-    
-    // Construct with the class name, with or without docstring, and default __init__() function
-    class_(char const* name, char const* doc = 0);
-
-    // Construct with class name, no docstring, and an uncallable __init__ function
-    class_(char const* name, no_init_t);
-
-    // Construct with class name, docstring, and an uncallable __init__ function
-    class_(char const* name, char const* doc, no_init_t);
-
-    // Construct with class name and init<> function
-    template <class DerivedT>
-    inline class_(char const* name, init_base<DerivedT> const& i)
-        : base(name, id_vector::size, id_vector().ids)
-    {
-        this->initialize(i);
-    }
-
-    // Construct with class name, docstring and init<> function
-    template <class DerivedT>
-    inline class_(char const* name, char const* doc, init_base<DerivedT> const& i)
-        : base(name, id_vector::size, id_vector().ids, doc)
-    {
-        this->initialize(i);
-    }
-
- public: // member functions
-    
-    // Generic visitation
-    template <class Derived>
-    self& def(def_visitor<Derived> const& visitor)
-    {
-        visitor.visit(*this);
-        return *this;
-    }
-
-    // Wrap a member function or a non-member function which can take
-    // a T, T cv&, or T cv* as its first parameter, a callable
-    // python object, or a generic visitor.
-    template <class F>
-    self& def(char const* name, F f)
-    {
-        this->def_impl(
-            detail::unwrap_wrapper((W*)0)
-          , name, f, detail::def_helper<char const*>(0), &f);
-        return *this;
-    }
-
-    template <class A1, class A2>
-    self& def(char const* name, A1 a1, A2 const& a2)
-    {
-        this->def_maybe_overloads(name, a1, a2, &a2);
-        return *this;
-    }
-
-    template <class Fn, class A1, class A2>
-    self& def(char const* name, Fn fn, A1 const& a1, A2 const& a2)
-    {
-        //  The arguments are definitely:
-        //      def(name, function, policy, doc_string)
-        //      def(name, function, doc_string, policy)
-
-        this->def_impl(
-            detail::unwrap_wrapper((W*)0)
-          , name, fn
-          , detail::def_helper<A1,A2>(a1,a2)
-          , &fn);
-
-        return *this;
-    }
-
-    template <class Fn, class A1, class A2, class A3>
-    self& def(char const* name, Fn fn, A1 const& a1, A2 const& a2, A3 const& a3)
-    {
-        this->def_impl(
-            detail::unwrap_wrapper((W*)0)
-          , name, fn
-          , detail::def_helper<A1,A2,A3>(a1,a2,a3)
-          , &fn);
-
-        return *this;
-    }
-
-    //
-    // Data member access
-    //
-    template <class D>
-    self& def_readonly(char const* name, D const& d, char const* doc=0)
-    {
-        return this->def_readonly_impl(name, d, doc BOOST_PYTHON_DATA_MEMBER_HELPER(D));
-    }
-
-    template <class D>
-    self& def_readwrite(char const* name, D const& d, char const* doc=0)
-    {
-        return this->def_readwrite_impl(name, d, doc BOOST_PYTHON_DATA_MEMBER_HELPER(D));
-    }
-    
-    template <class D>
-    self& def_readonly(char const* name, D& d, char const* doc=0)
-    {
-        return this->def_readonly_impl(name, d, doc BOOST_PYTHON_DATA_MEMBER_HELPER(D));
-    }
-
-    template <class D>
-    self& def_readwrite(char const* name, D& d, char const* doc=0)
-    {
-        return this->def_readwrite_impl(name, d, doc BOOST_PYTHON_DATA_MEMBER_HELPER(D));
-    }
-
-    // Property creation
-# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-    template <class Get>
-    self& add_property(char const* name, Get fget, char const* docstr = 0)
-    {
-        base::add_property(name, this->make_getter(fget), docstr);
-        return *this;
-    }
-
-    template <class Get, class Set>
-    self& add_property(char const* name, Get fget, Set fset, char const* docstr = 0)
-    {
-        base::add_property(
-            name, this->make_getter(fget), this->make_setter(fset), docstr);
-        return *this;
-    }
-# else
- private:
-    template <class Get>
-    self& add_property_impl(char const* name, Get fget, char const* docstr, int)
-    {
-        base::add_property(name, this->make_getter(fget), docstr);
-        return *this;
-    }
-
-    template <class Get, class Set>
-    self& add_property_impl(char const* name, Get fget, Set fset, ...)
-    {
-        base::add_property(
-            name, this->make_getter(fget), this->make_setter(fset), 0);
-        return *this;
-    }
-
- public:    
-    template <class Get>
-    self& add_property(char const* name, Get fget)
-    {
-        base::add_property(name, this->make_getter(fget), 0);
-        return *this;
-    }
-
-    template <class Get, class DocStrOrSet>
-    self& add_property(char const* name, Get fget, DocStrOrSet docstr_or_set)
-    {
-        this->add_property_impl(name, this->make_getter(fget), docstr_or_set, 0);
-        return *this;
-    }
-
-    template <class Get, class Set>
-    self&
-    add_property(char const* name, Get fget, Set fset, char const* docstr)
-    {
-        base::add_property(
-            name, this->make_getter(fget), this->make_setter(fset), docstr);
-        return *this;
-    }
-# endif
-        
-    template <class Get>
-    self& add_static_property(char const* name, Get fget)
-    {
-        base::add_static_property(name, object(fget));
-        return *this;
-    }
-
-    template <class Get, class Set>
-    self& add_static_property(char const* name, Get fget, Set fset)
-    {
-        base::add_static_property(name, object(fget), object(fset));
-        return *this;
-    }
-        
-    template <class U>
-    self& setattr(char const* name, U const& x)
-    {
-        this->base::setattr(name, object(x));
-        return *this;
-    }
-
-    // Pickle support
-    template <typename PickleSuiteType>
-    self& def_pickle(PickleSuiteType const& x)
-    {
-      error_messages::must_be_derived_from_pickle_suite(x);
-      detail::pickle_suite_finalize<PickleSuiteType>::register_(
-        *this,
-        &PickleSuiteType::getinitargs,
-        &PickleSuiteType::getstate,
-        &PickleSuiteType::setstate,
-        PickleSuiteType::getstate_manages_dict());
-      return *this;
-    }
-
-    self& enable_pickling()
-    {
-        this->base::enable_pickling_(false);
-        return *this;
-    }
-
-    self& staticmethod(char const* name)
-    {
-        this->make_method_static(name);
-        return *this;
-    }
- private: // helper functions
-
-    // Builds a method for this class around the given [member]
-    // function pointer or object, appropriately adjusting the type of
-    // the first signature argument so that if f is a member of a
-    // (possibly not wrapped) base class of T, an lvalue argument of
-    // type T will be required.
-    //
-    // @group PropertyHelpers {
-    template <class F>
-    object make_getter(F f)
-    {
-        typedef typename api::is_object_operators<F>::type is_obj_or_proxy;
-        
-        return this->make_fn_impl(
-            detail::unwrap_wrapper((W*)0)
-          , f, is_obj_or_proxy(), (char*)0, detail::is_data_member_pointer<F>()
-        );
-    }
-    
-    template <class F>
-    object make_setter(F f)
-    {
-        typedef typename api::is_object_operators<F>::type is_obj_or_proxy;
-        
-        return this->make_fn_impl(
-            detail::unwrap_wrapper((W*)0)
-          , f, is_obj_or_proxy(), (int*)0, detail::is_data_member_pointer<F>()
-        );
-    }
-    
-    template <class T, class F>
-    object make_fn_impl(T*, F const& f, mpl::false_, void*, mpl::false_)
-    {
-        return python::make_function(f, default_call_policies(), detail::get_signature(f, (T*)0));
-    }
-
-    template <class T, class D, class B>
-    object make_fn_impl(T*, D B::*pm_, mpl::false_, char*, mpl::true_)
-    {
-        D T::*pm = pm_;
-        return python::make_getter(pm);
-    }
-
-    template <class T, class D, class B>
-    object make_fn_impl(T*, D B::*pm_, mpl::false_, int*, mpl::true_)
-    {
-        D T::*pm = pm_;
-        return python::make_setter(pm);
-    }
-
-    template <class T, class F>
-    object make_fn_impl(T*, F const& x, mpl::true_, void*, mpl::false_)
-    {
-        return x;
-    }
-    // }
-    
-    template <class D, class B>
-    self& def_readonly_impl(
-        char const* name, D B::*pm_, char const* doc BOOST_PYTHON_YES_DATA_MEMBER)
-    {
-        return this->add_property(name, pm_, doc);
-    }
-
-    template <class D, class B>
-    self& def_readwrite_impl(
-        char const* name, D B::*pm_, char const* doc BOOST_PYTHON_YES_DATA_MEMBER)
-    {
-        return this->add_property(name, pm_, pm_, doc);
-    }
-
-    template <class D>
-    self& def_readonly_impl(
-        char const* name, D& d, char const* BOOST_PYTHON_NO_DATA_MEMBER)
-    {
-        return this->add_static_property(name, python::make_getter(d));
-    }
-
-    template <class D>
-    self& def_readwrite_impl(
-        char const* name, D& d, char const* BOOST_PYTHON_NO_DATA_MEMBER)
-    {
-        return this->add_static_property(name, python::make_getter(d), python::make_setter(d));
-    }
-
-    template <class DefVisitor>
-    inline void initialize(DefVisitor const& i)
-    {
-        metadata::register_(); // set up runtime metadata/conversions
-        
-        typedef typename metadata::holder holder;
-        this->set_instance_size( objects::additional_instance_size<holder>::value );
-        
-        this->def(i);
-    }
-    
-    inline void initialize(no_init_t)
-    {
-        metadata::register_(); // set up runtime metadata/conversions
-        this->def_no_init();
-    }
-    
-    //
-    // These two overloads discriminate between def() as applied to a
-    // generic visitor and everything else.
-    //
-    // @group def_impl {
-    template <class T, class Helper, class LeafVisitor, class Visitor>
-    inline void def_impl(
-        T*
-      , char const* name
-      , LeafVisitor
-      , Helper const& helper
-      , def_visitor<Visitor> const* v
-    )
-    {
-        v->visit(*this, name,  helper);
-    }
-
-    template <class T, class Fn, class Helper>
-    inline void def_impl(
-        T*
-      , char const* name
-      , Fn fn
-      , Helper const& helper
-      , ...
-    )
-    {
-        objects::add_to_namespace(
-            *this
-          , name
-          , make_function(
-                fn
-              , helper.policies()
-              , helper.keywords()
-              , detail::get_signature(fn, (T*)0)
-            )
-          , helper.doc()
-        );
-
-        this->def_default(name, fn, helper, mpl::bool_<Helper::has_default_implementation>());
-    }
-    // }
-
-    //
-    // These two overloads handle the definition of default
-    // implementation overloads for virtual functions. The second one
-    // handles the case where no default implementation was specified.
-    //
-    // @group def_default {
-    template <class Fn, class Helper>
-    inline void def_default(
-        char const* name
-        , Fn
-        , Helper const& helper
-        , mpl::bool_<true>)
-    {
-        detail::error::virtual_function_default<W,Fn>::must_be_derived_class_member(
-            helper.default_implementation());
-            
-        objects::add_to_namespace(
-            *this, name,
-            make_function(
-                helper.default_implementation(), helper.policies(), helper.keywords())
-            );
-    }
-    
-    template <class Fn, class Helper>
-    inline void def_default(char const*, Fn, Helper const&, mpl::bool_<false>)
-    { }
-    // }
-    
-    //
-    // These two overloads discriminate between def() as applied to
-    // regular functions and def() as applied to the result of
-    // BOOST_PYTHON_FUNCTION_OVERLOADS(). The final argument is used to
-    // discriminate.
-    //
-    // @group def_maybe_overloads {
-    template <class OverloadsT, class SigT>
-    void def_maybe_overloads(
-        char const* name
-        , SigT sig
-        , OverloadsT const& overloads
-        , detail::overloads_base const*)
-
-    {
-        //  convert sig to a type_list (see detail::get_signature in signature.hpp)
-        //  before calling detail::define_with_defaults.
-        detail::define_with_defaults(
-            name, overloads, *this, detail::get_signature(sig));
-    }
-
-    template <class Fn, class A1>
-    void def_maybe_overloads(
-        char const* name
-        , Fn fn
-        , A1 const& a1
-        , ...)
-    {
-        this->def_impl(
-            detail::unwrap_wrapper((W*)0)
-          , name
-          , fn
-          , detail::def_helper<A1>(a1)
-          , &fn
-        );
-
-    }
-    // }
-};
-
-
-//
-// implementations
-//
-
-template <class W, class X1, class X2, class X3>
-inline class_<W,X1,X2,X3>::class_(char const* name, char const* doc)
-    : base(name, id_vector::size, id_vector().ids, doc)
-{
-    this->initialize(init<>());
-//  select_holder::assert_default_constructible();
-}
-
-template <class W, class X1, class X2, class X3>
-inline class_<W,X1,X2,X3>::class_(char const* name, no_init_t)
-    : base(name, id_vector::size, id_vector().ids)
-{
-    this->initialize(no_init);
-}
-
-template <class W, class X1, class X2, class X3>
-inline class_<W,X1,X2,X3>::class_(char const* name, char const* doc, no_init_t)
-    : base(name, id_vector::size, id_vector().ids, doc)
-{
-    this->initialize(no_init);
-}
-
-}} // namespace boost::python
-
-# undef BOOST_PYTHON_DATA_MEMBER_HELPER
-# undef BOOST_PYTHON_YES_DATA_MEMBER
-# undef BOOST_PYTHON_NO_DATA_MEMBER
-# undef BOOST_PYTHON_NO_MEMBER_POINTER_ORDERING
-
-#endif // CLASS_DWA200216_HPP

include/boost/python/class_fwd.hpp

@@ -1,24 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 CLASS_FWD_DWA200222_HPP
-# define CLASS_FWD_DWA200222_HPP
-
-# include <boost/python/detail/prefix.hpp>
-# include <boost/python/detail/not_specified.hpp>
-
-namespace boost { namespace python { 
-
-template <
-    class T // class being wrapped
-    // arbitrarily-ordered optional arguments. Full qualification needed for MSVC6
-    , class X1 = ::boost::python::detail::not_specified
-    , class X2 = ::boost::python::detail::not_specified
-    , class X3 = ::boost::python::detail::not_specified
-    >
-class class_;
-
-}} // namespace boost::python
-
-#endif // CLASS_FWD_DWA200222_HPP

include/boost/python/converter/arg_from_python.hpp

@@ -1,336 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 ARG_FROM_PYTHON_DWA2002127_HPP
-# define ARG_FROM_PYTHON_DWA2002127_HPP
-
-# include <boost/python/detail/prefix.hpp>
-# include <boost/python/converter/from_python.hpp>
-# include <boost/python/detail/indirect_traits.hpp>
-# include <boost/type_traits/transform_traits.hpp>
-# include <boost/type_traits/cv_traits.hpp>
-# include <boost/python/converter/rvalue_from_python_data.hpp>
-# include <boost/mpl/eval_if.hpp>
-# include <boost/mpl/if.hpp>
-# include <boost/mpl/identity.hpp>
-# include <boost/mpl/and.hpp>
-# include <boost/mpl/or.hpp>
-# include <boost/mpl/not.hpp>
-# include <boost/python/converter/registry.hpp>
-# include <boost/python/converter/registered.hpp>
-# include <boost/python/converter/registered_pointee.hpp>
-# include <boost/python/detail/void_ptr.hpp>
-# include <boost/python/back_reference.hpp>
-# include <boost/python/detail/referent_storage.hpp>
-# include <boost/python/converter/obj_mgr_arg_from_python.hpp>
-
-namespace boost { namespace python
-{
-  template <class T> struct arg_from_python;
-}}
-
-// This header defines Python->C++ function argument converters,
-// parametrized on the argument type.
-
-namespace boost { namespace python { namespace converter {
-
-//
-// lvalue converters
-//
-//   These require that an lvalue of the type U is stored somewhere in
-//   the Python object being converted.
-
-// Used when T == U*const&
-template <class T>
-struct pointer_cref_arg_from_python
-{
-    typedef T result_type;
-    
-    pointer_cref_arg_from_python(PyObject*);
-    T operator()() const;
-    bool convertible() const;
-    
- private: // storage for a U*
-    // needed because not all compilers will let us declare U* as the
-    // return type of operator() -- we return U*const& instead
-    typename python::detail::referent_storage<T>::type m_result;
-};
-
-// Base class for pointer and reference converters
-struct arg_lvalue_from_python_base
-{
- public: // member functions
-    arg_lvalue_from_python_base(void* result);
-    bool convertible() const;
-    
- protected: // member functions
-    void*const& result() const;
-    
- private: // data members
-    void* m_result;
-};
-
-// Used when T == U* 
-template <class T>
-struct pointer_arg_from_python : arg_lvalue_from_python_base
-{
-    typedef T result_type;
-    
-    pointer_arg_from_python(PyObject*);
-    T operator()() const;
-};
-
-// Used when T == U& and (T != V const& or T == W volatile&)
-template <class T>
-struct reference_arg_from_python : arg_lvalue_from_python_base
-{
-    typedef T result_type;
-    
-    reference_arg_from_python(PyObject*);
-    T operator()() const;
-};
-
-// ===================
-
-//
-// rvalue converters
-//
-//   These require only that an object of type T can be created from
-//   the given Python object, but not that the T object exist
-//   somewhere in storage.
-//
-
-// Used when T is a plain value (non-pointer, non-reference) type or
-// a (non-volatile) const reference to a plain value type.
-template <class T>
-struct arg_rvalue_from_python
-{
-    typedef typename boost::add_reference<
-        T
-        // We can't add_const here, or it would be impossible to pass
-        // auto_ptr<U> args from Python to C++
-    >::type result_type;
-    
-    arg_rvalue_from_python(PyObject*);
-    bool convertible() const;
-
-# if BOOST_MSVC < 1301 || _MSC_FULL_VER > 13102196
-    typename arg_rvalue_from_python<T>::
-# endif 
-    result_type operator()();
-    
- private:
-    rvalue_from_python_data<result_type> m_data;
-    PyObject* m_source;
-};
-
-
-// ==================
-
-// Converts to a (PyObject*,T) bundle, for when you need a reference
-// back to the Python object
-template <class T>
-struct back_reference_arg_from_python
-    : boost::python::arg_from_python<typename T::type>
-{
-    typedef T result_type;
-    
-    back_reference_arg_from_python(PyObject*);
-    T operator()();
- private:
-    typedef boost::python::arg_from_python<typename T::type> base;
-    PyObject* m_source;
-};
-
-
-// ==================
-
-template <class C, class T, class F>
-struct if_2
-{
-    typedef typename mpl::eval_if<C, mpl::identity<T>, F>::type type;
-};
-
-// This metafunction selects the appropriate arg_from_python converter
-// type for an argument of type T.
-template <class T>
-struct select_arg_from_python
-{
-    typedef typename if_2<
-        is_object_manager<T>
-      , object_manager_value_arg_from_python<T>
-      , if_2<
-            is_reference_to_object_manager<T>
-          , object_manager_ref_arg_from_python<T>
-          , if_2<
-                is_pointer<T>
-              , pointer_arg_from_python<T>
-              , if_2<
-                    mpl::and_<
-                        indirect_traits::is_reference_to_pointer<T>
-                      , indirect_traits::is_reference_to_const<T>
-                      , mpl::not_<indirect_traits::is_reference_to_volatile<T> >
-                        >
-                  , pointer_cref_arg_from_python<T>
-                  , if_2<
-                        mpl::or_<
-                            indirect_traits::is_reference_to_non_const<T>
-                          , indirect_traits::is_reference_to_volatile<T>
-                        >
-                      , reference_arg_from_python<T>
-                      , mpl::if_<
-                            boost::python::is_back_reference<T>
-                          , back_reference_arg_from_python<T>
-                          , arg_rvalue_from_python<T>
-                        >
-                    >
-                >
-            >
-        >
-    >::type type;
-};
-
-// ==================
-
-//
-// implementations
-//
-
-// arg_lvalue_from_python_base
-//
-inline arg_lvalue_from_python_base::arg_lvalue_from_python_base(void* result)
-    : m_result(result)
-{
-}
-
-inline bool arg_lvalue_from_python_base::convertible() const
-{
-    return m_result != 0;
-}
-
-inline void*const& arg_lvalue_from_python_base::result() const
-{
-    return m_result;
-}
-
-// pointer_cref_arg_from_python
-//
-namespace detail
-{
-  // null_ptr_reference -- a function returning a reference to a null
-  // pointer of type U. Needed so that extractors for T*const& can
-  // convert Python's None.
-  template <class T>
-  struct null_ptr_owner
-  {
-      static T value;
-  };
-  template <class T> T null_ptr_owner<T>::value = 0;
-  
-  template <class U>
-  inline U& null_ptr_reference(U&(*)())
-  {
-      return null_ptr_owner<U>::value;
-  }
-}
-
-template <class T>
-inline pointer_cref_arg_from_python<T>::pointer_cref_arg_from_python(PyObject* p)
-{
-    // T == U*const&: store a U* in the m_result storage. Nonzero
-    // indicates success.  If find returns nonzero, it's a pointer to
-    // a U object.
-    python::detail::write_void_ptr_reference(
-        m_result.bytes
-        , p == Py_None ? p : converter::get_lvalue_from_python(p, registered_pointee<T>::converters)
-        , (T(*)())0);
-}
-
-template <class T>
-inline bool pointer_cref_arg_from_python<T>::convertible() const
-{
-    return python::detail::void_ptr_to_reference(m_result.bytes, (T(*)())0) != 0;
-}
-template <class T>
-inline T pointer_cref_arg_from_python<T>::operator()() const
-{
-    return (*(void**)m_result.bytes == Py_None)  // None ==> 0
-        ? detail::null_ptr_reference((T(*)())0)
-        // Otherwise, return a U*const& to the m_result storage.
-        : python::detail::void_ptr_to_reference(m_result.bytes, (T(*)())0);
-}
-
-// pointer_arg_from_python
-//
-template <class T>
-inline pointer_arg_from_python<T>::pointer_arg_from_python(PyObject* p)
-    : arg_lvalue_from_python_base(
-        p == Py_None ? p : converter::get_lvalue_from_python(p, registered_pointee<T>::converters))
-{
-}
-
-template <class T>
-inline T pointer_arg_from_python<T>::operator()() const
-{
-    return (result() == Py_None) ? 0 : T(result());
-}
-
-// reference_arg_from_python
-//
-template <class T>
-inline reference_arg_from_python<T>::reference_arg_from_python(PyObject* p)
-    : arg_lvalue_from_python_base(converter::get_lvalue_from_python(p,registered<T>::converters))
-{
-}
-
-template <class T>
-inline T reference_arg_from_python<T>::operator()() const
-{
-    return python::detail::void_ptr_to_reference(result(), (T(*)())0);
-}
-
-
-// arg_rvalue_from_python
-//
-template <class T>
-inline arg_rvalue_from_python<T>::arg_rvalue_from_python(PyObject* obj)
-    : m_data(converter::rvalue_from_python_stage1(obj, registered<T>::converters))
-    , m_source(obj)
-{
-}
-
-template <class T>
-inline bool arg_rvalue_from_python<T>::convertible() const
-{
-    return m_data.stage1.convertible != 0;
-}
-
-template <class T>
-inline typename arg_rvalue_from_python<T>::result_type
-arg_rvalue_from_python<T>::operator()()
-{
-    if (m_data.stage1.construct != 0)
-        m_data.stage1.construct(m_source, &m_data.stage1);
-    
-    return python::detail::void_ptr_to_reference(m_data.stage1.convertible, (result_type(*)())0);
-}
-
-// back_reference_arg_from_python
-//
-template <class T>
-back_reference_arg_from_python<T>::back_reference_arg_from_python(PyObject* x)
-  : base(x), m_source(x)
-{
-}
-
-template <class T>
-inline T
-back_reference_arg_from_python<T>::operator()()
-{
-    return T(m_source, base::operator()());
-}
-
-}}} // namespace boost::python::converter
-
-#endif // ARG_FROM_PYTHON_DWA2002127_HPP

include/boost/python/converter/arg_to_python.hpp

@@ -1,261 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 ARG_TO_PYTHON_DWA200265_HPP
-# define ARG_TO_PYTHON_DWA200265_HPP
-
-# include <boost/python/ptr.hpp>
-# include <boost/python/tag.hpp>
-# include <boost/python/to_python_indirect.hpp>
-
-# include <boost/python/converter/registered.hpp>
-# include <boost/python/converter/registered_pointee.hpp>
-# include <boost/python/converter/arg_to_python_base.hpp>
-# include <boost/python/converter/shared_ptr_to_python.hpp>
-// Bring in specializations
-# include <boost/python/converter/builtin_converters.hpp>
-
-# include <boost/python/object/function_handle.hpp>
-
-# include <boost/python/base_type_traits.hpp>
-
-# include <boost/python/detail/indirect_traits.hpp>
-# include <boost/python/detail/convertible.hpp>
-# include <boost/python/detail/string_literal.hpp>
-# include <boost/python/detail/value_is_shared_ptr.hpp>
-
-# include <boost/type_traits/cv_traits.hpp>
-# include <boost/type_traits/composite_traits.hpp>
-# include <boost/type_traits/function_traits.hpp>
-
-
-# include <boost/mpl/or.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-template <class T> struct is_object_manager;
-
-namespace detail
-{
-  template <class T>
-  struct function_arg_to_python : handle<>
-  {
-      function_arg_to_python(T const& x);
-  };
-
-  template <class T>
-  struct reference_arg_to_python : handle<>
-  {
-      reference_arg_to_python(T& x);
-   private:
-      static PyObject* get_object(T& x);
-  };
-
-  template <class T>
-  struct shared_ptr_arg_to_python : handle<>
-  {
-      shared_ptr_arg_to_python(T const& x);
-   private:
-      static PyObject* get_object(T& x);
-  };
-
-  template <class T>
-  struct value_arg_to_python : arg_to_python_base
-  {
-      // Throw an exception if the conversion can't succeed
-      value_arg_to_python(T const&);
-  };
-
-  template <class Ptr>
-  struct pointer_deep_arg_to_python : arg_to_python_base
-  {
-      // Throw an exception if the conversion can't succeed
-      pointer_deep_arg_to_python(Ptr);
-  };
-
-  template <class Ptr>
-  struct pointer_shallow_arg_to_python : handle<>
-  {
-      // Throw an exception if the conversion can't succeed
-      pointer_shallow_arg_to_python(Ptr);
-   private:
-      static PyObject* get_object(Ptr p);
-  };
-
-  // Convert types that manage a Python object to_python
-  template <class T>
-  struct object_manager_arg_to_python
-  {
-      object_manager_arg_to_python(T const& x) : m_src(x) {}
-      
-      PyObject* get() const
-      {
-          return python::upcast<PyObject>(get_managed_object(m_src, tag));
-      }
-      
-   private:
-      T const& m_src;
-  };
-
-  template <class T>
-  struct select_arg_to_python
-  {
-      typedef typename unwrap_reference<T>::type unwrapped_referent;
-      typedef typename unwrap_pointer<T>::type unwrapped_ptr;
-
-      typedef typename mpl::if_<
-          // Special handling for char const[N]; interpret them as char
-          // const* for the sake of conversion
-          python::detail::is_string_literal<T const>
-        , arg_to_python<char const*>
-
-        , typename mpl::if_<
-              python::detail::value_is_shared_ptr<T>
-            , shared_ptr_arg_to_python<T>
-      
-            , typename mpl::if_<
-                mpl::or_<
-                    is_function<T>
-                  , indirect_traits::is_pointer_to_function<T>
-                  , is_member_function_pointer<T>
-                >
-                , function_arg_to_python<T>
-
-                , typename mpl::if_<
-                      is_object_manager<T>
-                    , object_manager_arg_to_python<T>
-
-                    , typename mpl::if_<
-                          is_pointer<T>
-                        , pointer_deep_arg_to_python<T>
-
-                        , typename mpl::if_<
-                              is_pointer_wrapper<T>
-                            , pointer_shallow_arg_to_python<unwrapped_ptr>
-
-                            , typename mpl::if_<
-                                  is_reference_wrapper<T>
-                                , reference_arg_to_python<unwrapped_referent>
-                                , value_arg_to_python<T>
-                              >::type
-                          >::type
-                      >::type
-                  >::type
-              >::type
-          >::type
-      >::type
-      
-      type;
-  };
-}
-
-template <class T>
-struct arg_to_python
-    : detail::select_arg_to_python<T>::type
-{
-    typedef typename detail::select_arg_to_python<T>::type base;
- public: // member functions
-    // Throw an exception if the conversion can't succeed
-    arg_to_python(T const& x);
-};
-
-//
-// implementations
-//
-namespace detail
-{
-  // reject_raw_object_ptr -- cause a compile-time error if the user
-  // should pass a raw Python object pointer
-  using python::detail::yes_convertible;
-  using python::detail::no_convertible;
-  using python::detail::unspecialized;
-  
-  template <class T> struct cannot_convert_raw_PyObject;
-
-  template <class T, class Convertibility>
-  struct reject_raw_object_helper
-  {
-      static void error(Convertibility)
-      {
-          cannot_convert_raw_PyObject<T*>::to_python_use_handle_instead();
-      }
-      static void error(...) {}
-  };
-  
-  template <class T>
-  inline void reject_raw_object_ptr(T*)
-  {
-      reject_raw_object_helper<T,yes_convertible>::error(
-          python::detail::convertible<PyObject const volatile*>::check((T*)0));
-      
-      typedef typename remove_cv<T>::type value_type;
-      
-      reject_raw_object_helper<T,no_convertible>::error(
-          python::detail::convertible<unspecialized*>::check(
-              (base_type_traits<value_type>*)0
-              ));
-  }
-  // ---------
-      
-  template <class T>
-  inline function_arg_to_python<T>::function_arg_to_python(T const& x)
-      : handle<>(python::objects::make_function_handle(x))
-  {
-  }
-
-  template <class T>
-  inline value_arg_to_python<T>::value_arg_to_python(T const& x)
-      : arg_to_python_base(&x, registered<T>::converters)
-  {
-  }
-
-  template <class Ptr>
-  inline pointer_deep_arg_to_python<Ptr>::pointer_deep_arg_to_python(Ptr x)
-      : arg_to_python_base(x, registered_pointee<Ptr>::converters)
-  {
-      detail::reject_raw_object_ptr((Ptr)0);
-  }
-
-  template <class T>
-  inline PyObject* reference_arg_to_python<T>::get_object(T& x)
-  {
-      to_python_indirect<T&,python::detail::make_reference_holder> convert;
-      return convert(x);
-  }
-
-  template <class T>
-  inline reference_arg_to_python<T>::reference_arg_to_python(T& x)
-      : handle<>(reference_arg_to_python<T>::get_object(x))
-  {
-  }
-
-  template <class T>
-  inline shared_ptr_arg_to_python<T>::shared_ptr_arg_to_python(T const& x)
-      : handle<>(shared_ptr_to_python(x))
-  {
-  }
-
-  template <class Ptr>
-  inline pointer_shallow_arg_to_python<Ptr>::pointer_shallow_arg_to_python(Ptr x)
-      : handle<>(pointer_shallow_arg_to_python<Ptr>::get_object(x))
-  {
-      detail::reject_raw_object_ptr((Ptr)0);
-  }
-
-  template <class Ptr>
-  inline PyObject* pointer_shallow_arg_to_python<Ptr>::get_object(Ptr x)
-  {
-      to_python_indirect<Ptr,python::detail::make_reference_holder> convert;
-      return convert(x);
-  }
-}
-
-template <class T>
-inline arg_to_python<T>::arg_to_python(T const& x)
-    : base(x)
-{}
-
-}}} // namespace boost::python::converter
-
-#endif // ARG_TO_PYTHON_DWA200265_HPP

include/boost/python/converter/arg_to_python_base.hpp

@@ -1,32 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 ARG_TO_PYTHON_BASE_DWA200237_HPP
-# define ARG_TO_PYTHON_BASE_DWA200237_HPP
-# include <boost/python/handle.hpp>
-
-namespace boost { namespace python { namespace converter {
-
-struct registration;
-
-namespace detail
-{
-  struct BOOST_PYTHON_DECL arg_to_python_base
-# if !defined(BOOST_MSVC) || BOOST_MSVC <= 1300 || _MSC_FULL_VER > 13102179
-      : handle<>
-# endif 
-  {
-      arg_to_python_base(void const volatile* source, registration const&);
-# if defined(BOOST_MSVC) && BOOST_MSVC > 1300 && _MSC_FULL_VER <= 13102179
-      PyObject* get() const { return m_ptr.get(); }
-      PyObject* release() { return m_ptr.release(); }
-   private:
-      handle<> m_ptr;
-# endif 
-  };
-}
-
-}}} // namespace boost::python::converter
-
-#endif // ARG_TO_PYTHON_BASE_DWA200237_HPP

include/boost/python/converter/as_to_python_function.hpp

@@ -1,46 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 AS_TO_PYTHON_FUNCTION_DWA2002121_HPP
-# define AS_TO_PYTHON_FUNCTION_DWA2002121_HPP
-# include <boost/python/converter/to_python_function_type.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-// Given a typesafe to_python conversion function, produces a
-// to_python_function_t which can be registered in the usual way.
-template <class T, class ToPython>
-struct as_to_python_function
-{
-    // Assertion functions used to prevent wrapping of converters
-    // which take non-const reference parameters. The T* argument in
-    // the first overload ensures it isn't used in case T is a
-    // reference.
-    template <class U>
-    static void convert_function_must_take_value_or_const_reference(U(*)(T), int, T* = 0) {}
-    template <class U>
-    static void convert_function_must_take_value_or_const_reference(U(*)(T const&), long ...) {}
-        
-    static PyObject* convert(void const* x)
-    {
-        convert_function_must_take_value_or_const_reference(&ToPython::convert, 1L);
-        
-        // Yes, the const_cast below opens a hole in const-correctness,
-        // but it's needed to convert auto_ptr<U> to python.
-        //
-        // How big a hole is it?  It allows ToPython::convert() to be
-        // a function which modifies its argument. The upshot is that
-        // client converters applied to const objects may invoke
-        // undefined behavior. The damage, however, is limited by the
-        // use of the assertion function. Thus, the only way this can
-        // modify its argument is if T is an auto_ptr-like type. There
-        // is still a const-correctness hole w.r.t. auto_ptr<U> const,
-        // but c'est la vie.
-        return ToPython::convert(*const_cast<T*>(static_cast<T const*>(x)));
-    }
-};
-
-}}} // namespace boost::python::converter
-
-#endif // AS_TO_PYTHON_FUNCTION_DWA2002121_HPP

include/boost/python/converter/builtin_converters.hpp

@@ -1,144 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 BUILTIN_CONVERTERS_DWA2002124_HPP
-# define BUILTIN_CONVERTERS_DWA2002124_HPP
-# include <boost/python/detail/prefix.hpp>
-# include <boost/python/detail/none.hpp>
-# include <boost/python/handle.hpp>
-# include <boost/implicit_cast.hpp>
-# include <string>
-# include <complex>
-# include <boost/limits.hpp>
-
-// Since all we can use to decide how to convert an object to_python
-// is its C++ type, there can be only one such converter for each
-// type. Therefore, for built-in conversions we can bypass registry
-// lookups using explicit specializations of arg_to_python and
-// result_to_python.
-
-namespace boost { namespace python {
-
-namespace converter
-{
-  template <class T> struct arg_to_python;
-  BOOST_PYTHON_DECL PyObject* do_return_to_python(char);
-  BOOST_PYTHON_DECL PyObject* do_return_to_python(char const*);
-  BOOST_PYTHON_DECL PyObject* do_return_to_python(PyObject*);
-  BOOST_PYTHON_DECL PyObject* do_arg_to_python(PyObject*);
-}
-
-// Provide specializations of to_python_value
-template <class T> struct to_python_value;
-
-namespace detail
-{
-  // Since there's no registry lookup, always report the existence of
-  // a converter.
-  struct builtin_to_python
-  {
-      // This information helps make_getter() decide whether to try to
-      // return an internal reference or not. I don't like it much,
-      // but it will have to serve for now.
-      BOOST_STATIC_CONSTANT(bool, uses_registry = false);
-  };
-}
-
-// Use expr to create the PyObject corresponding to x
-# define BOOST_PYTHON_RETURN_TO_PYTHON_BY_VALUE(T, expr)        \
-    template <> struct to_python_value<T&>                      \
-        : detail::builtin_to_python                             \
-    {                                                           \
-        inline PyObject* operator()(T const& x) const           \
-        {                                                       \
-            return (expr);                                      \
-        }                                                       \
-    };                                                          \
-    template <> struct to_python_value<T const&>                \
-        : detail::builtin_to_python                             \
-    {                                                           \
-        inline PyObject* operator()(T const& x) const           \
-        {                                                       \
-            return (expr);                                      \
-        }                                                       \
-    };
-
-# define BOOST_PYTHON_ARG_TO_PYTHON_BY_VALUE(T, expr)   \
-    namespace converter                                 \
-    {                                                   \
-      template <> struct arg_to_python< T >             \
-        : handle<>                                      \
-      {                                                 \
-          arg_to_python(T const& x)                     \
-            : python::handle<>(expr) {}                 \
-      };                                                \
-    } 
-
-// Specialize argument and return value converters for T using expr
-# define BOOST_PYTHON_TO_PYTHON_BY_VALUE(T, expr)       \
-        BOOST_PYTHON_RETURN_TO_PYTHON_BY_VALUE(T,expr)  \
-        BOOST_PYTHON_ARG_TO_PYTHON_BY_VALUE(T,expr)
-
-// Specialize converters for signed and unsigned T to Python Int
-# define BOOST_PYTHON_TO_INT(T)                                         \
-    BOOST_PYTHON_TO_PYTHON_BY_VALUE(signed T, ::PyInt_FromLong(x))      \
-    BOOST_PYTHON_TO_PYTHON_BY_VALUE(                                    \
-        unsigned T                                                      \
-        , static_cast<unsigned long>(x) > static_cast<unsigned long>(   \
-                (std::numeric_limits<long>::max)())                     \
-        ? ::PyLong_FromUnsignedLong(x)                                  \
-        : ::PyInt_FromLong(x))
-
-// Bool is not signed.
-#if PY_VERSION_HEX >= 0x02030000
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(bool, ::PyBool_FromLong(x))
-#else
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(bool, ::PyInt_FromLong(x))
-#endif
-  
-// note: handles signed char and unsigned char, but not char (see below)
-BOOST_PYTHON_TO_INT(char)
-
-BOOST_PYTHON_TO_INT(short)
-BOOST_PYTHON_TO_INT(int)
-BOOST_PYTHON_TO_INT(long)
-
-// using Python's macro instead of Boost's - we don't seem to get the
-// config right all the time.
-# ifdef HAVE_LONG_LONG 
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(signed BOOST_PYTHON_LONG_LONG, ::PyLong_FromLongLong(x))
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(unsigned BOOST_PYTHON_LONG_LONG, ::PyLong_FromUnsignedLongLong(x))
-# endif
-    
-# undef BOOST_TO_PYTHON_INT
-
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(char, converter::do_return_to_python(x))
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(char const*, converter::do_return_to_python(x))
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::string, ::PyString_FromStringAndSize(x.data(),implicit_cast<int>(x.size())))
-#if defined(Py_USING_UNICODE) && !defined(BOOST_NO_STD_WSTRING)
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::wstring, ::PyUnicode_FromWideChar(x.data(),implicit_cast<int>(x.size())))
-# endif 
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(float, ::PyFloat_FromDouble(x))
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(double, ::PyFloat_FromDouble(x))
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(long double, ::PyFloat_FromDouble(x))
-BOOST_PYTHON_RETURN_TO_PYTHON_BY_VALUE(PyObject*, converter::do_return_to_python(x))
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::complex<float>, ::PyComplex_FromDoubles(x.real(), x.imag()))
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::complex<double>, ::PyComplex_FromDoubles(x.real(), x.imag()))
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::complex<long double>, ::PyComplex_FromDoubles(x.real(), x.imag()))
-
-# undef BOOST_PYTHON_RETURN_TO_PYTHON_BY_VALUE
-# undef BOOST_PYTHON_ARG_TO_PYTHON_BY_VALUE
-# undef BOOST_PYTHON_TO_PYTHON_BY_VALUE
-# undef BOOST_PYTHON_TO_INT
-    
-namespace converter
-{ 
-
-  void initialize_builtin_converters();
-
-}
-
-}} // namespace boost::python::converter
-
-#endif // BUILTIN_CONVERTERS_DWA2002124_HPP

include/boost/python/converter/constructor_function.hpp

@@ -1,17 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 CONSTRUCTOR_FUNCTION_DWA200278_HPP
-# define CONSTRUCTOR_FUNCTION_DWA200278_HPP
-
-namespace boost { namespace python { namespace converter { 
-
-// Declares the type of functions used to construct C++ objects for
-// rvalue from_python conversions.
-struct rvalue_from_python_stage1_data;
-typedef void (*constructor_function)(PyObject* source, rvalue_from_python_stage1_data*);
-
-}}} // namespace boost::python::converter
-
-#endif // CONSTRUCTOR_FUNCTION_DWA200278_HPP

include/boost/python/converter/context_result_converter.hpp

@@ -1,17 +0,0 @@
-// Copyright David Abrahams 2003.
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-#ifndef CONTEXT_RESULT_CONVERTER_DWA2003917_HPP
-# define CONTEXT_RESULT_CONVERTER_DWA2003917_HPP
-
-namespace boost { namespace python { namespace converter { 
-
-// A ResultConverter base class used to indicate that this result
-// converter should be constructed with the original Python argument
-// list.
-struct context_result_converter {};
-
-}}} // namespace boost::python::converter
-
-#endif // CONTEXT_RESULT_CONVERTER_DWA2003917_HPP

include/boost/python/converter/convertible_function.hpp

@@ -1,14 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 CONVERTIBLE_FUNCTION_DWA200278_HPP
-# define CONVERTIBLE_FUNCTION_DWA200278_HPP
-
-namespace boost { namespace python { namespace converter { 
-
-typedef void* (*convertible_function)(PyObject*);
-    
-}}} // namespace boost::python::converter
-
-#endif // CONVERTIBLE_FUNCTION_DWA200278_HPP

include/boost/python/converter/from_python.hpp

@@ -1,41 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 FIND_FROM_PYTHON_DWA2002223_HPP
-# define FIND_FROM_PYTHON_DWA2002223_HPP
-
-# include <boost/python/detail/prefix.hpp>
-# include <boost/python/converter/rvalue_from_python_data.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-struct registration;
-
-
-BOOST_PYTHON_DECL void* get_lvalue_from_python(
-    PyObject* source, registration const&);
-
-BOOST_PYTHON_DECL bool implicit_rvalue_convertible_from_python(
-    PyObject* source, registration const&);
-
-BOOST_PYTHON_DECL rvalue_from_python_stage1_data rvalue_from_python_stage1(
-    PyObject* source, registration const&);
-
-BOOST_PYTHON_DECL void* rvalue_from_python_stage2(
-    PyObject* source, rvalue_from_python_stage1_data&, registration const&);
-
-BOOST_PYTHON_DECL void* rvalue_result_from_python(
-    PyObject*, rvalue_from_python_stage1_data&);
-
-BOOST_PYTHON_DECL void* reference_result_from_python(PyObject*, registration const&);
-BOOST_PYTHON_DECL void* pointer_result_from_python(PyObject*, registration const&);
-
-BOOST_PYTHON_DECL void void_result_from_python(PyObject*);
-
-BOOST_PYTHON_DECL void throw_no_pointer_from_python(PyObject*, registration const&);
-BOOST_PYTHON_DECL void throw_no_reference_from_python(PyObject*, registration const&);
-
-}}} // namespace boost::python::converter
-
-#endif // FIND_FROM_PYTHON_DWA2002223_HPP

include/boost/python/converter/obj_mgr_arg_from_python.hpp

@@ -1,121 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 OBJ_MGR_ARG_FROM_PYTHON_DWA2002628_HPP
-# define OBJ_MGR_ARG_FROM_PYTHON_DWA2002628_HPP
-
-# include <boost/python/detail/prefix.hpp>
-# include <boost/python/detail/referent_storage.hpp>
-# include <boost/python/detail/destroy.hpp>
-# include <boost/python/detail/construct.hpp>
-# include <boost/python/converter/object_manager.hpp>
-# include <boost/python/detail/raw_pyobject.hpp>
-# include <boost/python/tag.hpp>
-
-//
-// arg_from_python converters for Python type wrappers, to be used as
-// base classes for specializations.
-//
-namespace boost { namespace python { namespace converter { 
-
-template <class T>
-struct object_manager_value_arg_from_python
-{
-    typedef T result_type;
-    
-    object_manager_value_arg_from_python(PyObject*);
-    bool convertible() const;
-    T operator()() const;
- private:
-    PyObject* m_source;
-};
-
-// Used for converting reference-to-object-manager arguments from
-// python. The process used here is a little bit odd. Upon
-// construction, we build the object manager object in the m_result
-// object, *forcing* it to accept the source Python object by casting
-// its pointer to detail::borrowed_reference. This is supposed to
-// bypass any type checking of the source object. The convertible
-// check then extracts the owned object and checks it. If the check
-// fails, nothing else in the program ever gets to touch this strange
-// "forced" object.
-template <class Ref>
-struct object_manager_ref_arg_from_python
-{
-    typedef Ref result_type;
-    
-    object_manager_ref_arg_from_python(PyObject*);
-    bool convertible() const;
-    Ref operator()() const;
-    ~object_manager_ref_arg_from_python();
- private:
-    typename python::detail::referent_storage<Ref>::type m_result;
-};
-
-//
-// implementations
-//
-
-template <class T>
-inline object_manager_value_arg_from_python<T>::object_manager_value_arg_from_python(PyObject* x)
-    : m_source(x)
-{
-}
-    
-template <class T>
-inline bool object_manager_value_arg_from_python<T>::convertible() const
-{
-    return object_manager_traits<T>::check(m_source);
-}
-
-template <class T>
-inline T object_manager_value_arg_from_python<T>::operator()() const
-{
-    return T(python::detail::borrowed_reference(m_source));
-}
-
-template <class Ref>
-inline object_manager_ref_arg_from_python<Ref>::object_manager_ref_arg_from_python(PyObject* x)
-{
-# if defined(__EDG_VERSION__) && __EDG_VERSION__ <= 243
-    // needed for warning suppression
-    python::detail::borrowed_reference x_ = python::detail::borrowed_reference(x);
-    python::detail::construct_referent<Ref>(&m_result.bytes, x_);
-# else 
-    python::detail::construct_referent<Ref>(&m_result.bytes, (python::detail::borrowed_reference)x);
-# endif 
-}
-
-template <class Ref>
-inline object_manager_ref_arg_from_python<Ref>::~object_manager_ref_arg_from_python()
-{
-    python::detail::destroy_referent<Ref>(this->m_result.bytes);
-}
-
-namespace detail
-{
-  template <class T>
-  inline bool object_manager_ref_check(T const& x)
-  {
-      return object_manager_traits<T>::check(get_managed_object(x, tag));
-  }
-}
-
-template <class Ref>
-inline bool object_manager_ref_arg_from_python<Ref>::convertible() const
-{
-    return detail::object_manager_ref_check(
-        python::detail::void_ptr_to_reference(this->m_result.bytes, (Ref(*)())0));
-}
-
-template <class Ref>
-inline Ref object_manager_ref_arg_from_python<Ref>::operator()() const
-{
-    return python::detail::void_ptr_to_reference(
-        this->m_result.bytes, (Ref(*)())0);
-}
-
-}}} // namespace boost::python::converter
-
-#endif // OBJ_MGR_ARG_FROM_PYTHON_DWA2002628_HPP

include/boost/python/converter/object_manager.hpp

@@ -1,230 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 OBJECT_MANAGER_DWA2002614_HPP
-# define OBJECT_MANAGER_DWA2002614_HPP
-
-# include <boost/python/handle.hpp>
-# include <boost/python/cast.hpp>
-# include <boost/python/converter/pyobject_traits.hpp>
-# include <boost/type_traits/object_traits.hpp>
-# include <boost/mpl/if.hpp>
-# include <boost/python/detail/indirect_traits.hpp>
-# include <boost/mpl/bool.hpp>
-
-// Facilities for dealing with types which always manage Python
-// objects. Some examples are object, list, str, et. al. Different
-// to_python/from_python conversion rules apply here because in
-// contrast to other types which are typically embedded inside a
-// Python object, these are wrapped around a Python object. For most
-// object managers T, a C++ non-const T reference argument does not
-// imply the existence of a T lvalue embedded in the corresponding
-// Python argument, since mutating member functions on T actually only
-// modify the held Python object.
-//
-// handle<T> is an object manager, though strictly speaking it should
-// not be. In other words, even though mutating member functions of
-// hanlde<T> actually modify the handle<T> and not the T object,
-// handle<T>& arguments of wrapped functions will bind to "rvalues"
-// wrapping the actual Python argument, just as with other object
-// manager classes. Making an exception for handle<T> is simply not
-// worth the trouble.
-//
-// borrowed<T> cv* is an object manager so that we can use the general
-// to_python mechanisms to convert raw Python object pointers to
-// python, without the usual semantic problems of using raw pointers.
-
-
-// Object Manager Concept requirements:
-//
-//    T is an Object Manager
-//    p is a PyObject*
-//    x is a T
-//
-//    * object_manager_traits<T>::is_specialized == true
-//
-//    * T(detail::borrowed_reference(p))
-//        Manages p without checking its type
-//
-//    * get_managed_object(x, boost::python::tag)
-//        Convertible to PyObject*
-//
-// Additional requirements if T can be converted from_python:
-//
-//    * T(object_manager_traits<T>::adopt(p))
-//        steals a reference to p, or throws a TypeError exception if
-//        p doesn't have an appropriate type. May assume p is non-null
-//
-//    * X::check(p)
-//        convertible to bool. True iff T(X::construct(p)) will not
-//        throw.
-
-// Forward declarations
-//
-namespace boost { namespace python
-{
-  namespace api
-  {
-    class object; 
-  }
-}}
-
-namespace boost { namespace python { namespace converter { 
-
-
-// Specializations for handle<T>
-template <class T>
-struct handle_object_manager_traits
-    : pyobject_traits<typename T::element_type>
-{
- private:
-  typedef pyobject_traits<typename T::element_type> base;
-  
- public:
-  BOOST_STATIC_CONSTANT(bool, is_specialized = true);
-
-  // Initialize with a null_ok pointer for efficiency, bypassing the
-  // null check since the source is always non-null.
-  static null_ok<typename T::element_type>* adopt(PyObject* p)
-  {
-      return python::allow_null(base::checked_downcast(p));
-  }
-};
-
-template <class T>
-struct default_object_manager_traits
-{
-    BOOST_STATIC_CONSTANT(
-        bool, is_specialized = python::detail::is_borrowed_ptr<T>::value
-        );
-};
-
-template <class T>
-struct object_manager_traits
-    : mpl::if_c<
-         is_handle<T>::value
-       , handle_object_manager_traits<T>
-       , default_object_manager_traits<T>
-    >::type
-{
-};
-
-//
-// Traits for detecting whether a type is an object manager or a
-// (cv-qualified) reference to an object manager.
-// 
-
-template <class T>
-struct is_object_manager
-    : mpl::bool_<object_manager_traits<T>::is_specialized>
-{
-};
-
-# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <class T>
-struct is_reference_to_object_manager
-    : mpl::false_
-{
-};
-
-template <class T>
-struct is_reference_to_object_manager<T&>
-    : is_object_manager<T>
-{
-};
-
-template <class T>
-struct is_reference_to_object_manager<T const&>
-    : is_object_manager<T>
-{
-};
-
-template <class T>
-struct is_reference_to_object_manager<T volatile&>
-    : is_object_manager<T>
-{
-};
-
-template <class T>
-struct is_reference_to_object_manager<T const volatile&>
-    : is_object_manager<T>
-{
-};
-# else
-
-namespace detail
-{
-  typedef char (&yes_reference_to_object_manager)[1];
-  typedef char (&no_reference_to_object_manager)[2];
-
-  // A number of nastinesses go on here in order to work around MSVC6
-  // bugs.
-  template <class T>
-  struct is_object_manager_help
-  {
-      typedef typename mpl::if_<
-          is_object_manager<T>
-          , yes_reference_to_object_manager
-          , no_reference_to_object_manager
-          >::type type;
-
-      // If we just use the type instead of the result of calling this
-      // function, VC6 will ICE.
-      static type call();
-  };
-
-  // A set of overloads for each cv-qualification. The same argument
-  // is passed twice: the first one is used to unwind the cv*, and the
-  // second one is used to avoid relying on partial ordering for
-  // overload resolution.
-  template <class U>
-  typename is_object_manager_help<U>
-  is_object_manager_helper(U*, void*);
-  
-  template <class U>
-  typename is_object_manager_help<U>
-  is_object_manager_helper(U const*, void const*);
-  
-  template <class U>
-  typename is_object_manager_help<U>
-  is_object_manager_helper(U volatile*, void volatile*);
-  
-  template <class U>
-  typename is_object_manager_help<U>
-  is_object_manager_helper(U const volatile*, void const volatile*);
-  
-  template <class T>
-  struct is_reference_to_object_manager_nonref
-      : mpl::false_
-  {
-  };
-
-  template <class T>
-  struct is_reference_to_object_manager_ref
-  {
-      static T sample_object;
-      BOOST_STATIC_CONSTANT(
-        bool, value
-        = (sizeof(is_object_manager_helper(&sample_object, &sample_object).call())
-            == sizeof(detail::yes_reference_to_object_manager)
-          )
-        );
-      typedef mpl::bool_<value> type;
-  };
-}
-
-template <class T>
-struct is_reference_to_object_manager
-    : mpl::if_<
-        is_reference<T>
-        , detail::is_reference_to_object_manager_ref<T>
-        , detail::is_reference_to_object_manager_nonref<T>
-    >::type
-{
-};
-# endif 
-
-}}} // namespace boost::python::converter
-
-#endif // OBJECT_MANAGER_DWA2002614_HPP

include/boost/python/converter/pointer_type_id.hpp

@@ -1,68 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 POINTER_TYPE_ID_DWA2002222_HPP
-# define POINTER_TYPE_ID_DWA2002222_HPP
-
-# include <boost/python/type_id.hpp>
-# include <boost/type_traits/composite_traits.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-namespace detail
-{
-  template <bool is_ref = false>
-  struct pointer_typeid_select
-  {
-      template <class T>
-      static inline type_info execute(T*(*)() = 0)
-      {
-          return type_id<T>();
-      }
-  };
-
-  template <>
-  struct pointer_typeid_select<true>
-  {
-      template <class T>
-      static inline type_info execute(T* const volatile&(*)() = 0)
-      {
-          return type_id<T>();
-      }
-    
-      template <class T>
-      static inline type_info execute(T*volatile&(*)() = 0)
-      {
-          return type_id<T>();
-      }
-    
-      template <class T>
-      static inline type_info execute(T*const&(*)() = 0)
-      {
-          return type_id<T>();
-      }
-
-      template <class T>
-      static inline type_info execute(T*&(*)() = 0)
-      {
-          return type_id<T>();
-      }
-  };
-}
-
-// Usage: pointer_type_id<T>()
-//
-// Returns a type_info associated with the type pointed
-// to by T, which may be a pointer or a reference to a pointer.
-template <class T>
-type_info pointer_type_id(T(*)() = 0)
-{
-    return detail::pointer_typeid_select<
-          is_reference<T>::value
-        >::execute((T(*)())0);
-}
-
-}}} // namespace boost::python::converter
-
-#endif // POINTER_TYPE_ID_DWA2002222_HPP

include/boost/python/converter/pyobject_traits.hpp

@@ -1,41 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 PYOBJECT_TRAITS_DWA2002720_HPP
-# define PYOBJECT_TRAITS_DWA2002720_HPP
-
-# include <boost/python/detail/prefix.hpp>
-# include <boost/python/converter/pyobject_type.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-template <class> struct pyobject_traits;
-
-template <>
-struct pyobject_traits<PyObject>
-{
-    // All objects are convertible to PyObject
-    static bool check(PyObject*) { return true; }
-    static PyObject* checked_downcast(PyObject* x) { return x; }
-};
-
-//
-// Specializations
-//
-
-# define BOOST_PYTHON_BUILTIN_OBJECT_TRAITS(T)                  \
-    template <> struct pyobject_traits<Py##T##Object>           \
-        : pyobject_type<Py##T##Object, &Py##T##_Type> {}
-
-// This is not an exhaustive list; should be expanded.
-BOOST_PYTHON_BUILTIN_OBJECT_TRAITS(Type);
-BOOST_PYTHON_BUILTIN_OBJECT_TRAITS(List);
-BOOST_PYTHON_BUILTIN_OBJECT_TRAITS(Int);
-BOOST_PYTHON_BUILTIN_OBJECT_TRAITS(Long);
-BOOST_PYTHON_BUILTIN_OBJECT_TRAITS(Dict);
-BOOST_PYTHON_BUILTIN_OBJECT_TRAITS(Tuple);
-
-}}} // namespace boost::python::converter
-
-#endif // PYOBJECT_TRAITS_DWA2002720_HPP

include/boost/python/converter/pyobject_type.hpp

@@ -1,34 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 PYOBJECT_TYPE_DWA2002720_HPP
-# define PYOBJECT_TYPE_DWA2002720_HPP
-
-# include <boost/python/cast.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-BOOST_PYTHON_DECL PyObject* checked_downcast_impl(PyObject*, PyTypeObject*);
-
-// Used as a base class for specializations which need to provide
-// Python type checking capability.
-template <class Object, PyTypeObject* pytype>
-struct pyobject_type
-{
-    static bool check(PyObject* x)
-    {
-        return ::PyObject_IsInstance(x, (PyObject*)pytype);
-    }
-
-    static Object* checked_downcast(PyObject* x)
-    {
-        return python::downcast<Object>(
-            (checked_downcast_impl)(x, pytype)
-            );
-    }
-};
-
-}}} // namespace boost::python::converter
-
-#endif // PYOBJECT_TYPE_DWA2002720_HPP

include/boost/python/converter/pytype_object_mgr_traits.hpp

@@ -1,42 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 PYTYPE_OBJECT_MANAGER_TRAITS_DWA2002716_HPP
-# define PYTYPE_OBJECT_MANAGER_TRAITS_DWA2002716_HPP
-
-# include <boost/python/detail/prefix.hpp>
-# include <boost/python/detail/raw_pyobject.hpp>
-# include <boost/python/cast.hpp>
-# include <boost/python/converter/pyobject_type.hpp>
-# include <boost/python/errors.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-// Provide a forward declaration as a convenience for clients, who all
-// need it.
-template <class T> struct object_manager_traits;
-
-// Derive specializations of object_manager_traits from this class
-// when T is an object manager for a particular Python type hierarchy.
-//
-template <PyTypeObject* pytype, class T>
-struct pytype_object_manager_traits
-    : pyobject_type<T, pytype> // provides check()
-{
-    BOOST_STATIC_CONSTANT(bool, is_specialized = true);
-    static inline python::detail::new_reference adopt(PyObject*);
-};
-
-//
-// implementations
-//
-template <PyTypeObject* pytype, class T>
-inline python::detail::new_reference pytype_object_manager_traits<pytype,T>::adopt(PyObject* x)
-{
-    return python::detail::new_reference(python::pytype_check(pytype, x));
-}
-
-}}} // namespace boost::python::converter
-
-#endif // PYTYPE_OBJECT_MANAGER_TRAITS_DWA2002716_HPP

include/boost/python/converter/registered.hpp

@@ -1,111 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 REGISTERED_DWA2002710_HPP
-# define REGISTERED_DWA2002710_HPP
-# include <boost/python/type_id.hpp>
-# include <boost/python/converter/registry.hpp>
-# include <boost/python/converter/registrations.hpp>
-# include <boost/type_traits/transform_traits.hpp>
-# include <boost/type_traits/cv_traits.hpp>
-# include <boost/type_traits/is_void.hpp>
-# include <boost/detail/workaround.hpp>
-# include <boost/python/type_id.hpp>
-# include <boost/type.hpp>
-
-namespace boost {
-
-// You'll see shared_ptr mentioned in this header because we need to
-// note which types are shared_ptrs in their registrations, to
-// implement special shared_ptr handling for rvalue conversions.
-template <class T> class shared_ptr;
-
-namespace python { namespace converter { 
-
-struct registration;
-
-namespace detail
-{
-  template <class T>
-  struct registered_base
-  {
-      static registration const& converters;
-  };
-}
-
-template <class T>
-struct registered
-  : detail::registered_base<
-        typename add_reference<
-            typename add_cv<T>::type
-        >::type
-    >
-{
-};
-
-# if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
-    && !BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
-// collapses a few more types to the same static instance.  MSVC7.1
-// fails to strip cv-qualification from array types in typeid.  For
-// some reason we can't use this collapse there or array converters
-// will not be found.
-template <class T>
-struct registered<T&>
-  : registered<T> {};
-# endif
-
-//
-// implementations
-//
-namespace detail
-{
-  inline void
-  register_shared_ptr0(...)
-  {
-  }
-  
-  template <class T>
-  inline void
-  register_shared_ptr0(shared_ptr<T>*)
-  {
-      registry::lookup_shared_ptr(type_id<shared_ptr<T> >());
-  }
-  
-  template <class T>
-  inline void
-  register_shared_ptr1(T const volatile*)
-  {
-      detail::register_shared_ptr0((T*)0);
-  }
-  
-  template <class T>
-  inline registration const& 
-  registry_lookup2(T&(*)())
-  {
-      detail::register_shared_ptr1((T*)0);
-      return registry::lookup(type_id<T&>());
-  }
-
-  template <class T>
-  inline registration const& 
-  registry_lookup1(type<T>)
-  {
-      return registry_lookup2((T(*)())0);
-  }
-
-  inline registration const& 
-  registry_lookup1(type<const volatile void>)
-  {
-      detail::register_shared_ptr1((void*)0);
-      return registry::lookup(type_id<void>());
-  }
-
-  template <class T>
-  registration const& registered_base<T>::converters = detail::registry_lookup1(type<T>());
-
-}
-
-}}} // namespace boost::python::converter
-
-#endif // REGISTERED_DWA2002710_HPP

include/boost/python/converter/registered_pointee.hpp

@@ -1,62 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 REGISTERED_POINTEE_DWA2002710_HPP
-# define REGISTERED_POINTEE_DWA2002710_HPP
-# include <boost/python/converter/registered.hpp>
-# include <boost/python/converter/pointer_type_id.hpp>
-# include <boost/python/converter/registry.hpp>
-# include <boost/type_traits/transform_traits.hpp>
-# include <boost/type_traits/cv_traits.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-struct registration;
-
-# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <class T>
-struct registered_pointee
-    : registered<
-        typename remove_pointer<
-           typename remove_cv<
-              typename remove_reference<T>::type
-           >::type
-        >::type
-    >
-{
-};
-# else
-namespace detail
-{
-  template <class T>
-  struct registered_pointee_base
-  {
-      static registration const& converters;
-  };
-}
-
-template <class T>
-struct registered_pointee
-    : detail::registered_pointee_base<
-        typename add_reference<
-           typename add_cv<T>::type
-        >::type
-    >
-{
-};
-
-//
-// implementations
-//
-namespace detail
-{
-  template <class T>
-  registration const& registered_pointee_base<T>::converters
-     = registry::lookup(pointer_type_id<T>());
-}
-
-# endif 
-}}} // namespace boost::python::converter
-
-#endif // REGISTERED_POINTEE_DWA2002710_HPP

include/boost/python/converter/registrations.hpp

@@ -1,89 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 REGISTRATIONS_DWA2002223_HPP
-# define REGISTRATIONS_DWA2002223_HPP
-
-# include <boost/python/detail/prefix.hpp>
-
-# include <boost/python/type_id.hpp>
-
-# include <boost/python/converter/convertible_function.hpp>
-# include <boost/python/converter/constructor_function.hpp>
-# include <boost/python/converter/to_python_function_type.hpp>
-
-# include <boost/detail/workaround.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-struct lvalue_from_python_chain
-{
-    convertible_function convert;
-    lvalue_from_python_chain* next;
-};
-
-struct rvalue_from_python_chain
-{
-    convertible_function convertible;
-    constructor_function construct;
-    rvalue_from_python_chain* next;
-};
-
-struct BOOST_PYTHON_DECL registration
-{
- public: // member functions
-    explicit registration(type_info target, bool is_shared_ptr = false);
-    
-    // Convert the appropriately-typed data to Python
-    PyObject* to_python(void const volatile*) const;
-
-    // Return the class object, or raise an appropriate Python
-    // exception if no class has been registered.
-    PyTypeObject* get_class_object() const;
-
- public: // data members. So sue me.
-    const python::type_info target_type;
-
-    // The chain of eligible from_python converters when an lvalue is required
-    lvalue_from_python_chain* lvalue_chain;
-
-    // The chain of eligible from_python converters when an rvalue is acceptable
-    rvalue_from_python_chain* rvalue_chain;
-    
-    // The class object associated with this type
-    PyTypeObject* m_class_object;
-
-    // The unique to_python converter for the associated C++ type.
-    to_python_function_t m_to_python;
-
-    // True iff this type is a shared_ptr.  Needed for special rvalue
-    // from_python handling.
-    const bool is_shared_ptr;
-
-# if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
- private:
-    void operator=(registration); // This is not defined, and just keeps MWCW happy.
-# endif 
-};
-
-//
-// implementations
-//
-inline registration::registration(type_info target_type, bool is_shared_ptr)
-    : target_type(target_type)
-      , lvalue_chain(0)
-      , rvalue_chain(0)
-      , m_class_object(0)
-      , m_to_python(0)
-      , is_shared_ptr(is_shared_ptr)
-{}
-
-inline bool operator<(registration const& lhs, registration const& rhs)
-{
-    return lhs.target_type < rhs.target_type;
-}
-
-}}} // namespace boost::python::converter
-
-#endif // REGISTRATIONS_DWA2002223_HPP

include/boost/python/converter/registry.hpp

@@ -1,53 +0,0 @@
-//  Copyright David Abrahams 2001.
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-#ifndef REGISTRY_DWA20011127_HPP
-# define REGISTRY_DWA20011127_HPP
-# include <boost/python/type_id.hpp>
-# include <boost/python/converter/to_python_function_type.hpp>
-# include <boost/python/converter/rvalue_from_python_data.hpp>
-# include <boost/python/converter/constructor_function.hpp>
-# include <boost/python/converter/convertible_function.hpp>
-
-namespace boost { namespace python { namespace converter {
-
-struct registration;
-
-// This namespace acts as a sort of singleton
-namespace registry
-{
-  // Get the registration corresponding to the type, creating it if necessary
-  BOOST_PYTHON_DECL registration const& lookup(type_info);
-
-  // Get the registration corresponding to the type, creating it if
-  // necessary.  Use this first when the type is a shared_ptr.
-  BOOST_PYTHON_DECL registration const& lookup_shared_ptr(type_info);
-
-  // Return a pointer to the corresponding registration, if one exists
-  BOOST_PYTHON_DECL registration const* query(type_info);
-  
-  BOOST_PYTHON_DECL void insert(to_python_function_t, type_info);
-
-  // Insert an lvalue from_python converter
-  BOOST_PYTHON_DECL void insert(void* (*convert)(PyObject*), type_info);
-
-  // Insert an rvalue from_python converter
-  BOOST_PYTHON_DECL void insert(
-      convertible_function
-      , constructor_function
-      , type_info
-      );
-  
-  // Insert an rvalue from_python converter at the tail of the
-  // chain. Used for implicit conversions
-  BOOST_PYTHON_DECL void push_back(
-      convertible_function
-      , constructor_function
-      , type_info
-      );
-}
-
-}}} // namespace boost::python::converter
-
-#endif // REGISTRY_DWA20011127_HPP

include/boost/python/converter/return_from_python.hpp

@@ -1,162 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 RETURN_FROM_PYTHON_DWA200265_HPP
-# define RETURN_FROM_PYTHON_DWA200265_HPP
-
-# include <boost/python/converter/from_python.hpp>
-# include <boost/python/converter/rvalue_from_python_data.hpp>
-# include <boost/python/converter/registered.hpp>
-# include <boost/python/converter/registered_pointee.hpp>
-# include <boost/python/converter/object_manager.hpp>
-# include <boost/python/detail/void_ptr.hpp>
-# include <boost/python/detail/void_return.hpp>
-# include <boost/python/errors.hpp>
-# include <boost/python/handle.hpp>
-# include <boost/type_traits/has_trivial_copy.hpp>
-# include <boost/mpl/and.hpp>
-# include <boost/mpl/bool.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-template <class T> struct is_object_manager;
-
-namespace detail
-{
-  template <class T>
-  struct return_pointer_from_python
-  {
-      typedef T result_type;
-      T operator()(PyObject*) const;
-  };
-  
-  template <class T>
-  struct return_reference_from_python
-  {
-      typedef T result_type;
-      T operator()(PyObject*) const;
-  };
-  
-  template <class T>
-  struct return_rvalue_from_python
-  {
-      typedef T result_type;
-
-      return_rvalue_from_python();
-      result_type operator()(PyObject*);
-   private:
-      rvalue_from_python_data<T> m_data;
-  };
-  
-  template <class T>
-  struct return_object_manager_from_python
-  {
-      typedef T result_type;
-      result_type operator()(PyObject*) const;
-  };
-  
-  template <class T>
-  struct select_return_from_python
-  {
-      BOOST_STATIC_CONSTANT(
-          bool, obj_mgr = is_object_manager<T>::value);
-
-      BOOST_STATIC_CONSTANT(
-          bool, ptr = is_pointer<T>::value);
-    
-      BOOST_STATIC_CONSTANT(
-          bool, ref = is_reference<T>::value);
-
-      typedef typename mpl::if_c<
-          obj_mgr
-          , return_object_manager_from_python<T>
-          , typename mpl::if_c<
-              ptr
-              , return_pointer_from_python<T>
-              , typename mpl::if_c<
-                  ref
-                  , return_reference_from_python<T>
-                  , return_rvalue_from_python<T>
-                >::type
-            >::type
-         >::type type;
-  };
-}
-
-template <class T>
-struct return_from_python
-    : detail::select_return_from_python<T>::type
-{
-};
-
-// Specialization as a convenience for call and call_method
-template <>
-struct return_from_python<void>
-{
-    typedef python::detail::returnable<void>::type result_type;
-    
-    result_type operator()(PyObject* x) const
-    {
-        (void_result_from_python)(x);
-# ifdef BOOST_NO_VOID_RETURNS
-        return result_type();
-# endif 
-    }
-};
-
-//
-// Implementations
-//
-namespace detail
-{
-  template <class T>
-  inline return_rvalue_from_python<T>::return_rvalue_from_python()
-      : m_data(
-          const_cast<registration*>(&registered<T>::converters)
-          )
-  {
-  }
-  
-  template <class T>
-  inline typename return_rvalue_from_python<T>::result_type
-  return_rvalue_from_python<T>::operator()(PyObject* obj)
-  {
-    // Take possession of the source object here.  If the result is in
-    // fact going to be a copy of an lvalue embedded in the object,
-    // and we take possession inside rvalue_result_from_python, it
-    // will be destroyed too early.
-    handle<> holder(obj);
-
-      return *(T*)
-          (rvalue_result_from_python)(obj, m_data.stage1);
-  }
-
-  template <class T>
-  inline T return_reference_from_python<T>::operator()(PyObject* obj) const
-  {
-      return python::detail::void_ptr_to_reference(
-          (reference_result_from_python)(obj, registered<T>::converters)
-          , (T(*)())0);
-  }
-
-  template <class T>
-  inline T return_pointer_from_python<T>::operator()(PyObject* obj) const
-  {
-      return T(
-          (pointer_result_from_python)(obj, registered_pointee<T>::converters)
-          );
-  }
-
-  template <class T>
-  inline T return_object_manager_from_python<T>::operator()(PyObject* obj) const
-  {
-      return T(
-          object_manager_traits<T>::adopt(expect_non_null(obj))
-          );
-  }
-}
-  
-}}} // namespace boost::python::converter
-
-#endif // RETURN_FROM_PYTHON_DWA200265_HPP

include/boost/python/converter/rvalue_from_python_data.hpp

@@ -1,140 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 FROM_PYTHON_AUX_DATA_DWA2002128_HPP
-# define FROM_PYTHON_AUX_DATA_DWA2002128_HPP
-
-# include <boost/python/converter/constructor_function.hpp>
-# include <boost/python/detail/referent_storage.hpp>
-# include <boost/python/detail/destroy.hpp>
-# include <boost/static_assert.hpp>
-# include <boost/type_traits/add_reference.hpp>
-# include <boost/type_traits/add_cv.hpp>
-# include <cstddef>
-
-// Data management for potential rvalue conversions from Python to C++
-// types. When a client requests a conversion to T* or T&, we
-// generally require that an object of type T exists in the source
-// Python object, and the code here does not apply**. This implements
-// conversions which may create new temporaries of type T. The classic
-// example is a conversion which converts a Python tuple to a
-// std::vector. Since no std::vector lvalue exists in the Python
-// object -- it must be created "on-the-fly" by the converter, and
-// which must manage the lifetime of the created object.
-//
-// Note that the client is not precluded from using a registered
-// lvalue conversion to T in this case. In other words, we will
-// happily accept a Python object which /does/ contain a std::vector
-// lvalue, provided an appropriate converter is registered. So, while
-// this is an rvalue conversion from the client's point-of-view, the
-// converter registry may serve up lvalue or rvalue conversions for
-// the target type.
-//
-// ** C++ argument from_python conversions to T const& are an
-// exception to the rule for references: since in C++, const
-// references can bind to temporary rvalues, we allow rvalue
-// converters to be chosen when the target type is T const& for some
-// T.
-namespace boost { namespace python { namespace converter { 
-
-// Conversions begin by filling in and returning a copy of this
-// structure. The process looks up a converter in the rvalue converter
-// registry for the target type. It calls the convertible() function
-// of each registered converter, passing the source PyObject* as an
-// argument, until a non-null result is returned. This result goes in
-// the convertible field, and the converter's construct() function is
-// stored in the construct field.
-//
-// If no appropriate converter is found, conversion fails and the
-// convertible field is null. When used in argument conversion for
-// wrapped C++ functions, it causes overload resolution to reject the
-// current function but not to fail completely. If an exception is
-// thrown, overload resolution stops and the exception propagates back
-// through the caller.
-//
-// If an lvalue converter is matched, its convertible() function is
-// expected to return a pointer to the stored T object; its
-// construct() function will be NULL. The convertible() function of
-// rvalue converters may return any non-singular pointer; the actual
-// target object will only be available once the converter's
-// construct() function is called.
-struct rvalue_from_python_stage1_data
-{
-    void* convertible;
-    constructor_function construct;
-};
-
-// Augments rvalue_from_python_stage1_data by adding storage for
-// constructing an object of remove_reference<T>::type. The
-// construct() function of rvalue converters (stored in m_construct
-// above) will cast the rvalue_from_python_stage1_data to an
-// appropriate instantiation of this template in order to access that
-// storage.
-template <class T>
-struct rvalue_from_python_storage
-{
-    rvalue_from_python_stage1_data stage1;
-
-    // Storage for the result, in case an rvalue must be constructed
-    typename python::detail::referent_storage<
-        typename add_reference<T>::type
-    >::type storage;
-};
-
-// Augments rvalue_from_python_storage<T> with a destructor. If
-// stage1.convertible == storage.bytes, it indicates that an object of
-// remove_reference<T>::type has been constructed in storage and
-// should will be destroyed in ~rvalue_from_python_data(). It is
-// crucial that successful rvalue conversions establish this equality
-// and that unsuccessful ones do not.
-template <class T>
-struct rvalue_from_python_data : rvalue_from_python_storage<T>
-{
-# if (!defined(__MWERKS__) || __MWERKS__ >= 0x3000) \
-        && (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= 245) \
-        && (!defined(__DECCXX_VER) || __DECCXX_VER > 60590014) \
-        && !defined(BOOST_PYTHON_SYNOPSIS) /* Synopsis' OpenCXX has trouble parsing this */
-    // This must always be a POD struct with m_data its first member.
-    BOOST_STATIC_ASSERT(BOOST_PYTHON_OFFSETOF(rvalue_from_python_storage<T>,stage1) == 0);
-# endif
-    
-    // The usual constructor 
-    rvalue_from_python_data(rvalue_from_python_stage1_data const&);
-
-    // This constructor just sets m_convertible -- used by
-    // implicitly_convertible<> to perform the final step of the
-    // conversion, where the construct() function is already known.
-    rvalue_from_python_data(void* convertible);
-
-    // Destroys any object constructed in the storage.
-    ~rvalue_from_python_data();
- private:
-    typedef typename add_reference<typename add_cv<T>::type>::type ref_type;
-};
-
-//
-// Implementataions
-//
-template <class T>
-inline rvalue_from_python_data<T>::rvalue_from_python_data(rvalue_from_python_stage1_data const& stage1)
-{
-    this->stage1 = stage1;
-}
-
-template <class T>
-inline rvalue_from_python_data<T>::rvalue_from_python_data(void* convertible)
-{
-    this->stage1.convertible = convertible;
-}
-
-template <class T>
-inline rvalue_from_python_data<T>::~rvalue_from_python_data()
-{
-    if (this->stage1.convertible == this->storage.bytes)
-        python::detail::destroy_referent<ref_type>(this->storage.bytes);
-}
-
-}}} // namespace boost::python::converter
-
-#endif // FROM_PYTHON_AUX_DATA_DWA2002128_HPP

include/boost/python/converter/shared_ptr_deleter.hpp

@@ -1,22 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 SHARED_PTR_DELETER_DWA2002121_HPP
-# define SHARED_PTR_DELETER_DWA2002121_HPP
-
-namespace boost { namespace python { namespace converter { 
-
-struct BOOST_PYTHON_DECL shared_ptr_deleter
-{
-    shared_ptr_deleter(handle<> owner);
-    ~shared_ptr_deleter();
-
-    void operator()(void const*);
-        
-    handle<> owner;
-};
-
-}}} // namespace boost::python::converter
-
-#endif // SHARED_PTR_DELETER_DWA2002121_HPP

include/boost/python/converter/shared_ptr_from_python.hpp

@@ -1,52 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 SHARED_PTR_FROM_PYTHON_DWA20021130_HPP
-# define SHARED_PTR_FROM_PYTHON_DWA20021130_HPP
-
-# include <boost/python/handle.hpp>
-# include <boost/python/converter/shared_ptr_deleter.hpp>
-# include <boost/python/converter/from_python.hpp>
-# include <boost/python/converter/rvalue_from_python_data.hpp>
-# include <boost/python/converter/registered.hpp>
-# include <boost/shared_ptr.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-template <class T>
-struct shared_ptr_from_python
-{
-    shared_ptr_from_python()
-    {
-        converter::registry::insert(&convertible, &construct, type_id<shared_ptr<T> >());
-    }
-
- private:
-    static void* convertible(PyObject* p)
-    {
-        if (p == Py_None)
-            return p;
-        
-        return converter::get_lvalue_from_python(p, registered<T>::converters);
-    }
-    
-    static void construct(PyObject* source, rvalue_from_python_stage1_data* data)
-    {
-        void* const storage = ((converter::rvalue_from_python_storage<shared_ptr<T> >*)data)->storage.bytes;
-        // Deal with the "None" case.
-        if (data->convertible == source)
-            new (storage) shared_ptr<T>();
-        else
-            new (storage) shared_ptr<T>(
-                static_cast<T*>(data->convertible),
-                shared_ptr_deleter(handle<>(borrowed(source)))
-                );
-        
-        data->convertible = storage;
-    }
-};
-
-}}} // namespace boost::python::converter
-
-#endif // SHARED_PTR_FROM_PYTHON_DWA20021130_HPP

include/boost/python/converter/shared_ptr_to_python.hpp

@@ -1,28 +0,0 @@
-// Copyright David Abrahams 2003.
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-#ifndef SHARED_PTR_TO_PYTHON_DWA2003224_HPP
-# define SHARED_PTR_TO_PYTHON_DWA2003224_HPP
-
-# include <boost/python/refcount.hpp>
-# include <boost/python/converter/shared_ptr_deleter.hpp>
-# include <boost/shared_ptr.hpp>
-# include <boost/get_pointer.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-template <class T>
-PyObject* shared_ptr_to_python(shared_ptr<T> const& x)
-{
-    if (!x)
-        return python::detail::none();
-    else if (shared_ptr_deleter* d = boost::get_deleter<shared_ptr_deleter>(x))
-        return incref( get_pointer( d->owner ) );
-    else
-        return converter::registered<shared_ptr<T> const&>::converters.to_python(&x);
-}
-
-}}} // namespace boost::python::converter
-
-#endif // SHARED_PTR_TO_PYTHON_DWA2003224_HPP

include/boost/python/converter/to_python_function_type.hpp

@@ -1,19 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 TO_PYTHON_FUNCTION_TYPE_DWA200236_HPP
-# define TO_PYTHON_FUNCTION_TYPE_DWA200236_HPP
-# include <boost/python/detail/prefix.hpp>
-# include <boost/static_assert.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-// The type of stored function pointers which actually do conversion
-// by-value. The void* points to the object to be converted, and
-// type-safety is preserved through runtime registration.
-typedef PyObject* (*to_python_function_t)(void const*);
-
-}}} // namespace boost::python::converter
-
-#endif // TO_PYTHON_FUNCTION_TYPE_DWA200236_HPP

include/boost/python/copy_const_reference.hpp

@@ -1,43 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 COPY_CONST_REFERENCE_DWA2002131_HPP
-# define COPY_CONST_REFERENCE_DWA2002131_HPP
-
-# include <boost/python/detail/prefix.hpp>
-# include <boost/python/detail/indirect_traits.hpp>
-# include <boost/mpl/if.hpp>
-# include <boost/python/to_python_value.hpp>
-
-namespace boost { namespace python { 
-
-namespace detail
-{
-  template <class R>
-  struct copy_const_reference_expects_a_const_reference_return_type
-# if defined(__GNUC__) && __GNUC__ >= 3 || defined(__EDG__)
-  {}
-# endif
-  ;
-}
-
-template <class T> struct to_python_value;
-
-struct copy_const_reference
-{
-    template <class T>
-    struct apply
-    {
-        typedef typename mpl::if_c<
-            indirect_traits::is_reference_to_const<T>::value
-          , to_python_value<T>
-          , detail::copy_const_reference_expects_a_const_reference_return_type<T>
-        >::type type;
-    };
-};
-
-
-}} // namespace boost::python
-
-#endif // COPY_CONST_REFERENCE_DWA2002131_HPP

include/boost/python/copy_non_const_reference.hpp

@@ -1,43 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 COPY_NON_CONST_REFERENCE_DWA2002131_HPP
-# define COPY_NON_CONST_REFERENCE_DWA2002131_HPP
-
-# include <boost/python/detail/prefix.hpp>
-# include <boost/python/detail/indirect_traits.hpp>
-# include <boost/mpl/if.hpp>
-# include <boost/python/to_python_value.hpp>
-
-namespace boost { namespace python { 
-
-namespace detail
-{
-  template <class R>
-  struct copy_non_const_reference_expects_a_non_const_reference_return_type
-# if defined(__GNUC__) && __GNUC__ >= 3 || defined(__EDG__)
-  {}
-# endif
-  ;
-}
-
-template <class T> struct to_python_value;
-
-struct copy_non_const_reference
-{
-    template <class T>
-    struct apply
-    {
-        typedef typename mpl::if_c<
-            indirect_traits::is_reference_to_non_const<T>::value
-            , to_python_value<T>
-            , detail::copy_non_const_reference_expects_a_non_const_reference_return_type<T>
-        >::type type;
-    };
-};
-
-
-}} // namespace boost::python
-
-#endif // COPY_NON_CONST_REFERENCE_DWA2002131_HPP

include/boost/python/data_members.hpp

@@ -1,316 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 DATA_MEMBERS_DWA2002328_HPP
-# define DATA_MEMBERS_DWA2002328_HPP
-
-# include <boost/python/detail/prefix.hpp>
-
-# include <boost/python/handle.hpp>
-
-# include <boost/python/return_value_policy.hpp>
-# include <boost/python/return_by_value.hpp>
-# include <boost/python/return_internal_reference.hpp>
-# include <boost/python/make_function.hpp>
-
-# include <boost/python/converter/builtin_converters.hpp>
-
-# include <boost/python/detail/indirect_traits.hpp>
-# include <boost/python/detail/not_specified.hpp>
-# include <boost/python/detail/value_arg.hpp>
-
-# include <boost/type_traits/add_const.hpp>
-# include <boost/type_traits/add_reference.hpp>
-# include <boost/type_traits/is_member_pointer.hpp>
-
-# if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
-#  include <boost/type_traits/remove_cv.hpp>
-# endif 
-
-# include <boost/mpl/eval_if.hpp>
-# include <boost/mpl/if.hpp>
-# include <boost/mpl/vector/vector10.hpp>
-
-# include <boost/detail/workaround.hpp>
-
-namespace boost { namespace python { 
-
-//
-// This file defines the make_getter and make_setter function
-// families, which are responsible for turning pointers, references,
-// and pointers-to-data-members into callable Python objects which
-// can be used for attribute access on wrapped classes.
-//
-
-namespace detail
-{
-
-  // A small function object which handles the getting and setting of
-  // data members.
-  template <class Data, class Class>
-  struct member
-  {
-   public:      
-      member(Data Class::*which) : m_which(which) {}
-      
-      Data& operator()(Class& c) const
-      {
-          return c.*m_which;
-      }
-
-      void operator()(Class& c, typename value_arg<Data>::type d) const
-      {
-          c.*m_which = d;
-      }
-   private:
-      Data Class::*m_which;
-  };
-
-  // A small function object which handles the getting and setting of
-  // non-member objects.
-  template <class Data>
-  struct datum
-  {
-   public:      
-      datum(Data *which) : m_which(which) {}
-      
-      Data& operator()() const
-      {
-          return *m_which;
-      }
-
-      void operator()(typename value_arg<Data>::type d) const
-      {
-          *m_which = d;
-      }
-   private:
-      Data *m_which;
-  };
-  
-  //
-  // Helper metafunction for determining the default CallPolicy to use
-  // for attribute access.  If T is a [reference to a] class type X
-  // whose conversion to python would normally produce a new copy of X
-  // in a wrapped X class instance (as opposed to types such as
-  // std::string, which are converted to native Python types, and
-  // smart pointer types which produce a wrapped class instance of the
-  // pointee type), to-python conversions will attempt to produce an
-  // object which refers to the original C++ object, rather than a
-  // copy.  See default_member_getter_policy for rationale.
-  // 
-  template <class T>
-  struct default_getter_by_ref
-      : mpl::and_<
-          mpl::bool_<
-              to_python_value<
-                  typename value_arg<T>::type
-              >::uses_registry
-          >
-        , indirect_traits::is_reference_to_class<
-              typename value_arg<T>::type
-          >
-       >
-  {
-  };
-
-  // Metafunction computing the default CallPolicy to use for reading
-  // data members
-  //
-  // If it's a regular class type (not an object manager or other
-  // type for which we have to_python specializations, use
-  // return_internal_reference so that we can do things like
-  //    x.y.z =  1
-  // and get the right result.
-  template <class T>
-  struct default_member_getter_policy
-    : mpl::if_<
-          default_getter_by_ref<T>
-        , return_internal_reference<>
-        , return_value_policy<return_by_value>
-      >
-  {};
-
-  // Metafunction computing the default CallPolicy to use for reading
-  // non-member data.
-  template <class T>
-  struct default_datum_getter_policy
-    : mpl::if_<
-          default_getter_by_ref<T>
-        , return_value_policy<reference_existing_object>
-        , return_value_policy<return_by_value>
-      >
-  {};
-
-  //
-  // make_getter helper function family -- These helpers to
-  // boost::python::make_getter are used to dispatch behavior.  The
-  // third argument is a workaround for a CWPro8 partial ordering bug
-  // with pointers to data members.  It should be convertible to
-  // mpl::true_ iff the first argument is a pointer-to-member, and
-  // mpl::false_ otherwise.  The fourth argument is for compilers
-  // which don't support partial ordering at all and should always be
-  // passed 0L.
-  //
-
-#if BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
-  template <class D, class P>
-  inline object make_getter(D& d, P& p, mpl::false_, ...);
-#endif
-
-  // Handle non-member pointers with policies
-  template <class D, class Policies>
-  inline object make_getter(D* d, Policies const& policies, mpl::false_, int)
-  {
-      return python::make_function(
-          detail::datum<D>(d), policies, mpl::vector1<D&>()
-      );
-  }
-  
-  // Handle non-member pointers without policies
-  template <class D>
-  inline object make_getter(D* d, not_specified, mpl::false_, long)
-  {
-      typedef typename default_datum_getter_policy<D>::type policies;
-      return detail::make_getter(d, policies(), mpl::false_(), 0);
-  }
-
-  // Handle pointers-to-members with policies
-  template <class C, class D, class Policies>
-  inline object make_getter(D C::*pm, Policies const& policies, mpl::true_, int)
-  {
-#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
-      typedef typename remove_cv<C>::type Class;
-#else
-      typedef C Class;
-#endif 
-      return python::make_function(
-          detail::member<D,Class>(pm)
-        , policies
-        , mpl::vector2<D&,Class&>()
-      );
-  }
-      
-  // Handle pointers-to-members without policies
-  template <class C, class D>
-  inline object make_getter(D C::*pm, not_specified, mpl::true_, long)
-  {
-      typedef typename default_member_getter_policy<D>::type policies;
-      return detail::make_getter(pm, policies(), mpl::true_(), 0);
-  }
-
-  // Handle references
-  template <class D, class P>
-  inline object make_getter(D& d, P& p, mpl::false_, ...)
-  {
-      // Just dispatch to the handler for pointer types.
-      return detail::make_getter(&d, p, mpl::false_(), 0L);
-  }
-
-  //
-  // make_setter helper function family -- These helpers to
-  // boost::python::make_setter are used to dispatch behavior.  The
-  // third argument is for compilers which don't support partial
-  // ordering at all and should always be passed 0.
-  //
-
-  
-  // Handle non-member pointers
-  template <class D, class Policies>
-  inline object make_setter(D* p, Policies const& policies, mpl::false_, int)
-  {
-      return python::make_function(
-          detail::datum<D>(p), policies, mpl::vector2<void,D const&>()
-      );
-  }
-
-  // Handle pointers-to-members
-  template <class C, class D, class Policies>
-  inline object make_setter(D C::*pm, Policies const& policies, mpl::true_, int)
-  {
-      return python::make_function(
-          detail::member<D,C>(pm)
-        , policies
-        , mpl::vector3<void, C&, D const&>()
-      );
-  }
-
-  // Handle references
-  template <class D, class Policies>
-  inline object make_setter(D& x, Policies const& policies, mpl::false_, ...)
-  {
-      return detail::make_setter(&x, policies, mpl::false_(), 0L);
-  }
-}
-
-//
-// make_getter function family -- build a callable object which
-// retrieves data through the first argument and is appropriate for
-// use as the `get' function in Python properties .  The second,
-// policies argument, is optional.  We need both D& and D const&
-// overloads in order be able to handle rvalues.
-//
-template <class D, class Policies>
-inline object make_getter(D& d, Policies const& policies)
-{
-    return detail::make_getter(d, policies, is_member_pointer<D>(), 0L);
-}
-
-template <class D, class Policies>
-inline object make_getter(D const& d, Policies const& policies)
-{
-    return detail::make_getter(d, policies, is_member_pointer<D>(), 0L);
-}
-
-template <class D>
-inline object make_getter(D& x)
-{
-    detail::not_specified policy;
-    return detail::make_getter(x, policy, is_member_pointer<D>(), 0L);
-}
-
-#  if !BOOST_WORKAROUND(__EDG_VERSION__, <= 238) && !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-template <class D>
-inline object make_getter(D const& d)
-{
-    detail::not_specified policy;
-    return detail::make_getter(d, policy, is_member_pointer<D>(), 0L);
-}
-#  endif
-
-//
-// make_setter function family -- build a callable object which
-// writes data through the first argument and is appropriate for
-// use as the `set' function in Python properties .  The second,
-// policies argument, is optional.  We need both D& and D const&
-// overloads in order be able to handle rvalues.
-//
-template <class D, class Policies>
-inline object make_setter(D& x, Policies const& policies)
-{
-    return detail::make_setter(x, policies, is_member_pointer<D>(), 0);
-}
-
-template <class D, class Policies>
-inline object make_setter(D const& x, Policies const& policies)
-{
-    return detail::make_setter(x, policies, is_member_pointer<D>(), 0);
-}
-
-template <class D>
-inline object make_setter(D& x)
-{
-    return detail::make_setter(x, default_call_policies(), is_member_pointer<D>(), 0);
-}
-
-# if !(BOOST_WORKAROUND(BOOST_MSVC, <= 1300) || BOOST_WORKAROUND(__EDG_VERSION__, <= 238))
-template <class D>
-inline object make_setter(D const& x)
-{
-    return detail::make_setter(x, default_call_policies(), is_member_pointer<D>(), 0);
-}
-# endif
-
-}} // namespace boost::python
-
-#endif // DATA_MEMBERS_DWA2002328_HPP

include/boost/python/def.hpp

@@ -1,114 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 DEF_DWA200292_HPP
-# define DEF_DWA200292_HPP
-
-# include <boost/python/detail/prefix.hpp>
-
-# include <boost/python/object_fwd.hpp>
-# include <boost/python/make_function.hpp>
-# include <boost/python/detail/def_helper.hpp>
-# include <boost/python/detail/overloads_fwd.hpp>
-# include <boost/python/scope.hpp>
-# include <boost/python/signature.hpp>
-# include <boost/python/detail/scope.hpp>
-
-namespace boost { namespace python {
-
-namespace detail
-{
-  namespace error
-  {
-    // Compile-time error messages
-    template <bool> struct multiple_functions_passed_to_def;
-    template <> struct multiple_functions_passed_to_def<false> { typedef char type; };
-  }
-  
-  //
-  // def_from_helper --
-  //
-  // Use a def_helper to define a regular wrapped function in the current scope.
-  template <class F, class Helper>
-  void def_from_helper(
-      char const* name, F const& fn, Helper const& helper)
-  {
-      // Must not try to use default implementations except with method definitions.
-      typedef typename error::multiple_functions_passed_to_def<
-          Helper::has_default_implementation
-          >::type assertion;
-      
-      detail::scope_setattr_doc(
-          name, boost::python::make_function(
-              fn
-              , helper.policies()
-              , helper.keywords())
-          , helper.doc()
-          );
-  }
-
-  //
-  // These two overloads discriminate between def() as applied to
-  // regular functions and def() as applied to the result of
-  // BOOST_PYTHON_FUNCTION_OVERLOADS(). The final argument is used to
-  // discriminate.
-  //
-  template <class Fn, class A1>
-  void
-  def_maybe_overloads(
-      char const* name
-      , Fn fn
-      , A1 const& a1
-      , ...)
-  {
-      detail::def_from_helper(name, fn, def_helper<A1>(a1));
-  }
-
-  template <class StubsT, class SigT>
-  void def_maybe_overloads(
-      char const* name
-      , SigT sig
-      , StubsT const& stubs
-      , detail::overloads_base const*)
-  {
-      scope current;
-      
-      detail::define_with_defaults(
-          name, stubs, current, detail::get_signature(sig));
-  }
-
-  template <class T>
-  object make_function1(T fn, ...) { return make_function(fn); }
-
-  inline
-  object make_function1(object const& x, object const*) { return x; }
-}
-
-template <class Fn>
-void def(char const* name, Fn fn)
-{
-    detail::scope_setattr_doc(name, detail::make_function1(fn, &fn), 0);
-}
-
-template <class Arg1T, class Arg2T>
-void def(char const* name, Arg1T arg1, Arg2T const& arg2)
-{
-    detail::def_maybe_overloads(name, arg1, arg2, &arg2);
-}
-
-template <class F, class A1, class A2>
-void def(char const* name, F f, A1 const& a1, A2 const& a2)
-{
-    detail::def_from_helper(name, f, detail::def_helper<A1,A2>(a1,a2));
-}
-
-template <class F, class A1, class A2, class A3>
-void def(char const* name, F f, A1 const& a1, A2 const& a2, A3 const& a3)
-{
-    detail::def_from_helper(name, f, detail::def_helper<A1,A2,A3>(a1,a2,a3));
-}
-
-}} // namespace boost::python
-
-#endif // DEF_DWA200292_HPP

include/boost/python/def_visitor.hpp

@@ -1,86 +0,0 @@
-// Copyright David Abrahams 2003.
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-#ifndef DEF_VISITOR_DWA2003810_HPP
-# define DEF_VISITOR_DWA2003810_HPP
-
-# include <boost/python/detail/prefix.hpp>
-# include <boost/detail/workaround.hpp>
-
-namespace boost { namespace python { 
-
-template <class DerivedVisitor> class def_visitor;
-template <class T, class X1, class X2, class X3> class class_;
-
-class def_visitor_access
-{
-# if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)                  \
-    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
-    // Tasteless as this may seem, making all members public allows member templates
-    // to work in the absence of member template friends.
- public:
-# else      
-    template <class Derived> friend class def_visitor;
-# endif
-    
-    // unnamed visit, c.f. init<...>, container suites
-    template <class V, class classT>
-    static void visit(V const& v, classT& c)
-    {
-        v.derived_visitor().visit(c);
-    }
-
-    // named visit, c.f. object, pure_virtual
-    template <class V, class classT, class OptionalArgs>
-    static void visit(
-        V const& v
-      , classT& c
-      , char const* name
-      , OptionalArgs const& options
-    ) 
-    {
-        v.derived_visitor().visit(c, name, options);
-    }
-    
-};
-
-
-template <class DerivedVisitor>
-class def_visitor
-{
-    friend class def_visitor_access;
-    
-# if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)                  \
-    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
-    // Tasteless as this may seem, making all members public allows member templates
-    // to work in the absence of member template friends.
- public:
-# else      
-    template <class T, class X1, class X2, class X3> friend class class_;
-# endif
-    
-    // unnamed visit, c.f. init<...>, container suites
-    template <class classT>
-    void visit(classT& c) const
-    {
-        def_visitor_access::visit(*this, c);
-    }
-
-    // named visit, c.f. object, pure_virtual
-    template <class classT, class OptionalArgs>
-    void visit(classT& c, char const* name, OptionalArgs const& options) const
-    {
-        def_visitor_access::visit(*this, c, name, options);
-    }
-    
- protected:
-    DerivedVisitor const& derived_visitor() const
-    {
-        return static_cast<DerivedVisitor const&>(*this);
-    }
-};
-
-}} // namespace boost::python
-
-#endif // DEF_VISITOR_DWA2003810_HPP

include/boost/python/default_call_policies.hpp

@@ -1,84 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 DEFAULT_CALL_POLICIES_DWA2002131_HPP
-# define DEFAULT_CALL_POLICIES_DWA2002131_HPP
-
-# include <boost/python/detail/prefix.hpp>
-# include <boost/mpl/if.hpp>
-# include <boost/python/to_python_value.hpp>
-# include <boost/python/detail/value_arg.hpp>
-# include <boost/type_traits/transform_traits.hpp>
-# include <boost/type_traits/is_pointer.hpp>
-# include <boost/type_traits/is_reference.hpp>
-# include <boost/mpl/or.hpp>
-
-namespace boost { namespace python { 
-
-template <class T> struct to_python_value;
-
-namespace detail
-{
-// for "readable" error messages
-  template <class T> struct specify_a_return_value_policy_to_wrap_functions_returning
-# if defined(__GNUC__) && __GNUC__ >= 3 || defined(__EDG__)
-  {}
-# endif 
-  ;
-}
-
-struct default_result_converter;
-
-struct default_call_policies
-{
-    // Ownership of this argument tuple will ultimately be adopted by
-    // the caller.
-    template <class ArgumentPackage>
-    static bool precall(ArgumentPackage const&)
-    {
-        return true;
-    }
-
-    // Pass the result through
-    template <class ArgumentPackage>
-    static PyObject* postcall(ArgumentPackage const&, PyObject* result)
-    {
-        return result;
-    }
-
-    typedef default_result_converter result_converter;
-    typedef PyObject* argument_package;
-};
-
-struct default_result_converter
-{
-    template <class R>
-    struct apply
-    {
-        typedef typename mpl::if_<
-            mpl::or_<is_pointer<R>, is_reference<R> >
-          , detail::specify_a_return_value_policy_to_wrap_functions_returning<R>
-          , boost::python::to_python_value<
-                typename detail::value_arg<R>::type
-            >
-        >::type type;
-    };
-};
-
-// Exceptions for c strings an PyObject*s
-template <>
-struct default_result_converter::apply<char const*>
-{
-    typedef boost::python::to_python_value<char const*const&> type;
-};
-
-template <>
-struct default_result_converter::apply<PyObject*>
-{
-    typedef boost::python::to_python_value<PyObject*const&> type;
-};
-
-}} // namespace boost::python
-
-#endif // DEFAULT_CALL_POLICIES_DWA2002131_HPP

include/boost/python/detail/aix_init_module.hpp

@@ -1,26 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 AIX_INIT_MODULE_DWA2002529_HPP
-# define AIX_INIT_MODULE_DWA2002529_HPP
-# ifdef _AIX
-# include <boost/python/detail/prefix.hpp>
-# include <cstdio>
-# ifdef __KCC
-#  include <iostream> // this works around a problem in KCC 4.0f
-# endif 
-
-namespace boost { namespace python { namespace detail { 
-
-extern "C"
-{
-    typedef PyObject* (*so_load_function)(char*,char*,FILE*);
-}
-
-void aix_init_module(so_load_function, char const* name, void (*init_module)());
-
-}}} // namespace boost::python::detail
-# endif
-
-#endif // AIX_INIT_MODULE_DWA2002529_HPP

include/boost/python/detail/api_placeholder.hpp

@@ -1,15 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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)
-
-// DEPRECATED HEADER (2006 Jan 12)
-// Provided only for backward compatibility.
-// The boost::python::len() function is now defined in object.hpp.
-
-#ifndef BOOST_PYTHON_API_PLACE_HOLDER_HPP
-#define BOOST_PYTHON_API_PLACE_HOLDER_HPP
-
-#include <boost/python/object.hpp>
-
-#endif // BOOST_PYTHON_API_PLACE_HOLDER_HPP

include/boost/python/detail/borrowed_ptr.hpp

@@ -1,111 +0,0 @@
-#ifndef BORROWED_PTR_DWA20020601_HPP
-# define BORROWED_PTR_DWA20020601_HPP
-// Copyright David Abrahams 2002.
-// 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)
-
-# include <boost/config.hpp>
-# include <boost/type.hpp>
-# include <boost/mpl/if.hpp>
-# include <boost/type_traits/object_traits.hpp>
-# include <boost/type_traits/cv_traits.hpp>
-# include <boost/python/tag.hpp>
-
-namespace boost { namespace python { namespace detail {
-
-template<class T> class borrowed
-{ 
-    typedef T type;
-};
-
-# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template<typename T>
-struct is_borrowed_ptr
-{
-    BOOST_STATIC_CONSTANT(bool, value = false); 
-};
-
-#  if !defined(__MWERKS__) || __MWERKS__ > 0x3000
-template<typename T>
-struct is_borrowed_ptr<borrowed<T>*>
-{
-    BOOST_STATIC_CONSTANT(bool, value = true);
-};
-
-template<typename T>
-struct is_borrowed_ptr<borrowed<T> const*>
-{
-    BOOST_STATIC_CONSTANT(bool, value = true);
-};
-
-template<typename T>
-struct is_borrowed_ptr<borrowed<T> volatile*>
-{
-    BOOST_STATIC_CONSTANT(bool, value = true);
-};
-
-template<typename T>
-struct is_borrowed_ptr<borrowed<T> const volatile*>
-{
-    BOOST_STATIC_CONSTANT(bool, value = true);
-};
-#  else
-template<typename T>
-struct is_borrowed
-{
-    BOOST_STATIC_CONSTANT(bool, value = false);
-};
-template<typename T>
-struct is_borrowed<borrowed<T> >
-{
-    BOOST_STATIC_CONSTANT(bool, value = true);
-};
-template<typename T>
-struct is_borrowed_ptr<T*>
-    : is_borrowed<typename remove_cv<T>::type>
-{
-};
-#  endif 
-
-# else // no partial specialization
-
-typedef char (&yes_borrowed_ptr_t)[1];
-typedef char (&no_borrowed_ptr_t)[2];
-
-no_borrowed_ptr_t is_borrowed_ptr_test(...);
-
-template <class T>
-typename mpl::if_c<
-    is_pointer<T>::value
-    , T
-    , int
-    >::type
-is_borrowed_ptr_test1(boost::type<T>);
-
-template<typename T>
-yes_borrowed_ptr_t is_borrowed_ptr_test(borrowed<T> const volatile*);
-
-template<typename T>
-class is_borrowed_ptr
-{
- public:
-    BOOST_STATIC_CONSTANT(
-        bool, value = (
-            sizeof(detail::is_borrowed_ptr_test(is_borrowed_ptr_test1(boost::type<T>())))
-            == sizeof(detail::yes_borrowed_ptr_t)));
-};
-
-# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-}
-
-template <class T>
-inline T* get_managed_object(detail::borrowed<T> const volatile* p, tag_t)
-{
-    return (T*)p;
-}
-
-}} // namespace boost::python::detail
-
-#endif // #ifndef BORROWED_PTR_DWA20020601_HPP

include/boost/python/detail/caller.hpp

@@ -1,220 +0,0 @@
-#if !defined(BOOST_PP_IS_ITERATING)
-
-// Copyright David Abrahams 2002.
-// 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 CALLER_DWA20021121_HPP
-#  define CALLER_DWA20021121_HPP
-
-#  include <boost/python/type_id.hpp>
-#  include <boost/python/handle.hpp>
-
-#  include <boost/python/detail/invoke.hpp>
-#  include <boost/python/detail/signature.hpp>
-#  include <boost/python/detail/preprocessor.hpp>
-
-#  include <boost/python/arg_from_python.hpp>
-#  include <boost/python/converter/context_result_converter.hpp>
-
-#  include <boost/preprocessor/iterate.hpp>
-#  include <boost/preprocessor/cat.hpp>
-#  include <boost/preprocessor/dec.hpp>
-#  include <boost/preprocessor/if.hpp>
-#  include <boost/preprocessor/iteration/local.hpp>
-#  include <boost/preprocessor/repetition/enum_trailing_params.hpp>
-#  include <boost/preprocessor/repetition/repeat.hpp>
-
-#  include <boost/compressed_pair.hpp>
-
-#  include <boost/type_traits/is_same.hpp>
-#  include <boost/type_traits/is_convertible.hpp>
-
-#  include <boost/mpl/apply.hpp>
-#  include <boost/mpl/eval_if.hpp>
-#  include <boost/mpl/identity.hpp>
-#  include <boost/mpl/size.hpp>
-#  include <boost/mpl/at.hpp>
-#  include <boost/mpl/int.hpp>
-#  include <boost/mpl/next.hpp>
-
-namespace boost { namespace python { namespace detail { 
-
-template <int N>
-inline PyObject* get(mpl::int_<N>, PyObject* const& args_)
-{
-    return PyTuple_GET_ITEM(args_,N);
-}
-
-inline unsigned arity(PyObject* const& args_)
-{
-    return PyTuple_GET_SIZE(args_);
-}
-
-// This "result converter" is really just used as
-// a dispatch tag to invoke(...), selecting the appropriate
-// implementation
-typedef int void_result_to_python;
-
-// Given a model of CallPolicies and a C++ result type, this
-// metafunction selects the appropriate converter to use for
-// converting the result to python.
-template <class Policies, class Result>
-struct select_result_converter
-  : mpl::eval_if<
-        is_same<Result,void>
-      , mpl::identity<void_result_to_python>
-      , mpl::apply1<typename Policies::result_converter,Result>
-    >
-{
-};
-
-template <class ArgPackage, class ResultConverter>
-inline ResultConverter create_result_converter(
-    ArgPackage const& args_
-  , ResultConverter*
-  , converter::context_result_converter*
-)
-{
-    return ResultConverter(args_);
-}
-    
-template <class ArgPackage, class ResultConverter>
-inline ResultConverter create_result_converter(
-    ArgPackage const&
-  , ResultConverter*
-  , ...
-)
-{
-    return ResultConverter();
-}
-    
-template <unsigned> struct caller_arity;
-
-template <class F, class CallPolicies, class Sig>
-struct caller;
-
-#  define BOOST_PYTHON_NEXT(init,name,n)                                                        \
-    typedef BOOST_PP_IF(n,typename mpl::next< BOOST_PP_CAT(name,BOOST_PP_DEC(n)) >::type, init) name##n;
-
-#  define BOOST_PYTHON_ARG_CONVERTER(n)                                         \
-     BOOST_PYTHON_NEXT(typename mpl::next<first>::type, arg_iter,n)             \
-     typedef arg_from_python<BOOST_DEDUCED_TYPENAME arg_iter##n::type> c_t##n;  \
-     c_t##n c##n(get(mpl::int_<n>(), inner_args));                              \
-     if (!c##n.convertible())                                                   \
-          return 0;
-
-#  define BOOST_PP_ITERATION_PARAMS_1                                            \
-        (3, (0, BOOST_PYTHON_MAX_ARITY + 1, <boost/python/detail/caller.hpp>))
-#  include BOOST_PP_ITERATE()
-
-#  undef BOOST_PYTHON_ARG_CONVERTER
-#  undef BOOST_PYTHON_NEXT
-
-// A metafunction returning the base class used for caller<class F,
-// class ConverterGenerators, class CallPolicies, class Sig>.
-template <class F, class CallPolicies, class Sig>
-struct caller_base_select
-{
-    enum { arity = mpl::size<Sig>::value - 1 };
-    typedef typename caller_arity<arity>::template impl<F,CallPolicies,Sig> type;
-};
-
-// A function object type which wraps C++ objects as Python callable
-// objects.
-//
-// Template Arguments:
-//
-//   F -
-//      the C++ `function object' that will be called. Might
-//      actually be any data for which an appropriate invoke_tag() can
-//      be generated. invoke(...) takes care of the actual invocation syntax.
-//
-//   CallPolicies -
-//      The precall, postcall, and what kind of resultconverter to
-//      generate for mpl::front<Sig>::type
-//
-//   Sig -
-//      The `intended signature' of the function. An MPL sequence
-//      beginning with a result type and continuing with a list of
-//      argument types.
-template <class F, class CallPolicies, class Sig>
-struct caller
-    : caller_base_select<F,CallPolicies,Sig>::type
-{
-    typedef typename caller_base_select<
-        F,CallPolicies,Sig
-        >::type base;
-
-    typedef PyObject* result_type;
-    
-    caller(F f, CallPolicies p) : base(f,p) {}
-
-};
-
-}}} // namespace boost::python::detail
-
-# endif // CALLER_DWA20021121_HPP
-
-#else
-
-# define N BOOST_PP_ITERATION()
-
-template <>
-struct caller_arity<N>
-{
-    template <class F, class Policies, class Sig>
-    struct impl
-    {
-        impl(F f, Policies p) : m_data(f,p) {}
-
-        PyObject* operator()(PyObject* args_, PyObject*) // eliminate
-                                                         // this
-                                                         // trailing
-                                                         // keyword dict
-        {
-            typedef typename mpl::begin<Sig>::type first;
-            typedef typename first::type result_t;
-            typedef typename select_result_converter<Policies, result_t>::type result_converter;
-            typedef typename Policies::argument_package argument_package;
-            
-            argument_package inner_args(args_);
-
-# if N
-#  define BOOST_PP_LOCAL_MACRO(i) BOOST_PYTHON_ARG_CONVERTER(i)
-#  define BOOST_PP_LOCAL_LIMITS (0, N-1)
-#  include BOOST_PP_LOCAL_ITERATE()
-# endif 
-            // all converters have been checked. Now we can do the
-            // precall part of the policy
-            if (!m_data.second().precall(inner_args))
-                return 0;
-
-            PyObject* result = detail::invoke(
-                detail::invoke_tag<result_t,F>()
-              , create_result_converter(args_, (result_converter*)0, (result_converter*)0)
-              , m_data.first()
-                BOOST_PP_ENUM_TRAILING_PARAMS(N, c)
-            );
-            
-            return m_data.second().postcall(inner_args, result);
-        }
-
-        static unsigned min_arity() { return N; }
-        
-        static signature_element const* signature()
-        {
-            return detail::signature<Sig>::elements();
-        }
-        
-     private:
-        compressed_pair<F,Policies> m_data;
-    };
-};
-
-
-
-#endif // BOOST_PP_IS_ITERATING 
-
-

include/boost/python/detail/config.hpp

@@ -1,117 +0,0 @@
-//  (C) Copyright David Abrahams 2000.
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-//  The author gratefully acknowleges the support of Dragon Systems, Inc., in
-//  producing this work.
-
-//  Revision History:
-//  04 Mar 01  Some fixes so it will compile with Intel C++ (Dave Abrahams)
-
-#ifndef CONFIG_DWA052200_H_
-# define CONFIG_DWA052200_H_
-
-# include <boost/config.hpp>
-# include <boost/detail/workaround.hpp>
-
-# ifdef BOOST_NO_OPERATORS_IN_NAMESPACE
-   // A gcc bug forces some symbols into the global namespace
-#  define BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
-#  define BOOST_PYTHON_END_CONVERSION_NAMESPACE
-#  define BOOST_PYTHON_CONVERSION
-#  define BOOST_PYTHON_IMPORT_CONVERSION(x) using ::x
-# else
-#  define BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE namespace boost { namespace python {
-#  define BOOST_PYTHON_END_CONVERSION_NAMESPACE }} // namespace boost::python
-#  define BOOST_PYTHON_CONVERSION boost::python
-#  define BOOST_PYTHON_IMPORT_CONVERSION(x) void never_defined() // so we can follow the macro with a ';'
-# endif
-
-# if defined(BOOST_MSVC)
-#  if _MSC_VER < 1300
-#   define BOOST_MSVC6_OR_EARLIER 1
-#  endif
-
-#  pragma warning (disable : 4786) // disable truncated debug symbols
-#  pragma warning (disable : 4251) // disable exported dll function
-#  pragma warning (disable : 4800) //'int' : forcing value to bool 'true' or 'false'
-#  pragma warning (disable : 4275) // non dll-interface class
-
-# elif defined(__ICL) && __ICL < 600 // Intel C++ 5
-
-#  pragma warning(disable: 985) // identifier was truncated in debug information
-
-# endif
-
-// The STLport puts all of the standard 'C' library names in std (as far as the
-// user is concerned), but without it you need a fix if you're using MSVC or
-// Intel C++
-# if defined(BOOST_NO_STDC_NAMESPACE)
-#  define BOOST_CSTD_
-# else
-#  define BOOST_CSTD_ std
-# endif
-
-/*****************************************************************************
- *
- *  Set up dll import/export options:
- *
- ****************************************************************************/
-
-// backwards compatibility:
-#ifdef BOOST_PYTHON_STATIC_LIB
-#  define BOOST_PYTHON_STATIC_LINK
-# elif !defined(BOOST_PYTHON_DYNAMIC_LIB)
-#  define BOOST_PYTHON_DYNAMIC_LIB
-#endif
-
-#if defined(BOOST_PYTHON_DYNAMIC_LIB)
-
-#  if !defined(_WIN32) && !defined(__CYGWIN__)                                  \
-    && !defined(BOOST_PYTHON_USE_GCC_SYMBOL_VISIBILITY)                         \
-    && BOOST_WORKAROUND(__GNUC__, >= 3) && (__GNUC_MINOR__ >=5 || __GNUC__ > 3)
-#    define BOOST_PYTHON_USE_GCC_SYMBOL_VISIBILITY 1
-#  endif 
-
-#  if BOOST_PYTHON_USE_GCC_SYMBOL_VISIBILITY
-#     if defined(BOOST_PYTHON_SOURCE)
-#        define BOOST_PYTHON_DECL __attribute__ ((visibility("default")))
-#        define BOOST_PYTHON_BUILD_DLL
-#     else
-#        define BOOST_PYTHON_DECL
-#     endif
-#     define BOOST_PYTHON_DECL_FORWARD
-#     define BOOST_PYTHON_DECL_EXCEPTION __attribute__ ((visibility("default")))
-#  elif (defined(_WIN32) || defined(__CYGWIN__))
-#     if defined(BOOST_PYTHON_SOURCE)
-#        define BOOST_PYTHON_DECL __declspec(dllexport)
-#        define BOOST_PYTHON_BUILD_DLL
-#     else
-#        define BOOST_PYTHON_DECL __declspec(dllimport)
-#     endif
-#  endif
-
-#endif
-
-#ifndef BOOST_PYTHON_DECL
-#  define BOOST_PYTHON_DECL
-#endif
-
-#ifndef BOOST_PYTHON_DECL_FORWARD
-#  define BOOST_PYTHON_DECL_FORWARD BOOST_PYTHON_DECL
-#endif
-
-#ifndef BOOST_PYTHON_DECL_EXCEPTION
-#  define BOOST_PYTHON_DECL_EXCEPTION BOOST_PYTHON_DECL
-#endif
-
-#if BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042))
-// Replace broken Tru64/cxx offsetof macro
-# define BOOST_PYTHON_OFFSETOF(s_name, s_member) \
-        ((size_t)__INTADDR__(&(((s_name *)0)->s_member)))
-#else
-# define BOOST_PYTHON_OFFSETOF offsetof
-#endif
-
-#endif // CONFIG_DWA052200_H_

include/boost/python/detail/construct.hpp

@@ -1,42 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 CONSTRUCT_REFERENCE_DWA2002716_HPP
-# define CONSTRUCT_REFERENCE_DWA2002716_HPP
-
-namespace boost { namespace python { namespace detail { 
-
-template <class T, class Arg>
-void construct_pointee(void* storage, Arg& x
-# if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
-                       , T const volatile*
-# else 
-                       , T const*
-# endif 
-    )
-{
-    new (storage) T(x);
-}
-
-template <class T, class Arg>
-void construct_referent_impl(void* storage, Arg& x, T&(*)())
-{
-    construct_pointee(storage, x, (T*)0);
-}
-
-template <class T, class Arg>
-void construct_referent(void* storage, Arg const& x, T(*tag)() = 0)
-{
-    construct_referent_impl(storage, x, tag);
-}
-
-template <class T, class Arg>
-void construct_referent(void* storage, Arg& x, T(*tag)() = 0)
-{
-    construct_referent_impl(storage, x, tag);
-}
-
-}}} // namespace boost::python::detail
-
-#endif // CONSTRUCT_REFERENCE_DWA2002716_HPP

include/boost/python/detail/convertible.hpp

@@ -1,38 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 CONVERTIBLE_DWA2002614_HPP
-# define CONVERTIBLE_DWA2002614_HPP
-
-# if defined(__EDG_VERSION__) && __EDG_VERSION__ <= 241
-#  include <boost/mpl/if.hpp>
-#  include <boost/type_traits/conversion_traits.hpp>
-# endif 
-
-// Supplies a runtime is_convertible check which can be used with tag
-// dispatching to work around the Metrowerks Pro7 limitation with boost::is_convertible
-namespace boost { namespace python { namespace detail { 
-
-typedef char* yes_convertible;
-typedef int* no_convertible;
-
-template <class Target>
-struct convertible
-{
-# if !defined(__EDG_VERSION__) || __EDG_VERSION__ > 241 || __EDG_VERSION__ == 238
-    static inline no_convertible check(...) { return 0; }
-    static inline yes_convertible check(Target) { return 0; }
-# else
-    template <class X>
-    static inline typename mpl::if_c<
-        is_convertible<X,Target>::value
-        , yes_convertible
-        , no_convertible
-        >::type check(X const&) { return 0; }
-# endif 
-};
-
-}}} // namespace boost::python::detail
-
-#endif // CONVERTIBLE_DWA2002614_HPP

include/boost/python/detail/copy_ctor_mutates_rhs.hpp

@@ -1,21 +0,0 @@
-// Copyright David Abrahams 2003.
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-#ifndef COPY_CTOR_MUTATES_RHS_DWA2003219_HPP
-# define COPY_CTOR_MUTATES_RHS_DWA2003219_HPP
-
-#include <boost/python/detail/is_auto_ptr.hpp>
-#include <boost/mpl/bool.hpp>
-
-namespace boost { namespace python { namespace detail { 
-
-template <class T>
-struct copy_ctor_mutates_rhs
-    : is_auto_ptr<T>
-{
-};
-
-}}} // namespace boost::python::detail
-
-#endif // COPY_CTOR_MUTATES_RHS_DWA2003219_HPP

include/boost/python/detail/cv_category.hpp

@@ -1,36 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 CV_CATEGORY_DWA200222_HPP
-# define CV_CATEGORY_DWA200222_HPP
-# include <boost/type_traits/cv_traits.hpp>
-
-namespace boost { namespace python { namespace detail { 
-
-template <bool is_const_, bool is_volatile_>
-struct cv_tag
-{
-    BOOST_STATIC_CONSTANT(bool, is_const = is_const_);
-    BOOST_STATIC_CONSTANT(bool, is_volatile = is_const_);
-};
-
-typedef cv_tag<false,false> cv_unqualified;
-typedef cv_tag<true,false> const_;
-typedef cv_tag<false,true> volatile_;
-typedef cv_tag<true,true> const_volatile_;
-
-template <class T>
-struct cv_category
-{
-//    BOOST_STATIC_CONSTANT(bool, c = is_const<T>::value);
-//    BOOST_STATIC_CONSTANT(bool, v = is_volatile<T>::value);
-    typedef cv_tag<
-        ::boost::is_const<T>::value
-      , ::boost::is_volatile<T>::value
-    > type;
-};
-
-}}} // namespace boost::python::detail
-
-#endif // CV_CATEGORY_DWA200222_HPP

include/boost/python/detail/dealloc.hpp

@@ -1,17 +0,0 @@
-// Copyright Gottfried Ganßauge 2003.
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-# ifndef BOOST_PYTHON_DETAIL_DEALLOC_HPP_
-# define BOOST_PYTHON_DETAIL_DEALLOC_HPP_
-namespace boost { namespace python { namespace detail {
-    extern "C"
-    {
-        inline void dealloc(PyObject* self)
-        {
-          PyObject_Del(self);
-        }
-    }
-}}} // namespace boost::python::detail
-# endif    // BOOST_PYTHON_DETAIL_DEALLOC_HPP_

include/boost/python/detail/decorated_type_id.hpp

@@ -1,76 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 DECORATED_TYPE_ID_DWA2002517_HPP
-# define DECORATED_TYPE_ID_DWA2002517_HPP
-
-# include <boost/python/type_id.hpp>
-# include <boost/python/detail/indirect_traits.hpp>
-# include <boost/type_traits/cv_traits.hpp>
-
-namespace boost { namespace python { namespace detail { 
-
-struct decorated_type_info : totally_ordered<decorated_type_info>
-{
-    enum decoration { const_ = 0x1, volatile_ = 0x2, reference = 0x4 };
-    
-    decorated_type_info(type_info, decoration = decoration());
-
-    inline bool operator<(decorated_type_info const& rhs) const;
-    inline bool operator==(decorated_type_info const& rhs) const;
-
-    friend BOOST_PYTHON_DECL std::ostream& operator<<(std::ostream&, decorated_type_info const&);
-
-    operator type_info const&() const;
- private: // type
-    typedef type_info base_id_t;
-    
- private: // data members
-    decoration m_decoration;
-    base_id_t m_base_type;
-};
-
-template <class T>
-inline decorated_type_info decorated_type_id(boost::type<T>* = 0)
-{
-    return decorated_type_info(
-        type_id<T>()
-        , decorated_type_info::decoration(
-            (is_const<T>::value || indirect_traits::is_reference_to_const<T>::value
-             ? decorated_type_info::const_ : 0)
-            | (is_volatile<T>::value || indirect_traits::is_reference_to_volatile<T>::value
-               ? decorated_type_info::volatile_ : 0)
-            | (is_reference<T>::value ? decorated_type_info::reference : 0)
-            )
-        );
-}
-
-inline decorated_type_info::decorated_type_info(type_info base_t, decoration decoration)
-    : m_decoration(decoration)
-    , m_base_type(base_t)
-{
-}
-
-inline bool decorated_type_info::operator<(decorated_type_info const& rhs) const
-{
-    return m_decoration < rhs.m_decoration
-        || m_decoration == rhs.m_decoration
-           && m_base_type < rhs.m_base_type;
-}
-
-inline bool decorated_type_info::operator==(decorated_type_info const& rhs) const
-{
-    return m_decoration == rhs.m_decoration && m_base_type == rhs.m_base_type;
-}
-
-inline decorated_type_info::operator type_info const&() const
-{
-    return m_base_type;
-}
-
-BOOST_PYTHON_DECL std::ostream& operator<<(std::ostream&, decorated_type_info const&);
-
-}}} // namespace boost::python::detail
-
-#endif // DECORATED_TYPE_ID_DWA2002517_HPP

include/boost/python/detail/decref_guard.hpp

@@ -1,21 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 DECREF_GUARD_DWA20021220_HPP
-# define DECREF_GUARD_DWA20021220_HPP
-
-namespace boost { namespace python { namespace detail { 
-
-struct decref_guard
-{
-    decref_guard(PyObject* o) : obj(o) {}
-    ~decref_guard() { Py_XDECREF(obj); }
-    void cancel() { obj = 0; }
- private:
-    PyObject* obj;
-};
-
-}}} // namespace boost::python::detail
-
-#endif // DECREF_GUARD_DWA20021220_HPP

include/boost/python/detail/def_helper.hpp

@@ -1,212 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 DEF_HELPER_DWA200287_HPP
-# define DEF_HELPER_DWA200287_HPP
-
-# include <boost/python/args.hpp>
-# include <boost/type_traits/ice.hpp>
-# include <boost/type_traits/same_traits.hpp>
-# include <boost/python/detail/indirect_traits.hpp>
-# include <boost/mpl/not.hpp>
-# include <boost/mpl/and.hpp>
-# include <boost/mpl/or.hpp>
-# include <boost/type_traits/add_reference.hpp>
-# include <boost/mpl/lambda.hpp>
-# include <boost/mpl/apply.hpp>
-# include <boost/tuple/tuple.hpp>
-# include <boost/python/detail/not_specified.hpp>
-# include <boost/python/detail/def_helper_fwd.hpp>
-
-namespace boost { namespace python {
-
-struct default_call_policies;
-
-namespace detail
-{
-  // tuple_extract<Tuple,Predicate>::extract(t) returns the first
-  // element of a Tuple whose type E satisfies the given Predicate
-  // applied to add_reference<E>. The Predicate must be an MPL
-  // metafunction class.
-  template <class Tuple, class Predicate>
-  struct tuple_extract;
-
-  // Implementation class for when the tuple's head type does not
-  // satisfy the Predicate
-  template <bool matched>
-  struct tuple_extract_impl
-  {
-      template <class Tuple, class Predicate>
-      struct apply
-      {
-          typedef typename Tuple::head_type result_type;
-          
-          static typename Tuple::head_type extract(Tuple const& x)
-          {
-              return x.get_head();
-          }
-      };
-  };
-
-  // Implementation specialization for when the tuple's head type
-  // satisfies the predicate
-  template <>
-  struct tuple_extract_impl<false>
-  {
-      template <class Tuple, class Predicate>
-      struct apply
-      {
-          // recursive application of tuple_extract on the tail of the tuple
-          typedef tuple_extract<typename Tuple::tail_type, Predicate> next;
-          typedef typename next::result_type result_type;
-          
-          static result_type extract(Tuple const& x)
-          {
-              return next::extract(x.get_tail());
-          }
-      };
-  };
-
-  // A metafunction which selects a version of tuple_extract_impl to
-  // use for the implementation of tuple_extract
-  template <class Tuple, class Predicate>
-  struct tuple_extract_base_select
-  {
-      typedef typename Tuple::head_type head_type;
-      typedef typename mpl::apply1<Predicate, typename add_reference<head_type>::type>::type match_t;
-      BOOST_STATIC_CONSTANT(bool, match = match_t::value);
-      typedef typename tuple_extract_impl<match>::template apply<Tuple,Predicate> type;
-  };
-  
-  template <class Tuple, class Predicate>
-  struct tuple_extract
-      : tuple_extract_base_select<
-         Tuple
-         , typename mpl::lambda<Predicate>::type
-      >::type
-  {
-  };
-
-
-  //
-  // Specialized extractors for the docstring, keywords, CallPolicies,
-  // and default implementation of virtual functions
-  //
-
-  template <class Tuple>
-  struct doc_extract
-      : tuple_extract<
-        Tuple
-        , mpl::not_<
-           mpl::or_<
-               indirect_traits::is_reference_to_class<mpl::_1>
-             , indirect_traits::is_reference_to_member_function_pointer<mpl::_1 >
-           >
-        >
-     >
-  {
-  };
-  
-  template <class Tuple>
-  struct keyword_extract
-      : tuple_extract<Tuple, is_reference_to_keywords<mpl::_1 > >
-  {
-  };
-
-  template <class Tuple>
-  struct policy_extract
-      : tuple_extract<
-          Tuple
-          , mpl::and_<
-             mpl::not_<is_same<not_specified const&,mpl::_1> >
-              , indirect_traits::is_reference_to_class<mpl::_1 >
-              , mpl::not_<is_reference_to_keywords<mpl::_1 > >
-          >
-        >
-  {
-  };
-
-  template <class Tuple>
-  struct default_implementation_extract
-      : tuple_extract<
-          Tuple
-          , indirect_traits::is_reference_to_member_function_pointer<mpl::_1 >
-          >
-  {
-  };
-
-  //
-  // A helper class for decoding the optional arguments to def()
-  // invocations, which can be supplied in any order and are
-  // discriminated by their type properties. The template parameters
-  // are expected to be the types of the actual (optional) arguments
-  // passed to def().
-  //
-  template <class T1, class T2, class T3, class T4>
-  struct def_helper
-  {
-      // A tuple type which begins with references to the supplied
-      // arguments and ends with actual representatives of the default
-      // types.
-      typedef boost::tuples::tuple<
-          T1 const&
-          , T2 const&
-          , T3 const&
-          , T4 const&
-          , default_call_policies
-          , keywords<0>
-          , char const*
-          , void(not_specified::*)()   // A function pointer type which is never an
-                                       // appropriate default implementation
-          > all_t;
-
-      // Constructors; these initialize an member of the tuple type
-      // shown above.
-      def_helper(T1 const& a1) : m_all(a1,m_nil,m_nil,m_nil) {}
-      def_helper(T1 const& a1, T2 const& a2) : m_all(a1,a2,m_nil,m_nil) {}
-      def_helper(T1 const& a1, T2 const& a2, T3 const& a3) : m_all(a1,a2,a3,m_nil) {}
-      def_helper(T1 const& a1, T2 const& a2, T3 const& a3, T4 const& a4) : m_all(a1,a2,a3,a4) {}
-
-   private: // types
-      typedef typename default_implementation_extract<all_t>::result_type default_implementation_t;
-      
-   public: // Constants which can be used for static assertions.
-
-      // Users must not supply a default implementation for non-class
-      // methods.
-      BOOST_STATIC_CONSTANT(
-          bool, has_default_implementation = (
-              !is_same<default_implementation_t, void(not_specified::*)()>::value));
-      
-   public: // Extractor functions which pull the appropriate value out
-           // of the tuple
-      char const* doc() const
-      {
-          return doc_extract<all_t>::extract(m_all);
-      }
-      
-      typename keyword_extract<all_t>::result_type keywords() const
-      {
-          return keyword_extract<all_t>::extract(m_all);
-      }
-      
-      typename policy_extract<all_t>::result_type policies() const
-      {
-          return policy_extract<all_t>::extract(m_all);
-      }
-
-      default_implementation_t default_implementation() const
-      {
-          return default_implementation_extract<all_t>::extract(m_all);
-      }
-      
-   private: // data members
-      all_t m_all; 
-      not_specified m_nil; // for filling in not_specified slots
-  };
-}
-
-}} // namespace boost::python::detail
-
-#endif // DEF_HELPER_DWA200287_HPP

include/boost/python/detail/def_helper_fwd.hpp

@@ -1,17 +0,0 @@
-// Copyright David Abrahams 2003.
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-#ifndef DEF_HELPER_FWD_DWA2003810_HPP
-# define DEF_HELPER_FWD_DWA2003810_HPP
-
-# include <boost/python/detail/not_specified.hpp>
-
-namespace boost { namespace python { namespace detail { 
-
-template <class T1, class T2 = not_specified, class T3 = not_specified, class T4 = not_specified>
-struct def_helper;
-
-}}} // namespace boost::python::detail
-
-#endif // DEF_HELPER_FWD_DWA2003810_HPP

include/boost/python/detail/defaults_def.hpp

@@ -1,291 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-// Copyright David Abrahams 2002, Joel de Guzman, 2002.
-// 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)
-//
-///////////////////////////////////////////////////////////////////////////////
-#if !defined(BOOST_PP_IS_ITERATING)
-
-#ifndef DEFAULTS_DEF_JDG20020811_HPP
-#define DEFAULTS_DEF_JDG20020811_HPP
-
-#include <boost/python/detail/defaults_gen.hpp>
-#include <boost/type_traits.hpp>
-#include <boost/mpl/front.hpp>
-#include <boost/mpl/size.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/preprocessor/iterate.hpp>
-#include <boost/python/class_fwd.hpp>
-#include <boost/python/scope.hpp>
-#include <boost/preprocessor/debug/line.hpp>
-#include <boost/python/detail/scope.hpp>
-#include <boost/python/detail/make_keyword_range_fn.hpp>
-#include <boost/python/object/add_to_namespace.hpp>
-
-///////////////////////////////////////////////////////////////////////////////
-namespace boost { namespace python {
-
-struct module;
-
-namespace objects
-{
-  struct class_base;
-}
-
-namespace detail
-{
-  // Called as::
-  //
-  //    name_space_def(ns, "func", func, kw, policies, docstring, &ns)
-  //
-  // Dispatch to properly add f to namespace ns.
-  //
-  // @group define_stub_function helpers { 
-  template <class Func, class CallPolicies, class NameSpaceT>
-  static void name_space_def(
-      NameSpaceT& name_space
-      , char const* name
-      , Func f
-      , keyword_range const& kw
-      , CallPolicies const& policies
-      , char const* doc
-      , objects::class_base*
-      )
-  {
-      typedef typename NameSpaceT::wrapped_type wrapped_type;
-      
-      objects::add_to_namespace(
-          name_space, name,
-          detail::make_keyword_range_function(
-              f, policies, kw, get_signature(f, (wrapped_type*)0))
-        , doc
-      );
-  }
-
-  template <class Func, class CallPolicies>
-  static void name_space_def(
-      object& name_space
-      , char const* name
-      , Func f
-      , keyword_range const& kw
-      , CallPolicies const& policies
-      , char const* doc
-      , ...
-      )
-  {
-      scope within(name_space);
-
-      detail::scope_setattr_doc(
-          name
-          , detail::make_keyword_range_function(f, policies, kw)
-          , doc);
-  }
-
-  // For backward compatibility -- is this obsolete?
-  template <class Func, class CallPolicies, class NameSpaceT>
-  static void name_space_def(
-      NameSpaceT& name_space
-      , char const* name
-      , Func f
-      , keyword_range const& kw // ignored
-      , CallPolicies const& policies
-      , char const* doc
-      , module*
-      )
-  {
-      name_space.def(name, f, policies, doc);
-  }
-  // }
-
-
-  //  Expansions of ::
-  //
-  //      template <typename OverloadsT, typename NameSpaceT>
-  //      inline void
-  //      define_stub_function(
-  //          char const* name, OverloadsT s, NameSpaceT& name_space, mpl::int_<N>)
-  //      {
-  //          name_space.def(name, &OverloadsT::func_N);
-  //      }
-  //
-  //  where N runs from 0 to BOOST_PYTHON_MAX_ARITY.
-  //
-  //  The set of overloaded functions (define_stub_function) expects:
-  //
-  //      1. char const* name:        function name that will be visible to python
-  //      2. OverloadsT:              a function overloads struct (see defaults_gen.hpp)
-  //      3. NameSpaceT& name_space:  a python::class_ or python::module instance
-  //      4. int_t<N>:                the Nth overloaded function (OverloadsT::func_N)
-  //                                  (see defaults_gen.hpp)
-  //      5. char const* name:        doc string
-  //
-  // @group define_stub_function<N> {
-  template <int N>
-  struct define_stub_function {};
-
-#define BOOST_PP_ITERATION_PARAMS_1                                             \
-    (3, (0, BOOST_PYTHON_MAX_ARITY, <boost/python/detail/defaults_def.hpp>))
-
-#include BOOST_PP_ITERATE()
-  
-  // }
-  
-  //  This helper template struct does the actual recursive
-  //  definition.  There's a generic version
-  //  define_with_defaults_helper<N> and a terminal case
-  //  define_with_defaults_helper<0>. The struct and its
-  //  specialization has a sole static member function def that
-  //  expects:
-  //
-  //    1. char const* name:        function name that will be
-  //                                visible to python
-  //
-  //    2. OverloadsT:              a function overloads struct
-  //                                (see defaults_gen.hpp)
-  //
-  //    3. NameSpaceT& name_space:  a python::class_ or
-  //                                python::module instance
-  //
-  //    4. char const* name:        doc string
-  //
-  //  The def static member function calls a corresponding
-  //  define_stub_function<N>. The general case recursively calls
-  //  define_with_defaults_helper<N-1>::def until it reaches the
-  //  terminal case case define_with_defaults_helper<0>.
-  template <int N>
-  struct define_with_defaults_helper {
-
-      template <class StubsT, class CallPolicies, class NameSpaceT>
-      static void
-      def(
-          char const* name,
-          StubsT stubs,
-          keyword_range kw,
-          CallPolicies const& policies,
-          NameSpaceT& name_space,
-          char const* doc)
-      {
-          //  define the NTH stub function of stubs
-          define_stub_function<N>::define(name, stubs, kw, policies, name_space, 0);
-
-          if (kw.second > kw.first)
-              --kw.second;
-
-          //  call the next define_with_defaults_helper
-          define_with_defaults_helper<N-1>::def(name, stubs, kw, policies, name_space, doc);
-      }
-  };
-
-  template <>
-  struct define_with_defaults_helper<0> {
-
-      template <class StubsT, class CallPolicies, class NameSpaceT>
-      static void
-      def(
-          char const* name,
-          StubsT stubs,
-          keyword_range const& kw,
-          CallPolicies const& policies,
-          NameSpaceT& name_space,
-          char const* doc)
-      {
-          //  define the Oth stub function of stubs
-          define_stub_function<0>::define(name, stubs, kw, policies, name_space, doc);
-          //  return
-      }
-  };
-
-  //  define_with_defaults
-  //
-  //      1. char const* name:        function name that will be
-  //                                  visible to python
-  //
-  //      2. OverloadsT:              a function overloads struct
-  //                                  (see defaults_gen.hpp)
-  //
-  //      3. CallPolicies& policies:  Call policies
-  //      4. NameSpaceT& name_space:  a python::class_ or
-  //                                  python::module instance
-  //
-  //      5. SigT sig:                Function signature typelist
-  //                                  (see defaults_gen.hpp)
-  //
-  //      6. char const* name:        doc string
-  //
-  //  This is the main entry point. This function recursively
-  //  defines all stub functions of StubT (see defaults_gen.hpp) in
-  //  NameSpaceT name_space which can be either a python::class_ or
-  //  a python::module. The sig argument is a typelist that
-  //  specifies the return type, the class (for member functions,
-  //  and the arguments. Here are some SigT examples:
-  //
-  //      int foo(int)        mpl::vector<int, int>
-  //      void bar(int, int)  mpl::vector<void, int, int>
-  //      void C::foo(int)    mpl::vector<void, C, int>
-  //
-  template <class OverloadsT, class NameSpaceT, class SigT>
-  inline void
-  define_with_defaults(
-      char const* name,
-      OverloadsT const& overloads,
-      NameSpaceT& name_space,
-      SigT const&)
-  {
-      typedef typename mpl::front<SigT>::type return_type;
-      typedef typename OverloadsT::void_return_type void_return_type;
-      typedef typename OverloadsT::non_void_return_type non_void_return_type;
-
-      typedef typename mpl::if_c<
-          boost::is_same<void, return_type>::value
-          , void_return_type
-          , non_void_return_type
-      >::type stubs_type;
-
-      BOOST_STATIC_ASSERT(
-          (stubs_type::max_args) <= mpl::size<SigT>::value);
-
-      typedef typename stubs_type::template gen<SigT> gen_type;
-      define_with_defaults_helper<stubs_type::n_funcs-1>::def(
-          name
-          , gen_type()
-          , overloads.keywords()
-          , overloads.call_policies()
-          , name_space
-          , overloads.doc_string());
-  }
-
-} // namespace detail
-
-}} // namespace boost::python
-
-#endif // DEFAULTS_DEF_JDG20020811_HPP
-
-#else // defined(BOOST_PP_IS_ITERATING)
-// PP vertical iteration code
-
-
-template <>
-struct define_stub_function<BOOST_PP_ITERATION()> {
-    template <class StubsT, class CallPolicies, class NameSpaceT>
-    static void define(
-        char const* name
-        , StubsT const&
-        , keyword_range const& kw
-        , CallPolicies const& policies
-        , NameSpaceT& name_space
-        , char const* doc)
-    {
-        detail::name_space_def(
-            name_space
-            , name
-            , &StubsT::BOOST_PP_CAT(func_, BOOST_PP_ITERATION())
-            , kw
-            , policies
-            , doc
-            , &name_space);
-    }
-};
-
-#endif // !defined(BOOST_PP_IS_ITERATING)

include/boost/python/detail/defaults_gen.hpp

@@ -1,388 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-// Copyright David Abrahams 2002, Joel de Guzman, 2002.
-// 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 DEFAULTS_GEN_JDG20020807_HPP
-#define DEFAULTS_GEN_JDG20020807_HPP
-
-#include <boost/python/detail/preprocessor.hpp>
-#include <boost/preprocessor/repeat.hpp>
-#include <boost/preprocessor/repeat_from_to.hpp>
-#include <boost/preprocessor/enum.hpp>
-#include <boost/preprocessor/enum_params.hpp>
-#include <boost/preprocessor/repetition/enum_binary_params.hpp>
-#include <boost/preprocessor/tuple.hpp>
-#include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/arithmetic/sub.hpp>
-#include <boost/preprocessor/stringize.hpp>
-#include <boost/preprocessor/inc.hpp>
-#include <boost/preprocessor/empty.hpp>
-#include <boost/preprocessor/comma_if.hpp>
-#include <boost/config.hpp>
-#include <boost/mpl/begin_end.hpp>
-#include <boost/mpl/next.hpp>
-#include <boost/mpl/deref.hpp>
-#include <cstddef>
-
-namespace boost { namespace python {
-
-namespace detail
-{
-  // overloads_base is used as a base class for all function
-  // stubs. This class holds the doc_string of the stubs.
-  struct overloads_base
-  {
-      overloads_base(char const* doc_)
-          : m_doc(doc_) {}
-
-      overloads_base(char const* doc_, detail::keyword_range const& kw)
-          : m_doc(doc_), m_keywords(kw) {}
-
-      char const* doc_string() const
-      {
-          return m_doc;
-      }
-
-      detail::keyword_range const& keywords() const
-      {
-          return m_keywords;
-      }
-
-   private:
-      char const* m_doc;
-      detail::keyword_range m_keywords;
-  };
-
-  // overloads_proxy is generated by the overloads_common operator[] (see
-  // below). This class holds a user defined call policies of the stubs.
-  template <class CallPoliciesT, class OverloadsT>
-  struct overloads_proxy
-      : public overloads_base
-  {
-      typedef typename OverloadsT::non_void_return_type   non_void_return_type;
-      typedef typename OverloadsT::void_return_type       void_return_type;
-
-      overloads_proxy(
-          CallPoliciesT const& policies_
-          , char const* doc
-          , keyword_range const& kw
-          )
-          : overloads_base(doc, kw)
-            , policies(policies_)
-      {}
-
-      CallPoliciesT
-      call_policies() const
-      {
-          return policies;
-      }
-
-      CallPoliciesT policies;
-  };
-
-  // overloads_common is our default function stubs base class. This
-  // class returns the default_call_policies in its call_policies()
-  // member function.  It can generate a overloads_proxy however through
-  // its operator[]
-  template <class DerivedT>
-  struct overloads_common
-      : public overloads_base
-  {
-      overloads_common(char const* doc)
-          : overloads_base(doc) {}
-
-      overloads_common(char const* doc, keyword_range const& kw)
-          : overloads_base(doc, kw) {}
-
-      default_call_policies
-      call_policies() const
-      {
-          return default_call_policies();
-      }
-
-      template <class CallPoliciesT>
-      overloads_proxy<CallPoliciesT, DerivedT>
-      operator[](CallPoliciesT const& policies) const
-      {
-          return overloads_proxy<CallPoliciesT, DerivedT>(
-              policies, this->doc_string(), this->keywords());
-      }
-  };
-
-}}} // namespace boost::python::detail
-
-
-#define BOOST_PYTHON_TYPEDEF_GEN(z, index, data)                                \
-    typedef typename ::boost::mpl::next<BOOST_PP_CAT(iter, index)>::type        \
-        BOOST_PP_CAT(iter, BOOST_PP_INC(index));                                \
-    typedef typename ::boost::mpl::deref<BOOST_PP_CAT(iter, index)>::type       \
-        BOOST_PP_CAT(T, index);
-
-#define BOOST_PYTHON_FUNC_WRAPPER_GEN(z, index, data)                   \
-    static RT BOOST_PP_CAT(func_,                                       \
-        BOOST_PP_SUB_D(1, index, BOOST_PP_TUPLE_ELEM(3, 1, data))) (    \
-        BOOST_PP_ENUM_BINARY_PARAMS_Z(                                  \
-            1, index, T, arg))                                          \
-    {                                                                   \
-        BOOST_PP_TUPLE_ELEM(3, 2, data)                                 \
-        BOOST_PP_TUPLE_ELEM(3, 0, data)(                                \
-            BOOST_PP_ENUM_PARAMS(                                       \
-                index,                                                  \
-                arg));                                                  \
-    }
-
-#define BOOST_PYTHON_GEN_FUNCTION(fname, fstubs_name, n_args, n_dflts, ret)     \
-    struct fstubs_name                                                          \
-    {                                                                           \
-        BOOST_STATIC_CONSTANT(int, n_funcs = BOOST_PP_INC(n_dflts));            \
-        BOOST_STATIC_CONSTANT(int, max_args = n_funcs);                         \
-                                                                                \
-        template <typename SigT>                                                \
-        struct gen                                                              \
-        {                                                                       \
-            typedef typename ::boost::mpl::begin<SigT>::type rt_iter;           \
-            typedef typename ::boost::mpl::deref<rt_iter>::type RT;             \
-            typedef typename ::boost::mpl::next<rt_iter>::type iter0;           \
-                                                                                \
-            BOOST_PP_REPEAT_2ND(                                                \
-                n_args,                                                         \
-                BOOST_PYTHON_TYPEDEF_GEN,                                       \
-                0)                                                              \
-                                                                                \
-            BOOST_PP_REPEAT_FROM_TO_2(                                          \
-                BOOST_PP_SUB_D(1, n_args, n_dflts),                             \
-                BOOST_PP_INC(n_args),                                           \
-                BOOST_PYTHON_FUNC_WRAPPER_GEN,                                  \
-                (fname, BOOST_PP_SUB_D(1, n_args, n_dflts), ret))               \
-        };                                                                      \
-    };                                                                          \
-
-///////////////////////////////////////////////////////////////////////////////
-#define BOOST_PYTHON_MEM_FUNC_WRAPPER_GEN(z, index, data)                       \
-    static RT BOOST_PP_CAT(func_,                                               \
-        BOOST_PP_SUB_D(1, index, BOOST_PP_TUPLE_ELEM(3, 1, data))) (            \
-            ClassT obj BOOST_PP_COMMA_IF(index)                                 \
-            BOOST_PP_ENUM_BINARY_PARAMS_Z(1, index, T, arg)                     \
-        )                                                                       \
-    {                                                                           \
-        BOOST_PP_TUPLE_ELEM(3, 2, data) obj.BOOST_PP_TUPLE_ELEM(3, 0, data)(    \
-            BOOST_PP_ENUM_PARAMS(index, arg)                                    \
-        );                                                                      \
-    }
-
-#define BOOST_PYTHON_GEN_MEM_FUNCTION(fname, fstubs_name, n_args, n_dflts, ret) \
-    struct fstubs_name                                                          \
-    {                                                                           \
-        BOOST_STATIC_CONSTANT(int, n_funcs = BOOST_PP_INC(n_dflts));            \
-        BOOST_STATIC_CONSTANT(int, max_args = n_funcs + 1);                     \
-                                                                                \
-        template <typename SigT>                                                \
-        struct gen                                                              \
-        {                                                                       \
-            typedef typename ::boost::mpl::begin<SigT>::type rt_iter;           \
-            typedef typename ::boost::mpl::deref<rt_iter>::type RT;             \
-                                                                                \
-            typedef typename ::boost::mpl::next<rt_iter>::type class_iter;      \
-            typedef typename ::boost::mpl::deref<class_iter>::type ClassT;      \
-            typedef typename ::boost::mpl::next<class_iter>::type iter0;        \
-                                                                                \
-            BOOST_PP_REPEAT_2ND(                                                \
-                n_args,                                                         \
-                BOOST_PYTHON_TYPEDEF_GEN,                                       \
-                0)                                                              \
-                                                                                \
-            BOOST_PP_REPEAT_FROM_TO_2(                                          \
-                BOOST_PP_SUB_D(1, n_args, n_dflts),                             \
-                BOOST_PP_INC(n_args),                                           \
-                BOOST_PYTHON_MEM_FUNC_WRAPPER_GEN,                              \
-                (fname, BOOST_PP_SUB_D(1, n_args, n_dflts), ret))               \
-        };                                                                      \
-    };
-
-#define BOOST_PYTHON_OVERLOAD_CONSTRUCTORS(fstubs_name, n_args, n_dflts)                    \
-    fstubs_name(char const* doc = 0)                                                        \
-        : ::boost::python::detail::overloads_common<fstubs_name>(doc) {}                    \
-    template <std::size_t N>                                                                \
-    fstubs_name(char const* doc, ::boost::python::detail::keywords<N> const& keywords)      \
-        : ::boost::python::detail::overloads_common<fstubs_name>(                           \
-            doc, keywords.range())                                                          \
-    {                                                                                       \
-        typedef typename ::boost::python::detail::                                          \
-            error::more_keywords_than_function_arguments<                                   \
-                N,n_args>::too_many_keywords assertion;                                     \
-    }                                                                                       \
-    template <std::size_t N>                                                                \
-    fstubs_name(::boost::python::detail::keywords<N> const& keywords, char const* doc = 0)  \
-        : ::boost::python::detail::overloads_common<fstubs_name>(                           \
-            doc, keywords.range())                                                          \
-    {                                                                                       \
-        typedef typename ::boost::python::detail::                                          \
-            error::more_keywords_than_function_arguments<                                   \
-                N,n_args>::too_many_keywords assertion;                                     \
-    }
-
-# if defined(BOOST_NO_VOID_RETURNS)
-
-#  define BOOST_PYTHON_GEN_FUNCTION_STUB(fname, fstubs_name, n_args, n_dflts)   \
-    struct fstubs_name                                                          \
-        : public ::boost::python::detail::overloads_common<fstubs_name>         \
-    {                                                                           \
-        BOOST_PYTHON_GEN_FUNCTION(                                              \
-            fname, non_void_return_type, n_args, n_dflts, return)               \
-        BOOST_PYTHON_GEN_FUNCTION(                                              \
-            fname, void_return_type, n_args, n_dflts, ;)                        \
-                                                                                \
-        BOOST_PYTHON_OVERLOAD_CONSTRUCTORS(fstubs_name, n_args, n_dflts)        \
-    };
-
-#  define BOOST_PYTHON_GEN_MEM_FUNCTION_STUB(fname, fstubs_name, n_args, n_dflts)       \
-    struct fstubs_name                                                                  \
-        : public ::boost::python::detail::overloads_common<fstubs_name>                 \
-    {                                                                                   \
-        BOOST_PYTHON_GEN_MEM_FUNCTION(                                                  \
-            fname, non_void_return_type, n_args, n_dflts, return)                       \
-        BOOST_PYTHON_GEN_MEM_FUNCTION(                                                  \
-            fname, void_return_type, n_args, n_dflts, ;)                                \
-                                                                                        \
-        BOOST_PYTHON_OVERLOAD_CONSTRUCTORS(fstubs_name, n_args, n_dflts)                \
-    };
-
-# else // !defined(BOOST_NO_VOID_RETURNS)
-
-#  define BOOST_PYTHON_GEN_FUNCTION_STUB(fname, fstubs_name, n_args, n_dflts)   \
-    struct fstubs_name                                                          \
-        : public ::boost::python::detail::overloads_common<fstubs_name>         \
-    {                                                                           \
-        BOOST_PYTHON_GEN_FUNCTION(                                              \
-            fname, non_void_return_type, n_args, n_dflts, return)               \
-                                                                                \
-        typedef non_void_return_type void_return_type;                          \
-        BOOST_PYTHON_OVERLOAD_CONSTRUCTORS(fstubs_name, n_args, n_dflts)        \
-    };
-
-
-#  define BOOST_PYTHON_GEN_MEM_FUNCTION_STUB(fname, fstubs_name, n_args, n_dflts)       \
-    struct fstubs_name                                                                  \
-        : public ::boost::python::detail::overloads_common<fstubs_name>                 \
-    {                                                                                   \
-        BOOST_PYTHON_GEN_MEM_FUNCTION(                                                  \
-            fname, non_void_return_type, n_args, n_dflts, return)                       \
-                                                                                        \
-        typedef non_void_return_type void_return_type;                                  \
-        BOOST_PYTHON_OVERLOAD_CONSTRUCTORS(fstubs_name, n_args, n_dflts)                \
-    };
-
-# endif // !defined(BOOST_NO_VOID_RETURNS)
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//  MAIN MACROS
-//
-//      Given generator_name, fname, min_args and max_args, These macros
-//      generate function stubs that forward to a function or member function
-//      named fname. max_args is the arity of the function or member function
-//      fname. fname can have default arguments. min_args is the minimum
-//      arity that fname can accept.
-//
-//      There are two versions:
-//
-//          1. BOOST_PYTHON_FUNCTION_OVERLOADS for free functions
-//          2. BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS for member functions.
-//
-//      For instance, given a function:
-//
-//      int
-//      foo(int a, char b = 1, unsigned c = 2, double d = 3)
-//      {
-//          return a + b + c + int(d);
-//      }
-//
-//      The macro invocation:
-//
-//          BOOST_PYTHON_FUNCTION_OVERLOADS(foo_stubs, foo, 1, 4)
-//
-//      Generates this code:
-//
-//      struct foo_stubsNonVoid
-//      {
-//          static const int n_funcs = 4;
-//          static const int max_args = n_funcs;
-//
-//          template <typename SigT>
-//          struct gen
-//          {
-//              typedef typename ::boost::mpl::begin<SigT>::type    rt_iter;
-//              typedef typename rt_iter::type                      RT;
-//              typedef typename rt_iter::next                      iter0;
-//              typedef typename iter0::type                        T0;
-//              typedef typename iter0::next                        iter1;
-//              typedef typename iter1::type                        T1;
-//              typedef typename iter1::next                        iter2;
-//              typedef typename iter2::type                        T2;
-//              typedef typename iter2::next                        iter3;
-//              typedef typename iter3::type                        T3;
-//              typedef typename iter3::next                        iter4;
-//
-//              static RT func_0(T0 arg0)
-//              { return foo(arg0); }
-//
-//              static RT func_1(T0 arg0, T1 arg1)
-//              { return foo(arg0, arg1); }
-//
-//              static RT func_2(T0 arg0, T1 arg1, T2 arg2)
-//              { return foo(arg0, arg1, arg2); }
-//
-//              static RT func_3(T0 arg0, T1 arg1, T2 arg2, T3 arg3)
-//              { return foo(arg0, arg1, arg2, arg3); }
-//          };
-//      };
-//
-//      struct foo_overloads
-//          : public boost::python::detail::overloads_common<foo_overloads>
-//      {
-//          typedef foo_overloadsNonVoid    non_void_return_type;
-//          typedef foo_overloadsNonVoid    void_return_type;
-//
-//          foo_overloads(char const* doc = 0)
-//             : boost::python::detail::overloads_common<foo_overloads>(doc) {}
-//      };
-//
-//      The typedefs non_void_return_type and void_return_type are
-//      used to handle compilers that do not support void returns. The
-//      example above typedefs non_void_return_type and
-//      void_return_type to foo_overloadsNonVoid. On compilers that do
-//      not support void returns, there are two versions:
-//      foo_overloadsNonVoid and foo_overloadsVoid.  The "Void"
-//      version is almost identical to the "NonVoid" version except
-//      for the return type (void) and the lack of the return keyword.
-//
-//      See the overloads_common above for a description of the
-//      foo_overloads' base class.
-//
-///////////////////////////////////////////////////////////////////////////////
-#define BOOST_PYTHON_FUNCTION_OVERLOADS(generator_name, fname, min_args, max_args)          \
-    BOOST_PYTHON_GEN_FUNCTION_STUB(                                                         \
-        fname,                                                                              \
-        generator_name,                                                                     \
-        max_args,                                                                           \
-        BOOST_PP_SUB_D(1, max_args, min_args))
-
-#define BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(generator_name, fname, min_args, max_args)   \
-    BOOST_PYTHON_GEN_MEM_FUNCTION_STUB(                                                     \
-        fname,                                                                              \
-        generator_name,                                                                     \
-        max_args,                                                                           \
-        BOOST_PP_SUB_D(1, max_args, min_args))
-
-// deprecated macro names (to be removed)
-#define BOOST_PYTHON_FUNCTION_GENERATOR BOOST_PYTHON_FUNCTION_OVERLOADS
-#define BOOST_PYTHON_MEM_FUN_GENERATOR BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS
-
-///////////////////////////////////////////////////////////////////////////////
-#endif // DEFAULTS_GEN_JDG20020807_HPP
-
-

include/boost/python/detail/dependent.hpp

@@ -1,27 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 DEPENDENT_DWA200286_HPP
-# define DEPENDENT_DWA200286_HPP
-
-namespace boost { namespace python { namespace detail { 
-
-// A way to turn a concrete type T into a type dependent on U. This
-// keeps conforming compilers (those implementing proper 2-phase
-// name lookup for templates) from complaining about incomplete
-// types in situations where it would otherwise be inconvenient or
-// impossible to re-order code so that all types are defined in time.
-
-// One such use is when we must return an incomplete T from a member
-// function template (which must be defined in the class body to
-// keep MSVC happy).
-template <class T, class U>
-struct dependent
-{
-    typedef T type;
-};
-
-}}} // namespace boost::python::detail
-
-#endif // DEPENDENT_DWA200286_HPP

include/boost/python/detail/destroy.hpp

@@ -1,106 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 DESTROY_DWA2002221_HPP
-# define DESTROY_DWA2002221_HPP
-
-# include <boost/type_traits/is_array.hpp>
-# include <boost/detail/workaround.hpp>
-# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
-#  include <boost/type_traits/is_enum.hpp>
-# endif 
-namespace boost { namespace python { namespace detail { 
-
-template <
-    bool array
-# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
-  , bool enum_  // vc7 has a problem destroying enums
-# endif 
-    > struct value_destroyer;
-    
-template <>
-struct value_destroyer<
-    false
-# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
-  , false
-# endif 
-    >
-{
-    template <class T>
-    static void execute(T const volatile* p)
-    {
-        p->T::~T();
-    }
-};
-
-template <>
-struct value_destroyer<
-    true
-# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
-  , false
-# endif 
-    >
-{
-    template <class A, class T>
-    static void execute(A*, T const volatile* const first)
-    {
-        for (T const volatile* p = first; p != first + sizeof(A)/sizeof(T); ++p)
-        {
-            value_destroyer<
-                boost::is_array<T>::value
-# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
-              , boost::is_enum<T>::value
-# endif 
-            >::execute(p);
-        }
-    }
-    
-    template <class T>
-    static void execute(T const volatile* p)
-    {
-        execute(p, *p);
-    }
-};
-
-# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
-template <>
-struct value_destroyer<true,true>
-{
-    template <class T>
-    static void execute(T const volatile*)
-    {
-    }
-};
-
-template <>
-struct value_destroyer<false,true>
-{
-    template <class T>
-    static void execute(T const volatile*)
-    {
-    }
-};
-# endif 
-template <class T>
-inline void destroy_referent_impl(void* p, T& (*)())
-{
-    // note: cv-qualification needed for MSVC6
-    // must come *before* T for metrowerks
-    value_destroyer<
-         (boost::is_array<T>::value)
-# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
-       , (boost::is_enum<T>::value)
-# endif 
-    >::execute((const volatile T*)p);
-}
-
-template <class T>
-inline void destroy_referent(void* p, T(*)() = 0)
-{
-    destroy_referent_impl(p, (T(*)())0);
-}
-
-}}} // namespace boost::python::detail
-
-#endif // DESTROY_DWA2002221_HPP

include/boost/python/detail/enable_if.hpp

@@ -1,72 +0,0 @@
-// Copyright David Abrahams 2004. Distributed under the Boost
-// Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#ifndef ENABLE_IF_DWA2004722_HPP
-# define ENABLE_IF_DWA2004722_HPP
-
-# include <boost/python/detail/sfinae.hpp>
-# include <boost/detail/workaround.hpp>
-
-# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-#  include <boost/mpl/if.hpp>
-
-namespace boost { namespace python { namespace detail { 
-
-template <class T> struct always_void { typedef void type; };
-
-template <class C, class T = int>
-struct enable_if_arg
-{
-    typedef typename mpl::if_<C,T,int&>::type type;
-};
-             
-template <class C, class T = int>
-struct disable_if_arg
-{
-    typedef typename mpl::if_<C,int&,T>::type type;
-};
-             
-template <class C, class T = typename always_void<C>::type>
-struct enable_if_ret
-{
-    typedef typename mpl::if_<C,T,int[2]>::type type;
-};
-             
-template <class C, class T = typename always_void<C>::type>
-struct disable_if_ret
-{
-    typedef typename mpl::if_<C,int[2],T>::type type;
-};
-             
-}}} // namespace boost::python::detail
-
-# elif !defined(BOOST_NO_SFINAE)
-#  include <boost/utility/enable_if.hpp>
-
-namespace boost { namespace python { namespace detail { 
-
-template <class C, class T = int>
-struct enable_if_arg
-  : enable_if<C,T>
-{};
-             
-template <class C, class T = int>
-struct disable_if_arg
-  : disable_if<C,T>
-{};
-             
-template <class C, class T = void>
-struct enable_if_ret
-  : enable_if<C,T>
-{};
-             
-template <class C, class T = void>
-struct disable_if_ret
-  : disable_if<C,T>
-{};
-             
-}}} // namespace boost::python::detail
-
-# endif
-
-#endif // ENABLE_IF_DWA2004722_HPP

include/boost/python/detail/exception_handler.hpp

@@ -1,48 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 EXCEPTION_HANDLER_DWA2002810_HPP
-# define EXCEPTION_HANDLER_DWA2002810_HPP
-
-# include <boost/python/detail/config.hpp>
-# include <boost/function/function0.hpp>
-# include <boost/function/function2.hpp>
-
-namespace boost { namespace python { namespace detail {
-
-struct BOOST_PYTHON_DECL_FORWARD exception_handler;
-
-typedef function2<bool, exception_handler const&, function0<void> const&> handler_function;
-
-struct BOOST_PYTHON_DECL exception_handler
-{
- private: // types
-    
- public:
-    explicit exception_handler(handler_function const& impl);
-
-    inline bool handle(function0<void> const& f) const;
-    
-    bool operator()(function0<void> const& f) const;
- 
-    static exception_handler* chain;
-    
- private:
-    static exception_handler* tail;
-    
-    handler_function m_impl;
-    exception_handler* m_next;
-};
-
-
-inline bool exception_handler::handle(function0<void> const& f) const
-{
-    return this->m_impl(*this, f);
-}
-
-BOOST_PYTHON_DECL void register_exception_handler(handler_function const& f);
-
-}}} // namespace boost::python::detail
-
-#endif // EXCEPTION_HANDLER_DWA2002810_HPP

include/boost/python/detail/force_instantiate.hpp

@@ -1,32 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 FORCE_INSTANTIATE_DWA200265_HPP
-# define FORCE_INSTANTIATE_DWA200265_HPP
-
-namespace boost { namespace python { namespace detail { 
-
-// Allows us to force the argument to be instantiated without
-// incurring unused variable warnings
-
-# if !defined(BOOST_MSVC) || BOOST_MSVC < 1300 || _MSC_FULL_VER > 13102196
-
-template <class T>
-inline void force_instantiate(T const&) {}
-
-# else
-
-#  pragma optimize("g", off)
-inline void force_instantiate_impl(...) {}
-#  pragma optimize("", on)
-template <class T>
-inline void force_instantiate(T const& x)
-{
-    detail::force_instantiate_impl(&x);
-}
-# endif
-
-}}} // namespace boost::python::detail
-
-#endif // FORCE_INSTANTIATE_DWA200265_HPP

include/boost/python/detail/if_else.hpp

@@ -1,116 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 IF_ELSE_DWA2002322_HPP
-# define IF_ELSE_DWA2002322_HPP
-# include <boost/config.hpp>
-
-namespace boost { namespace python { namespace detail { 
-
-template <class T> struct elif_selected;
-
-template <class T>
-struct if_selected
-{
-    template <bool b>
-    struct elif : elif_selected<T>
-    {
-    };
-
-    template <class U>
-    struct else_
-    {
-        typedef T type;
-    };
-};
-
-# if defined(BOOST_MSVC) && (BOOST_MSVC == 1300)
-namespace msvc70_aux {
-
-template< bool > struct inherit_from
-{
-    template< typename T > struct result
-    {
-        typedef T type;
-    };
-};
-
-template<> struct inherit_from<true>
-{
-    template< typename T > struct result
-    {
-        struct type {};
-    };
-};
-
-template< typename T >
-struct never_true
-{
-    BOOST_STATIC_CONSTANT(bool, value = false);
-};
-
-} // namespace msvc70_aux
-
-#endif // # if defined(BOOST_MSVC) && (BOOST_MSVC == 1300)
-
-template <class T>
-struct elif_selected
-{
-# if !(defined(BOOST_MSVC) && BOOST_MSVC <= 1300 || defined(__MWERKS__) && __MWERKS__ <= 0x2407)
-    template <class U> class then;
-# elif defined(BOOST_MSVC) && (BOOST_MSVC == 1300)
-    template <class U>
-    struct then : msvc70_aux::inherit_from< msvc70_aux::never_true<U>::value >
-        ::template result< if_selected<T> >::type
-    {
-    };
-# else
-    template <class U>
-    struct then : if_selected<T>
-    {
-    };
-# endif 
-};
-
-# if !(defined(BOOST_MSVC) && BOOST_MSVC <= 1300 || defined(__MWERKS__) && __MWERKS__ <= 0x2407)
-template <class T>
-template <class U>
-class elif_selected<T>::then : public if_selected<T>
-{
-};
-# endif 
-
-template <bool b> struct if_
-{
-    template <class T>
-    struct then : if_selected<T>
-    {
-    };
-};
-
-struct if_unselected
-{
-    template <bool b> struct elif : if_<b>
-    {
-    };
-
-    template <class U>
-    struct else_
-    {
-        typedef U type;
-    };
-};
-
-template <>
-struct if_<false>
-{
-    template <class T>
-    struct then : if_unselected
-    {
-    };
-};
-
-}}} // namespace boost::python::detail
-
-#endif // IF_ELSE_DWA2002322_HPP

include/boost/python/detail/indirect_traits.hpp

@@ -1,13 +0,0 @@
-// Copyright David Abrahams 2004. Distributed under the Boost
-// Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#ifndef INDIRECT_TRAITS_DWA2004915_HPP
-# define INDIRECT_TRAITS_DWA2004915_HPP
-
-# include <boost/detail/indirect_traits.hpp>
-
-namespace boost { namespace python {
-namespace indirect_traits = boost::detail::indirect_traits;
-}} // namespace boost::python::detail
-
-#endif // INDIRECT_TRAITS_DWA2004915_HPP

include/boost/python/detail/invoke.hpp

@@ -1,100 +0,0 @@
-#if !defined(BOOST_PP_IS_ITERATING)
-
-// Copyright David Abrahams 2002.
-// 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 INVOKE_DWA20021122_HPP
-#  define INVOKE_DWA20021122_HPP
-
-#  include <boost/python/detail/prefix.hpp>
-#  include <boost/python/detail/preprocessor.hpp>
-#  include <boost/python/detail/none.hpp>
-
-#  include <boost/type_traits/is_member_function_pointer.hpp>
-
-#  include <boost/preprocessor/iterate.hpp>
-#  include <boost/preprocessor/facilities/intercept.hpp>
-#  include <boost/preprocessor/repetition/enum_trailing_params.hpp>
-#  include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
-#  include <boost/preprocessor/repetition/enum_binary_params.hpp>
-#  include <boost/python/to_python_value.hpp>
-
-// This file declares a series of overloaded invoke(...)  functions,
-// used to invoke wrapped C++ function (object)s from Python. Each one
-// accepts:
-//
-//   - a tag which identifies the invocation syntax (e.g. member
-//   functions must be invoked with a different syntax from regular
-//   functions)
-//
-//   - a pointer to a result converter type, used solely as a way of
-//   transmitting the type of the result converter to the function (or
-//   an int, if the return type is void).
-//
-//   - the "function", which may be a function object, a function or
-//   member function pointer, or a defaulted_virtual_fn.
-//
-//   - The arg_from_python converters for each of the arguments to be
-//   passed to the function being invoked.
-
-namespace boost { namespace python { namespace detail { 
-
-// This "result converter" is really just used as a dispatch tag to
-// invoke(...), selecting the appropriate implementation
-typedef int void_result_to_python;
-
-template <bool void_return, bool member>
-struct invoke_tag_ {};
-
-// A metafunction returning the appropriate tag type for invoking an
-// object of type F with return type R.
-template <class R, class F>
-struct invoke_tag
-  : invoke_tag_<
-        is_same<R,void>::value
-      , is_member_function_pointer<F>::value
-    >
-{
-};
-
-#  define BOOST_PP_ITERATION_PARAMS_1                                            \
-        (3, (0, BOOST_PYTHON_MAX_ARITY, <boost/python/detail/invoke.hpp>))
-#  include BOOST_PP_ITERATE()
-
-}}} // namespace boost::python::detail
-
-# endif // INVOKE_DWA20021122_HPP
-#else 
-
-# define N BOOST_PP_ITERATION()
-
-template <class RC, class F BOOST_PP_ENUM_TRAILING_PARAMS_Z(1, N, class AC)>
-inline PyObject* invoke(invoke_tag_<false,false>, RC const& rc, F& f BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(1, N, AC, & ac) )
-{
-    return rc(f( BOOST_PP_ENUM_BINARY_PARAMS_Z(1, N, ac, () BOOST_PP_INTERCEPT) ));
-}
-                 
-template <class RC, class F BOOST_PP_ENUM_TRAILING_PARAMS_Z(1, N, class AC)>
-inline PyObject* invoke(invoke_tag_<true,false>, RC const&, F& f BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(1, N, AC, & ac) )
-{
-    f( BOOST_PP_ENUM_BINARY_PARAMS_Z(1, N, ac, () BOOST_PP_INTERCEPT) );
-    return none();
-}
-
-template <class RC, class F, class TC BOOST_PP_ENUM_TRAILING_PARAMS_Z(1, N, class AC)>
-inline PyObject* invoke(invoke_tag_<false,true>, RC const& rc, F& f, TC& tc BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(1, N, AC, & ac) )
-{
-    return rc( (tc().*f)(BOOST_PP_ENUM_BINARY_PARAMS_Z(1, N, ac, () BOOST_PP_INTERCEPT)) );
-}
-                 
-template <class RC, class F, class TC BOOST_PP_ENUM_TRAILING_PARAMS_Z(1, N, class AC)>
-inline PyObject* invoke(invoke_tag_<true,true>, RC const&, F& f, TC& tc BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(1, N, AC, & ac) )
-{
-    (tc().*f)(BOOST_PP_ENUM_BINARY_PARAMS_Z(1, N, ac, () BOOST_PP_INTERCEPT));
-    return none();
-}
-
-# undef N
-
-#endif // BOOST_PP_IS_ITERATING 

include/boost/python/detail/is_auto_ptr.hpp

@@ -1,30 +0,0 @@
-// Copyright David Abrahams 2003.
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-#ifndef IS_AUTO_PTR_DWA2003224_HPP
-# define IS_AUTO_PTR_DWA2003224_HPP
-
-# ifndef BOOST_NO_AUTO_PTR
-#  include <boost/python/detail/is_xxx.hpp>
-#  include <memory>
-# endif
-
-namespace boost { namespace python { namespace detail { 
-
-# if !defined(BOOST_NO_AUTO_PTR)
-
-BOOST_PYTHON_IS_XXX_DEF(auto_ptr, std::auto_ptr, 1)
-
-# else
-
-template <class T>
-struct is_auto_ptr : mpl::false_
-{
-};
-
-# endif
-    
-}}} // namespace boost::python::detail
-
-#endif // IS_AUTO_PTR_DWA2003224_HPP

include/boost/python/detail/is_shared_ptr.hpp

@@ -1,17 +0,0 @@
-// Copyright David Abrahams 2003.
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-#ifndef IS_SHARED_PTR_DWA2003224_HPP
-# define IS_SHARED_PTR_DWA2003224_HPP
-
-# include <boost/python/detail/is_xxx.hpp>
-# include <boost/shared_ptr.hpp>
-
-namespace boost { namespace python { namespace detail { 
-
-BOOST_PYTHON_IS_XXX_DEF(shared_ptr, shared_ptr, 1)
-    
-}}} // namespace boost::python::detail
-
-#endif // IS_SHARED_PTR_DWA2003224_HPP

include/boost/python/detail/is_wrapper.hpp

@@ -1,29 +0,0 @@
-// Copyright David Abrahams 2004. Distributed under the Boost
-// Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#ifndef IS_WRAPPER_DWA2004723_HPP
-# define IS_WRAPPER_DWA2004723_HPP
-
-# include <boost/python/detail/prefix.hpp>
-# include <boost/mpl/bool.hpp>
-
-namespace boost { namespace python {
-
-template <class T> class wrapper;
-
-namespace detail
-{
-  typedef char (&is_not_wrapper)[2];
-  is_not_wrapper is_wrapper_helper(...);
-  template <class T>
-  char is_wrapper_helper(wrapper<T> const volatile*);
-
-  // A metafunction returning true iff T is [derived from] wrapper<U> 
-  template <class T>
-  struct is_wrapper
-    : mpl::bool_<(sizeof(detail::is_wrapper_helper((T*)0)) == 1)>
-  {};
-
-}}} // namespace boost::python::detail
-
-#endif // IS_WRAPPER_DWA2004723_HPP

include/boost/python/detail/is_xxx.hpp

@@ -1,13 +0,0 @@
-// Copyright David Abrahams 2005.
-// 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 IS_XXX_DWA2003224_HPP
-# define IS_XXX_DWA2003224_HPP
-
-# include <boost/detail/is_xxx.hpp>
-
-#  define BOOST_PYTHON_IS_XXX_DEF(name, qualified_name, nargs) \
-    BOOST_DETAIL_IS_XXX_DEF(name, qualified_name, nargs)
-
-#endif // IS_XXX_DWA2003224_HPP

include/boost/python/detail/make_keyword_range_fn.hpp

@@ -1,69 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 MAKE_KEYWORD_RANGE_FN_DWA2002927_HPP
-# define MAKE_KEYWORD_RANGE_FN_DWA2002927_HPP
-
-# include <boost/python/make_function.hpp>
-# include <boost/python/args_fwd.hpp>
-
-# include <boost/python/object/make_holder.hpp>
-
-# include <boost/mpl/size.hpp>
-
-
-namespace boost { namespace python { namespace detail { 
-
-// Think of this as a version of make_function without a compile-time
-// check that the size of kw is no greater than the expected arity of
-// F. This version is needed when defining functions with default
-// arguments, because compile-time information about the number of
-// keywords is missing for all but the initial function definition.
-//
-// @group make_keyword_range_function {
-template <class F, class Policies>
-object make_keyword_range_function(
-    F f
-  , Policies const& policies
-  , keyword_range const& kw)
-{
-    return detail::make_function_aux(
-        f, policies, detail::get_signature(f), kw, mpl::int_<0>());
-}
-
-template <class F, class Policies, class Signature>
-object make_keyword_range_function(
-    F f
-  , Policies const& policies
-  , keyword_range const& kw
-  , Signature const& sig)
-{
-    return detail::make_function_aux(
-        f, policies, sig, kw, mpl::int_<0>());
-}
-// }
-
-// Builds an '__init__' function which inserts the given Holder type
-// in a wrapped C++ class instance. ArgList is an MPL type sequence
-// describing the C++ argument types to be passed to Holder's
-// constructor.
-//
-// Holder and ArgList are intended to be explicitly specified. 
-template <class ArgList, class Arity, class Holder, class CallPolicies>
-object make_keyword_range_constructor(
-    CallPolicies const& policies        // The CallPolicies with which to invoke the Holder's constructor
-    , detail::keyword_range const& kw   // The (possibly empty) set of associated argument keywords
-    , Holder* = 0                       
-    , ArgList* = 0, Arity* = 0)
-{
-    return detail::make_keyword_range_function(
-        objects::make_holder<Arity::value>
-            ::template apply<Holder,ArgList>::execute
-        , policies
-        , kw);
-}
-
-}}} // namespace boost::python::detail
-
-#endif // MAKE_KEYWORD_RANGE_FN_DWA2002927_HPP

include/boost/python/detail/make_tuple.hpp

@@ -1,32 +0,0 @@
-# ifndef BOOST_PYTHON_SYNOPSIS 
-# // Copyright David Abrahams 2002.
-# // 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)
-
-#  if !defined(BOOST_PP_IS_ITERATING)
-#   error Boost.Python - do not include this file!
-#  endif
-
-#  define N BOOST_PP_ITERATION()
-
-#  define BOOST_PYTHON_MAKE_TUPLE_ARG(z, N, ignored)    \
-    PyTuple_SET_ITEM(                                   \
-        result.ptr()                                    \
-        , N                                             \
-        , python::incref(python::object(a##N).ptr())    \
-        );
-
-    template <BOOST_PP_ENUM_PARAMS_Z(1, N, class A)>
-    tuple
-    make_tuple(BOOST_PP_ENUM_BINARY_PARAMS_Z(1, N, A, const& a))
-    {
-        tuple result((detail::new_reference)::PyTuple_New(N));
-        BOOST_PP_REPEAT_1ST(N, BOOST_PYTHON_MAKE_TUPLE_ARG, _)
-        return result;
-    }
-
-#  undef BOOST_PYTHON_MAKE_TUPLE_ARG
-
-#  undef N
-# endif // BOOST_PYTHON_SYNOPSIS 

include/boost/python/detail/map_entry.hpp

@@ -1,43 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 MAP_ENTRY_DWA2002118_HPP
-# define MAP_ENTRY_DWA2002118_HPP
-
-namespace boost { namespace python { namespace detail { 
-
-// A trivial type that works well as the value_type of associative
-// vector maps
-template <class Key, class Value>
-struct map_entry
-{
-    map_entry() {}
-    map_entry(Key k) : key(k), value() {}
-    map_entry(Key k, Value v) : key(k), value(v) {}
-    
-    bool operator<(map_entry const& rhs) const
-    {
-        return this->key < rhs.key;
-    }
-        
-    Key key;
-    Value value;
-};
-
-template <class Key, class Value>
-bool operator<(map_entry<Key,Value> const& e, Key const& k)
-{
-    return e.key < k;
-}
-
-template <class Key, class Value>
-bool operator<(Key const& k, map_entry<Key,Value> const& e)
-{
-    return k < e.key;
-}
-
-
-}}} // namespace boost::python::detail
-
-#endif // MAP_ENTRY_DWA2002118_HPP

include/boost/python/detail/mpl_lambda.hpp

@@ -1,12 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 MPL_LAMBDA_DWA2002122_HPP
-# define MPL_LAMBDA_DWA2002122_HPP
-
-// this header should go away soon
-# include <boost/mpl/aux_/lambda_support.hpp>
-# define BOOST_PYTHON_MPL_LAMBDA_SUPPORT BOOST_MPL_AUX_LAMBDA_SUPPORT
-
-#endif // MPL_LAMBDA_DWA2002122_HPP

include/boost/python/detail/msvc_typeinfo.hpp

@@ -1,75 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 MSVC_TYPEINFO_DWA200222_HPP
-# define MSVC_TYPEINFO_DWA200222_HPP
-
-#include <typeinfo>
-#include <boost/type.hpp>
-#include <boost/type_traits/config.hpp>
-
-//
-// Fix for MSVC's broken typeid() implementation which doesn't strip
-// decoration. This fix doesn't handle cv-qualified array types. It
-// could probably be done, but I haven't figured it out yet.
-//
-
-# if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 || defined(BOOST_INTEL_CXX_VERSION) && BOOST_INTEL_CXX_VERSION <= 700
-
-namespace boost { namespace python { namespace detail { 
-
-typedef std::type_info const& typeinfo;
-
-template <class T>
-static typeinfo typeid_nonref(T const volatile*) { return typeid(T); }
-
-template <class T>
-inline typeinfo typeid_ref_1(T&(*)())
-{
-    return detail::typeid_nonref((T*)0);
-}
-
-// A non-reference
-template <class T>
-inline typeinfo typeid_ref(type<T>*, T&(*)(type<T>))
-{
-    return detail::typeid_nonref((T*)0);
-}
-
-// A reference
-template <class T>
-inline typeinfo typeid_ref(type<T>*, ...)
-{
-    return detail::typeid_ref_1((T(*)())0);
-}
-
-template< typename T > T&(* is_ref_tester1(type<T>) )(type<T>) { return 0; }
-inline char BOOST_TT_DECL is_ref_tester1(...) { return 0; }
-
-template <class T>
-inline typeinfo msvc_typeid(boost::type<T>*)
-{
-    return detail::typeid_ref(
-        (boost::type<T>*)0, detail::is_ref_tester1(type<T>())
-        );
-}
-
-template <>
-inline typeinfo msvc_typeid<void>(boost::type<void>*)
-{
-    return typeid(void);
-}
-
-#  ifndef NDEBUG
-inline typeinfo assert_array_typeid_compiles()
-{
-    return msvc_typeid((boost::type<char const[3]>*)0)
-        , msvc_typeid((boost::type<char[3]>*)0);
-}
-#  endif
-
-}}} // namespace boost::python::detail
-
-# endif // BOOST_MSVC
-#endif // MSVC_TYPEINFO_DWA200222_HPP

include/boost/python/detail/none.hpp

@@ -1,20 +0,0 @@
-//  (C) Copyright David Abrahams 2000.
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-//  The author gratefully acknowleges the support of Dragon Systems, Inc., in
-//  producing this work.
-
-#ifndef NONE_DWA_052000_H_
-# define NONE_DWA_052000_H_
-
-# include <boost/python/detail/prefix.hpp>
-
-namespace boost { namespace python { namespace detail {
-
-inline PyObject* none() { Py_INCREF(Py_None); return Py_None; }
-    
-}}} // namespace boost::python::detail
-
-#endif // NONE_DWA_052000_H_

include/boost/python/detail/not_specified.hpp

@@ -1,14 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 NOT_SPECIFIED_DWA2002321_HPP
-# define NOT_SPECIFIED_DWA2002321_HPP
-
-namespace boost { namespace python { namespace detail { 
-
-  struct not_specified {};
-
-}}} // namespace boost::python::detail
-
-#endif // NOT_SPECIFIED_DWA2002321_HPP

include/boost/python/detail/nullary_function_adaptor.hpp

@@ -1,46 +0,0 @@
-// Copyright David Abrahams 2003.
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-#ifndef NULLARY_FUNCTION_ADAPTOR_DWA2003824_HPP
-# define NULLARY_FUNCTION_ADAPTOR_DWA2003824_HPP
-
-# include <boost/python/detail/prefix.hpp>
-# include <boost/preprocessor/iteration/local.hpp>
-# include <boost/preprocessor/facilities/intercept.hpp>
-# include <boost/preprocessor/repetition/enum_params.hpp>
-# include <boost/preprocessor/repetition/enum_binary_params.hpp>
-
-namespace boost { namespace python { namespace detail { 
-
-// nullary_function_adaptor -- a class template which ignores its
-// arguments and calls a nullary function instead.  Used for building
-// error-reporting functions, c.f. pure_virtual
-template <class NullaryFunction>
-struct nullary_function_adaptor
-{
-    nullary_function_adaptor(NullaryFunction fn)
-      : m_fn(fn)
-    {}
-
-    void operator()() const { m_fn(); }
-
-# define BOOST_PP_LOCAL_MACRO(i)                                            \
-    template <BOOST_PP_ENUM_PARAMS_Z(1, i, class A)>                        \
-    void operator()(                                                        \
-        BOOST_PP_ENUM_BINARY_PARAMS_Z(1, i, A, const& BOOST_PP_INTERCEPT)   \
-    ) const                                                                 \
-    {                                                                       \
-        m_fn();                                                             \
-    }
-
-# define BOOST_PP_LOCAL_LIMITS (1, BOOST_PYTHON_MAX_ARITY)
-# include BOOST_PP_LOCAL_ITERATE()
-    
- private:
-    NullaryFunction m_fn;
-};
-
-}}} // namespace boost::python::detail
-
-#endif // NULLARY_FUNCTION_ADAPTOR_DWA2003824_HPP

include/boost/python/detail/operator_id.hpp

@@ -1,55 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 OPERATOR_ID_DWA2002531_HPP
-# define OPERATOR_ID_DWA2002531_HPP
-
-namespace boost { namespace python { namespace detail {
-
-enum operator_id
-{ 
-    op_add, 
-    op_sub, 
-    op_mul, 
-    op_div, 
-    op_mod, 
-    op_divmod,
-    op_pow, 
-    op_lshift, 
-    op_rshift, 
-    op_and, 
-    op_xor, 
-    op_or, 
-    op_neg, 
-    op_pos, 
-    op_abs, 
-    op_invert, 
-    op_int, 
-    op_long, 
-    op_float, 
-    op_str,
-    op_cmp,
-    op_gt,
-    op_ge,
-    op_lt,
-    op_le,
-    op_eq,
-    op_ne,
-    op_iadd,
-    op_isub,
-    op_imul,
-    op_idiv,
-    op_imod,
-    op_ilshift,
-    op_irshift,
-    op_iand,
-    op_ixor,
-    op_ior,
-    op_complex,
-    op_nonzero
-};
-
-}}} // namespace boost::python::detail
-
-#endif // OPERATOR_ID_DWA2002531_HPP

include/boost/python/detail/overloads_fwd.hpp

@@ -1,18 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 OVERLOADS_FWD_DWA2002101_HPP
-# define OVERLOADS_FWD_DWA2002101_HPP
-
-namespace boost { namespace python { namespace detail { 
-
-// forward declarations
-struct overloads_base;
-  
-template <class OverloadsT, class NameSpaceT, class SigT>
-inline void define_with_defaults(char const* name, OverloadsT const&, NameSpaceT&, SigT const&);
-
-}}} // namespace boost::python::detail
-
-#endif // OVERLOADS_FWD_DWA2002101_HPP

include/boost/python/detail/pointee.hpp

@@ -1,35 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 POINTEE_DWA2002323_HPP
-# define POINTEE_DWA2002323_HPP
-
-# include <boost/type_traits/object_traits.hpp>
-
-namespace boost { namespace python { namespace detail { 
-
-template <bool is_ptr = true>
-struct pointee_impl
-{
-    template <class T> struct apply : remove_pointer<T> {};
-};
-
-template <>
-struct pointee_impl<false>
-{
-    template <class T> struct apply
-    {
-        typedef typename T::element_type type;
-    };
-};
-
-template <class T>
-struct pointee
-    : pointee_impl<is_pointer<T>::value>::template apply<T>
-{
-};
-
-}}} // namespace boost::python::detail
-
-#endif // POINTEE_DWA2002323_HPP

include/boost/python/detail/prefix.hpp

@@ -1,16 +0,0 @@
-// Copyright David Abrahams 2003.
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-#ifndef PREFIX_DWA2003531_HPP
-# define PREFIX_DWA2003531_HPP
-
-// The rule is that <Python.h> must be included before any system
-// headers (so it can get control over some awful macros).
-// Unfortunately, Boost.Python needs to #include <limits.h> first, at
-// least... but this gets us as close as possible.
-
-# include <boost/python/detail/wrap_python.hpp>
-# include <boost/python/detail/config.hpp>
-
-#endif // PREFIX_DWA2003531_HPP

include/boost/python/detail/preprocessor.hpp

@@ -1,66 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 PREPROCESSOR_DWA200247_HPP
-# define PREPROCESSOR_DWA200247_HPP
-
-# include <boost/preprocessor/cat.hpp>
-# include <boost/preprocessor/comma_if.hpp>
-# include <boost/preprocessor/repeat.hpp>
-# include <boost/preprocessor/tuple/elem.hpp>
-
-// stuff that should be in the preprocessor library
-
-# define BOOST_PYTHON_APPLY(x) BOOST_PP_CAT(BOOST_PYTHON_APPLY_, x)
-
-# define BOOST_PYTHON_APPLY_BOOST_PYTHON_ITEM(v) v
-# define BOOST_PYTHON_APPLY_BOOST_PYTHON_NIL
-
-// cv-qualifiers
-
-# if !defined(__MWERKS__) || __MWERKS__ > 0x2407
-#  define BOOST_PYTHON_CV_COUNT 4
-# else
-#  define BOOST_PYTHON_CV_COUNT 1
-# endif
-
-# ifndef BOOST_PYTHON_MAX_ARITY
-#  define BOOST_PYTHON_MAX_ARITY 15
-# endif
-
-# ifndef BOOST_PYTHON_MAX_BASES
-#  define BOOST_PYTHON_MAX_BASES 10
-# endif 
-
-# define BOOST_PYTHON_CV_QUALIFIER(i)                          \
-    BOOST_PYTHON_APPLY(                                        \
-        BOOST_PP_TUPLE_ELEM(4, i, BOOST_PYTHON_CV_QUALIFIER_I) \
-    )
-
-# define BOOST_PYTHON_CV_QUALIFIER_I      \
-    (                                     \
-        BOOST_PYTHON_NIL,                 \
-        BOOST_PYTHON_ITEM(const),         \
-        BOOST_PYTHON_ITEM(volatile),      \
-        BOOST_PYTHON_ITEM(const volatile) \
-    )
-
-// enumerators
-# define BOOST_PYTHON_UNARY_ENUM(c, text) BOOST_PP_REPEAT(c, BOOST_PYTHON_UNARY_ENUM_I, text)
-# define BOOST_PYTHON_UNARY_ENUM_I(z, n, text) BOOST_PP_COMMA_IF(n) text ## n
-
-# define BOOST_PYTHON_BINARY_ENUM(c, a, b) BOOST_PP_REPEAT(c, BOOST_PYTHON_BINARY_ENUM_I, (a, b))
-# define BOOST_PYTHON_BINARY_ENUM_I(z, n, _) BOOST_PP_COMMA_IF(n) BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2, 0, _), n) BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2, 1, _), n)
-
-# define BOOST_PYTHON_ENUM_WITH_DEFAULT(c, text, def) BOOST_PP_REPEAT(c, BOOST_PYTHON_ENUM_WITH_DEFAULT_I, (text, def))
-# define BOOST_PYTHON_ENUM_WITH_DEFAULT_I(z, n, _) BOOST_PP_COMMA_IF(n) BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2, 0, _), n) = BOOST_PP_TUPLE_ELEM(2, 1, _)
-
-// fixed text (no commas)
-# define BOOST_PYTHON_FIXED(z, n, text) text
-
-// flags
-# define BOOST_PYTHON_FUNCTION_POINTER 0x0001
-# define BOOST_PYTHON_POINTER_TO_MEMBER 0x0002
-
-#endif // PREPROCESSOR_DWA200247_HPP

include/boost/python/detail/python22_fixed.h

@@ -1,150 +0,0 @@
-// This file is a modified version of Python 2.2/2.2.1 Python.h. As
-// such it is:
-//
-//    Copyright (c) 2001, 2002 Python Software Foundation; All Rights
-//    Reserved
-//
-// Changes from the original:
-//  1. #includes <unistd.h> for Python 2.2.1
-//  2. Provides missing extern "C" wrapper for  "iterobject.h" and  "descrobject.h".
-//
-
-// Changes marked with "Boost.Python modification"
-#ifndef Py_PYTHON_H
-#define Py_PYTHON_H
-/* Since this is a "meta-include" file, no #ifdef __cplusplus / extern "C" { */
-
-
-/* Enable compiler features; switching on C lib defines doesn't work
-   here, because the symbols haven't necessarily been defined yet. */
-#ifndef _GNU_SOURCE
-# define _GNU_SOURCE    1
-#endif
-
-/* Forcing SUSv2 compatibility still produces problems on some
-   platforms, True64 and SGI IRIX begin two of them, so for now the
-   define is switched off. */
-#if 0
-#ifndef _XOPEN_SOURCE
-# define _XOPEN_SOURCE  500
-#endif
-#endif
-
-/* Include nearly all Python header files */
-
-#include "patchlevel.h"
-#include "pyconfig.h"
-
-#ifdef HAVE_LIMITS_H
-#include <limits.h>
-#endif
-
-/* pyconfig.h may or may not define DL_IMPORT */
-#ifndef DL_IMPORT       /* declarations for DLL import/export */
-#define DL_IMPORT(RTYPE) RTYPE
-#endif
-#ifndef DL_EXPORT       /* declarations for DLL import/export */
-#define DL_EXPORT(RTYPE) RTYPE
-#endif
-
-#if defined(__sgi) && defined(WITH_THREAD) && !defined(_SGI_MP_SOURCE)
-#define _SGI_MP_SOURCE
-#endif
-
-#include <stdio.h>
-#ifndef NULL
-#   error "Python.h requires that stdio.h define NULL."
-#endif
-
-#include <string.h>
-#include <errno.h>
-#ifdef HAVE_STDLIB_H
-#include <stdlib.h>
-#endif
-#if PY_MICRO_VERSION == 1 // Boost.Python modification: emulate Python 2.2
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#endif // Boost.Python modification: emulate Python 2.2
-
-/* CAUTION:  Build setups should ensure that NDEBUG is defined on the
- * compiler command line when building Python in release mode; else
- * assert() calls won't be removed.
- */
-#include <assert.h>
-
-#include "pyport.h"
-
-#include "pymem.h"
-
-#include "object.h"
-#include "objimpl.h"
-
-#include "pydebug.h"
-
-#include "unicodeobject.h"
-#include "intobject.h"
-#include "longobject.h"
-#include "floatobject.h"
-#ifndef WITHOUT_COMPLEX
-#include "complexobject.h"
-#endif
-#include "rangeobject.h"
-#include "stringobject.h"
-#include "bufferobject.h"
-#include "tupleobject.h"
-#include "listobject.h"
-#include "dictobject.h"
-#include "methodobject.h"
-#include "moduleobject.h"
-#include "funcobject.h"
-#include "classobject.h"
-#include "fileobject.h"
-#include "cobject.h"
-#include "traceback.h"
-#include "sliceobject.h"
-#include "cellobject.h"
-extern "C" { // Boost.Python modification: provide missing extern "C"
-#include "iterobject.h"
-#include "descrobject.h"
-} // Boost.Python modification: provide missing extern "C"
-#include "weakrefobject.h"
-
-#include "codecs.h"
-#include "pyerrors.h"
-
-#include "pystate.h"
-
-#include "modsupport.h"
-#include "pythonrun.h"
-#include "ceval.h"
-#include "sysmodule.h"
-#include "intrcheck.h"
-#include "import.h"
-
-#include "abstract.h"
-
-#define PyArg_GetInt(v, a)      PyArg_Parse((v), "i", (a))
-#define PyArg_NoArgs(v)         PyArg_Parse(v, "")
-
-/* Convert a possibly signed character to a nonnegative int */
-/* XXX This assumes characters are 8 bits wide */
-#ifdef __CHAR_UNSIGNED__
-#define Py_CHARMASK(c)          (c)
-#else
-#define Py_CHARMASK(c)          ((c) & 0xff)
-#endif
-
-#include "pyfpe.h"
-
-/* These definitions must match corresponding definitions in graminit.h.
-   There's code in compile.c that checks that they are the same. */
-#define Py_single_input 256
-#define Py_file_input 257
-#define Py_eval_input 258
-
-#ifdef HAVE_PTH
-/* GNU pth user-space thread support */
-#include <pth.h>
-#endif
-#endif /* !Py_PYTHON_H */

include/boost/python/detail/raw_pyobject.hpp

@@ -1,32 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 RAW_PYOBJECT_DWA2002628_HPP
-# define RAW_PYOBJECT_DWA2002628_HPP
-
-namespace boost { namespace python { namespace detail { 
-
-//
-// Define some types which we can use to get around the vagaries of
-// PyObject*. We will use these to initialize object instances, and
-// keep them in namespace detail to make sure they stay out of the
-// hands of users. That is much simpler than trying to grant
-// friendship to all the appropriate parties.
-//
-
-// New references are normally checked for null
-struct new_reference_t;
-typedef new_reference_t* new_reference;
-
-// Borrowed references are assumed to be non-null
-struct borrowed_reference_t;
-typedef borrowed_reference_t* borrowed_reference;
-
-// New references which aren't checked for null
-struct new_non_null_reference_t;
-typedef new_non_null_reference_t* new_non_null_reference;
-
-}}} // namespace boost::python::detail
-
-#endif // RAW_PYOBJECT_DWA2002628_HPP

include/boost/python/detail/referent_storage.hpp

@@ -1,76 +0,0 @@
-// Copyright David Abrahams 2002.
-// 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 REFERENT_STORAGE_DWA200278_HPP
-# define REFERENT_STORAGE_DWA200278_HPP
-# include <boost/mpl/if.hpp>
-# include <cstddef>
-
-namespace boost { namespace python { namespace detail {
-
-struct alignment_dummy;
-typedef void (*function_ptr)();
-typedef int (alignment_dummy::*member_ptr);
-typedef int (alignment_dummy::*member_function_ptr)();
-
-# define BOOST_PYTHON_ALIGNER(T, n)                     \
-        typename mpl::if_c<                             \
-           sizeof(T) <= size, T, char>::type t##n
-
-// Storage for size bytes, aligned to all fundamental types no larger than size
-template <std::size_t size>
-union aligned_storage
-{
-    BOOST_PYTHON_ALIGNER(char, 0);
-    BOOST_PYTHON_ALIGNER(short, 1);
-    BOOST_PYTHON_ALIGNER(int, 2);
-    BOOST_PYTHON_ALIGNER(long, 3);
-    BOOST_PYTHON_ALIGNER(float, 4);
-    BOOST_PYTHON_ALIGNER(double, 5);
-    BOOST_PYTHON_ALIGNER(long double, 6);
-    BOOST_PYTHON_ALIGNER(void*, 7);
-    BOOST_PYTHON_ALIGNER(function_ptr, 8);
-    BOOST_PYTHON_ALIGNER(member_ptr, 9);
-    BOOST_PYTHON_ALIGNER(member_function_ptr, 10);
-    char bytes[size];
-};
-
-# undef BOOST_PYTHON_ALIGNER
-
-  // Compute the size of T's referent. We wouldn't need this at all,
-  // but sizeof() is broken in CodeWarriors <= 8.0
-  template <class T> struct referent_size;
-  
-# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-  
-  template <class T>
-  struct referent_size<T&>
-  {
-      BOOST_STATIC_CONSTANT(
-          std::size_t, value = sizeof(T));
-  };
-
-# else
-
-  template <class T> struct referent_size
-  {
-      static T f();
-      BOOST_STATIC_CONSTANT(std::size_t, value = sizeof(f()));
-  };
-  
-# endif
-
-// 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 aligned_storage<
-        ::boost::python::detail::referent_size<T>::value
-    > type;
-};
-
-}}} // namespace boost::python::detail
-
-#endif // REFERENT_STORAGE_DWA200278_HPP

include/boost/python/detail/result.hpp

@@ -1,131 +0,0 @@
-#if !defined(BOOST_PP_IS_ITERATING)
-
-// Copyright David Abrahams 2002.
-// 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 RESULT_DWA2002521_HPP
-#  define RESULT_DWA2002521_HPP
-
-#  include <boost/type.hpp>
-
-#  include <boost/python/detail/preprocessor.hpp>
-
-#  include <boost/type_traits/object_traits.hpp>
-#  include <boost/mpl/if.hpp>
-
-#  include <boost/preprocessor/comma_if.hpp>
-#  include <boost/preprocessor/iterate.hpp>
-#  include <boost/preprocessor/debug/line.hpp>
-#  include <boost/preprocessor/enum_params.hpp>
-#  include <boost/preprocessor/repetition/enum_trailing_params.hpp>
-
-namespace boost { namespace python { namespace detail {
-
-// Defines a family of overloaded function which, given x, a function
-// pointer, member [function] pointer, or an AdaptableFunction object,
-// returns a pointer to type<R>*, where R is the result type of
-// invoking the result of bind(x).
-//
-// In order to work around bugs in deficient compilers, if x might be
-// an AdaptableFunction object, you must pass OL as a second argument
-// to get this to work portably.
-
-#  define BOOST_PP_ITERATION_PARAMS_1                                                                   \
-    (4, (0, BOOST_PYTHON_MAX_ARITY, <boost/python/detail/result.hpp>, BOOST_PYTHON_FUNCTION_POINTER))
-#  include BOOST_PP_ITERATE()
-
-#  define BOOST_PP_ITERATION_PARAMS_1                                                                     \
-    (4, (0, BOOST_PYTHON_CV_COUNT - 1, <boost/python/detail/result.hpp>, BOOST_PYTHON_POINTER_TO_MEMBER))
-#  include BOOST_PP_ITERATE()
-
-template <class R, class T>
-boost::type<R>* result(R (T::*), int = 0) { return 0; }
-
-#  if (defined(BOOST_MSVC) && _MSC_FULL_VER <= 13102140)  \
-   || (defined(__GNUC__) && __GNUC__ < 3)                 \
-   || (defined(__MWERKS__) && __MWERKS__ < 0x3000)
-// This code actually works on all implementations, but why use it when we don't have to?
-template <class T>
-struct get_result_type
-{
-    typedef boost::type<typename T::result_type> type;
-};
-
-struct void_type
-{
-    typedef void type;
-};
-
-template <class T>
-struct result_result
-{
-    typedef typename mpl::if_c<
-        is_class<T>::value
-        , get_result_type<T>
-        , void_type
-        >::type t1;
-
-    typedef typename t1::type* type;
-};
-
-template <class X>
-typename result_result<X>::type
-result(X const&, short) { return 0; }
-
-#  else // Simpler code for more-capable compilers
-template <class X>
-boost::type<typename X::result_type>*
-result(X const&, short = 0) { return 0; }
-
-#  endif
-
-}}} // namespace boost::python::detail
-
-# endif // RESULT_DWA2002521_HPP
-
-/* --------------- function pointers --------------- */
-#elif 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))
-# endif
-
-# define N BOOST_PP_ITERATION()
-
-template <class R BOOST_PP_ENUM_TRAILING_PARAMS_Z(1, N, class A)>
-boost::type<R>* result(R (*pf)(BOOST_PP_ENUM_PARAMS_Z(1, N, A)), int = 0)
-{
-    return 0;
-}
-
-# undef N
-
-/* --------------- pointers-to-members --------------- */
-#elif BOOST_PP_ITERATION_DEPTH() == 1 && BOOST_PP_ITERATION_FLAGS() == BOOST_PYTHON_POINTER_TO_MEMBER
-// Outer over cv-qualifiers
-
-# define BOOST_PP_ITERATION_PARAMS_2 (3, (0, BOOST_PYTHON_MAX_ARITY, <boost/python/detail/result.hpp>))
-# include BOOST_PP_ITERATE()
-
-#elif BOOST_PP_ITERATION_DEPTH() == 2
-# if !(BOOST_WORKAROUND(__MWERKS__, > 0x3100)                      \
-        && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3201)))
-#  line BOOST_PP_LINE(__LINE__, result.hpp(pointers-to-members))
-# endif 
-// Inner over arities
-
-# define N BOOST_PP_ITERATION()
-# define Q BOOST_PYTHON_CV_QUALIFIER(BOOST_PP_RELATIVE_ITERATION(1))
-
-template <class R, class T BOOST_PP_ENUM_TRAILING_PARAMS_Z(1, N, class A)>
-boost::type<R>* result(R (T::*pmf)(BOOST_PP_ENUM_PARAMS_Z(1, N, A)) Q, int = 0)
-{
-    return 0;
-}
-
-# undef N
-# undef Q
-
-#endif