Restore main trunk to health

dabrahams · dabrahams · commit 06f6f2ff2140 · 2002-09-16T04:03:39.000Z
[SVN r15359]
diff --git a/test/back_reference.cpp b/test/back_reference.cpp
@@ -93,12 +93,12 @@ BOOST_PYTHON_MODULE_INIT(back_reference_ext)
     def("copy_Z", copy_Z, return_value_policy<copy_const_reference>());
     def("x_instances", &X::count);
     
-    class_<Y>("Y", init<int>())
+    class_<Y>("Y", args<int>())
         .def("value", &Y::value)
         .def("set", &Y::set)
         ;
 
-    class_<Z,std::auto_ptr<Z> >("Z", init<int>())
+    class_<Z,std::auto_ptr<Z> >("Z", args<int>())
         .def("value", &Z::value)
         .def("set", &Z::set)
         ;
diff --git a/test/bienstman3.cpp b/test/bienstman3.cpp
@@ -17,6 +17,6 @@ BOOST_PYTHON_MODULE_INIT(bienstman3_ext)
   using namespace boost::python;
 
   class_<V, boost::noncopyable>("V", no_init);
-  class_<B>("B", init<const V&>());
+  class_<B>("B", args<const V&>());
 
 }
diff --git a/test/bienstman4.cpp b/test/bienstman4.cpp
@@ -30,7 +30,7 @@ BOOST_PYTHON_MODULE_INIT(bienstman4_ext)
   class_<Type1>("T1")
       ;
   
-  class_<Term>("Term", init<Type1&>())
+  class_<Term>("Term", args<Type1&>())
       ;
   
   Type1 t1;
diff --git a/test/bienstman5.cpp b/test/bienstman5.cpp
@@ -17,7 +17,7 @@ BOOST_PYTHON_MODULE_INIT(bienstman5_ext)
 {
   using namespace boost::python;
 
-  class_<M>("M", init<std::complex<double> const&>())
+  class_<M>("M", args<std::complex<double> const&>())
       ;
 }
 
diff --git a/test/callbacks.cpp b/test/callbacks.cpp
@@ -137,8 +137,8 @@ BOOST_PYTHON_MODULE_INIT(callbacks_ext)
     def("apply_to_string_literal", apply_to_string_literal);
         
     
-    class_<X>("X", init<int>())
-        .def(init<X const&>())
+    class_<X>("X", args<int>())
+        .def_init(args<X const&>())
         .def("value", &X::value)
         .def("set", &X::set)
         ;
diff --git a/test/data_members.cpp b/test/data_members.cpp
@@ -22,14 +22,14 @@ double get_fair_value(X const& x) { return x.value(); }
 
 BOOST_PYTHON_MODULE_INIT(data_members_ext)
 {
-    class_<X>("X", init<int>())
+    class_<X>("X", args<int>())
         .def("value", &X::value)
         .def("set", &X::set)
         .def_readonly("x", &X::x)
         .add_property("fair_value", &get_fair_value)
         ;
     
-    class_<Y>("Y", init<int>())
+    class_<Y>("Y", args<int>())
         .def("value", &Y::value)
         .def("set", &Y::set)
         .def_readwrite("x", &Y::x)
diff --git a/test/defaults.cpp b/test/defaults.cpp
@@ -158,17 +158,25 @@ BOOST_PYTHON_MODULE_INIT(defaults_ext)
         .def("barfoo", (object(*)(int, char, std::string, double))0, bar_stubs())
         ;
 
-    class_<Y>("Y", init<>("doc of Y init")) // this should work
+    class_<Y>("Y", no_init)
 	    .def("get_state", &Y::get_state)
         ;
 
     class_<X>("X")
 
-        .def(init<int, optional<char, std::string, double> >("doc of init"))
-        .def(init<std::string, bool>()[default_call_policies()]) // what's a good policy here?
+# if (!defined(BOOST_INTEL_CXX_VERSION) || BOOST_INTEL_CXX_VERSION > 600)
+        .def(init<int, optional<char, std::string, double> >())
+        .def(init<std::string, bool>())
+# else
+        .def_init(args<int>())
+        .def_init(args<int, char>())
+        .def_init(args<int, char, std::string>())
+        .def_init(args<int, char, std::string, double>())
+        .def_init(args<std::string, bool>())
+# endif
         .def("get_state", &X::get_state)
         .def("bar", &X::bar, X_bar_stubs())
-        .def("bar2", &X::bar2, X_bar_stubs2("doc of X::bar2")[return_internal_reference<>()])
+        .def("bar2", &X::bar2, X_bar_stubs2(), return_internal_reference<>())
         .def("foo", (object(X::*)(std::string, bool) const)0, X_foo_2_stubs())
         .def("foo", (object(X::*)(int, bool) const)0, X_foo_2_stubs())
         .def("foo", (object(X::*)(list, list, bool) const)0, X_foo_3_stubs())
diff --git a/test/docstring.cpp b/test/docstring.cpp
@@ -36,24 +36,23 @@ BOOST_PYTHON_MODULE_INIT(docstring_ext)
         "A simple test module for documentation strings\n"
         "Exercised by docstring.py"
         ;
-
+        
     class_<X>("X",
               "A simple class wrapper around a C++ int\n"
               "includes some error-checking"
-
-              , init<int>(
-                  "this is the __init__ function\n"
-                  "its documentation has two lines."
-                )
+                      
+              , args<int>(),
+              "this is the __init__ function\n"
+              "its documentation has two lines."
 
         )
         .def("value", &X::value,
              "gets the value of the object")
         ;
-
+        
     def("create", create, return_value_policy<manage_new_object>(),
         "creates a new X object");
-
+        
     def("fact", fact, "compute the factorial");
 }
 
diff --git a/test/extract.cpp b/test/extract.cpp
@@ -124,7 +124,7 @@ BOOST_PYTHON_MODULE_INIT(extract_ext)
         ;
 
     object x_class(
-        class_<X>("X", init<int>())
+        class_<X>("X", args<int>())
             .def( "__repr__", x_rep));
         
     // Instantiate an X object through the Python interface
diff --git a/test/implicit.cpp b/test/implicit.cpp
@@ -27,7 +27,7 @@ BOOST_PYTHON_MODULE_INIT(implicit_ext)
     def("x_value", x_value);
     def("make_x", make_x);
 
-    class_<X>("X", init<int>())
+    class_<X>("X", args<int>())
         .def("value", &X::value)
         .def("set", &X::set)
         ;
diff --git a/test/list.cpp b/test/list.cpp
@@ -138,7 +138,7 @@ BOOST_PYTHON_MODULE_INIT(list_ext)
 
     def("exercise", exercise);
     
-    class_<X>("X", init<int>())
+    class_<X>("X", args<int>())
         .def( "__repr__", x_rep)
         ;
 }
diff --git a/test/m1.cpp b/test/m1.cpp
@@ -259,8 +259,8 @@ BOOST_PYTHON_MODULE_INIT(m1)
         ;
 
     class_<complicated>("complicated",
-                        init<simple const&,int>())
-        .def(init<simple const&>())
+                        args<simple const&,int>())
+        .def_init(args<simple const&>())
         .def("get_n", &complicated::get_n)
         ;
 }
diff --git a/test/multi_arg_constructor.cpp b/test/multi_arg_constructor.cpp
@@ -17,7 +17,7 @@ BOOST_PYTHON_MODULE_INIT(multi_arg_constructor_ext)
 
   class_<A, shared_ptr<A> >(
       "A"
-      , init<double, double, double, double, double, double, double, double, double>()
+      , args<double, double, double, double, double, double, double, double, double>()
       )
       ;
 
diff --git a/test/nested.cpp b/test/nested.cpp
@@ -34,12 +34,12 @@ BOOST_PYTHON_MODULE_INIT(nested_ext)
 
     // Establish X as the current scope.
     scope x_class(
-        class_<X>("X", init<int>())
+        class_<X>("X", args<int>())
            .def(str(self))
         );
 
     // Y will now be defined in the current scope
-    class_<Y>("Y", init<int>())
+    class_<Y>("Y", args<int>())
         .def(str(self))
         ;
 }
diff --git a/test/operators.cpp b/test/operators.cpp
@@ -59,7 +59,7 @@ std::ostream& operator<<(std::ostream& s, X const& x)
 
 BOOST_PYTHON_MODULE_INIT(operators_ext)
 {
-    class_<X>("X", init<int>())
+    class_<X>("X", args<int>())
         .def("value", &X::value)
         .def(self - self)
         .def(self - int())
@@ -77,7 +77,7 @@ BOOST_PYTHON_MODULE_INIT(operators_ext)
         .def(pow(int(),self))
         ;
 
-    class_<test_class<1> >("Z", init<int>())
+    class_<test_class<1> >("Z", args<int>())
         .def(int_(self))
         .def(float_(self))
         .def(complex_(self))
diff --git a/test/pickle1.cpp b/test/pickle1.cpp
@@ -48,7 +48,7 @@ namespace {
 BOOST_PYTHON_MODULE_INIT(pickle1_ext)
 {
   using namespace boost::python;
-  class_<world>("world", init<const std::string&>())
+  class_<world>("world", args<const std::string&>())
       .def("greet", &world::greet)
       .def_pickle(world_pickle_suite())
       ;
diff --git a/test/pickle2.cpp b/test/pickle2.cpp
@@ -90,7 +90,7 @@ namespace { // Avoid cluttering the global namespace.
 BOOST_PYTHON_MODULE_INIT(pickle2_ext)
 {
     boost::python::class_<world>(
-        "world", boost::python::init<const std::string&>())
+        "world", boost::python::args<const std::string&>())
         .def("greet", &world::greet)
         .def("get_secret_number", &world::get_secret_number)
         .def("set_secret_number", &world::set_secret_number)
diff --git a/test/pickle3.cpp b/test/pickle3.cpp
@@ -98,7 +98,7 @@ namespace { // Avoid cluttering the global namespace.
 BOOST_PYTHON_MODULE_INIT(pickle3_ext)
 {
     boost::python::class_<world>(
-        "world", boost::python::init<const std::string&>())
+        "world", boost::python::args<const std::string&>())
         .def("greet", &world::greet)
         .def("get_secret_number", &world::get_secret_number)
         .def("set_secret_number", &world::set_secret_number)
diff --git a/test/test_pointer_adoption.cpp b/test/test_pointer_adoption.cpp
@@ -26,7 +26,7 @@ struct inner
     {
         this->s = new_s;
     }
-
+    
     std::string s;
 };
 
@@ -42,7 +42,7 @@ struct A : Base
     {
         ++a_instances;
     }
-
+    
     ~A()
     {
         --a_instances;
@@ -65,7 +65,7 @@ struct B
 {
     B() : x(0) {}
     B(A* x_) : x(x_) {}
-
+    
     inner const* adopt(A* x) { this->x = x; return &x->get_inner(); }
 
     std::string a_content()
@@ -96,29 +96,29 @@ BOOST_PYTHON_MODULE_INIT(test_pointer_adoption_ext)
     def("create", create, return_value_policy<manage_new_object>());
 
     def("as_A", as_A, return_internal_reference<>());
-
+    
     class_<Base>("Base")
         ;
-
-    class_<A, bases<Base> >("A", no_init)
+        
+    class_<A, bases<Base> >(no_init)
         .def("content", &A::content)
         .def("get_inner", &A::get_inner, return_internal_reference<>())
         ;
-
-    class_<inner>("inner", no_init)
+    
+    class_<inner>(no_init)
         .def("change", &inner::change)
         ;
-
+        
     class_<B>("B")
-        .def(init<A*>()[with_custodian_and_ward_postcall<1,2>()])
-
+        .def_init(args<A*>(), with_custodian_and_ward_postcall<1,2>())
+            
         .def("adopt", &B::adopt
              // Adopt returns a pointer referring to a subobject of its 2nd argument (1st being "self")
              , return_internal_reference<2
              // Meanwhile, self holds a reference to the 2nd argument.
              , with_custodian_and_ward<1,2> >()
             )
-
+            
          .def("a_content", &B::a_content)
         ;
 }
diff --git a/test/virtual_functions.cpp b/test/virtual_functions.cpp
@@ -89,22 +89,22 @@ int X::counter;
 
 BOOST_PYTHON_MODULE_INIT(virtual_functions_ext)
 {
-    class_<concrete, concrete_callback>("concrete", init<int>())
+    class_<concrete, concrete_callback>("concrete", args<int>())
         .def("value", &concrete::value)
         .def("set", &concrete::set)
         .def("call_f", &concrete::call_f)
         .def("f", &concrete_callback::f_impl)
         ;
         
     class_<abstract, boost::noncopyable, boost::shared_ptr<abstract_callback>
-        >("abstract", init<int>())
+        >("abstract", args<int>())
             
         .def("value", &abstract::value)
         .def("call_f", &abstract::call_f)
         .def("set", &abstract::set)
         ;
         
-    class_<Y>("Y", init<int>())
+    class_<Y>("Y", args<int>())
         .def("value", &Y::value)
         .def("set", &Y::set)
         ;

Original file line number	Diff line number	Diff line change
`@@ -93,12 +93,12 @@ BOOST_PYTHON_MODULE_INIT(back_reference_ext)`
`93`	`93`	`def("copy_Z", copy_Z, return_value_policy<copy_const_reference>());`
`94`	`94`	`def("x_instances", &X::count);`
`95`	`95`
`96`		`- class_<Y>("Y", init<int>())`
	`96`	`+ class_<Y>("Y", args<int>())`
`97`	`97`	`.def("value", &Y::value)`
`98`	`98`	`.def("set", &Y::set)`
`99`	`99`	`;`
`100`	`100`
`101`		`- class_<Z,std::auto_ptr<Z> >("Z", init<int>())`
	`101`	`+ class_<Z,std::auto_ptr<Z> >("Z", args<int>())`
`102`	`102`	`.def("value", &Z::value)`
`103`	`103`	`.def("set", &Z::set)`
`104`	`104`	`;`
Original file line number	Diff line number	Diff line change
`@@ -17,6 +17,6 @@ BOOST_PYTHON_MODULE_INIT(bienstman3_ext)`
`17`	`17`	`using namespace boost::python;`
`18`	`18`
`19`	`19`	`class_<V, boost::noncopyable>("V", no_init);`
`20`		`- class_<B>("B", init<const V&>());`
	`20`	`+ class_<B>("B", args<const V&>());`
`21`	`21`
`22`	`22`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ BOOST_PYTHON_MODULE_INIT(bienstman4_ext)`
`30`	`30`	`class_<Type1>("T1")`
`31`	`31`	`;`
`32`	`32`
`33`		`- class_<Term>("Term", init<Type1&>())`
	`33`	`+ class_<Term>("Term", args<Type1&>())`
`34`	`34`	`;`
`35`	`35`
`36`	`36`	`Type1 t1;`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ BOOST_PYTHON_MODULE_INIT(bienstman5_ext)`
`17`	`17`	`{`
`18`	`18`	`using namespace boost::python;`
`19`	`19`
`20`		`- class_<M>("M", init<std::complex<double> const&>())`
	`20`	`+ class_<M>("M", args<std::complex<double> const&>())`
`21`	`21`	`;`
`22`	`22`	`}`
`23`	`23`
Original file line number	Diff line number	Diff line change
`@@ -137,8 +137,8 @@ BOOST_PYTHON_MODULE_INIT(callbacks_ext)`
`137`	`137`	`def("apply_to_string_literal", apply_to_string_literal);`
`138`	`138`
`139`	`139`
`140`		`- class_<X>("X", init<int>())`
`141`		`- .def(init<X const&>())`
	`140`	`+ class_<X>("X", args<int>())`
	`141`	`+ .def_init(args<X const&>())`
`142`	`142`	`.def("value", &X::value)`
`143`	`143`	`.def("set", &X::set)`
`144`	`144`	`;`
Original file line number	Diff line number	Diff line change
`@@ -124,7 +124,7 @@ BOOST_PYTHON_MODULE_INIT(extract_ext)`
`124`	`124`	`;`
`125`	`125`
`126`	`126`	`object x_class(`
`127`		`- class_<X>("X", init<int>())`
	`127`	`+ class_<X>("X", args<int>())`
`128`	`128`	`.def( "__repr__", x_rep));`
`129`	`129`
`130`	`130`	`// Instantiate an X object through the Python interface`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ BOOST_PYTHON_MODULE_INIT(implicit_ext)`
`27`	`27`	`def("x_value", x_value);`
`28`	`28`	`def("make_x", make_x);`
`29`	`29`
`30`		`- class_<X>("X", init<int>())`
	`30`	`+ class_<X>("X", args<int>())`
`31`	`31`	`.def("value", &X::value)`
`32`	`32`	`.def("set", &X::set)`
`33`	`33`	`;`