Configurable::Configurable Class Reference

Inheritance diagram for Configurable::Configurable:

Collaboration diagram for Configurable::Configurable:

List of all members.

Classes
class	DefaultName
	for detecting the default name More...
Public Member Functions
def	__new__
def	__init__
def	__getstate__
def	__getnewargs__
def	__setstate__
def	__len__
def	__iter__
def	__deepcopy__
def	__iadd__
def	__getattr__
def	__setattr__
def	__delattr__
def	__nonzero__
def	remove
def	removeAll
def	copyChild
def	setParent
def	getParent
def	hasParent
def	copyChildAndSetParent
def	getChildren
def	getTools
def	children
def	getAllChildren
def	getSequence
def	setup
def	getProperties
def	getValuedProperties
def	properties
def	getDefaultProperties
def	getDefaultProperty
def	getProp
def	setProp
def	isPropertySet
def	getType
def	getName
def	name
def	getJobOptName
def	isPublic
def	jobOptName
def	getFullName
def	getFullJobOptName
def	getPrintTitle
def	getTitleName
def	setDefaults
def	clone
def	splitName
def	addTool
def	__repr__
def	__str__
Static Public Attributes
string	indentUnit = '| '
int	printHeaderWidth = 100
int	printHeaderPre = 5
dictionary	allConfigurables = {}
dictionary	configurableServices = {}
Private Member Functions
def	_isInSetDefaults
def	__setupServices
def	__setupDlls
def	__setupDefaults
def	_printHeader
def	_printFooter
Private Attributes
	__children
	__tools
	_name
	_inSetDefaults
	_initok
	_setupok
Static Private Attributes
	__metaclass__ = ConfigurableMeta.ConfigurableMeta
tuple	__slots__
	_configurationLocked = False

---

Detailed Description

Base class for Gaudi components that implement the IProperty interface.
   Provides most of the boilerplate code, but the actual useful classes
   are its derived ConfigurableAlgorithm, ConfigurableService, and
   ConfigurableAlgTool.

Definition at line 87 of file Configurable.py.

---

Constructor & Destructor Documentation

def Configurable::Configurable::__init__	(		self,
			name = DefaultName
	)

Reimplemented in Configurable::ConfigurableGeneric, Configurable::ConfigurableAlgorithm, Configurable::ConfigurableAlgTool, and Configurable::ConfigurableAuditor.

Definition at line 254 of file Configurable.py.

                                            :
        # check class readiness, all required overloads should be there now
        klass = self.__class__

        # this is an abstract class
        if klass == Configurable:
            raise TypeError, "%s is an ABC and can not be instantiated" % str(Configurable)

        # the following methods require overloading
        #NOT YET  meths = { 'getServices'   : 1,    # retrieve list of services to configure
        meths = { 'getDlls'       : 1,    # provide list of Dlls to load
                  'getGaudiType'  : 1,    # return string describing component class
                  'getHandle'     : 1 }   # provide access to C++ side component instance
#                'getType'       : 1 }   # return the type of the actual C++ component

        for meth, nArgs in meths.items():
            try:
                f = getattr( klass, meth ).im_func
            except AttributeError:
                raise NotImplementedError, "%s is missing in class %s" % (meth,str(klass))

            # in addition, verify the number of arguments w/o defaults
            nargcount = f.func_code.co_argcount
            ndefaults = f.func_defaults and len(f.func_defaults) or 0
            if not nargcount - ndefaults <= nArgs <= nargcount:
                raise TypeError, "%s.%s requires exactly %d arguments" % (klass,meth,nArgs)

        # for using this Configurable as a (Gaudi) sequence
        self.__children = []
        self.__tools = {}

        # know who we are
        if name == Configurable.DefaultName :
            if hasattr(self.__class__, 'DefaultedName' ) :
                self._name = self.__class__.DefaultedName
            else :
                self._name = self.getType()
        else :
            self._name = name

        # set to True when collecting defaults, False otherwise
        self._inSetDefaults = False

        # for later, in case __init__ itself is overridden
        self._initok = True

        # for debugging purposes (temporary)
        self._setupok = False

---

Member Function Documentation

def Configurable::Configurable::__deepcopy__	(		self,
			memo
	)

Reimplemented in Configurable::ConfigurableGeneric, Configurable::ConfigurableAlgorithm, and Configurable::ConfigurableService.

