python.Dso.DsoDb Class Reference

Inheritance diagram for python.Dso.DsoDb:

Collaboration diagram for python.Dso.DsoDb:

Public Member Functions
def	__init__ (self)
def	has_type (self, typename)
def	load_type (self, typename)
def	rflx_type (self, typename)
def	visit (self, typename, visitor=None, ctx=None)

Public Attributes
	msg

Private Attributes
	_rflx_type

Detailed Description

The repository of 'rootmap' files (location, content,...) and a set of
operations one can apply on them (load dict, query dicts,...)

Definition at line 42 of file Control/AthenaServices/python/Dso.py.

Constructor & Destructor Documentation

__init__()

def python.Dso.DsoDb.__init__

(

self

)

Definition at line 47 of file Control/AthenaServices/python/Dso.py.

    def __init__(self):
        super(DsoDb, self).__init__('AthenaDsoDb')
        import AthenaCommon.Logging
        self.msg = AthenaCommon.Logging.logging.getLogger("AthenaDsoDb")
        #self.msg.setLevel(AthenaCommon.Logging.logging.VERBOSE)
        
        # inject the known aliases NOW
        for k,v in _aliases.iteritems():
            try:
                self.db[k] = self.db[v]
            except KeyError:
                self.msg.info("could not install alias [%s] -> [%s]", k,v)
        # make sure we'll be able to load dicts
        import cppyy
        #self._load_dict = cppyy.loadDict
        self._rflx_type = cppyy.gbl.RootType.ByName  
        return
 

Member Function Documentation

has_type()

def python.Dso.DsoDb.has_type	(		self,
			typename
	)

Definition at line 65 of file Control/AthenaServices/python/Dso.py.

    def has_type (self, typename):
        global _cpp_builtins
        if typename in _cpp_builtins:
            return True
        # need to massage a bit the typename to match ROOT naming convention
        typename = self._to_rootmap_name (typename)
        return self.db.has_key (typename) or \
               self.pf.has_key (typename)
 

load_type()

def python.Dso.DsoDb.load_type	(		self,
			typename
	)

Definition at line 74 of file Control/AthenaServices/python/Dso.py.

    def load_type (self, typename):
        rflx_type = self.rflx_type(typename)
        if not(rflx_type is None):
            rflx_name = rflx_type.Name(RflxEnums.DICTSCOPE)
            if rflx_name != '':
                return rflx_name
        return None
 

rflx_type()

def python.Dso.DsoDb.rflx_type	(		self,
			typename
	)

Definition at line 82 of file Control/AthenaServices/python/Dso.py.

    def rflx_type(self, typename):
        _rootmap_name = self._to_rootmap_name (typename)
        _rflx_name    = self._to_rflx_name    (typename)
        self.msg.verbose("------- loading type [%s]...", typename)
        
        global _cpp_builtins
        if typename in _cpp_builtins:
            self.msg.verbose(" ==> [ok] (builtin)")
            return self._rflx_type (_rflx_name)
 
        if not self.has_type (_rootmap_name):
            self.msg.verbose(" ==> [err] (no '%s')",_rootmap_name)
            return None
        libs = (self.db.get(_rootmap_name) or
                self.pf.get(_rootmap_name))
        if libs is None or len(libs) <= 0:
            return None
        from ctypes import cdll
        _load = cdll.LoadLibrary
        from cppyy import loadDict as _load
        lib = libs[0]
        self.msg.verbose("... %s",lib)
        _load (os.path.basename(lib.strip()))
        self.msg.verbose("... %s [done]",lib)
        self.msg.verbose(" ==> [ok]")
 
        # give the non-massaged name to reflex as this is what it expects
        # ...ROOT is sooo self-consistent...
        rflx_type = self._rflx_type (_rflx_name)
        if rflx_type.Name() != '':
            return rflx_type
        return None
 
 

visit()

def python.Dso.DsoDb.visit	(		self,
			typename,
			visitor = None,
			ctx = None
	)

Definition at line 116 of file Control/AthenaServices/python/Dso.py.

    def visit(self, typename, visitor=None, ctx=None):
        self.msg.verbose("=== visiting %s", typename)
        if ctx is None:
            ctx = set()
        if isinstance (typename, str):
            rflx_type = self.load_type (typename)
            typename = rflx_type.Name (RflxEnums.DICTSCOPE)
        else:
            rflx_type = typename
            
        if not rflx_type:
            self.msg.verbose("**warning** no dict for [%s] !!", typename)
            return ctx
        
        ctx.add (typename)
        if visitor:
            visitor (rflx_type)
            
        if rflx_type.IsClass() or rflx_type.IsStruct():
            for i in range(rflx_type.BaseSize()):
                itype = rflx_type.BaseAt(i).ToType()
                itype_name = itype.Name(RflxEnums.DICTSCOPE)
                if itype_name != '' and not (itype_name in ctx):
                    self.load_type (itype_name)
                    ctx.add (itype_name)
                    ctx.update (self.visit (itype, visitor, ctx))
                            
        for i in range(rflx_type.DataMemberSize()):
            itype = rflx_type.DataMemberAt (i).TypeOf()
            itype = itype.RawType() if itype.IsPointer() else itype
            itype_name = itype.Name(RflxEnums.DICTSCOPE)
            if itype_name != '' and not (itype_name in ctx):
                self.load_type (itype_name)
                ctx.add (itype_name)
                # restore original type
                itype = rflx_type.DataMemberAt (i).TypeOf()
                itype_name = itype.Name(RflxEnums.DICTSCOPE)
                ctx.update (self.visit (itype, visitor, ctx))
        return ctx
    

Member Data Documentation

_rflx_type

python.Dso.DsoDb._rflx_type

private

Definition at line 62 of file Control/AthenaServices/python/Dso.py.

msg

python.Dso.DsoDb.msg

Definition at line 50 of file Control/AthenaServices/python/Dso.py.

---

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

• Control/AthenaServices/python/Dso.py