From ccabeef9374e472ae022b478c3e3a49eaea6eaa3 Mon Sep 17 00:00:00 2001 From: Dave Abrahams Date: Tue, 1 Nov 2005 15:09:28 +0000 Subject: [PATCH] merged from trunk [SVN r31529] --- doc/v2/class.html | 993 +++++++++++++++++++++++----------------------- 1 file changed, 488 insertions(+), 505 deletions(-) diff --git a/doc/v2/class.html b/doc/v2/class.html index a6693fcd..3130fa5b 100644 --- a/doc/v2/class.html +++ b/doc/v2/class.html @@ -1,214 +1,219 @@ - - - - + + + + - Boost.Python - <boost/python/class.hpp>, - <boost/python/class_fwd.hpp> - + Boost.Python - <boost/python/class.hpp>, + <boost/python/class_fwd.hpp> + - - - - + +
-

C++ Boost

-
+ + - - -
+

+

+ 		-

Boost.Python

+ 		+

Boost.Python

-

Headers <boost/python/class.hpp>, - <boost/python/class_fwd.hpp>

-
-
+

Headers <boost/python/class.hpp>, + <boost/python/class_fwd.hpp>

+ + + +
-

Contents

+

Contents

-
-
Introduction
+
+
Introduction
-
Classes
+
Classes
-
-
-
Class template - class_
+
+
+
Class template + class_
-
-
-
Class class_ - synopsis
+
+
+
Class class_ + synopsis
-
Class class_ - constructors
+
Class class_ + constructors
-
Class class_ - modifier functions
-
-
+
Class class_ + modifier functions
+
+
-
Class template - bases
+
Class template bases
-
-
-
Class template - bases synopsis
-
-
-
-
+
+
+
Class template + bases synopsis
+
+
+
+
-
Example(s)
-
-
+
Example(s)
+
+
-

Introduction

+

Introduction

-

<boost/python/class.hpp> defines the interface - through which users expose their C++ classes to Python. It declares the - class_ class template, which is parameterized on the class - type being exposed. It also exposes the init, - optional and bases utility class templates, - which are used in conjunction with class_.

+

<boost/python/class.hpp> defines the interface + through which users expose their C++ classes to Python. It declares the + class_ class template, which is parameterized on the class + type being exposed. It also exposes the init, + optional and bases utility class templates, which + are used in conjunction with class_.

-

<boost/python/class_fwd.hpp> contains a forward - declaration of the class_ class template.

+

<boost/python/class_fwd.hpp> contains a forward + declaration of the class_ class template.

-

Classes

+

Classes

-

Class template - class_<T, Bases, HeldType, - NonCopyable>

+

Class template + class_<T, Bases, HeldType, + NonCopyable>

-

Creates a Python class associated with the C++ type passed as its - first parameter. Although it has four template parameters, only the first - one is required. The three optional arguments can actually be supplied - in any order; Boost.Python determines - the role of the argument from its type.
-
-

+

Creates a Python class associated with the C++ type passed as its first + parameter. Although it has four template parameters, only the first one is + required. The three optional arguments can actually be supplied + in any order; Boost.Python determines + the role of the argument from its type.
+

