Passed
Push — master ( f1e3b2...b13a8b )
by Peter
01:02
created

ore.models.xml_faulttree   B

Complexity

Total Complexity 29

Size/Duplication

Total Lines 2023
Duplicated Lines 67.92 %

Importance

Changes 0
Metric Value
wmc 29
eloc 1243
dl 1374
loc 2023
rs 8.8
c 0
b 0
f 0

How to fix   Duplicated Code   

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

1
# ore/models/xml_faulttree.py
2
# -*- coding: utf-8 -*-
3
# PyXB bindings for NM:0c3643272b4de760c38b0556be1c2c4346c7368c
4
# Generated 2019-01-09 14:06:28.478291 by PyXB version 1.2.6 using Python 2.7.15.candidate.1
5
# Namespace net.faulttree
6
7
from __future__ import unicode_literals
8
import pyxb
9
import pyxb.binding
10
import pyxb.binding.saxer
11
import io
12
import pyxb.utils.utility
13
import pyxb.utils.domutils
14
import sys
15
import pyxb.utils.six as _six
16
# Unique identifier for bindings created at the same time
17
_GenerationUID = pyxb.utils.utility.UniqueIdentifier('urn:uuid:c1f84e9a-1417-11e9-9981-0242c0a83004')
18
19
# Version of PyXB used to generate the bindings
20
_PyXBVersion = '1.2.6'
21
# Generated bindings are not compatible across PyXB versions
22
if pyxb.__version__ != _PyXBVersion:
23
    raise pyxb.PyXBVersionError(_PyXBVersion)
24
25
# A holder for module-level binding classes so we can access them from
26
# inside class definitions where property names may conflict.
27
_module_typeBindings = pyxb.utils.utility.Object()
28
29
# Import bindings for namespaces imported into schema
30
import pyxb.binding.datatypes
31
32
# NOTE: All namespace declarations are reserved within the binding
33
Namespace = pyxb.namespace.NamespaceForURI('net.faulttree', create_if_missing=True)
34
Namespace.configureCategories(['typeBinding', 'elementBinding'])
35
36
def CreateFromDocument (xml_text, default_namespace=None, location_base=None):
37
    """Parse the given XML and use the document element to create a
38
    Python instance.
39
40
    @param xml_text An XML document.  This should be data (Python 2
41
    str or Python 3 bytes), or a text (Python 2 unicode or Python 3
42
    str) in the L{pyxb._InputEncoding} encoding.
43
44
    @keyword default_namespace The L{pyxb.Namespace} instance to use as the
45
    default namespace where there is no default namespace in scope.
46
    If unspecified or C{None}, the namespace of the module containing
47
    this function will be used.
48
49
    @keyword location_base: An object to be recorded as the base of all
50
    L{pyxb.utils.utility.Location} instances associated with events and
51
    objects handled by the parser.  You might pass the URI from which
52
    the document was obtained.
53
    """
54
55
    if pyxb.XMLStyle_saxer != pyxb._XMLStyle:
56
        dom = pyxb.utils.domutils.StringToDOM(xml_text)
57
        return CreateFromDOM(dom.documentElement, default_namespace=default_namespace)
58
    if default_namespace is None:
59
        default_namespace = Namespace.fallbackNamespace()
60
    saxer = pyxb.binding.saxer.make_parser(fallback_namespace=default_namespace, location_base=location_base)
61
    handler = saxer.getContentHandler()
62
    xmld = xml_text
63
    if isinstance(xmld, _six.text_type):
64
        xmld = xmld.encode(pyxb._InputEncoding)
65
    saxer.parse(io.BytesIO(xmld))
66
    instance = handler.rootObject()
67
    return instance
68
69
def CreateFromDOM (node, default_namespace=None):
70
    """Create a Python instance from the given DOM node.
71
    The node tag must correspond to an element declaration in this module.
72
73
    @deprecated: Forcing use of DOM interface is unnecessary; use L{CreateFromDocument}."""
74
    if default_namespace is None:
75
        default_namespace = Namespace.fallbackNamespace()
76
    return pyxb.binding.basis.element.AnyCreateFromDOM(node, default_namespace)
77
78
79
# List simple type: {net.faulttree}idlist
80
# superclasses pyxb.binding.datatypes.anySimpleType
81
class idlist (pyxb.binding.basis.STD_list):
82
83
    """Simple type that is a list of pyxb.binding.datatypes.string."""
84
85
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'idlist')
86
    _XSDLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 186, 4)
87
    _Documentation = None
88
89
    _ItemType = pyxb.binding.datatypes.string
90
idlist._InitializeFacetMap()
91
Namespace.addCategoryObject('typeBinding', 'idlist', idlist)
92
_module_typeBindings.idlist = idlist
93
94
# Complex type {net.faulttree}Annotation with content type EMPTY
95
class Annotation (pyxb.binding.basis.complexTypeDefinition):
96
    """Complex type {net.faulttree}Annotation with content type EMPTY"""
97
    _TypeDefinition = None
98
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
99
    _Abstract = True
100
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'Annotation')
101
    _XSDLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 5, 4)
102
    _ElementMap = {}
103
    _AttributeMap = {}
104
    # Base type is pyxb.binding.datatypes.anyType
105
    _ElementMap.update({
106
        
107
    })
108
    _AttributeMap.update({
109
        
110
    })
111
_module_typeBindings.Annotation = Annotation
112
Namespace.addCategoryObject('typeBinding', 'Annotation', Annotation)
113
114
115
# Complex type {net.faulttree}Probability with content type EMPTY
116
class Probability (pyxb.binding.basis.complexTypeDefinition):
117
    """Complex type {net.faulttree}Probability with content type EMPTY"""
118
    _TypeDefinition = None
119
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
120
    _Abstract = True
121
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'Probability')
122
    _XSDLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 6, 4)
123
    _ElementMap = {}
124
    _AttributeMap = {}
125
    # Base type is pyxb.binding.datatypes.anyType
126
    _ElementMap.update({
127
        
128
    })
129
    _AttributeMap.update({
130
        
131
    })
132
_module_typeBindings.Probability = Probability
133
Namespace.addCategoryObject('typeBinding', 'Probability', Probability)
134
135
136
# Complex type {net.faulttree}AnnotatedElement with content type ELEMENT_ONLY
137
class AnnotatedElement (pyxb.binding.basis.complexTypeDefinition):
138
    """Complex type {net.faulttree}AnnotatedElement with content type ELEMENT_ONLY"""
139
    _TypeDefinition = None
140
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
141
    _Abstract = True
142
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'AnnotatedElement')
143
    _XSDLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 8, 4)
144
    _ElementMap = {}
145
    _AttributeMap = {}
146
    # Base type is pyxb.binding.datatypes.anyType
147
    
148
    # Element annotations uses Python identifier annotations
149
    __annotations = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'annotations'), 'annotations', '__net_faulttree_AnnotatedElement_annotations', True, pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12), )
150
151
    
152
    annotations = property(__annotations.value, __annotations.set, None, None)
153
154
    
155
    # Attribute id uses Python identifier id
156
    __id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__net_faulttree_AnnotatedElement_id', pyxb.binding.datatypes.string, required=True)
157
    __id._DeclarationLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 12, 8)
158
    __id._UseLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 12, 8)
159
    
160
    id = property(__id.value, __id.set, None, None)
161
162
    
163
    # Attribute name uses Python identifier name
164
    __name = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'name'), 'name', '__net_faulttree_AnnotatedElement_name', pyxb.binding.datatypes.string)
165
    __name._DeclarationLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 13, 8)
166
    __name._UseLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 13, 8)
167
    
168
    name = property(__name.value, __name.set, None, None)
169
170
    _ElementMap.update({
171
        __annotations.name() : __annotations
172
    })
173
    _AttributeMap.update({
174
        __id.name() : __id,
175
        __name.name() : __name
176
    })
177
_module_typeBindings.AnnotatedElement = AnnotatedElement
178
Namespace.addCategoryObject('typeBinding', 'AnnotatedElement', AnnotatedElement)
179
180
181
# Complex type {net.faulttree}Model with content type ELEMENT_ONLY
182
class Model (AnnotatedElement):
183
    """Complex type {net.faulttree}Model with content type ELEMENT_ONLY"""
184
    _TypeDefinition = None
185
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
186
    _Abstract = True
187
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'Model')
188
    _XSDLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 16, 4)
189
    _ElementMap = AnnotatedElement._ElementMap.copy()
190
    _AttributeMap = AnnotatedElement._AttributeMap.copy()
191
    # Base type is AnnotatedElement
192
    
193
    # Element annotations (annotations) inherited from {net.faulttree}AnnotatedElement
194
    
195
    # Attribute id inherited from {net.faulttree}AnnotatedElement
196
    
197
    # Attribute name inherited from {net.faulttree}AnnotatedElement
198
    _ElementMap.update({
199
        
200
    })
201
    _AttributeMap.update({
202
        
203
    })
204
_module_typeBindings.Model = Model
205
Namespace.addCategoryObject('typeBinding', 'Model', Model)
206
207
208
# Complex type {net.faulttree}Node with content type ELEMENT_ONLY
209
class Node (AnnotatedElement):
210
    """Complex type {net.faulttree}Node with content type ELEMENT_ONLY"""
211
    _TypeDefinition = None
212
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
213
    _Abstract = True
214
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'Node')
215
    _XSDLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 23, 4)
216
    _ElementMap = AnnotatedElement._ElementMap.copy()
217
    _AttributeMap = AnnotatedElement._AttributeMap.copy()
218
    # Base type is AnnotatedElement
219
    
220
    # Element annotations (annotations) inherited from {net.faulttree}AnnotatedElement
221
    
222
    # Element children uses Python identifier children
223
    __children = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'children'), 'children', '__net_faulttree_Node_children', True, pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20), )
224
225
    
226
    children = property(__children.value, __children.set, None, None)
227
228
    
229
    # Attribute id inherited from {net.faulttree}AnnotatedElement
230
    
231
    # Attribute name inherited from {net.faulttree}AnnotatedElement
232
    
233
    # Attribute x uses Python identifier x
234
    __x = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'x'), 'x', '__net_faulttree_Node_x', pyxb.binding.datatypes.int)
235
    __x._DeclarationLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 29, 16)
236
    __x._UseLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 29, 16)
237
    
238
    x = property(__x.value, __x.set, None, None)
239
240
    
241
    # Attribute y uses Python identifier y
242
    __y = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'y'), 'y', '__net_faulttree_Node_y', pyxb.binding.datatypes.int)
243
    __y._DeclarationLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 30, 16)
244
    __y._UseLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 30, 16)
245
    
246
    y = property(__y.value, __y.set, None, None)
247
248
    _ElementMap.update({
249
        __children.name() : __children
250
    })
251
    _AttributeMap.update({
252
        __x.name() : __x,
253
        __y.name() : __y
254
    })
