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 443 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::cerr << "==[" << tcls->GetName() << "]== (#mbrs:"
            << nmembers 
            << " #stl:" << hdr /*PySequence_Size(pyobj)*/
            << " #py-sz:" << PyList_Size(py_members)
            << ")...\n";
#endif
 
  if (hdr) {
    // handle collection
    const Py_ssize_t nelems = PySequence_Size(pyobj);
#if PYROOT_INSPECTOR_DBG
    std::cerr << "== sequence (" << nelems << ")...\n";
#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::cerr << "== sequence (" << nelems << ")... content:\n"
              << ::to_str(py_elems)
              << "\n";
    std::cerr << "== sequence (" << nelems << ")... [done]\n";
#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::cerr << "==[" << j << "] - [" << mbr->GetTypeName() << "] "
              << "[" << mbr->GetName() 
              << "]"
              << "[" << (mbr_cls ? mbr_cls->GetName() : "N/A") << "]\n";
#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::cerr << "==[" << mbr->GetTypeName() << "]["
                << mbr->GetDataType()->GetType() << "][val="
                << (*(int*)ptr) << "]["
                << mbr->GetName() << "] is an enum !!\n";
#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::cerr << "could not create py-object of type ["
                << mbr->GetTypeName() << "] !\n";
      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::cerr << "==[" << tcls->GetName() << "]== (#mbrs:"
            << nmembers << ")... [done]\n";
#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 586 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