- - - +
Template Parameter
+ + - + - + - - + + - - + + - + - - + + - - + + - + - + - - + + - - + + - + - + - - + + - - + + - + - + - - -
Template ParameterRequirementsRequirementsSemanticsSemanticsDefault
Default
T
TA class type.A class type.The class being wrapped
The class being wrapped
Bases
BasesA specialization of bases<...> which - specifies previously-exposed C++ base classes of T[1].A specialization of bases<...> which + specifies previously-exposed C++ base classes of T[1].Registers from_python conversions from wrapped - T instances to each of its exposed direct and indirect - bases. For each polymorphic base B, registers - conversions from indirectly-held wrapped B instances to - T.Registers from_python conversions from wrapped + T instances to each of its exposed direct and indirect + bases. For each polymorphic base B, registers conversions + from indirectly-held wrapped B instances to + T.bases<>
bases<>
HeldType
HeldTypeMust be T, a class derived from T, or a - Dereferenceable type for which - pointee<HeldType>::type - is T or a class derived from T.Must be T, a class derived from T, or a + Dereferenceable type for which + pointee<HeldType>::type is + T or a class derived from T.Specifies the type which is actually embedded in a Python object - wrapping a T instance. More details below.Specifies the type that is actually embedded in a Python object + wrapping a T instance when T's constructor is + called or when a T or T* is converted to + Python without the use of + ptr, + ref, or Call Policies + such as return_internal_reference. + More details below.T
T
NonCopyable
NonCopyableIf supplied, must be boost::noncopyable.If supplied, must be boost::noncopyable.Suppresses automatic registration of to_python - conversions which copy T instances. Required when - T has no publicly-accessible copy constructor.Suppresses automatic registration of to_python + conversions which copy T instances. Required when + T has no publicly-accessible copy constructor.An unspecified type other than - boost::noncopyable.
+ An unspecified type other than + boost::noncopyable. + + -

HeldType Semantics

+

HeldType Semantics

-
    -
  1. If HeldType is derived from T, its exposed - constructor(s) must accept an initial PyObject* argument - which refers back to the Python object that contains the - HeldType instance, as shown in this example. This argument is not - included in the init-expression passed to def(init_expr), below, - nor is it passed explicitly by users when Python instances of - T are created. This idiom allows C++ virtual functions - which will be overridden in Python to access the Python object so the - Python method can be invoked. Boost.Python automatically registers - additional converters which allow wrapped instances of T - to be passed to wrapped C++ functions expecting HeldType - arguments.
    2. +
      +
    1. If HeldType is derived from T, its exposed + constructor(s) must accept an initial PyObject* argument + which refers back to the Python object that contains the + HeldType instance, as shown in this example. This argument is not + included in the init-expression passed to def(init_expr), below, nor is + it passed explicitly by users when Python instances of T are + created. This idiom allows C++ virtual functions which will be overridden + in Python to access the Python object so the Python method can be + invoked. Boost.Python automatically registers additional converters which + allow wrapped instances of T to be passed to wrapped C++ + functions expecting HeldType arguments.
      2. -
    2. Because Boost.Python will always allow wrapped instances of - T to be passed in place of HeldType - arguments, specifying a smart pointer for HeldType allows - users to pass Python T instances where a smart - pointer-to-T is expected. Smart pointers such as - std::auto_ptr<> or boost::shared_ptr<> - which contain a nested type element_type designating the - referent type are automatically supported; additional smart pointer - types can be supported by specializing pointee<HeldType>.
      3. +
    3. Because Boost.Python will always allow wrapped instances of + T to be passed in place of HeldType arguments, + specifying a smart pointer for HeldType allows users to pass + Python T instances where a smart pointer-to-T + is expected. Smart pointers such as std::auto_ptr<> or + boost::shared_ptr<> + which contain a nested type element_type designating the + referent type are automatically supported; additional smart pointer types + can be supported by specializing pointee<HeldType>.
      4. -
    4. As in case 1 above, when HeldType is a smart pointer - to a class derived from T, the initial - PyObject* argument must be supplied by all of - HeldType's exposed constructors.
      5. +
    5. As in case 1 above, when HeldType is a smart pointer to + a class derived from T, the initial PyObject* + argument must be supplied by all of HeldType's exposed + constructors.
      6. -
    6. Except in cases 1 and 3, users may optionally specify that T itself - gets initialized with a similar initial PyObject* argument - by specializing has_back_reference<T>.
      7. -
    +
  2. Except in cases 1 and 3, users may optionally specify that T itself + gets initialized with a similar initial PyObject* argument + by specializing has_back_reference<T>.
    3. +
-

Class template class_ - synopsis

-
+  
Class
+  template class_ synopsis

