GaudiKernel.Configurable.ConfigurableUser Class Reference

Inheritance diagram for GaudiKernel.Configurable.ConfigurableUser:

Collaboration diagram for GaudiKernel.Configurable.ConfigurableUser:

Public Member Functions
def	__init__ (self, name=Configurable.DefaultName, _enabled=True, kwargs)
def	getGaudiType (self)
def	getDlls (self)
def	getHandle (self)
def	__detach_used__ (self)
def	propagateProperty
def	propagateProperties
def	__apply_configuration__ (self)
def	applyConf (self)
def	getUsedInstance (self, name)
def	isApplicable (self)
Public Member Functions inherited from GaudiKernel.Configurable.Configurable
def	__new__ (cls, args, kwargs)
def	__init__
def	__getstate__ (self)
def	__getnewargs__ (self)
def	__setstate__ (self, dict)
def	__len__ (self)
def	__iter__ (self)
def	__deepcopy__ (self, memo)
def	__iadd__
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	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
def	__repr__ (self)
def	__str__

Private Member Functions
def	__addActiveUseOf (self, other)
def	__addPassiveUseOf (self, other)
def	_instanceName (self, cls)

Private Attributes
	_enabled
	__users__
	_applied
	__used_instances__

Static Private Attributes
dictionary	__slots__
list	__used_configurables__ = []
	list of ConfigurableUser classes this one is going to modify in the apply_configuration method. More...
list	__queried_configurables__ = []
	list of ConfigurableUser classes this one is going to query in the apply_configuration method More...

Additional Inherited Members
Static Public Attributes inherited from GaudiKernel.Configurable.Configurable
string	indentUnit = '| '
int	printHeaderWidth = 100
int	printHeaderPre = 5
dictionary	allConfigurables = {}
dictionary	configurableServices = {}

Detailed Description

Definition at line 1121 of file Configurable.py.

Constructor & Destructor Documentation

def GaudiKernel.Configurable.ConfigurableUser.__init__	(		self,
			name = Configurable.DefaultName,
			_enabled = True,
			kwargs
	)

Definition at line 1138 of file Configurable.py.

    def __init__( self, name = Configurable.DefaultName, _enabled = True, **kwargs ):
        super( ConfigurableUser, self ).__init__( name )
        for n, v in kwargs.items():
            setattr(self, n, v)
        self._enabled = _enabled
        self.__users__ = []
        self._applied = False

        # Needed to retrieve the actual class if the declaration in __used_configurables__
        # and  __queried_configurables__ is done with strings.
        from GaudiKernel.ConfigurableDb import getConfigurable as confDbGetConfigurable

        # Set the list of users of the used configurables
        #
        self.__used_instances__ = []
        for used in self.__used_configurables__:
            # By default we want to use the default name of the instances
            # for the used configurables
            used_name = Configurable.DefaultName
            # If the entry in the list is a tuple, we need a named instance
            if type(used) is tuple:
                used, used_name = used # we re-set used to re-use the code below
                if not used_name:
                    used_name = self._instanceName(used)
            # Check is 'used' is a string or not
            if type(used) is str:
                used_class = confDbGetConfigurable(used)
            else:
                used_class = used
            # Instantiate the configurable that we are going to use
            try:
                inst = used_class(name = used_name, _enabled = False)
            except AttributeError:
                # This cover the case where the used configurable is not a
                # ConfigurableUser instance, i.e. id doesn't have the attribute
                # '_enabled'.
                inst = used_class(name = used_name)
            self.__addActiveUseOf(inst)
        for queried in self.__queried_configurables__:
            try:
                if type(queried) is str:
                    queried = confDbGetConfigurable(queried)
                inst = queried(_enabled = False)
            except AttributeError:
                inst = queried()
            self.__addPassiveUseOf(inst)

Member Function Documentation

def GaudiKernel.Configurable.ConfigurableUser.__addActiveUseOf (   self,   other  )

private

Declare that we are going to modify the Configurable 'other' in our
__apply_configuration__.

Definition at line 1184 of file Configurable.py.

    def __addActiveUseOf(self, other):
        """
        Declare that we are going to modify the Configurable 'other' in our
        __apply_configuration__.
        """
        self.__used_instances__.append(other)
        if hasattr(other, "__users__"): # allow usage of plain Configurables
            other.__users__.append(self)

def GaudiKernel.Configurable.ConfigurableUser.__addPassiveUseOf (   self,   other  )

private

Declare that we are going to retrieve property values from the
ConfigurableUser 'other' in our __apply_configuration__.

Definition at line 1192 of file Configurable.py.

    def __addPassiveUseOf(self, other):
        """
        Declare that we are going to retrieve property values from the
        ConfigurableUser 'other' in our __apply_configuration__.
        """
        if not isinstance(other, ConfigurableUser):
            raise Error("'%s': Cannot make passive use of '%s', it is not a ConfigurableUser" % (self.name(), other.name()))
        other.__addActiveUseOf(self)

def GaudiKernel.Configurable.ConfigurableUser.__apply_configuration__

(

self

)

Function to be overridden to convert the high level configuration into a
low level one.
The default implementation calls applyConf, which is the method defined
in some ConfigurableUser implementations.

Definition at line 1276 of file Configurable.py.

    def __apply_configuration__(self):
        """
        Function to be overridden to convert the high level configuration into a
        low level one.
        The default implementation calls applyConf, which is the method defined
        in some ConfigurableUser implementations.
        """
        return self.applyConf()

def GaudiKernel.Configurable.ConfigurableUser.__detach_used__

(

self

)

Remove this ConfigurableUser instance from the users list of the used
instances.

Definition at line 1207 of file Configurable.py.

    def __detach_used__(self):
        """
        Remove this ConfigurableUser instance from the users list of the used
        instances.
        """
        for used in self.__used_instances__:
            if hasattr(used, "__users__"): # allow usage of plain Configurables
                used.__users__.remove(self)

def GaudiKernel.Configurable.ConfigurableUser._instanceName (   self,   cls  )

private

Function used to define the name of the private instance of a given class
name.
This method is used when the __used_configurables_property__ declares the
need of a private used configurable without specifying the name.

Definition at line 1292 of file Configurable.py.

    def _instanceName(self, cls):
        """
        Function used to define the name of the private instance of a given class
        name.
        This method is used when the __used_configurables_property__ declares the
        need of a private used configurable without specifying the name.
        """
        if type(cls) is str:
            clName = cls
        else:
            clName = cls.__name__
        return "%s_%s" % (self.name(), clName)

def GaudiKernel.Configurable.ConfigurableUser.applyConf

(

self

)

Function to be overridden to convert the high level configuration into a
low level one.

Definition at line 1285 of file Configurable.py.

    def applyConf( self ):
        """
        Function to be overridden to convert the high level configuration into a
        low level one.
        """
        pass

def GaudiKernel.Configurable.ConfigurableUser.getDlls

(

self

)

Definition at line 1202 of file Configurable.py.

    def getDlls( self ):
        return None

def GaudiKernel.Configurable.ConfigurableUser.getGaudiType

(

self

)

Definition at line 1200 of file Configurable.py.

    def getGaudiType( self ):
        return 'User'

def GaudiKernel.Configurable.ConfigurableUser.getHandle

(

self

)

Definition at line 1204 of file Configurable.py.

    def getHandle( self ):
        return None

def GaudiKernel.Configurable.ConfigurableUser.getUsedInstance	(		self,
			name
	)

Return the used instance with a given name.

Definition at line 1305 of file Configurable.py.

    def getUsedInstance(self, name):
        """
        Return the used instance with a given name.
        """
        for i in self.__used_instances__:
            if i.name() == name:
                if hasattr(i, "_enabled"):
                    # ensure that the instances retrieved through the method are
                    # enabled
                    i._enabled = True
                return i
        raise KeyError(name)

def GaudiKernel.Configurable.ConfigurableUser.isApplicable

(

self

)

Return True is the instance can be "applied".

Definition at line 1318 of file Configurable.py.

    def isApplicable(self):
        '''
        Return True is the instance can be "applied".
        '''
        return (not self.__users__) and (not self._applied)


# list of callables to be called after all the __apply_configuration__ are called.

def GaudiKernel.Configurable.ConfigurableUser.propagateProperties	(		self,
			names = None,
			others = None,
			force = True
	)

Call propagateProperty for each property listed in 'names'.
If 'names' is None, all the properties are propagated.

Definition at line 1265 of file Configurable.py.

    def propagateProperties(self, names = None, others = None, force = True):
        """
        Call propagateProperty for each property listed in 'names'.
        If 'names' is None, all the properties are propagated.
        """
        if names is None:
            # use all the non-private slots
            names = [ p for p in self.__slots__ if not p.startswith("_") ]
        for n in names:
            self.propagateProperty(n, others, force)

def GaudiKernel.Configurable.ConfigurableUser.propagateProperty	(		self,
			name,
			others = None,
			force = True
	)

Propagate the property 'name' (if set) to other configurables (if possible).
'others' can be:
    None:
propagate to all the entries in __used_configurables__
    a configurable instance:
propagate only to it
    list of configurable instances:
propagate to all of them.


The logic is:
- if the local property is set, the other property will be overwritten
- local property not set and other set => keep other
- local property not set and other not set => overwrite the default for
    ConfigurableUser instances and set the property for Configurables

Definition at line 1216 of file Configurable.py.

    def propagateProperty(self, name, others = None, force = True):
        """
        Propagate the property 'name' (if set) to other configurables (if possible).
        'others' can be:
            None:
                propagate to all the entries in __used_configurables__
            a configurable instance:
                propagate only to it
            list of configurable instances:
                propagate to all of them.


        The logic is:
        - if the local property is set, the other property will be overwritten
        - local property not set and other set => keep other
        - local property not set and other not set => overwrite the default for
            ConfigurableUser instances and set the property for Configurables
        """
        # transform 'others' to a list of configurable instances
        if others is None:
            others = self.__used_instances__
        elif type(others) not in [ list, tuple ] :
            others = [ others ]
        # these can be computed before the loop
        local_is_set = self.isPropertySet(name)
        value = self.getProp(name)
        # loop over the others that do have 'name' in their slots
        for other in [ o for o in others if name in o.__slots__ ]:
            # If self property is set, use it
            if local_is_set:
                if other.isPropertySet(name):
                    log.warning("Property '%(prop)s' is set in both '%(self)s' and '%(other)s', using '%(self)s.%(prop)s'"%
                                { "self": self.name(),
                                  "other": other.name(),
                                  "prop": name } )
                other.setProp(name, value)
            # If not, and other property also not set, propagate the default
            elif not other.isPropertySet(name):
                if isinstance(other,ConfigurableUser):
                    otherType = type(other._properties[name].getDefault())
                    other._properties[name].setDefault(value)
                    if otherType in [list, dict]:
                        # Special case for list and dictionaries:
                        # also set the property to the same value of the default (copy)
                        other.setProp(name, otherType(value))
                else:
                    other.setProp(name, value)
            # If not set and other set, do nothing

Member Data Documentation

list GaudiKernel.Configurable.ConfigurableUser.__queried_configurables__ = []

staticprivate

list of ConfigurableUser classes this one is going to query in the apply_configuration method

Definition at line 1137 of file Configurable.py.

dictionary GaudiKernel.Configurable.ConfigurableUser.__slots__

staticprivate

Initial value:

= { "__users__": [],
                  "__used_instances__": [],
                  "_enabled": True,
                  "_applied": False }

Definition at line 1122 of file Configurable.py.

list GaudiKernel.Configurable.ConfigurableUser.__used_configurables__ = []

staticprivate

list of ConfigurableUser classes this one is going to modify in the apply_configuration method.

The list may contain class objects, strings representing class objects or tuples with the class object (or a string) as first element and the instance name as second element. If the instance name is None or not present, the function instanceName() is used to determine the name of the instance (the default implementation returns "<this name></em><other name>".

Definition at line 1134 of file Configurable.py.

GaudiKernel.Configurable.ConfigurableUser.__used_instances__

private

Definition at line 1152 of file Configurable.py.

GaudiKernel.Configurable.ConfigurableUser.__users__

private

Definition at line 1143 of file Configurable.py.

GaudiKernel.Configurable.ConfigurableUser._applied

private

Definition at line 1144 of file Configurable.py.

GaudiKernel.Configurable.ConfigurableUser._enabled

private

Definition at line 1142 of file Configurable.py.

---

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

• GaudiKernel/python/GaudiKernel/Configurable.py