Working with a homebrewed shared pointer type that does not implement .get()

[jbarlow83]

First off, I really appreciate pybind11, after having played with bindings in Cython, SWIG, and some automatic generators that mostly create broken bindings, this is the clear winner.

I am trying to bind a class that is returned via a library's homebrewed shared pointer called PointerHolder that is basically a std::shared_ptr with a slightly different API.

The main difference is that it does not have a .get() method, the equivalent being named .getPointer(). It has the expected operator* and operator->.

Changing the existing library and header is not an option.

Is there any way to deal with this? Is it safe to change this occurrence of src.get() in pybind11 to *src since most custom holder types will have operator*? Or should should I wrap or extend PointerHolder to work around this?

In file included from src/main.cpp:15:
In file included from pybind11/pybind11.h:36:
In file included from pybind11/attr.h:13:
pybind11/cast.h:942:17: error: 
      no member named 'get' in 'PointerHolder<Actor>'
            src.get(), return_value_policy::take_ownership, handle(),
            ~~~ ^
pybind11/pybind11.h:140:39: note: 
      in instantiation of member function
      'pybind11::detail::type_caster_holder<Actor, PointerHolder<Actor>
      >::cast' requested here
            handle result = cast_out::cast(args_converter.template call<...
                                      ^
[... some details omitted... ]
1 error generated.
error: command 'clang' failed with exit status 1

[aldanor]

Is it safe to change this occurrence of src.get() in pybind11 to *src since most custom holder types will have operator*.

Nope; because .get() returns the owned pointer which may be null and doesn't dereference it.

In theory, I guess, we could abstract this away, e.g. via specialization (with specializations provided for standard library holders like unique_ptr and shared_ptr), so you could do something like

template<typename Actor> struct pybind11::detail::holder_getter<PointerHolder<Actor>> {
    Actor* get(PointerHolder<Actor>& holder) {
        return holder.getPointer();
    }
}

[dean0x7d]

I don't think there's a need for a struct specialization. A simple function should do. This could be used as generic abstraction for any smart pointer type which has a .get() function:

template <typename T>
auto get_pointer(const T &p) -> decltype(p.get()) { return p.get(); }

Users would just need to provide an overload for types without .get():

namespace pybind11 { namespace detail {
    template <typename T>
    T* get_pointer(const MySmartPtr<T> &p) { return p.getPointer(); }
}}

The occurances of src.get() in pybind11 would need to be replaced with get_pointer(src) to make this work.