+  
 namespace boost { namespace python
 {
   template <class T
@@ -272,7 +277,7 @@ namespace boost { namespace python
     void add_property(char const* name, Get const& fget, char const* doc=0);
     template <class Get, class Set>
     void add_property(
-    	char const* name, Get const& fget, Set const& fset, char const* doc=0);
+        char const* name, Get const& fget, Set const& fset, char const* doc=0);
 
     template <class Get>
     void add_static_property(char const* name, Get const& fget);
@@ -287,9 +292,9 @@ namespace boost { namespace python
 }}
 

 
-    
Class template class_
-    constructors

-
+  
Class template
+  class_ constructors

+  
 class_(char const* name);
 class_(char const* name, char const* docstring);
 template <class Init>
@@ -298,82 +303,80 @@ template <class Init>
 class_(char const* name, char const* docstring, Init init_spec);
 

 
-    

-      
Requires: name is an ntbs which conforms to Python's identifier
-      naming rules. If docstring is supplied, it must be an
-      ntbs. If init_spec is
-      supplied, it must be either the special enumeration constant
-      no_init or an init-expression compatible with
-      T.

+  

+    
Requires: name is an ntbs which conforms to Python's identifier
+    naming rules. If docstring is supplied, it must be an
+    ntbs. If init_spec is
+    supplied, it must be either the special enumeration constant
+    no_init or an init-expression compatible with
+    T.

 
-      
Effects: Constructs a class_ object holding a
-      Boost.Python extension class named name. The
-      named attribute of the current scope is bound to the new
-      extension class.

+    
Effects: Constructs a class_ object holding a
+    Boost.Python extension class named name. The
+    named attribute of the current scope is bound to the new extension
+    class.

 
-      

-        
    
-          
  • If supplied, the value of docstring is bound to
-          the __doc__ attribute of the extension class.
    • 
+    
    
+      
      
+        
    • If supplied, the value of docstring is bound to the
+        __doc__ attribute of the extension class.
      • 
 
-          
    • If init_spec is no_init, a special
-          __init__ function is generated which always raises a
-          Python exception. Otherwise, this->def(init_spec)
-          is called.
      • 
+        
    • If init_spec is no_init, a special
+        __init__ function is generated which always raises a
+        Python exception. Otherwise, this->def(init_spec) is
+        called.
      • 
 
-          
    • If init_spec is not supplied,
-          this->def(init<>()) is called.
      • 
-        
    
-      
    
+        
  • If init_spec is not supplied,
+        this->def(init<>()) is called.
    • 
+      

+    

 
-      
Rationale:Allowing the user to specify constructor arguments
-      in the class_<> constructor helps her to avoid the
-      common run-time errors which result from invoking wrapped member
-      functions without having exposed an __init__ function
-      which creates the requisite T instance. Types which are
-      not default-constructible will cause a compile-time error unless
-      Init is supplied. The user must always supply
-      name as there is currently no portable method to derive
-      the text of the class name from its type.

-    

+    
Rationale:Allowing the user to specify constructor arguments
+    in the class_<> constructor helps her to avoid the
+    common run-time errors which result from invoking wrapped member
+    functions without having exposed an __init__ function which
+    creates the requisite T instance. Types which are not
+    default-constructible will cause a compile-time error unless
+    Init is supplied. The user must always supply
+    name as there is currently no portable method to derive the
+    text of the class name from its type.

+  

 
-    
Class template
-    class_ modifier functions

-
+  
Class
+  template class_ modifier functions

+  
 template <class Init>
 class_& def(Init init_expr);
 

 
-    

-      
Requires: init_expr is the result of an init-expression compatible with
-      T.

+  

+    
Requires: init_expr is the result of an init-expression compatible with
+    T.

 
-      
Effects: For each valid
-      prefix P of Init, adds an
-      __init__(...) function overload to the
-      extension class accepting P as arguments. Each overload
-      generated constructs an object of HeldType according to
-      the semantics described above, using a copy of
-      init_expr's call policies.
-      If the longest valid prefix of
-      Init contains N types and init_expr
-      holds M keywords, an initial sequence of the keywords are used
-      for all but the first N - M arguments of
-      each overload.

+    
Effects: For each valid
+    prefix P of Init, adds an
+    __init__(...) function overload to the
+    extension class accepting P as arguments. Each overload
+    generated constructs an object of HeldType according to the
+    semantics described above, using a copy of
+    init_expr's call policies.
+    If the longest valid prefix of
+    Init contains N types and init_expr
+    holds M keywords, an initial sequence of the keywords are used
+    for all but the first N - M arguments of each
+    overload.

 
-      
Returns: *this

+    
Returns: *this

 
-      
Rationale: Allows users to easily expose a class'
-      constructor to Python.

-    

-    

-     
-
+    
Rationale: Allows users to easily expose a class' constructor
+    to Python.

+  


+  
 template <class F>
 class_& def(char const* name, Fn fn);
 template <class Fn, class A1>
@@ -384,363 +387,347 @@ template <class Fn, class A1, class A2, class A3>
 class_& def(char const* name, Fn fn, A1 const& a1, A2 const& a2, A3 const& a3);
 

 
-    

-      
Requires: name is an ntbs which conforms to Python's identifier
-      naming rules.

+  

+    
Requires: name is an ntbs which conforms to Python's identifier
+    naming rules.

 
-      

-        
    
-          
  • 
-            If a1 is the result of an overload-dispatch-expression,
-            only the second form is allowed and fn must be a pointer to
-            function or pointer to member function whose arity is the same as A1's maximum
-            arity. 
+    
    
+      
      
+        
    • If a1 is the result of an overload-dispatch-expression,
+        only the second form is allowed and fn must be a pointer to function
+        or pointer to member function whose 
+          arity is the same as A1's maximum
+          arity.
 
-            
      
-              
      Effects: For each prefix P of
-              Fn's sequence of argument types, beginning with
-              the one whose length is A1's minimum
-              arity, adds a
-              name(...) method overload to
-              the extension class. Each overload generated invokes
-              a1's call-expression with P, using a copy
-              of a1's call
-              policies. If the longest valid prefix of A1
-              contains N types and a1 holds M
-              keywords, an initial sequence of the keywords are used for all
-              but the first N - M arguments of
-              each overload.
      
-              
      
-            
      
-          
      • 
+          
      
+            
      Effects: For each prefix P of
+            Fn's sequence of argument types, beginning with the
+            one whose length is A1's minimum
+            arity, adds a
+            name(...) method overload to
+            the extension class. Each overload generated invokes
+            a1's call-expression with P, using a copy
+            of a1's call
+            policies. If the longest valid prefix of A1
+            contains N types and a1 holds M
+            keywords, an initial sequence of the keywords are used for all
+            but the first N - M arguments of each
+            overload.
      
+          
      
+        
 
-          
    • 
-            Otherwise, a single method overload is built around fn, which
-            must not be null: 
+        
    • Otherwise, a single method overload is built around fn, which
+        must not be null:
 
-            
        
-              
      • If fn is a function pointer, its first argument must be of
-              the form U, U cv&,
-              U cv*, or
-              U cv* const&, where
-              T* is convertible to U*, and
-              a1-a3, if supplied, may be selected
-              in any order from the table below.
        • 
+          
          
+            
        • If fn is a function pointer, its first argument must be of
+            the form U, U cv&, U
+            cv*, or U cv* const&,
+            where T* is convertible to U*, and
+            a1-a3, if supplied, may be selected in
+            any order from the table below.
          • 
 
-              
        • Otherwise, if fn is a member function pointer, its target
-              must be T or one of its public base classes, and
-              a1-a3, if supplied, may be selected
-              in any order from the table below.
          • 
+            
        • Otherwise, if fn is a member function pointer, its target
+            must be T or one of its public base classes, and
+            a1-a3, if supplied, may be selected in
+            any order from the table below.
          • 
 
-              
        • Otherwise, Fn must be [derived from] object, and
-              a1-a2, if supplied, may be selcted in any order
-              from the first two rows of the table below. To be useful,
-              fn should be 
-              callable.
          • 
-            
        
+            
      • Otherwise, Fn must be [derived from]
+            object, and
+            a1-a2, if supplied, may be selcted in any order from
+            the first two rows of the table below. To be useful,
+            fn should be 
+            callable.
        • 
+          
      
 
-            
-              
-                
+          
      Memnonic Name
      
+            
+              
 
-                
+              
 
-                
-              
+              
+            
 
-              
-                
+            
+              
 
-                
+              
 
-                
-              
+              
+            
 
-              
-                
+            
+              
 
-                
+              
 
-                
-              
+              
+            
 
-              
-                
+            
+              
 
-                
+              
 
-                
-              
-            
      Memnonic NameRequirements/Type propertiesRequirements/Type propertiesEffects
      Effects
      docstring
      docstringAny ntbs.Any ntbs.Value will be bound to the __doc__ attribute
-                of the resulting method overload. If an earlier overload 
-                supplied a docstring, two newline characters and the new
-                docstring are appended to it.
      Value will be bound to the __doc__ attribute
+              of the resulting method overload. If an earlier overload
+              supplied a docstring, two newline characters and the new
+              docstring are appended to it.
      policies
      policiesA model of CallPoliciesA model of CallPoliciesA copy will be used as the call policies of the resulting
-                method overload.
      A copy will be used as the call policies of the resulting
+              method overload.
      keywords
      keywordsThe result of a keyword-expression
-                specifying no more arguments than the arity of fn.The result of a keyword-expression
+              specifying no more arguments than the arity of fn.A copy will be used as the call policies of the resulting
-                method overload.
      
-          
      • 
-        
    
-      
    
+              A copy will be used as the call policies of the resulting
+              method overload.
+            
+          
+        
    • 
+      

+    

 
-      
Returns: *this

-    

-
+    
Returns: *this

+  

+  
 class_& staticmethod(char const* name);
 

 
-    

-      
Requires: name is an ntbs which conforms to Python's identifier
-      naming rules, and corresponds to a method whose overloads have all
-      been defined.

+  

+    
Requires: name is an ntbs which conforms to Python's identifier
+    naming rules, and corresponds to a method whose overloads have all
+    been defined.

 
-      
Effects: Replaces the existing named attribute x with
-      the result of invoking staticmethod(x)
-      in Python. Specifies that the corresponding method is static and
-      therefore no object instance will be passed to it. This is equivalent
-      to the Python statement:

+    
Effects: Replaces the existing named attribute x with
+    the result of invoking staticmethod(x)
+    in Python. Specifies that the corresponding method is static and
+    therefore no object instance will be passed to it. This is equivalent to
+    the Python statement:

 
-      

-
+    

+      
 setattr(self, name, staticmethod(getattr(self, name)))
 

-      

+    

 
-      
Note: Attempting to invoke def(name,...) after
-      invoking staticmethod(name) will raise a RuntimeError.

+    
Note: Attempting to invoke def(name,...) after
+    invoking staticmethod(name) will raise a RuntimeError.

 
-      
Returns: *this

-    

-    

-     
-
+    
Returns: *this

+  


+  
 template <unspecified>
 class_& def(detail::operator_<unspecified>);
 

 
-    

-      
Effects: Adds a Python special method as
-      described here.

+  

+    
Effects: Adds a Python special method as
+    described here.

 
-      
Returns: *this

-    

-
+    
Returns: *this

+  

+  
 template <class U>
 class_& setattr(char const* name, U const& u);
 

 
-    

-      
Requires: name is an ntbs which conforms to Python's identifier
-      naming rules.

+  

+    
Requires: name is an ntbs which conforms to Python's identifier
+    naming rules.

 
-      
Effects: Converts u to Python and adds it to the attribute
-      dictionary of the extension class:

+    
Effects: Converts u to Python and adds it to the attribute
+    dictionary of the extension class:

 
-      

-        

-          PyObject_SetAttrString(this->ptr(), name, object(u).ptr());
-        

-      

+    

+      

+        PyObject_SetAttrString(this->ptr(),
+        name, object(u).ptr());
+      

+    

 
-      
Returns: *this

-    

-    

-     
-
+    
Returns: *this

+  


+  
 template <class Get>
 void add_property(char const* name, Get const& fget, char const* doc=0);
 template <class Get, class Set>
 void add_property(
-	char const* name, Get const& fget, Set const& fset, char const* doc=0);
+        char const* name, Get const& fget, Set const& fset, char const* doc=0);
 

 
-    

