SG::PyProxyMgr Struct Reference

A helper class to manage accesses to PyProxies. More...

#include <SgPyDataModel.h>

Collaboration diagram for SG::PyProxyMgr:

Public Types
typedef std::unordered_map< StoreGateSvc *, SG::PyProxyDict * >	PyProxyMap_t
typedef std::unordered_map< CLID, std::string >	ClidMap_t
	a dictionary of CLID -> reflex typename

Public Member Functions
	PyProxyMgr ()
	~PyProxyMgr ()
SG::PyProxyDict *	pyproxy (StoreGateSvc *sg)
PyObject *	pyclid (PyObject *tp)
	returns a borrowed reference
PyObject *	pytp (PyObject *clid)
	returns a borrowed reference
PyObject *	pytp (CLID clid)
	returns a borrowed reference
CLID	clid (PyObject *tp)
CLID	clid_from_tid (PyObject *tp)
const char *	load_type (CLID id)
	ensure everything has been loaded for the clid id (classid, reflex dict, baseinfobase,...)

Static Public Member Functions
static PyProxyMgr &	instance ()

Public Attributes
IDictLoaderSvc *	m_dictSvc
IClassIDSvc *	m_clidSvc
PyObject *	m_aliases
	a dictionary of "typedef'ed typename" -> "typename"
PyObject *	m_clids
	a dictionary of 'typename' -> CLID (and reverse CLID->'typename')
PyProxyMap_t	m_proxyMap
ClidMap_t	m_clidMap

Private Member Functions
PyObject *	importDictAliases ()
	import the dictionary of aliases from a well known location

Detailed Description

A helper class to manage accesses to PyProxies.

Definition at line 194 of file SgPyDataModel.h.

Member Typedef Documentation

ClidMap_t

typedef std::unordered_map<CLID, std::string> SG::PyProxyMgr::ClidMap_t

a dictionary of CLID -> reflex typename

Definition at line 208 of file SgPyDataModel.h.

PyProxyMap_t

typedef std::unordered_map<StoreGateSvc*,SG::PyProxyDict*> SG::PyProxyMgr::PyProxyMap_t

Definition at line 204 of file SgPyDataModel.h.

Constructor & Destructor Documentation

PyProxyMgr()

SG::PyProxyMgr::PyProxyMgr

(

)

Definition at line 169 of file SgPyDataModel.cxx.

  {
    m_aliases = importDictAliases();
    m_clids   = PyDict_New();
    m_clidSvc = 0;
    {
      ServiceHandle<IClassIDSvc> svc("ClassIDSvc", "SgPyDataModel");
      if ( !svc.retrieve().isSuccess()) {
    throw std::runtime_error
      ("SG::PyProxyMgr: Could not retrieve ClassIDSvc");
      }
      m_clidSvc = svc.operator->();
    }
    m_dictSvc = 0;
    {
      ServiceHandle<IDictLoaderSvc> svc("AthDictLoaderSvc", "SgPyDataModel");
      if ( !svc.retrieve().isSuccess()) {
    throw std::runtime_error
      ("SG::PyProxyMgr: Could not retrieve AthDictLoaderSvc");
      }
      m_dictSvc = svc.operator->();
    }
  }

~PyProxyMgr()

SG::PyProxyMgr::~PyProxyMgr

(

)

Definition at line 193 of file SgPyDataModel.cxx.

  {
    // Don't do this if don't have a valid thread state.
    // (With py3, the interpreter gets shut down before global dtors run...)
    if (PyThreadState_GetUnchecked())
    {
      Py_DECREF(m_aliases);
      Py_DECREF(m_clids);
    }
    // delete the proxy dicts...
    for ( PyProxyMap_t::iterator
        i    = m_proxyMap.begin(),
        iEnd = m_proxyMap.end();
      i != iEnd;
      ++i ) {
      delete i->second; i->second = 0;
    }
  }

Member Function Documentation

clid()

CLID SG::PyProxyMgr::clid ( PyObject * tp )

inline

