for_each changes

[SVN r13513]

include/boost/python/class.hpp

@@ -0,0 +1,283 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef CLASS_DWA200216_HPP
+# define CLASS_DWA200216_HPP
+
+# include <boost/python/class_fwd.hpp>
+# include <boost/python/bases.hpp>
+# include <boost/python/args.hpp>
+# include <boost/python/reference.hpp>
+# include <boost/python/object/class.hpp>
+# include <boost/python/converter/type_id.hpp>
+# include <boost/python/detail/wrap_function.hpp>
+# include <boost/python/detail/member_function_cast.hpp>
+# include <boost/python/object/class_converters.hpp>
+# include <boost/type_traits/ice.hpp>
+# include <boost/type_traits/same_traits.hpp>
+# include <boost/mpl/size.hpp>
+# include <boost/mpl/for_each.hpp>
+# include <boost/mpl/bool_c.hpp>
+# include <boost/python/object/select_holder.hpp>
+# include <boost/python/object/class_wrapper.hpp>
+# include <boost/python/data_members.hpp>
+# include <boost/utility.hpp>
+
+namespace boost { namespace python { 
+
+namespace detail
+{
+  struct write_type_id;
+  
+  template <class T, class Prev = detail::not_specified>
+  struct select_held_type;
+  
+  template <class T1, class T2, class T3>
+  struct has_noncopyable;
+
+  // Register a to_python converter for a class T, depending on the
+  // type of the first (tag) argument. The 2nd argument is a pointer
+  // to the type of holder that must be created. The 3rd argument is a
+  // reference to the Python type object to be created.
+  template <class T, class Holder>
+  static inline void register_copy_constructor(mpl::bool_c<true> const&, Holder*, ref const& obj, T* = 0)
+  {
+      objects::class_wrapper<T,Holder> x(obj);
+  }
+
+  // Tag dispatched to have no effect.
+  template <class T, class Holder>
+  static inline void register_copy_constructor(mpl::bool_c<false> const&, Holder*, ref const&, T* = 0)
+  {
+  }
+}
+
+//
+// class_<T,Bases,HolderGenerator>
+//
+//      This is the primary mechanism through which users will expose
+//      C++ classes to Python. The three template arguments are:
+//
+template <
+    class T // class being wrapped
+    , class X1 // = detail::not_specified
+    , class X2 // = detail::not_specified
+    , class X3 // = detail::not_specified
+    >
+class class_ : public objects::class_base
+{
+    typedef class_<T,X1,X2,X3> self;
+    BOOST_STATIC_CONSTANT(bool, is_copyable = (!detail::has_noncopyable<X1,X2,X3>::value));
+    
+    typedef typename detail::select_held_type<
+        X1, typename detail::select_held_type<
+        X2, typename detail::select_held_type<
+        X3
+    >::type>::type>::type held_type;
+    
+ public:
+    // Automatically derive the class name - only works on some
+    // compilers because type_info::name is sometimes mangled (gcc)
+    class_();
+    
+    // Construct with the class name.  [ Would have used a default
+    // argument but gcc-2.95.2 choked on typeid(T).name() as a default
+    // parameter value]
+    class_(char const* name);
+
+
+    // Wrap a member function or a non-member function which can take
+    // a T, T cv&, or T cv* as its first parameter, or a callable
+    // python object.
+    template <class F>
+    self& def(char const* name, F f)
+    {
+        // Use function::add_to_namespace to achieve overloading if
+        // appropriate.
+        objects::function::add_to_namespace(
+            this->object(), name,
+            ref(detail::wrap_function(
+                    // This bit of nastiness casts F to a member function of T if possible. 
+                    detail::member_function_cast<T,F>::stage1(f).stage2((T*)0).stage3(f)
+                    )));
+        return *this;
+    }
+
+    template <class Fn, class CallPolicy>
+    self& def(char const* name, Fn fn, CallPolicy policy)
+    {
+        this->def(name
+                  , boost::python::make_function(
+                      // This bit of nastiness casts F to a member function of T if possible. 
+                      detail::member_function_cast<T,Fn>::stage1(fn).stage2((T*)0).stage3(fn)
+                      , policy)
+            );
+        
+        return *this;
+    }
+    
+    // Define the constructor with the given Args, which should be an
+    // MPL sequence of types.
+    template <class Args>
+    self& def_init(Args const&)
+    {
+        def("__init__",
+            make_constructor<Args>(
+                // Using runtime type selection works around a CWPro7 bug.
+                objects::select_holder<T,held_type>((held_type*)0).get()
+                )
+            );
+        return *this;
+    }
+
+    template <class Args, class CallPolicy>
+    self& def_init(Args const&, CallPolicy policy)
+    {
+        def("__init__",
+            make_constructor<Args>(
+                policy
+                // Using runtime type selection works around a CWPro7 bug.
+                , objects::select_holder<T,held_type>((held_type*)0).get()
+                )
+            );
+        return *this;
+    }
+
+    // Define the default constructor.
+    self& def_init()
+    {
+        this->def_init(mpl::list<>::type());
+        return *this;
+    }
+
+    //
+    // Data member access
+    //
+    template <class D>
+    self& def_readonly(char const* name, D T::*pm)
+    {
+        ref fget(make_getter(pm));
+        this->add_property(name, fget);
+        return *this;
+    }
+
+    template <class D>
+    self& def_readwrite(char const* name, D T::*pm)
+    {
+        ref fget(make_getter(pm));
+        ref fset(make_setter(pm));
+        this->add_property(name, fget, fset);
+        return *this;
+    }
+
+    // return the underlying object
+//    ref object() const;
+
+ private: // types
+    typedef objects::class_id class_id;
+    
+    typedef typename detail::select_bases<X1
+            , typename detail::select_bases<X2
+              , typename boost::python::detail::select_bases<X3>::type
+              >::type
+            >::type bases;
+    
+    // A helper class which will contain an array of id objects to be
+    // passed to the base class constructor
+    struct id_vector
+    {
+        typedef objects::class_id class_id;
+        id_vector()
+        {
+            // Stick the derived class id into the first element of the array
+            ids[0] = converter::undecorated_type_id<T>();
+    
+            // Write the rest of the elements into succeeding positions.
+            mpl::for_each<bases>(detail::write_type_id(ids + 1));
+        }
+        
+        BOOST_STATIC_CONSTANT(
+            std::size_t, size = mpl::size<bases>::value + 1);
+        class_id ids[size];
+    };
+    friend struct id_vector;
+};
+
+
+//
+// implementations
+//
+template <class T, class X1, class X2, class X3>
+inline class_<T,X1,X2,X3>::class_()
+    : class_base(typeid(T).name(), id_vector::size, id_vector().ids)
+{
+    // register converters
+    objects::register_class_from_python<T,bases>();
+    
+    detail::register_copy_constructor<T>(
+        mpl::bool_c<is_copyable>()
+        , objects::select_holder<T,held_type>((held_type*)0).get()
+        , this->object());
+}
+
+template <class T, class X1, class X2, class X3>
+inline class_<T,X1,X2,X3>::class_(char const* name)
+    : class_base(name, id_vector::size, id_vector().ids)
+{
+    // register converters
+    objects::register_class_from_python<T,bases>();
+    
+    detail::register_copy_constructor<T>(
+        mpl::bool_c<is_copyable>()
+        , objects::select_holder<T,held_type>((held_type*)0).get()
+        , this->object());
+}
+
+namespace detail
+{
+  // A function object that on each invocation writes the id of 
+  // the type 'T' into the iterator passed to it in the constructor
+  struct write_type_id
+  {
+      write_type_id(converter::undecorated_type_id_t* iter)
+          : m_iter(iter)
+      {}
+
+      template <class T> void operator()(boost::mpl::identity<T>)
+      {
+          *m_iter++ = converter::undecorated_type_id<T>();
+      };
+
+   private:
+      converter::undecorated_type_id_t* m_iter;
+  };
+
+
+  template <class T1, class T2, class T3>
+  struct has_noncopyable
+      : type_traits::ice_or<
+        is_same<T1,noncopyable>::value
+      , is_same<T2,noncopyable>::value
+      , is_same<T3,noncopyable>::value>
+  {};
+
+
+    template <class T, class Prev>
+    struct select_held_type
+        : mpl::select_if_c<
+            type_traits::ice_or<
+                 specifies_bases<T>::value
+               , is_same<T,noncopyable>::value
+            >::value
+            , Prev
+            , T
+          >
+    {
+    };
+}
+
+}} // namespace boost::python
+
+#endif // CLASS_DWA200216_HPP

pyste/NEWS

@@ -1,180 +0,0 @@
-23 October 2003
-Fixed bug where a class would appear more than one in the generated code.
-
-6 October 2003
-Fixed bug reported by Niall Douglas (using his patch) about UniqueInt not
-appearing correctly with --multiple.
-
-Added precompiled header support on windows systems (using #pragma hdrstop).
-Suggested by Niall Douglas.
-
-Fixed a bug with -I directive and AllFromHeader. Reported by Scott Snyder.
-
-4 October 2003
-Added return_self, thanks for Niall Douglas for pointing out that it was
-missing.
-
-Added --file-list, where you can pass a file where the pyste files are listed
-one per line. Also suggested by Niall Douglas.
-
-Documentation has been finally updated, after a long wait. Please let me know
-if you spot any mistake!
-
-2 October 2003
-Scott Snyder found a typo in ClassExporter that prevented -= and *= operators
-from being exported. Thanks Scott!
-
-20 September 2003
-Added return_by_value in the list of policies supported. Thanks to Niall
-Douglas for the remainder.
-
-19 September 2003
-Better support for unnamed enums, plus they are by default exported to the
-parent's namespace. Normal enums can have the same behaviour using the function
-export_values on the Enum object. Feature requested by Niall Douglas.
-
-10 September 2003
-A new variable is accessible in the Pyste files: INTERFACE_FILE contains the 
-full path of the pyste file.
-
-4 September 2003
-Now it is possible to override protected and private pure virtual functions
-in Python, as requested by Roman Yakovenko.
-
-23 August 2003
-Fixed bug where some Imports where not writing their include files.  
-Now whenever the declarations change, the cache files are rebuilt
-automatically.
-
-19 August 2003
-Fixed a bug related to the generation of the bases<> template.
-
-17 August 2003
-Added support for insertion of user code in the generated code.
-
-16 August 2003
-Applied a patch by Gottfried Ganssauge that adds exception specifiers to 
-wrapper functions and pointer declarations. Thanks a lot Gottfried!!
-
-Applied a patch by Prabhu Ramachandran that fixes ae problem with the 
-pure virtual method generation. Thanks again Prabhu!
-
-10 August 2003
-Support for incremental generation of the code has been added. This changes
-how --multiple works; documentation of this new feature will follow. Thanks
-to Prabhu Ramachandran, that saw the need for this feature and discussed a
-solution. 
-
-Automatically convert \ to / in Windows systems before passing the paths to
-gccxml.
-
-Fixed a bug reported by Prabhu Ramachandran, where in some classes the virtual
-methods were being definied incorrectly. Thanks a lot Prabhu!
-
-7 July 2003
-Applied 2 patches by Prabhu Ramachandran: a fix in the new --multiple method,
-and two new functions "hold_with_shared_ptr" and its counterpart for auto_ptr.
-Thanks a lot Prabhu!
-
-Fixed a bug where the macro BOOST_PYTHON_OPAQUE_SPECIALIZED_TYPE_ID was being
-called multiple times for the same type.
-Thanks to Gottfried Ganßauge for reporting this!
-
-Fixed bug where using AllFromHeader didn't use bases<> when exporting 
-hierarchies.
-
-Fixed the staticmethod bug.
-
-5 July 2003
-Changed how --multiple works: now it generates one cpp file for each pyste
-file, makeing easier to integrate Pyste with build systems.
-
-4 July 2003
-Applied patch that solved a bug in ClassExporter and added a distutils install
-script (install/setup.py), both contributed by Prabhu Ramachandran.
-Thanks Prabhu!
-
-2 July 2003
-Jim Wilson found a bug where types like "char**" were being interpreted as 
-"char*". Thanks Jim!
-
-16 June 2003
-Thanks to discussions with David Abrahams and Roman Sulzhyk, some behaviours
-have changed:
-
-- If you export a derived class without exporting its base classes, the derived
-  class will explicitly export the bases's methods and attributes. Before, if
-  you were interested in the bases's methods, you had to export the base
-  classes too.
-
-- Added a new function, no_override. When a member function is specified as
-  "no_override", no virtual wrappers are generated for it, improving
-  performance and letting the code more clean.
-
-- There was a bug in which the policy of virtual member functions was being
-  ignored (patch by Roman Sulzhyk). 
-  
-Thanks again to Roman Sulzhyk for the patches and discussion in the c++-sig.
-
-4 June 2003
-Major improvements in memory usage.
-
-3 June 2003
-Appliced a patch from Giulio Eulisse that allows unnamed enumerations to be
-exported with an AllFromHeader construct. Thanks a lot Giulio!
-
-2 June 2003
-Added a new construct, add_method. See documentation.
-
-23 May 2003
-Support for global variables added.
-Various bug fixes.
-
-08 May 2003
-Fixed bug where in a certain cases the GCCXMLParser would end up with multiple
-declarations of the same class
-
-22 Apr 2003
-- Now shows a warning when the user tries to export a forward-declared class.
-  Forward-declared classes are ignored by the AllFromHeader construct.
-- Fixed a bug where classes, functions and enums where being exported, even if
-  excluded from a AllFromHeader construct.
-
-16 Apr 2003
-Added a more generic (but ugly) code to declare the smart pointer converters.
-
-07 Apr 2003
-- Removed the warnings about forward declarations: it was not accurate enough.
-  Another strategy must be thought of.
-- Fixed bug in the --multiple mode, where the order of the class instantiations
-  could end up wrong.
-- Lots of fixes in the documentation, pointed out by Dirk Gerrits. Thanks Dirk!
-- Fixed support for the return_opaque_pointer policy (the support macro was not
-  being declared).
-
-
-06 Apr 2003
-Support for the improved static data members support of Boost.Python.
-
-05 Apr 2003
-New option for generating the bindings: --multiple.
-
-02 Apr 2003
-Forward declarations are now detected and a warning is generated.
-
-24 Mar 2003
-Default policy for functions/methods that return const T& is now
-return_value_policy<copy_const_reference>().
-
-22 Mar 2003
-Exporting virtual methods of the base classes in the derived classes too.
-
-21 Mar 2003
-Added manual support for boost::shared_ptr and std::auto_ptr (see doc).
-
-19 Mar 2003 
-Added support for int, double, float and long operators acting as expected in
-python.
-
-14 Mar 2003 
-Fixed bug: Wrappers for protected and virtual methods were not being generated.