-      
Requires: name is an ntbs which conform to Python's identifier
-      naming rules.

+  

+    
Requires: name is an ntbs which conform to Python's identifier
+    naming rules.

 
-      
Effects: Creates a new Python property
-      class instance, passing object(fget) (and object(fset) in the
-      second form) with an (optional) docstring doc to its constructor,
-      then adds that property to the Python class object under construction 
-      with the given attribute name.

+    
Effects: Creates a new Python property
+    class instance, passing object(fget) (and
+    object(fset) in
+    the second form) with an (optional) docstring doc to its
+    constructor, then adds that property to the Python class object under
+    construction with the given attribute name.

 
-      
Returns: *this

+    
Returns: *this

 
-      
Rationale: Allows users to easily expose functions that can
-      be invoked from Python with attribute access syntax.

-    

-    

-
+    
Rationale: Allows users to easily expose functions that can be
+    invoked from Python with attribute access syntax.

+  


+  
 template <class Get>
 void add_static_property(char const* name, Get const& fget);
 template <class Get, class Set>
 void add_static_property(char const* name, Get const& fget, Set const& fset);
 

 
-    

-      
Requires: name is an ntbs which conforms to Python's identifier
-      naming rules.

+  

+    
Requires: name is an ntbs which conforms to Python's identifier
+    naming rules.

 
-      
Effects: Creates a Boost.Python.StaticProperty object,
-      passing object(fget) (and object(fset) in the
-      second form) to its constructor, then adds that property to the Python
-      class under construction with the given attribute name.
-      StaticProperty is a special subclass of Python's property
-      class which can be called without an initial self
-      argument.

