DispatchPtr.h

Go to the documentation of this file.

#ifndef CPYRT_DISPATCHPTR_H
#define CPYRT_DISPATCHPTR_H
 
//////////////////////////////////////////////////////////////////////////////
//                                                                          //
// DispatchPtr                                                              //
//                                                                          //
// Smart pointer for reference management and C++ instance tracking when    //
// cross-inheriting. The carried pointer is always expected to be derived   //
// from CPPInstance, and the DispatchPtr to be embedded in the C++ instance //
// derived dispatcher to which it points (ownership is two-way; life-times  //
// are equal). The C++ dispatcher then uses the DispatchPtr to call Python  //
// functions for virtual methods.                                           //
//                                                                          //
//////////////////////////////////////////////////////////////////////////////
 
// Bindings
#include <Python.h>
#include "cpyrt/CommonDefs.h"
 
namespace cppjit::cpyrt {
class PythonGILRAII {
  PyGILState_STATE state;
 
public:
  PythonGILRAII() : state(PyGILState_Ensure()) {}
  ~PythonGILRAII() { PyGILState_Release(state); }
};
 
class CPYRT_CLASS_EXTERN DispatchPtr {
public:
  // Default constructor: only ever created from C++, as by definition, creation
  // from the Python side makes the relevant Python instance available. Calls to
  // the default ctor happen eg. in STL containers. It is expected that the
  // pointer to the Python object is filled in later, eg. through assign().
  DispatchPtr() : fPyHardRef(nullptr), fPyWeakRef(nullptr) {}
 
  // Conversion constructor: called with C++ object construction when the
  // PyObject is known (eg. when instantiating from Python), with pyobj the
  // Python-side representation of the C++ object.
  explicit DispatchPtr(PyObject* pyobj, bool strong = false);
 
  // Copy constructor: only ever called from C++. The Python object needs to be
  // copied, in case it has added state, and rebound to the new C++ instance.
  DispatchPtr(const DispatchPtr& other, void* cppinst);
 
  // Assignment: only ever called from C++. Similarly to the copy constructor,
  // the Pythonb object needs to be copied and rebound.
  DispatchPtr& assign(const DispatchPtr& other, void* cppinst);
 
  // Do not otherwise allow straight copies/assignment.
  DispatchPtr(DispatchPtr&) = delete;
  DispatchPtr(DispatchPtr&&) = delete;
  DispatchPtr& operator=(const DispatchPtr& other) = delete;
 
  // lifetime is directly bound to the lifetime of the dispatcher object
  ~DispatchPtr();
 
  // either C++ owns the Python object through a reference count (on fPyHardRef)
  // or Python owns the C++ object and we only have a weak reference (through
  // fPyWeakRef)
  void PythonOwns();
  void CppOwns();
 
  // access to underlying object: cast and dereferencing
  operator PyObject*() const { return Get(); }
 
  PyObject* operator->() const { return Get(); }
 
private:
  PyObject* Get(bool borrowed = true) const;
 
private:
  PyObject* fPyHardRef;
  PyObject* fPyWeakRef;
};
 
} // namespace cppjit::cpyrt
 
#endif // !CPYRT_DISPATCHPTR_H