Use customized smart_holder for disowning pointers

Author: HaarigerHarald

.gitmodules

@@ -1,4 +1,4 @@
 [submodule "pybind11"]
 	path = pybind11
-	url = https://github.com/pybind/pybind11
-	branch = v2.6
+	url = https://github.com/HaarigerHarald/pybind11
+	branch = smart_holder

CMakeLists.txt

@@ -20,12 +20,6 @@ find_package(Geant4 OPTIONAL_COMPONENTS gdml ui_tcsh motif vis_raytracer_x11 vis
 include_directories(${Geant4_INCLUDE_DIRS})
 
 set(PYBIND11_PYTHON_VERSION 3.5)
-
-if(EXISTS ${CMAKE_SOURCE_DIR}/pybind11/CMakeLists.txt)
-  add_subdirectory(pybind11)
-else()
-  # if not checked out correctly we search for an install
-  find_package(pybind11 2.6 REQUIRED)
-endif()
+add_subdirectory(pybind11)
 
 add_subdirectory(source)

pybind11

@@ -3,7 +3,6 @@ requires = [
     "setuptools>=42",
     "wheel",
     "cmake>=3.12",
-    "pybind11>=2.6",
     "ninja; sys_platform != 'win32'",
 ]
 build-backend = "setuptools.build_meta"

pyproject.toml

@@ -49,6 +49,8 @@ if(Geant4_qt_FOUND)
   add_definitions(-DG4_HAS_QT)
 endif()
 
+add_definitions(-DPYBIND11_USE_SMART_HOLDER_AS_DEFAULT)
+
 pybind11_add_module(geant4_pybind
   ${SOURCE}
   geant4_pybind.cc

source/CMakeLists.txt

@@ -22,8 +22,7 @@ namespace py = pybind11;
 
 void export_G4AnalysisManager(py::module &m)
 {
-   py::class_<G4ToolsAnalysisManager, G4VAnalysisManager, std::unique_ptr<G4ToolsAnalysisManager, py::nodelete>>(
-      m, "G4ToolsAnalysisManager")
+   py::class_<G4ToolsAnalysisManager, G4VAnalysisManager, py::nodelete>(m, "G4ToolsAnalysisManager")
 
       //.def(py::init<const G4String &, G4bool>(), py::arg("type"), py::arg("isMaster") = true)
 
@@ -45,8 +44,7 @@ void export_G4AnalysisManager(py::module &m)
       .def("GetP2", &G4ToolsAnalysisManager::GetP2, py::arg("id"), py::arg("warn") = true,
            py::arg("onlyIfActive") = true, py::return_value_policy::reference_internal);
 
-   py::class_<G4RootAnalysisManager, G4ToolsAnalysisManager, std::unique_ptr<G4RootAnalysisManager, py::nodelete>>(
-      m, "G4RootAnalysisManager")
+   py::class_<G4RootAnalysisManager, G4ToolsAnalysisManager, py::nodelete>(m, "G4RootAnalysisManager")
 
       .def(py::init<G4bool>(), py::arg("isMaster") = true)
       .def_static("Instance", &G4RootAnalysisManager::Instance, py::return_value_policy::reference)
@@ -60,22 +58,19 @@ void export_G4AnalysisManager(py::module &m)
       .def("SetBasketSize", &G4RootAnalysisManager::SetBasketSize, py::arg("basketSize"))
       .def("SetBasketEntries", &G4RootAnalysisManager::SetBasketEntries, py::arg("basketEntries"));
 
-   py::class_<G4CsvAnalysisManager, G4ToolsAnalysisManager, std::unique_ptr<G4CsvAnalysisManager, py::nodelete>>(
-      m, "G4CsvAnalysisManager")
+   py::class_<G4CsvAnalysisManager, G4ToolsAnalysisManager, py::nodelete>(m, "G4CsvAnalysisManager")
 
       .def(py::init<G4bool>(), py::arg("isMaster") = true)
       .def_static("Instance", &G4CsvAnalysisManager::Instance, py::return_value_policy::reference)
       .def_static("IsInstance", &G4CsvAnalysisManager::IsInstance);
 
-   py::class_<G4XmlAnalysisManager, G4ToolsAnalysisManager, std::unique_ptr<G4XmlAnalysisManager, py::nodelete>>(
-      m, "G4XmlAnalysisManager")
+   py::class_<G4XmlAnalysisManager, G4ToolsAnalysisManager, py::nodelete>(m, "G4XmlAnalysisManager")
 
       .def(py::init<G4bool>(), py::arg("isMaster") = true)
       .def_static("Instance", &G4XmlAnalysisManager::Instance, py::return_value_policy::reference)
       .def_static("IsInstance", &G4XmlAnalysisManager::IsInstance);
 
-   py::class_<G4GenericAnalysisManager, G4ToolsAnalysisManager,
-              std::unique_ptr<G4GenericAnalysisManager, py::nodelete>>(m, "G4GenericAnalysisManager")
+   py::class_<G4GenericAnalysisManager, G4ToolsAnalysisManager, py::nodelete>(m, "G4GenericAnalysisManager")
 
       .def(py::init<G4bool>(), py::arg("isMaster") = true)
       .def_static("Instance", &G4GenericAnalysisManager::Instance, py::return_value_policy::reference)

source/analysis/pyG4AnalysisManager.cc

@@ -23,8 +23,7 @@ namespace py = pybind11;
 
 void export_G4TScoreNtupleWriter(py::module &m)
 {
-   py::class_<G4TScoreNtupleWriter<G4RootAnalysisManager>,
-              std::unique_ptr<G4TScoreNtupleWriter<G4RootAnalysisManager>>>(m, "G4RootScoreNtupleWriter")
+   py::class_<G4TScoreNtupleWriter<G4RootAnalysisManager>>(m, "G4RootScoreNtupleWriter")
 
       .def(py::init<>())
       .def("Book", &G4TScoreNtupleWriter<G4RootAnalysisManager>::Book)
@@ -37,8 +36,7 @@ void export_G4TScoreNtupleWriter(py::module &m)
       .def("GetFileName", &G4TScoreNtupleWriter<G4RootAnalysisManager>::GetFileName)
       .def("GetVerboseLevel", &G4TScoreNtupleWriter<G4RootAnalysisManager>::GetVerboseLevel);
 
-   py::class_<G4TScoreNtupleWriter<G4CsvAnalysisManager>, std::unique_ptr<G4TScoreNtupleWriter<G4CsvAnalysisManager>>>(
-      m, "G4CsvScoreNtupleWriter")
+   py::class_<G4TScoreNtupleWriter<G4CsvAnalysisManager>>(m, "G4CsvScoreNtupleWriter")
 
       .def(py::init<>())
       .def("Book", &G4TScoreNtupleWriter<G4CsvAnalysisManager>::Book)
@@ -51,8 +49,7 @@ void export_G4TScoreNtupleWriter(py::module &m)
       .def("GetFileName", &G4TScoreNtupleWriter<G4CsvAnalysisManager>::GetFileName)
       .def("GetVerboseLevel", &G4TScoreNtupleWriter<G4CsvAnalysisManager>::GetVerboseLevel);
 
-   py::class_<G4TScoreNtupleWriter<G4XmlAnalysisManager>, std::unique_ptr<G4TScoreNtupleWriter<G4XmlAnalysisManager>>>(
-      m, "G4XmlScoreNtupleWriter")
+   py::class_<G4TScoreNtupleWriter<G4XmlAnalysisManager>>(m, "G4XmlScoreNtupleWriter")
 
       .def(py::init<>())
       .def("Book", &G4TScoreNtupleWriter<G4XmlAnalysisManager>::Book)

source/analysis/pyG4TScoreNtupleWriter.cc

@@ -24,7 +24,7 @@ namespace py = pybind11;
 
 void export_G4VAnalysisManager(py::module &m)
 {
-   py::class_<G4VAnalysisManager, std::unique_ptr<G4VAnalysisManager, py::nodelete>>(m, "G4VAnalysisManager")
+   py::class_<G4VAnalysisManager, py::nodelete>(m, "G4VAnalysisManager")
 
       //.def(py::init<const G4String &, G4bool>())
 
@@ -178,6 +178,7 @@ void export_G4VAnalysisManager(py::module &m)
            py::arg("zmax") = 0, py::arg("xunitName") = "none", py::arg("yunitName") = "none",
            py::arg("zunitName") = "none", py::arg("xfcnName") = "none", py::arg("yfcnName") = "none",
            py::arg("zfcnName") = "none")
+
       .def("SetP1",
            py::overload_cast<G4int, G4int, G4double, G4double, G4double, G4double, const G4String &, const G4String &,
                              const G4String &, const G4String &, const G4String &>(&G4VAnalysisManager::SetP1),

source/analysis/pyG4VAnalysisManager.cc

@@ -14,7 +14,7 @@ namespace py = pybind11;
 
 void export_histo(py::module &m)
 {
-   py::class_<tools::histo::h1d, std::unique_ptr<tools::histo::h1d>>(m, "h1d")
+   py::class_<tools::histo::h1d>(m, "h1d")
       .def(py::init<>())
       .def(py::init<const std::string &, const std::vector<double> &>(), py::arg("title"), py::arg("edges"))
       .def(py::init<const std::string &, unsigned int, double, double>(), py::arg("title"), py::arg("xnumber"),
@@ -51,8 +51,8 @@ void export_histo(py::module &m)
       .def("dimension", &tools::histo::h1d::dimension)
       .def("divide", &tools::histo::h1d::divide)
       .def("entries", &tools::histo::h1d::entries)
-      .def("equals", &tools::histo::h1d::equals)
-      .def("equals_TH", &tools::histo::h1d::equals_TH)
+      //.def("equals", &tools::histo::h1d::equals)
+      //.def("equals_TH", &tools::histo::h1d::equals_TH)
       .def("equivalent_bin_entries", &tools::histo::h1d::equivalent_bin_entries)
       .def("extra_entries", &tools::histo::h1d::extra_entries)
       .def("Fill", &tools::histo::h1d::Fill)

source/analysis/pyhisto.cc

@@ -3,24 +3,19 @@
 
 #include <G4HCofThisEvent.hh>
 
-#include "holder.hh"
 #include "typecast.hh"
 #include "opaques.hh"
 
 namespace py = pybind11;
 
 void export_G4HCofThisEvent(py::module &m)
 {
-   py::class_<G4HCofThisEvent, std::unique_ptr<G4HCofThisEvent>>(m, "G4HCofThisEvent")
+   py::class_<G4HCofThisEvent>(m, "G4HCofThisEvent")
       .def(py::init<>())
       .def(py::init<G4int>())
       .def(py::init<const G4HCofThisEvent &>())
-      .def("AddHitsCollection",
-           [](G4HCofThisEvent &self, G4int HCID, G4VHitsCollection *aHC) {
-              owntrans_ptr<G4VHitsCollection>::remove(aHC);
-              // TRAMPOLINE_REF_INCREASE(G4VHitsCollection, aHC);
-              self.AddHitsCollection(HCID, aHC);
-           })
+      .def("AddHitsCollection", [](G4HCofThisEvent &self, G4int HCID,
+                                   py::disown_ptr<G4VHitsCollection> aHC) { self.AddHitsCollection(HCID, aHC); })
 
       .def("GetHC", &G4HCofThisEvent::GetHC, py::return_value_policy::reference_internal)
       .def("GetNumberOfCollections", &G4HCofThisEvent::GetNumberOfCollections)