+    
Effects: Creates a Boost.Python.StaticProperty object, passing
+    object(fget)
+    (and object(fset) in the second
+    form) to its constructor, then adds that property to the Python class
+    under construction with the given attribute name.
+    StaticProperty is a special subclass of Python's property
+    class which can be called without an initial self
+    argument.

 
-      
Returns: *this

+    
Returns: *this

 
-      
Rationale: Allows users to easily expose functions that can
-      be invoked from Python with static attribute access syntax.

-    

-    

-
+    
Rationale: Allows users to easily expose functions that can be
+    invoked from Python with static attribute access syntax.

+  


+  
 template <class D>
 class_& def_readonly(char const* name, D T::*pm, char const* doc=0);
 template <class D>
 class_& def_readonly(char const* name, D const& d);
 

 
-    

-      
Requires: name is an ntbs which conforms to Python's identifier
-      naming rules. doc is also an ntbs.

+  

+    
Requires: name is an ntbs which conforms to Python's identifier
+    naming rules. doc is also an ntbs.

 
-      
Effects:

+    
Effects:

 
-      

-
+    

+      
 this->add_property(name, make_getter(pm), doc);
-

-        and 
-
+
and
+      
 this->add_static_property(name, make_getter(d));
-

-        respectively.

-        

-      

+
respectively.

+      

+    

 
-      
Returns: *this

+    
Returns: *this

 
-      
Rationale: Allows users to easily expose a class' data
-      member or free variable such that it can be inspected from Python with
-      a natural syntax.

-    

-
+    
Rationale: Allows users to easily expose a class' data member
+    or free variable such that it can be inspected from Python with a natural
+    syntax.

+  

+  
 template <class D>
 class_& def_readwrite(char const* name, D T::*pm, char const* doc=0);
 template <class D>
 class_& def_readwrite(char const* name, D& d);
 

 
-    

-      
Effects:

+  

+    
Effects:

 
-      

-
+    

+      
 this->add_property(name, make_getter(pm), make_setter(pm), doc);
-

-        and 
-
+
and
+      
 this->add_static_property(name, make_getter(d), make_setter(d));
-

-        respectively.

-        

-      

+
respectively.

+      

+    

 
-      
Returns: *this

+    
Returns: *this

 
-      
Rationale: Allows users to easily expose a class' data or
-      free variable member such that it can be inspected and set from Python
-      with a natural syntax.

-    

-
+    
Rationale: Allows users to easily expose a class' data or free
+    variable member such that it can be inspected and set from Python with a
+    natural syntax.

+  

+  
 template <typename PickleSuite>
 class_& def_pickle(PickleSuite const&);
 

 
