A wrapped std::shared_ptr.

[andre-caldas]

Dear professor and other developers,

I am writing python bindings for my still unborn software. I do use std::shared_ptr exhaustively. And I am very happy that nanobind deals with std::shared_ptr in a wonderful and transparent way.

I have, however, wrapped all my std::shared_ptr to a derived class that does not allow referencing a "null pointer". My class is called SharedPtr.

https://github.com/andre-caldas/ParaCADis/blob/main/src/base/expected_behaviour/SharedPtr.h

I do not want to use SharedPtr in nanobind. They are just std::shared_ptr with some extra methods and can be safely sliced back and forth. I do, however, have methods that take as argument and return instances of SharedPtr.

Of course, I could just copy and paste nanobind/stl/shared_ptr.h and get things to work with SharedPtr. But I think there must be a nicer and more "nanobindonic" way to do it.

So... what would be the ideal way to handle my case? For example, I have a Container class that has a Container::addContainer(SharedPtr<Container>) that nests containers:
https://github.com/andre-caldas/ParaCADis/blob/09abeb18a360b769e09ecfca480a25c6b3b8f2c5/src/base/document_tree/Container.h#L62

I would like to work with it as if instead of a SharedPtr<Container>, it took an std::shared_ptr<Container>.

[andre-caldas]

I think I am supposed to implement a type caster. It seems that the correct way to implement a type caster is by specializing the type_caster template.

Instead of copying the nanobind/stl/shared_ptr.h code, I have derived from type_caster<std::shared_ptr<T>> and then I convert back and forth, from my SharedPtr<T> to std::shared_ptr<T>.

I am not really sure if it is correct to use std::move() where I did.

template <typename T>
struct type_caster<SharedPtr<T>>
    : type_caster<std::shared_ptr<T>>
{
  NB_TYPE_CASTER(SharedPtr<T>, type_caster<std::shared_ptr<T>>::Caster::Name)

  bool from_python(handle src, uint8_t flags, cleanup_list *cleanup) noexcept
  {
    if(!type_caster<std::shared_ptr<T>>::from_python(src, flags, cleanup))
    {
      return false;
    }
    // Can we use std::move()? Or ::value is accessed by other people?
    value = std::move(type_caster<std::shared_ptr<T>>::value);
    return true;
  }

  static handle from_cpp(
      const Value &value, rv_policy p, cleanup_list *cleanup) noexcept
  {
    return type_caster<std::shared_ptr<T>>::from_cpp(value.sliced(), p, cleanup);
  }
};

Type caster:
https://github.com/andre-caldas/ParaCADis/blob/5746afe0f85e2a82114aa39a637fd90575377da3/src/python_bindings/SharedPtr_type_caster.h

Binding:
https://github.com/andre-caldas/ParaCADis/blob/5746afe0f85e2a82114aa39a637fd90575377da3/src/base/document_tree/python_bindings/module.cpp#L53

Executed commands::

$ python3
Python 3.11.9 (main, Apr 10 2024, 13:16:36) [GCC 13.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import paracadis.geometric_primitives as g
>>> v = g.DeferenceableVector(1,2,3)
>>> import paracadis.document as d
>>> c = d.Container()
>>> c.add_element(v)
>>> 
>>> # Now... to avoid a leak...
>>> # It seems "c" is not garbage collected on "quit()"
>>> c = 'abc'
>>> quit()
$

If I do not execute c = 'abc', I get a leak message. But I think it is python, not me. :-)

Please, let me know if I am doing anything wrong.