| # Gaudi Framework, version v25r0 |

Home |  | Generated: Mon Feb 17 2014

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- Class List
- Class Index
- Class Hierarchy
- Class Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
Public Member Functions | Private Member Functions | Private Attributes | Static Private Attributes | List of all members
GaudiKernel.Configurable.ConfigurableUser Class Reference
Inheritance diagram for GaudiKernel.Configurable.ConfigurableUser:
[legend]
Collaboration diagram for GaudiKernel.Configurable.ConfigurableUser:
[legend]

## 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
def | isApplicable
Public Member Functions inherited from GaudiKernel.Configurable.Configurable
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__

## Private Member Functions
def | __addActiveUseOf
def | __addPassiveUseOf
def | _instanceName

## 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.
list | __queried_configurables__ []
| list of ConfigurableUser classes this one is going to query in the apply_configuration method

## 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 1120 of file Configurable.py.

## Constructor & Destructor Documentation

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

Definition at line 1137 of file Configurable.py.

1137
1138 def __init__( self, name = Configurable.DefaultName, _enabled = True, **kwargs ):
1139 super( ConfigurableUser, self ).__init__( name )
1140 for n, v in kwargs.items():
1141 setattr(self, n, v)
1142 self._enabled = _enabled
1143 self.__users__ = []
1144 self._applied = False
1145
1146 # Needed to retrieve the actual class if the declaration in __used_configurables__
1147 # and __queried_configurables__ is done with strings.
1148 from GaudiKernel.ConfigurableDb import getConfigurable as confDbGetConfigurable
1149
1150 # Set the list of users of the used configurables
1151 #
1152 self.__used_instances__ = []
1153 for used in self.__used_configurables__:
1154 # By default we want to use the default name of the instances
1155 # for the used configurables
1156 used_name = Configurable.DefaultName
1157 # If the entry in the list is a tuple, we need a named instance
1158 if type(used) is tuple:
1159 used, used_name = used # we re-set used to re-use the code below
1160 if not used_name:
1161 used_name = self._instanceName(used)
1162 # Check is 'used' is a string or not
1163 if type(used) is str:
1164 used_class = confDbGetConfigurable(used)
1165 else:
1166 used_class = used
1167 # Instantiate the configurable that we are going to use
1168 try:
1169 inst = used_class(name = used_name, _enabled = False)
1170 except AttributeError:
1171 # This cover the case where the used configurable is not a
1172 # ConfigurableUser instance, i.e. id doesn't have the attribute
1173 # '_enabled'.
1174 inst = used_class(name = used_name)
1175 self.__addActiveUseOf(inst)
1176 for queried in self.__queried_configurables__:
1177 try:
1178 if type(queried) is str:
1179 queried = confDbGetConfigurable(used)
1180 inst = queried(_enabled = False)
1181 except AttributeError:
1182 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 1183 of file Configurable.py.

1183
1184 def __addActiveUseOf(self, other):
1185 """
1186 Declare that we are going to modify the Configurable 'other' in our
1187 __apply_configuration__.
1188 """
1189 self.__used_instances__.append(other)
1190 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 1191 of file Configurable.py.

1191
1192 def __addPassiveUseOf(self, other):
1193 """
1194 Declare that we are going to retrieve property values from the
1195 ConfigurableUser 'other' in our __apply_configuration__.
1196 """
1197 if not isinstance(other, ConfigurableUser):
1198 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 1275 of file Configurable.py.

1275
1276 def __apply_configuration__(self):
1277 """
1278 Function to be overridden to convert the high level configuration into a
1279 low level one.
1280 The default implementation calls applyConf, which is the method defined
1281 in some ConfigurableUser implementations.
1282 """
1283 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 1206 of file Configurable.py.

1206
1207 def __detach_used__(self):
1208 """
1209 Remove this ConfigurableUser instance from the users list of the used
1210 instances.
1211 """
1212 for used in self.__used_instances__:
1213 if hasattr(used, "__users__"): # allow usage of plain Configurables
1214 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 1291 of file Configurable.py.

1291
1292 def _instanceName(self, cls):
1293 """
1294 Function used to define the name of the private instance of a given class
1295 name.
1296 This method is used when the __used_configurables_property__ declares the
1297 need of a private used configurable without specifying the name.
1298 """
1299 if type(cls) is str:
1300 clName = cls
1301 else:
1302 clName = cls.__name__
1303 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 1284 of file Configurable.py.

1284
1285 def applyConf( self ):
1286 """
1287 Function to be overridden to convert the high level configuration into a
1288 low level one.
1289 """
1290 pass

def GaudiKernel.Configurable.ConfigurableUser.getDlls | ( |  | self | ) |

Definition at line 1201 of file Configurable.py.

1201
1202 def getDlls( self ):
return None

def GaudiKernel.Configurable.ConfigurableUser.getGaudiType | ( |  | self | ) |

Definition at line 1199 of file Configurable.py.

1199
1200 def getGaudiType( self ):
return 'User'

def GaudiKernel.Configurable.ConfigurableUser.getHandle | ( |  | self | ) |

Definition at line 1203 of file Configurable.py.

1203
1204 def getHandle( self ):
1205 return None

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

    Return the used instance with a given name.

Definition at line 1304 of file Configurable.py.

1304
1305 def getUsedInstance(self, name):
1306 """
1307 Return the used instance with a given name.
1308 """
1309 for i in self.__used_instances__:
1310 if i.name() == name:
1311 if hasattr(i, "_enabled"):
1312 # ensure that the instances retrieved through the method are
1313 # enabled
1314 i._enabled = True
1315 return i
1316 raise KeyError(name)

def GaudiKernel.Configurable.ConfigurableUser.isApplicable | ( |  | self | ) |

    Return True is the instance can be "applied".

Definition at line 1317 of file Configurable.py.

1317
1318 def isApplicable(self):
1319 '''
1320 Return True is the instance can be "applied".
1321 '''
1322 return (not self.__users__) and (not self._applied)
1323
1324
# 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 1264 of file Configurable.py.

1264
1265 def propagateProperties(self, names = None, others = None, force = True):
1266 """
1267 Call propagateProperty for each property listed in 'names'.
1268 If 'names' is None, all the properties are propagated.
1269 """
1270 if names is None:
1271 # use all the non-private slots
1272 names = [ p for p in self.__slots__ if not p.startswith("_") ]
1273 for n in names:
1274 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 1215 of file Configurable.py.

1215
1216 def propagateProperty(self, name, others = None, force = True):
1217 """
1218 Propagate the property 'name' (if set) to other configurables (if possible).
1219 'others' can be:
1220 None:
1221 propagate to all the entries in __used_configurables__
1222 a configurable instance:
1223 propagate only to it
1224 list of configurable instances:
1225 propagate to all of them.
1226
1227
1228 The logic is:
1229 - if the local property is set, the other property will be overwritten
1230 - local property not set and other set => keep other
1231 - local property not set and other not set => overwrite the default for
1232 ConfigurableUser instances and set the property for Configurables
1233 """
1234 # transform 'others' to a list of configurable instances
1235 if others is None:
1236 others = self.__used_instances__
1237 elif type(others) not in [ list, tuple ] :
1238 others = [ others ]
1239 # these can be computed before the loop
1240 local_is_set = self.isPropertySet(name)
1241 value = self.getProp(name)
1242 # loop over the others that do have 'name' in their slots
1243 for other in [ o for o in others if name in o.__slots__ ]:
1244 # If self property is set, use it
1245 if local_is_set:
1246 if other.isPropertySet(name):
1247 log.warning("Property '%(prop)s' is set in both '%(self)s' and '%(other)s', using '%(self)s.%(prop)s'"%
1248 { "self": self.name(),
1249 "other": other.name(),
1250 "prop": name } )
1251 other.setProp(name, value)
1252 # If not, and other property also not set, propagate the default
1253 elif not other.isPropertySet(name):
1254 if isinstance(other,ConfigurableUser):
1255 otherType = type(other._properties[name].getDefault())
1256 other._properties[name].setDefault(value)
1257 if otherType in [list, dict]:
1258 # Special case for list and dictionaries:
1259 # also set the property to the same value of the default (copy)
1260 other.setProp(name, otherType(value))
1261 else:
1262 other.setProp(name, value)
1263 # If not set and other set, do nothing

## Member Data Documentation

list GaudiKernel.Configurable.ConfigurableUser.__queried_configurables__ []
| static private

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

Definition at line 1136 of file Configurable.py.

dictionary GaudiKernel.Configurable.ConfigurableUser.__slots__
| static private

Initial value:
1 { "__users__": [],
2 "__used_instances__": [],
3 "_enabled": True,
4 "_applied": False }

Definition at line 1121 of file Configurable.py.

list GaudiKernel.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></em><other name>".

Definition at line 1133 of file Configurable.py.

GaudiKernel.Configurable.ConfigurableUser.__used_instances__
| private

Definition at line 1151 of file Configurable.py.

GaudiKernel.Configurable.ConfigurableUser.__users__
| private

Definition at line 1142 of file Configurable.py.

GaudiKernel.Configurable.ConfigurableUser._applied
| private

Definition at line 1143 of file Configurable.py.

GaudiKernel.Configurable.ConfigurableUser._enabled
| private

Definition at line 1141 of file Configurable.py.

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

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