-    

-      
Requires: PickleSuite must be publically derived from pickle_suite.

+  

+    
Requires: PickleSuite must be publically derived from pickle_suite.

 
-      
Effects: Defines a legal combination of the special
-      attributes and methods: __getinitargs__,
-      __getstate__, __setstate__,
-      __getstate_manages_dict__,
-      __safe_for_unpickling__, __reduce__

+    
Effects: Defines a legal combination of the special attributes
+    and methods: __getinitargs__, __getstate__,
+    __setstate__, __getstate_manages_dict__,
+    __safe_for_unpickling__, __reduce__

 
-      
Returns: *this

+    
Returns: *this

 
-      
Rationale: Provides an easy to use
-      high-level interface for establishing complete pickle support for
-      the wrapped class. The user is protected by compile-time consistency
-      checks.

-    

-    

-
+    
Rationale: Provides an easy to use
+    high-level interface for establishing complete pickle support for the
+    wrapped class. The user is protected by compile-time consistency
+    checks.

+  


+  
 class_& enable_pickling();
 

 
-    

-      
Effects: Defines the __reduce__ method and
-      the __safe_for_unpickling__ attribute.
+  

+    
Effects: Defines the __reduce__ method and the
+    __safe_for_unpickling__ attribute.

 
-      
Returns: *this

+    
Returns: *this

 
-      
Rationale: Light-weight alternative to
-      def_pickle(). Enables implementation of
-      pickle support from Python.

-    

-    

-     
+    
Rationale: Light-weight alternative to
+    def_pickle(). Enables implementation of pickle support from Python.

+  


 
-    
Class template
-    bases<T1, T2,...TN>

+  
Class template
+  bases<T1, T2,...TN>

 
-    
An MPL sequence
-    which can be used in class_<...>
-    instantiations indicate a list of base classes.

+  
An MPL
+  sequence which can be used in
+  class_<...> instantiations indicate a list
+  of base classes.

 
-    
Class template bases
-    synopsis

-
+  
Class
+  template bases synopsis

+  
 namespace boost { namespace python
 {
   template <T1 = unspecified,...Tn = unspecified>
@@ -749,10 +736,10 @@ namespace boost { namespace python
 }}
 

 
-    
Example(s)

+  
Example(s)

 
-    
Given a C++ class declaration:

-
+  
Given a C++ class declaration:

+  
 class Foo : public Bar, public Baz
 {
  public:
@@ -766,9 +753,8 @@ class Foo : public Bar, public Baz
  private:
    ...
 };
-

-    A corresponding Boost.Python extension class can be created with: 
-
+
A corresponding Boost.Python extension class can be created with:
+  
 using namespace boost::python;
 
 class_<Foo,bases<Bar,Baz> >("Foo",
@@ -783,22 +769,19 @@ class_<Foo,bases<Bar,Baz> >("Foo",
    .def_readwrite("value", &Foo::value)
    ;
 

-    

-    [1] By "previously-exposed" we mean that the for
-    each B in bases, an instance of
-    class_<B, ...> must have
-    already been constructed. 
-
+  

+  [1] By "previously-exposed" we
+  mean that the for each B in bases, an instance of
+  class_<B, ...> must have
+  already been constructed.
+  
 class_<Base>("Base");
 class_<Derived, bases<Base> >("Derived");
-

-    Revised 
-    
-     5 August, 2002 
-     
+
Revised 
+
+   1 November, 2005 
 
-    
© Copyright Dave Abrahams 2002.

-  
+  
© Copyright Dave
+  Abrahams 2002.

+
 
-