Inheritance diagram for GaudiKernel.Configurable.Configurable:

[legend]

Collaboration diagram for GaudiKernel.Configurable.Configurable:

Classes
class	DefaultName

Public Member Functions
def	__new__ (cls, args, kwargs)

def	__init__ (self, name=DefaultName)

def	__getstate__ (self)

def	__getnewargs__ (self)

def	__setstate__ (self, dict)

def	__len__ (self)

def	__iter__ (self)

def	__deepcopy__ (self, memo)

def	__iadd__ (self, configs, descr=None)

def	__getattr__ (self, attr)

def	__setattr__ (self, name, value)

def	__delattr__ (self, attr)

def	__nonzero__ (self)

def	remove (self, items)

def	removeAll (self)

def	copyChild (self, child)

def	setParent (self, parentName)

def	getParent (self)

def	hasParent (self, parent)

def	copyChildAndSetParent (self, cfg, parent)

def	getChildren (self)

def	getTools (self)

def	children (self)

def	getAllChildren (self)

def	getSequence (self)

def	setup (self)

def	getProperties (self)

def	getPropertiesWithDescription (self)

def	getValuedProperties (self)

def	properties (self)

def	getDefaultProperties (cls)

def	getDefaultProperty (cls, name)

def	getProp (self, name)

def	setProp (self, name, value)

def	isPropertySet (self, name)

def	getType (cls)

def	getName (self)

def	name (self)

def	getJobOptName (self)

def	isPublic (self)

def	jobOptName (self)

def	getFullName (self)

def	getFullJobOptName (self)

def	getPrintTitle (self)

def	getTitleName (self)

def	setDefaults (cls, handle)

def	clone (self, name=None, kwargs)

def	splitName (self)

def	addTool (self, tool, name=None)

def	__repr__ (self)

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

Static Public Attributes
	propertyNoValue

string	indentUnit = '\| '

int	printHeaderWidth = 100

int	printHeaderPre = 5

dictionary	allConfigurables = {}

dictionary	configurableServices = {}

Private Member Functions
def	_isInSetDefaults (self)

def	__setupServices (self)

def	__setupDlls (self)

def	__setupDefaults (self)

Static Private Member Functions
def	_printHeader (indentStr, title)

def	_printFooter (indentStr, title)

Private Attributes
	__children

	__tools

	_name

	_inSetDefaults

	_initok

	_setupok

	_unpickling

Static Private Attributes
	__metaclass__ = ConfigurableMeta.ConfigurableMeta

tuple	__slots__

bool	_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 107 of file Configurable.py.

Constructor & Destructor Documentation

def GaudiKernel.Configurable.Configurable.__init__	(	self,
		name = `DefaultName`
	)

Definition at line 279 of file Configurable.py.

     def __init__(self, name=DefaultName):
         # 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
 
         # used to prevent spurious deprecation warnings when unpickling
         self._unpickling = False
 

Member Function Documentation

def GaudiKernel.Configurable.Configurable.__deepcopy__	(	self,
		memo
	)

Definition at line 374 of file Configurable.py.

     def __deepcopy__(self, memo):
         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 GaudiKernel.Configurable.Configurable.__delattr__	(	self,
		attr
	)

Definition at line 449 of file Configurable.py.

     def __delattr__(self, attr):
         # 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 GaudiKernel.Configurable.Configurable.__getattr__	(	self,
		attr
	)

Definition at line 423 of file Configurable.py.

     def __getattr__(self, attr):  # until ToolProperties exist ...
 
         if attr in self.__tools:
             return self.__tools[attr]
 
         if attr in self._properties:
             if isinstance(self._properties[attr].__get__(self), DataObjectHandleBase):
                 return self._properties[attr].__get__(self)
 
         for c in self.__children:
             if c.getName() == attr:
                 return c
 
         raise AttributeError(
             "'%s' object has no attribute '%s'" % (self.__class__, attr))
 

def GaudiKernel.Configurable.Configurable.__getnewargs__ ( self )

Definition at line 348 of file Configurable.py.

     def __getnewargs__(self):
         return (self._name,)
 

def GaudiKernel.Configurable.Configurable.__getstate__ ( self )

Definition at line 335 of file Configurable.py.

     def __getstate__(self):
         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 GaudiKernel.Configurable.Configurable.__iadd__	(	self,
		configs,
		descr = `None`
	)

Definition at line 390 of file Configurable.py.

     def __iadd__(self, configs, descr=None):
         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 GaudiKernel.Configurable.Configurable.__iter__ ( self )

Definition at line 370 of file Configurable.py.

     def __iter__(self):
         return iter(self.__children)
 

def GaudiKernel.Configurable.Configurable.__len__ ( self )

Definition at line 367 of file Configurable.py.

     def __len__(self):
         return len(self.__children)
 

def GaudiKernel.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 140 of file Configurable.py.

     def __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."""
 
         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 GaudiKernel.Configurable.Configurable.__nonzero__ ( self )

Definition at line 474 of file Configurable.py.

     def __nonzero__(self):
         return True
 

def GaudiKernel.Configurable.Configurable.__repr__ ( self )

Definition at line 887 of file Configurable.py.

     def __repr__(self):
         return '{0}({1!r})'.format(self.__class__.__name__, self.name())
 

def GaudiKernel.Configurable.Configurable.__setattr__	(	self,
		name,
		value
	)

Definition at line 439 of file Configurable.py.

     def __setattr__(self, name, value):
         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 GaudiKernel.Configurable.Configurable.__setstate__	(	self,
		dict
	)

Definition at line 351 of file Configurable.py.

     def __setstate__(self, dict):
         self._initok = True
         from contextlib import contextmanager
 
         @contextmanager
         def unpickling():
             try:
                 self._unpickling = True
                 yield
             finally:
                 self._unpickling = False
         with unpickling():
             for n, v in dict.items():
                 setattr(self, n, v)
 

def GaudiKernel.Configurable.Configurable.__setupDefaults ( self )

private

Definition at line 864 of file Configurable.py.

     def __setupDefaults(self):
         # 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 GaudiKernel.Configurable.Configurable.__setupDlls ( self )

private

Definition at line 852 of file Configurable.py.

     def __setupDlls(self):
         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 GaudiKernel.Configurable.Configurable.__setupServices ( self )

private

Definition at line 835 of file Configurable.py.

     def __setupServices(self):
         #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 GaudiKernel.Configurable.Configurable.__str__	(	self,
		indent = `0`,
		headerLastIndentUnit = `indentUnit`
	)

Definition at line 890 of file Configurable.py.

     def __str__(self, indent=0, headerLastIndentUnit=indentUnit):
         global log  # to print some info depending on output level
         indentStr = indent * Configurable.indentUnit
         # print header
         title = self.getPrintTitle()
         # print line to easily see start-of-configurable
         if indent > 0:
             headerIndent = (indent - 1) * \
                 Configurable.indentUnit + headerLastIndentUnit
         else:
             headerIndent = ''
         rep = Configurable._printHeader(headerIndent, title)
         rep += os.linesep
         # print own properties
         props = self.getProperties()
         defs = self.getDefaultProperties()
         if not props:
             rep += indentStr + '|-<no properties>' + os.linesep
         else:
             # get property name with
             nameWidth = 0
             for p in props.keys():
                 nameWidth = max(nameWidth, len(p))
             for p, v in props.items():
                 # start with indent and property name
                 prefix = indentStr + '|-%-*s' % (nameWidth, p)
                 # add memory address for debugging (not for defaults)
                 if log.isEnabledFor(logging.DEBUG):
                     if v != Configurable.propertyNoValue:
                         address = ' @%11s' % hex(id(v))
                     else:
                         address = 13 * ' '
                     prefix += address
                 # add value and default
                 default = defs.get(p)
                 if v == Configurable.propertyNoValue:
                     # show default value as value, and no extra 'default'
                     strVal = repr(default)
                     strDef = None
                 else:
                     # convert configurable to handle
                     if hasattr(v, "getGaudiHandle"):
                         vv = v.getGaudiHandle()
                     else:
                         vv = v
                     if isinstance(vv, GaudiHandle) or isinstance(vv, GaudiHandleArray):
                         strVal = repr(vv)
                         # the default may not be a GaudiHandle (?)
                         if hasattr(default, "toStringProperty"):
                             strDef = repr(default.toStringProperty())
                         else:
                             strDef = repr(default)
                         if strDef == repr(vv.toStringProperty()):
                             strDef = None
                     else:
                         strVal = repr(vv)
                         strDef = repr(default)
                 # add the value
                 line = prefix + ' = ' + strVal
                 # add default if present
                 if strDef is not None:
                     # put default on new line if too big
                     if len(line) + len(strDef) > Configurable.printHeaderWidth:
                         line += os.linesep + indentStr + '| ' + \
                             (len(prefix) - len(indentStr) - 3) * ' '
                     line += '  (default: %s)' % (strDef,)
                 # add the line to the total string
                 rep += line + os.linesep
                 # print out full private configurables
 # if isinstance(v,Configurable) and not v.isPublic():

def GaudiKernel.Configurable.Configurable._isInSetDefaults ( self )

private

Definition at line 832 of file Configurable.py.

     def _isInSetDefaults(self):
         return self._inSetDefaults
 

def GaudiKernel.Configurable.Configurable._printFooter	(	indentStr,
		title
	)

staticprivate

Definition at line 880 of file Configurable.py.

     def _printFooter(indentStr, title):
         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 GaudiKernel.Configurable.Configurable._printHeader	(	indentStr,
		title
	)

staticprivate

Definition at line 872 of file Configurable.py.

     def _printHeader(indentStr, title):
         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 GaudiKernel.Configurable.Configurable.addTool	(	self,
		tool,
		name = `None`
	)

Definition at line 811 of file Configurable.py.

     def addTool(self, tool, name=None):
         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])
         return self.__tools[name]
 

def GaudiKernel.Configurable.Configurable.children ( self )

Definition at line 525 of file Configurable.py.

     def children(self):
         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 GaudiKernel.Configurable.Configurable.clone	(	self,
		name = `None`,
		kwargs
	)

Definition at line 764 of file Configurable.py.

     def clone(self, name=None, **kwargs):
         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 GaudiKernel.Configurable.Configurable.copyChild	(	self,
		child
	)

Definition at line 487 of file Configurable.py.

     def copyChild(self, child):
         return copy.deepcopy(child)
 

def GaudiKernel.Configurable.Configurable.copyChildAndSetParent	(	self,
		cfg,
		parent
	)

Definition at line 499 of file Configurable.py.

     def copyChildAndSetParent(self, cfg, parent):
         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 GaudiKernel.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 532 of file Configurable.py.

     def getAllChildren(self):
         """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 GaudiKernel.Configurable.Configurable.getChildren ( self )

Definition at line 519 of file Configurable.py.

     def getChildren(self):
         return self.__children[:]    # read only
 

def GaudiKernel.Configurable.Configurable.getDefaultProperties ( cls )

Definition at line 660 of file Configurable.py.

     def getDefaultProperties(cls):
         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 GaudiKernel.Configurable.Configurable.getDefaultProperty	(	cls,
		name
	)

Definition at line 676 of file Configurable.py.

     def getDefaultProperty(cls, name):
         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 GaudiKernel.Configurable.Configurable.getFullJobOptName ( self )

Definition at line 749 of file Configurable.py.

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

def GaudiKernel.Configurable.Configurable.getFullName ( self )

Definition at line 746 of file Configurable.py.

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

def GaudiKernel.Configurable.Configurable.getJobOptName ( self )

Definition at line 734 of file Configurable.py.

     def getJobOptName(self):               # full hierachical name
         return self.getName()
 

def GaudiKernel.Configurable.Configurable.getName ( self )

Definition at line 728 of file Configurable.py.

     def getName(self):
         return self._name
 

def GaudiKernel.Configurable.Configurable.getParent ( self )

Definition at line 493 of file Configurable.py.

     def getParent(self):
         return ""
 

def GaudiKernel.Configurable.Configurable.getPrintTitle ( self )

Definition at line 752 of file Configurable.py.

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

def GaudiKernel.Configurable.Configurable.getProp	(	self,
		name
	)

Returns the value of the given property.

Definition at line 697 of file Configurable.py.

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

def GaudiKernel.Configurable.Configurable.getProperties ( self )

Definition at line 609 of file Configurable.py.

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

def GaudiKernel.Configurable.Configurable.getPropertiesWithDescription ( self )

Get all properties with their description string as { name : (value, desc) }.

Definition at line 619 of file Configurable.py.

     def getPropertiesWithDescription(self):
         """Get all properties with their description string as { name : (value, desc) }."""
         props = {}
         for name, proxy in self._properties.items():
             try:
                 props[name] = (proxy.__get__(self), proxy.__doc__)
             except AttributeError:
                 props[name] = (Configurable.propertyNoValue, proxy.__doc__)
         return props
 

def GaudiKernel.Configurable.Configurable.getSequence ( self )

Definition at line 571 of file Configurable.py.

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

def GaudiKernel.Configurable.Configurable.getTitleName ( self )

Definition at line 755 of file Configurable.py.

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

def GaudiKernel.Configurable.Configurable.getTools ( self )

Definition at line 522 of file Configurable.py.

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

def GaudiKernel.Configurable.Configurable.getType ( cls )

Definition at line 725 of file Configurable.py.

     def getType(cls):
         return cls.__name__
 

def GaudiKernel.Configurable.Configurable.getValuedProperties ( self )

Definition at line 629 of file Configurable.py.

     def getValuedProperties(self):
         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 GaudiKernel.Configurable.Configurable.hasParent	(	self,
		parent
	)

Definition at line 496 of file Configurable.py.

     def hasParent(self, parent):
         return False
 

def GaudiKernel.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 710 of file Configurable.py.

     def 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.
         """
         if not hasattr(self, name):
             return False
         default = self.getDefaultProperty(name)
         if isinstance(default, (list, dict, DataObjectHandleBase)):
             value = getattr(self, name)
             return value != default
         return True
 

def GaudiKernel.Configurable.Configurable.isPublic ( self )

Definition at line 737 of file Configurable.py.

     def isPublic(self):
         return True
 

def GaudiKernel.Configurable.Configurable.jobOptName ( self )

Definition at line 741 of file Configurable.py.

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

def GaudiKernel.Configurable.Configurable.name ( self )

Definition at line 731 of file Configurable.py.

     def name(self):
         return self.getName()
 

def GaudiKernel.Configurable.Configurable.properties ( self )

Definition at line 656 of file Configurable.py.

     def properties(self):
         return self.getProperties()           # compatibility
 

def GaudiKernel.Configurable.Configurable.remove	(	self,
		items
	)

Definition at line 477 of file Configurable.py.

     def remove(self, items):
         if type(items) != list and type(items) != tuple:
             items = [items]
 
         self.__children = [e for e in self.__children if not e in items]
 

def GaudiKernel.Configurable.Configurable.removeAll ( self )

Definition at line 483 of file Configurable.py.

     def removeAll(self):
         self.remove(self.__children)
 

def GaudiKernel.Configurable.Configurable.setDefaults	(	cls,
		handle
	)

Definition at line 761 of file Configurable.py.

     def setDefaults(cls, handle):
         pass
 

def GaudiKernel.Configurable.Configurable.setParent	(	self,
		parentName
	)

Definition at line 490 of file Configurable.py.

     def setParent(self, parentName):
         pass
 

def GaudiKernel.Configurable.Configurable.setProp	(	self,
		name,
		value
	)

Set the value of a given property

Definition at line 705 of file Configurable.py.

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

def GaudiKernel.Configurable.Configurable.setup ( self )

Definition at line 577 of file Configurable.py.

     def setup(self):
         # 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 GaudiKernel.Configurable.Configurable.splitName ( self )

Definition at line 795 of file Configurable.py.

     def splitName(self):
         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

GaudiKernel.Configurable.Configurable.__children

private

Definition at line 310 of file Configurable.py.

GaudiKernel.Configurable.Configurable.__metaclass__ = ConfigurableMeta.ConfigurableMeta

staticprivate

Definition at line 122 of file Configurable.py.

tuple GaudiKernel.Configurable.Configurable.__slots__

staticprivate

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)
         '_unpickling',          # flag for actions done during unpickling
     )

Definition at line 124 of file Configurable.py.

GaudiKernel.Configurable.Configurable.__tools

private

Definition at line 311 of file Configurable.py.

bool GaudiKernel.Configurable.Configurable._configurationLocked = False

staticprivate

Definition at line 138 of file Configurable.py.

GaudiKernel.Configurable.Configurable._initok

private

Definition at line 326 of file Configurable.py.

GaudiKernel.Configurable.Configurable._inSetDefaults

private

Definition at line 323 of file Configurable.py.

GaudiKernel.Configurable.Configurable._name

private

Definition at line 316 of file Configurable.py.

GaudiKernel.Configurable.Configurable._setupok

private

Definition at line 329 of file Configurable.py.

GaudiKernel.Configurable.Configurable._unpickling

private

Definition at line 332 of file Configurable.py.

dictionary GaudiKernel.Configurable.Configurable.allConfigurables = {}

static

Definition at line 134 of file Configurable.py.

dictionary GaudiKernel.Configurable.Configurable.configurableServices = {}

static

Definition at line 135 of file Configurable.py.

string GaudiKernel.Configurable.Configurable.indentUnit = '| '

static

Definition at line 118 of file Configurable.py.

int GaudiKernel.Configurable.Configurable.printHeaderPre = 5

static

Definition at line 120 of file Configurable.py.

int GaudiKernel.Configurable.Configurable.printHeaderWidth = 100

static

Definition at line 119 of file Configurable.py.

GaudiKernel.Configurable.Configurable.propertyNoValue

static

Definition at line 117 of file Configurable.py.

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

GaudiKernel/python/GaudiKernel/Configurable.py

Classes

Public Member Functions

Static Public Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation