RootUtils::PyROOTInspector Class Reference

#include <PyROOTInspector.h>

Collaboration diagram for RootUtils::PyROOTInspector:

Static Public Member Functions
static PyObject *	pyroot_inspect (PyObject *obj, bool persistentOnly=false)
static PyObject *	pyroot_inspect2 (PyObject *obj, PyObject *obj_name, bool persistentOnly=false, bool retvecs=false)

Detailed Description

Definition at line 21 of file PyROOTInspector.h.

Member Function Documentation

pyroot_inspect()

PyObject * RootUtils::PyROOTInspector::pyroot_inspect ( PyObject * obj, bool persistentOnly = false )

static

Definition at line 441 of file PyROOTInspector.cxx.

{
  // handle non-pyroot objects
  if (!TPython::CPPInstance_Check(pyobj)) {
    Py_XINCREF(pyobj);
    return pyobj;
  }
 
  TClass *tcls = RootUtils::objectIsA(pyobj);
  if (0 == tcls) {
    Py_INCREF(Py_None);
    return Py_None;
  }
  void *obj = TPython::CPPInstance_AsVoidPtr(pyobj);
 
  if (!strcmp(tcls->GetName(), "string")) {
    std::string *str = (std::string*)obj;
    return PyUnicode_FromString(str->c_str());
  }
 
  TString tstring = tcls->GetName();
  if (tstring.BeginsWith("pair<") ||
      tstring.BeginsWith("std::pair<")) {
    PyObject *val = PyTuple_New(2);
    PyObject *v0 = PyObject_GetAttrString(pyobj, "first");
    PyObject *v1 = PyObject_GetAttrString(pyobj, "second");
    PyTuple_SET_ITEM(val, 0, pyroot_inspect(v0, persistentOnly));
    PyTuple_SET_ITEM(val, 1, pyroot_inspect(v1, persistentOnly));
    Py_DECREF(v0);
    Py_DECREF(v1);
    return val;
  }
 
  Int_t hdr = 0;
  if (CPyCppyy::Sequence_Check(pyobj)) {
    if (!strcmp(tcls->GetName(), "CLHEP::Hep3Vector")) {
      hdr = 0;
    } else {
      hdr = 1;
    }
  } else {
    hdr = 0;
  }
 
  TList *members = tcls->GetListOfDataMembers();
  const Int_t nmembers = members->GetEntries();
 
  PyObject *py_members = PyList_New(nmembers+hdr);
#if PYROOT_INSPECTOR_DBG
  std::println (std::cerr, "==[{}]== (#mbrs:{} #stl:{} #py-sz:{})...",
                tcls->GetName(), nmembers, hdr, PyList_Size(py_members));
#endif
 
  if (hdr) {
    // handle collection
    const Py_ssize_t nelems = PySequence_Size(pyobj);
#if PYROOT_INSPECTOR_DBG
    std::println (std::cerr, "== sequence ({})...", nelems);
#endif
    PyObject *py_elems = PyList_New(nelems);
    for (Py_ssize_t i = 0; i < nelems; ++i) {
      PyObject *itr = PySequence_GetItem(pyobj, i);
      PyObject *itr_pyroot = pyroot_inspect(itr, persistentOnly);
      PyList_SET_ITEM(py_elems, i, itr_pyroot);
      Py_DECREF(itr);
      //Py_DECREF(itr_pyroot);
    }
    // add the elements to the "members" list
    PyList_SET_ITEM(py_members, 0, py_elems);
#if PYROOT_INSPECTOR_DBG
    std::println (std::cerr, "== sequence ({})... content:\n{}",
                  nelems, ::to_str(py_elems));
    std::println (std::cerr, "== sequence ({})... [done]", nelems);
#endif
  }
 
 
  for (Int_t j = 0; j<nmembers; ++j) {
    TDataMember *mbr = (TDataMember*)(members->At(j));
    Int_t offset =     mbr->GetOffset();
    char *ptr =        (char*)obj + offset;
 
#if PYROOT_INSPECTOR_DBG
    TClass *mbr_cls = TClass::GetClass(mbr->GetTypeName());
    std::println (std::cerr,  "==[{}] - [{}] [{}][{}]",
                  j, mbr->GetTypeName(), mbr->GetName(),
                  (mbr_cls ? mbr_cls->GetName() : "N/A"));
#endif
 
    PyObject *py_mbr = 0;
 
    if (persistentOnly && !mbr->IsPersistent())
      continue;
    if (mbr->IsaPointer())
      continue;
    if (mbr->IsBasic()) {
      TDataType * mbr_type = mbr->GetDataType();
      EDataType mbr_dtype = (EDataType)mbr_type->GetType();
      py_mbr = to_pyobj(ptr, mbr_dtype);
    } else if (mbr->IsEnum()) {
#if PYROOT_INSPECTOR_DBG
      std::println (std::cerr, "==[{}][{}][val=][{}] is an enum !!",
                    mbr->GetTypeName(), mbr->GetDataType()->GetType(),
                    *reinterpret_cast<int*>(ptr), mbr->GetName());
#endif
      py_mbr = to_pyobj(ptr, kInt_t);
    } else {
      PyObject *pyroot_obj = TPython::CPPInstance_FromVoidPtr
        ((void*)ptr,
         mbr->GetTypeName());
      if (pyroot_obj) {
        py_mbr = pyroot_inspect(pyroot_obj, persistentOnly);
      }
      Py_XDECREF(pyroot_obj);
    }
    if (!py_mbr) {
      std::println (std::cerr, "could not create py-object of type [{}] !",
                    mbr->GetTypeName());
      Py_DECREF(py_members);
      throw RootUtils::PyException();
    }
 
    PyObject *py_item = PyTuple_New(2);
    PyTuple_SET_ITEM(py_item, 0, 
                     PyUnicode_FromString(mbr->GetName()));
    PyTuple_SET_ITEM(py_item, 1, py_mbr);
    PyList_SET_ITEM(py_members, j+hdr, py_item);
  }
#if PYROOT_INSPECTOR_DBG
  std::println (std::cerr, "==[{}]== (#mbrs:{})... [done]",
                tcls->GetName(), nmembers);
#endif
  return py_members;
}

pyroot_inspect2()

PyObject * RootUtils::PyROOTInspector::pyroot_inspect2 ( PyObject * obj, PyObject * obj_name, bool persistentOnly = false, bool retvecs = false )

static

Definition at line 578 of file PyROOTInspector.cxx.

{
  PyObject *pystack = PyList_New(0);
  ::recurse_pyinspect(pyobj, pyobj_name, pystack, persistentOnly, retvecs);
  return pystack;
}

---

The documentation for this class was generated from the following files:

• PyROOTInspector.h
• PyROOTInspector.cxx