Definition at line 277 of file SgPyDataModel.h.

    {
      CLID id = CLID_NULL;
      // FIXME: get rid of this massaging when/if ROOT finally
      // standardize on keeping the std:: namespace...
      std::string tpstr = RootUtils::PyGetString(tp).first;
      std::string tn;
      {
        // Protect against data race inside TClassEdit.
        // https://github.com/root-project/root/issues/10353
        // Should be fixed in root 6.26.02.
        R__WRITE_LOCKGUARD(ROOT::gCoreMutex);
        tn = TClassEdit::ShortType(tpstr.c_str(),
                                   TClassEdit::kDropAllDefault);
      }
      m_clidSvc->getIDOfTypeName(tn, id).ignore();
      if ( id == CLID_NULL ) {
        // try an alias...
        PyObject* alias = PyDict_GetItemString(m_aliases, tn.c_str());
        if ( alias ){
          std::string aliasstr = RootUtils::PyGetString(alias).first;
          m_clidSvc->getIDOfTypeName(aliasstr, id).ignore();
        }
      }
      if (id == CLID_NULL) {
        // then try a type-id name...
        return this->clid_from_tid (tp);
      }
      return id;
    }

clid_from_tid()

CLID SG::PyProxyMgr::clid_from_tid ( PyObject * tp )

inline

Definition at line 309 of file SgPyDataModel.h.

    {
      CLID id = CLID_NULL;
      // FIXME: get rid of this massaging when/if ROOT finally
      // standardize on keeping the std:: namespace...
      std::string tpstr = RootUtils::PyGetString(tp).first;
      std::string tn;
      {
        // Protect against data race inside TClassEdit.
        // https://github.com/root-project/root/issues/10353
        // Should be fixed in root 6.26.02.
        R__WRITE_LOCKGUARD(ROOT::gCoreMutex);
        tn = TClassEdit::ShortType(tpstr.c_str(),
                                   TClassEdit::kDropAllDefault);
      }
      m_clidSvc->getIDOfTypeInfoName(tn, id).ignore();
      if ( id == CLID_NULL ) {
        // try an alias...
        PyObject* alias = PyDict_GetItemString(m_aliases, tn.c_str());
        if ( alias ){
          std::string aliasstr = RootUtils::PyGetString(alias).first;
          m_clidSvc->getIDOfTypeInfoName(aliasstr,
                                         id).ignore();
        }
      }
      return id;
    }

importDictAliases()

PyObject * SG::PyProxyMgr::importDictAliases ( )

inlineprivate

import the dictionary of aliases from a well known location

Definition at line 372 of file SgPyDataModel.h.

    {
      const std::string moduleName = "AthenaPython.Bindings";
      PyObject* module = PyImport_ImportModule
        ( const_cast<char*>(moduleName.c_str()) );
      if ( !module || !PyModule_Check(module) ) {
        std::cerr << "SG::PyProxyDict WARNING: could not import module '"
                  << moduleName << "' !\n";
        Py_XDECREF(module);
        m_aliases = PyDict_New();
        return m_aliases;
      }
 
      m_aliases = PyDict_GetItemString(PyModule_GetDict(module),
                                       (char*)"_clid_typename_aliases");
      // borrowed ref. so we increment it
      Py_XINCREF(m_aliases);
      // don't need this one anymore
      Py_DECREF(module);
 
      if ( !m_aliases ) {
        std::cerr << "SG::PyProxyDict WARNING: could not retrieve the "
                  << "dictionary of aliases from '"
                  << moduleName << "' !\n";
        Py_XDECREF(m_aliases);
        m_aliases = PyDict_New();
      }
      return m_aliases;
    }

instance()

PyProxyMgr & SG::PyProxyMgr::instance ( )

inlinestatic

Definition at line 212 of file SgPyDataModel.h.

    { static PyProxyMgr mgr; return mgr; }

load_type()

const char * SG::PyProxyMgr::load_type ( CLID id )

inline

ensure everything has been loaded for the clid id (classid, reflex dict, baseinfobase,...)

Returns

the reflex typename associated with that clid

Definition at line 342 of file SgPyDataModel.h.

    {
      typedef ClidMap_t::iterator Itr_t;
      Itr_t i = m_clidMap.find(id);
      if (i != m_clidMap.end()) {
        return i->second.c_str();
      }
      // Reflex now returns std::basic_string<char> instead of std::string
      std::string tname = m_dictSvc->load_type(id).Name(Reflex::SCOPED);
      // handle '> >'. order MATTERS!
      ::cxx_replace(tname, "basic_string<char> >", "string>");
      ::cxx_replace(tname, "basic_string<char>",   "string");
      m_clidMap[id] = tname;
 
      // Try to make sure the BIB is initialized.
      std::string bibname = "SG::BaseInfo<" + tname + ">";
      TClass* bibcl = gROOT->GetClass (bibname.c_str());
      if (bibcl) {
        TMethod* m = bibcl->GetMethodAny ("baseinfo");
        if (m) {
          TMethodCall call (m);
          call.Execute();
        }
      }
 
      return m_clidMap[id].c_str();
    }

pyclid()

PyObject * SG::PyProxyMgr::pyclid ( PyObject * tp )

inline

returns a borrowed reference

Definition at line 222 of file SgPyDataModel.h.

    {
      PyObject* clid = PyDict_GetItem(m_clids, tp);
      if ( NULL == clid ) {
        const CLID id = this->clid(tp);
        if ( id == CLID_NULL ) {
          return NULL;
        }
        clid = PyLong_FromLong(id);
        PyDict_SetItem(m_clids, tp, clid);
        // add reverse look-up entry too
        PyDict_SetItem(m_clids, clid, tp);
        //Py_INCREF(clid);
      }
      return clid;
    }

pyproxy()

PyProxyDict * SG::PyProxyMgr::pyproxy ( StoreGateSvc * sg )

inline

Definition at line 469 of file SgPyDataModel.h.

  {
    SG::PyProxyDict* p = 0;
    PyProxyMap_t::iterator i = m_proxyMap.find(sg);
    if ( i == m_proxyMap.end() ) {
      m_proxyMap[sg] = p = new SG::PyProxyDict(sg);
    } else {
      p = i->second;
    }
    return p;
  }

pytp() [1/2]

PyObject * SG::PyProxyMgr::pytp ( CLID clid )

inline

returns a borrowed reference

Definition at line 268 of file SgPyDataModel.h.

    {
      PyObject* pyclid = PyLong_FromLong(clid);
      PyObject* o = this->pytp(pyclid);
      Py_DECREF(pyclid);
      return o;
    }

pytp() [2/2]

PyObject * SG::PyProxyMgr::pytp ( PyObject * clid )

inline

returns a borrowed reference

Definition at line 241 of file SgPyDataModel.h.

    {
      PyObject* tp = PyDict_GetItem(m_clids, clid);
      if ( NULL == tp ) {
        std::string cpp_tp;
        if (!m_clidSvc->getTypeNameOfID(PyLong_AsUnsignedLong(clid),
                                        cpp_tp).isSuccess()) {
          return NULL;
        }
        PyObject* alias = PyDict_GetItemString(m_aliases, cpp_tp.c_str());
        if ( alias ) {
          tp = alias;
        } else {
          tp = PyUnicode_FromString(cpp_tp.c_str());
        }
        PyDict_SetItem(m_clids, clid, tp);
        // reverse look-up
        PyDict_SetItem(m_clids, tp, clid);
        if (!alias) {
          Py_DECREF(tp);
        }
      }
      return tp;
    }

Member Data Documentation

m_aliases

PyObject* SG::PyProxyMgr::m_aliases

a dictionary of "typedef'ed typename" -> "typename"

Definition at line 199 of file SgPyDataModel.h.

m_clidMap

ClidMap_t SG::PyProxyMgr::m_clidMap

Definition at line 209 of file SgPyDataModel.h.

m_clids

PyObject* SG::PyProxyMgr::m_clids

a dictionary of 'typename' -> CLID (and reverse CLID->'typename')

Definition at line 202 of file SgPyDataModel.h.

m_clidSvc

IClassIDSvc* SG::PyProxyMgr::m_clidSvc

Definition at line 197 of file SgPyDataModel.h.

m_dictSvc

IDictLoaderSvc* SG::PyProxyMgr::m_dictSvc

Definition at line 196 of file SgPyDataModel.h.

m_proxyMap

PyProxyMap_t SG::PyProxyMgr::m_proxyMap

Definition at line 205 of file SgPyDataModel.h.

---

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

• SgPyDataModel.h
• SgPyDataModel.cxx