Inheritance diagram for SequenceTypes::_ModuleSequenceType:

Public Member Functions
def	__iadd__
def	__imul__
def	__init__
def	__repr__
def	__setattr__
def	__str__
def	copy
def	copyAndExclude
def	dumpConfig
def	dumpPython
def	dumpSequenceConfig
def	dumpSequencePython
def	expandAndClone
def	index
def	insert
def	insertInto
def	isFrozen
def	moduleNames
def	nameInProcessDesc_
def	remove
def	replace
def	resolve
def	setIsFrozen
def	visit
Private Member Functions
def	_place
def	_postProcessFixup
Private Attributes
	_isFrozen
	_isModified
	_seq

Detailed Description

Base class for classes which define a sequence of modules

Definition at line 107 of file SequenceTypes.py.

Constructor & Destructor Documentation

def SequenceTypes::_ModuleSequenceType::__init__	(	self,
		arg,
		argv
	)

Reimplemented in SequenceTypes::Path, SequenceTypes::EndPath, and SequenceTypes::Sequence.

Definition at line 109 of file SequenceTypes.py.

00110                                    :
00111         self.__dict__["_isFrozen"] = False
00112         self._seq = None
00113         if len(arg) > 1:
00114             typename = format_typename(self)
00115             msg = format_outerframe(2) 
00116             msg += "%s takes exactly one input value. But the following ones are given:\n" %typename
00117             for item,i in zip(arg, xrange(1,20)):
00118                 msg += "    %i) %s \n"  %(i, item._errorstr())
00119             msg += "Maybe you forgot to combine them via '*' or '+'."     
00120             raise TypeError(msg)
00121         if len(arg)==1:
00122             _checkIfSequenceable(self, arg[0])
00123             self._seq = _SequenceCollection()
00124             arg[0]._appendToCollection(self._seq._collection)
        self._isModified = False

Member Function Documentation

def SequenceTypes::_ModuleSequenceType::__iadd__	(	self,
		rhs
	)

Definition at line 137 of file SequenceTypes.py.

00138                           :
00139         _checkIfSequenceable(self, rhs)
00140         if self._seq is None:
00141             self.__dict__["_seq"] = _SequenceCollection()
00142         self._seq += rhs
        return self

def SequenceTypes::_ModuleSequenceType::__imul__	(	self,
		rhs
	)

Definition at line 131 of file SequenceTypes.py.

00132                           :
00133         _checkIfSequenceable(self, rhs)
00134         if self._seq is None:
00135             self.__dict__["_seq"] = _SequenceCollection()
00136         self._seq+=rhs
        return self

def SequenceTypes::_ModuleSequenceType::__repr__ ( self )

Definition at line 176 of file SequenceTypes.py.

00177                       :
00178         s = ''
00179         if self._seq is not None:
00180            s = str(self._seq)
        return "cms."+type(self).__name__+'('+s+')\n'

def SequenceTypes::_ModuleSequenceType::__setattr__	(	self,
		name,
		value
	)

Definition at line 240 of file SequenceTypes.py.

00241                                     :
00242         if not name.startswith("_"):
00243             raise AttributeError, "You cannot set parameters for sequence like objects."
00244         else:
            self.__dict__[name] = value

def SequenceTypes::_ModuleSequenceType::__str__ ( self )

Reimplemented from Mixins::_Labelable.

Definition at line 143 of file SequenceTypes.py.

00144                      :
        return str(self._seq)

def SequenceTypes::_ModuleSequenceType::_place	(	self,
		name,
		proc
	)	`[private]`

Definition at line 129 of file SequenceTypes.py.

00130                               :
        self._placeImpl(name,proc)

def SequenceTypes::_ModuleSequenceType::_postProcessFixup	(	self,
		lookuptable
	)	`[private]`

Definition at line 205 of file SequenceTypes.py.

00206                                            :
00207         self._seq = self._seq._clonesequence(lookuptable)
        return self

def SequenceTypes::_ModuleSequenceType::copy ( self )

Definition at line 187 of file SequenceTypes.py.

00188                   :
00189         returnValue =_ModuleSequenceType.__new__(type(self))
00190         if self._seq is not None:
00191             returnValue.__init__(self._seq)
00192         else:
00193             returnValue.__init__()
        return returnValue

def SequenceTypes::_ModuleSequenceType::copyAndExclude	(	self,
		listOfModulesToExclude
	)

Returns a copy of the sequence which exlcudes those module in 'listOfModulesToExclude'

Definition at line 194 of file SequenceTypes.py.

00195                                                    :
00196         """Returns a copy of the sequence which exlcudes those module in 'listOfModulesToExclude'"""
00197         v = _CopyAndExcludeSequenceVisitor(listOfModulesToExclude)
00198         self.visit(v)
00199         result = self.__new__(type(self))
00200         result.__init__(v.result())
        return result

def SequenceTypes::_ModuleSequenceType::dumpConfig	(	self,
		options
	)

Definition at line 145 of file SequenceTypes.py.

00146                                  :
00147         s = ''
00148         if self._seq is not None:
00149             s = self._seq.dumpSequenceConfig()
        return '{'+s+'}\n'

def SequenceTypes::_ModuleSequenceType::dumpPython	(	self,
		options
	)

Returns a string which is the python representation of the object

Definition at line 150 of file SequenceTypes.py.

00151                                  :
00152         """Returns a string which is the python representation of the object"""
00153         s=''
00154         if self._seq is not None:
00155             s =self._seq.dumpSequencePython()
        return 'cms.'+type(self).__name__+'('+s+')\n'

def SequenceTypes::_ModuleSequenceType::dumpSequenceConfig ( self )

Returns a string which contains the old config language representation of just the internal sequence

Reimplemented from Mixins::_Labelable.

Definition at line 166 of file SequenceTypes.py.

00167                                 :
00168         """Returns a string which contains the old config language representation of just the internal sequence"""
00169         # only dump the label, if possible
00170         if self.hasLabel_():
00171             return _Labelable.dumpSequenceConfig(self)
00172         else:
00173             # dump it verbose
00174             if self._seq is None:
00175                 return ''
            return '('+self._seq.dumpSequenceConfig()+')'

def SequenceTypes::_ModuleSequenceType::dumpSequencePython ( self )

Returns a string which contains the python representation of just the internal sequence

Reimplemented from Mixins::_Labelable.

Definition at line 156 of file SequenceTypes.py.

00157                                 :
00158         """Returns a string which contains the python representation of just the internal sequence"""
00159         # only dump the label, if possible
00160         if self.hasLabel_():
00161             return _Labelable.dumpSequencePython(self)
00162         else:
00163             # dump it verbose
00164             if self._seq is None:
00165                 return ''
            return '('+self._seq.dumpSequencePython()+')'

def SequenceTypes::_ModuleSequenceType::expandAndClone ( self )

Definition at line 201 of file SequenceTypes.py.

00202                             :
00203         visitor = ExpandVisitor(type(self))
00204         self.visit(visitor)
        return visitor.result()

def SequenceTypes::_ModuleSequenceType::index	(	self,
		item
	)

Returns the index at which the item is found or raises an exception

Definition at line 219 of file SequenceTypes.py.

00220                         :
00221         """Returns the index at which the item is found or raises an exception"""
00222         if self._seq is not None:
00223             return self._seq.index(item)
        raise ValueError(str(item)+" is not in the sequence")

def SequenceTypes::_ModuleSequenceType::insert	(	self,
		index,
		item
	)

Inserts the item at the index specified

Definition at line 224 of file SequenceTypes.py.

00225                                :
00226         """Inserts the item at the index specified"""
00227         _checkIfSequenceable(self, item)
        self._seq.insert(index,item)

def SequenceTypes::_ModuleSequenceType::insertInto	(	self,
		parameterSet,
		myname,
		processDict
	)

Definition at line 258 of file SequenceTypes.py.

