FWIW Finally had a chance to get back to this and found a way to make it work.
If I remove the implicit conversion from smart_ptr<Factory> to
smart_ptr<Factory_wrapper> in the base class export all is good.
Not sure why that leads to the loop and seg fault if you derive from BasicFactory in python though.
On 8/19/05, Scott McKay <skottmckay@gmail.com> wrote:
That has led me to a question on what is required in terms of implicit
conversion calls to handle classes in the same hierarchy that are
wrapped with wrapper<> and held by smart pointers. I can't seem to
find a combination to allow derivation from both Factory and
BasicFactory.
void Export_Factory()
{
class_< Factory_Wrapper, smart_ptr< Factory_Wrapper > >("Factory",
init< >())
.def("generate", &Factory::generate,
&Factory_Wrapper::default_generate, return_self<>())
.def(init< const Factory& >())
;
implicitly_convertible< smart_ptr< Factory_Wrapper >, smart_ptr<
Factory > >();
implicitly_convertible< smart_ptr< Factory >, smart_ptr<
Factory_Wrapper > >();
}
void Export_BasicFactory()
{
class_< BasicFactory_Wrapper, bases< Factory > , smart_ptr<
BasicFactory_Wrapper > >("BasicFactory", init< >())
.def("generate", (Factory& (BasicFactory::*)(SourceGroup&)
)&BasicFactory::generate, (Factory&
(BasicFactory_Wrapper::*)(SourceGroup&))&BasicFactory_Wrapper::default_generate,
return_self<>())
.def(init< const BasicFactory& >())
;
implicitly_convertible< smart_ptr< BasicFactory_Wrapper >,
smart_ptr< Factory > >();
implicitly_convertible< smart_ptr< Factory >, smart_ptr<
BasicFactory_Wrapper > >();
}