| # Gaudi Framework, version v22r0 |

Home |  | Generated: 9 Feb 2011

# Configurable::ConfigurableUser Class Reference

Inheritance diagram for Configurable::ConfigurableUser:
[legend]
Collaboration diagram for Configurable::ConfigurableUser:
[legend]

List of all members.

## Public Member Functions
def | __init__
def | getGaudiType
def | getDlls
def | getHandle
def | __detach_used__
def | propagateProperty
def | propagateProperties
def | __apply_configuration__
def | applyConf
def | getUsedInstance
## Private Member Functions
def | __addActiveUseOf
def | __addPassiveUseOf
def | _instanceName
## Private Attributes
| _enabled
| __users__
| __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.
list | __queried_configurables__ = []
| list of ConfigurableUser classes this one is going to query in the __apply_configuration__ method

## Detailed Description

Definition at line 1112 of file Configurable.py.

## Member Function Documentation

def Configurable::ConfigurableUser::__addActiveUseOf | ( |  | self,
|  |  | other |
| ) |  |  | `[private]`

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

Definition at line 1173 of file Configurable.py.

    01174                                      :
    01175         """
    01176         Declare that we are going to modify the Configurable 'other' in our
    01177         __apply_configuration__.
    01178         """
    01179         self.__used_instances__.append(other)
    01180         if hasattr(other, "__users__"): # allow usage of plain Configurables
                other.__users__.append(self)

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

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

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

    01266                                      :
    01267         """
    01268         Function to be overridden to convert the high level configuration into a
    01269         low level one.
    01270         The default implementation calls applyConf, which is the method defined
    01271         in some ConfigurableUser implementations.
    01272         """
    01273         return self.applyConf()

def Configurable::ConfigurableUser::__detach_used__ | ( |  | self | ) |

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

Definition at line 1196 of file Configurable.py.

    01197                              :
    01198         """
    01199         Remove this ConfigurableUser instance from the users list of the used
    01200         instances.
    01201         """
    01202         for used in self.__used_instances__:
    01203             if hasattr(used, "__users__"): # allow usage of plain Configurables
    01204                 used.__users__.remove(self)

def Configurable::ConfigurableUser::__init__ | ( |  | self,
|  |  | name = `Configurable.DefaultName`,
|  |  | _enabled = `True`,
|  |  | kwargs |
| ) |  |  |

Definition at line 1128 of file Configurable.py.

    01129                                                                                     :
    01130         super( ConfigurableUser, self ).__init__( name )
    01131         for n, v in kwargs.items():
    01132             setattr(self, n, v)
    01133         self._enabled = _enabled
    01134         self.__users__ = []
    01135
    01136         # Needed to retrieve the actual class if the declaration in __used_configurables__
    01137         # and  __queried_configurables__ is done with strings.
    01138         from GaudiKernel.ConfigurableDb import getConfigurable as confDbGetConfigurable
    01139
    01140         # Set the list of users of the used configurables
    01141         #
    01142         self.__used_instances__ = []
    01143         for used in self.__used_configurables__:
    01144             # By default we want to use the default name of the instances
    01145             # for the used configurables
    01146             used_name = Configurable.DefaultName
    01147             # If the entry in the list is a tuple, we need a named instance
    01148             if type(used) is tuple:
    01149                 used, used_name = used # we re-set used to re-use the code below
    01150                 if not used_name:
    01151                     used_name = self._instanceName(used)
    01152             # Check is 'used' is a string or not
    01153             if type(used) is str:
    01154                 used_class = confDbGetConfigurable(used)
    01155             else:
    01156                 used_class = used
    01157             # Instantiate the configurable that we are going to use
    01158             try:
    01159                 inst = used_class(name = used_name, _enabled = False)
    01160             except AttributeError:
    01161                 # This cover the case where the used configurable is not a
    01162                 # ConfigurableUser instance, i.e. id doesn't have the attribute
    01163                 # '_enabled'.
    01164                 inst = used_class(name = used_name)
    01165             self.__addActiveUseOf(inst)
    01166         for queried in self.__queried_configurables__:
    01167             try:
    01168                 if type(queried) is str:
    01169                     queried = confDbGetConfigurable(used)
    01170                 inst = queried(_enabled = False)
    01171             except AttributeError:
    01172                 inst = queried()
                self.__addPassiveUseOf(inst)

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

    01282                                 :
    01283         """
    01284         Function used to define the name of the private instance of a given class
    01285         name.
    01286         This method is used when the __used_configurables_property__ declares the
    01287         need of a private used configurable without specifying the name.
    01288         """
    01289         if type(cls) is str:
    01290             clName = cls
    01291         else:
    01292             clName = cls.__name__
    01293         return "%s_%s" % (self.name(), clName)

def Configurable::ConfigurableUser::applyConf | ( |  | self | ) |

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

Definition at line 1274 of file Configurable.py.

    01275                          :
    01276         """
    01277         Function to be overridden to convert the high level configuration into a
    01278         low level one.
    01279         """
    01280         pass

def Configurable::ConfigurableUser::getDlls | ( |  | self | ) |

Definition at line 1191 of file Configurable.py.

    01192                        :
            return None

def Configurable::ConfigurableUser::getGaudiType | ( |  | self | ) |

Definition at line 1189 of file Configurable.py.

    01190                             :
            return 'User'

def Configurable::ConfigurableUser::getHandle | ( |  | self | ) |

Definition at line 1193 of file Configurable.py.

    01194                          :
    01195         return None

def Configurable::ConfigurableUser::getUsedInstance | ( |  | self,
|  |  | name |
| ) |  |  |

    Return the used instance with a given name.

Definition at line 1294 of file Configurable.py.

    01295                                    :
    01296         """
    01297         Return the used instance with a given name.
    01298         """
    01299         for i in self.__used_instances__:
    01300             if i.name() == name:
    01301                 if hasattr(i, "_enabled"):
    01302                     # ensure that the instances retrieved through the method are
    01303                     # enabled
    01304                     i._enabled = True
    01305                 return i
    01306         raise KeyError(name)
    01307
    # list of callables to be called after all the __apply_configuration__ are called.

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

    01255                                                                             :
    01256         """
    01257         Call propagateProperty for each property listed in 'names'.
    01258         If 'names' is None, all the properties are propagated.
    01259         """
    01260         if names is None:
    01261             # use all the non-private slots
    01262             names = [ p for p in self.__slots__ if not p.startswith("_") ]
    01263         for n in names:
    01264             self.propagateProperty(n, others, force)

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

    01206                                                                   :
    01207         """
    01208         Propagate the property 'name' (if set) to other configurables (if possible).
    01209         'others' can be:
    01210             None:
    01211                 propagate to all the entries in __used_configurables__
    01212             a configurable instance:
    01213                 propagate only to it
    01214             list of configurable instances:
    01215                 propagate to all of them.
    01216
    01217
    01218         The logic is:
    01219         - if the local property is set, the other property will be overwritten
    01220         - local property not set and other set => keep other
    01221         - local property not set and other not set => overwrite the default for
    01222             ConfigurableUser instances and set the property for Configurables
    01223         """
    01224         # transform 'others' to a list of configurable instances
    01225         if others is None:
    01226             others = self.__used_instances__
    01227         elif type(others) not in [ list, tuple ] :
    01228             others = [ others ]
    01229         # these can be computed before the loop
    01230         local_is_set = self.isPropertySet(name)
    01231         value = self.getProp(name)
    01232         # loop over the others that do have 'name' in their slots
    01233         for other in [ o for o in others if name in o.__slots__ ]:
    01234             # If self property is set, use it
    01235             if local_is_set:
    01236                 if other.isPropertySet(name):
    01237                     log.warning("Property '%(prop)s' is set in both '%(self)s' and '%(other)s', using '%(self)s.%(prop)s'"%
    01238                                 { "self": self.name(),
    01239                                   "other": other.name(),
    01240                                   "prop": name } )
    01241                 other.setProp(name, value)
    01242             # If not, and other property also not set, propagate the default
    01243             elif not other.isPropertySet(name):
    01244                 if isinstance(other,ConfigurableUser):
    01245                     otherType = type(other._properties[name].getDefault())
    01246                     other._properties[name].setDefault(value)
    01247                     if otherType in [list, dict]:
    01248                         # Special case for list and dictionaries:
    01249                         # also set the property to the same value of the default (copy)
    01250                         other.setProp(name, otherType(value))
    01251                 else:
    01252                     other.setProp(name, value)
    01253             # If not set and other set, do nothing

## Member Data Documentation

list Configurable::ConfigurableUser::__queried_configurables__ = []`[static, private]`

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

Definition at line 1127 of file Configurable.py.

dictionary Configurable::ConfigurableUser::__slots__`[static, private]`

Initial value:

    { "__users__": [],
                      "__used_instances__": [],
                      "_enabled": True }

Reimplemented from Configurable::Configurable.

Definition at line 1113 of file Configurable.py.

list Configurable::ConfigurableUser::__used_configurables__ = []`[static, private]`

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>_<other name>".

Definition at line 1124 of file Configurable.py.

Configurable::ConfigurableUser::__used_instances__`[private]`

Definition at line 1141 of file Configurable.py.

Configurable::ConfigurableUser::__users__`[private]`

Definition at line 1133 of file Configurable.py.

Configurable::ConfigurableUser::_enabled`[private]`

Definition at line 1132 of file Configurable.py.

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

- /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v22r0/GaudiKernel/python/GaudiKernel/Configurable.py

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Defines