Definition at line 334 of file Configurable.py.

                                  :
        newconf = object.__new__( self.__class__ )
        self.__class__.__init__( newconf, self.getName() )

        for proxy in self._properties.values():
            try:
                proxy.__set__( newconf, proxy.__get__( self ) )
            except AttributeError:
                pass                   # means property was not set for self

        for c in self.__children:
            newconf += c              # processes proper copy semantics

        return newconf

def Configurable::Configurable::__delattr__	(		self,
			attr
	)

Definition at line 401 of file Configurable.py.

                                 :
        # remove as property, otherwise try as child
        try:
            # remove history etc., then reset to default (in case set before)
            prop = self._properties[ attr ]
            prop.__delete__( self )
            prop.__set__( self, prop.default )
            return               # reaches here? was property: done now
        except KeyError:
            pass
        # otherwise, remove the private tool
        if attr in self.__tools :
            del self.__tools[attr]

        # otherwise, remove child, if one is so named
        for c in self.__children:
            if c.getName() == attr:
                self.__children.remove( c )

        # potentially, there are left over caches (certain user derived classes)
        try:
            del self.__dict__[ attr ]
        except (AttributeError,KeyError):
            pass

def Configurable::Configurable::__getattr__	(		self,
			attr
	)

Definition at line 382 of file Configurable.py.

                                 :  # until ToolProperties exist ...

        if attr in self.__tools : return self.__tools[attr]

        for c in self.__children:
            if c.getName() == attr:
                return c

        raise AttributeError( "'%s' object has no attribute '%s'" % (self.__class__,attr) )

def Configurable::Configurable::__getnewargs__

(

self )

Definition at line 317 of file Configurable.py.

                             :
        return (self._name,)

def Configurable::Configurable::__getstate__

(

self )

Definition at line 304 of file Configurable.py.

                           :
        dict = {}
        for name, proxy in self._properties.items():
            try:
                dict[ name ] = proxy.__get__( self )
            except AttributeError:
                pass

        dict[ '_Configurable__children' ] = self.__children
        dict[ '_Configurable__tools' ] = self.__tools
        dict[ '_name' ] = self._name
        return dict

def Configurable::Configurable::__iadd__	(		self,
			configs,
			descr = None
	)

Definition at line 350 of file Configurable.py.

                                               :
        if not type(configs) in (list,tuple):
            configs = ( configs, )

        joname = self.getJobOptName()

        for cfg in configs:
            # prevent type mismatches
            if not isinstance( cfg, Configurable ):
                raise TypeError( "'%s' is not a Configurable" % str(cfg) )

            cc = self.copyChildAndSetParent( cfg, joname )

            # filters dupes; usually "ok" (backdoor should catch them)
            ccjo = cc.getJobOptName()
            for c in self.__children:
                if c.getJobOptName() == ccjo:
                    log.error( 'attempt to add a duplicate ... dupe ignored%s', error_explanation )
                    break
            else:
                self.__children.append( cc )

            try:
                if descr:         # support for tool properties
                    descr.__set__( self, cc )
                else:
                    setattr( self, cc.getName(), cc )
            except AttributeError:
                pass              # to allow free addition of tools/subalgorithms

        return self

def Configurable::Configurable::__iter__

(

self )

Definition at line 330 of file Configurable.py.

                        :
        return iter( self.__children )

def Configurable::Configurable::__len__

(

self )

Definition at line 327 of file Configurable.py.

                       :
        return len( self.__children )

def Configurable::Configurable::__new__	(		cls,
			args,
			kwargs
	)

To Gaudi, any object with the same type/name is the same object. Hence,
   this is mimicked in the configuration: instantiating a new Configurable
   of a type with the same name will return the same instance.