00259                                                            :
00260         # represented just as a list of names in the ParameterSet
00261         l = []
00262         #resolver = ResolveVisitor(processDict)
00263         lister = DecoratedNodeNameVisitor(l)
00264         #self.visit(resolver)
00265         self.resolve(processDict)
00266         self.visit(lister)
        parameterSet.addVString(True, myname, l)

def SequenceTypes::_ModuleSequenceType::isFrozen ( self )

Definition at line 125 of file SequenceTypes.py.

00126                       :
        return self._isFrozen

def SequenceTypes::_ModuleSequenceType::moduleNames ( self )

Returns a set containing the names of all modules being used

Definition at line 181 of file SequenceTypes.py.

00182                          :
00183         """Returns a set containing the names of all modules being used"""
00184         result = set()
00185         visitor = NodeNameVisitor(result)
00186         self.visit(visitor)
        return result

def SequenceTypes::_ModuleSequenceType::nameInProcessDesc_	(	self,
		myname
	)

Definition at line 256 of file SequenceTypes.py.

00257                                         :
        return myname

def SequenceTypes::_ModuleSequenceType::remove	(	self,
		something
	)

Remove the first occurrence of 'something' (a sequence or a module)
   Returns 'True' if the module has been removed, False if it was not found

Definition at line 228 of file SequenceTypes.py.

00229                                :
00230         """Remove the first occurrence of 'something' (a sequence or a module)
00231            Returns 'True' if the module has been removed, False if it was not found"""
00232         v = _CopyAndRemoveFirstSequenceVisitor(something)
00233         self.visit(v)
00234         if v.didRemove():
00235             self._seq = v.result()
        return v.didRemove()

def SequenceTypes::_ModuleSequenceType::replace	(	self,
		original,
		replacement
	)

Finds all instances of 'original' and substitutes 'replacement' for them.
   Returns 'True' if a replacement occurs.

Definition at line 208 of file SequenceTypes.py.

00209                                             :
00210         """Finds all instances of 'original' and substitutes 'replacement' for them.
00211            Returns 'True' if a replacement occurs."""
00212         if not isinstance(original,_Sequenceable) or not isinstance(replacement,_Sequenceable):
00213            raise TypeError("replace only works with sequenceable objects")
00214         else:
00215             v = _CopyAndReplaceSequenceVisitor(original,replacement)
00216             self.visit(v)
00217             if v.didReplace():
00218                 self._seq = v.result()
            return v.didReplace()

def SequenceTypes::_ModuleSequenceType::resolve	(	self,
		processDict
	)

Definition at line 236 of file SequenceTypes.py.

00237                                   :
00238         if self._seq is not None:
00239             self._seq = self._seq.resolve(processDict)
        return self

def SequenceTypes::_ModuleSequenceType::setIsFrozen ( self )

Definition at line 127 of file SequenceTypes.py.

00128                          :
        self._isFrozen = True

def SequenceTypes::_ModuleSequenceType::visit	(	self,
		visitor
	)

Passes to visitor's 'enter' and 'leave' method each item describing the module sequence.
If the item contains 'sub' items then visitor will see those 'sub' items between the
item's 'enter' and 'leave' calls.

Definition at line 267 of file SequenceTypes.py.

00268                            :
00269         """Passes to visitor's 'enter' and 'leave' method each item describing the module sequence.
00270         If the item contains 'sub' items then visitor will see those 'sub' items between the
00271         item's 'enter' and 'leave' calls.
00272         """
00273         if self._seq is not None:
00274             self._seq.visitNode(visitor)

Member Data Documentation

SequenceTypes::_ModuleSequenceType::_isFrozen [private]

Definition at line 127 of file SequenceTypes.py.

SequenceTypes::_ModuleSequenceType::_isModified [private]

Definition at line 109 of file SequenceTypes.py.

SequenceTypes::_ModuleSequenceType::_seq [private]

Definition at line 109 of file SequenceTypes.py.

SequenceTypes::_ModuleSequenceType Class Reference

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation