SG::PyDataBucket Class Reference

Concrete DataBucket that holds the object via a void* and uses the Root dictionary to do conversions. More...

#include <SgPyDataModel.h>

Inheritance diagram for SG::PyDataBucket:

Collaboration diagram for SG::PyDataBucket:

Public Member Functions
	PyDataBucket (PyObject *obj, CLID clid)
	Constructor.
virtual	~PyDataBucket () override
	Destructor.
virtual void *	object () override
	Return the held object.
virtual void *	cast (CLID clid, IRegisterTransient *itr=0, bool isConst=true) override
	Return the contents of the DataBucket, converted to type given by clid.
virtual void *	cast (const std::type_info &tinfo, IRegisterTransient *itr=0, bool isConst=true) override
	Return the contents of the DataBucket, converted to type given by std::type_info.
virtual const CLID &	clID () const override
	Retrieve reference to class definition structure.
virtual const std::type_info &	tinfo () const override
	Return the type_info for the stored object.
virtual void	relinquish () override
	Give up ownership of the DataBucket contents.
virtual void	lock () override
	If the held object derives from ILockable, call lock() on it.
template<class T>
T *	cast (SG::IRegisterTransient *irt=0, bool isConst=true)
	Return the contents of the DataBucket, converted to type T.
virtual void *	cast (CLID clid, const std::type_info &tinfo, SG::IRegisterTransient *irt=0, bool isConst=true)
	Return the contents of the DataBucket, converted to type given by clid.

Private Attributes
PyObject *	m_pyObj
	Pointer to the held pyroot object (or 'regular' PyObject)
CLID	m_clid
	The class ID of the wrapped object.
const SG::BaseInfoBase *	m_bib
	pointer to the SG::BaseInfoBase structure holding the converter functions for objects held by StoreGate

Detailed Description

Concrete DataBucket that holds the object via a void* and uses the Root dictionary to do conversions.

A concrete DataBucket instance holds a pointer to an arbitrary object, and is able to further convert it to pointers to other types related by inheritance. This variant is used for PyAthena, where don't have the type available at compile time and thus cannot use templates. However, we know that we do have the Root dictionary available for the types, so we can use that information for the conversions.

Definition at line 92 of file SgPyDataModel.h.

Constructor & Destructor Documentation

PyDataBucket()

SG::PyDataBucket::PyDataBucket	(	PyObject *	obj,
		CLID	clid )

Constructor.

Parameters

pyObj	The (pyroot) object proxy to hold.
clid	The class ID of the wrapped object.

Definition at line 43 of file SgPyDataModel.cxx.

                              :
    DataBucketBase(),
    m_pyObj( pyObj ),
    m_clid ( clid  ),
    m_bib  ( SG::BaseInfoBase::find(clid) )
  {
    // prevent Python from sweeping the rug under our feet
    Py_INCREF( pyObj );
  }

~PyDataBucket()

virtual SG::PyDataBucket::~PyDataBucket ( )

inlineoverridevirtual

Destructor.

Definition at line 107 of file SgPyDataModel.h.

                                     { 
      RootUtils::PyGILStateEnsure gil;
      Py_DECREF( m_pyObj ); 
    }

Member Function Documentation

cast() [1/4]

virtual void * DataBucketBase::cast ( CLID clid, const std::type_info & tinfo, SG::IRegisterTransient * irt = 0, bool isConst = true )

virtual

Return the contents of the DataBucket, converted to type given by clid.

Note that only derived->base conversions are allowed here.

Parameters

clid	The class ID to which to convert.
tinfo	The std::type_info of the type to which to convert.
irt	To be called if we make a new instance.
isConst	True if the object being converted is regarded as const.

This allows the callee to choose whether to use clid or tinfo. By default, this uses type_info.

Reimplemented from DataBucketBase.

cast() [2/4]

void * SG::PyDataBucket::cast ( CLID clid, IRegisterTransient * itr = 0, bool isConst = true )

overridevirtual

Return the contents of the DataBucket, converted to type given by clid.

Note that only derived->base conversions are allowed here.

Parameters

clid	The class ID to which to convert.
irt	To be called if we make a new instance.
isConst	True if the object being converted is regarded as const.

Implements DataBucketBase.

Definition at line 54 of file SgPyDataModel.cxx.

  {
    RootUtils::PyGILStateEnsure gil;
    // if requested type is same than myself ==> no conversion needed
    if ( clid == m_clid ) {
      return clid == PyCLID 
    ? m_pyObj
    : CPPInstance_ASVOIDPTR(m_pyObj);
    }
    void* address = (m_clid == PyCLID)
      ? (void*)m_pyObj
      : CPPInstance_ASVOIDPTR(m_pyObj);
 
    // try SG-based conversion functions
    {
      void* o = m_bib ? m_bib->cast(address, clid) : 0;
      if ( o ) { return o; }
    }
 
    // try PyRoot based ones
    PyObject* pytp = PyProxyMgr::instance().pytp(clid);
    if ( !pytp ) {
      PyErr_Format( PyExc_TypeError, "actual type of CLID %lu unknown",
            (long unsigned int)clid );
      return 0;
    }
 
    // this will be a conversion for a class instance only (see below:
    // verified that only a CPPInstance is expected), so bind with cast
    std::string pytpstr = RootUtils::PyGetString(pytp).first;
    TClass* cls = TClass::GetClass (pytpstr.c_str());
    if (!cls) {
      PyErr_Format( PyExc_TypeError, "Can't find TClass for `%s'",
            pytpstr.c_str() );
      return 0;
    }
    TClass* act_class = cls->GetActualClass (address);
    PyObject* value = TPython::CPPInstance_FromVoidPtr (address, act_class->GetName());
 
    if ( value && TPython::CPPInstance_Check(value) ) {
      return CPPInstance_ASVOIDPTR(value);
    }
    Py_XDECREF(value);
    throw CPyCppyy::PyException();
    return 0;
  }

cast() [3/4]

void * SG::PyDataBucket::cast ( const std::type_info & tinfo, IRegisterTransient * itr = 0, bool isConst = true )

overridevirtual

Return the contents of the DataBucket, converted to type given by std::type_info.

Note that only derived->base conversions are allowed here.

Parameters

tinfo	The std::type_info of the type to which to convert.
irt	To be called if we make a new instance.
isConst	True if the object being converted is regarded as const.

Implements DataBucketBase.

Definition at line 103 of file SgPyDataModel.cxx.

  {
    RootUtils::PyGILStateEnsure gil;
    // if regular PyObject, meaningless
    if ( m_clid == PyCLID ) {
      return 0;
    }
 
    // if requested type is same than myself ==> no conversion needed
    TClass* tcls = objectIsA (m_pyObj);
    if ( tcls && (tinfo == *(tcls->GetTypeInfo())) ) {
      return CPPInstance_ASVOIDPTR(m_pyObj);
    }
    void* address = CPPInstance_ASVOIDPTR(m_pyObj);
 
    // try SG-based conversion functions
    {
      void* o = m_bib ? m_bib->cast(address, tinfo) : 0;
      if ( o ) { return o; }
    }
 
    // this will be a conversion for a class instance only (see below:
    // verified that only a CPPInstance is expected), so bind with cast
    TClass* clsnew = TClass::GetClass (tinfo);
    if (!clsnew) {
      PyErr_SetString
        ( PyExc_RuntimeError, 
          "SG::PyDataBucket::cast() can't find TClass" );
      return 0;
    }
    TClass* act_class = clsnew->GetActualClass (address);
    PyObject* value = TPython::CPPInstance_FromVoidPtr (address, act_class->GetName());
    PyErr_Clear();
 
    if ( value && TPython::CPPInstance_Check(value) ) {
      return CPPInstance_ASVOIDPTR(value);
    }
    Py_XDECREF(value);
    //throw PyROOT::TPyException();
    return 0;
  }

cast() [4/4]

template<class T>

T * DataBucketBase::cast	(	SG::IRegisterTransient *	irt = 0,
		bool	isConst = true )

Return the contents of the DataBucket, converted to type T.

Note that only derived->base conversions are allowed here. T must have a valid Class ID for this to work.

Parameters

irt	To be called if we make a new instance.
isConst	True if the object being converted is regarded as const.

clID()

virtual const CLID & SG::PyDataBucket::clID ( ) const

inlineoverridevirtual

Retrieve reference to class definition structure.

Definition at line 153 of file SgPyDataModel.h.

{ return m_clid; }

lock()

void SG::PyDataBucket::lock ( )

overridevirtual

If the held object derives from ILockable, call lock() on it.

Implements DataBucketBase.

Definition at line 147 of file SgPyDataModel.cxx.

  {
    RootUtils::PyGILStateEnsure gil;
    if (!m_pyObj) return;
    if (!PyObject_HasAttrString (m_pyObj, "lock"))
      return;
    PyObject* lock = PyObject_GetAttrString (m_pyObj, "lock");
    if (!lock) return;
    if (PyCallable_Check (lock)) {
      PyObject* ret = PyObject_CallObject (lock, NULL);
      Py_DECREF (ret);
    }
    Py_DECREF (lock);
  }

object()

virtual void * SG::PyDataBucket::object ( )

inlineoverridevirtual

Return the held object.

Implements DataBucketBase.

Definition at line 115 of file SgPyDataModel.h.

    { 
      return m_clid != PyCLID
        ? CPPInstance_ASVOIDPTR(m_pyObj)
        : m_pyObj; 
    }

relinquish()

virtual void SG::PyDataBucket::relinquish ( )

inlineoverridevirtual

Give up ownership of the DataBucket contents.

Implements DataBucketBase.

Definition at line 166 of file SgPyDataModel.h.

    {
      Py_DECREF( m_pyObj );
    }

tinfo()

virtual const std::type_info & SG::PyDataBucket::tinfo ( ) const

inlineoverridevirtual

Return the type_info for the stored object.

Implements DataBucketBase.

Definition at line 158 of file SgPyDataModel.h.

    {
      return m_bib->typeinfo();
    }

Member Data Documentation

m_bib

const SG::BaseInfoBase* SG::PyDataBucket::m_bib

private

pointer to the SG::BaseInfoBase structure holding the converter functions for objects held by StoreGate

Definition at line 185 of file SgPyDataModel.h.

m_clid

CLID SG::PyDataBucket::m_clid

private

The class ID of the wrapped object.

Definition at line 181 of file SgPyDataModel.h.

m_pyObj

PyObject* SG::PyDataBucket::m_pyObj

private

Pointer to the held pyroot object (or 'regular' PyObject)

Definition at line 178 of file SgPyDataModel.h.

---

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

• SgPyDataModel.h
• SgPyDataModel.cxx