PyAthena::Tool Class Reference

#include <PyAthenaTool.h>

Inheritance diagram for PyAthena::Tool:

Collaboration diagram for PyAthena::Tool:

Public Member Functions
	Tool (const std::string &type, const std::string &name, const IInterface *parent)
	Constructor with parameters:
virtual	~Tool ()
	Destructor:
virtual StatusCode	initialize () override
virtual StatusCode	sysInitialize () override
virtual StatusCode	finalize () override
virtual const char *	typeName () const override
	return the std::type_info name of the underlying py-component This is used by concrete implementations to connect a python component to its C++ counter-part
virtual PyObject *	self () override
	return associated python object.

Protected Member Functions
virtual bool	setPyAttr (PyObject *pyobj) override
	attach the C++ component to its python cousin

Protected Attributes
PyObject *	m_self
	Pointer to self (from the python world)

Private Member Functions
	Tool ()=delete
	Default constructor:

Detailed Description

Definition at line 30 of file PyAthenaTool.h.

Constructor & Destructor Documentation

Tool() [1/2]

Tool::Tool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Constructor with parameters:

Definition at line 36 of file PyAthenaTool.cxx.

                                   : 
  base_class( type, name, parent ),
  m_self    ( nullptr )
{
  //
  // Property declaration
  // 
  //declareProperty( "Property", m_nProperty );
 
}

~Tool()

Tool::~Tool ( )

virtual

Destructor:

Definition at line 51 of file PyAthenaTool.cxx.

{ 
  ATH_MSG_DEBUG("Calling destructor");
  if ( m_self ) {
    RootUtils::PyGILStateEnsure ensure;
    Py_DECREF( m_self );
    m_self = nullptr;
  }
}

Tool() [2/2]

PyAthena::Tool::Tool ( )

privatedelete

Default constructor:

Member Function Documentation

finalize()

StatusCode Tool::finalize ( )

overridevirtual

Definition at line 69 of file PyAthenaTool.cxx.

{
  ATH_MSG_INFO("Finalizing " << name() << "...");
  return PyAthena::callPyMethod( m_self, "sysFinalize" );
}

initialize()

StatusCode Tool::initialize ( )

overridevirtual

Definition at line 63 of file PyAthenaTool.cxx.

{
  ATH_MSG_INFO("Initializing " << name() << "...");
  return PyAthena::callPyMethod( m_self, "sysInitialize" );
}

self()

virtual PyObject * PyAthena::Tool::self ( )

inlineoverridevirtual

return associated python object.

BORROWED reference.

Definition at line 64 of file PyAthenaTool.h.

{ return m_self; }

setPyAttr()

bool Tool::setPyAttr ( PyObject * pyobj )

overrideprotectedvirtual

attach the C++ component to its python cousin

Definition at line 108 of file PyAthenaTool.cxx.

{
  // now we tell the PyObject which C++ object it is the cousin of.
  RootUtils::PyGILStateEnsure ensure;
  PyObject* pyobj = TPython::CPPInstance_FromVoidPtr
    ( (void*)this, this->typeName() );
  if ( !pyobj ) {
    PyErr_Clear();
    // try PyAthena::Tool
    pyobj = TPython::CPPInstance_FromVoidPtr ((void*)this, "PyAthena::Tool");
    ATH_MSG_INFO
      ("could not dyncast component [" << name() << "] to a python "
       << "object of type [" << this->typeName() << "] (probably a missing "
       << "dictionary)" << endmsg
       << "fallback to [PyAthena::Tool]...");
  }
  if ( !pyobj ) {
    PyErr_Clear();
    ATH_MSG_WARNING("Could not dyncast component ["
                    << name() << "] to a pyobject of type [" 
                    << this->typeName() << "] (missing reflex dict ?)");
  } else {
    if ( -1 == PyObject_SetAttrString(o, "_cppHandle", pyobj) ) {
      PyErr_Clear();
      ATH_MSG_WARNING
        ("Could not attach C++ handle [" << name() << "] to its python "
         << "cousin !");
      if ( -1 == PyObject_SetAttrString(o, "_cppHandle", Py_None) ) {
        PyErr_Clear();
        ATH_MSG_WARNING
          ("could not attach a dummy C++ handle [" << name() << "] to its "
           << "python cousin !");
      }
    } else {
      return true;
    }
  }
  return false;
}

sysInitialize()

StatusCode Tool::sysInitialize ( )

overridevirtual

Definition at line 76 of file PyAthenaTool.cxx.

{
  ServiceHandle<IPyComponentMgr> pyMgr
    ( "PyAthena::PyComponentMgr/PyComponentMgr", 
      name() );
  if ( !pyMgr.retrieve().isSuccess() ) {
    ATH_MSG_ERROR("Could not retrieve service [" << pyMgr.typeAndName() << "] !!");
    return StatusCode::FAILURE;
  }
 
  // first retrieve our python object cousin...
  m_self = pyMgr->pyObject( this );
 
  if ( m_self == Py_None ) {
    ATH_MSG_ERROR("Wrapped PyObject is NONE !");
    return StatusCode::FAILURE;
  }
 
  // re-route to usual sysInit...
  return ToolBase_t::sysInitialize();
}

typeName()

const char * Tool::typeName ( ) const

overridevirtual

return the std::type_info name of the underlying py-component This is used by concrete implementations to connect a python component to its C++ counter-part

Definition at line 100 of file PyAthenaTool.cxx.

{ 
  static const std::string tname = System::typeinfoName(typeid(*this));
  return tname.c_str();
}

Member Data Documentation

m_self

PyObject* PyAthena::Tool::m_self

protected

Pointer to self (from the python world)

Definition at line 80 of file PyAthenaTool.h.

---

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

• PyAthenaTool.h
• PyAthenaTool.cxx