Definition at line 119 of file Configurable.py.

                                        :
        """To Gaudi, any object with the same type/name is the same object. Hence,
           this is mimicked in the configuration: instantiating a new Configurable
           of a type with the same name will return the same instance."""

        global log
        # try to get the name of the Configurable (having a name is compulsory)
        if 'name' in kwargs:
        # simple keyword (by far the easiest)
            name = kwargs[ 'name' ]
        elif 'name' in cls.__init__.func_code.co_varnames:
        # either positional in args, or default
            index =  list(cls.__init__.func_code.co_varnames).index( 'name' )
            try:
             # var names index is offset by one as __init__ is to be called with self
                name = args[ index - 1 ]
            except IndexError:
             # retrieve default value, then
                name = cls.__init__.func_defaults[ index - (len(args)+1) ]
        else:
        # positional index is assumed (will work most of the time)
            try:
                name = args[1]    # '0' is for self
            except (IndexError,TypeError):
                raise TypeError( 'no "name" argument while instantiating "%s"' % cls.__name__ )

        argname = name
        if name == Configurable.DefaultName :
            if hasattr(cls, 'DefaultedName' ) :
                name = cls.DefaultedName
            else :
                name = cls.getType()
        elif not name or type(name) != str:
        # unnamed, highly specialized user code, etc. ... unacceptable
            raise TypeError( 'could not retrieve name from %s.__init__ arguments' % cls.__name__ )

        # Handle the case of global tools to prepend ToolSvc in the name.
        # This is needed for compatibility with old JobOptions files being read
        if issubclass( cls, ConfigurableAlgTool) and '.' not in name :
            name = 'ToolSvc.' + name

        # close backdoor access to otherwise private subalgs/tools
        #PM if 0 <= name.find( '.' ):
        #PM # temp protection for old style types
        #PM   from OldStyleConfig import GenericConfigurable
        #PM   if not issubclass( cls, GenericConfigurable ): # except raised for new types only
        #PM      raise NameError( '"%s": backdoor access to private configurables not allowed' % name )

        # ordinary recycle case
        if name in cls.configurables:
            conf = cls.configurables[ name ]
            if name != argname:      # special case: user derived <-> real ... make same
                cls.configurables[ conf.getType() ] = conf
            #---PM: Initialize additional properties
            for n,v in kwargs.items():
                if n != "name": # it should not be confused with a normal property
                    setattr(conf, n, v)
            if not cls._configurationLocked and not "_enabled" in kwargs and isinstance(conf, ConfigurableUser):
                # Ensure that the ConfigurableUser gets enabled if nothing is
                # specified in the constructor.
                setattr(conf, "_enabled", True)
            return conf

        # a couple of special cases (note that these cases don't mix)
        spos = name.find( '/' )
        ti_name = None
        if spos < 0:
            ti_name = "%s/%s" % (name,name)
            if ti_name in cls.configurables:
                # support for old-style name as type/name lookup where name==type
                return cls.configurables[ ti_name ]

        i_name = None
        if spos > 0:
            i_name = name[:spos]
            if i_name == name[spos+1:] and i_name in cls.configurables:
            # this is the opposite of the above special case
                return cls.configurables[ i_name ]

        # the following is purely for debugging support and should realistically bomb
        conf = cls.allConfigurables.get( name, None ) or\
                 (spos < 0 and cls.allConfigurables.get( ti_name, None )) or\
                 (spos > 0 and i_name == name[spos+1:] and cls.allConfigurables.get( i_name, None ))
        if conf:                    # wrong type used?
            if conf.__class__ is ConfigurableGeneric :
                #  If the instance found is ConfigurableGeneric then
                #  we create a new one with the proper type and fill with
                #  the contents of the generic one
                newconf = object.__new__( cls )
                cls.__init__( newconf, *args, **kwargs )
                #  initialize with the properties of generic configurable
                #  (we map the names of the properties to lowercase versions because
                #  old options are not case sensitive)
                names = {}
                for n in newconf.__slots__:
                    names[n.lower()] = n
                for n in conf._properties:
                    if names[n.lower()] != n:
                        log.warning( "Option '%s' was used for %s, but the correct spelling is '%s'"%(n,name,names[n.lower()]) )
                    setattr(newconf, names[n.lower()], getattr( conf, n ) )
                for n,v in kwargs.items():
                    setattr(newconf, n, v)
                cls.configurables[ name ] = newconf
                cls.allConfigurables[ name ] = newconf
                return newconf
            else :
                #  will be an actual error in the future (now only report as such)
                log.error( 'attempt to redefine type of "%s" (was: %s, new: %s)%s',
                name, conf.__class__.__name__, cls.__name__, error_explanation )
                #  in the future:
                #  return None             # will bomb on use (or go unharmed on non-use)
                #  for now, allow use through allConfigurables lookup
                #---PM: Initialize additional properties
                for n,v in kwargs.items():
                    setattr(conf, n, v)
                return conf

        # still here: create a new instance and initialize it
        conf = object.__new__(cls)
        cls.__init__( conf, *args, **kwargs )

        # update normal, per-class cache
        cls.configurables[ name ] = conf

        for base in cls.__bases__:
            if base.__name__ == 'ConfigurableService':
                cls.configurableServices[ name ] = conf

        # update generics super-cache, if needed
        cls.allConfigurables[ name ] = conf
        #-->PM#if hasattr( cls, 'getType' ) and name.find('/') < 0:
        #-->PM#   cls.allConfigurables[ cls.getType() + '/' + name ] = conf

        return conf

