[C++-sig] wrapper & HeldType

[Roman Yakovenko]

Sorry I forgot to attach files.

On 10/16/05, Roman Yakovenko <roman.yakovenko at gmail.com> wrote:
> On 10/12/05, David Abrahams <dave at boost-consulting.com> wrote:
>
> > Could you please post a minimal, complete example that you think
> > should work?
>
> Yes of course. See attached files.
>
> C++ code to be exported
>
> smart_pointers_to_be_exported.hpp
> smart_pointers_to_be_exported.cpp
>
> boost.python wrappers:
>
> smart_pointers.cpp
>
> In order to show my point file smart_pointers.cpp could not be compiled.
> If you want it to be compiled uncomment PyObject* argument in wrapper
> constructors.
>
> An other way you can see my point to update boost.python unittests to
> use wrapper
> class.
>
> > Thanks,
> > Dave
> >
> > --
> > Dave Abrahams
> > Boost Consulting
> > www.boost-consulting.com
>
> Thanks for help
>
> Roman Yakovenko
>
-------------- next part --------------
#ifndef __smart_pointers_to_be_exported_hpp__
#define __smart_pointers_to_be_exported_hpp__
#include <memory>
#include "boost/shared_ptr.hpp"

namespace smart_pointers{

struct base{
    base() : base_value(19) {}
    int base_value;
    virtual int get_base_value(){ return base_value; }
};

struct data : base{
    data() : value(11){}
    int value;
    virtual int get_value(){ return value; }
};

typedef std::auto_ptr< base > base_a_ptr;
typedef boost::shared_ptr< base > base_s_ptr;

typedef std::auto_ptr< data > data_a_ptr;
typedef boost::shared_ptr< data > data_s_ptr;
    
data_a_ptr create_auto();
data_s_ptr create_shared();

int ref_auto( data_a_ptr& a );
int ref_shared( data_s_ptr& a );

int val_auto( data_a_ptr a );
int val_shared( data_s_ptr a );

int const_ref_auto( const data_a_ptr& a );
int const_ref_shared( const data_s_ptr& a );

int ref_auto_base_value( base_a_ptr& a );
int ref_shared_base_value( base_s_ptr& a );

int val_auto_base_value( base_a_ptr a );
int val_shared_base_value( base_s_ptr a );

int const_ref_auto_base_value( const base_a_ptr& a );
int const_ref_shared_base_value( const base_s_ptr& a );
    
}    

#endif//__smart_pointers_to_be_exported_hpp__
-------------- next part --------------
#include "smart_pointers_to_be_exported.hpp"

namespace smart_pointers{
   
data_a_ptr create_auto(){ return data_a_ptr( new data() ); }
data_s_ptr create_shared(){ return data_s_ptr( new data() ); }

int ref_auto( data_a_ptr& a ){ return a->get_value(); }
int ref_shared( data_s_ptr& a ){ return a->get_value(); }

int val_auto( data_a_ptr a ){ return a->get_value(); }
int val_shared( data_s_ptr a ){ return a->get_value(); }

int const_ref_auto( const data_a_ptr& a ){ return a->get_value(); }
int const_ref_shared( const data_s_ptr& a ){ return a->get_value(); }

int ref_auto_base_value( base_a_ptr& a ){ return a->get_base_value(); }
int ref_shared_base_value( base_s_ptr& a ){ return a->get_base_value(); }

int val_auto_base_value( base_a_ptr a ){ return a->get_base_value(); }
int val_shared_base_value( base_s_ptr a ){ return a->get_base_value(); }

int const_ref_auto_base_value( const base_a_ptr& a ){ return a->get_base_value(); }
int const_ref_shared_base_value( const base_s_ptr& a ){ return a->get_base_value(); }
   
    
}    
-------------- next part --------------
//std directories: ['d:\\boost_cvs', 'c:\\python\\include']
//user defined directories: ['d:\\pygccxml_sources\\source\\pyplusplus']

#include "boost/python.hpp"

#include "unittests/data/smart_pointers_to_be_exported.hpp"

namespace bp = boost::python;

struct base_wrapper : smart_pointers::base, bp::wrapper< smart_pointers::base > {

    base_wrapper(/*PyObject**/, smart_pointers::base const & arg )
    : smart_pointers::base( arg )
      , bp::wrapper< smart_pointers::base >()
    {}

    base_wrapper(/*PyObject**/ )
    : smart_pointers::base( )
      , bp::wrapper< smart_pointers::base >()
    {}

    virtual int get_base_value(  ){
        if( bp::override get_base_value = this->get_override( "get_base_value" ) )
            return get_base_value(  );
        else
            return smart_pointers::base::get_base_value(  );
    }
    
    virtual int default_get_base_value(  ){
        return this->smart_pointers::base::get_base_value( );
    }

};

struct data_wrapper : smart_pointers::data, bp::wrapper< smart_pointers::data > {

    data_wrapper(/*PyObject**/, smart_pointers::data const & arg )
    : smart_pointers::data( arg )
      , bp::wrapper< smart_pointers::data >()
    {}

    data_wrapper(/*PyObject**/ )
    : smart_pointers::data( )
      , bp::wrapper< smart_pointers::data >()
    {}

    virtual int get_value(  ){
        if( bp::override get_value = this->get_override( "get_value" ) )
            return get_value(  );
        else
            return smart_pointers::data::get_value(  );
    }
    
    virtual int default_get_value(  ){
        return this->smart_pointers::data::get_value( );
    }

};

BOOST_PYTHON_MODULE(smart_pointers){
    bp::class_< smart_pointers::base, base_wrapper, boost::shared_ptr< smart_pointers::base > >( "base" )    
        .def( bp::init< >()[bp::default_call_policies()] )    
        .def( "get_base_value"
                , &smart_pointers::base::get_base_value
                , &::base_wrapper::default_get_base_value
                , bp::default_call_policies() )    
        .def_readwrite( "base_value", &smart_pointers::base::base_value );

    bp::register_ptr_to_python< boost::shared_ptr< smart_pointers::base > >();

    bp::register_ptr_to_python< std::auto_ptr< smart_pointers::base > >();

    bp::class_< smart_pointers::data, data_wrapper, bp::bases< smart_pointers::base >, boost::shared_ptr< smart_pointers::data > >( "data" )    
        .def( bp::init< >()[bp::default_call_policies()] )    
        .def( "get_value"
                , &smart_pointers::data::get_value
                , &::data_wrapper::default_get_value
                , bp::default_call_policies() )    
        .def_readwrite( "value", &smart_pointers::data::value );

    bp::register_ptr_to_python< boost::shared_ptr< smart_pointers::data > >();

    bp::implicitly_convertible< boost::shared_ptr< smart_pointers::data >, boost::shared_ptr< smart_pointers::base > >();

    bp::register_ptr_to_python< std::auto_ptr< smart_pointers::data > >();

    bp::implicitly_convertible< std::auto_ptr< smart_pointers::data >, std::auto_ptr< smart_pointers::base > >();

}