255
_module_typeBindings.Node = Node
256
Namespace.addCategoryObject('typeBinding', 'Node', Node)
257
258
259
# Complex type {net.faulttree}CrispProbability with content type EMPTY
260
class CrispProbability (Probability):
261
    """Complex type {net.faulttree}CrispProbability with content type EMPTY"""
262
    _TypeDefinition = None
263
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
264
    _Abstract = False
265
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'CrispProbability')
266
    _XSDLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 63, 4)
267
    _ElementMap = Probability._ElementMap.copy()
268
    _AttributeMap = Probability._AttributeMap.copy()
269
    # Base type is Probability
270
    
271
    # Attribute value uses Python identifier value_
272
    __value = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'value'), 'value_', '__net_faulttree_CrispProbability_value', pyxb.binding.datatypes.double, required=True)
273
    __value._DeclarationLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 66, 16)
274
    __value._UseLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 66, 16)
275
    
276
    value_ = property(__value.value, __value.set, None, None)
277
278
    _ElementMap.update({
279
        
280
    })
281
    _AttributeMap.update({
282
        __value.name() : __value
283
    })
284
_module_typeBindings.CrispProbability = CrispProbability
285
Namespace.addCategoryObject('typeBinding', 'CrispProbability', CrispProbability)
286
287
288
# Complex type {net.faulttree}FailureRate with content type EMPTY
289
class FailureRate_ (Probability):
290
    """Complex type {net.faulttree}FailureRate with content type EMPTY"""
291
    _TypeDefinition = None
292
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
293
    _Abstract = False
294
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'FailureRate')
295
    _XSDLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 72, 4)
296
    _ElementMap = Probability._ElementMap.copy()
297
    _AttributeMap = Probability._AttributeMap.copy()
298
    # Base type is Probability
299
    
300
    # Attribute value uses Python identifier value_
301
    __value = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'value'), 'value_', '__net_faulttree_FailureRate__value', pyxb.binding.datatypes.double, required=True)
302
    __value._DeclarationLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 75, 16)
303
    __value._UseLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 75, 16)
304
    
305
    value_ = property(__value.value, __value.set, None, None)
306
307
    _ElementMap.update({
308
        
309
    })
310
    _AttributeMap.update({
311
        __value.name() : __value
312
    })
313
_module_typeBindings.FailureRate_ = FailureRate_
314
Namespace.addCategoryObject('typeBinding', 'FailureRate', FailureRate_)
315
316
317
# Complex type {net.faulttree}ChildNode with content type ELEMENT_ONLY
318
class ChildNode (Node):
319
    """Complex type {net.faulttree}ChildNode with content type ELEMENT_ONLY"""
320
    _TypeDefinition = None
321
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
322
    _Abstract = True
323
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ChildNode')
324
    _XSDLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 35, 4)
325
    _ElementMap = Node._ElementMap.copy()
326
    _AttributeMap = Node._AttributeMap.copy()
327
    # Base type is Node
328
    
329
    # Element annotations (annotations) inherited from {net.faulttree}AnnotatedElement
330
    
331
    # Element children (children) inherited from {net.faulttree}Node
332
    
333
    # Attribute id inherited from {net.faulttree}AnnotatedElement
334
    
335
    # Attribute name inherited from {net.faulttree}AnnotatedElement
336
    
337
    # Attribute x inherited from {net.faulttree}Node
338
    
339
    # Attribute y inherited from {net.faulttree}Node
340
    _ElementMap.update({
341
        
342
    })
343
    _AttributeMap.update({
344
        
345
    })
346
_module_typeBindings.ChildNode = ChildNode
347
Namespace.addCategoryObject('typeBinding', 'ChildNode', ChildNode)
348
349
350
# Complex type {net.faulttree}FaultTree with content type ELEMENT_ONLY
351
class FaultTree_ (Model):
352
    """Complex type {net.faulttree}FaultTree with content type ELEMENT_ONLY"""
353
    _TypeDefinition = None
354
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
355
    _Abstract = False
356
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'FaultTree')
357
    _XSDLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 42, 4)
358
    _ElementMap = Model._ElementMap.copy()
359
    _AttributeMap = Model._AttributeMap.copy()
360
    # Base type is Model
361
    
362
    # Element annotations (annotations) inherited from {net.faulttree}AnnotatedElement
363
    
364
    # Element topEvent uses Python identifier topEvent
365
    __topEvent = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'topEvent'), 'topEvent', '__net_faulttree_FaultTree__topEvent', False, pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 46, 20), )
366
367
    
368
    topEvent = property(__topEvent.value, __topEvent.set, None, None)
369
370
    
371
    # Attribute id inherited from {net.faulttree}AnnotatedElement
372
    
373
    # Attribute name inherited from {net.faulttree}AnnotatedElement
374
    _ElementMap.update({
375
        __topEvent.name() : __topEvent
376
    })
377
    _AttributeMap.update({
378
        
379
    })
380
_module_typeBindings.FaultTree_ = FaultTree_
381
Namespace.addCategoryObject('typeBinding', 'FaultTree', FaultTree_)
382
383
384
# Complex type {net.faulttree}TopEvent with content type ELEMENT_ONLY
385
class TopEvent_ (Node):
386
    """Complex type {net.faulttree}TopEvent with content type ELEMENT_ONLY"""
387
    _TypeDefinition = None
388
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
389
    _Abstract = False
390
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'TopEvent')
391
    _XSDLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 53, 4)
392
    _ElementMap = Node._ElementMap.copy()
393
    _AttributeMap = Node._AttributeMap.copy()
394
    # Base type is Node
395
    
396
    # Element annotations (annotations) inherited from {net.faulttree}AnnotatedElement
397
    
398
    # Element children (children) inherited from {net.faulttree}Node
399
    
400
    # Attribute id inherited from {net.faulttree}AnnotatedElement
401
    
402
    # Attribute name inherited from {net.faulttree}AnnotatedElement
403
    
404
    # Attribute x inherited from {net.faulttree}Node
405
    
406
    # Attribute y inherited from {net.faulttree}Node
407
    
408
    # Attribute missionTime uses Python identifier missionTime
409
    __missionTime = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'missionTime'), 'missionTime', '__net_faulttree_TopEvent__missionTime', pyxb.binding.datatypes.int)
410
    __missionTime._DeclarationLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 56, 16)
411
    __missionTime._UseLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 56, 16)
412
    
413
    missionTime = property(__missionTime.value, __missionTime.set, None, None)
414
415
    
416
    # Attribute decompositionNumber uses Python identifier decompositionNumber
417
    __decompositionNumber = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'decompositionNumber'), 'decompositionNumber', '__net_faulttree_TopEvent__decompositionNumber', pyxb.binding.datatypes.int)
418
    __decompositionNumber._DeclarationLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 57, 16)
419
    __decompositionNumber._UseLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 57, 16)
420
    
421
    decompositionNumber = property(__decompositionNumber.value, __decompositionNumber.set, None, None)
422
423
    _ElementMap.update({
424
        
425
    })
426
    _AttributeMap.update({
427
        __missionTime.name() : __missionTime,
428
        __decompositionNumber.name() : __decompositionNumber
429
    })
430
_module_typeBindings.TopEvent_ = TopEvent_
431
Namespace.addCategoryObject('typeBinding', 'TopEvent', TopEvent_)
432
433
434
# Complex type {net.faulttree}Gate with content type ELEMENT_ONLY
435
class Gate (ChildNode):
436
    """Complex type {net.faulttree}Gate with content type ELEMENT_ONLY"""
437
    _TypeDefinition = None
438
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
439
    _Abstract = True
440
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'Gate')
441
    _XSDLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 82, 4)
442
    _ElementMap = ChildNode._ElementMap.copy()
443
    _AttributeMap = ChildNode._AttributeMap.copy()
444
    # Base type is ChildNode
445
    
446
    # Element annotations (annotations) inherited from {net.faulttree}AnnotatedElement
447
    
448
    # Element children (children) inherited from {net.faulttree}Node
449
    
450
    # Attribute id inherited from {net.faulttree}AnnotatedElement
451
    
452
    # Attribute name inherited from {net.faulttree}AnnotatedElement
453
    
454
    # Attribute x inherited from {net.faulttree}Node
455
    
456
    # Attribute y inherited from {net.faulttree}Node
457
    _ElementMap.update({
458
        
459
    })
460
    _AttributeMap.update({
461
        
462
    })
463
_module_typeBindings.Gate = Gate
464
Namespace.addCategoryObject('typeBinding', 'Gate', Gate)
465
466
467
# Complex type {net.faulttree}TransferIn with content type ELEMENT_ONLY
468
class TransferIn_ (ChildNode):
469
    """Complex type {net.faulttree}TransferIn with content type ELEMENT_ONLY"""
470
    _TypeDefinition = None
471
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
472
    _Abstract = False
473
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'TransferIn')
474
    _XSDLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 119, 4)
475
    _ElementMap = ChildNode._ElementMap.copy()
476
    _AttributeMap = ChildNode._AttributeMap.copy()
477
    # Base type is ChildNode
478
    
479
    # Element annotations (annotations) inherited from {net.faulttree}AnnotatedElement
480
    
481
    # Element children (children) inherited from {net.faulttree}Node
482
    
483
    # Attribute id inherited from {net.faulttree}AnnotatedElement
484
    
485
    # Attribute name inherited from {net.faulttree}AnnotatedElement
486
    
487
    # Attribute x inherited from {net.faulttree}Node
488
    
489
    # Attribute y inherited from {net.faulttree}Node
490
    
491
    # Attribute fromModelId uses Python identifier fromModelId
492
    __fromModelId = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'fromModelId'), 'fromModelId', '__net_faulttree_TransferIn__fromModelId', pyxb.binding.datatypes.int, required=True)
493
    __fromModelId._DeclarationLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 122, 16)
494
    __fromModelId._UseLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 122, 16)
495
    
496
    fromModelId = property(__fromModelId.value, __fromModelId.set, None, None)
497
498
    
499
    # Attribute maxCosts uses Python identifier maxCosts
500
    __maxCosts = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'maxCosts'), 'maxCosts', '__net_faulttree_TransferIn__maxCosts', pyxb.binding.datatypes.int, unicode_default='0')
501
    __maxCosts._DeclarationLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 123, 16)
502
    __maxCosts._UseLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 123, 16)
503
    
504
    maxCosts = property(__maxCosts.value, __maxCosts.set, None, None)
505
506
    _ElementMap.update({
507
        
508
    })
509
    _AttributeMap.update({
510
        __fromModelId.name() : __fromModelId,
511
        __maxCosts.name() : __maxCosts
512
    })
513
_module_typeBindings.TransferIn_ = TransferIn_
514
Namespace.addCategoryObject('typeBinding', 'TransferIn', TransferIn_)
515
516
517
# Complex type {net.faulttree}UndevelopedEvent with content type ELEMENT_ONLY
518
class UndevelopedEvent_ (ChildNode):
519
    """Complex type {net.faulttree}UndevelopedEvent with content type ELEMENT_ONLY"""
520
    _TypeDefinition = None
521
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
522
    _Abstract = False
523
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'UndevelopedEvent')
524
    _XSDLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 129, 4)
525
    _ElementMap = ChildNode._ElementMap.copy()
526
    _AttributeMap = ChildNode._AttributeMap.copy()
527
    # Base type is ChildNode
528
    
529
    # Element annotations (annotations) inherited from {net.faulttree}AnnotatedElement
530
    
531
    # Element children (children) inherited from {net.faulttree}Node
532
    
533
    # Attribute id inherited from {net.faulttree}AnnotatedElement
534
    
535
    # Attribute name inherited from {net.faulttree}AnnotatedElement
536
    
537
    # Attribute x inherited from {net.faulttree}Node
538
    
539
    # Attribute y inherited from {net.faulttree}Node
540
    _ElementMap.update({
541
        
542
    })
543
    _AttributeMap.update({
544
        
545
    })
546
_module_typeBindings.UndevelopedEvent_ = UndevelopedEvent_
547
Namespace.addCategoryObject('typeBinding', 'UndevelopedEvent', UndevelopedEvent_)
548
549
550
# Complex type {net.faulttree}BasicEvent with content type ELEMENT_ONLY
551
class BasicEvent_ (ChildNode):
552
    """Complex type {net.faulttree}BasicEvent with content type ELEMENT_ONLY"""
553
    _TypeDefinition = None
554
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
555
    _Abstract = False
556
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'BasicEvent')
557
    _XSDLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 143, 4)
558
    _ElementMap = ChildNode._ElementMap.copy()
559
    _AttributeMap = ChildNode._AttributeMap.copy()
560
    # Base type is ChildNode
561
    
562
    # Element annotations (annotations) inherited from {net.faulttree}AnnotatedElement
563
    
564
    # Element children (children) inherited from {net.faulttree}Node
565
    
566
    # Element probability uses Python identifier probability
567
    __probability = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'probability'), 'probability', '__net_faulttree_BasicEvent__probability', False, pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 147, 20), )
568
569
    
570
    probability = property(__probability.value, __probability.set, None, None)
571
572
    
573
    # Attribute id inherited from {net.faulttree}AnnotatedElement
574
    
575
    # Attribute name inherited from {net.faulttree}AnnotatedElement
576
    
577
    # Attribute x inherited from {net.faulttree}Node
578
    
579
    # Attribute y inherited from {net.faulttree}Node
580
    _ElementMap.update({
581
        __probability.name() : __probability
582
    })
583
    _AttributeMap.update({
584
        
585
    })
586
_module_typeBindings.BasicEvent_ = BasicEvent_
587
Namespace.addCategoryObject('typeBinding', 'BasicEvent', BasicEvent_)
588
589
590
# Complex type {net.faulttree}IntermediateEvent with content type ELEMENT_ONLY
591
class IntermediateEvent_ (ChildNode):
592
    """Complex type {net.faulttree}IntermediateEvent with content type ELEMENT_ONLY"""
593
    _TypeDefinition = None
594
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
595
    _Abstract = False
596
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'IntermediateEvent')
597
    _XSDLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 154, 4)
598
    _ElementMap = ChildNode._ElementMap.copy()
599
    _AttributeMap = ChildNode._AttributeMap.copy()
600
    # Base type is ChildNode
601
    
602
    # Element annotations (annotations) inherited from {net.faulttree}AnnotatedElement
603
    
604
    # Element children (children) inherited from {net.faulttree}Node
605
    
606
    # Attribute id inherited from {net.faulttree}AnnotatedElement
607
    
608
    # Attribute name inherited from {net.faulttree}AnnotatedElement
609
    
610
    # Attribute x inherited from {net.faulttree}Node
611
    
612
    # Attribute y inherited from {net.faulttree}Node
613
    _ElementMap.update({
614
        
615
    })
616
    _AttributeMap.update({
617
        
618
    })
619
_module_typeBindings.IntermediateEvent_ = IntermediateEvent_
620
Namespace.addCategoryObject('typeBinding', 'IntermediateEvent', IntermediateEvent_)
621
622
623
# Complex type {net.faulttree}And with content type ELEMENT_ONLY
624
class And_ (Gate):
625
    """Complex type {net.faulttree}And with content type ELEMENT_ONLY"""
626
    _TypeDefinition = None
627
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
628
    _Abstract = False
629
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'And')
630
    _XSDLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 88, 4)
631
    _ElementMap = Gate._ElementMap.copy()
632
    _AttributeMap = Gate._AttributeMap.copy()
633
    # Base type is Gate
634
    
635
    # Element annotations (annotations) inherited from {net.faulttree}AnnotatedElement
636
    
637
    # Element children (children) inherited from {net.faulttree}Node
638
    
639
    # Attribute id inherited from {net.faulttree}AnnotatedElement
640
    
641
    # Attribute name inherited from {net.faulttree}AnnotatedElement
642
    
643
    # Attribute x inherited from {net.faulttree}Node
644
    
645
    # Attribute y inherited from {net.faulttree}Node
646
    _ElementMap.update({
647
        
648
    })
649
    _AttributeMap.update({
650
        
651
    })
652
_module_typeBindings.And_ = And_
653
Namespace.addCategoryObject('typeBinding', 'And', And_)
654
655
656
# Complex type {net.faulttree}Or with content type ELEMENT_ONLY
657
class Or_ (Gate):
658
    """Complex type {net.faulttree}Or with content type ELEMENT_ONLY"""
659
    _TypeDefinition = None
660
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
661
    _Abstract = False
662
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'Or')
663
    _XSDLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 95, 4)
664
    _ElementMap = Gate._ElementMap.copy()
665
    _AttributeMap = Gate._AttributeMap.copy()
666
    # Base type is Gate
667
    
668
    # Element annotations (annotations) inherited from {net.faulttree}AnnotatedElement
669
    
670
    # Element children (children) inherited from {net.faulttree}Node
671
    
672
    # Attribute id inherited from {net.faulttree}AnnotatedElement
673
    
674
    # Attribute name inherited from {net.faulttree}AnnotatedElement
675
    
676
    # Attribute x inherited from {net.faulttree}Node
677
    
678
    # Attribute y inherited from {net.faulttree}Node
679
    _ElementMap.update({
680
        
681
    })
682
    _AttributeMap.update({
683
        
684
    })
685
_module_typeBindings.Or_ = Or_
686
Namespace.addCategoryObject('typeBinding', 'Or', Or_)
687
688
689
# Complex type {net.faulttree}Xor with content type ELEMENT_ONLY
690
class Xor_ (Gate):
691
    """Complex type {net.faulttree}Xor with content type ELEMENT_ONLY"""
692
    _TypeDefinition = None
693
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
694
    _Abstract = False
695
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'Xor')
696
    _XSDLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 102, 4)
697
    _ElementMap = Gate._ElementMap.copy()
698
    _AttributeMap = Gate._AttributeMap.copy()
699
    # Base type is Gate
700
    
701
    # Element annotations (annotations) inherited from {net.faulttree}AnnotatedElement
702
    
703
    # Element children (children) inherited from {net.faulttree}Node
704
    
705
    # Attribute id inherited from {net.faulttree}AnnotatedElement
706
    
707
    # Attribute name inherited from {net.faulttree}AnnotatedElement
708
    
709
    # Attribute x inherited from {net.faulttree}Node
710
    
711
    # Attribute y inherited from {net.faulttree}Node
712
    _ElementMap.update({
713
        
714
    })
715
    _AttributeMap.update({
716
        
717
    })
718
_module_typeBindings.Xor_ = Xor_
719
Namespace.addCategoryObject('typeBinding', 'Xor', Xor_)
720
721
722
# Complex type {net.faulttree}VotingOr with content type ELEMENT_ONLY
723
class VotingOr_ (Gate):
724
    """Complex type {net.faulttree}VotingOr with content type ELEMENT_ONLY"""
725
    _TypeDefinition = None
726
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
727
    _Abstract = False
728
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'VotingOr')
729
    _XSDLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 109, 4)
730
    _ElementMap = Gate._ElementMap.copy()
731
    _AttributeMap = Gate._AttributeMap.copy()
732
    # Base type is Gate
733
    
734
    # Element annotations (annotations) inherited from {net.faulttree}AnnotatedElement
735
    
736
    # Element children (children) inherited from {net.faulttree}Node
737
    
738
    # Attribute id inherited from {net.faulttree}AnnotatedElement
739
    
740
    # Attribute name inherited from {net.faulttree}AnnotatedElement
741
    
742
    # Attribute x inherited from {net.faulttree}Node
743
    
744
    # Attribute y inherited from {net.faulttree}Node
745
    
746
    # Attribute k uses Python identifier k
747
    __k = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'k'), 'k', '__net_faulttree_VotingOr__k', pyxb.binding.datatypes.int, required=True)
748
    __k._DeclarationLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 112, 16)
749
    __k._UseLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 112, 16)
750
    
751
    k = property(__k.value, __k.set, None, None)
752
753
    _ElementMap.update({
754
        
755
    })
756
    _AttributeMap.update({
757
        __k.name() : __k
758
    })
759
_module_typeBindings.VotingOr_ = VotingOr_
760
Namespace.addCategoryObject('typeBinding', 'VotingOr', VotingOr_)
761
762
763
# Complex type {net.faulttree}HouseEvent with content type ELEMENT_ONLY
764
class HouseEvent_ (BasicEvent_):
765
    """Complex type {net.faulttree}HouseEvent with content type ELEMENT_ONLY"""
766
    _TypeDefinition = None
767
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
768
    _Abstract = False
769
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'HouseEvent')
770
    _XSDLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 136, 4)
771
    _ElementMap = BasicEvent_._ElementMap.copy()
772
    _AttributeMap = BasicEvent_._AttributeMap.copy()
773
    # Base type is BasicEvent_
774
    
775
    # Element annotations (annotations) inherited from {net.faulttree}AnnotatedElement
776
    
777
    # Element children (children) inherited from {net.faulttree}Node
778
    
779
    # Element probability (probability) inherited from {net.faulttree}BasicEvent
780
    
781
    # Attribute id inherited from {net.faulttree}AnnotatedElement
782
    
783
    # Attribute name inherited from {net.faulttree}AnnotatedElement
784
    
785
    # Attribute x inherited from {net.faulttree}Node
786
    
787
    # Attribute y inherited from {net.faulttree}Node
788
    _ElementMap.update({
789
        
790
    })
791
    _AttributeMap.update({
792
        
793
    })
794
_module_typeBindings.HouseEvent_ = HouseEvent_
795
Namespace.addCategoryObject('typeBinding', 'HouseEvent', HouseEvent_)
796
797
798
# Complex type {net.faulttree}BasicEventSet with content type ELEMENT_ONLY
799
class BasicEventSet_ (BasicEvent_):
800
    """Complex type {net.faulttree}BasicEventSet with content type ELEMENT_ONLY"""
801
    _TypeDefinition = None
802
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
803
    _Abstract = False
804
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'BasicEventSet')
805
    _XSDLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 161, 4)
806
    _ElementMap = BasicEvent_._ElementMap.copy()
807
    _AttributeMap = BasicEvent_._AttributeMap.copy()
808
    # Base type is BasicEvent_
809
    
810
    # Element annotations (annotations) inherited from {net.faulttree}AnnotatedElement
811
    
812
    # Element children (children) inherited from {net.faulttree}Node
813
    
814
    # Element probability (probability) inherited from {net.faulttree}BasicEvent
815
    
816
    # Attribute id inherited from {net.faulttree}AnnotatedElement
817
    
818
    # Attribute name inherited from {net.faulttree}AnnotatedElement
819
    
820
    # Attribute x inherited from {net.faulttree}Node
821
    
822
    # Attribute y inherited from {net.faulttree}Node
823
    
824
    # Attribute quantity uses Python identifier quantity
825
    __quantity = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'quantity'), 'quantity', '__net_faulttree_BasicEventSet__quantity', pyxb.binding.datatypes.int)
826
    __quantity._DeclarationLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 164, 16)
827
    __quantity._UseLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 164, 16)
828
    
829
    quantity = property(__quantity.value, __quantity.set, None, None)
830
831
    _ElementMap.update({
832
        
833
    })
834
    _AttributeMap.update({
835
        __quantity.name() : __quantity
836
    })
837
_module_typeBindings.BasicEventSet_ = BasicEventSet_
838
Namespace.addCategoryObject('typeBinding', 'BasicEventSet', BasicEventSet_)
839
840
841
# Complex type {net.faulttree}IntermediateEventSet with content type ELEMENT_ONLY
842
class IntermediateEventSet_ (IntermediateEvent_):
843
    """Complex type {net.faulttree}IntermediateEventSet with content type ELEMENT_ONLY"""
844
    _TypeDefinition = None
845
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
846
    _Abstract = False
847
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'IntermediateEventSet')
848
    _XSDLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 170, 4)
849
    _ElementMap = IntermediateEvent_._ElementMap.copy()
850
    _AttributeMap = IntermediateEvent_._AttributeMap.copy()
851
    # Base type is IntermediateEvent_
852
    
853
    # Element annotations (annotations) inherited from {net.faulttree}AnnotatedElement
854
    
855
    # Element children (children) inherited from {net.faulttree}Node
856
    
857
    # Attribute id inherited from {net.faulttree}AnnotatedElement
858
    
859
    # Attribute name inherited from {net.faulttree}AnnotatedElement
860
    
861
    # Attribute x inherited from {net.faulttree}Node
862
    
863
    # Attribute y inherited from {net.faulttree}Node
864
    
865
    # Attribute quantity uses Python identifier quantity
866
    __quantity = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'quantity'), 'quantity', '__net_faulttree_IntermediateEventSet__quantity', pyxb.binding.datatypes.int)
867
    __quantity._DeclarationLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 173, 16)
868
    __quantity._UseLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 173, 16)
869
    
870
    quantity = property(__quantity.value, __quantity.set, None, None)
871
872
    _ElementMap.update({
873
        
874
    })
875
    _AttributeMap.update({
876
        __quantity.name() : __quantity
877
    })
878
_module_typeBindings.IntermediateEventSet_ = IntermediateEventSet_
879
Namespace.addCategoryObject('typeBinding', 'IntermediateEventSet', IntermediateEventSet_)
880
881
882
# Complex type {net.faulttree}DynamicGate with content type ELEMENT_ONLY
883
class DynamicGate (Gate):
884
    """Complex type {net.faulttree}DynamicGate with content type ELEMENT_ONLY"""
885
    _TypeDefinition = None
886
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
887
    _Abstract = True
888
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'DynamicGate')
889
    _XSDLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 180, 4)
890
    _ElementMap = Gate._ElementMap.copy()
891
    _AttributeMap = Gate._AttributeMap.copy()
892
    # Base type is Gate
893
    
894
    # Element annotations (annotations) inherited from {net.faulttree}AnnotatedElement
895
    
896
    # Element children (children) inherited from {net.faulttree}Node
897
    
898
    # Attribute id inherited from {net.faulttree}AnnotatedElement
899
    
900
    # Attribute name inherited from {net.faulttree}AnnotatedElement
901
    
902
    # Attribute x inherited from {net.faulttree}Node
903
    
904
    # Attribute y inherited from {net.faulttree}Node
905
    _ElementMap.update({
906
        
907
    })
908
    _AttributeMap.update({
909
        
910
    })
911
_module_typeBindings.DynamicGate = DynamicGate
912
Namespace.addCategoryObject('typeBinding', 'DynamicGate', DynamicGate)
913
914
915
# Complex type {net.faulttree}Spare with content type ELEMENT_ONLY
916
class Spare_ (DynamicGate):
917
    """Complex type {net.faulttree}Spare with content type ELEMENT_ONLY"""
918
    _TypeDefinition = None
919
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
920
    _Abstract = False
921
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'Spare')
922
    _XSDLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 190, 4)
923
    _ElementMap = DynamicGate._ElementMap.copy()
924
    _AttributeMap = DynamicGate._AttributeMap.copy()
925
    # Base type is DynamicGate
926
    
927
    # Element annotations (annotations) inherited from {net.faulttree}AnnotatedElement
928
    
929
    # Element children (children) inherited from {net.faulttree}Node
930
    
931
    # Attribute id inherited from {net.faulttree}AnnotatedElement
932
    
933
    # Attribute name inherited from {net.faulttree}AnnotatedElement
934
    
935
    # Attribute x inherited from {net.faulttree}Node
936
    
937
    # Attribute y inherited from {net.faulttree}Node
938
    
939
    # Attribute primaryID uses Python identifier primaryID
940
    __primaryID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'primaryID'), 'primaryID', '__net_faulttree_Spare__primaryID', pyxb.binding.datatypes.string, required=True)
941
    __primaryID._DeclarationLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 193, 16)
942
    __primaryID._UseLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 193, 16)
943
    
944
    primaryID = property(__primaryID.value, __primaryID.set, None, None)
945
946
    
947
    # Attribute dormancyFactor uses Python identifier dormancyFactor
948
    __dormancyFactor = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'dormancyFactor'), 'dormancyFactor', '__net_faulttree_Spare__dormancyFactor', pyxb.binding.datatypes.double, required=True)
949
    __dormancyFactor._DeclarationLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 194, 16)
950
    __dormancyFactor._UseLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 194, 16)
951
    
952
    dormancyFactor = property(__dormancyFactor.value, __dormancyFactor.set, None, None)
953
954
    _ElementMap.update({
955
        
956
    })
957
    _AttributeMap.update({
958
        __primaryID.name() : __primaryID,
959
        __dormancyFactor.name() : __dormancyFactor
960
    })
961
_module_typeBindings.Spare_ = Spare_
962
Namespace.addCategoryObject('typeBinding', 'Spare', Spare_)
963
964
965
# Complex type {net.faulttree}PriorityAnd with content type ELEMENT_ONLY
966
class PriorityAnd_ (DynamicGate):
967
    """Complex type {net.faulttree}PriorityAnd with content type ELEMENT_ONLY"""
968
    _TypeDefinition = None
969
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
970
    _Abstract = False
971
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'PriorityAnd')
972
    _XSDLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 200, 4)
973
    _ElementMap = DynamicGate._ElementMap.copy()
974
    _AttributeMap = DynamicGate._AttributeMap.copy()
975
    # Base type is DynamicGate
976
    
977
    # Element annotations (annotations) inherited from {net.faulttree}AnnotatedElement
978
    
979
    # Element children (children) inherited from {net.faulttree}Node
980
    
981
    # Attribute id inherited from {net.faulttree}AnnotatedElement
982
    
983
    # Attribute name inherited from {net.faulttree}AnnotatedElement
984
    
985
    # Attribute x inherited from {net.faulttree}Node
986
    
987
    # Attribute y inherited from {net.faulttree}Node
988
    
989
    # Attribute eventSequence uses Python identifier eventSequence
990
    __eventSequence = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'eventSequence'), 'eventSequence', '__net_faulttree_PriorityAnd__eventSequence', _module_typeBindings.idlist, required=True)
991
    __eventSequence._DeclarationLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 203, 16)
992
    __eventSequence._UseLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 203, 16)
993
    
994
    eventSequence = property(__eventSequence.value, __eventSequence.set, None, None)
995
996
    _ElementMap.update({
997
        
998
    })
999
    _AttributeMap.update({
1000
        __eventSequence.name() : __eventSequence
1001
    })
1002
_module_typeBindings.PriorityAnd_ = PriorityAnd_
1003
Namespace.addCategoryObject('typeBinding', 'PriorityAnd', PriorityAnd_)
1004
1005
1006
# Complex type {net.faulttree}Sequence with content type ELEMENT_ONLY
1007
class Sequence_ (DynamicGate):
1008
    """Complex type {net.faulttree}Sequence with content type ELEMENT_ONLY"""
1009
    _TypeDefinition = None
1010
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
1011
    _Abstract = False
1012
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'Sequence')
1013
    _XSDLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 209, 4)
1014
    _ElementMap = DynamicGate._ElementMap.copy()
1015
    _AttributeMap = DynamicGate._AttributeMap.copy()
1016
    # Base type is DynamicGate
1017
    
1018
    # Element annotations (annotations) inherited from {net.faulttree}AnnotatedElement
1019
    
1020
    # Element children (children) inherited from {net.faulttree}Node
1021
    
1022
    # Attribute id inherited from {net.faulttree}AnnotatedElement
1023
    
1024
    # Attribute name inherited from {net.faulttree}AnnotatedElement
1025
    
1026
    # Attribute x inherited from {net.faulttree}Node
1027
    
1028
    # Attribute y inherited from {net.faulttree}Node
1029
    
1030
    # Attribute eventSequence uses Python identifier eventSequence
1031
    __eventSequence = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'eventSequence'), 'eventSequence', '__net_faulttree_Sequence__eventSequence', _module_typeBindings.idlist, required=True)
1032
    __eventSequence._DeclarationLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 212, 16)
1033
    __eventSequence._UseLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 212, 16)
1034
    
1035
    eventSequence = property(__eventSequence.value, __eventSequence.set, None, None)
1036
1037
    _ElementMap.update({
1038
        
1039
    })
1040
    _AttributeMap.update({
1041
        __eventSequence.name() : __eventSequence
1042
    })
1043
_module_typeBindings.Sequence_ = Sequence_
1044
Namespace.addCategoryObject('typeBinding', 'Sequence', Sequence_)
1045
1046
1047
# Complex type {net.faulttree}FDEP with content type ELEMENT_ONLY
1048
class FDEP_ (DynamicGate):
1049
    """Complex type {net.faulttree}FDEP with content type ELEMENT_ONLY"""
1050
    _TypeDefinition = None
1051
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
1052
    _Abstract = False
1053
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'FDEP')
1054
    _XSDLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 218, 4)
1055
    _ElementMap = DynamicGate._ElementMap.copy()
1056
    _AttributeMap = DynamicGate._AttributeMap.copy()
1057
    # Base type is DynamicGate
1058
    
1059
    # Element annotations (annotations) inherited from {net.faulttree}AnnotatedElement
1060
    
1061
    # Element children (children) inherited from {net.faulttree}Node
1062
    
1063
    # Attribute id inherited from {net.faulttree}AnnotatedElement
1064
    
1065
    # Attribute name inherited from {net.faulttree}AnnotatedElement
1066
    
1067
    # Attribute x inherited from {net.faulttree}Node
1068
    
1069
    # Attribute y inherited from {net.faulttree}Node
1070
    
1071
    # Attribute trigger uses Python identifier trigger
1072
    __trigger = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'trigger'), 'trigger', '__net_faulttree_FDEP__trigger', pyxb.binding.datatypes.string, required=True)
1073
    __trigger._DeclarationLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 221, 16)
1074
    __trigger._UseLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 221, 16)
1075
    
1076
    trigger = property(__trigger.value, __trigger.set, None, None)
1077
1078
    
1079
    # Attribute triggeredEvents uses Python identifier triggeredEvents
1080
    __triggeredEvents = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'triggeredEvents'), 'triggeredEvents', '__net_faulttree_FDEP__triggeredEvents', _module_typeBindings.idlist, required=True)
1081
    __triggeredEvents._DeclarationLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 222, 16)
1082
    __triggeredEvents._UseLocation = pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 222, 16)
1083
    
1084
    triggeredEvents = property(__triggeredEvents.value, __triggeredEvents.set, None, None)
1085
1086
    _ElementMap.update({
1087
        
1088
    })
1089
    _AttributeMap.update({
1090
        __trigger.name() : __trigger,
1091
        __triggeredEvents.name() : __triggeredEvents
1092
    })
1093
_module_typeBindings.FDEP_ = FDEP_
1094
Namespace.addCategoryObject('typeBinding', 'FDEP', FDEP_)
1095
1096
1097
FailureRate = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'FailureRate'), FailureRate_, location=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 79, 4))
1098
Namespace.addCategoryObject('elementBinding', FailureRate.name().localName(), FailureRate)
1099
1100
FaultTree = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'FaultTree'), FaultTree_, location=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 51, 4))
1101
Namespace.addCategoryObject('elementBinding', FaultTree.name().localName(), FaultTree)
1102
1103
TopEvent = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'TopEvent'), TopEvent_, location=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 61, 4))
1104
Namespace.addCategoryObject('elementBinding', TopEvent.name().localName(), TopEvent)
1105
1106
TransferIn = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'TransferIn'), TransferIn_, location=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 127, 4))
1107
Namespace.addCategoryObject('elementBinding', TransferIn.name().localName(), TransferIn)
1108
1109
UndevelopedEvent = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'UndevelopedEvent'), UndevelopedEvent_, location=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 134, 4))
1110
Namespace.addCategoryObject('elementBinding', UndevelopedEvent.name().localName(), UndevelopedEvent)
1111
1112
BasicEvent = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'BasicEvent'), BasicEvent_, location=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 152, 4))
1113
Namespace.addCategoryObject('elementBinding', BasicEvent.name().localName(), BasicEvent)
1114
1115
IntermediateEvent = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'IntermediateEvent'), IntermediateEvent_, location=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 159, 4))
1116
Namespace.addCategoryObject('elementBinding', IntermediateEvent.name().localName(), IntermediateEvent)
1117
1118
And = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'And'), And_, location=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 93, 4))
1119
Namespace.addCategoryObject('elementBinding', And.name().localName(), And)
1120
1121
Or = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Or'), Or_, location=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 100, 4))
1122
Namespace.addCategoryObject('elementBinding', Or.name().localName(), Or)
1123
1124
Xor = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Xor'), Xor_, location=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 107, 4))
1125
Namespace.addCategoryObject('elementBinding', Xor.name().localName(), Xor)
1126
1127
VotingOr = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'VotingOr'), VotingOr_, location=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 116, 4))
1128
Namespace.addCategoryObject('elementBinding', VotingOr.name().localName(), VotingOr)
1129
1130
HouseEvent = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'HouseEvent'), HouseEvent_, location=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 141, 4))
1131
Namespace.addCategoryObject('elementBinding', HouseEvent.name().localName(), HouseEvent)
1132
1133
BasicEventSet = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'BasicEventSet'), BasicEventSet_, location=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 168, 4))
1134
Namespace.addCategoryObject('elementBinding', BasicEventSet.name().localName(), BasicEventSet)
1135
1136
IntermediateEventSet = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'IntermediateEventSet'), IntermediateEventSet_, location=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 177, 4))
1137
Namespace.addCategoryObject('elementBinding', IntermediateEventSet.name().localName(), IntermediateEventSet)
1138
1139
Spare = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Spare'), Spare_, location=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 198, 4))
1140
Namespace.addCategoryObject('elementBinding', Spare.name().localName(), Spare)
1141
1142
PriorityAnd = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'PriorityAnd'), PriorityAnd_, location=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 207, 4))
1143
Namespace.addCategoryObject('elementBinding', PriorityAnd.name().localName(), PriorityAnd)
1144
1145
Sequence = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Sequence'), Sequence_, location=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 216, 4))
1146
Namespace.addCategoryObject('elementBinding', Sequence.name().localName(), Sequence)
1147
1148
FDEP = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'FDEP'), FDEP_, location=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 226, 4))
1149
Namespace.addCategoryObject('elementBinding', FDEP.name().localName(), FDEP)
1150
1151
1152
1153
AnnotatedElement._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'annotations'), Annotation, scope=AnnotatedElement, location=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12)))
1154
1155
def _BuildAutomaton ():
1156
    # Remove this helper function from the namespace after it is invoked
1157
    global _BuildAutomaton
1158
    del _BuildAutomaton
1159
    import pyxb.utils.fac as fac
1160
1161
    counters = set()
1162
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1163
    counters.add(cc_0)
1164
    states = []
1165
    final_update = set()
1166
    final_update.add(fac.UpdateInstruction(cc_0, False))
1167
    symbol = pyxb.binding.content.ElementUse(AnnotatedElement._UseForTag(pyxb.namespace.ExpandedName(None, 'annotations')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1168
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1169
    states.append(st_0)
1170
    transitions = []
1171
    transitions.append(fac.Transition(st_0, [
1172
        fac.UpdateInstruction(cc_0, True) ]))
1173
    st_0._set_transitionSet(transitions)
1174
    return fac.Automaton(states, counters, True, containing_state=None)
1175
AnnotatedElement._Automaton = _BuildAutomaton()
1176
1177
1178
1179
1180
def _BuildAutomaton_ ():
1181
    # Remove this helper function from the namespace after it is invoked
1182
    global _BuildAutomaton_
1183
    del _BuildAutomaton_
1184
    import pyxb.utils.fac as fac
1185
1186
    counters = set()
1187
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1188
    counters.add(cc_0)
1189
    states = []
1190
    final_update = set()
1191
    final_update.add(fac.UpdateInstruction(cc_0, False))
1192
    symbol = pyxb.binding.content.ElementUse(Model._UseForTag(pyxb.namespace.ExpandedName(None, 'annotations')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1193
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1194
    states.append(st_0)
1195
    transitions = []
1196
    transitions.append(fac.Transition(st_0, [
1197
        fac.UpdateInstruction(cc_0, True) ]))
1198
    st_0._set_transitionSet(transitions)
1199
    return fac.Automaton(states, counters, True, containing_state=None)
1200
Model._Automaton = _BuildAutomaton_()
1201
1202
1203
1204
1205
Node._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'children'), ChildNode, scope=Node, location=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20)))
1206
1207
def _BuildAutomaton_2 ():
1208
    # Remove this helper function from the namespace after it is invoked
1209
    global _BuildAutomaton_2
1210
    del _BuildAutomaton_2
1211
    import pyxb.utils.fac as fac
1212
1213
    counters = set()
1214
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1215
    counters.add(cc_0)
1216
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20))
1217
    counters.add(cc_1)
1218
    states = []
1219
    final_update = set()
1220
    final_update.add(fac.UpdateInstruction(cc_0, False))
1221
    symbol = pyxb.binding.content.ElementUse(Node._UseForTag(pyxb.namespace.ExpandedName(None, 'annotations')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1222
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1223
    states.append(st_0)
1224
    final_update = set()
1225
    final_update.add(fac.UpdateInstruction(cc_1, False))
1226
    symbol = pyxb.binding.content.ElementUse(Node._UseForTag(pyxb.namespace.ExpandedName(None, 'children')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20))
1227
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1228
    states.append(st_1)
1229
    transitions = []
1230
    transitions.append(fac.Transition(st_0, [
1231
        fac.UpdateInstruction(cc_0, True) ]))
1232
    transitions.append(fac.Transition(st_1, [
1233
        fac.UpdateInstruction(cc_0, False) ]))
1234
    st_0._set_transitionSet(transitions)
1235
    transitions = []
1236
    transitions.append(fac.Transition(st_1, [
1237
        fac.UpdateInstruction(cc_1, True) ]))
1238
    st_1._set_transitionSet(transitions)
1239
    return fac.Automaton(states, counters, True, containing_state=None)
1240
Node._Automaton = _BuildAutomaton_2()
1241
1242
1243
1244
1245
def _BuildAutomaton_3 ():
1246
    # Remove this helper function from the namespace after it is invoked
1247
    global _BuildAutomaton_3
1248
    del _BuildAutomaton_3
1249
    import pyxb.utils.fac as fac
1250
1251
    counters = set()
1252
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1253
    counters.add(cc_0)
1254
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20))
1255
    counters.add(cc_1)
1256
    states = []
1257
    final_update = set()
1258
    final_update.add(fac.UpdateInstruction(cc_0, False))
1259
    symbol = pyxb.binding.content.ElementUse(ChildNode._UseForTag(pyxb.namespace.ExpandedName(None, 'annotations')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1260
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1261
    states.append(st_0)
1262
    final_update = set()
1263
    final_update.add(fac.UpdateInstruction(cc_1, False))
1264
    symbol = pyxb.binding.content.ElementUse(ChildNode._UseForTag(pyxb.namespace.ExpandedName(None, 'children')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20))
1265
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1266
    states.append(st_1)
1267
    transitions = []
1268
    transitions.append(fac.Transition(st_0, [
1269
        fac.UpdateInstruction(cc_0, True) ]))
1270
    transitions.append(fac.Transition(st_1, [
1271
        fac.UpdateInstruction(cc_0, False) ]))
1272
    st_0._set_transitionSet(transitions)
1273
    transitions = []
1274
    transitions.append(fac.Transition(st_1, [
1275
        fac.UpdateInstruction(cc_1, True) ]))
1276
    st_1._set_transitionSet(transitions)
1277
    return fac.Automaton(states, counters, True, containing_state=None)
1278
ChildNode._Automaton = _BuildAutomaton_3()
1279
1280
1281
1282
1283
FaultTree_._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'topEvent'), TopEvent_, scope=FaultTree_, location=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 46, 20)))
1284
1285
def _BuildAutomaton_4 ():
1286
    # Remove this helper function from the namespace after it is invoked
1287
    global _BuildAutomaton_4
1288
    del _BuildAutomaton_4
1289
    import pyxb.utils.fac as fac
1290
1291
    counters = set()
1292
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1293
    counters.add(cc_0)
1294
    states = []
1295
    final_update = None
1296
    symbol = pyxb.binding.content.ElementUse(FaultTree_._UseForTag(pyxb.namespace.ExpandedName(None, 'annotations')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1297
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1298
    states.append(st_0)
1299
    final_update = set()
1300
    symbol = pyxb.binding.content.ElementUse(FaultTree_._UseForTag(pyxb.namespace.ExpandedName(None, 'topEvent')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 46, 20))
1301
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1302
    states.append(st_1)
1303
    transitions = []
1304
    transitions.append(fac.Transition(st_0, [
1305
        fac.UpdateInstruction(cc_0, True) ]))
1306
    transitions.append(fac.Transition(st_1, [
1307
        fac.UpdateInstruction(cc_0, False) ]))
1308
    st_0._set_transitionSet(transitions)
1309
    transitions = []
1310
    st_1._set_transitionSet(transitions)
1311
    return fac.Automaton(states, counters, False, containing_state=None)
1312
FaultTree_._Automaton = _BuildAutomaton_4()
1313
1314
1315
1316
1317
def _BuildAutomaton_5 ():
1318
    # Remove this helper function from the namespace after it is invoked
1319
    global _BuildAutomaton_5
1320
    del _BuildAutomaton_5
1321
    import pyxb.utils.fac as fac
1322
1323
    counters = set()
1324
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1325
    counters.add(cc_0)
1326
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20))
1327
    counters.add(cc_1)
1328
    states = []
1329
    final_update = set()
1330
    final_update.add(fac.UpdateInstruction(cc_0, False))
1331
    symbol = pyxb.binding.content.ElementUse(TopEvent_._UseForTag(pyxb.namespace.ExpandedName(None, 'annotations')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1332
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1333
    states.append(st_0)
1334
    final_update = set()
1335
    final_update.add(fac.UpdateInstruction(cc_1, False))
1336
    symbol = pyxb.binding.content.ElementUse(TopEvent_._UseForTag(pyxb.namespace.ExpandedName(None, 'children')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20))
1337
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1338
    states.append(st_1)
1339
    transitions = []
1340
    transitions.append(fac.Transition(st_0, [
1341
        fac.UpdateInstruction(cc_0, True) ]))
1342
    transitions.append(fac.Transition(st_1, [
1343
        fac.UpdateInstruction(cc_0, False) ]))
1344
    st_0._set_transitionSet(transitions)
1345
    transitions = []
1346
    transitions.append(fac.Transition(st_1, [
1347
        fac.UpdateInstruction(cc_1, True) ]))
1348
    st_1._set_transitionSet(transitions)
1349
    return fac.Automaton(states, counters, True, containing_state=None)
1350
TopEvent_._Automaton = _BuildAutomaton_5()
1351
1352
1353
1354
1355
def _BuildAutomaton_6 ():
1356
    # Remove this helper function from the namespace after it is invoked
1357
    global _BuildAutomaton_6
1358
    del _BuildAutomaton_6
1359
    import pyxb.utils.fac as fac
1360
1361
    counters = set()
1362
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1363
    counters.add(cc_0)
1364
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20))
1365
    counters.add(cc_1)
1366
    states = []
1367
    final_update = set()
1368
    final_update.add(fac.UpdateInstruction(cc_0, False))
1369
    symbol = pyxb.binding.content.ElementUse(Gate._UseForTag(pyxb.namespace.ExpandedName(None, 'annotations')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1370
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1371
    states.append(st_0)
1372
    final_update = set()
1373
    final_update.add(fac.UpdateInstruction(cc_1, False))
1374
    symbol = pyxb.binding.content.ElementUse(Gate._UseForTag(pyxb.namespace.ExpandedName(None, 'children')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20))
1375
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1376
    states.append(st_1)
1377
    transitions = []
1378
    transitions.append(fac.Transition(st_0, [
1379
        fac.UpdateInstruction(cc_0, True) ]))
1380
    transitions.append(fac.Transition(st_1, [
1381
        fac.UpdateInstruction(cc_0, False) ]))
1382
    st_0._set_transitionSet(transitions)
1383
    transitions = []
1384
    transitions.append(fac.Transition(st_1, [
1385
        fac.UpdateInstruction(cc_1, True) ]))
1386
    st_1._set_transitionSet(transitions)
1387
    return fac.Automaton(states, counters, True, containing_state=None)
1388
Gate._Automaton = _BuildAutomaton_6()
1389
1390
1391
1392
1393
def _BuildAutomaton_7 ():
1394
    # Remove this helper function from the namespace after it is invoked
1395
    global _BuildAutomaton_7
1396
    del _BuildAutomaton_7
1397
    import pyxb.utils.fac as fac
1398
1399
    counters = set()
1400
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1401
    counters.add(cc_0)
1402
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20))
1403
    counters.add(cc_1)
1404
    states = []
1405
    final_update = set()
1406
    final_update.add(fac.UpdateInstruction(cc_0, False))
1407
    symbol = pyxb.binding.content.ElementUse(TransferIn_._UseForTag(pyxb.namespace.ExpandedName(None, 'annotations')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1408
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1409
    states.append(st_0)
1410
    final_update = set()
1411
    final_update.add(fac.UpdateInstruction(cc_1, False))
1412
    symbol = pyxb.binding.content.ElementUse(TransferIn_._UseForTag(pyxb.namespace.ExpandedName(None, 'children')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20))
1413
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1414
    states.append(st_1)
1415
    transitions = []
1416
    transitions.append(fac.Transition(st_0, [
1417
        fac.UpdateInstruction(cc_0, True) ]))
1418
    transitions.append(fac.Transition(st_1, [
1419
        fac.UpdateInstruction(cc_0, False) ]))
1420
    st_0._set_transitionSet(transitions)
1421
    transitions = []
1422
    transitions.append(fac.Transition(st_1, [
1423
        fac.UpdateInstruction(cc_1, True) ]))
1424
    st_1._set_transitionSet(transitions)
1425
    return fac.Automaton(states, counters, True, containing_state=None)
1426
TransferIn_._Automaton = _BuildAutomaton_7()
1427
1428
1429
1430
1431
def _BuildAutomaton_8 ():
1432
    # Remove this helper function from the namespace after it is invoked
1433
    global _BuildAutomaton_8
1434
    del _BuildAutomaton_8
1435
    import pyxb.utils.fac as fac
1436
1437
    counters = set()
1438
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1439
    counters.add(cc_0)
1440
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20))
1441
    counters.add(cc_1)
1442
    states = []
1443
    final_update = set()
1444
    final_update.add(fac.UpdateInstruction(cc_0, False))
1445
    symbol = pyxb.binding.content.ElementUse(UndevelopedEvent_._UseForTag(pyxb.namespace.ExpandedName(None, 'annotations')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1446
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1447
    states.append(st_0)
1448
    final_update = set()
1449
    final_update.add(fac.UpdateInstruction(cc_1, False))
1450
    symbol = pyxb.binding.content.ElementUse(UndevelopedEvent_._UseForTag(pyxb.namespace.ExpandedName(None, 'children')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20))
1451
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1452
    states.append(st_1)
1453
    transitions = []
1454
    transitions.append(fac.Transition(st_0, [
1455
        fac.UpdateInstruction(cc_0, True) ]))
1456
    transitions.append(fac.Transition(st_1, [
1457
        fac.UpdateInstruction(cc_0, False) ]))
1458
    st_0._set_transitionSet(transitions)
1459
    transitions = []
1460
    transitions.append(fac.Transition(st_1, [
1461
        fac.UpdateInstruction(cc_1, True) ]))
1462
    st_1._set_transitionSet(transitions)
1463
    return fac.Automaton(states, counters, True, containing_state=None)
1464
UndevelopedEvent_._Automaton = _BuildAutomaton_8()
1465
1466
1467
1468
1469
BasicEvent_._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'probability'), Probability, scope=BasicEvent_, location=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 147, 20)))
1470
1471
def _BuildAutomaton_9 ():
1472
    # Remove this helper function from the namespace after it is invoked
1473
    global _BuildAutomaton_9
1474
    del _BuildAutomaton_9
1475
    import pyxb.utils.fac as fac
1476
1477
    counters = set()
1478
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1479
    counters.add(cc_0)
1480
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20))
1481
    counters.add(cc_1)
1482
    states = []
1483
    final_update = None
1484
    symbol = pyxb.binding.content.ElementUse(BasicEvent_._UseForTag(pyxb.namespace.ExpandedName(None, 'annotations')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1485
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1486
    states.append(st_0)
1487
    final_update = None
1488
    symbol = pyxb.binding.content.ElementUse(BasicEvent_._UseForTag(pyxb.namespace.ExpandedName(None, 'children')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20))
1489
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1490
    states.append(st_1)
1491
    final_update = set()
1492
    symbol = pyxb.binding.content.ElementUse(BasicEvent_._UseForTag(pyxb.namespace.ExpandedName(None, 'probability')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 147, 20))
1493
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1494
    states.append(st_2)
1495
    transitions = []
1496
    transitions.append(fac.Transition(st_0, [
1497
        fac.UpdateInstruction(cc_0, True) ]))
1498
    transitions.append(fac.Transition(st_1, [
1499
        fac.UpdateInstruction(cc_0, False) ]))
1500
    transitions.append(fac.Transition(st_2, [
1501
        fac.UpdateInstruction(cc_0, False) ]))
1502
    st_0._set_transitionSet(transitions)
1503
    transitions = []
1504
    transitions.append(fac.Transition(st_1, [
1505
        fac.UpdateInstruction(cc_1, True) ]))
1506
    transitions.append(fac.Transition(st_2, [
1507
        fac.UpdateInstruction(cc_1, False) ]))
1508
    st_1._set_transitionSet(transitions)
1509
    transitions = []
1510
    st_2._set_transitionSet(transitions)
1511
    return fac.Automaton(states, counters, False, containing_state=None)
1512
BasicEvent_._Automaton = _BuildAutomaton_9()
1513
1514
1515
1516
1517
def _BuildAutomaton_10 ():
1518
    # Remove this helper function from the namespace after it is invoked
1519
    global _BuildAutomaton_10
1520
    del _BuildAutomaton_10
1521
    import pyxb.utils.fac as fac
1522
1523
    counters = set()
1524
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1525
    counters.add(cc_0)
1526
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20))
1527
    counters.add(cc_1)
1528
    states = []
1529
    final_update = set()
1530
    final_update.add(fac.UpdateInstruction(cc_0, False))
1531
    symbol = pyxb.binding.content.ElementUse(IntermediateEvent_._UseForTag(pyxb.namespace.ExpandedName(None, 'annotations')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1532
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1533
    states.append(st_0)
1534
    final_update = set()
1535
    final_update.add(fac.UpdateInstruction(cc_1, False))
1536
    symbol = pyxb.binding.content.ElementUse(IntermediateEvent_._UseForTag(pyxb.namespace.ExpandedName(None, 'children')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20))
1537
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1538
    states.append(st_1)
1539
    transitions = []
1540
    transitions.append(fac.Transition(st_0, [
1541
        fac.UpdateInstruction(cc_0, True) ]))
1542
    transitions.append(fac.Transition(st_1, [
1543
        fac.UpdateInstruction(cc_0, False) ]))
1544
    st_0._set_transitionSet(transitions)
1545
    transitions = []
1546
    transitions.append(fac.Transition(st_1, [
1547
        fac.UpdateInstruction(cc_1, True) ]))
1548
    st_1._set_transitionSet(transitions)
1549
    return fac.Automaton(states, counters, True, containing_state=None)
1550
IntermediateEvent_._Automaton = _BuildAutomaton_10()
1551
1552
1553
1554
1555
def _BuildAutomaton_11 ():
1556
    # Remove this helper function from the namespace after it is invoked
1557
    global _BuildAutomaton_11
1558
    del _BuildAutomaton_11
1559
    import pyxb.utils.fac as fac
1560
1561
    counters = set()
1562
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1563
    counters.add(cc_0)
1564
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20))
1565
    counters.add(cc_1)
1566
    states = []
1567
    final_update = set()
1568
    final_update.add(fac.UpdateInstruction(cc_0, False))
1569
    symbol = pyxb.binding.content.ElementUse(And_._UseForTag(pyxb.namespace.ExpandedName(None, 'annotations')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1570
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1571
    states.append(st_0)
1572
    final_update = set()
1573
    final_update.add(fac.UpdateInstruction(cc_1, False))
1574
    symbol = pyxb.binding.content.ElementUse(And_._UseForTag(pyxb.namespace.ExpandedName(None, 'children')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20))
1575
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1576
    states.append(st_1)
1577
    transitions = []
1578
    transitions.append(fac.Transition(st_0, [
1579
        fac.UpdateInstruction(cc_0, True) ]))
1580
    transitions.append(fac.Transition(st_1, [
1581
        fac.UpdateInstruction(cc_0, False) ]))
1582
    st_0._set_transitionSet(transitions)
1583
    transitions = []
1584
    transitions.append(fac.Transition(st_1, [
1585
        fac.UpdateInstruction(cc_1, True) ]))
1586
    st_1._set_transitionSet(transitions)
1587
    return fac.Automaton(states, counters, True, containing_state=None)
1588
And_._Automaton = _BuildAutomaton_11()
1589
1590
1591
1592
1593
def _BuildAutomaton_12 ():
1594
    # Remove this helper function from the namespace after it is invoked
1595
    global _BuildAutomaton_12
1596
    del _BuildAutomaton_12
1597
    import pyxb.utils.fac as fac
1598
1599
    counters = set()
1600
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1601
    counters.add(cc_0)
1602
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20))
1603
    counters.add(cc_1)
1604
    states = []
1605
    final_update = set()
1606
    final_update.add(fac.UpdateInstruction(cc_0, False))
1607
    symbol = pyxb.binding.content.ElementUse(Or_._UseForTag(pyxb.namespace.ExpandedName(None, 'annotations')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1608
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1609
    states.append(st_0)
1610
    final_update = set()
1611
    final_update.add(fac.UpdateInstruction(cc_1, False))
1612
    symbol = pyxb.binding.content.ElementUse(Or_._UseForTag(pyxb.namespace.ExpandedName(None, 'children')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20))
1613
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1614
    states.append(st_1)
1615
    transitions = []
1616
    transitions.append(fac.Transition(st_0, [
1617
        fac.UpdateInstruction(cc_0, True) ]))
1618
    transitions.append(fac.Transition(st_1, [
1619
        fac.UpdateInstruction(cc_0, False) ]))
1620
    st_0._set_transitionSet(transitions)
1621
    transitions = []
1622
    transitions.append(fac.Transition(st_1, [
1623
        fac.UpdateInstruction(cc_1, True) ]))
1624
    st_1._set_transitionSet(transitions)
1625
    return fac.Automaton(states, counters, True, containing_state=None)
1626
Or_._Automaton = _BuildAutomaton_12()
1627
1628
1629
1630
1631
def _BuildAutomaton_13 ():
1632
    # Remove this helper function from the namespace after it is invoked
1633
    global _BuildAutomaton_13
1634
    del _BuildAutomaton_13
1635
    import pyxb.utils.fac as fac
1636
1637
    counters = set()
1638
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1639
    counters.add(cc_0)
1640
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20))
1641
    counters.add(cc_1)
1642
    states = []
1643
    final_update = set()
1644
    final_update.add(fac.UpdateInstruction(cc_0, False))
1645
    symbol = pyxb.binding.content.ElementUse(Xor_._UseForTag(pyxb.namespace.ExpandedName(None, 'annotations')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1646
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1647
    states.append(st_0)
1648
    final_update = set()
1649
    final_update.add(fac.UpdateInstruction(cc_1, False))
1650
    symbol = pyxb.binding.content.ElementUse(Xor_._UseForTag(pyxb.namespace.ExpandedName(None, 'children')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20))
1651
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1652
    states.append(st_1)
1653
    transitions = []
1654
    transitions.append(fac.Transition(st_0, [
1655
        fac.UpdateInstruction(cc_0, True) ]))
1656
    transitions.append(fac.Transition(st_1, [
1657
        fac.UpdateInstruction(cc_0, False) ]))
1658
    st_0._set_transitionSet(transitions)
1659
    transitions = []
1660
    transitions.append(fac.Transition(st_1, [
1661
        fac.UpdateInstruction(cc_1, True) ]))
1662
    st_1._set_transitionSet(transitions)
1663
    return fac.Automaton(states, counters, True, containing_state=None)
1664
Xor_._Automaton = _BuildAutomaton_13()
1665
1666
1667
1668
1669
def _BuildAutomaton_14 ():
1670
    # Remove this helper function from the namespace after it is invoked
1671
    global _BuildAutomaton_14
1672
    del _BuildAutomaton_14
1673
    import pyxb.utils.fac as fac
1674
1675
    counters = set()
1676
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1677
    counters.add(cc_0)
1678
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20))
1679
    counters.add(cc_1)
1680
    states = []
1681
    final_update = set()
1682
    final_update.add(fac.UpdateInstruction(cc_0, False))
1683
    symbol = pyxb.binding.content.ElementUse(VotingOr_._UseForTag(pyxb.namespace.ExpandedName(None, 'annotations')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1684
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1685
    states.append(st_0)
1686
    final_update = set()
1687
    final_update.add(fac.UpdateInstruction(cc_1, False))
1688
    symbol = pyxb.binding.content.ElementUse(VotingOr_._UseForTag(pyxb.namespace.ExpandedName(None, 'children')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20))
1689
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1690
    states.append(st_1)
1691
    transitions = []
1692
    transitions.append(fac.Transition(st_0, [
1693
        fac.UpdateInstruction(cc_0, True) ]))
1694
    transitions.append(fac.Transition(st_1, [
1695
        fac.UpdateInstruction(cc_0, False) ]))
1696
    st_0._set_transitionSet(transitions)
1697
    transitions = []
1698
    transitions.append(fac.Transition(st_1, [
1699
        fac.UpdateInstruction(cc_1, True) ]))
1700
    st_1._set_transitionSet(transitions)
1701
    return fac.Automaton(states, counters, True, containing_state=None)
1702
VotingOr_._Automaton = _BuildAutomaton_14()
1703
1704
1705
1706
1707
def _BuildAutomaton_15 ():
1708
    # Remove this helper function from the namespace after it is invoked
1709
    global _BuildAutomaton_15
1710
    del _BuildAutomaton_15
1711
    import pyxb.utils.fac as fac
1712
1713
    counters = set()
1714
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1715
    counters.add(cc_0)
1716
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20))
1717
    counters.add(cc_1)
1718
    states = []
1719
    final_update = None
1720
    symbol = pyxb.binding.content.ElementUse(HouseEvent_._UseForTag(pyxb.namespace.ExpandedName(None, 'annotations')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1721
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1722
    states.append(st_0)
1723
    final_update = None
1724
    symbol = pyxb.binding.content.ElementUse(HouseEvent_._UseForTag(pyxb.namespace.ExpandedName(None, 'children')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20))
1725
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1726
    states.append(st_1)
1727
    final_update = set()
1728
    symbol = pyxb.binding.content.ElementUse(HouseEvent_._UseForTag(pyxb.namespace.ExpandedName(None, 'probability')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 147, 20))
1729
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1730
    states.append(st_2)
1731
    transitions = []
1732
    transitions.append(fac.Transition(st_0, [
1733
        fac.UpdateInstruction(cc_0, True) ]))
1734
    transitions.append(fac.Transition(st_1, [
1735
        fac.UpdateInstruction(cc_0, False) ]))
1736
    transitions.append(fac.Transition(st_2, [
1737
        fac.UpdateInstruction(cc_0, False) ]))
1738
    st_0._set_transitionSet(transitions)
1739
    transitions = []
1740
    transitions.append(fac.Transition(st_1, [
1741
        fac.UpdateInstruction(cc_1, True) ]))
1742
    transitions.append(fac.Transition(st_2, [
1743
        fac.UpdateInstruction(cc_1, False) ]))
1744
    st_1._set_transitionSet(transitions)
1745
    transitions = []
1746
    st_2._set_transitionSet(transitions)
1747
    return fac.Automaton(states, counters, False, containing_state=None)
1748
HouseEvent_._Automaton = _BuildAutomaton_15()
1749
1750
1751
1752
1753
def _BuildAutomaton_16 ():
1754
    # Remove this helper function from the namespace after it is invoked
1755
    global _BuildAutomaton_16
1756
    del _BuildAutomaton_16
1757
    import pyxb.utils.fac as fac
1758
1759
    counters = set()
1760
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1761
    counters.add(cc_0)
1762
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20))
1763
    counters.add(cc_1)
1764
    states = []
1765
    final_update = None
1766
    symbol = pyxb.binding.content.ElementUse(BasicEventSet_._UseForTag(pyxb.namespace.ExpandedName(None, 'annotations')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1767
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1768
    states.append(st_0)
1769
    final_update = None
1770
    symbol = pyxb.binding.content.ElementUse(BasicEventSet_._UseForTag(pyxb.namespace.ExpandedName(None, 'children')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20))
1771
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1772
    states.append(st_1)
1773
    final_update = set()
1774
    symbol = pyxb.binding.content.ElementUse(BasicEventSet_._UseForTag(pyxb.namespace.ExpandedName(None, 'probability')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 147, 20))
1775
    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1776
    states.append(st_2)
1777
    transitions = []
1778
    transitions.append(fac.Transition(st_0, [
1779
        fac.UpdateInstruction(cc_0, True) ]))
1780
    transitions.append(fac.Transition(st_1, [
1781
        fac.UpdateInstruction(cc_0, False) ]))
1782
    transitions.append(fac.Transition(st_2, [
1783
        fac.UpdateInstruction(cc_0, False) ]))
1784
    st_0._set_transitionSet(transitions)
1785
    transitions = []
1786
    transitions.append(fac.Transition(st_1, [
1787
        fac.UpdateInstruction(cc_1, True) ]))
1788
    transitions.append(fac.Transition(st_2, [
1789
        fac.UpdateInstruction(cc_1, False) ]))
1790
    st_1._set_transitionSet(transitions)
1791
    transitions = []
1792
    st_2._set_transitionSet(transitions)
1793
    return fac.Automaton(states, counters, False, containing_state=None)
1794
BasicEventSet_._Automaton = _BuildAutomaton_16()
1795
1796
1797
1798
1799
def _BuildAutomaton_17 ():
1800
    # Remove this helper function from the namespace after it is invoked
1801
    global _BuildAutomaton_17
1802
    del _BuildAutomaton_17
1803
    import pyxb.utils.fac as fac
1804
1805
    counters = set()
1806
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1807
    counters.add(cc_0)
1808
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20))
1809
    counters.add(cc_1)
1810
    states = []
1811
    final_update = set()
1812
    final_update.add(fac.UpdateInstruction(cc_0, False))
1813
    symbol = pyxb.binding.content.ElementUse(IntermediateEventSet_._UseForTag(pyxb.namespace.ExpandedName(None, 'annotations')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1814
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1815
    states.append(st_0)
1816
    final_update = set()
1817
    final_update.add(fac.UpdateInstruction(cc_1, False))
1818
    symbol = pyxb.binding.content.ElementUse(IntermediateEventSet_._UseForTag(pyxb.namespace.ExpandedName(None, 'children')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20))
1819
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1820
    states.append(st_1)
1821
    transitions = []
1822
    transitions.append(fac.Transition(st_0, [
1823
        fac.UpdateInstruction(cc_0, True) ]))
1824
    transitions.append(fac.Transition(st_1, [
1825
        fac.UpdateInstruction(cc_0, False) ]))
1826
    st_0._set_transitionSet(transitions)
1827
    transitions = []
1828
    transitions.append(fac.Transition(st_1, [
1829
        fac.UpdateInstruction(cc_1, True) ]))
1830
    st_1._set_transitionSet(transitions)
1831
    return fac.Automaton(states, counters, True, containing_state=None)
1832
IntermediateEventSet_._Automaton = _BuildAutomaton_17()
1833
1834
1835
1836
1837
def _BuildAutomaton_18 ():
1838
    # Remove this helper function from the namespace after it is invoked
1839
    global _BuildAutomaton_18
1840
    del _BuildAutomaton_18
1841
    import pyxb.utils.fac as fac
1842
1843
    counters = set()
1844
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1845
    counters.add(cc_0)
1846
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20))
1847
    counters.add(cc_1)
1848
    states = []
1849
    final_update = set()
1850
    final_update.add(fac.UpdateInstruction(cc_0, False))
1851
    symbol = pyxb.binding.content.ElementUse(DynamicGate._UseForTag(pyxb.namespace.ExpandedName(None, 'annotations')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1852
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1853
    states.append(st_0)
1854
    final_update = set()
1855
    final_update.add(fac.UpdateInstruction(cc_1, False))
1856
    symbol = pyxb.binding.content.ElementUse(DynamicGate._UseForTag(pyxb.namespace.ExpandedName(None, 'children')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20))
1857
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1858
    states.append(st_1)
1859
    transitions = []
1860
    transitions.append(fac.Transition(st_0, [
1861
        fac.UpdateInstruction(cc_0, True) ]))
1862
    transitions.append(fac.Transition(st_1, [
1863
        fac.UpdateInstruction(cc_0, False) ]))
1864
    st_0._set_transitionSet(transitions)
1865
    transitions = []
1866
    transitions.append(fac.Transition(st_1, [
1867
        fac.UpdateInstruction(cc_1, True) ]))
1868
    st_1._set_transitionSet(transitions)
1869
    return fac.Automaton(states, counters, True, containing_state=None)
1870
DynamicGate._Automaton = _BuildAutomaton_18()
1871
1872
1873
1874
1875
def _BuildAutomaton_19 ():
1876
    # Remove this helper function from the namespace after it is invoked
1877
    global _BuildAutomaton_19
1878
    del _BuildAutomaton_19
1879
    import pyxb.utils.fac as fac
1880
1881
    counters = set()
1882
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1883
    counters.add(cc_0)
1884
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20))
1885
    counters.add(cc_1)
1886
    states = []
1887
    final_update = set()
1888
    final_update.add(fac.UpdateInstruction(cc_0, False))
1889
    symbol = pyxb.binding.content.ElementUse(Spare_._UseForTag(pyxb.namespace.ExpandedName(None, 'annotations')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1890
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1891
    states.append(st_0)
1892
    final_update = set()
1893
    final_update.add(fac.UpdateInstruction(cc_1, False))
1894
    symbol = pyxb.binding.content.ElementUse(Spare_._UseForTag(pyxb.namespace.ExpandedName(None, 'children')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20))
1895
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1896
    states.append(st_1)
1897
    transitions = []
1898
    transitions.append(fac.Transition(st_0, [
1899
        fac.UpdateInstruction(cc_0, True) ]))
1900
    transitions.append(fac.Transition(st_1, [
1901
        fac.UpdateInstruction(cc_0, False) ]))
1902
    st_0._set_transitionSet(transitions)
1903
    transitions = []
1904
    transitions.append(fac.Transition(st_1, [
1905
        fac.UpdateInstruction(cc_1, True) ]))
1906
    st_1._set_transitionSet(transitions)
1907
    return fac.Automaton(states, counters, True, containing_state=None)
1908
Spare_._Automaton = _BuildAutomaton_19()
1909
1910
1911
1912
1913
def _BuildAutomaton_20 ():
1914
    # Remove this helper function from the namespace after it is invoked
1915
    global _BuildAutomaton_20
1916
    del _BuildAutomaton_20
1917
    import pyxb.utils.fac as fac
1918
1919
    counters = set()
1920
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1921
    counters.add(cc_0)
1922
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20))
1923
    counters.add(cc_1)
1924
    states = []
1925
    final_update = set()
1926
    final_update.add(fac.UpdateInstruction(cc_0, False))
1927
    symbol = pyxb.binding.content.ElementUse(PriorityAnd_._UseForTag(pyxb.namespace.ExpandedName(None, 'annotations')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1928
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1929
    states.append(st_0)
1930
    final_update = set()
1931
    final_update.add(fac.UpdateInstruction(cc_1, False))
1932
    symbol = pyxb.binding.content.ElementUse(PriorityAnd_._UseForTag(pyxb.namespace.ExpandedName(None, 'children')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20))
1933
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1934
    states.append(st_1)
1935
    transitions = []
1936
    transitions.append(fac.Transition(st_0, [
1937
        fac.UpdateInstruction(cc_0, True) ]))
1938
    transitions.append(fac.Transition(st_1, [
1939
        fac.UpdateInstruction(cc_0, False) ]))
1940
    st_0._set_transitionSet(transitions)
1941
    transitions = []
1942
    transitions.append(fac.Transition(st_1, [
1943
        fac.UpdateInstruction(cc_1, True) ]))
1944
    st_1._set_transitionSet(transitions)
1945
    return fac.Automaton(states, counters, True, containing_state=None)
1946
PriorityAnd_._Automaton = _BuildAutomaton_20()
1947
1948
1949
1950
1951
def _BuildAutomaton_21 ():
1952
    # Remove this helper function from the namespace after it is invoked
1953
    global _BuildAutomaton_21
1954
    del _BuildAutomaton_21
1955
    import pyxb.utils.fac as fac
1956
1957
    counters = set()
1958
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1959
    counters.add(cc_0)
1960
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20))
1961
    counters.add(cc_1)
1962
    states = []
1963
    final_update = set()
1964
    final_update.add(fac.UpdateInstruction(cc_0, False))
1965
    symbol = pyxb.binding.content.ElementUse(Sequence_._UseForTag(pyxb.namespace.ExpandedName(None, 'annotations')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1966
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1967
    states.append(st_0)
1968
    final_update = set()
1969
    final_update.add(fac.UpdateInstruction(cc_1, False))
1970
    symbol = pyxb.binding.content.ElementUse(Sequence_._UseForTag(pyxb.namespace.ExpandedName(None, 'children')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20))
1971
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
1972
    states.append(st_1)
1973
    transitions = []
1974
    transitions.append(fac.Transition(st_0, [
1975
        fac.UpdateInstruction(cc_0, True) ]))
1976
    transitions.append(fac.Transition(st_1, [
1977
        fac.UpdateInstruction(cc_0, False) ]))
1978
    st_0._set_transitionSet(transitions)
1979
    transitions = []
1980
    transitions.append(fac.Transition(st_1, [
1981
        fac.UpdateInstruction(cc_1, True) ]))
1982
    st_1._set_transitionSet(transitions)
1983
    return fac.Automaton(states, counters, True, containing_state=None)
1984
Sequence_._Automaton = _BuildAutomaton_21()
1985
1986
1987
1988
1989
def _BuildAutomaton_22 ():
1990
    # Remove this helper function from the namespace after it is invoked
1991
    global _BuildAutomaton_22
1992
    del _BuildAutomaton_22
1993
    import pyxb.utils.fac as fac
1994
1995
    counters = set()
1996
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
1997
    counters.add(cc_0)
1998
    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20))
1999
    counters.add(cc_1)
2000
    states = []
2001
    final_update = set()
2002
    final_update.add(fac.UpdateInstruction(cc_0, False))
2003
    symbol = pyxb.binding.content.ElementUse(FDEP_._UseForTag(pyxb.namespace.ExpandedName(None, 'annotations')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 10, 12))
2004
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
2005
    states.append(st_0)
2006
    final_update = set()
2007
    final_update.add(fac.UpdateInstruction(cc_1, False))
2008
    symbol = pyxb.binding.content.ElementUse(FDEP_._UseForTag(pyxb.namespace.ExpandedName(None, 'children')), pyxb.utils.utility.Location('/ore-common/xsd/faulttree.xsd', 27, 20))
2009
    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
2010
    states.append(st_1)
2011
    transitions = []
2012
    transitions.append(fac.Transition(st_0, [
2013
        fac.UpdateInstruction(cc_0, True) ]))
2014
    transitions.append(fac.Transition(st_1, [
2015
        fac.UpdateInstruction(cc_0, False) ]))
2016
    st_0._set_transitionSet(transitions)
2017
    transitions = []
2018
    transitions.append(fac.Transition(st_1, [
2019
        fac.UpdateInstruction(cc_1, True) ]))
2020
    st_1._set_transitionSet(transitions)
2021
    return fac.Automaton(states, counters, True, containing_state=None)
2022
FDEP_._Automaton = _BuildAutomaton_22()
2023
2024