def Configurable::Configurable::__nonzero__

(

self )

Definition at line 426 of file Configurable.py.

                         :
        return True

def Configurable::Configurable::__repr__

(

self )

Definition at line 827 of file Configurable.py.

                        :
        return '<%s at %s>' % (self.getFullJobOptName(),hex(id(self)))

def Configurable::Configurable::__setattr__	(		self,
			name,
			value
	)

Reimplemented in Configurable::ConfigurableGeneric.

Definition at line 392 of file Configurable.py.

                                         :
        if self._configurationLocked:
            raise RuntimeError("%s: Configuration cannot be modified after the ApplicationMgr has been started."%self.name())
        try :
            super( Configurable, self ).__setattr__( name, value )
        except AttributeError:
            raise AttributeError( "Configurable '%s' does not have property '%s'."
                                  % ( self.__class__.__name__, name) )

def Configurable::Configurable::__setstate__	(		self,
			dict
	)

Definition at line 320 of file Configurable.py.

                                   :
        self._initok = True
        for n, v in dict.items():
            setattr (self, n, v)
        return

def Configurable::Configurable::__setupDefaults

(

self )

[private]

Definition at line 806 of file Configurable.py.

                               :
        # set handle defaults flags to inform __setattr__ that it is being
        # called during setDefaults of the concrete Configurable
        self._inSetDefaults = True
        self.setDefaults( self )
        self._inSetDefaults = False

def Configurable::Configurable::__setupDlls

(

self )

[private]

Definition at line 795 of file Configurable.py.

                           :
        dlls = self.getDlls()
        if not dlls:
            dlls = []
        elif type(dlls) == types.StringType:
            dlls = [ dlls ]

        from __main__ import theApp
        dlls = filter( lambda d: d not in theApp.Dlls, dlls )
        if dlls: theApp.Dlls += dlls

def Configurable::Configurable::__setupServices

(

self )

[private]

Definition at line 778 of file Configurable.py.

                               :
        #svcs = self.getServices()
        #if not svcs:
        svcs = []
        #elif type(svcs) == types.StringType:
        #   svcs = [ svcs ]

        import __main__
        for svc in svcs:
            handle = __main__.Service( svc )
            # services should be configurables as well, but aren't for now
            # handle.setup()

            # allow Configurable to make some changes
            if hasattr( self, 'configure' + svc ):
                eval( 'self.configure' + svc + '( handle )' )

def Configurable::Configurable::__str__	(		self,
			indent = 0,
			headerLastIndentUnit = indentUnit
	)

Definition at line 830 of file Configurable.py.

00831                                                                     :
00832         global log  # to print some info depending on output level
00833         indentStr = indent*Configurable.indentUnit
00834         # print header
00835         title = self.getPrintTitle()
00836         # print line to easily see start-of-configurable
00837         if indent > 0:
00838             headerIndent = (indent-1)*Configurable.indentUnit + headerLastIndentUnit
00839         else:
00840             headerIndent = ''
00841         rep = Configurable._printHeader( headerIndent, title )
00842         rep += os.linesep
00843         # print own properties
00844         props = self.getProperties()
00845         defs = self.getDefaultProperties()
00846         if not props:
00847             rep += indentStr + '|-<no properties>' + os.linesep
00848         else:
00849             # get property name with
00850             nameWidth = 0
00851             for p in props.keys():
00852                 nameWidth=max(nameWidth,len(p))
00853             for p, v in props.items():
00854                 # start with indent and property name
00855                 prefix = indentStr + '|-%-*s' % (nameWidth,p)
00856                 # add memory address for debugging (not for defaults)
00857                 if log.isEnabledFor( logging.DEBUG ):
00858                     if v != Configurable.propertyNoValue:
00859                         address = ' @%11s' % hex(id(v))
00860                     else:
00861                         address = 13*' '
00862                     prefix += address
00863                 # add value and default
00864                 default = defs.get(p)
00865                 if v == Configurable.propertyNoValue:
00866                     # show default value as value, and no extra 'default'
00867                     strVal = repr(default)
00868                     strDef = None
00869                 else:
00870                     # convert configurable to handle
00871                     if hasattr(v,"getGaudiHandle"):
00872                         vv = v.getGaudiHandle()
00873                     else:
00874                         vv = v
00875                     if isinstance(vv,GaudiHandle) or isinstance(vv,GaudiHandleArray):
00876                         strVal = repr(vv)
00877                         if hasattr(default,"toStringProperty"): # the default may not be a GaudiHandle (?)
00878                             strDef = repr(default.toStringProperty())
00879                         else:
00880                             strDef = repr(default)
00881                         if strDef == repr(vv.toStringProperty()):
00882                             strDef = None
00883                     else:
00884                         strVal = repr(vv)
00885                         strDef = repr(default)
00886                 # add the value
00887                 line = prefix + ' = ' + strVal
00888                 # add default if present
00889                 if strDef is not None:
00890                     # put default on new line if too big
00891                     if len(line) + len(strDef) > Configurable.printHeaderWidth:
00892                         line += os.linesep + indentStr + '| ' + (len(prefix)-len(indentStr)-3)*' '
00893                     line += '  (default: %s)' % (strDef,)
00894                 # add the line to the total string
00895                 rep += line + os.linesep
                # print out full private configurables

def Configurable::Configurable::_isInSetDefaults

(

self )

[private]

Definition at line 775 of file Configurable.py.

                                :
        return self._inSetDefaults

def Configurable::Configurable::_printFooter	(		indentStr,
			title
	)		[private]

Definition at line 821 of file Configurable.py.

                                        :
        preLen  = Configurable.printHeaderPre
        postLen = Configurable.printHeaderWidth - preLen - 12 - len(title)# - len(indentStr)
        postLen = max(preLen,postLen)
        return indentStr + '\\%s (End of %s) %s' % (preLen*'-',title,postLen*'-')

def Configurable::Configurable::_printHeader	(		indentStr,
			title
	)		[private]

Definition at line 814 of file Configurable.py.

                                        :
        preLen  = Configurable.printHeaderPre
        postLen = Configurable.printHeaderWidth - preLen - 3 - len(title)# - len(indentStr)
        postLen = max(preLen,postLen)
        return indentStr + '/%s %s %s' % (preLen*'*',title,postLen*'*')

def Configurable::Configurable::addTool	(		self,
			tool,
			name = None
	)

Definition at line 755 of file Configurable.py.

                                           :
        if isclass(tool) and issubclass(tool, ConfigurableAlgTool):
            if name is None:
                name = tool.__name__
            priv_tool = tool( self.getName()+ '.' + name )
        elif isinstance(tool, ConfigurableAlgTool):
            if name is None:
                name = tool.splitName()[1]
            priv_tool = tool.clone( self.getName()+ '.' + name )
        else:
            if isclass(tool):
                classname = tool.__name__
            else:
                classname = type(tool).__name__
            raise TypeError, "addTool requires AlgTool configurable. Got %s type" % classname
        self.__tools[name] =  priv_tool
        if name in self.__slots__:
            # this is to avoid that the property hides the tool
            setattr(self,name,self.__tools[name])

def Configurable::Configurable::children

(

self )

Definition at line 478 of file Configurable.py.

                        :
        log.error( "children() is deprecated, use getChildren() instead for consistency" )
        log.error( "getChildren() returns a copy; to add a child, use 'parent += child'%s",
                   error_explanation )
        return self.__children       # by ref, for compatibility

def Configurable::Configurable::clone	(		self,
			name = None,
			kwargs
	)

Definition at line 710 of file Configurable.py.

                                              :
        if not name :
            if hasattr(self, 'DefaultedName' ) : name = self.DefaultedName
            else                               : name = self.getType()

        newconf = Configurable.__new__( self.__class__, name )
        self.__class__.__init__( newconf, name )

        for proxy in self._properties.values():
            try :
                value = proxy.__get__( self )
                if type(value) in [ str, list, dict, tuple ]:
                    # clone the values of the properties for basic types
                    value = type(value)(value)
                proxy.__set__( newconf, value )
            except AttributeError:
                pass

        for c in self.__children:
            newconf += c              # processes proper copy semantics

        for n , t in self.__tools.items():
            newconf.addTool(t, n)

        for name, value in kwargs.items():
            setattr(newconf, name, value)

        return newconf

def Configurable::Configurable::copyChild	(		self,
			child
	)

Reimplemented in Configurable::ConfigurableService.

Definition at line 440 of file Configurable.py.

                                :
        return copy.deepcopy( child )

def Configurable::Configurable::copyChildAndSetParent	(		self,
			cfg,
			parent
	)

Definition at line 452 of file Configurable.py.

                                              :
        cc = self.copyChild( cfg )

        if hasattr( cc, 'setParent' ) and parent:
            try:
                cc.setParent( parent )
            except RuntimeError, e:
                # temporary backdoor resolution for compatibility
                log.error( str(e) + '%s', error_explanation )
                ccbd = cc.configurables[ cc.getJobOptName() ]

                # merge properties, new over pre-existing
                for proxy in self._properties.values():
                    if proxy.history.has_key( cc ):
                        proxy.__set__( ccbd, proxy.__get__( cc ) )

                # consolidate
                cc = ccbd
        return cc

def Configurable::Configurable::getAllChildren

(

self )

Get all (private) configurable children, both explicit ones (added with +=)
and the ones in the private GaudiHandle properties

Definition at line 484 of file Configurable.py.

                              :
        """Get all (private) configurable children, both explicit ones (added with +=)
        and the ones in the private GaudiHandle properties"""
        childs = []
        # add private configurable properties (also inside handles)
        for proxy in self._properties.values():
            try:
                c = proxy.__get__( self )
            except AttributeError:
                pass
            else:
                if isinstance(c,Configurable) and not c.isPublic():
                    childs.append(c)
                elif isinstance(c,GaudiHandle):
                    try:
                        conf = c.configurable
                    except AttributeError:
                        pass
                    else:
                        if not conf.isPublic():
                            childs.append(conf)
                elif isinstance(c,GaudiHandleArray):
                    # only setup private arrays
                    if not c.isPublic():
                        for ci in c:
                            if isinstance(ci,Configurable):
                                childs.append(ci)
                            else:
                                try:
                                    conf = ci.configurable
                                except AttributeError:
                                    pass
                                else:
                                    childs.append(conf)

        # add explicit children
        childs += self.__children
        return childs

def Configurable::Configurable::getChildren

(

self )

Definition at line 472 of file Configurable.py.

                           :
        return self.__children[:]    # read only

def Configurable::Configurable::getDefaultProperties

(

cls )

Definition at line 602 of file Configurable.py.

                                   :
        class collector:
            pass

        # user provided defaults
        c = collector()
        cls.setDefaults( c )

        # defaults from C++
        for k,v in cls._properties.items():
            if not k in c.__dict__ and hasattr( v, 'default' ):
                c.__dict__[ k ] = v.default

        return c.__dict__

def Configurable::Configurable::getDefaultProperty	(		cls,
			name
	)

Definition at line 618 of file Configurable.py.

                                       :
        class collector:
            pass

        # user provided defaults
        c = collector()
        cls.setDefaults( c )

        if name in c.__dict__:
            return c.__dict__[ name ]

        # defaults from C++
        try:
            v = cls._properties[name]
            if hasattr( v, 'default' ):
                return v.default
        except KeyError:
            pass

        return None

def Configurable::Configurable::getFullJobOptName

(

self )

Definition at line 695 of file Configurable.py.

                                 :
        return "%s/%s" % (self.getType(),self.getJobOptName() or self.getName())

def Configurable::Configurable::getFullName

(

self )

Reimplemented in Configurable::ConfigurableAlgTool.

Definition at line 692 of file Configurable.py.

                            :
        return str( self.getType() + '/' + self.getName() )

def Configurable::Configurable::getJobOptName

(

self )

Reimplemented in Configurable::ConfigurableGeneric, Configurable::ConfigurableAlgorithm, Configurable::ConfigurableAlgTool, and Configurable::ConfigurableAuditor.

Definition at line 680 of file Configurable.py.

                             :               # full hierachical name
        return self.getName()

def Configurable::Configurable::getName

(

self )

Definition at line 674 of file Configurable.py.

                       :
        return self._name

def Configurable::Configurable::getParent

(

self )

Reimplemented in Configurable::ConfigurableAlgTool.

Definition at line 446 of file Configurable.py.

                         :
        return ""

def Configurable::Configurable::getPrintTitle

(

self )

Reimplemented in Configurable::ConfigurableAlgTool.

Definition at line 698 of file Configurable.py.

                           :
        return self.getGaudiType() + ' ' + self.getTitleName()

def Configurable::Configurable::getProp	(		self,
			name
	)

Returns the value of the given property.

Definition at line 639 of file Configurable.py.

                           :
        """Returns the value of the given property.
        """
        if hasattr(self, name):
            return getattr(self, name)
        else:
            return self.getDefaultProperties()[name]

def Configurable::Configurable::getProperties

(

self )

Definition at line 561 of file Configurable.py.

                             :
        props = {}
        for name, proxy in self._properties.items():
            try:
                props[ name ] = proxy.__get__( self )
            except AttributeError:
                props[ name ] = Configurable.propertyNoValue

        return props

def Configurable::Configurable::getSequence

(

self )

Definition at line 523 of file Configurable.py.

                           :
        elems = []
        for c in self.__children:
            elems.append( c.getFullName() )
        return elems

def Configurable::Configurable::getTitleName

(

self )

Definition at line 701 of file Configurable.py.

                            :
        if log.isEnabledFor( logging.DEBUG ):
            return self.getFullJobOptName()
        else:
            return self.getFullName()

def Configurable::Configurable::getTools

(

self )

Definition at line 475 of file Configurable.py.

                        :
        return self.__tools.values()    # read only

def Configurable::Configurable::getType

(

cls )

Definition at line 671 of file Configurable.py.

                      :
        return cls.__name__

def Configurable::Configurable::getValuedProperties

(

self )

Definition at line 571 of file Configurable.py.

                                   :
        props = {}
        for name, proxy in self._properties.items():
            if self.isPropertySet(name):
                value = proxy.__get__( self )
                if hasattr(value, 'getFullName') :
                    value = value.getFullName()
                elif type(value) in [list, tuple]:
                    new_value = []
                    for i in value:
                        if hasattr(i, 'getFullName'):
                            new_value.append(i.getFullName())
                        else:
                            new_value.append(i)
                    value = type(value)(new_value)
                elif type(value) is dict:
                    new_value = {}
                    for i in value:
                        if hasattr(value[i], 'getFullName'):
                            new_value[i] = value[i].getFullName()
                        else:
                            new_value[i] = value[i]
                    value = new_value
                props[ name ] = value

        return props

def Configurable::Configurable::hasParent	(		self,
			parent
	)

Reimplemented in Configurable::ConfigurableAlgTool.

Definition at line 449 of file Configurable.py.

                                 :
        return False

def Configurable::Configurable::isPropertySet	(		self,
			name
	)

Tell if the property 'name' has been set or not.

Because of a problem with list and dictionary properties, in those cases
if the value is equal to the default, the property is considered as not
set.

Definition at line 652 of file Configurable.py.

                                 :
        """Tell if the property 'name' has been set or not.

        Because of a problem with list and dictionary properties, in those cases
        if the value is equal to the default, the property is considered as not
        set.
        """
        if not hasattr(self, name):
            return False
        else:
            try:
                default = self.getDefaultProperties()[name]
                if isinstance(default, (list, dict)):
                    value = getattr(self, name)
                    return value != default
            except KeyError:
                pass # no default found
            return True

def Configurable::Configurable::isPublic

(

self )

Reimplemented in Configurable::ConfigurableAlgTool.

Definition at line 683 of file Configurable.py.

                        :
        return True

def Configurable::Configurable::jobOptName

(

self )

Definition at line 687 of file Configurable.py.

                          :
        log.error( "jobOptName() is deprecated, use getJobOptName() instead for consistency%s",
                   error_explanation )
        return self.getJobOptName()           # compatibility

def Configurable::Configurable::name

(

self )

Definition at line 677 of file Configurable.py.

                    :
        return self.getName()

def Configurable::Configurable::properties

(

self )

Definition at line 598 of file Configurable.py.

                          :
        return self.getProperties()           # compatibility

def Configurable::Configurable::remove	(		self,
			items
	)

Definition at line 430 of file Configurable.py.

                             :
        if type(items) != list and type(items) != tuple:
            items = [ items ]

        self.__children = [ e for e in self.__children if not e in items ]

def Configurable::Configurable::removeAll

(

self )

Definition at line 436 of file Configurable.py.

                         :
        self.remove( self.__children )

def Configurable::Configurable::setDefaults	(		cls,
			handle
	)

Definition at line 707 of file Configurable.py.

                                  :
        pass

def Configurable::Configurable::setParent	(		self,
			parentName
	)

Reimplemented in Configurable::ConfigurableAlgTool.

Definition at line 443 of file Configurable.py.

                                     :
        pass

def Configurable::Configurable::setProp	(		self,
			name,
			value
	)

Set the value of a given property

Definition at line 647 of file Configurable.py.

                                  :
        """Set the value of a given property
        """
        return setattr(self, name, value)

def Configurable::Configurable::setup

(

self )

Definition at line 529 of file Configurable.py.

                     :
        # make sure base class init has been called
        if not hasattr(self,'_initok') or not self._initok:
        # could check more, but this is the only explanation
            raise TypeError, \
               "Configurable.__init__ not called in %s override" % self.__class__.__name__

#      log.debug("calling setup() on " + self.getFullJobOptName())

        # setup self: this collects all values on the python side
        self.__setupServices()
        self.__setupDlls()
        self.__setupDefaults()

        # setup children
        for c in self.getAllChildren():
            c.setup()

        # now get handle to work with for moving properties into the catalogue
        handle = self.getHandle()
        if not handle:
            log.debug( 'no handle for %s: not transporting properties', self._name )
            return                    # allowed, done early

        # pass final set of properties on to handle on the C++ side or JobOptSvc
        for name in self._properties.keys():
            if hasattr( self, name ): # means property has python-side value/default
                setattr( handle, name, getattr(self,name) )

        # for debugging purposes
        self._setupok = True

def Configurable::Configurable::splitName

(

self )

Definition at line 739 of file Configurable.py.

                          :
        fullname = self.getName()
        dot = fullname.find('.')
        if dot != -1 :
            parentname = fullname[:dot]
            longname = fullname[dot+1:]
        else :
            parentname = ''
            longname = fullname
        dot = longname.find('.')
        if dot != -1 :
            name = longname[:dot]
        else :
            name = longname
        return parentname, name, longname

---

Member Data Documentation

Configurable::Configurable::__children [private]

Definition at line 255 of file Configurable.py.

Configurable::Configurable::__metaclass__ = ConfigurableMeta.ConfigurableMeta [static, private]

Definition at line 102 of file Configurable.py.

tuple Configurable::Configurable::__slots__ [static, private]

Initial value:

(
       '__children',           # controlled components, e.g. private AlgTools
       '__tools',              # private AlgTools  (#PM-->)
       '_name',                # the (unqualified) component name
       '_inSetDefaults',       # currently setting default values
       '_initok',              # used to enforce base class init
       '_setupok'              # for debugging purposes (temporary)
    )

Reimplemented in Configurable::ConfigurableAlgorithm, Configurable::ConfigurableService, Configurable::ConfigurableAlgTool, Configurable::ConfigurableAuditor, and Configurable::ConfigurableUser.

Definition at line 104 of file Configurable.py.

Configurable::Configurable::__tools [private]

Definition at line 255 of file Configurable.py.

Configurable::Configurable::_configurationLocked = False [static, private]

Definition at line 117 of file Configurable.py.

Configurable::Configurable::_initok [private]

Definition at line 255 of file Configurable.py.

Configurable::Configurable::_inSetDefaults [private]

Definition at line 255 of file Configurable.py.

Configurable::Configurable::_name [private]

Reimplemented in Configurable::ConfigurableGeneric, and Configurable::ConfigurableAlgTool.

Definition at line 255 of file Configurable.py.

Configurable::Configurable::_setupok [private]

Definition at line 255 of file Configurable.py.

dictionary Configurable::Configurable::allConfigurables = {} [static]

Definition at line 113 of file Configurable.py.

dictionary Configurable::Configurable::configurableServices = {} [static]

Definition at line 114 of file Configurable.py.

string Configurable::Configurable::indentUnit = '| ' [static]

Definition at line 98 of file Configurable.py.

int Configurable::Configurable::printHeaderPre = 5 [static]

Definition at line 100 of file Configurable.py.

int Configurable::Configurable::printHeaderWidth = 100 [static]

Definition at line 99 of file Configurable.py.

---

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

• /afs/.cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v22r2/GaudiKernel/python/GaudiKernel/Configurable.py