1# Copyright (c) 2017, The MITRE Corporation. All rights reserved. 2# See LICENSE.txt for complete terms. 3 4import sys 5 6from mixbox.binding_utils import * 7 8#List delimiter value for lists captured in *ObjectPropertyTypes 9__LIST_DELIMITER__ = "##comma##" 10 11 12class DateWithPrecisionType(GeneratedsSuper): 13 """This type is used as a replacement for the standard xs:date type but 14 allows for the representation of the precision of the date. If 15 the precision is given, consumers must ignore the portions of 16 this field that is more precise than the given precision. 17 Producers should zero-out (fill with zeros) digits in the date 18 that are required by the xs:date datatype but are beyond the 19 specified precision.In order to avoid ambiguity, it is strongly 20 suggested that all dates include a specification of the timezone 21 if it is known.The precision of the associated date. If omitted, 22 the default is "day", meaning the full field value.""" 23 subclass = None 24 superclass = None 25 def __init__(self, precision='day', valueOf_=None): 26 self.precision = _cast(None, precision) 27 self.valueOf_ = valueOf_ 28 def factory(*args_, **kwargs_): 29 if DateWithPrecisionType.subclass: 30 return DateWithPrecisionType.subclass(*args_, **kwargs_) 31 else: 32 return DateWithPrecisionType(*args_, **kwargs_) 33 factory = staticmethod(factory) 34 def get_precision(self): return self.precision 35 def set_precision(self, precision): self.precision = precision 36 def get_valueOf_(self): return self.valueOf_ 37 def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ 38 def hasContent_(self): 39 if ( 40 self.valueOf_ 41 ): 42 return True 43 else: 44 return False 45 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='DateWithPrecisionType', namespacedef_='', pretty_print=True): 46 if pretty_print: 47 eol_ = '\n' 48 else: 49 eol_ = '' 50 showIndent(lwrite, level, pretty_print) 51 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 52 already_processed = set() 53 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='DateWithPrecisionType') 54 if self.hasContent_(): 55 lwrite('>') 56 lwrite(quote_xml(self.valueOf_)) 57 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 58 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 59 else: 60 lwrite('/>%s' % (eol_, )) 61 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='DateWithPrecisionType'): 62 if self.precision not in (None, 'second'): 63 64 lwrite(' precision=%s' % (quote_attrib(self.precision), )) 65 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='DateWithPrecisionType', fromsubclass_=False, pretty_print=True): 66 pass 67 def build(self, node): 68 self.__sourcenode__ = node 69 already_processed = set() 70 self.buildAttributes(node, node.attrib, already_processed) 71 self.valueOf_ = get_all_text_(node) 72 for child in node: 73 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 74 self.buildChildren(child, node, nodeName_) 75 def buildAttributes(self, node, attrs, already_processed): 76 value = find_attr_value_('precision', node) 77 if value is not None: 78 79 self.precision = value 80 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 81 pass 82# end class DateWithPrecisionType 83 84class DateTimeWithPrecisionType(GeneratedsSuper): 85 """This type is used as a replacement for the standard xs:dateTime type 86 but allows for the representation of the precision of the 87 dateTime. If the precision is given, consumers must ignore the 88 portions of this field that is more precise than the given 89 precision. Producers should zero-out (fill with zeros) digits in 90 the dateTime that are required by the xs:dateTime datatype but 91 are beyond the specified precision.In order to avoid ambiguity, 92 it is strongly suggested that all dateTimes include a 93 specification of the timezone if it is known.The precision of 94 the associated dateTime. If omitted, the default is "second", 95 meaning the full field value (including fractional seconds).""" 96 subclass = None 97 superclass = None 98 def __init__(self, precision='second', valueOf_=None): 99 self.precision = _cast(None, precision) 100 self.valueOf_ = valueOf_ 101 def factory(*args_, **kwargs_): 102 if DateTimeWithPrecisionType.subclass: 103 return DateTimeWithPrecisionType.subclass(*args_, **kwargs_) 104 else: 105 return DateTimeWithPrecisionType(*args_, **kwargs_) 106 factory = staticmethod(factory) 107 def get_precision(self): return self.precision 108 def set_precision(self, precision): self.precision = precision 109 def get_valueOf_(self): return self.valueOf_ 110 def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ 111 def hasContent_(self): 112 if ( 113 self.valueOf_ 114 ): 115 return True 116 else: 117 return False 118 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='DateTimeWithPrecisionType', namespacedef_='', pretty_print=True): 119 if pretty_print: 120 eol_ = '\n' 121 else: 122 eol_ = '' 123 showIndent(lwrite, level, pretty_print) 124 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 125 already_processed = set() 126 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='DateTimeWithPrecisionType') 127 if self.hasContent_(): 128 lwrite('>') 129 lwrite(quote_xml(self.valueOf_)) 130 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 131 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 132 else: 133 lwrite('/>%s' % (eol_, )) 134 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='DateTimeWithPrecisionType'): 135 if self.precision not in (None, 'second'): 136 137 lwrite(' precision=%s' % (quote_attrib(self.precision), )) 138 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='DateTimeWithPrecisionType', fromsubclass_=False, pretty_print=True): 139 pass 140 def build(self, node): 141 self.__sourcenode__ = node 142 already_processed = set() 143 self.buildAttributes(node, node.attrib, already_processed) 144 self.valueOf_ = get_all_text_(node) 145 for child in node: 146 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 147 self.buildChildren(child, node, nodeName_) 148 def buildAttributes(self, node, attrs, already_processed): 149 value = find_attr_value_('precision', node) 150 if value is not None: 151 152 self.precision = value 153 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 154 pass 155# end class DateTimeWithPrecisionType 156 157class LocationType(GeneratedsSuper): 158 """The LocationType is used to express geographic location 159 information.This type is extended through the xsi:type 160 mechanism. The default type is CIQAddress3.0InstanceType in the 161 http://cybox.mitre.org/extensions/Address#CIQAddress3.0-1 162 namespace. This type is defined in the 163 extensions/location/ciq_address_3.0.xsd file or at the URL http: 164 //cybox.mitre.org/XMLSchema/extensions/location/ciq_address_3.0/ 165 1.0/ciq_address_3.0.xsd.Those who wish to express a simple name 166 may also do so by not specifying an xsi:type and using the Name 167 field of this type.Specifies a unique ID for this 168 Location.Specifies a reference to a unique ID defined elsewhere.""" 169 subclass = None 170 superclass = None 171 def __init__(self, idref=None, id=None, Name=None): 172 self.idref = _cast(None, idref) 173 self.id = _cast(None, id) 174 self.Name = Name 175 def factory(*args_, **kwargs_): 176 if LocationType.subclass: 177 return LocationType.subclass(*args_, **kwargs_) 178 else: 179 return LocationType(*args_, **kwargs_) 180 factory = staticmethod(factory) 181 def get_Name(self): return self.Name 182 def set_Name(self, Name): self.Name = Name 183 def get_idref(self): return self.idref 184 def set_idref(self, idref): self.idref = idref 185 def get_id(self): return self.id 186 def set_id(self, id): self.id = id 187 def hasContent_(self): 188 if ( 189 self.Name is not None 190 ): 191 return True 192 else: 193 return False 194 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='LocationType', namespacedef_='', pretty_print=True): 195 if pretty_print: 196 eol_ = '\n' 197 else: 198 eol_ = '' 199 showIndent(lwrite, level, pretty_print) 200 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 201 already_processed = set() 202 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='LocationType') 203 if self.hasContent_(): 204 lwrite('>%s' % (eol_, )) 205 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 206 showIndent(lwrite, level, pretty_print) 207 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 208 else: 209 lwrite('/>%s' % (eol_, )) 210 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='LocationType'): 211 if self.idref is not None: 212 213 lwrite(' idref=%s' % (quote_attrib(self.idref), )) 214 if self.id is not None: 215 216 lwrite(' id=%s' % (quote_attrib(self.id), )) 217 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='LocationType', fromsubclass_=False, pretty_print=True): 218 if pretty_print: 219 eol_ = '\n' 220 else: 221 eol_ = '' 222 if self.Name is not None: 223 showIndent(lwrite, level, pretty_print) 224 lwrite('<%sName>%s</%sName>%s' % ('cyboxCommon:', self.gds_format_string(quote_xml(self.Name), input_name='Name'), 'cyboxCommon:', eol_)) 225 def build(self, node): 226 self.__sourcenode__ = node 227 already_processed = set() 228 self.buildAttributes(node, node.attrib, already_processed) 229 for child in node: 230 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 231 self.buildChildren(child, node, nodeName_) 232 def buildAttributes(self, node, attrs, already_processed): 233 value = find_attr_value_('idref', node) 234 if value is not None: 235 236 self.idref = value 237 value = find_attr_value_('id', node) 238 if value is not None: 239 240 self.id = value 241 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 242 if nodeName_ == 'Name': 243 Name_ = child_.text 244 Name_ = self.gds_validate_string(Name_, node, 'Name') 245 self.Name = Name_ 246# end class LocationType 247 248class MeasureSourceType(GeneratedsSuper): 249 """The MeasureSourceType is a type representing a description of a 250 single cyber observation source.The class field is optional and 251 enables identification of the high-level class of this cyber 252 observation source.The source_type field is optional and enables 253 identification of the broad type of this cyber observation 254 source.The name field is optional and enables the assignment of 255 a relevant name to a this Discovery Method.""" 256 subclass = None 257 superclass = None 258 def __init__(self, source_type=None, sighting_count=None, classxx=None, name=None, Information_Source_Type=None, Tool_Type=None, Description=None, Contributors=None, Time=None, Observation_Location=None, Tools=None, Platform=None, System=None, Instance=None, Observable_Location=None): 259 self.source_type = _cast(None, source_type) 260 self.sighting_count = _cast(int, sighting_count) 261 self.classxx = _cast(None, classxx) 262 self.name = _cast(None, name) 263 self.Information_Source_Type = Information_Source_Type 264 self.Tool_Type = Tool_Type 265 self.Description = Description 266 self.Contributors = Contributors 267 self.Time = Time 268 self.Observation_Location = Observation_Location 269 self.Tools = Tools 270 self.Platform = Platform 271 self.System = System 272 self.Instance = Instance 273 self.Observable_Location = Observable_Location 274 def factory(*args_, **kwargs_): 275 if MeasureSourceType.subclass: 276 return MeasureSourceType.subclass(*args_, **kwargs_) 277 else: 278 return MeasureSourceType(*args_, **kwargs_) 279 factory = staticmethod(factory) 280 def get_Information_Source_Type(self): return self.Information_Source_Type 281 def set_Information_Source_Type(self, Information_Source_Type): self.Information_Source_Type = Information_Source_Type 282 def get_Tool_Type(self): return self.Tool_Type 283 def set_Tool_Type(self, Tool_Type): self.Tool_Type = Tool_Type 284 def get_Description(self): return self.Description 285 def set_Description(self, Description): self.Description = Description 286 def get_Contributors(self): return self.Contributors 287 def set_Contributors(self, Contributors): self.Contributors = Contributors 288 def get_Time(self): return self.Time 289 def set_Time(self, Time): self.Time = Time 290 def get_Observation_Location(self): return self.Observation_Location 291 def set_Observation_Location(self, Observation_Location): self.Observation_Location = Observation_Location 292 def get_Tools(self): return self.Tools 293 def set_Tools(self, Tools): self.Tools = Tools 294 def get_Platform(self): return self.Platform 295 def set_Platform(self, Platform): self.Platform = Platform 296 def get_System(self): return self.System 297 def set_System(self, System): self.System = System 298 def get_Instance(self): return self.Instance 299 def set_Instance(self, Instance): self.Instance = Instance 300 def get_Observable_Location(self): return self.Observable_Location 301 def set_Observable_Location(self, Observable_Location): self.Observable_Location = Observable_Location 302 def get_source_type(self): return self.source_type 303 def set_source_type(self, source_type): self.source_type = source_type 304 def get_sighting_count(self): return self.sighting_count 305 def set_sighting_count(self, sighting_count): self.sighting_count = sighting_count 306 def get_class(self): return self.classxx 307 def set_class(self, classxx): self.classxx = classxx 308 def get_name(self): return self.name 309 def set_name(self, name): self.name = name 310 def hasContent_(self): 311 if ( 312 self.Information_Source_Type is not None or 313 self.Tool_Type is not None or 314 self.Description is not None or 315 self.Contributors is not None or 316 self.Time is not None or 317 self.Observation_Location is not None or 318 self.Tools is not None or 319 self.Platform is not None or 320 self.System is not None or 321 self.Instance is not None or 322 self.Observable_Location is not None 323 ): 324 return True 325 else: 326 return False 327 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='MeasureSourceType', namespacedef_='', pretty_print=True): 328 if pretty_print: 329 eol_ = '\n' 330 else: 331 eol_ = '' 332 showIndent(lwrite, level, pretty_print) 333 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 334 already_processed = set() 335 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='MeasureSourceType') 336 if self.hasContent_(): 337 lwrite('>%s' % (eol_, )) 338 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 339 showIndent(lwrite, level, pretty_print) 340 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 341 else: 342 lwrite('/>%s' % (eol_, )) 343 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='MeasureSourceType'): 344 if self.source_type is not None: 345 346 lwrite(' source_type=%s' % (quote_attrib(self.source_type), )) 347 if self.sighting_count is not None: 348 349 lwrite(' sighting_count="%s"' % self.gds_format_integer(self.sighting_count, input_name='sighting_count')) 350 if self.classxx is not None: 351 352 lwrite(' class=%s' % (quote_attrib(self.classxx), )) 353 if self.name is not None: 354 355 lwrite(' name=%s' % (self.gds_format_string(quote_attrib(self.name), input_name='name'), )) 356 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='MeasureSourceType', fromsubclass_=False, pretty_print=True): 357 if pretty_print: 358 eol_ = '\n' 359 else: 360 eol_ = '' 361 if self.Information_Source_Type is not None: 362 self.Information_Source_Type.export(lwrite, level, 'cyboxCommon:', name_='Information_Source_Type', pretty_print=pretty_print) 363 if self.Tool_Type is not None: 364 self.Tool_Type.export(lwrite, level, 'cyboxCommon:', name_='Tool_Type', pretty_print=pretty_print) 365 if self.Description is not None: 366 self.Description.export(lwrite, level, 'cyboxCommon:', name_='Description', pretty_print=pretty_print) 367 if self.Contributors is not None: 368 self.Contributors.export(lwrite, level, 'cyboxCommon:', name_='Contributors', pretty_print=pretty_print) 369 if self.Time is not None: 370 self.Time.export(lwrite, level, 'cyboxCommon:', name_='Time', pretty_print=pretty_print) 371 if self.Observation_Location is not None: 372 self.Observation_Location.export(lwrite, level, 'cyboxCommon:', name_='Observation_Location', pretty_print=pretty_print) 373 if self.Tools is not None: 374 self.Tools.export(lwrite, level, 'cyboxCommon:', name_='Tools', pretty_print=pretty_print) 375 if self.Platform is not None: 376 self.Platform.export(lwrite, level, 'cyboxCommon:', name_='Platform', pretty_print=pretty_print) 377 if self.System is not None: 378 self.System.export(lwrite, level, 'cyboxCommon:', name_='System', pretty_print=pretty_print) 379 if self.Instance is not None: 380 self.Instance.export(lwrite, level, 'cyboxCommon:', name_='Instance', pretty_print=pretty_print) 381 if self.Observable_Location is not None: 382 self.Observable_Location.export(lwrite, level, 'cyboxCommon:', name_='Observable_Location', pretty_print=pretty_print) 383 def build(self, node): 384 self.__sourcenode__ = node 385 already_processed = set() 386 self.buildAttributes(node, node.attrib, already_processed) 387 for child in node: 388 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 389 self.buildChildren(child, node, nodeName_) 390 def buildAttributes(self, node, attrs, already_processed): 391 value = find_attr_value_('source_type', node) 392 if value is not None: 393 394 self.source_type = value 395 value = find_attr_value_('sighting_count', node) 396 if value is not None: 397 398 try: 399 self.sighting_count = int(value) 400 except ValueError as exp: 401 raise_parse_error(node, 'Bad integer attribute: %s' % exp) 402 if self.sighting_count <= 0: 403 raise_parse_error(node, 'Invalid PositiveInteger') 404 value = find_attr_value_('class', node) 405 if value is not None: 406 407 self.classxx = value 408 value = find_attr_value_('name', node) 409 if value is not None: 410 411 self.name = value 412 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 413 if nodeName_ == 'Information_Source_Type': 414 obj_ = ControlledVocabularyStringType.factory() 415 obj_.build(child_) 416 self.set_Information_Source_Type(obj_) 417 elif nodeName_ == 'Tool_Type': 418 obj_ = ControlledVocabularyStringType.factory() 419 obj_.build(child_) 420 self.set_Tool_Type(obj_) 421 elif nodeName_ == 'Description': 422 obj_ = StructuredTextType.factory() 423 obj_.build(child_) 424 self.set_Description(obj_) 425 elif nodeName_ == 'Contributors': 426 obj_ = PersonnelType.factory() 427 obj_.build(child_) 428 self.set_Contributors(obj_) 429 elif nodeName_ == 'Time': 430 obj_ = TimeType.factory() 431 obj_.build(child_) 432 self.set_Time(obj_) 433 elif nodeName_ == 'Observation_Location': 434 type_name_ = child_.attrib.get('{http://www.w3.org/2001/XMLSchema-instance}type') 435 if type_name_ is None: 436 type_name_ = child_.attrib.get('type') 437 if type_name_ is not None: 438 type_names_ = type_name_.split(':') 439 if len(type_names_) == 1: 440 type_name_ = type_names_[0] 441 else: 442 type_name_ = type_names_[1] 443 444 if type_name_ == "CIQAddress3.0InstanceType": 445 import cybox.bindings.extensions.location.ciq_address_3_0 as ciq_address_binding 446 obj_ = ciq_address_binding.CIQAddress3_0InstanceType.factory() 447 else: 448 obj_ = LocationType.factory() 449 450 obj_.build(child_) 451 self.set_Observation_Location(obj_) 452 elif nodeName_ == 'Tools': 453 obj_ = ToolsInformationType.factory() 454 obj_.build(child_) 455 self.set_Tools(obj_) 456 elif nodeName_ == 'Platform': 457 obj_ = PlatformSpecificationType.factory() 458 obj_.build(child_) 459 self.set_Platform(obj_) 460 elif nodeName_ == 'System': 461 type_name_ = child_.attrib.get( 462 '{http://www.w3.org/2001/XMLSchema-instance}type') 463 if type_name_ is None: 464 type_name_ = child_.attrib.get('type') 465 if type_name_ is not None: 466 type_names_ = type_name_.split(':') 467 if len(type_names_) == 1: 468 type_name_ = type_names_[0] 469 else: 470 type_name_ = type_names_[1] 471 class_ = globals()[type_name_] 472 obj_ = class_.factory() 473 obj_.build(child_) 474 else: 475 raise NotImplementedError( 476 'Class not implemented for <System> element') 477 self.set_System(obj_) 478 elif nodeName_ == 'Instance': 479 type_name_ = child_.attrib.get( 480 '{http://www.w3.org/2001/XMLSchema-instance}type') 481 if type_name_ is None: 482 type_name_ = child_.attrib.get('type') 483 if type_name_ is not None: 484 type_names_ = type_name_.split(':') 485 if len(type_names_) == 1: 486 type_name_ = type_names_[0] 487 else: 488 type_name_ = type_names_[1] 489 class_ = globals()[type_name_] 490 obj_ = class_.factory() 491 obj_.build(child_) 492 else: 493 raise NotImplementedError( 494 'Class not implemented for <Instance> element') 495 self.set_Instance(obj_) 496 elif nodeName_ == 'Observable_Location': 497 type_name_ = child_.attrib.get('{http://www.w3.org/2001/XMLSchema-instance}type') 498 if type_name_ is None: 499 type_name_ = child_.attrib.get('type') 500 if type_name_ is not None: 501 type_names_ = type_name_.split(':') 502 if len(type_names_) == 1: 503 type_name_ = type_names_[0] 504 else: 505 type_name_ = type_names_[1] 506 507 if type_name_ == "CIQAddress3.0InstanceType": 508 import cybox.bindings.extensions.location.ciq_address_3_0 as ciq_address_binding 509 obj_ = ciq_address_binding.CIQAddress3_0InstanceType.factory() 510 else: 511 obj_ = LocationType.factory() 512 513 obj_.build(child_) 514 self.set_Observable_Location(obj_) 515# end class MeasureSourceType 516 517class ContributorType(GeneratedsSuper): 518 """The ContributorType represents a description of an individual who 519 contributed as a source of cyber observation data.""" 520 521 subclass = None 522 superclass = None 523 def __init__(self, Role=None, Name=None, Email=None, Phone=None, Organization=None, Date=None, Contribution_Location=None): 524 self.Role = Role 525 self.Name = Name 526 self.Email = Email 527 self.Phone = Phone 528 self.Organization = Organization 529 self.Date = Date 530 self.Contribution_Location = Contribution_Location 531 def factory(*args_, **kwargs_): 532 if ContributorType.subclass: 533 return ContributorType.subclass(*args_, **kwargs_) 534 else: 535 return ContributorType(*args_, **kwargs_) 536 factory = staticmethod(factory) 537 def get_Role(self): return self.Role 538 def set_Role(self, Role): self.Role = Role 539 def get_Name(self): return self.Name 540 def set_Name(self, Name): self.Name = Name 541 def get_Email(self): return self.Email 542 def set_Email(self, Email): self.Email = Email 543 def get_Phone(self): return self.Phone 544 def set_Phone(self, Phone): self.Phone = Phone 545 def get_Organization(self): return self.Organization 546 def set_Organization(self, Organization): self.Organization = Organization 547 def get_Date(self): return self.Date 548 def set_Date(self, Date): self.Date = Date 549 def get_Contribution_Location(self): return self.Contribution_Location 550 def set_Contribution_Location(self, Contribution_Location): self.Contribution_Location = Contribution_Location 551 def hasContent_(self): 552 if ( 553 self.Role is not None or 554 self.Name is not None or 555 self.Email is not None or 556 self.Phone is not None or 557 self.Organization is not None or 558 self.Date is not None or 559 self.Contribution_Location is not None 560 ): 561 return True 562 else: 563 return False 564 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='ContributorType', namespacedef_='', pretty_print=True): 565 if pretty_print: 566 eol_ = '\n' 567 else: 568 eol_ = '' 569 showIndent(lwrite, level, pretty_print) 570 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 571 already_processed = set() 572 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='ContributorType') 573 if self.hasContent_(): 574 lwrite('>%s' % (eol_, )) 575 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 576 showIndent(lwrite, level, pretty_print) 577 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 578 else: 579 lwrite('/>%s' % (eol_, )) 580 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='ContributorType'): 581 pass 582 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='ContributorType', fromsubclass_=False, pretty_print=True): 583 if pretty_print: 584 eol_ = '\n' 585 else: 586 eol_ = '' 587 if self.Role is not None: 588 showIndent(lwrite, level, pretty_print) 589 lwrite('<%sRole>%s</%sRole>%s' % ('cyboxCommon:', self.gds_format_string(quote_xml(self.Role), input_name='Role'), 'cyboxCommon:', eol_)) 590 if self.Name is not None: 591 showIndent(lwrite, level, pretty_print) 592 lwrite('<%sName>%s</%sName>%s' % ('cyboxCommon:', self.gds_format_string(quote_xml(self.Name), input_name='Name'), 'cyboxCommon:', eol_)) 593 if self.Email is not None: 594 showIndent(lwrite, level, pretty_print) 595 lwrite('<%sEmail>%s</%sEmail>%s' % ('cyboxCommon:', self.gds_format_string(quote_xml(self.Email), input_name='Email'), 'cyboxCommon:', eol_)) 596 if self.Phone is not None: 597 showIndent(lwrite, level, pretty_print) 598 lwrite('<%sPhone>%s</%sPhone>%s' % ('cyboxCommon:', self.gds_format_string(quote_xml(self.Phone), input_name='Phone'), 'cyboxCommon:', eol_)) 599 if self.Organization is not None: 600 showIndent(lwrite, level, pretty_print) 601 lwrite('<%sOrganization>%s</%sOrganization>%s' % ('cyboxCommon:', self.gds_format_string(quote_xml(self.Organization), input_name='Organization'), 'cyboxCommon:', eol_)) 602 if self.Date is not None: 603 self.Date.export(lwrite, level, 'cyboxCommon:', name_='Date', pretty_print=pretty_print) 604 if self.Contribution_Location is not None: 605 showIndent(lwrite, level, pretty_print) 606 lwrite('<%sContribution_Location>%s</%sContribution_Location>%s' % ('cyboxCommon:', self.gds_format_string(quote_xml(self.Contribution_Location), input_name='Contribution_Location'), 'cyboxCommon:', eol_)) 607 def build(self, node): 608 self.__sourcenode__ = node 609 already_processed = set() 610 self.buildAttributes(node, node.attrib, already_processed) 611 for child in node: 612 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 613 self.buildChildren(child, node, nodeName_) 614 def buildAttributes(self, node, attrs, already_processed): 615 pass 616 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 617 if nodeName_ == 'Role': 618 Role_ = child_.text 619 Role_ = self.gds_validate_string(Role_, node, 'Role') 620 self.Role = Role_ 621 elif nodeName_ == 'Name': 622 Name_ = child_.text 623 Name_ = self.gds_validate_string(Name_, node, 'Name') 624 self.Name = Name_ 625 elif nodeName_ == 'Email': 626 Email_ = child_.text 627 Email_ = self.gds_validate_string(Email_, node, 'Email') 628 self.Email = Email_ 629 elif nodeName_ == 'Phone': 630 Phone_ = child_.text 631 Phone_ = self.gds_validate_string(Phone_, node, 'Phone') 632 self.Phone = Phone_ 633 elif nodeName_ == 'Organization': 634 Organization_ = child_.text 635 Organization_ = self.gds_validate_string(Organization_, node, 'Organization') 636 self.Organization = Organization_ 637 elif nodeName_ == 'Date': 638 obj_ = DateRangeType.factory() 639 obj_.build(child_) 640 self.set_Date(obj_) 641 elif nodeName_ == 'Contribution_Location': 642 Contribution_Location_ = child_.text 643 Contribution_Location_ = self.gds_validate_string(Contribution_Location_, node, 'Contribution_Location') 644 self.Contribution_Location = Contribution_Location_ 645# end class ContributorType 646 647class DateRangeType(GeneratedsSuper): 648 """The DateRangeType specifies a range of dates.""" 649 subclass = None 650 superclass = None 651 def __init__(self, Start_Date=None, End_Date=None): 652 self.Start_Date = Start_Date 653 self.End_Date = End_Date 654 def factory(*args_, **kwargs_): 655 if DateRangeType.subclass: 656 return DateRangeType.subclass(*args_, **kwargs_) 657 else: 658 return DateRangeType(*args_, **kwargs_) 659 factory = staticmethod(factory) 660 def get_Start_Date(self): return self.Start_Date 661 def set_Start_Date(self, Start_Date): self.Start_Date = Start_Date 662 def get_End_Date(self): return self.End_Date 663 def set_End_Date(self, End_Date): self.End_Date = End_Date 664 def hasContent_(self): 665 if ( 666 self.Start_Date is not None or 667 self.End_Date is not None 668 ): 669 return True 670 else: 671 return False 672 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='DateRangeType', namespacedef_='', pretty_print=True): 673 if pretty_print: 674 eol_ = '\n' 675 else: 676 eol_ = '' 677 showIndent(lwrite, level, pretty_print) 678 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 679 already_processed = set() 680 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='DateRangeType') 681 if self.hasContent_(): 682 lwrite('>%s' % (eol_, )) 683 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 684 showIndent(lwrite, level, pretty_print) 685 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 686 else: 687 lwrite('/>%s' % (eol_, )) 688 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='DateRangeType'): 689 pass 690 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='DateRangeType', fromsubclass_=False, pretty_print=True): 691 if pretty_print: 692 eol_ = '\n' 693 else: 694 eol_ = '' 695 if self.Start_Date is not None: 696 self.Start_Date.export(lwrite, level, 'cyboxCommon:', name_='Start_Date', pretty_print=pretty_print) 697 if self.End_Date is not None: 698 self.End_Date.export(lwrite, level, 'cyboxCommon:', name_='End_Date', pretty_print=pretty_print) 699 def build(self, node): 700 self.__sourcenode__ = node 701 already_processed = set() 702 self.buildAttributes(node, node.attrib, already_processed) 703 for child in node: 704 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 705 self.buildChildren(child, node, nodeName_) 706 def buildAttributes(self, node, attrs, already_processed): 707 pass 708 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 709 if nodeName_ == 'Start_Date': 710 obj_ = DateWithPrecisionType.factory() 711 obj_.build(child_) 712 self.set_Start_Date(obj_) 713 elif nodeName_ == 'End_Date': 714 obj_ = DateWithPrecisionType.factory() 715 obj_.build(child_) 716 self.set_End_Date(obj_) 717# end class DateRangeType 718 719class PersonnelType(GeneratedsSuper): 720 """The PersonnelType is an abstracted data type to standardize the 721 description of sets of personnel.""" 722 723 subclass = None 724 superclass = None 725 def __init__(self, Contributor=None): 726 if Contributor is None: 727 self.Contributor = [] 728 else: 729 self.Contributor = Contributor 730 def factory(*args_, **kwargs_): 731 if PersonnelType.subclass: 732 return PersonnelType.subclass(*args_, **kwargs_) 733 else: 734 return PersonnelType(*args_, **kwargs_) 735 factory = staticmethod(factory) 736 def get_Contributor(self): return self.Contributor 737 def set_Contributor(self, Contributor): self.Contributor = Contributor 738 def add_Contributor(self, value): self.Contributor.append(value) 739 def insert_Contributor(self, index, value): self.Contributor[index] = value 740 def hasContent_(self): 741 if ( 742 self.Contributor 743 ): 744 return True 745 else: 746 return False 747 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='PersonnelType', namespacedef_='', pretty_print=True): 748 if pretty_print: 749 eol_ = '\n' 750 else: 751 eol_ = '' 752 showIndent(lwrite, level, pretty_print) 753 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 754 already_processed = set() 755 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='PersonnelType') 756 if self.hasContent_(): 757 lwrite('>%s' % (eol_, )) 758 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 759 showIndent(lwrite, level, pretty_print) 760 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 761 else: 762 lwrite('/>%s' % (eol_, )) 763 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='PersonnelType'): 764 pass 765 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='PersonnelType', fromsubclass_=False, pretty_print=True): 766 if pretty_print: 767 eol_ = '\n' 768 else: 769 eol_ = '' 770 for Contributor_ in self.Contributor: 771 Contributor_.export(lwrite, level, 'cyboxCommon:', name_='Contributor', pretty_print=pretty_print) 772 def build(self, node): 773 self.__sourcenode__ = node 774 already_processed = set() 775 self.buildAttributes(node, node.attrib, already_processed) 776 for child in node: 777 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 778 self.buildChildren(child, node, nodeName_) 779 def buildAttributes(self, node, attrs, already_processed): 780 pass 781 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 782 if nodeName_ == 'Contributor': 783 obj_ = ContributorType.factory() 784 obj_.build(child_) 785 self.Contributor.append(obj_) 786# end class PersonnelType 787 788class TimeType(GeneratedsSuper): 789 """The TimeType specifies various time properties for this construct.""" 790 subclass = None 791 superclass = None 792 def __init__(self, Start_Time=None, End_Time=None, Produced_Time=None, Received_Time=None): 793 self.Start_Time = Start_Time 794 self.End_Time = End_Time 795 self.Produced_Time = Produced_Time 796 self.Received_Time = Received_Time 797 def factory(*args_, **kwargs_): 798 if TimeType.subclass: 799 return TimeType.subclass(*args_, **kwargs_) 800 else: 801 return TimeType(*args_, **kwargs_) 802 factory = staticmethod(factory) 803 def get_Start_Time(self): return self.Start_Time 804 def set_Start_Time(self, Start_Time): self.Start_Time = Start_Time 805 def get_End_Time(self): return self.End_Time 806 def set_End_Time(self, End_Time): self.End_Time = End_Time 807 def get_Produced_Time(self): return self.Produced_Time 808 def set_Produced_Time(self, Produced_Time): self.Produced_Time = Produced_Time 809 def get_Received_Time(self): return self.Received_Time 810 def set_Received_Time(self, Received_Time): self.Received_Time = Received_Time 811 def hasContent_(self): 812 if ( 813 self.Start_Time is not None or 814 self.End_Time is not None or 815 self.Produced_Time is not None or 816 self.Received_Time is not None 817 ): 818 return True 819 else: 820 return False 821 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='TimeType', namespacedef_='', pretty_print=True): 822 if pretty_print: 823 eol_ = '\n' 824 else: 825 eol_ = '' 826 showIndent(lwrite, level, pretty_print) 827 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 828 already_processed = set() 829 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='TimeType') 830 if self.hasContent_(): 831 lwrite('>%s' % (eol_, )) 832 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 833 showIndent(lwrite, level, pretty_print) 834 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 835 else: 836 lwrite('/>%s' % (eol_, )) 837 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='TimeType'): 838 pass 839 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='TimeType', fromsubclass_=False, pretty_print=True): 840 if pretty_print: 841 eol_ = '\n' 842 else: 843 eol_ = '' 844 if self.Start_Time is not None: 845 self.Start_Time.export(lwrite, level, 'cyboxCommon:', name_='Start_Time', pretty_print=pretty_print) 846 if self.End_Time is not None: 847 self.End_Time.export(lwrite, level, 'cyboxCommon:', name_='End_Time', pretty_print=pretty_print) 848 if self.Produced_Time is not None: 849 self.Produced_Time.export(lwrite, level, 'cyboxCommon:', name_='Produced_Time', pretty_print=pretty_print) 850 if self.Received_Time is not None: 851 self.Received_Time.export(lwrite, level, 'cyboxCommon:', name_='Received_Time', pretty_print=pretty_print) 852 def build(self, node): 853 self.__sourcenode__ = node 854 already_processed = set() 855 self.buildAttributes(node, node.attrib, already_processed) 856 for child in node: 857 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 858 self.buildChildren(child, node, nodeName_) 859 def buildAttributes(self, node, attrs, already_processed): 860 pass 861 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 862 if nodeName_ == 'Start_Time': 863 obj_ = DateTimeWithPrecisionType.factory() 864 obj_.build(child_) 865 self.set_Start_Time(obj_) 866 elif nodeName_ == 'End_Time': 867 obj_ = DateTimeWithPrecisionType.factory() 868 obj_.build(child_) 869 self.set_End_Time(obj_) 870 elif nodeName_ == 'Produced_Time': 871 obj_ = DateTimeWithPrecisionType.factory() 872 obj_.build(child_) 873 self.set_Produced_Time(obj_) 874 elif nodeName_ == 'Received_Time': 875 obj_ = DateTimeWithPrecisionType.factory() 876 obj_.build(child_) 877 self.set_Received_Time(obj_) 878# end class TimeType 879 880class ToolSpecificDataType(GeneratedsSuper): 881 """The ToolSpecificDataType is an Abstract type placeholder within the 882 CybOX schema enabling the inclusion of metadata for a specific 883 type of tool through the use of a custom type defined as an 884 extension of this base Abstract type.""" 885 886 subclass = None 887 superclass = None 888 def __init__(self): 889 pass 890 def factory(*args_, **kwargs_): 891 if ToolSpecificDataType.subclass: 892 return ToolSpecificDataType.subclass(*args_, **kwargs_) 893 else: 894 return ToolSpecificDataType(*args_, **kwargs_) 895 factory = staticmethod(factory) 896 def hasContent_(self): 897 if ( 898 899 ): 900 return True 901 else: 902 return False 903 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='ToolSpecificDataType', namespacedef_='', pretty_print=True): 904 if pretty_print: 905 eol_ = '\n' 906 else: 907 eol_ = '' 908 showIndent(lwrite, level, pretty_print) 909 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 910 already_processed = set() 911 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='ToolSpecificDataType') 912 if self.hasContent_(): 913 lwrite('>%s' % (eol_, )) 914 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 915 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 916 else: 917 lwrite('/>%s' % (eol_, )) 918 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='ToolSpecificDataType'): 919 pass 920 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='ToolSpecificDataType', fromsubclass_=False, pretty_print=True): 921 pass 922 def build(self, node): 923 self.__sourcenode__ = node 924 already_processed = set() 925 self.buildAttributes(node, node.attrib, already_processed) 926 for child in node: 927 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 928 self.buildChildren(child, node, nodeName_) 929 def buildAttributes(self, node, attrs, already_processed): 930 pass 931 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 932 pass 933# end class ToolSpecificDataType 934 935class ToolsInformationType(GeneratedsSuper): 936 """The ToolsInformationType represents a description of a set of 937 automated tools.""" 938 939 subclass = None 940 superclass = None 941 def __init__(self, Tool=None): 942 if Tool is None: 943 self.Tool = [] 944 else: 945 self.Tool = Tool 946 def factory(*args_, **kwargs_): 947 if ToolsInformationType.subclass: 948 return ToolsInformationType.subclass(*args_, **kwargs_) 949 else: 950 return ToolsInformationType(*args_, **kwargs_) 951 factory = staticmethod(factory) 952 def get_Tool(self): return self.Tool 953 def set_Tool(self, Tool): self.Tool = Tool 954 def add_Tool(self, value): self.Tool.append(value) 955 def insert_Tool(self, index, value): self.Tool[index] = value 956 def hasContent_(self): 957 if ( 958 self.Tool 959 ): 960 return True 961 else: 962 return False 963 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='ToolsInformationType', namespacedef_='', pretty_print=True): 964 if pretty_print: 965 eol_ = '\n' 966 else: 967 eol_ = '' 968 showIndent(lwrite, level, pretty_print) 969 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 970 already_processed = set() 971 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='ToolsInformationType') 972 if self.hasContent_(): 973 lwrite('>%s' % (eol_, )) 974 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 975 showIndent(lwrite, level, pretty_print) 976 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 977 else: 978 lwrite('/>%s' % (eol_, )) 979 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='ToolsInformationType'): 980 pass 981 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='ToolsInformationType', fromsubclass_=False, pretty_print=True): 982 if pretty_print: 983 eol_ = '\n' 984 else: 985 eol_ = '' 986 for Tool_ in self.Tool: 987 Tool_.export(lwrite, level, 'cyboxCommon:', name_='Tool', pretty_print=pretty_print) 988 def build(self, node): 989 self.__sourcenode__ = node 990 already_processed = set() 991 self.buildAttributes(node, node.attrib, already_processed) 992 for child in node: 993 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 994 self.buildChildren(child, node, nodeName_) 995 def buildAttributes(self, node, attrs, already_processed): 996 pass 997 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 998 if nodeName_ == 'Tool': 999 obj_ = ToolInformationType.factory() 1000 obj_.build(child_) 1001 self.Tool.append(obj_) 1002# end class ToolsInformationType 1003 1004class ToolInformationType(GeneratedsSuper): 1005 """The ToolInformationType represens a description of a single 1006 automated tool.The id field specifies a unique ID for this 1007 Tool.The idref field specifies reference to a unique ID for this 1008 Tool.""" 1009 1010 subclass = None 1011 superclass = None 1012 def __init__(self, idref=None, id=None, Name=None, Type=None, Description=None, References=None, Vendor=None, Version=None, Service_Pack=None, Tool_Specific_Data=None, Tool_Hashes=None, Tool_Configuration=None, Execution_Environment=None, Errors=None, Metadata=None, Compensation_Model=None): 1013 self.idref = _cast(None, idref) 1014 self.id = _cast(None, id) 1015 self.Name = Name 1016 if Type is None: 1017 self.Type = [] 1018 else: 1019 self.Type = Type 1020 self.Description = Description 1021 self.References = References 1022 self.Vendor = Vendor 1023 self.Version = Version 1024 self.Service_Pack = Service_Pack 1025 self.Tool_Specific_Data = Tool_Specific_Data 1026 self.Tool_Hashes = Tool_Hashes 1027 self.Tool_Configuration = Tool_Configuration 1028 self.Execution_Environment = Execution_Environment 1029 self.Errors = Errors 1030 if Metadata is None: 1031 self.Metadata = [] 1032 else: 1033 self.Metadata = Metadata 1034 self.Compensation_Model = Compensation_Model 1035 def factory(*args_, **kwargs_): 1036 if ToolInformationType.subclass: 1037 return ToolInformationType.subclass(*args_, **kwargs_) 1038 else: 1039 return ToolInformationType(*args_, **kwargs_) 1040 factory = staticmethod(factory) 1041 def get_Name(self): return self.Name 1042 def set_Name(self, Name): self.Name = Name 1043 def get_Type(self): return self.Type 1044 def set_Type(self, Type): self.Type = Type 1045 def add_Type(self, value): self.Type.append(value) 1046 def insert_Type(self, index, value): self.Type[index] = value 1047 def get_Description(self): return self.Description 1048 def set_Description(self, Description): self.Description = Description 1049 def get_References(self): return self.References 1050 def set_References(self, References): self.References = References 1051 def get_Vendor(self): return self.Vendor 1052 def set_Vendor(self, Vendor): self.Vendor = Vendor 1053 def get_Version(self): return self.Version 1054 def set_Version(self, Version): self.Version = Version 1055 def get_Service_Pack(self): return self.Service_Pack 1056 def set_Service_Pack(self, Service_Pack): self.Service_Pack = Service_Pack 1057 def get_Tool_Specific_Data(self): return self.Tool_Specific_Data 1058 def set_Tool_Specific_Data(self, Tool_Specific_Data): self.Tool_Specific_Data = Tool_Specific_Data 1059 def get_Tool_Hashes(self): return self.Tool_Hashes 1060 def set_Tool_Hashes(self, Tool_Hashes): self.Tool_Hashes = Tool_Hashes 1061 def get_Tool_Configuration(self): return self.Tool_Configuration 1062 def set_Tool_Configuration(self, Tool_Configuration): self.Tool_Configuration = Tool_Configuration 1063 def get_Execution_Environment(self): return self.Execution_Environment 1064 def set_Execution_Environment(self, Execution_Environment): self.Execution_Environment = Execution_Environment 1065 def get_Errors(self): return self.Errors 1066 def set_Errors(self, Errors): self.Errors = Errors 1067 def get_Metadata(self): return self.Metadata 1068 def set_Metadata(self, Metadata): self.Metadata = Metadata 1069 def add_Metadata(self, value): self.Metadata.append(value) 1070 def insert_Metadata(self, index, value): self.Metadata[index] = value 1071 def get_Compensation_Model(self): return self.Compensation_Model 1072 def set_Compensation_Model(self, Compensation_Model): self.Compensation_Model = Compensation_Model 1073 def get_idref(self): return self.idref 1074 def set_idref(self, idref): self.idref = idref 1075 def get_id(self): return self.id 1076 def set_id(self, id): self.id = id 1077 def hasContent_(self): 1078 if ( 1079 self.Name is not None or 1080 self.Type or 1081 self.Description is not None or 1082 self.References is not None or 1083 self.Vendor is not None or 1084 self.Version is not None or 1085 self.Service_Pack is not None or 1086 self.Tool_Specific_Data is not None or 1087 self.Tool_Hashes is not None or 1088 self.Tool_Configuration is not None or 1089 self.Execution_Environment is not None or 1090 self.Errors is not None or 1091 self.Metadata or 1092 self.Compensation_Model is not None 1093 ): 1094 return True 1095 else: 1096 return False 1097 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='ToolInformationType', namespacedef_='', pretty_print=True): 1098 if pretty_print: 1099 eol_ = '\n' 1100 else: 1101 eol_ = '' 1102 showIndent(lwrite, level, pretty_print) 1103 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 1104 already_processed = set() 1105 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='ToolInformationType') 1106 if self.hasContent_(): 1107 lwrite('>%s' % (eol_, )) 1108 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 1109 showIndent(lwrite, level, pretty_print) 1110 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 1111 else: 1112 lwrite('/>%s' % (eol_, )) 1113 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='ToolInformationType'): 1114 if self.idref is not None: 1115 1116 lwrite(' idref=%s' % (quote_attrib(self.idref), )) 1117 if self.id is not None: 1118 1119 lwrite(' id=%s' % (quote_attrib(self.id), )) 1120 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='ToolInformationType', fromsubclass_=False, pretty_print=True): 1121 if pretty_print: 1122 eol_ = '\n' 1123 else: 1124 eol_ = '' 1125 if self.Name is not None: 1126 showIndent(lwrite, level, pretty_print) 1127 lwrite('<%sName>%s</%sName>%s' % ('cyboxCommon:', self.gds_format_string(quote_xml(self.Name), input_name='Name'), 'cyboxCommon:', eol_)) 1128 for Type_ in self.Type: 1129 Type_.export(lwrite, level, 'cyboxCommon:', name_='Type', pretty_print=pretty_print) 1130 if self.Description is not None: 1131 self.Description.export(lwrite, level, 'cyboxCommon:', name_='Description', pretty_print=pretty_print) 1132 if self.References is not None: 1133 self.References.export(lwrite, level, 'cyboxCommon:', name_='References', pretty_print=pretty_print) 1134 if self.Vendor is not None: 1135 showIndent(lwrite, level, pretty_print) 1136 lwrite('<%sVendor>%s</%sVendor>%s' % ('cyboxCommon:', self.gds_format_string(quote_xml(self.Vendor), input_name='Vendor'), 'cyboxCommon:', eol_)) 1137 if self.Version is not None: 1138 showIndent(lwrite, level, pretty_print) 1139 lwrite('<%sVersion>%s</%sVersion>%s' % ('cyboxCommon:', self.gds_format_string(quote_xml(self.Version), input_name='Version'), 'cyboxCommon:', eol_)) 1140 if self.Service_Pack is not None: 1141 showIndent(lwrite, level, pretty_print) 1142 lwrite('<%sService_Pack>%s</%sService_Pack>%s' % ('cyboxCommon:', self.gds_format_string(quote_xml(self.Service_Pack), input_name='Service_Pack'), 'cyboxCommon:', eol_)) 1143 if self.Tool_Specific_Data is not None: 1144 self.Tool_Specific_Data.export(lwrite, level, 'cyboxCommon:', name_='Tool_Specific_Data', pretty_print=pretty_print) 1145 if self.Tool_Hashes is not None: 1146 self.Tool_Hashes.export(lwrite, level, 'cyboxCommon:', name_='Tool_Hashes', pretty_print=pretty_print) 1147 if self.Tool_Configuration is not None: 1148 self.Tool_Configuration.export(lwrite, level, 'cyboxCommon:', name_='Tool_Configuration', pretty_print=pretty_print) 1149 if self.Execution_Environment is not None: 1150 self.Execution_Environment.export(lwrite, level, 'cyboxCommon:', name_='Execution_Environment', pretty_print=pretty_print) 1151 if self.Errors is not None: 1152 self.Errors.export(lwrite, level, 'cyboxCommon:', name_='Errors', pretty_print=pretty_print) 1153 for Metadata_ in self.Metadata: 1154 Metadata_.export(lwrite, level, 'cyboxCommon:', name_='Metadata', pretty_print=pretty_print) 1155 if self.Compensation_Model is not None: 1156 self.Compensation_Model.export(lwrite, level, 'cyboxCommon:', name_='Compensation_Model', pretty_print=pretty_print) 1157 def build(self, node): 1158 self.__sourcenode__ = node 1159 already_processed = set() 1160 self.buildAttributes(node, node.attrib, already_processed) 1161 for child in node: 1162 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 1163 self.buildChildren(child, node, nodeName_) 1164 def buildAttributes(self, node, attrs, already_processed): 1165 value = find_attr_value_('idref', node) 1166 if value is not None: 1167 1168 self.idref = value 1169 value = find_attr_value_('id', node) 1170 if value is not None: 1171 1172 self.id = value 1173 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 1174 if nodeName_ == 'Name': 1175 Name_ = child_.text 1176 Name_ = self.gds_validate_string(Name_, node, 'Name') 1177 self.Name = Name_ 1178 elif nodeName_ == 'Type': 1179 obj_ = ControlledVocabularyStringType.factory() 1180 obj_.build(child_) 1181 self.Type.append(obj_) 1182 elif nodeName_ == 'Description': 1183 obj_ = StructuredTextType.factory() 1184 obj_.build(child_) 1185 self.set_Description(obj_) 1186 elif nodeName_ == 'References': 1187 obj_ = ToolReferencesType.factory() 1188 obj_.build(child_) 1189 self.set_References(obj_) 1190 elif nodeName_ == 'Vendor': 1191 Vendor_ = child_.text 1192 Vendor_ = self.gds_validate_string(Vendor_, node, 'Vendor') 1193 self.Vendor = Vendor_ 1194 elif nodeName_ == 'Version': 1195 Version_ = child_.text 1196 Version_ = self.gds_validate_string(Version_, node, 'Version') 1197 self.Version = Version_ 1198 elif nodeName_ == 'Service_Pack': 1199 Service_Pack_ = child_.text 1200 Service_Pack_ = self.gds_validate_string(Service_Pack_, node, 'Service_Pack') 1201 self.Service_Pack = Service_Pack_ 1202 elif nodeName_ == 'Tool_Specific_Data': 1203 type_name_ = child_.attrib.get( 1204 '{http://www.w3.org/2001/XMLSchema-instance}type') 1205 if type_name_ is None: 1206 type_name_ = child_.attrib.get('type') 1207 if type_name_ is not None: 1208 type_names_ = type_name_.split(':') 1209 if len(type_names_) == 1: 1210 type_name_ = type_names_[0] 1211 else: 1212 type_name_ = type_names_[1] 1213 class_ = globals()[type_name_] 1214 obj_ = class_.factory() 1215 obj_.build(child_) 1216 else: 1217 raise NotImplementedError( 1218 'Class not implemented for <Tool_Specific_Data> element') 1219 self.set_Tool_Specific_Data(obj_) 1220 elif nodeName_ == 'Tool_Hashes': 1221 obj_ = HashListType.factory() 1222 obj_.build(child_) 1223 self.set_Tool_Hashes(obj_) 1224 elif nodeName_ == 'Tool_Configuration': 1225 obj_ = ToolConfigurationType.factory() 1226 obj_.build(child_) 1227 self.set_Tool_Configuration(obj_) 1228 elif nodeName_ == 'Execution_Environment': 1229 obj_ = ExecutionEnvironmentType.factory() 1230 obj_.build(child_) 1231 self.set_Execution_Environment(obj_) 1232 elif nodeName_ == 'Errors': 1233 obj_ = ErrorsType.factory() 1234 obj_.build(child_) 1235 self.set_Errors(obj_) 1236 elif nodeName_ == 'Metadata': 1237 obj_ = MetadataType.factory() 1238 obj_.build(child_) 1239 self.Metadata.append(obj_) 1240 elif nodeName_ == 'Compensation_Model': 1241 obj_ = CompensationModelType.factory() 1242 obj_.build(child_) 1243 self.set_Compensation_Model(obj_) 1244# end class ToolInformationType 1245 1246class ToolReferencesType(GeneratedsSuper): 1247 """Used to indicate one or more references to tool instances and 1248 information""" 1249 1250 subclass = None 1251 superclass = None 1252 def __init__(self, Reference=None): 1253 if Reference is None: 1254 self.Reference = [] 1255 else: 1256 self.Reference = Reference 1257 def factory(*args_, **kwargs_): 1258 if ToolReferencesType.subclass: 1259 return ToolReferencesType.subclass(*args_, **kwargs_) 1260 else: 1261 return ToolReferencesType(*args_, **kwargs_) 1262 factory = staticmethod(factory) 1263 def get_Reference(self): return self.Reference 1264 def set_Reference(self, Reference): self.Reference = Reference 1265 def add_Reference(self, value): self.Reference.append(value) 1266 def insert_Reference(self, index, value): self.Reference[index] = value 1267 def hasContent_(self): 1268 if ( 1269 self.Reference 1270 ): 1271 return True 1272 else: 1273 return False 1274 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='ToolReferencesType', namespacedef_='', pretty_print=True): 1275 if pretty_print: 1276 eol_ = '\n' 1277 else: 1278 eol_ = '' 1279 showIndent(lwrite, level, pretty_print) 1280 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 1281 already_processed = set() 1282 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='ToolReferencesType') 1283 if self.hasContent_(): 1284 lwrite('>%s' % (eol_, )) 1285 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 1286 showIndent(lwrite, level, pretty_print) 1287 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 1288 else: 1289 lwrite('/>%s' % (eol_, )) 1290 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='ToolReferencesType'): 1291 pass 1292 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='ToolReferencesType', fromsubclass_=False, pretty_print=True): 1293 if pretty_print: 1294 eol_ = '\n' 1295 else: 1296 eol_ = '' 1297 for Reference_ in self.Reference: 1298 Reference_.export(lwrite, level, 'cyboxCommon:', name_='Reference', pretty_print=pretty_print) 1299 def build(self, node): 1300 self.__sourcenode__ = node 1301 already_processed = set() 1302 self.buildAttributes(node, node.attrib, already_processed) 1303 for child in node: 1304 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 1305 self.buildChildren(child, node, nodeName_) 1306 def buildAttributes(self, node, attrs, already_processed): 1307 pass 1308 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 1309 if nodeName_ == 'Reference': 1310 obj_ = ToolReferenceType.factory() 1311 obj_.build(child_) 1312 self.Reference.append(obj_) 1313# end class ToolReferencesType 1314 1315class ToolReferenceType(GeneratedsSuper): 1316 """Contains one reference to information or instances of a given 1317 toolIndicates the nature of the referenced material 1318 (documentation, source, executable, etc.)""" 1319 1320 subclass = None 1321 superclass = None 1322 def __init__(self, reference_type=None, valueOf_=None): 1323 self.reference_type = _cast(None, reference_type) 1324 self.valueOf_ = valueOf_ 1325 def factory(*args_, **kwargs_): 1326 if ToolReferenceType.subclass: 1327 return ToolReferenceType.subclass(*args_, **kwargs_) 1328 else: 1329 return ToolReferenceType(*args_, **kwargs_) 1330 factory = staticmethod(factory) 1331 def get_reference_type(self): return self.reference_type 1332 def set_reference_type(self, reference_type): self.reference_type = reference_type 1333 def get_valueOf_(self): return self.valueOf_ 1334 def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ 1335 def hasContent_(self): 1336 if ( 1337 self.valueOf_ 1338 ): 1339 return True 1340 else: 1341 return False 1342 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='ToolReferenceType', namespacedef_='', pretty_print=True): 1343 if pretty_print: 1344 eol_ = '\n' 1345 else: 1346 eol_ = '' 1347 showIndent(lwrite, level, pretty_print) 1348 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 1349 already_processed = set() 1350 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='ToolReferenceType') 1351 if self.hasContent_(): 1352 lwrite('>') 1353 lwrite(quote_xml(self.valueOf_)) 1354 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 1355 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 1356 else: 1357 lwrite('/>%s' % (eol_, )) 1358 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='ToolReferenceType'): 1359 if self.reference_type is not None: 1360 1361 lwrite(' reference_type=%s' % (quote_attrib(self.reference_type), )) 1362 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='ToolReferenceType', fromsubclass_=False, pretty_print=True): 1363 pass 1364 def build(self, node): 1365 self.__sourcenode__ = node 1366 already_processed = set() 1367 self.buildAttributes(node, node.attrib, already_processed) 1368 self.valueOf_ = get_all_text_(node) 1369 for child in node: 1370 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 1371 self.buildChildren(child, node, nodeName_) 1372 def buildAttributes(self, node, attrs, already_processed): 1373 value = find_attr_value_('reference_type', node) 1374 if value is not None: 1375 1376 self.reference_type = value 1377 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 1378 pass 1379# end class ToolReferenceType 1380 1381class ToolConfigurationType(GeneratedsSuper): 1382 """The ToolConfigurationType characterizes the configuration for a tool 1383 used as a cyber observation source.""" 1384 subclass = None 1385 superclass = None 1386 def __init__(self, Configuration_Settings=None, Dependencies=None, Usage_Context_Assumptions=None, Internationalization_Settings=None, Build_Information=None): 1387 self.Configuration_Settings = Configuration_Settings 1388 self.Dependencies = Dependencies 1389 self.Usage_Context_Assumptions = Usage_Context_Assumptions 1390 self.Internationalization_Settings = Internationalization_Settings 1391 self.Build_Information = Build_Information 1392 def factory(*args_, **kwargs_): 1393 if ToolConfigurationType.subclass: 1394 return ToolConfigurationType.subclass(*args_, **kwargs_) 1395 else: 1396 return ToolConfigurationType(*args_, **kwargs_) 1397 factory = staticmethod(factory) 1398 def get_Configuration_Settings(self): return self.Configuration_Settings 1399 def set_Configuration_Settings(self, Configuration_Settings): self.Configuration_Settings = Configuration_Settings 1400 def get_Dependencies(self): return self.Dependencies 1401 def set_Dependencies(self, Dependencies): self.Dependencies = Dependencies 1402 def get_Usage_Context_Assumptions(self): return self.Usage_Context_Assumptions 1403 def set_Usage_Context_Assumptions(self, Usage_Context_Assumptions): self.Usage_Context_Assumptions = Usage_Context_Assumptions 1404 def get_Internationalization_Settings(self): return self.Internationalization_Settings 1405 def set_Internationalization_Settings(self, Internationalization_Settings): self.Internationalization_Settings = Internationalization_Settings 1406 def get_Build_Information(self): return self.Build_Information 1407 def set_Build_Information(self, Build_Information): self.Build_Information = Build_Information 1408 def hasContent_(self): 1409 if ( 1410 self.Configuration_Settings is not None or 1411 self.Dependencies is not None or 1412 self.Usage_Context_Assumptions is not None or 1413 self.Internationalization_Settings is not None or 1414 self.Build_Information is not None 1415 ): 1416 return True 1417 else: 1418 return False 1419 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='ToolConfigurationType', namespacedef_='', pretty_print=True): 1420 if pretty_print: 1421 eol_ = '\n' 1422 else: 1423 eol_ = '' 1424 showIndent(lwrite, level, pretty_print) 1425 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 1426 already_processed = set() 1427 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='ToolConfigurationType') 1428 if self.hasContent_(): 1429 lwrite('>%s' % (eol_, )) 1430 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 1431 showIndent(lwrite, level, pretty_print) 1432 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 1433 else: 1434 lwrite('/>%s' % (eol_, )) 1435 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='ToolConfigurationType'): 1436 pass 1437 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='ToolConfigurationType', fromsubclass_=False, pretty_print=True): 1438 if pretty_print: 1439 eol_ = '\n' 1440 else: 1441 eol_ = '' 1442 if self.Configuration_Settings is not None: 1443 self.Configuration_Settings.export(lwrite, level, 'cyboxCommon:', name_='Configuration_Settings', pretty_print=pretty_print) 1444 if self.Dependencies is not None: 1445 self.Dependencies.export(lwrite, level, 'cyboxCommon:', name_='Dependencies', pretty_print=pretty_print) 1446 if self.Usage_Context_Assumptions is not None: 1447 self.Usage_Context_Assumptions.export(lwrite, level, 'cyboxCommon:', name_='Usage_Context_Assumptions', pretty_print=pretty_print) 1448 if self.Internationalization_Settings is not None: 1449 self.Internationalization_Settings.export(lwrite, level, 'cyboxCommon:', name_='Internationalization_Settings', pretty_print=pretty_print) 1450 if self.Build_Information is not None: 1451 self.Build_Information.export(lwrite, level, 'cyboxCommon:', name_='Build_Information', pretty_print=pretty_print) 1452 def build(self, node): 1453 self.__sourcenode__ = node 1454 already_processed = set() 1455 self.buildAttributes(node, node.attrib, already_processed) 1456 for child in node: 1457 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 1458 self.buildChildren(child, node, nodeName_) 1459 def buildAttributes(self, node, attrs, already_processed): 1460 pass 1461 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 1462 if nodeName_ == 'Configuration_Settings': 1463 obj_ = ConfigurationSettingsType.factory() 1464 obj_.build(child_) 1465 self.set_Configuration_Settings(obj_) 1466 elif nodeName_ == 'Dependencies': 1467 obj_ = DependenciesType.factory() 1468 obj_.build(child_) 1469 self.set_Dependencies(obj_) 1470 elif nodeName_ == 'Usage_Context_Assumptions': 1471 obj_ = UsageContextAssumptionsType.factory() 1472 obj_.build(child_) 1473 self.set_Usage_Context_Assumptions(obj_) 1474 elif nodeName_ == 'Internationalization_Settings': 1475 obj_ = InternationalizationSettingsType.factory() 1476 obj_.build(child_) 1477 self.set_Internationalization_Settings(obj_) 1478 elif nodeName_ == 'Build_Information': 1479 obj_ = BuildInformationType.factory() 1480 obj_.build(child_) 1481 self.set_Build_Information(obj_) 1482# end class ToolConfigurationType 1483 1484class ConfigurationSettingsType(GeneratedsSuper): 1485 """The ConfigurationSettingsType is a modularized data type used to 1486 provide a consistent approach to describing configuration 1487 settings for a tool, application or other cyber object""" 1488 1489 subclass = None 1490 superclass = None 1491 def __init__(self, Configuration_Setting=None): 1492 if Configuration_Setting is None: 1493 self.Configuration_Setting = [] 1494 else: 1495 self.Configuration_Setting = Configuration_Setting 1496 def factory(*args_, **kwargs_): 1497 if ConfigurationSettingsType.subclass: 1498 return ConfigurationSettingsType.subclass(*args_, **kwargs_) 1499 else: 1500 return ConfigurationSettingsType(*args_, **kwargs_) 1501 factory = staticmethod(factory) 1502 def get_Configuration_Setting(self): return self.Configuration_Setting 1503 def set_Configuration_Setting(self, Configuration_Setting): self.Configuration_Setting = Configuration_Setting 1504 def add_Configuration_Setting(self, value): self.Configuration_Setting.append(value) 1505 def insert_Configuration_Setting(self, index, value): self.Configuration_Setting[index] = value 1506 def hasContent_(self): 1507 if ( 1508 self.Configuration_Setting 1509 ): 1510 return True 1511 else: 1512 return False 1513 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='ConfigurationSettingsType', namespacedef_='', pretty_print=True): 1514 if pretty_print: 1515 eol_ = '\n' 1516 else: 1517 eol_ = '' 1518 showIndent(lwrite, level, pretty_print) 1519 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 1520 already_processed = set() 1521 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='ConfigurationSettingsType') 1522 if self.hasContent_(): 1523 lwrite('>%s' % (eol_, )) 1524 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 1525 showIndent(lwrite, level, pretty_print) 1526 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 1527 else: 1528 lwrite('/>%s' % (eol_, )) 1529 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='ConfigurationSettingsType'): 1530 pass 1531 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='ConfigurationSettingsType', fromsubclass_=False, pretty_print=True): 1532 if pretty_print: 1533 eol_ = '\n' 1534 else: 1535 eol_ = '' 1536 for Configuration_Setting_ in self.Configuration_Setting: 1537 Configuration_Setting_.export(lwrite, level, 'cyboxCommon:', name_='Configuration_Setting', pretty_print=pretty_print) 1538 def build(self, node): 1539 self.__sourcenode__ = node 1540 already_processed = set() 1541 self.buildAttributes(node, node.attrib, already_processed) 1542 for child in node: 1543 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 1544 self.buildChildren(child, node, nodeName_) 1545 def buildAttributes(self, node, attrs, already_processed): 1546 pass 1547 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 1548 if nodeName_ == 'Configuration_Setting': 1549 obj_ = ConfigurationSettingType.factory() 1550 obj_.build(child_) 1551 self.Configuration_Setting.append(obj_) 1552# end class ConfigurationSettingsType 1553 1554class ConfigurationSettingType(GeneratedsSuper): 1555 """The ConfigurationSettingType is a modularized data type used to 1556 provide a consistent approach to describing a particular 1557 configuration setting for a tool, application or other cyber 1558 object""" 1559 1560 subclass = None 1561 superclass = None 1562 def __init__(self, Item_Name=None, Item_Value=None, Item_Type=None, Item_Description=None): 1563 self.Item_Name = Item_Name 1564 self.Item_Value = Item_Value 1565 self.Item_Type = Item_Type 1566 self.Item_Description = Item_Description 1567 def factory(*args_, **kwargs_): 1568 if ConfigurationSettingType.subclass: 1569 return ConfigurationSettingType.subclass(*args_, **kwargs_) 1570 else: 1571 return ConfigurationSettingType(*args_, **kwargs_) 1572 factory = staticmethod(factory) 1573 def get_Item_Name(self): return self.Item_Name 1574 def set_Item_Name(self, Item_Name): self.Item_Name = Item_Name 1575 def get_Item_Value(self): return self.Item_Value 1576 def set_Item_Value(self, Item_Value): self.Item_Value = Item_Value 1577 def get_Item_Type(self): return self.Item_Type 1578 def set_Item_Type(self, Item_Type): self.Item_Type = Item_Type 1579 def get_Item_Description(self): return self.Item_Description 1580 def set_Item_Description(self, Item_Description): self.Item_Description = Item_Description 1581 def hasContent_(self): 1582 if ( 1583 self.Item_Name is not None or 1584 self.Item_Value is not None or 1585 self.Item_Type is not None or 1586 self.Item_Description is not None 1587 ): 1588 return True 1589 else: 1590 return False 1591 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='ConfigurationSettingType', namespacedef_='', pretty_print=True): 1592 if pretty_print: 1593 eol_ = '\n' 1594 else: 1595 eol_ = '' 1596 showIndent(lwrite, level, pretty_print) 1597 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 1598 already_processed = set() 1599 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='ConfigurationSettingType') 1600 if self.hasContent_(): 1601 lwrite('>%s' % (eol_, )) 1602 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 1603 showIndent(lwrite, level, pretty_print) 1604 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 1605 else: 1606 lwrite('/>%s' % (eol_, )) 1607 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='ConfigurationSettingType'): 1608 pass 1609 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='ConfigurationSettingType', fromsubclass_=False, pretty_print=True): 1610 if pretty_print: 1611 eol_ = '\n' 1612 else: 1613 eol_ = '' 1614 if self.Item_Name is not None: 1615 showIndent(lwrite, level, pretty_print) 1616 lwrite('<%sItem_Name>%s</%sItem_Name>%s' % ('cyboxCommon:', self.gds_format_string(quote_xml(self.Item_Name), input_name='Item_Name'), 'cyboxCommon:', eol_)) 1617 if self.Item_Value is not None: 1618 showIndent(lwrite, level, pretty_print) 1619 lwrite('<%sItem_Value>%s</%sItem_Value>%s' % ('cyboxCommon:', self.gds_format_string(quote_xml(self.Item_Value), input_name='Item_Value'), 'cyboxCommon:', eol_)) 1620 if self.Item_Type is not None: 1621 showIndent(lwrite, level, pretty_print) 1622 lwrite('<%sItem_Type>%s</%sItem_Type>%s' % ('cyboxCommon:', self.gds_format_string(quote_xml(self.Item_Type), input_name='Item_Type'), 'cyboxCommon:', eol_)) 1623 if self.Item_Description is not None: 1624 showIndent(lwrite, level, pretty_print) 1625 lwrite('<%sItem_Description>%s</%sItem_Description>%s' % ('cyboxCommon:', self.gds_format_string(quote_xml(self.Item_Description), input_name='Item_Description'), 'cyboxCommon:', eol_)) 1626 def build(self, node): 1627 self.__sourcenode__ = node 1628 already_processed = set() 1629 self.buildAttributes(node, node.attrib, already_processed) 1630 for child in node: 1631 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 1632 self.buildChildren(child, node, nodeName_) 1633 def buildAttributes(self, node, attrs, already_processed): 1634 pass 1635 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 1636 if nodeName_ == 'Item_Name': 1637 Item_Name_ = child_.text 1638 Item_Name_ = self.gds_validate_string(Item_Name_, node, 'Item_Name') 1639 self.Item_Name = Item_Name_ 1640 elif nodeName_ == 'Item_Value': 1641 Item_Value_ = child_.text 1642 Item_Value_ = self.gds_validate_string(Item_Value_, node, 'Item_Value') 1643 self.Item_Value = Item_Value_ 1644 elif nodeName_ == 'Item_Type': 1645 Item_Type_ = child_.text 1646 Item_Type_ = self.gds_validate_string(Item_Type_, node, 'Item_Type') 1647 self.Item_Type = Item_Type_ 1648 elif nodeName_ == 'Item_Description': 1649 Item_Description_ = child_.text 1650 Item_Description_ = self.gds_validate_string(Item_Description_, node, 'Item_Description') 1651 self.Item_Description = Item_Description_ 1652# end class ConfigurationSettingType 1653 1654class DependenciesType(GeneratedsSuper): 1655 """The DependenciesType contains information describing a set of 1656 dependencies for this tool.""" 1657 1658 subclass = None 1659 superclass = None 1660 def __init__(self, Dependency=None): 1661 if Dependency is None: 1662 self.Dependency = [] 1663 else: 1664 self.Dependency = Dependency 1665 def factory(*args_, **kwargs_): 1666 if DependenciesType.subclass: 1667 return DependenciesType.subclass(*args_, **kwargs_) 1668 else: 1669 return DependenciesType(*args_, **kwargs_) 1670 factory = staticmethod(factory) 1671 def get_Dependency(self): return self.Dependency 1672 def set_Dependency(self, Dependency): self.Dependency = Dependency 1673 def add_Dependency(self, value): self.Dependency.append(value) 1674 def insert_Dependency(self, index, value): self.Dependency[index] = value 1675 def hasContent_(self): 1676 if ( 1677 self.Dependency 1678 ): 1679 return True 1680 else: 1681 return False 1682 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='DependenciesType', namespacedef_='', pretty_print=True): 1683 if pretty_print: 1684 eol_ = '\n' 1685 else: 1686 eol_ = '' 1687 showIndent(lwrite, level, pretty_print) 1688 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 1689 already_processed = set() 1690 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='DependenciesType') 1691 if self.hasContent_(): 1692 lwrite('>%s' % (eol_, )) 1693 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 1694 showIndent(lwrite, level, pretty_print) 1695 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 1696 else: 1697 lwrite('/>%s' % (eol_, )) 1698 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='DependenciesType'): 1699 pass 1700 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='DependenciesType', fromsubclass_=False, pretty_print=True): 1701 if pretty_print: 1702 eol_ = '\n' 1703 else: 1704 eol_ = '' 1705 for Dependency_ in self.Dependency: 1706 Dependency_.export(lwrite, level, 'cyboxCommon:', name_='Dependency', pretty_print=pretty_print) 1707 def build(self, node): 1708 self.__sourcenode__ = node 1709 already_processed = set() 1710 self.buildAttributes(node, node.attrib, already_processed) 1711 for child in node: 1712 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 1713 self.buildChildren(child, node, nodeName_) 1714 def buildAttributes(self, node, attrs, already_processed): 1715 pass 1716 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 1717 if nodeName_ == 'Dependency': 1718 obj_ = DependencyType.factory() 1719 obj_.build(child_) 1720 self.Dependency.append(obj_) 1721# end class DependenciesType 1722 1723class DependencyType(GeneratedsSuper): 1724 """The DependencyType contains information describing a single 1725 dependency for this tool.""" 1726 1727 subclass = None 1728 superclass = None 1729 def __init__(self, Dependency_Type=None, Dependency_Description=None): 1730 self.Dependency_Type = Dependency_Type 1731 self.Dependency_Description = Dependency_Description 1732 def factory(*args_, **kwargs_): 1733 if DependencyType.subclass: 1734 return DependencyType.subclass(*args_, **kwargs_) 1735 else: 1736 return DependencyType(*args_, **kwargs_) 1737 factory = staticmethod(factory) 1738 def get_Dependency_Type(self): return self.Dependency_Type 1739 def set_Dependency_Type(self, Dependency_Type): self.Dependency_Type = Dependency_Type 1740 def get_Dependency_Description(self): return self.Dependency_Description 1741 def set_Dependency_Description(self, Dependency_Description): self.Dependency_Description = Dependency_Description 1742 def hasContent_(self): 1743 if ( 1744 self.Dependency_Type is not None or 1745 self.Dependency_Description is not None 1746 ): 1747 return True 1748 else: 1749 return False 1750 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='DependencyType', namespacedef_='', pretty_print=True): 1751 if pretty_print: 1752 eol_ = '\n' 1753 else: 1754 eol_ = '' 1755 showIndent(lwrite, level, pretty_print) 1756 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 1757 already_processed = set() 1758 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='DependencyType') 1759 if self.hasContent_(): 1760 lwrite('>%s' % (eol_, )) 1761 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 1762 showIndent(lwrite, level, pretty_print) 1763 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 1764 else: 1765 lwrite('/>%s' % (eol_, )) 1766 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='DependencyType'): 1767 pass 1768 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='DependencyType', fromsubclass_=False, pretty_print=True): 1769 if pretty_print: 1770 eol_ = '\n' 1771 else: 1772 eol_ = '' 1773 if self.Dependency_Type is not None: 1774 showIndent(lwrite, level, pretty_print) 1775 lwrite('<%sDependency_Type>%s</%sDependency_Type>%s' % ('cyboxCommon:', self.gds_format_string(quote_xml(self.Dependency_Type), input_name='Dependency_Type'), 'cyboxCommon:', eol_)) 1776 if self.Dependency_Description is not None: 1777 self.Dependency_Description.export(lwrite, level, 'cyboxCommon:', name_='Dependency_Description', pretty_print=pretty_print) 1778 def build(self, node): 1779 self.__sourcenode__ = node 1780 already_processed = set() 1781 self.buildAttributes(node, node.attrib, already_processed) 1782 for child in node: 1783 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 1784 self.buildChildren(child, node, nodeName_) 1785 def buildAttributes(self, node, attrs, already_processed): 1786 pass 1787 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 1788 if nodeName_ == 'Dependency_Type': 1789 Dependency_Type_ = child_.text 1790 Dependency_Type_ = self.gds_validate_string(Dependency_Type_, node, 'Dependency_Type') 1791 self.Dependency_Type = Dependency_Type_ 1792 elif nodeName_ == 'Dependency_Description': 1793 obj_ = StructuredTextType.factory() 1794 obj_.build(child_) 1795 self.set_Dependency_Description(obj_) 1796# end class DependencyType 1797 1798class UsageContextAssumptionsType(GeneratedsSuper): 1799 """The UsageContextAssumptionsType contains descriptions of the various 1800 relevant usage context assumptions for this tool""" 1801 1802 subclass = None 1803 superclass = None 1804 def __init__(self, Usage_Context_Assumption=None): 1805 if Usage_Context_Assumption is None: 1806 self.Usage_Context_Assumption = [] 1807 else: 1808 self.Usage_Context_Assumption = Usage_Context_Assumption 1809 def factory(*args_, **kwargs_): 1810 if UsageContextAssumptionsType.subclass: 1811 return UsageContextAssumptionsType.subclass(*args_, **kwargs_) 1812 else: 1813 return UsageContextAssumptionsType(*args_, **kwargs_) 1814 factory = staticmethod(factory) 1815 def get_Usage_Context_Assumption(self): return self.Usage_Context_Assumption 1816 def set_Usage_Context_Assumption(self, Usage_Context_Assumption): self.Usage_Context_Assumption = Usage_Context_Assumption 1817 def add_Usage_Context_Assumption(self, value): self.Usage_Context_Assumption.append(value) 1818 def insert_Usage_Context_Assumption(self, index, value): self.Usage_Context_Assumption[index] = value 1819 def hasContent_(self): 1820 if ( 1821 self.Usage_Context_Assumption 1822 ): 1823 return True 1824 else: 1825 return False 1826 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='UsageContextAssumptionsType', namespacedef_='', pretty_print=True): 1827 if pretty_print: 1828 eol_ = '\n' 1829 else: 1830 eol_ = '' 1831 showIndent(lwrite, level, pretty_print) 1832 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 1833 already_processed = set() 1834 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='UsageContextAssumptionsType') 1835 if self.hasContent_(): 1836 lwrite('>%s' % (eol_, )) 1837 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 1838 showIndent(lwrite, level, pretty_print) 1839 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 1840 else: 1841 lwrite('/>%s' % (eol_, )) 1842 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='UsageContextAssumptionsType'): 1843 pass 1844 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='UsageContextAssumptionsType', fromsubclass_=False, pretty_print=True): 1845 if pretty_print: 1846 eol_ = '\n' 1847 else: 1848 eol_ = '' 1849 for Usage_Context_Assumption_ in self.Usage_Context_Assumption: 1850 Usage_Context_Assumption_.export(lwrite, level, 'cyboxCommon:', name_='Usage_Context_Assumption', pretty_print=pretty_print) 1851 def build(self, node): 1852 self.__sourcenode__ = node 1853 already_processed = set() 1854 self.buildAttributes(node, node.attrib, already_processed) 1855 for child in node: 1856 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 1857 self.buildChildren(child, node, nodeName_) 1858 def buildAttributes(self, node, attrs, already_processed): 1859 pass 1860 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 1861 if nodeName_ == 'Usage_Context_Assumption': 1862 obj_ = StructuredTextType.factory() 1863 obj_.build(child_) 1864 self.Usage_Context_Assumption.append(obj_) 1865# end class UsageContextAssumptionsType 1866 1867class InternationalizationSettingsType(GeneratedsSuper): 1868 """The InternationalizationSettingsType contains information describing 1869 relevant internationalization setting for this tool""" 1870 1871 subclass = None 1872 superclass = None 1873 def __init__(self, Internal_Strings=None): 1874 if Internal_Strings is None: 1875 self.Internal_Strings = [] 1876 else: 1877 self.Internal_Strings = Internal_Strings 1878 def factory(*args_, **kwargs_): 1879 if InternationalizationSettingsType.subclass: 1880 return InternationalizationSettingsType.subclass(*args_, **kwargs_) 1881 else: 1882 return InternationalizationSettingsType(*args_, **kwargs_) 1883 factory = staticmethod(factory) 1884 def get_Internal_Strings(self): return self.Internal_Strings 1885 def set_Internal_Strings(self, Internal_Strings): self.Internal_Strings = Internal_Strings 1886 def add_Internal_Strings(self, value): self.Internal_Strings.append(value) 1887 def insert_Internal_Strings(self, index, value): self.Internal_Strings[index] = value 1888 def hasContent_(self): 1889 if ( 1890 self.Internal_Strings 1891 ): 1892 return True 1893 else: 1894 return False 1895 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='InternationalizationSettingsType', namespacedef_='', pretty_print=True): 1896 if pretty_print: 1897 eol_ = '\n' 1898 else: 1899 eol_ = '' 1900 showIndent(lwrite, level, pretty_print) 1901 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 1902 already_processed = set() 1903 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='InternationalizationSettingsType') 1904 if self.hasContent_(): 1905 lwrite('>%s' % (eol_, )) 1906 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 1907 showIndent(lwrite, level, pretty_print) 1908 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 1909 else: 1910 lwrite('/>%s' % (eol_, )) 1911 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='InternationalizationSettingsType'): 1912 pass 1913 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='InternationalizationSettingsType', fromsubclass_=False, pretty_print=True): 1914 if pretty_print: 1915 eol_ = '\n' 1916 else: 1917 eol_ = '' 1918 for Internal_Strings_ in self.Internal_Strings: 1919 Internal_Strings_.export(lwrite, level, 'cyboxCommon:', name_='Internal_Strings', pretty_print=pretty_print) 1920 def build(self, node): 1921 self.__sourcenode__ = node 1922 already_processed = set() 1923 self.buildAttributes(node, node.attrib, already_processed) 1924 for child in node: 1925 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 1926 self.buildChildren(child, node, nodeName_) 1927 def buildAttributes(self, node, attrs, already_processed): 1928 pass 1929 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 1930 if nodeName_ == 'Internal_Strings': 1931 obj_ = InternalStringsType.factory() 1932 obj_.build(child_) 1933 self.Internal_Strings.append(obj_) 1934# end class InternationalizationSettingsType 1935 1936class InternalStringsType(GeneratedsSuper): 1937 """The InternalStringsType contains a single internal string instance 1938 for this internationalization setting instance.""" 1939 1940 subclass = None 1941 superclass = None 1942 def __init__(self, Key=None, Content=None): 1943 self.Key = Key 1944 self.Content = Content 1945 def factory(*args_, **kwargs_): 1946 if InternalStringsType.subclass: 1947 return InternalStringsType.subclass(*args_, **kwargs_) 1948 else: 1949 return InternalStringsType(*args_, **kwargs_) 1950 factory = staticmethod(factory) 1951 def get_Key(self): return self.Key 1952 def set_Key(self, Key): self.Key = Key 1953 def get_Content(self): return self.Content 1954 def set_Content(self, Content): self.Content = Content 1955 def hasContent_(self): 1956 if ( 1957 self.Key is not None or 1958 self.Content is not None 1959 ): 1960 return True 1961 else: 1962 return False 1963 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='InternalStringsType', namespacedef_='', pretty_print=True): 1964 if pretty_print: 1965 eol_ = '\n' 1966 else: 1967 eol_ = '' 1968 showIndent(lwrite, level, pretty_print) 1969 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 1970 already_processed = set() 1971 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='InternalStringsType') 1972 if self.hasContent_(): 1973 lwrite('>%s' % (eol_, )) 1974 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 1975 showIndent(lwrite, level, pretty_print) 1976 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 1977 else: 1978 lwrite('/>%s' % (eol_, )) 1979 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='InternalStringsType'): 1980 pass 1981 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='InternalStringsType', fromsubclass_=False, pretty_print=True): 1982 if pretty_print: 1983 eol_ = '\n' 1984 else: 1985 eol_ = '' 1986 if self.Key is not None: 1987 showIndent(lwrite, level, pretty_print) 1988 lwrite('<%sKey>%s</%sKey>%s' % ('cyboxCommon:', self.gds_format_string(quote_xml(self.Key), input_name='Key'), 'cyboxCommon:', eol_)) 1989 if self.Content is not None: 1990 showIndent(lwrite, level, pretty_print) 1991 lwrite('<%sContent>%s</%sContent>%s' % ('cyboxCommon:', self.gds_format_string(quote_xml(self.Content), input_name='Content'), 'cyboxCommon:', eol_)) 1992 def build(self, node): 1993 self.__sourcenode__ = node 1994 already_processed = set() 1995 self.buildAttributes(node, node.attrib, already_processed) 1996 for child in node: 1997 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 1998 self.buildChildren(child, node, nodeName_) 1999 def buildAttributes(self, node, attrs, already_processed): 2000 pass 2001 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 2002 if nodeName_ == 'Key': 2003 Key_ = child_.text 2004 Key_ = self.gds_validate_string(Key_, node, 'Key') 2005 self.Key = Key_ 2006 elif nodeName_ == 'Content': 2007 Content_ = child_.text 2008 Content_ = self.gds_validate_string(Content_, node, 'Content') 2009 self.Content = Content_ 2010# end class InternalStringsType 2011 2012class BuildInformationType(GeneratedsSuper): 2013 """The BuildInformationType contains information describing how this 2014 tool was built.""" 2015 subclass = None 2016 superclass = None 2017 def __init__(self, Build_ID=None, Build_Project=None, Build_Utility=None, Build_Version=None, Build_Label=None, Compilers=None, Compilation_Date=None, Build_Configuration=None, Build_Script=None, Libraries=None, Build_Output_Log=None): 2018 self.Build_ID = Build_ID 2019 self.Build_Project = Build_Project 2020 self.Build_Utility = Build_Utility 2021 self.Build_Version = Build_Version 2022 self.Build_Label = Build_Label 2023 self.Compilers = Compilers 2024 self.Compilation_Date = Compilation_Date 2025 self.Build_Configuration = Build_Configuration 2026 self.Build_Script = Build_Script 2027 self.Libraries = Libraries 2028 self.Build_Output_Log = Build_Output_Log 2029 def factory(*args_, **kwargs_): 2030 if BuildInformationType.subclass: 2031 return BuildInformationType.subclass(*args_, **kwargs_) 2032 else: 2033 return BuildInformationType(*args_, **kwargs_) 2034 factory = staticmethod(factory) 2035 def get_Build_ID(self): return self.Build_ID 2036 def set_Build_ID(self, Build_ID): self.Build_ID = Build_ID 2037 def get_Build_Project(self): return self.Build_Project 2038 def set_Build_Project(self, Build_Project): self.Build_Project = Build_Project 2039 def get_Build_Utility(self): return self.Build_Utility 2040 def set_Build_Utility(self, Build_Utility): self.Build_Utility = Build_Utility 2041 def get_Build_Version(self): return self.Build_Version 2042 def set_Build_Version(self, Build_Version): self.Build_Version = Build_Version 2043 def get_Build_Label(self): return self.Build_Label 2044 def set_Build_Label(self, Build_Label): self.Build_Label = Build_Label 2045 def get_Compilers(self): return self.Compilers 2046 def set_Compilers(self, Compilers): self.Compilers = Compilers 2047 def get_Compilation_Date(self): return self.Compilation_Date 2048 def set_Compilation_Date(self, Compilation_Date): self.Compilation_Date = Compilation_Date 2049 def get_Build_Configuration(self): return self.Build_Configuration 2050 def set_Build_Configuration(self, Build_Configuration): self.Build_Configuration = Build_Configuration 2051 def get_Build_Script(self): return self.Build_Script 2052 def set_Build_Script(self, Build_Script): self.Build_Script = Build_Script 2053 def get_Libraries(self): return self.Libraries 2054 def set_Libraries(self, Libraries): self.Libraries = Libraries 2055 def get_Build_Output_Log(self): return self.Build_Output_Log 2056 def set_Build_Output_Log(self, Build_Output_Log): self.Build_Output_Log = Build_Output_Log 2057 def hasContent_(self): 2058 if ( 2059 self.Build_ID is not None or 2060 self.Build_Project is not None or 2061 self.Build_Utility is not None or 2062 self.Build_Version is not None or 2063 self.Build_Label is not None or 2064 self.Compilers is not None or 2065 self.Compilation_Date is not None or 2066 self.Build_Configuration is not None or 2067 self.Build_Script is not None or 2068 self.Libraries is not None or 2069 self.Build_Output_Log is not None 2070 ): 2071 return True 2072 else: 2073 return False 2074 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='BuildInformationType', namespacedef_='', pretty_print=True): 2075 if pretty_print: 2076 eol_ = '\n' 2077 else: 2078 eol_ = '' 2079 showIndent(lwrite, level, pretty_print) 2080 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 2081 already_processed = set() 2082 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='BuildInformationType') 2083 if self.hasContent_(): 2084 lwrite('>%s' % (eol_, )) 2085 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 2086 showIndent(lwrite, level, pretty_print) 2087 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 2088 else: 2089 lwrite('/>%s' % (eol_, )) 2090 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='BuildInformationType'): 2091 pass 2092 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='BuildInformationType', fromsubclass_=False, pretty_print=True): 2093 if pretty_print: 2094 eol_ = '\n' 2095 else: 2096 eol_ = '' 2097 if self.Build_ID is not None: 2098 showIndent(lwrite, level, pretty_print) 2099 lwrite('<%sBuild_ID>%s</%sBuild_ID>%s' % ('cyboxCommon:', self.gds_format_string(quote_xml(self.Build_ID), input_name='Build_ID'), 'cyboxCommon:', eol_)) 2100 if self.Build_Project is not None: 2101 showIndent(lwrite, level, pretty_print) 2102 lwrite('<%sBuild_Project>%s</%sBuild_Project>%s' % ('cyboxCommon:', self.gds_format_string(quote_xml(self.Build_Project), input_name='Build_Project'), 'cyboxCommon:', eol_)) 2103 if self.Build_Utility is not None: 2104 self.Build_Utility.export(lwrite, level, 'cyboxCommon:', name_='Build_Utility', pretty_print=pretty_print) 2105 if self.Build_Version is not None: 2106 showIndent(lwrite, level, pretty_print) 2107 lwrite('<%sBuild_Version>%s</%sBuild_Version>%s' % ('cyboxCommon:', self.gds_format_string(quote_xml(self.Build_Version), input_name='Build_Version'), 'cyboxCommon:', eol_)) 2108 if self.Build_Label is not None: 2109 showIndent(lwrite, level, pretty_print) 2110 lwrite('<%sBuild_Label>%s</%sBuild_Label>%s' % ('cyboxCommon:', self.gds_format_string(quote_xml(self.Build_Label), input_name='Build_Label'), 'cyboxCommon:', eol_)) 2111 if self.Compilers is not None: 2112 self.Compilers.export(lwrite, level, 'cyboxCommon:', name_='Compilers', pretty_print=pretty_print) 2113 if self.Compilation_Date is not None: 2114 self.Compilation_Date.export(lwrite, level, 'cyboxCommon:', name_='Compilation_Date', pretty_print=pretty_print) 2115 if self.Build_Configuration is not None: 2116 self.Build_Configuration.export(lwrite, level, 'cyboxCommon:', name_='Build_Configuration', pretty_print=pretty_print) 2117 if self.Build_Script is not None: 2118 showIndent(lwrite, level, pretty_print) 2119 lwrite('<%sBuild_Script>%s</%sBuild_Script>%s' % ('cyboxCommon:', self.gds_format_string(quote_xml(self.Build_Script), input_name='Build_Script'), 'cyboxCommon:', eol_)) 2120 if self.Libraries is not None: 2121 self.Libraries.export(lwrite, level, 'cyboxCommon:', name_='Libraries', pretty_print=pretty_print) 2122 if self.Build_Output_Log is not None: 2123 showIndent(lwrite, level, pretty_print) 2124 lwrite('<%sBuild_Output_Log>%s</%sBuild_Output_Log>%s' % ('cyboxCommon:', self.gds_format_string(quote_xml(self.Build_Output_Log), input_name='Build_Output_Log'), 'cyboxCommon:', eol_)) 2125 def build(self, node): 2126 self.__sourcenode__ = node 2127 already_processed = set() 2128 self.buildAttributes(node, node.attrib, already_processed) 2129 for child in node: 2130 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 2131 self.buildChildren(child, node, nodeName_) 2132 def buildAttributes(self, node, attrs, already_processed): 2133 pass 2134 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 2135 if nodeName_ == 'Build_ID': 2136 Build_ID_ = child_.text 2137 Build_ID_ = self.gds_validate_string(Build_ID_, node, 'Build_ID') 2138 self.Build_ID = Build_ID_ 2139 elif nodeName_ == 'Build_Project': 2140 Build_Project_ = child_.text 2141 Build_Project_ = self.gds_validate_string(Build_Project_, node, 'Build_Project') 2142 self.Build_Project = Build_Project_ 2143 elif nodeName_ == 'Build_Utility': 2144 obj_ = BuildUtilityType.factory() 2145 obj_.build(child_) 2146 self.set_Build_Utility(obj_) 2147 elif nodeName_ == 'Build_Version': 2148 Build_Version_ = child_.text 2149 Build_Version_ = self.gds_validate_string(Build_Version_, node, 'Build_Version') 2150 self.Build_Version = Build_Version_ 2151 elif nodeName_ == 'Build_Label': 2152 Build_Label_ = child_.text 2153 Build_Label_ = self.gds_validate_string(Build_Label_, node, 'Build_Label') 2154 self.Build_Label = Build_Label_ 2155 elif nodeName_ == 'Compilers': 2156 obj_ = CompilersType.factory() 2157 obj_.build(child_) 2158 self.set_Compilers(obj_) 2159 elif nodeName_ == 'Compilation_Date': 2160 obj_ = DateTimeWithPrecisionType.factory() 2161 obj_.build(child_) 2162 self.set_Compilation_Date(obj_) 2163 elif nodeName_ == 'Build_Configuration': 2164 obj_ = BuildConfigurationType.factory() 2165 obj_.build(child_) 2166 self.set_Build_Configuration(obj_) 2167 elif nodeName_ == 'Build_Script': 2168 Build_Script_ = child_.text 2169 Build_Script_ = self.gds_validate_string(Build_Script_, node, 'Build_Script') 2170 self.Build_Script = Build_Script_ 2171 elif nodeName_ == 'Libraries': 2172 obj_ = LibrariesType.factory() 2173 obj_.build(child_) 2174 self.set_Libraries(obj_) 2175 elif nodeName_ == 'Build_Output_Log': 2176 Build_Output_Log_ = child_.text 2177 Build_Output_Log_ = self.gds_validate_string(Build_Output_Log_, node, 'Build_Output_Log') 2178 self.Build_Output_Log = Build_Output_Log_ 2179# end class BuildInformationType 2180 2181class BuildUtilityType(GeneratedsSuper): 2182 """The BuildUtilityType contains information identifying the utility 2183 used to build this application.""" 2184 2185 subclass = None 2186 superclass = None 2187 def __init__(self, Build_Utility_Name=None, Build_Utility_Platform_Specification=None): 2188 self.Build_Utility_Name = Build_Utility_Name 2189 self.Build_Utility_Platform_Specification = Build_Utility_Platform_Specification 2190 def factory(*args_, **kwargs_): 2191 if BuildUtilityType.subclass: 2192 return BuildUtilityType.subclass(*args_, **kwargs_) 2193 else: 2194 return BuildUtilityType(*args_, **kwargs_) 2195 factory = staticmethod(factory) 2196 def get_Build_Utility_Name(self): return self.Build_Utility_Name 2197 def set_Build_Utility_Name(self, Build_Utility_Name): self.Build_Utility_Name = Build_Utility_Name 2198 def get_Build_Utility_Platform_Specification(self): return self.Build_Utility_Platform_Specification 2199 def set_Build_Utility_Platform_Specification(self, Build_Utility_Platform_Specification): self.Build_Utility_Platform_Specification = Build_Utility_Platform_Specification 2200 def hasContent_(self): 2201 if ( 2202 self.Build_Utility_Name is not None or 2203 self.Build_Utility_Platform_Specification is not None 2204 ): 2205 return True 2206 else: 2207 return False 2208 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='BuildUtilityType', namespacedef_='', pretty_print=True): 2209 if pretty_print: 2210 eol_ = '\n' 2211 else: 2212 eol_ = '' 2213 showIndent(lwrite, level, pretty_print) 2214 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 2215 already_processed = set() 2216 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='BuildUtilityType') 2217 if self.hasContent_(): 2218 lwrite('>%s' % (eol_, )) 2219 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 2220 showIndent(lwrite, level, pretty_print) 2221 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 2222 else: 2223 lwrite('/>%s' % (eol_, )) 2224 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='BuildUtilityType'): 2225 pass 2226 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='BuildUtilityType', fromsubclass_=False, pretty_print=True): 2227 if pretty_print: 2228 eol_ = '\n' 2229 else: 2230 eol_ = '' 2231 if self.Build_Utility_Name is not None: 2232 showIndent(lwrite, level, pretty_print) 2233 lwrite('<%sBuild_Utility_Name>%s</%sBuild_Utility_Name>%s' % ('cyboxCommon:', self.gds_format_string(quote_xml(self.Build_Utility_Name), input_name='Build_Utility_Name'), 'cyboxCommon:', eol_)) 2234 if self.Build_Utility_Platform_Specification is not None: 2235 self.Build_Utility_Platform_Specification.export(lwrite, level, 'cyboxCommon:', name_='Build_Utility_Platform_Specification', pretty_print=pretty_print) 2236 def build(self, node): 2237 self.__sourcenode__ = node 2238 already_processed = set() 2239 self.buildAttributes(node, node.attrib, already_processed) 2240 for child in node: 2241 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 2242 self.buildChildren(child, node, nodeName_) 2243 def buildAttributes(self, node, attrs, already_processed): 2244 pass 2245 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 2246 if nodeName_ == 'Build_Utility_Name': 2247 Build_Utility_Name_ = child_.text 2248 Build_Utility_Name_ = self.gds_validate_string(Build_Utility_Name_, node, 'Build_Utility_Name') 2249 self.Build_Utility_Name = Build_Utility_Name_ 2250 elif nodeName_ == 'Build_Utility_Platform_Specification': 2251 obj_ = PlatformSpecificationType.factory() 2252 obj_.build(child_) 2253 self.set_Build_Utility_Platform_Specification(obj_) 2254# end class BuildUtilityType 2255 2256class CompilersType(GeneratedsSuper): 2257 """The CompilersType describes the compilers utilized during this build 2258 of this application.""" 2259 2260 subclass = None 2261 superclass = None 2262 def __init__(self, Compiler=None): 2263 if Compiler is None: 2264 self.Compiler = [] 2265 else: 2266 self.Compiler = Compiler 2267 def factory(*args_, **kwargs_): 2268 if CompilersType.subclass: 2269 return CompilersType.subclass(*args_, **kwargs_) 2270 else: 2271 return CompilersType(*args_, **kwargs_) 2272 factory = staticmethod(factory) 2273 def get_Compiler(self): return self.Compiler 2274 def set_Compiler(self, Compiler): self.Compiler = Compiler 2275 def add_Compiler(self, value): self.Compiler.append(value) 2276 def insert_Compiler(self, index, value): self.Compiler[index] = value 2277 def hasContent_(self): 2278 if ( 2279 self.Compiler 2280 ): 2281 return True 2282 else: 2283 return False 2284 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='CompilersType', namespacedef_='', pretty_print=True): 2285 if pretty_print: 2286 eol_ = '\n' 2287 else: 2288 eol_ = '' 2289 showIndent(lwrite, level, pretty_print) 2290 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 2291 already_processed = set() 2292 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='CompilersType') 2293 if self.hasContent_(): 2294 lwrite('>%s' % (eol_, )) 2295 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 2296 showIndent(lwrite, level, pretty_print) 2297 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 2298 else: 2299 lwrite('/>%s' % (eol_, )) 2300 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='CompilersType'): 2301 pass 2302 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='CompilersType', fromsubclass_=False, pretty_print=True): 2303 if pretty_print: 2304 eol_ = '\n' 2305 else: 2306 eol_ = '' 2307 for Compiler_ in self.Compiler: 2308 Compiler_.export(lwrite, level, 'cyboxCommon:', name_='Compiler', pretty_print=pretty_print) 2309 def build(self, node): 2310 self.__sourcenode__ = node 2311 already_processed = set() 2312 self.buildAttributes(node, node.attrib, already_processed) 2313 for child in node: 2314 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 2315 self.buildChildren(child, node, nodeName_) 2316 def buildAttributes(self, node, attrs, already_processed): 2317 pass 2318 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 2319 if nodeName_ == 'Compiler': 2320 obj_ = CompilerType.factory() 2321 obj_.build(child_) 2322 self.Compiler.append(obj_) 2323# end class CompilersType 2324 2325class CompilerType(GeneratedsSuper): 2326 """The CompilerType describes a single compiler utilized during this 2327 build of this application.""" 2328 2329 subclass = None 2330 superclass = None 2331 def __init__(self, Compiler_Informal_Description=None, Compiler_Platform_Specification=None): 2332 self.Compiler_Informal_Description = Compiler_Informal_Description 2333 self.Compiler_Platform_Specification = Compiler_Platform_Specification 2334 def factory(*args_, **kwargs_): 2335 if CompilerType.subclass: 2336 return CompilerType.subclass(*args_, **kwargs_) 2337 else: 2338 return CompilerType(*args_, **kwargs_) 2339 factory = staticmethod(factory) 2340 def get_Compiler_Informal_Description(self): return self.Compiler_Informal_Description 2341 def set_Compiler_Informal_Description(self, Compiler_Informal_Description): self.Compiler_Informal_Description = Compiler_Informal_Description 2342 def get_Compiler_Platform_Specification(self): return self.Compiler_Platform_Specification 2343 def set_Compiler_Platform_Specification(self, Compiler_Platform_Specification): self.Compiler_Platform_Specification = Compiler_Platform_Specification 2344 def hasContent_(self): 2345 if ( 2346 self.Compiler_Informal_Description is not None or 2347 self.Compiler_Platform_Specification is not None 2348 ): 2349 return True 2350 else: 2351 return False 2352 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='CompilerType', namespacedef_='', pretty_print=True): 2353 if pretty_print: 2354 eol_ = '\n' 2355 else: 2356 eol_ = '' 2357 showIndent(lwrite, level, pretty_print) 2358 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 2359 already_processed = set() 2360 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='CompilerType') 2361 if self.hasContent_(): 2362 lwrite('>%s' % (eol_, )) 2363 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 2364 showIndent(lwrite, level, pretty_print) 2365 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 2366 else: 2367 lwrite('/>%s' % (eol_, )) 2368 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='CompilerType'): 2369 pass 2370 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='CompilerType', fromsubclass_=False, pretty_print=True): 2371 if pretty_print: 2372 eol_ = '\n' 2373 else: 2374 eol_ = '' 2375 if self.Compiler_Informal_Description is not None: 2376 self.Compiler_Informal_Description.export(lwrite, level, 'cyboxCommon:', name_='Compiler_Informal_Description', pretty_print=pretty_print) 2377 if self.Compiler_Platform_Specification is not None: 2378 self.Compiler_Platform_Specification.export(lwrite, level, 'cyboxCommon:', name_='Compiler_Platform_Specification', pretty_print=pretty_print) 2379 def build(self, node): 2380 self.__sourcenode__ = node 2381 already_processed = set() 2382 self.buildAttributes(node, node.attrib, already_processed) 2383 for child in node: 2384 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 2385 self.buildChildren(child, node, nodeName_) 2386 def buildAttributes(self, node, attrs, already_processed): 2387 pass 2388 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 2389 if nodeName_ == 'Compiler_Informal_Description': 2390 obj_ = CompilerInformalDescriptionType.factory() 2391 obj_.build(child_) 2392 self.set_Compiler_Informal_Description(obj_) 2393 elif nodeName_ == 'Compiler_Platform_Specification': 2394 obj_ = PlatformSpecificationType.factory() 2395 obj_.build(child_) 2396 self.set_Compiler_Platform_Specification(obj_) 2397# end class CompilerType 2398 2399class CompilerInformalDescriptionType(GeneratedsSuper): 2400 """The CompilerInformalDescriptionType contains the informal 2401 description of this compiler instance.""" 2402 2403 subclass = None 2404 superclass = None 2405 def __init__(self, Compiler_Name=None, Compiler_Version=None): 2406 self.Compiler_Name = Compiler_Name 2407 self.Compiler_Version = Compiler_Version 2408 def factory(*args_, **kwargs_): 2409 if CompilerInformalDescriptionType.subclass: 2410 return CompilerInformalDescriptionType.subclass(*args_, **kwargs_) 2411 else: 2412 return CompilerInformalDescriptionType(*args_, **kwargs_) 2413 factory = staticmethod(factory) 2414 def get_Compiler_Name(self): return self.Compiler_Name 2415 def set_Compiler_Name(self, Compiler_Name): self.Compiler_Name = Compiler_Name 2416 def get_Compiler_Version(self): return self.Compiler_Version 2417 def set_Compiler_Version(self, Compiler_Version): self.Compiler_Version = Compiler_Version 2418 def hasContent_(self): 2419 if ( 2420 self.Compiler_Name is not None or 2421 self.Compiler_Version is not None 2422 ): 2423 return True 2424 else: 2425 return False 2426 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='CompilerInformalDescriptionType', namespacedef_='', pretty_print=True): 2427 if pretty_print: 2428 eol_ = '\n' 2429 else: 2430 eol_ = '' 2431 showIndent(lwrite, level, pretty_print) 2432 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 2433 already_processed = set() 2434 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='CompilerInformalDescriptionType') 2435 if self.hasContent_(): 2436 lwrite('>%s' % (eol_, )) 2437 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 2438 showIndent(lwrite, level, pretty_print) 2439 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 2440 else: 2441 lwrite('/>%s' % (eol_, )) 2442 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='CompilerInformalDescriptionType'): 2443 pass 2444 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='CompilerInformalDescriptionType', fromsubclass_=False, pretty_print=True): 2445 if pretty_print: 2446 eol_ = '\n' 2447 else: 2448 eol_ = '' 2449 if self.Compiler_Name is not None: 2450 showIndent(lwrite, level, pretty_print) 2451 lwrite('<%sCompiler_Name>%s</%sCompiler_Name>%s' % ('cyboxCommon:', self.gds_format_string(quote_xml(self.Compiler_Name), input_name='Compiler_Name'), 'cyboxCommon:', eol_)) 2452 if self.Compiler_Version is not None: 2453 showIndent(lwrite, level, pretty_print) 2454 lwrite('<%sCompiler_Version>%s</%sCompiler_Version>%s' % ('cyboxCommon:', self.gds_format_string(quote_xml(self.Compiler_Version), input_name='Compiler_Version'), 'cyboxCommon:', eol_)) 2455 def build(self, node): 2456 self.__sourcenode__ = node 2457 already_processed = set() 2458 self.buildAttributes(node, node.attrib, already_processed) 2459 for child in node: 2460 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 2461 self.buildChildren(child, node, nodeName_) 2462 def buildAttributes(self, node, attrs, already_processed): 2463 pass 2464 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 2465 if nodeName_ == 'Compiler_Name': 2466 Compiler_Name_ = child_.text 2467 Compiler_Name_ = self.gds_validate_string(Compiler_Name_, node, 'Compiler_Name') 2468 self.Compiler_Name = Compiler_Name_ 2469 elif nodeName_ == 'Compiler_Version': 2470 Compiler_Version_ = child_.text 2471 Compiler_Version_ = self.gds_validate_string(Compiler_Version_, node, 'Compiler_Version') 2472 self.Compiler_Version = Compiler_Version_ 2473# end class CompilerInformalDescriptionType 2474 2475class BuildConfigurationType(GeneratedsSuper): 2476 """The BuildConfigurationType describes how the build utility was 2477 configured for this build of this application.""" 2478 2479 subclass = None 2480 superclass = None 2481 def __init__(self, Configuration_Setting_Description=None, Configuration_Settings=None): 2482 self.Configuration_Setting_Description = Configuration_Setting_Description 2483 self.Configuration_Settings = Configuration_Settings 2484 def factory(*args_, **kwargs_): 2485 if BuildConfigurationType.subclass: 2486 return BuildConfigurationType.subclass(*args_, **kwargs_) 2487 else: 2488 return BuildConfigurationType(*args_, **kwargs_) 2489 factory = staticmethod(factory) 2490 def get_Configuration_Setting_Description(self): return self.Configuration_Setting_Description 2491 def set_Configuration_Setting_Description(self, Configuration_Setting_Description): self.Configuration_Setting_Description = Configuration_Setting_Description 2492 def get_Configuration_Settings(self): return self.Configuration_Settings 2493 def set_Configuration_Settings(self, Configuration_Settings): self.Configuration_Settings = Configuration_Settings 2494 def hasContent_(self): 2495 if ( 2496 self.Configuration_Setting_Description is not None or 2497 self.Configuration_Settings is not None 2498 ): 2499 return True 2500 else: 2501 return False 2502 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='BuildConfigurationType', namespacedef_='', pretty_print=True): 2503 if pretty_print: 2504 eol_ = '\n' 2505 else: 2506 eol_ = '' 2507 showIndent(lwrite, level, pretty_print) 2508 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 2509 already_processed = set() 2510 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='BuildConfigurationType') 2511 if self.hasContent_(): 2512 lwrite('>%s' % (eol_, )) 2513 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 2514 showIndent(lwrite, level, pretty_print) 2515 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 2516 else: 2517 lwrite('/>%s' % (eol_, )) 2518 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='BuildConfigurationType'): 2519 pass 2520 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='BuildConfigurationType', fromsubclass_=False, pretty_print=True): 2521 if pretty_print: 2522 eol_ = '\n' 2523 else: 2524 eol_ = '' 2525 if self.Configuration_Setting_Description is not None: 2526 showIndent(lwrite, level, pretty_print) 2527 lwrite('<%sConfiguration_Setting_Description>%s</%sConfiguration_Setting_Description>%s' % ('cyboxCommon:', self.gds_format_string(quote_xml(self.Configuration_Setting_Description), input_name='Configuration_Setting_Description'), 'cyboxCommon:', eol_)) 2528 if self.Configuration_Settings is not None: 2529 self.Configuration_Settings.export(lwrite, level, 'cyboxCommon:', name_='Configuration_Settings', pretty_print=pretty_print) 2530 def build(self, node): 2531 self.__sourcenode__ = node 2532 already_processed = set() 2533 self.buildAttributes(node, node.attrib, already_processed) 2534 for child in node: 2535 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 2536 self.buildChildren(child, node, nodeName_) 2537 def buildAttributes(self, node, attrs, already_processed): 2538 pass 2539 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 2540 if nodeName_ == 'Configuration_Setting_Description': 2541 Configuration_Setting_Description_ = child_.text 2542 Configuration_Setting_Description_ = self.gds_validate_string(Configuration_Setting_Description_, node, 'Configuration_Setting_Description') 2543 self.Configuration_Setting_Description = Configuration_Setting_Description_ 2544 elif nodeName_ == 'Configuration_Settings': 2545 obj_ = ConfigurationSettingsType.factory() 2546 obj_.build(child_) 2547 self.set_Configuration_Settings(obj_) 2548# end class BuildConfigurationType 2549 2550class LibrariesType(GeneratedsSuper): 2551 """The LibrariesType identifies the libraries incorporated into the 2552 build of the tool.""" 2553 2554 subclass = None 2555 superclass = None 2556 def __init__(self, Library=None): 2557 self.Library = Library 2558 def factory(*args_, **kwargs_): 2559 if LibrariesType.subclass: 2560 return LibrariesType.subclass(*args_, **kwargs_) 2561 else: 2562 return LibrariesType(*args_, **kwargs_) 2563 factory = staticmethod(factory) 2564 def get_Library(self): return self.Library 2565 def set_Library(self, Library): self.Library = Library 2566 def hasContent_(self): 2567 if ( 2568 self.Library is not None 2569 ): 2570 return True 2571 else: 2572 return False 2573 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='LibrariesType', namespacedef_='', pretty_print=True): 2574 if pretty_print: 2575 eol_ = '\n' 2576 else: 2577 eol_ = '' 2578 showIndent(lwrite, level, pretty_print) 2579 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 2580 already_processed = set() 2581 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='LibrariesType') 2582 if self.hasContent_(): 2583 lwrite('>%s' % (eol_, )) 2584 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 2585 showIndent(lwrite, level, pretty_print) 2586 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 2587 else: 2588 lwrite('/>%s' % (eol_, )) 2589 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='LibrariesType'): 2590 pass 2591 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='LibrariesType', fromsubclass_=False, pretty_print=True): 2592 if pretty_print: 2593 eol_ = '\n' 2594 else: 2595 eol_ = '' 2596 if self.Library is not None: 2597 self.Library.export(lwrite, level, 'cyboxCommon:', name_='Library', pretty_print=pretty_print) 2598 def build(self, node): 2599 self.__sourcenode__ = node 2600 already_processed = set() 2601 self.buildAttributes(node, node.attrib, already_processed) 2602 for child in node: 2603 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 2604 self.buildChildren(child, node, nodeName_) 2605 def buildAttributes(self, node, attrs, already_processed): 2606 pass 2607 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 2608 if nodeName_ == 'Library': 2609 obj_ = LibraryType.factory() 2610 obj_.build(child_) 2611 self.set_Library(obj_) 2612# end class LibrariesType 2613 2614class LibraryType(GeneratedsSuper): 2615 """The LibraryType identifies a single library incorporated into the 2616 build of the tool.This field identifies the name of the 2617 library.This field identifies the version of the library.""" 2618 2619 subclass = None 2620 superclass = None 2621 def __init__(self, version=None, name=None): 2622 self.version = _cast(None, version) 2623 self.name = _cast(None, name) 2624 pass 2625 def factory(*args_, **kwargs_): 2626 if LibraryType.subclass: 2627 return LibraryType.subclass(*args_, **kwargs_) 2628 else: 2629 return LibraryType(*args_, **kwargs_) 2630 factory = staticmethod(factory) 2631 def get_version(self): return self.version 2632 def set_version(self, version): self.version = version 2633 def get_name(self): return self.name 2634 def set_name(self, name): self.name = name 2635 def hasContent_(self): 2636 if ( 2637 2638 ): 2639 return True 2640 else: 2641 return False 2642 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='LibraryType', namespacedef_='', pretty_print=True): 2643 if pretty_print: 2644 eol_ = '\n' 2645 else: 2646 eol_ = '' 2647 showIndent(lwrite, level, pretty_print) 2648 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 2649 already_processed = set() 2650 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='LibraryType') 2651 if self.hasContent_(): 2652 lwrite('>%s' % (eol_, )) 2653 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 2654 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 2655 else: 2656 lwrite('/>%s' % (eol_, )) 2657 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='LibraryType'): 2658 if self.version is not None: 2659 2660 lwrite(' version=%s' % (self.gds_format_string(quote_attrib(self.version), input_name='version'), )) 2661 if self.name is not None: 2662 2663 lwrite(' name=%s' % (self.gds_format_string(quote_attrib(self.name), input_name='name'), )) 2664 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='LibraryType', fromsubclass_=False, pretty_print=True): 2665 pass 2666 def build(self, node): 2667 self.__sourcenode__ = node 2668 already_processed = set() 2669 self.buildAttributes(node, node.attrib, already_processed) 2670 for child in node: 2671 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 2672 self.buildChildren(child, node, nodeName_) 2673 def buildAttributes(self, node, attrs, already_processed): 2674 value = find_attr_value_('version', node) 2675 if value is not None: 2676 2677 self.version = value 2678 value = find_attr_value_('name', node) 2679 if value is not None: 2680 2681 self.name = value 2682 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 2683 pass 2684# end class LibraryType 2685 2686class ExecutionEnvironmentType(GeneratedsSuper): 2687 """The ExecutionEnvironmentType contains information describing the 2688 execution environment of the tool.""" 2689 subclass = None 2690 superclass = None 2691 def __init__(self, System=None, User_Account_Info=None, Command_Line=None, Start_Time=None): 2692 self.System = System 2693 self.User_Account_Info = User_Account_Info 2694 self.Command_Line = Command_Line 2695 self.Start_Time = Start_Time 2696 def factory(*args_, **kwargs_): 2697 if ExecutionEnvironmentType.subclass: 2698 return ExecutionEnvironmentType.subclass(*args_, **kwargs_) 2699 else: 2700 return ExecutionEnvironmentType(*args_, **kwargs_) 2701 factory = staticmethod(factory) 2702 def get_System(self): return self.System 2703 def set_System(self, System): self.System = System 2704 def get_User_Account_Info(self): return self.User_Account_Info 2705 def set_User_Account_Info(self, User_Account_Info): self.User_Account_Info = User_Account_Info 2706 def get_Command_Line(self): return self.Command_Line 2707 def set_Command_Line(self, Command_Line): self.Command_Line = Command_Line 2708 def get_Start_Time(self): return self.Start_Time 2709 def set_Start_Time(self, Start_Time): self.Start_Time = Start_Time 2710 def hasContent_(self): 2711 if ( 2712 self.System is not None or 2713 self.User_Account_Info is not None or 2714 self.Command_Line is not None or 2715 self.Start_Time is not None 2716 ): 2717 return True 2718 else: 2719 return False 2720 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='ExecutionEnvironmentType', namespacedef_='', pretty_print=True): 2721 if pretty_print: 2722 eol_ = '\n' 2723 else: 2724 eol_ = '' 2725 showIndent(lwrite, level, pretty_print) 2726 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 2727 already_processed = set() 2728 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='ExecutionEnvironmentType') 2729 if self.hasContent_(): 2730 lwrite('>%s' % (eol_, )) 2731 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 2732 showIndent(lwrite, level, pretty_print) 2733 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 2734 else: 2735 lwrite('/>%s' % (eol_, )) 2736 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='ExecutionEnvironmentType'): 2737 pass 2738 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='ExecutionEnvironmentType', fromsubclass_=False, pretty_print=True): 2739 if pretty_print: 2740 eol_ = '\n' 2741 else: 2742 eol_ = '' 2743 if self.System is not None: 2744 self.System.export(lwrite, level, 'cyboxCommon:', name_='System', pretty_print=pretty_print) 2745 if self.User_Account_Info is not None: 2746 self.User_Account_Info.export(lwrite, level, 'cyboxCommon:', name_='User_Account_Info', pretty_print=pretty_print) 2747 if self.Command_Line is not None: 2748 showIndent(lwrite, level, pretty_print) 2749 lwrite('<%sCommand_Line>%s</%sCommand_Line>%s' % ('cyboxCommon:', self.gds_format_string(quote_xml(self.Command_Line), input_name='Command_Line'), 'cyboxCommon:', eol_)) 2750 if self.Start_Time is not None: 2751 self.Start_Time.export(lwrite, level, 'cyboxCommon:', name_='Start_Time', pretty_print=pretty_print) 2752 def build(self, node): 2753 self.__sourcenode__ = node 2754 already_processed = set() 2755 self.buildAttributes(node, node.attrib, already_processed) 2756 for child in node: 2757 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 2758 self.buildChildren(child, node, nodeName_) 2759 def buildAttributes(self, node, attrs, already_processed): 2760 pass 2761 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 2762 if nodeName_ == 'System': 2763 type_name_ = child_.attrib.get( 2764 '{http://www.w3.org/2001/XMLSchema-instance}type') 2765 if type_name_ is None: 2766 type_name_ = child_.attrib.get('type') 2767 if type_name_ is not None: 2768 type_names_ = type_name_.split(':') 2769 if len(type_names_) == 1: 2770 type_name_ = type_names_[0] 2771 else: 2772 type_name_ = type_names_[1] 2773 class_ = globals()[type_name_] 2774 obj_ = class_.factory() 2775 obj_.build(child_) 2776 else: 2777 raise NotImplementedError( 2778 'Class not implemented for <System> element') 2779 self.set_System(obj_) 2780 elif nodeName_ == 'User_Account_Info': 2781 type_name_ = child_.attrib.get( 2782 '{http://www.w3.org/2001/XMLSchema-instance}type') 2783 if type_name_ is None: 2784 type_name_ = child_.attrib.get('type') 2785 if type_name_ is not None: 2786 type_names_ = type_name_.split(':') 2787 if len(type_names_) == 1: 2788 type_name_ = type_names_[0] 2789 else: 2790 type_name_ = type_names_[1] 2791 class_ = globals()[type_name_] 2792 obj_ = class_.factory() 2793 obj_.build(child_) 2794 else: 2795 raise NotImplementedError( 2796 'Class not implemented for <User_Account_Info> element') 2797 self.set_User_Account_Info(obj_) 2798 elif nodeName_ == 'Command_Line': 2799 Command_Line_ = child_.text 2800 Command_Line_ = self.gds_validate_string(Command_Line_, node, 'Command_Line') 2801 self.Command_Line = Command_Line_ 2802 elif nodeName_ == 'Start_Time': 2803 obj_ = DateTimeWithPrecisionType.factory() 2804 obj_.build(child_) 2805 self.set_Start_Time(obj_) 2806# end class ExecutionEnvironmentType 2807 2808class ErrorsType(GeneratedsSuper): 2809 """The ErrorsType captures any errors generated during the run of the 2810 tool.""" 2811 2812 subclass = None 2813 superclass = None 2814 def __init__(self, Error=None): 2815 if Error is None: 2816 self.Error = [] 2817 else: 2818 self.Error = Error 2819 def factory(*args_, **kwargs_): 2820 if ErrorsType.subclass: 2821 return ErrorsType.subclass(*args_, **kwargs_) 2822 else: 2823 return ErrorsType(*args_, **kwargs_) 2824 factory = staticmethod(factory) 2825 def get_Error(self): return self.Error 2826 def set_Error(self, Error): self.Error = Error 2827 def add_Error(self, value): self.Error.append(value) 2828 def insert_Error(self, index, value): self.Error[index] = value 2829 def hasContent_(self): 2830 if ( 2831 self.Error 2832 ): 2833 return True 2834 else: 2835 return False 2836 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='ErrorsType', namespacedef_='', pretty_print=True): 2837 if pretty_print: 2838 eol_ = '\n' 2839 else: 2840 eol_ = '' 2841 showIndent(lwrite, level, pretty_print) 2842 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 2843 already_processed = set() 2844 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='ErrorsType') 2845 if self.hasContent_(): 2846 lwrite('>%s' % (eol_, )) 2847 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 2848 showIndent(lwrite, level, pretty_print) 2849 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 2850 else: 2851 lwrite('/>%s' % (eol_, )) 2852 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='ErrorsType'): 2853 pass 2854 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='ErrorsType', fromsubclass_=False, pretty_print=True): 2855 if pretty_print: 2856 eol_ = '\n' 2857 else: 2858 eol_ = '' 2859 for Error_ in self.Error: 2860 Error_.export(lwrite, level, 'cyboxCommon:', name_='Error', pretty_print=pretty_print) 2861 def build(self, node): 2862 self.__sourcenode__ = node 2863 already_processed = set() 2864 self.buildAttributes(node, node.attrib, already_processed) 2865 for child in node: 2866 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 2867 self.buildChildren(child, node, nodeName_) 2868 def buildAttributes(self, node, attrs, already_processed): 2869 pass 2870 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 2871 if nodeName_ == 'Error': 2872 obj_ = ErrorType.factory() 2873 obj_.build(child_) 2874 self.Error.append(obj_) 2875# end class ErrorsType 2876 2877class ErrorType(GeneratedsSuper): 2878 """The ErrorType captures a single error generated during the run of 2879 the tool.""" 2880 2881 subclass = None 2882 superclass = None 2883 def __init__(self, Error_Type=None, Error_Count=None, Error_Instances=None): 2884 self.Error_Type = Error_Type 2885 self.Error_Count = Error_Count 2886 self.Error_Instances = Error_Instances 2887 def factory(*args_, **kwargs_): 2888 if ErrorType.subclass: 2889 return ErrorType.subclass(*args_, **kwargs_) 2890 else: 2891 return ErrorType(*args_, **kwargs_) 2892 factory = staticmethod(factory) 2893 def get_Error_Type(self): return self.Error_Type 2894 def set_Error_Type(self, Error_Type): self.Error_Type = Error_Type 2895 def get_Error_Count(self): return self.Error_Count 2896 def set_Error_Count(self, Error_Count): self.Error_Count = Error_Count 2897 def get_Error_Instances(self): return self.Error_Instances 2898 def set_Error_Instances(self, Error_Instances): self.Error_Instances = Error_Instances 2899 def hasContent_(self): 2900 if ( 2901 self.Error_Type is not None or 2902 self.Error_Count is not None or 2903 self.Error_Instances is not None 2904 ): 2905 return True 2906 else: 2907 return False 2908 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='ErrorType', namespacedef_='', pretty_print=True): 2909 if pretty_print: 2910 eol_ = '\n' 2911 else: 2912 eol_ = '' 2913 showIndent(lwrite, level, pretty_print) 2914 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 2915 already_processed = set() 2916 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='ErrorType') 2917 if self.hasContent_(): 2918 lwrite('>%s' % (eol_, )) 2919 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 2920 showIndent(lwrite, level, pretty_print) 2921 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 2922 else: 2923 lwrite('/>%s' % (eol_, )) 2924 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='ErrorType'): 2925 pass 2926 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='ErrorType', fromsubclass_=False, pretty_print=True): 2927 if pretty_print: 2928 eol_ = '\n' 2929 else: 2930 eol_ = '' 2931 if self.Error_Type is not None: 2932 showIndent(lwrite, level, pretty_print) 2933 lwrite('<%sError_Type>%s</%sError_Type>%s' % ('cyboxCommon:', self.gds_format_string(quote_xml(self.Error_Type), input_name='Error_Type'), 'cyboxCommon:', eol_)) 2934 if self.Error_Count is not None: 2935 showIndent(lwrite, level, pretty_print) 2936 lwrite('<%sError_Count>%s</%sError_Count>%s' % ('cyboxCommon:', self.gds_format_integer(self.Error_Count, input_name='Error_Count'), 'cyboxCommon:', eol_)) 2937 if self.Error_Instances is not None: 2938 self.Error_Instances.export(lwrite, level, 'cyboxCommon:', name_='Error_Instances', pretty_print=pretty_print) 2939 def build(self, node): 2940 self.__sourcenode__ = node 2941 already_processed = set() 2942 self.buildAttributes(node, node.attrib, already_processed) 2943 for child in node: 2944 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 2945 self.buildChildren(child, node, nodeName_) 2946 def buildAttributes(self, node, attrs, already_processed): 2947 pass 2948 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 2949 if nodeName_ == 'Error_Type': 2950 Error_Type_ = child_.text 2951 Error_Type_ = self.gds_validate_string(Error_Type_, node, 'Error_Type') 2952 self.Error_Type = Error_Type_ 2953 elif nodeName_ == 'Error_Count': 2954 sval_ = child_.text 2955 try: 2956 ival_ = int(sval_) 2957 except (TypeError, ValueError) as exp: 2958 raise_parse_error(child_, 'requires integer: %s' % exp) 2959 ival_ = self.gds_validate_integer(ival_, node, 'Error_Count') 2960 self.Error_Count = ival_ 2961 elif nodeName_ == 'Error_Instances': 2962 obj_ = ErrorInstancesType.factory() 2963 obj_.build(child_) 2964 self.set_Error_Instances(obj_) 2965# end class ErrorType 2966 2967class ErrorInstancesType(GeneratedsSuper): 2968 """The ErrorInstancesType captures the actual error output for each 2969 instance of this type of error.""" 2970 2971 subclass = None 2972 superclass = None 2973 def __init__(self, Error_Instance=None): 2974 if Error_Instance is None: 2975 self.Error_Instance = [] 2976 else: 2977 self.Error_Instance = Error_Instance 2978 def factory(*args_, **kwargs_): 2979 if ErrorInstancesType.subclass: 2980 return ErrorInstancesType.subclass(*args_, **kwargs_) 2981 else: 2982 return ErrorInstancesType(*args_, **kwargs_) 2983 factory = staticmethod(factory) 2984 def get_Error_Instance(self): return self.Error_Instance 2985 def set_Error_Instance(self, Error_Instance): self.Error_Instance = Error_Instance 2986 def add_Error_Instance(self, value): self.Error_Instance.append(value) 2987 def insert_Error_Instance(self, index, value): self.Error_Instance[index] = value 2988 def hasContent_(self): 2989 if ( 2990 self.Error_Instance 2991 ): 2992 return True 2993 else: 2994 return False 2995 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='ErrorInstancesType', namespacedef_='', pretty_print=True): 2996 if pretty_print: 2997 eol_ = '\n' 2998 else: 2999 eol_ = '' 3000 showIndent(lwrite, level, pretty_print) 3001 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 3002 already_processed = set() 3003 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='ErrorInstancesType') 3004 if self.hasContent_(): 3005 lwrite('>%s' % (eol_, )) 3006 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 3007 showIndent(lwrite, level, pretty_print) 3008 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 3009 else: 3010 lwrite('/>%s' % (eol_, )) 3011 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='ErrorInstancesType'): 3012 pass 3013 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='ErrorInstancesType', fromsubclass_=False, pretty_print=True): 3014 if pretty_print: 3015 eol_ = '\n' 3016 else: 3017 eol_ = '' 3018 for Error_Instance_ in self.Error_Instance: 3019 showIndent(lwrite, level, pretty_print) 3020 lwrite('<%sError_Instance>%s</%sError_Instance>%s' % ('cyboxCommon:', self.gds_format_string(quote_xml(Error_Instance_), input_name='Error_Instance'), 'cyboxCommon:', eol_)) 3021 def build(self, node): 3022 self.__sourcenode__ = node 3023 already_processed = set() 3024 self.buildAttributes(node, node.attrib, already_processed) 3025 for child in node: 3026 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 3027 self.buildChildren(child, node, nodeName_) 3028 def buildAttributes(self, node, attrs, already_processed): 3029 pass 3030 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 3031 if nodeName_ == 'Error_Instance': 3032 Error_Instance_ = child_.text 3033 Error_Instance_ = self.gds_validate_string(Error_Instance_, node, 'Error_Instance') 3034 self.Error_Instance.append(Error_Instance_) 3035# end class ErrorInstancesType 3036 3037class ObjectPropertiesType(GeneratedsSuper): 3038 """The ObjectPropertiesType is an Abstract type placeholder within the 3039 CybOX schema enabling the inclusion of contextually varying 3040 object properties descriptions. This Abstract type is leveraged 3041 as the extension base for all predefined CybOX object properties 3042 schemas. Through this extension mechanism any object instance 3043 data based on an object properties schema extended from 3044 ObjectPropertiesType (e.g. File_Object, Address_Object, etc.) 3045 can be directly integrated into any instance document where a 3046 field is defined as ObjectPropertiesType. For flexibility and 3047 extensibility purposes any user of CybOX can specify their own 3048 externally defined object properties schemas (outside of or 3049 derived from the set of predefined objects) extended from 3050 ObjectPropertiesType and utilize them as part of their CybOX 3051 content.The object_reference field specifies a unique ID 3052 reference to an Object defined elsewhere. This construct allows 3053 for the re-use of the defined Properties of one Object within 3054 another, without the need to embed the full Object in the 3055 location from which it is being referenced. Thus, this ID 3056 reference is intended to resolve to the Properties of the Object 3057 that it points to.""" 3058 3059 subclass = None 3060 superclass = None 3061 def __init__(self, object_reference=None, Custom_Properties=None, xsi_type=None): 3062 self.object_reference = _cast(None, object_reference) 3063 self.Custom_Properties = Custom_Properties 3064 self.xsi_type = xsi_type 3065 def factory(*args_, **kwargs_): 3066 if ObjectPropertiesType.subclass: 3067 return ObjectPropertiesType.subclass(*args_, **kwargs_) 3068 else: 3069 return ObjectPropertiesType(*args_, **kwargs_) 3070 factory = staticmethod(factory) 3071 def get_Custom_Properties(self): return self.Custom_Properties 3072 def set_Custom_Properties(self, Custom_Properties): self.Custom_Properties = Custom_Properties 3073 def get_object_reference(self): return self.object_reference 3074 def set_object_reference(self, object_reference): self.object_reference = object_reference 3075 def get_xsi_type(self): return self.xsi_type 3076 def set_xsi_type(self, xsi_type): self.xsi_type = xsi_type 3077 def hasContent_(self): 3078 if ( 3079 self.Custom_Properties is not None or 3080 self.object_reference is not None or 3081 self.xsi_type is not None 3082 ): 3083 return True 3084 else: 3085 return False 3086 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='ObjectPropertiesType', namespacedef_='', pretty_print=True): 3087 if pretty_print: 3088 eol_ = '\n' 3089 else: 3090 eol_ = '' 3091 showIndent(lwrite, level, pretty_print) 3092 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 3093 already_processed = set() 3094 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='ObjectPropertiesType') 3095 if self.hasContent_(): 3096 lwrite('>%s' % (eol_, )) 3097 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 3098 showIndent(lwrite, level, pretty_print) 3099 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 3100 else: 3101 lwrite('/>%s' % (eol_, )) 3102 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='ObjectPropertiesType'): 3103 if self.object_reference is not None: 3104 3105 lwrite(' object_reference=%s' % (quote_attrib(self.object_reference), )) 3106 if self.xsi_type is not None: 3107 3108 lwrite(' xsi:type="%s"' % self.xsi_type) 3109 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='ObjectPropertiesType', fromsubclass_=False, pretty_print=True): 3110 if pretty_print: 3111 eol_ = '\n' 3112 else: 3113 eol_ = '' 3114 if self.Custom_Properties is not None: 3115 self.Custom_Properties.export(lwrite, level, 'cyboxCommon:', name_='Custom_Properties', pretty_print=pretty_print) 3116 def build(self, node): 3117 self.__sourcenode__ = node 3118 already_processed = set() 3119 self.buildAttributes(node, node.attrib, already_processed) 3120 for child in node: 3121 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 3122 self.buildChildren(child, node, nodeName_) 3123 def buildAttributes(self, node, attrs, already_processed): 3124 value = find_attr_value_('object_reference', node) 3125 if value is not None: 3126 3127 self.object_reference = value 3128 value = find_attr_value_('xsi:type', node) 3129 if value is not None: 3130 3131 self.xsi_type = value 3132 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 3133 if nodeName_ == 'Custom_Properties': 3134 obj_ = CustomPropertiesType.factory() 3135 obj_.build(child_) 3136 self.set_Custom_Properties(obj_) 3137# end class ObjectPropertiesType 3138 3139class CustomPropertiesType(GeneratedsSuper): 3140 """The CustomPropertiesType enables the specification of a set of 3141 custom Object Properties that may not be defined in existing 3142 Properties schemas.""" 3143 3144 subclass = None 3145 superclass = None 3146 def __init__(self, Property=None): 3147 if Property is None: 3148 self.Property = [] 3149 else: 3150 self.Property = Property 3151 def factory(*args_, **kwargs_): 3152 if CustomPropertiesType.subclass: 3153 return CustomPropertiesType.subclass(*args_, **kwargs_) 3154 else: 3155 return CustomPropertiesType(*args_, **kwargs_) 3156 factory = staticmethod(factory) 3157 def get_Property(self): return self.Property 3158 def set_Property(self, Property): self.Property = Property 3159 def add_Property(self, value): self.Property.append(value) 3160 def insert_Property(self, index, value): self.Property[index] = value 3161 def hasContent_(self): 3162 if ( 3163 self.Property 3164 ): 3165 return True 3166 else: 3167 return False 3168 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='CustomPropertiesType', namespacedef_='', pretty_print=True): 3169 if pretty_print: 3170 eol_ = '\n' 3171 else: 3172 eol_ = '' 3173 showIndent(lwrite, level, pretty_print) 3174 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 3175 already_processed = set() 3176 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='CustomPropertiesType') 3177 if self.hasContent_(): 3178 lwrite('>%s' % (eol_, )) 3179 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 3180 showIndent(lwrite, level, pretty_print) 3181 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 3182 else: 3183 lwrite('/>%s' % (eol_, )) 3184 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='CustomPropertiesType'): 3185 pass 3186 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='CustomPropertiesType', fromsubclass_=False, pretty_print=True): 3187 if pretty_print: 3188 eol_ = '\n' 3189 else: 3190 eol_ = '' 3191 for Property_ in self.Property: 3192 Property_.export(lwrite, level, 'cyboxCommon:', name_='Property', pretty_print=pretty_print) 3193 def build(self, node): 3194 self.__sourcenode__ = node 3195 already_processed = set() 3196 self.buildAttributes(node, node.attrib, already_processed) 3197 for child in node: 3198 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 3199 self.buildChildren(child, node, nodeName_) 3200 def buildAttributes(self, node, attrs, already_processed): 3201 pass 3202 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 3203 if nodeName_ == 'Property': 3204 obj_ = PropertyType.factory() 3205 obj_.build(child_) 3206 self.Property.append(obj_) 3207# end class CustomPropertiesType 3208 3209class BaseObjectPropertyType(GeneratedsSuper): 3210 """The BaseObjectPropertyType is a type representing a common typing 3211 foundation for the specification of a single Object 3212 Property.Properties that use this type can express multiple 3213 values by providing them using a delimiter-separated list. The 3214 default delimiter is '##comma##' (no quotes) but can be 3215 overridden through use of the delimiter field. Note that 3216 whitespace is preserved and so, when specifying a list of 3217 values, do not include a space following the delimiter in a list 3218 unless the first character of the next list item should, in 3219 fact, be a space.""" 3220 subclass = None 3221 superclass = None 3222 def __init__(self, obfuscation_algorithm_ref=None, refanging_transform_type=None, has_changed=None, delimiter='##comma##', pattern_type=None, datatype='string', refanging_transform=None, is_case_sensitive=True, bit_mask=None, appears_random=None, observed_encoding=None, defanging_algorithm_ref=None, is_obfuscated=None, regex_syntax=None, apply_condition='ANY', trend=None, idref=None, is_defanged=None, id=None, condition=None, valueOf_=None, extensiontype_=None): 3223 self.obfuscation_algorithm_ref = _cast(None, obfuscation_algorithm_ref) 3224 self.refanging_transform_type = _cast(None, refanging_transform_type) 3225 self.has_changed = _cast(bool, has_changed) 3226 self.delimiter = _cast(None, delimiter) 3227 self.pattern_type = _cast(None, pattern_type) 3228 self.datatype = _cast(None, datatype) 3229 self.refanging_transform = _cast(None, refanging_transform) 3230 self.is_case_sensitive = _cast(bool, is_case_sensitive) 3231 self.bit_mask = _cast(None, bit_mask) 3232 self.appears_random = _cast(bool, appears_random) 3233 self.observed_encoding = _cast(None, observed_encoding) 3234 self.defanging_algorithm_ref = _cast(None, defanging_algorithm_ref) 3235 self.is_obfuscated = _cast(bool, is_obfuscated) 3236 self.regex_syntax = _cast(None, regex_syntax) 3237 self.apply_condition = _cast(None, apply_condition) 3238 self.trend = _cast(bool, trend) 3239 self.idref = _cast(None, idref) 3240 self.is_defanged = _cast(bool, is_defanged) 3241 self.id = _cast(None, id) 3242 self.condition = _cast(None, condition) 3243 self.valueOf_ = valueOf_ 3244 self.extensiontype_ = extensiontype_ 3245 def factory(*args_, **kwargs_): 3246 if BaseObjectPropertyType.subclass: 3247 return BaseObjectPropertyType.subclass(*args_, **kwargs_) 3248 else: 3249 return BaseObjectPropertyType(*args_, **kwargs_) 3250 factory = staticmethod(factory) 3251 def get_obfuscation_algorithm_ref(self): return self.obfuscation_algorithm_ref 3252 def set_obfuscation_algorithm_ref(self, obfuscation_algorithm_ref): self.obfuscation_algorithm_ref = obfuscation_algorithm_ref 3253 def get_refanging_transform_type(self): return self.refanging_transform_type 3254 def set_refanging_transform_type(self, refanging_transform_type): self.refanging_transform_type = refanging_transform_type 3255 def get_has_changed(self): return self.has_changed 3256 def set_has_changed(self, has_changed): self.has_changed = has_changed 3257 def get_delimiter(self): return self.delimiter 3258 def set_delimiter(self, delimiter): self.delimiter = delimiter 3259 def get_pattern_type(self): return self.pattern_type 3260 def set_pattern_type(self, pattern_type): self.pattern_type = pattern_type 3261 def get_datatype(self): return self.datatype 3262 def set_datatype(self, datatype): self.datatype = datatype 3263 def get_refanging_transform(self): return self.refanging_transform 3264 def set_refanging_transform(self, refanging_transform): self.refanging_transform = refanging_transform 3265 def get_is_case_sensitive(self): return self.is_case_sensitive 3266 def set_is_case_sensitive(self, is_case_sensitive): self.is_case_sensitive = is_case_sensitive 3267 def get_bit_mask(self): return self.bit_mask 3268 def set_bit_mask(self, bit_mask): self.bit_mask = bit_mask 3269 def get_appears_random(self): return self.appears_random 3270 def set_appears_random(self, appears_random): self.appears_random = appears_random 3271 def get_observed_encoding(self): return self.observed_encoding 3272 def set_observed_encoding(self, observed_encoding): self.observed_encoding = observed_encoding 3273 def get_defanging_algorithm_ref(self): return self.defanging_algorithm_ref 3274 def set_defanging_algorithm_ref(self, defanging_algorithm_ref): self.defanging_algorithm_ref = defanging_algorithm_ref 3275 def get_is_obfuscated(self): return self.is_obfuscated 3276 def set_is_obfuscated(self, is_obfuscated): self.is_obfuscated = is_obfuscated 3277 def get_regex_syntax(self): return self.regex_syntax 3278 def set_regex_syntax(self, regex_syntax): self.regex_syntax = regex_syntax 3279 def get_apply_condition(self): return self.apply_condition 3280 def set_apply_condition(self, apply_condition): self.apply_condition = apply_condition 3281 def get_trend(self): return self.trend 3282 def set_trend(self, trend): self.trend = trend 3283 def get_idref(self): return self.idref 3284 def set_idref(self, idref): self.idref = idref 3285 def get_is_defanged(self): return self.is_defanged 3286 def set_is_defanged(self, is_defanged): self.is_defanged = is_defanged 3287 def get_id(self): return self.id 3288 def set_id(self, id): self.id = id 3289 def get_condition(self): return self.condition 3290 def set_condition(self, condition): self.condition = condition 3291 def get_valueOf_(self): return self.valueOf_ 3292 def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ 3293 def get_extensiontype_(self): return self.extensiontype_ 3294 def set_extensiontype_(self, extensiontype_): self.extensiontype_ = extensiontype_ 3295 def hasContent_(self): 3296 if ( 3297 self.valueOf_ 3298 ): 3299 return True 3300 else: 3301 return False 3302 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='BaseObjectPropertyType', namespacedef_='', pretty_print=True): 3303 if pretty_print: 3304 eol_ = '\n' 3305 else: 3306 eol_ = '' 3307 showIndent(lwrite, level, pretty_print) 3308 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 3309 already_processed = set() 3310 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='BaseObjectPropertyType') 3311 if self.hasContent_(): 3312 lwrite('>') 3313 lwrite(quote_xml(self.valueOf_)) 3314 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 3315 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 3316 else: 3317 lwrite('/>%s' % (eol_, )) 3318 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='BaseObjectPropertyType'): 3319 if self.obfuscation_algorithm_ref is not None: 3320 3321 lwrite(' obfuscation_algorithm_ref=%s' % (self.gds_format_string(quote_attrib(self.obfuscation_algorithm_ref), input_name='obfuscation_algorithm_ref'), )) 3322 if self.refanging_transform_type is not None: 3323 3324 lwrite(' refanging_transform_type=%s' % (self.gds_format_string(quote_attrib(self.refanging_transform_type), input_name='refanging_transform_type'), )) 3325 if self.has_changed is not None: 3326 3327 lwrite(' has_changed="%s"' % self.gds_format_boolean(self.has_changed, input_name='has_changed')) 3328 if self.delimiter not in (None, "##comma##"): 3329 3330 lwrite(' delimiter=%s' % (self.gds_format_string(quote_attrib(self.delimiter), input_name='delimiter'), )) 3331 if self.pattern_type is not None: 3332 3333 lwrite(' pattern_type=%s' % (quote_attrib(self.pattern_type), )) 3334 if self.datatype is not None: 3335 3336 lwrite(' datatype=%s' % (quote_attrib(self.datatype), )) 3337 if self.refanging_transform is not None: 3338 3339 lwrite(' refanging_transform=%s' % (self.gds_format_string(quote_attrib(self.refanging_transform), input_name='refanging_transform'), )) 3340 if self.is_case_sensitive not in (None, True): 3341 3342 lwrite(' is_case_sensitive="%s"' % self.gds_format_boolean(self.is_case_sensitive, input_name='is_case_sensitive')) 3343 if self.bit_mask is not None: 3344 3345 lwrite(' bit_mask=%s' % (self.gds_format_string(quote_attrib(self.bit_mask), input_name='bit_mask'), )) 3346 if self.appears_random is not None: 3347 3348 lwrite(' appears_random="%s"' % self.gds_format_boolean(self.appears_random, input_name='appears_random')) 3349 if self.observed_encoding is not None: 3350 3351 lwrite(' observed_encoding=%s' % (self.gds_format_string(quote_attrib(self.observed_encoding), input_name='observed_encoding'), )) 3352 if self.defanging_algorithm_ref is not None: 3353 3354 lwrite(' defanging_algorithm_ref=%s' % (self.gds_format_string(quote_attrib(self.defanging_algorithm_ref), input_name='defanging_algorithm_ref'), )) 3355 if self.is_obfuscated is not None: 3356 3357 lwrite(' is_obfuscated="%s"' % self.gds_format_boolean(self.is_obfuscated, input_name='is_obfuscated')) 3358 if self.regex_syntax is not None: 3359 3360 lwrite(' regex_syntax=%s' % (self.gds_format_string(quote_attrib(self.regex_syntax), input_name='regex_syntax'), )) 3361 if self.trend is not None: 3362 3363 lwrite(' trend="%s"' % self.gds_format_boolean(self.trend, input_name='trend')) 3364 if self.idref is not None: 3365 3366 lwrite(' idref=%s' % (quote_attrib(self.idref), )) 3367 if self.is_defanged is not None: 3368 3369 lwrite(' is_defanged="%s"' % self.gds_format_boolean(self.is_defanged, input_name='is_defanged')) 3370 if self.id is not None: 3371 3372 lwrite(' id=%s' % (quote_attrib(self.id), )) 3373 if self.condition is not None: 3374 3375 lwrite(' condition=%s' % (quote_attrib(self.condition), )) 3376 if self.apply_condition is not None and (self.delimiter is not None and self.valueOf_ is not None and self.delimiter in self.valueOf_): 3377 3378 lwrite(' apply_condition=%s' % (quote_attrib(self.apply_condition), )) 3379 if self.extensiontype_ is not None: 3380 3381 lwrite(' xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"') 3382 lwrite(' xsi:type="%s"' % self.extensiontype_) 3383 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='BaseObjectPropertyType', fromsubclass_=False, pretty_print=True): 3384 pass 3385 def build(self, node): 3386 self.__sourcenode__ = node 3387 already_processed = set() 3388 self.buildAttributes(node, node.attrib, already_processed) 3389 self.valueOf_ = get_all_text_(node) 3390 for child in node: 3391 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 3392 self.buildChildren(child, node, nodeName_) 3393 def buildAttributes(self, node, attrs, already_processed): 3394 value = find_attr_value_('obfuscation_algorithm_ref', node) 3395 if value is not None: 3396 3397 self.obfuscation_algorithm_ref = value 3398 value = find_attr_value_('refanging_transform_type', node) 3399 if value is not None: 3400 3401 self.refanging_transform_type = value 3402 value = find_attr_value_('has_changed', node) 3403 if value is not None: 3404 3405 if value in ('true', '1'): 3406 self.has_changed = True 3407 elif value in ('false', '0'): 3408 self.has_changed = False 3409 else: 3410 raise_parse_error(node, 'Bad boolean attribute') 3411 value = find_attr_value_('delimiter', node) 3412 if value is not None: 3413 3414 self.delimiter = value 3415 value = find_attr_value_('pattern_type', node) 3416 if value is not None: 3417 3418 self.pattern_type = value 3419 value = find_attr_value_('datatype', node) 3420 if value is not None: 3421 3422 self.datatype = value 3423 value = find_attr_value_('refanging_transform', node) 3424 if value is not None: 3425 3426 self.refanging_transform = value 3427 value = find_attr_value_('is_case_sensitive', node) 3428 if value is not None: 3429 3430 if value in ('true', '1'): 3431 self.is_case_sensitive = True 3432 elif value in ('false', '0'): 3433 self.is_case_sensitive = False 3434 else: 3435 raise_parse_error(node, 'Bad boolean attribute') 3436 value = find_attr_value_('bit_mask', node) 3437 if value is not None: 3438 3439 self.bit_mask = value 3440 value = find_attr_value_('appears_random', node) 3441 if value is not None: 3442 3443 if value in ('true', '1'): 3444 self.appears_random = True 3445 elif value in ('false', '0'): 3446 self.appears_random = False 3447 else: 3448 raise_parse_error(node, 'Bad boolean attribute') 3449 value = find_attr_value_('observed_encoding', node) 3450 if value is not None: 3451 3452 self.observed_encoding = value 3453 value = find_attr_value_('defanging_algorithm_ref', node) 3454 if value is not None: 3455 3456 self.defanging_algorithm_ref = value 3457 value = find_attr_value_('is_obfuscated', node) 3458 if value is not None: 3459 3460 if value in ('true', '1'): 3461 self.is_obfuscated = True 3462 elif value in ('false', '0'): 3463 self.is_obfuscated = False 3464 else: 3465 raise_parse_error(node, 'Bad boolean attribute') 3466 value = find_attr_value_('regex_syntax', node) 3467 if value is not None: 3468 3469 self.regex_syntax = value 3470 value = find_attr_value_('apply_condition', node) 3471 if value is not None: 3472 3473 self.apply_condition = value 3474 value = find_attr_value_('trend', node) 3475 if value is not None: 3476 3477 if value in ('true', '1'): 3478 self.trend = True 3479 elif value in ('false', '0'): 3480 self.trend = False 3481 else: 3482 raise_parse_error(node, 'Bad boolean attribute') 3483 value = find_attr_value_('idref', node) 3484 if value is not None: 3485 3486 self.idref = value 3487 value = find_attr_value_('is_defanged', node) 3488 if value is not None: 3489 3490 if value in ('true', '1'): 3491 self.is_defanged = True 3492 elif value in ('false', '0'): 3493 self.is_defanged = False 3494 else: 3495 raise_parse_error(node, 'Bad boolean attribute') 3496 value = find_attr_value_('id', node) 3497 if value is not None: 3498 3499 self.id = value 3500 value = find_attr_value_('condition', node) 3501 if value is not None: 3502 3503 self.condition = value 3504 value = find_attr_value_('xsi:type', node) 3505 if value is not None: 3506 3507 self.extensiontype_ = value 3508 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 3509 pass 3510# end class BaseObjectPropertyType 3511 3512class DateObjectPropertyRestrictionType(BaseObjectPropertyType): 3513 """This type is an intermediate type to allow for the addition of the 3514 precision attribute to DateObjectPropertyType. It should not be 3515 used directly.This attribute is optional and specifies the type 3516 of the value of the specified property. If a type different than 3517 the default is used, it MUST be specified here.""" 3518 subclass = None 3519 superclass = BaseObjectPropertyType 3520 def __init__(self, obfuscation_algorithm_ref=None, refanging_transform_type=None, has_changed=None, delimiter='##comma##', pattern_type=None, datatype='date', refanging_transform=None, is_case_sensitive=True, bit_mask=None, appears_random=None, observed_encoding=None, defanging_algorithm_ref=None, is_obfuscated=None, regex_syntax=None, apply_condition='ANY', trend=None, idref=None, is_defanged=None, id=None, condition=None, valueOf_=None, extensiontype_=None): 3521 # PROP: This is a BaseObjectPropertyType subclass 3522 super(DateObjectPropertyRestrictionType, self).__init__(obfuscation_algorithm_ref, refanging_transform_type, has_changed, delimiter, pattern_type, datatype, refanging_transform, is_case_sensitive, bit_mask, appears_random, observed_encoding, defanging_algorithm_ref, is_obfuscated, regex_syntax, apply_condition, trend, idref, is_defanged, id, condition, valueOf_, extensiontype_) 3523 def factory(*args_, **kwargs_): 3524 if DateObjectPropertyRestrictionType.subclass: 3525 return DateObjectPropertyRestrictionType.subclass(*args_, **kwargs_) 3526 else: 3527 return DateObjectPropertyRestrictionType(*args_, **kwargs_) 3528 factory = staticmethod(factory) 3529 def hasContent_(self): 3530 if ( 3531 self.valueOf_ or 3532 super(DateObjectPropertyRestrictionType, self).hasContent_() 3533 ): 3534 return True 3535 else: 3536 return False 3537 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='DateObjectPropertyRestrictionType', namespacedef_='', pretty_print=True): 3538 if pretty_print: 3539 eol_ = '\n' 3540 else: 3541 eol_ = '' 3542 showIndent(lwrite, level, pretty_print) 3543 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 3544 already_processed = set() 3545 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='DateObjectPropertyRestrictionType') 3546 if self.hasContent_(): 3547 lwrite('>') 3548 lwrite(quote_xml(self.valueOf_)) 3549 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 3550 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 3551 else: 3552 lwrite('/>%s' % (eol_, )) 3553 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='DateObjectPropertyRestrictionType'): 3554 super(DateObjectPropertyRestrictionType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='DateObjectPropertyRestrictionType') 3555 if self.extensiontype_ is not None: 3556 3557 lwrite(' xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"') 3558 lwrite(' xsi:type="%s"' % self.extensiontype_) 3559 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='DateObjectPropertyRestrictionType', fromsubclass_=False, pretty_print=True): 3560 super(DateObjectPropertyRestrictionType, self).exportChildren(lwrite, level, 'cyboxCommon:', name_, True, pretty_print=pretty_print) 3561 pass 3562 def build(self, node): 3563 self.__sourcenode__ = node 3564 already_processed = set() 3565 self.buildAttributes(node, node.attrib, already_processed) 3566 self.valueOf_ = get_all_text_(node) 3567 for child in node: 3568 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 3569 self.buildChildren(child, node, nodeName_) 3570 def buildAttributes(self, node, attrs, already_processed): 3571 value = find_attr_value_('datatype', node) 3572 if value is not None: 3573 3574 self.datatype = value 3575 value = find_attr_value_('xsi:type', node) 3576 if value is not None: 3577 3578 self.extensiontype_ = value 3579 super(DateObjectPropertyRestrictionType, self).buildAttributes(node, attrs, already_processed) 3580 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 3581 pass 3582# end class DateObjectPropertyRestrictionType 3583 3584class DateObjectPropertyType(DateObjectPropertyRestrictionType): 3585 """The DateObjectPropertyType is a type (extended from 3586 BaseObjectPropertyType) representing the specification of a 3587 single Object property whose core value is of type Date. This 3588 type will be assigned to any property of a CybOX object that 3589 should contain content of type Date and enables the use of 3590 relevant metadata for the property. In order to avoid ambiguity, 3591 it is strongly suggested that any date representation in this 3592 field include a timezone if it is known. As with the rest of the 3593 field, this should be formatted per the xs:date 3594 specification.Properties that use this type can express multiple 3595 values by providing them using a delimiter-separated list. The 3596 default delimiter is '##comma##' (no quotes) but can be 3597 overridden through use of the delimiter field. Note that 3598 whitespace is preserved and so, when specifying a list of 3599 values, do not include a space following the delimiter in a list 3600 unless the first character of the next list item should, in 3601 fact, be a space.For fields of this type using CybOX patterning, 3602 it is strongly suggested that the condition (pattern type) is 3603 limited to one of Equals, DoesNotEqual, GreaterThan, LessThan, 3604 GreaterThanOrEqual, LessThanOrEqual, ExclusiveBetween, or 3605 InclusiveBetween. The use of other conditions may lead to 3606 ambiguity or unexpected results. When evaluating data against a 3607 pattern, the evaluator should take into account the precision of 3608 the field (as given by the precision attribute) and any timezone 3609 information that is available to perform a data-aware 3610 comparison. The usage of simple string comparisons is 3611 discouraged due to ambiguities in how precision and timezone 3612 information is processed.The precision of the associated time. 3613 If omitted, the default is "day", meaning the full field value. 3614 Digits in the date that are required by the xs:date datatype but 3615 are beyond the specified precision should be zeroed out.When 3616 used in conjunction with CybOX patterning, the pattern should 3617 only be evaluated against the target up to the given precision.""" 3618 subclass = None 3619 superclass = DateObjectPropertyRestrictionType 3620 def __init__(self, obfuscation_algorithm_ref=None, refanging_transform_type=None, has_changed=None, delimiter='##comma##', pattern_type=None, datatype='date', refanging_transform=None, is_case_sensitive=True, bit_mask=None, appears_random=None, observed_encoding=None, defanging_algorithm_ref=None, is_obfuscated=None, regex_syntax=None, apply_condition='ANY', trend=None, idref=None, is_defanged=None, id=None, condition=None, valueOf_=None, extensiontype_=None, precision='day'): 3621 # PROP: This is a BaseObjectPropertyType subclass 3622 super(DateObjectPropertyType, self).__init__(obfuscation_algorithm_ref, refanging_transform_type, has_changed, delimiter, pattern_type, datatype, refanging_transform, is_case_sensitive, bit_mask, appears_random, observed_encoding, defanging_algorithm_ref, is_obfuscated, regex_syntax, apply_condition, trend, idref, is_defanged, id, condition, valueOf_, extensiontype_) 3623 self.precision = _cast(None, precision) 3624 def factory(*args_, **kwargs_): 3625 if DateObjectPropertyType.subclass: 3626 return DateObjectPropertyType.subclass(*args_, **kwargs_) 3627 else: 3628 return DateObjectPropertyType(*args_, **kwargs_) 3629 factory = staticmethod(factory) 3630 def get_precision(self): return self.precision 3631 def set_precision(self, precision): self.precision = precision 3632 def hasContent_(self): 3633 if ( 3634 self.valueOf_ or 3635 super(DateObjectPropertyType, self).hasContent_() 3636 ): 3637 return True 3638 else: 3639 return False 3640 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='DateObjectPropertyType', namespacedef_='', pretty_print=True): 3641 if pretty_print: 3642 eol_ = '\n' 3643 else: 3644 eol_ = '' 3645 showIndent(lwrite, level, pretty_print) 3646 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 3647 already_processed = set() 3648 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='DateObjectPropertyType') 3649 if self.hasContent_(): 3650 lwrite('>') 3651 lwrite(quote_xml(self.valueOf_)) 3652 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 3653 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 3654 else: 3655 lwrite('/>%s' % (eol_, )) 3656 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='DateObjectPropertyType'): 3657 super(DateObjectPropertyType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='DateObjectPropertyType') 3658 if self.precision not in (None, 'second'): 3659 3660 lwrite(' precision=%s' % (quote_attrib(self.precision), )) 3661 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='DateObjectPropertyType', fromsubclass_=False, pretty_print=True): 3662 super(DateObjectPropertyType, self).exportChildren(lwrite, level, 'cyboxCommon:', name_, True, pretty_print=pretty_print) 3663 pass 3664 def build(self, node): 3665 self.__sourcenode__ = node 3666 already_processed = set() 3667 self.buildAttributes(node, node.attrib, already_processed) 3668 self.valueOf_ = get_all_text_(node) 3669 for child in node: 3670 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 3671 self.buildChildren(child, node, nodeName_) 3672 def buildAttributes(self, node, attrs, already_processed): 3673 value = find_attr_value_('precision', node) 3674 if value is not None: 3675 3676 self.precision = value 3677 super(DateObjectPropertyType, self).buildAttributes(node, attrs, already_processed) 3678 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 3679 pass 3680# end class DateObjectPropertyType 3681 3682class DateTimeObjectPropertyRestrictionType(BaseObjectPropertyType): 3683 """This type is an intermediate type to allow for the addition of the 3684 precision attribute to DateTimeObjectPropertyType. It should not 3685 be used directly.This attribute is optional and specifies the 3686 type of the value of the specified property. If a type different 3687 than the default is used, it MUST be specified here.""" 3688 subclass = None 3689 superclass = BaseObjectPropertyType 3690 def __init__(self, obfuscation_algorithm_ref=None, refanging_transform_type=None, has_changed=None, delimiter='##comma##', pattern_type=None, datatype='dateTime', refanging_transform=None, is_case_sensitive=True, bit_mask=None, appears_random=None, observed_encoding=None, defanging_algorithm_ref=None, is_obfuscated=None, regex_syntax=None, apply_condition='ANY', trend=None, idref=None, is_defanged=None, id=None, condition=None, valueOf_=None, extensiontype_=None): 3691 # PROP: This is a BaseObjectPropertyType subclass 3692 super(DateTimeObjectPropertyRestrictionType, self).__init__(obfuscation_algorithm_ref, refanging_transform_type, has_changed, delimiter, pattern_type, datatype, refanging_transform, is_case_sensitive, bit_mask, appears_random, observed_encoding, defanging_algorithm_ref, is_obfuscated, regex_syntax, apply_condition, trend, idref, is_defanged, id, condition, valueOf_, extensiontype_) 3693 def factory(*args_, **kwargs_): 3694 if DateTimeObjectPropertyRestrictionType.subclass: 3695 return DateTimeObjectPropertyRestrictionType.subclass(*args_, **kwargs_) 3696 else: 3697 return DateTimeObjectPropertyRestrictionType(*args_, **kwargs_) 3698 factory = staticmethod(factory) 3699 def hasContent_(self): 3700 if ( 3701 self.valueOf_ or 3702 super(DateTimeObjectPropertyRestrictionType, self).hasContent_() 3703 ): 3704 return True 3705 else: 3706 return False 3707 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='DateTimeObjectPropertyRestrictionType', namespacedef_='', pretty_print=True): 3708 if pretty_print: 3709 eol_ = '\n' 3710 else: 3711 eol_ = '' 3712 showIndent(lwrite, level, pretty_print) 3713 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 3714 already_processed = set() 3715 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='DateTimeObjectPropertyRestrictionType') 3716 if self.hasContent_(): 3717 lwrite('>') 3718 lwrite(quote_xml(self.valueOf_)) 3719 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 3720 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 3721 else: 3722 lwrite('/>%s' % (eol_, )) 3723 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='DateTimeObjectPropertyRestrictionType'): 3724 super(DateTimeObjectPropertyRestrictionType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='DateTimeObjectPropertyRestrictionType') 3725 if self.extensiontype_ is not None: 3726 3727 lwrite(' xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"') 3728 lwrite(' xsi:type="%s"' % self.extensiontype_) 3729 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='DateTimeObjectPropertyRestrictionType', fromsubclass_=False, pretty_print=True): 3730 super(DateTimeObjectPropertyRestrictionType, self).exportChildren(lwrite, level, 'cyboxCommon:', name_, True, pretty_print=pretty_print) 3731 pass 3732 def build(self, node): 3733 self.__sourcenode__ = node 3734 already_processed = set() 3735 self.buildAttributes(node, node.attrib, already_processed) 3736 self.valueOf_ = get_all_text_(node) 3737 for child in node: 3738 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 3739 self.buildChildren(child, node, nodeName_) 3740 def buildAttributes(self, node, attrs, already_processed): 3741 value = find_attr_value_('datatype', node) 3742 if value is not None: 3743 3744 self.datatype = value 3745 value = find_attr_value_('xsi:type', node) 3746 if value is not None: 3747 3748 self.extensiontype_ = value 3749 super(DateTimeObjectPropertyRestrictionType, self).buildAttributes(node, attrs, already_processed) 3750 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 3751 pass 3752# end class DateTimeObjectPropertyRestrictionType 3753 3754class DateTimeObjectPropertyType(DateTimeObjectPropertyRestrictionType): 3755 """The DateTimeObjectPropertyType is a type (extended from 3756 BaseObjectPropertyType) representing the specification of a 3757 single Object property whose core value is of type DateTime. 3758 This type will be assigned to any property of a CybOX object 3759 that should contain content of type DateTime and enables the use 3760 of relevant metadata for the property. In order to avoid 3761 ambiguity, it is strongly suggested that any dateTime 3762 representation in this field include a timezone. As with the 3763 rest of the field, this should be formatted per the xs:dateTime 3764 specification.Properties that use this type can express multiple 3765 values by providing them using a delimiter-separated list. The 3766 default delimiter is '##comma##' (no quotes) but can be 3767 overridden through use of the delimiter field. Note that 3768 whitespace is preserved and so, when specifying a list of 3769 values, do not include a space following the delimiter in a list 3770 unless the first character of the next list item should, in 3771 fact, be a space.For fields of this type using CybOX patterning, 3772 it is strongly suggested that the condition (pattern type) is 3773 limited to one of Equals, DoesNotEqual, GreaterThan, LessThan, 3774 GreaterThanOrEqual, LessThanOrEqual, ExclusiveBetween, or 3775 InclusiveBetween. The use of other conditions may lead to 3776 ambiguity or unexpected results. When evaluating data against a 3777 pattern, the evaluator should take into account the precision of 3778 the field (as given by the precision attribute) and any timezone 3779 information that is available to perform a data-aware 3780 comparison. The usage of simple string comparisons is 3781 discouraged due to ambiguities in how precision and timezone 3782 information is processed.The precision of the associated time. 3783 If omitted, the default is "second", meaning the full field 3784 value (including fractional seconds). Digits in the dateTime 3785 that are required by the xs:dateTime datatype but are beyond the 3786 specified precision should be zeroed out.When used in 3787 conjunction with CybOX patterning, the pattern should only be 3788 evaluated against the target up to the given precision.""" 3789 subclass = None 3790 superclass = DateTimeObjectPropertyRestrictionType 3791 def __init__(self, obfuscation_algorithm_ref=None, refanging_transform_type=None, has_changed=None, delimiter='##comma##', pattern_type=None, datatype='dateTime', refanging_transform=None, is_case_sensitive=True, bit_mask=None, appears_random=None, observed_encoding=None, defanging_algorithm_ref=None, is_obfuscated=None, regex_syntax=None, apply_condition='ANY', trend=None, idref=None, is_defanged=None, id=None, condition=None, valueOf_=None, extensiontype_=None, precision='second'): 3792 # PROP: This is a BaseObjectPropertyType subclass 3793 super(DateTimeObjectPropertyType, self).__init__(obfuscation_algorithm_ref, refanging_transform_type, has_changed, delimiter, pattern_type, datatype, refanging_transform, is_case_sensitive, bit_mask, appears_random, observed_encoding, defanging_algorithm_ref, is_obfuscated, regex_syntax, apply_condition, trend, idref, is_defanged, id, condition, valueOf_, extensiontype_) 3794 self.precision = _cast(None, precision) 3795 def factory(*args_, **kwargs_): 3796 if DateTimeObjectPropertyType.subclass: 3797 return DateTimeObjectPropertyType.subclass(*args_, **kwargs_) 3798 else: 3799 return DateTimeObjectPropertyType(*args_, **kwargs_) 3800 factory = staticmethod(factory) 3801 def get_precision(self): return self.precision 3802 def set_precision(self, precision): self.precision = precision 3803 def hasContent_(self): 3804 if ( 3805 self.valueOf_ or 3806 super(DateTimeObjectPropertyType, self).hasContent_() 3807 ): 3808 return True 3809 else: 3810 return False 3811 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='DateTimeObjectPropertyType', namespacedef_='', pretty_print=True): 3812 if pretty_print: 3813 eol_ = '\n' 3814 else: 3815 eol_ = '' 3816 showIndent(lwrite, level, pretty_print) 3817 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 3818 already_processed = set() 3819 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='DateTimeObjectPropertyType') 3820 if self.hasContent_(): 3821 lwrite('>') 3822 lwrite(quote_xml(self.valueOf_)) 3823 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 3824 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 3825 else: 3826 lwrite('/>%s' % (eol_, )) 3827 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='DateTimeObjectPropertyType'): 3828 super(DateTimeObjectPropertyType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='DateTimeObjectPropertyType') 3829 if self.precision not in (None, 'second'): 3830 3831 lwrite(' precision=%s' % (quote_attrib(self.precision), )) 3832 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='DateTimeObjectPropertyType', fromsubclass_=False, pretty_print=True): 3833 super(DateTimeObjectPropertyType, self).exportChildren(lwrite, level, 'cyboxCommon:', name_, True, pretty_print=pretty_print) 3834 pass 3835 def build(self, node): 3836 self.__sourcenode__ = node 3837 already_processed = set() 3838 self.buildAttributes(node, node.attrib, already_processed) 3839 self.valueOf_ = get_all_text_(node) 3840 for child in node: 3841 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 3842 self.buildChildren(child, node, nodeName_) 3843 def buildAttributes(self, node, attrs, already_processed): 3844 value = find_attr_value_('precision', node) 3845 if value is not None: 3846 3847 self.precision = value 3848 super(DateTimeObjectPropertyType, self).buildAttributes(node, attrs, already_processed) 3849 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 3850 pass 3851# end class DateTimeObjectPropertyType 3852 3853class IntegerObjectPropertyType(BaseObjectPropertyType): 3854 subclass = None 3855 superclass = BaseObjectPropertyType 3856 def __init__(self, obfuscation_algorithm_ref=None, refanging_transform_type=None, has_changed=None, delimiter='##comma##', pattern_type=None, datatype='int', refanging_transform=None, is_case_sensitive=True, bit_mask=None, appears_random=None, observed_encoding=None, defanging_algorithm_ref=None, is_obfuscated=None, regex_syntax=None, apply_condition='ANY', trend=None, idref=None, is_defanged=None, id=None, condition=None, valueOf_=None, extensiontype_=None): 3857 # PROP: This is a BaseObjectPropertyType subclass 3858 super(IntegerObjectPropertyType, self).__init__(obfuscation_algorithm_ref, refanging_transform_type, has_changed, delimiter, pattern_type, datatype, refanging_transform, is_case_sensitive, bit_mask, appears_random, observed_encoding, defanging_algorithm_ref, is_obfuscated, regex_syntax, apply_condition, trend, idref, is_defanged, id, condition, valueOf_, extensiontype_) 3859 def factory(*args_, **kwargs_): 3860 if IntegerObjectPropertyType.subclass: 3861 return IntegerObjectPropertyType.subclass(*args_, **kwargs_) 3862 else: 3863 return IntegerObjectPropertyType(*args_, **kwargs_) 3864 factory = staticmethod(factory) 3865 def hasContent_(self): 3866 if ( 3867 self.valueOf_ or 3868 super(IntegerObjectPropertyType, self).hasContent_() 3869 ): 3870 return True 3871 else: 3872 return False 3873 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='IntegerObjectPropertyType', namespacedef_='', pretty_print=True): 3874 if pretty_print: 3875 eol_ = '\n' 3876 else: 3877 eol_ = '' 3878 showIndent(lwrite, level, pretty_print) 3879 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 3880 already_processed = set() 3881 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='IntegerObjectPropertyType') 3882 if self.hasContent_(): 3883 lwrite('>') 3884 lwrite(quote_xml(self.valueOf_)) 3885 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 3886 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 3887 else: 3888 lwrite('/>%s' % (eol_, )) 3889 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='IntegerObjectPropertyType'): 3890 super(IntegerObjectPropertyType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='IntegerObjectPropertyType') 3891 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='IntegerObjectPropertyType', fromsubclass_=False, pretty_print=True): 3892 super(IntegerObjectPropertyType, self).exportChildren(lwrite, level, 'cyboxCommon:', name_, True, pretty_print=pretty_print) 3893 pass 3894 def build(self, node): 3895 self.__sourcenode__ = node 3896 already_processed = set() 3897 self.buildAttributes(node, node.attrib, already_processed) 3898 self.valueOf_ = get_all_text_(node) 3899 for child in node: 3900 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 3901 self.buildChildren(child, node, nodeName_) 3902 def buildAttributes(self, node, attrs, already_processed): 3903 value = find_attr_value_('datatype', node) 3904 if value is not None: 3905 3906 self.datatype = value 3907 super(IntegerObjectPropertyType, self).buildAttributes(node, attrs, already_processed) 3908 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 3909 pass 3910# end class IntegerObjectPropertyType 3911 3912class StringObjectPropertyType(BaseObjectPropertyType): 3913 subclass = None 3914 superclass = BaseObjectPropertyType 3915 def __init__(self, obfuscation_algorithm_ref=None, refanging_transform_type=None, has_changed=None, delimiter='##comma##', pattern_type=None, datatype='string', refanging_transform=None, is_case_sensitive=True, bit_mask=None, appears_random=None, observed_encoding=None, defanging_algorithm_ref=None, is_obfuscated=None, regex_syntax=None, apply_condition='ANY', trend=None, idref=None, is_defanged=None, id=None, condition=None, valueOf_=None, extensiontype_=None): 3916 # PROP: This is a BaseObjectPropertyType subclass 3917 super(StringObjectPropertyType, self).__init__(obfuscation_algorithm_ref, refanging_transform_type, has_changed, delimiter, pattern_type, datatype, refanging_transform, is_case_sensitive, bit_mask, appears_random, observed_encoding, defanging_algorithm_ref, is_obfuscated, regex_syntax, apply_condition, trend, idref, is_defanged, id, condition, valueOf_, extensiontype_) 3918 def factory(*args_, **kwargs_): 3919 if StringObjectPropertyType.subclass: 3920 return StringObjectPropertyType.subclass(*args_, **kwargs_) 3921 else: 3922 return StringObjectPropertyType(*args_, **kwargs_) 3923 factory = staticmethod(factory) 3924 def hasContent_(self): 3925 if ( 3926 self.valueOf_ or 3927 super(StringObjectPropertyType, self).hasContent_() 3928 ): 3929 return True 3930 else: 3931 return False 3932 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='StringObjectPropertyType', namespacedef_='', pretty_print=True): 3933 if pretty_print: 3934 eol_ = '\n' 3935 #lwrite(' ' * level) 3936 else: 3937 eol_ = '' 3938 showIndent(lwrite, level, pretty_print) 3939 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 3940 already_processed = set() 3941 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='StringObjectPropertyType') 3942 if self.hasContent_(): 3943 lwrite('>') 3944 lwrite(quote_xml(self.valueOf_)) 3945 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 3946 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 3947 else: 3948 lwrite('/>%s' % (eol_, )) 3949 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='StringObjectPropertyType'): 3950 super(StringObjectPropertyType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='StringObjectPropertyType') 3951 if self.extensiontype_ is not None: 3952 lwrite(' xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"') 3953 lwrite(' xsi:type="%s"' % self.extensiontype_) 3954 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='StringObjectPropertyType', fromsubclass_=False, pretty_print=True): 3955 super(StringObjectPropertyType, self).exportChildren(lwrite, level, 'cyboxCommon:', name_, True, pretty_print=pretty_print) 3956 pass 3957 def build(self, node): 3958 self.__sourcenode__ = node 3959 already_processed = set() 3960 self.buildAttributes(node, node.attrib, already_processed) 3961 self.valueOf_ = get_all_text_(node) 3962 for child in node: 3963 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 3964 self.buildChildren(child, node, nodeName_) 3965 def buildAttributes(self, node, attrs, already_processed): 3966 value = find_attr_value_('datatype', node) 3967 if value is not None: 3968 self.datatype = value 3969 value = find_attr_value_('xsi:type', node) 3970 if value is not None: 3971 self.extensiontype_ = value 3972 super(StringObjectPropertyType, self).buildAttributes(node, attrs, already_processed) 3973 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 3974 pass 3975# end class StringObjectPropertyType 3976 3977class NameObjectPropertyType(BaseObjectPropertyType): 3978 subclass = None 3979 superclass = BaseObjectPropertyType 3980 def __init__(self, obfuscation_algorithm_ref=None, refanging_transform_type=None, has_changed=None, delimiter='##comma##', pattern_type=None, datatype='name', refanging_transform=None, is_case_sensitive=True, bit_mask=None, appears_random=None, observed_encoding=None, defanging_algorithm_ref=None, is_obfuscated=None, regex_syntax=None, apply_condition='ANY', trend=None, idref=None, is_defanged=None, id=None, condition=None, valueOf_=None, extensiontype_=None): 3981 # PROP: This is a BaseObjectPropertyType subclass 3982 super(NameObjectPropertyType, self).__init__(obfuscation_algorithm_ref, refanging_transform_type, has_changed, delimiter, pattern_type, datatype, refanging_transform, is_case_sensitive, bit_mask, appears_random, observed_encoding, defanging_algorithm_ref, is_obfuscated, regex_syntax, apply_condition, trend, idref, is_defanged, id, condition, valueOf_, extensiontype_) 3983 def factory(*args_, **kwargs_): 3984 if NameObjectPropertyType.subclass: 3985 return NameObjectPropertyType.subclass(*args_, **kwargs_) 3986 else: 3987 return NameObjectPropertyType(*args_, **kwargs_) 3988 factory = staticmethod(factory) 3989 def hasContent_(self): 3990 if ( 3991 self.valueOf_ or 3992 super(NameObjectPropertyType, self).hasContent_() 3993 ): 3994 return True 3995 else: 3996 return False 3997 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='NameObjectPropertyType', namespacedef_='', pretty_print=True): 3998 if pretty_print: 3999 eol_ = '\n' 4000 else: 4001 eol_ = '' 4002 showIndent(lwrite, level, pretty_print) 4003 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 4004 already_processed = set() 4005 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='NameObjectPropertyType') 4006 if self.hasContent_(): 4007 lwrite('>') 4008 lwrite(quote_xml(self.valueOf_)) 4009 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 4010 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 4011 else: 4012 lwrite('/>%s' % (eol_, )) 4013 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='NameObjectPropertyType'): 4014 super(NameObjectPropertyType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='NameObjectPropertyType') 4015 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='NameObjectPropertyType', fromsubclass_=False, pretty_print=True): 4016 super(NameObjectPropertyType, self).exportChildren(lwrite, level, 'cyboxCommon:', name_, True, pretty_print=pretty_print) 4017 pass 4018 def build(self, node): 4019 self.__sourcenode__ = node 4020 already_processed = set() 4021 self.buildAttributes(node, node.attrib, already_processed) 4022 self.valueOf_ = get_all_text_(node) 4023 for child in node: 4024 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 4025 self.buildChildren(child, node, nodeName_) 4026 def buildAttributes(self, node, attrs, already_processed): 4027 value = find_attr_value_('datatype', node) 4028 if value is not None: 4029 4030 self.datatype = value 4031 super(NameObjectPropertyType, self).buildAttributes(node, attrs, already_processed) 4032 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 4033 pass 4034# end class NameObjectPropertyType 4035 4036 4037 4038class FloatObjectPropertyType(BaseObjectPropertyType): 4039 subclass = None 4040 superclass = BaseObjectPropertyType 4041 def __init__(self, obfuscation_algorithm_ref=None, refanging_transform_type=None, has_changed=None, delimiter='##comma##', pattern_type=None, datatype='float', refanging_transform=None, is_case_sensitive=True, bit_mask=None, appears_random=None, observed_encoding=None, defanging_algorithm_ref=None, is_obfuscated=None, regex_syntax=None, apply_condition='ANY', trend=None, idref=None, is_defanged=None, id=None, condition=None, valueOf_=None, extensiontype_=None): 4042 # PROP: This is a BaseObjectPropertyType subclass 4043 super(FloatObjectPropertyType, self).__init__(obfuscation_algorithm_ref, refanging_transform_type, has_changed, delimiter, pattern_type, datatype, refanging_transform, is_case_sensitive, bit_mask, appears_random, observed_encoding, defanging_algorithm_ref, is_obfuscated, regex_syntax, apply_condition, trend, idref, is_defanged, id, condition, valueOf_, extensiontype_) 4044 def factory(*args_, **kwargs_): 4045 if FloatObjectPropertyType.subclass: 4046 return FloatObjectPropertyType.subclass(*args_, **kwargs_) 4047 else: 4048 return FloatObjectPropertyType(*args_, **kwargs_) 4049 factory = staticmethod(factory) 4050 def hasContent_(self): 4051 if ( 4052 str(self.valueOf_) == '0' or 4053 str(self.valueOf_) == '0.0' or 4054 self.valueOf_ or 4055 super(FloatObjectPropertyType, self).hasContent_() 4056 ): 4057 return True 4058 else: 4059 return False 4060 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='FloatObjectPropertyType', namespacedef_='', pretty_print=True): 4061 if pretty_print: 4062 eol_ = '\n' 4063 else: 4064 eol_ = '' 4065 showIndent(lwrite, level, pretty_print) 4066 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 4067 already_processed = set() 4068 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='FloatObjectPropertyType') 4069 if self.hasContent_(): 4070 lwrite('>') 4071 lwrite(quote_xml(self.valueOf_)) 4072 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 4073 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 4074 else: 4075 lwrite('/>%s' % (eol_, )) 4076 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='FloatObjectPropertyType'): 4077 super(FloatObjectPropertyType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='FloatObjectPropertyType') 4078 4079 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='FloatObjectPropertyType', fromsubclass_=False, pretty_print=True): 4080 super(FloatObjectPropertyType, self).exportChildren(lwrite, level, 'cyboxCommon:', name_, True, pretty_print=pretty_print) 4081 pass 4082 def build(self, node): 4083 self.__sourcenode__ = node 4084 already_processed = set() 4085 self.buildAttributes(node, node.attrib, already_processed) 4086 self.valueOf_ = get_all_text_(node) 4087 for child in node: 4088 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 4089 self.buildChildren(child, node, nodeName_) 4090 def buildAttributes(self, node, attrs, already_processed): 4091 value = find_attr_value_('datatype', node) 4092 if value is not None: 4093 4094 self.datatype = value 4095 super(FloatObjectPropertyType, self).buildAttributes(node, attrs, already_processed) 4096 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 4097 pass 4098# end class FloatObjectPropertyType 4099 4100class DoubleObjectPropertyType(BaseObjectPropertyType): 4101 subclass = None 4102 superclass = BaseObjectPropertyType 4103 def __init__(self, obfuscation_algorithm_ref=None, refanging_transform_type=None, has_changed=None, delimiter='##comma##', pattern_type=None, datatype='double', refanging_transform=None, is_case_sensitive=True, bit_mask=None, appears_random=None, observed_encoding=None, defanging_algorithm_ref=None, is_obfuscated=None, regex_syntax=None, apply_condition='ANY', trend=None, idref=None, is_defanged=None, id=None, condition=None, valueOf_=None, extensiontype_=None): 4104 # PROP: This is a BaseObjectPropertyType subclass 4105 super(DoubleObjectPropertyType, self).__init__(obfuscation_algorithm_ref, refanging_transform_type, has_changed, delimiter, pattern_type, datatype, refanging_transform, is_case_sensitive, bit_mask, appears_random, observed_encoding, defanging_algorithm_ref, is_obfuscated, regex_syntax, apply_condition, trend, idref, is_defanged, id, condition, valueOf_, extensiontype_) 4106 def factory(*args_, **kwargs_): 4107 if DoubleObjectPropertyType.subclass: 4108 return DoubleObjectPropertyType.subclass(*args_, **kwargs_) 4109 else: 4110 return DoubleObjectPropertyType(*args_, **kwargs_) 4111 factory = staticmethod(factory) 4112 def hasContent_(self): 4113 if ( 4114 str(self.valueOf_) == '0' or 4115 str(self.valueOf_) == '0.0' or 4116 self.valueOf_ or 4117 super(DoubleObjectPropertyType, self).hasContent_() 4118 ): 4119 return True 4120 else: 4121 return False 4122 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='DoubleObjectPropertyType', namespacedef_='', pretty_print=True): 4123 if pretty_print: 4124 eol_ = '\n' 4125 else: 4126 eol_ = '' 4127 showIndent(lwrite, level, pretty_print) 4128 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 4129 already_processed = set() 4130 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='DoubleObjectPropertyType') 4131 if self.hasContent_(): 4132 lwrite('>') 4133 lwrite(quote_xml(self.valueOf_)) 4134 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 4135 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 4136 else: 4137 lwrite('/>%s' % (eol_, )) 4138 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='DoubleObjectPropertyType'): 4139 super(DoubleObjectPropertyType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='DoubleObjectPropertyType') 4140 4141 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='DoubleObjectPropertyType', fromsubclass_=False, pretty_print=True): 4142 super(DoubleObjectPropertyType, self).exportChildren(lwrite, level, 'cyboxCommon:', name_, True, pretty_print=pretty_print) 4143 pass 4144 def build(self, node): 4145 self.__sourcenode__ = node 4146 already_processed = set() 4147 self.buildAttributes(node, node.attrib, already_processed) 4148 self.valueOf_ = get_all_text_(node) 4149 for child in node: 4150 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 4151 self.buildChildren(child, node, nodeName_) 4152 def buildAttributes(self, node, attrs, already_processed): 4153 value = find_attr_value_('datatype', node) 4154 if value is not None: 4155 4156 self.datatype = value 4157 super(DoubleObjectPropertyType, self).buildAttributes(node, attrs, already_processed) 4158 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 4159 pass 4160# end class DoubleObjectPropertyType 4161 4162class UnsignedLongObjectPropertyType(BaseObjectPropertyType): 4163 subclass = None 4164 superclass = BaseObjectPropertyType 4165 def __init__(self, obfuscation_algorithm_ref=None, refanging_transform_type=None, has_changed=None, delimiter='##comma##', pattern_type=None, datatype='unsignedLong', refanging_transform=None, is_case_sensitive=True, bit_mask=None, appears_random=None, observed_encoding=None, defanging_algorithm_ref=None, is_obfuscated=None, regex_syntax=None, apply_condition='ANY', trend=None, idref=None, is_defanged=None, id=None, condition=None, valueOf_=None, extensiontype_=None): 4166 # PROP: This is a BaseObjectPropertyType subclass 4167 super(UnsignedLongObjectPropertyType, self).__init__(obfuscation_algorithm_ref, refanging_transform_type, has_changed, delimiter, pattern_type, datatype, refanging_transform, is_case_sensitive, bit_mask, appears_random, observed_encoding, defanging_algorithm_ref, is_obfuscated, regex_syntax, apply_condition, trend, idref, is_defanged, id, condition, valueOf_, extensiontype_) 4168 def factory(*args_, **kwargs_): 4169 if UnsignedLongObjectPropertyType.subclass: 4170 return UnsignedLongObjectPropertyType.subclass(*args_, **kwargs_) 4171 else: 4172 return UnsignedLongObjectPropertyType(*args_, **kwargs_) 4173 factory = staticmethod(factory) 4174 def hasContent_(self): 4175 if ( 4176 self.valueOf_ or 4177 super(UnsignedLongObjectPropertyType, self).hasContent_() 4178 ): 4179 return True 4180 else: 4181 return False 4182 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='UnsignedLongObjectPropertyType', namespacedef_='', pretty_print=True): 4183 if pretty_print: 4184 eol_ = '\n' 4185 else: 4186 eol_ = '' 4187 showIndent(lwrite, level, pretty_print) 4188 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 4189 already_processed = set() 4190 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='UnsignedLongObjectPropertyType') 4191 if self.hasContent_(): 4192 lwrite('>') 4193 lwrite(quote_xml(self.valueOf_)) 4194 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 4195 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 4196 else: 4197 lwrite('/>%s' % (eol_, )) 4198 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='UnsignedLongObjectPropertyType'): 4199 super(UnsignedLongObjectPropertyType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='UnsignedLongObjectPropertyType') 4200 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='UnsignedLongObjectPropertyType', fromsubclass_=False, pretty_print=True): 4201 super(UnsignedLongObjectPropertyType, self).exportChildren(lwrite, level, 'cyboxCommon:', name_, True, pretty_print=pretty_print) 4202 pass 4203 def build(self, node): 4204 self.__sourcenode__ = node 4205 already_processed = set() 4206 self.buildAttributes(node, node.attrib, already_processed) 4207 self.valueOf_ = get_all_text_(node) 4208 for child in node: 4209 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 4210 self.buildChildren(child, node, nodeName_) 4211 def buildAttributes(self, node, attrs, already_processed): 4212 value = find_attr_value_('datatype', node) 4213 if value is not None: 4214 4215 self.datatype = value 4216 super(UnsignedLongObjectPropertyType, self).buildAttributes(node, attrs, already_processed) 4217 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 4218 pass 4219# end class UnsignedLongObjectPropertyType 4220 4221class UnsignedIntegerObjectPropertyType(BaseObjectPropertyType): 4222 subclass = None 4223 superclass = BaseObjectPropertyType 4224 def __init__(self, obfuscation_algorithm_ref=None, refanging_transform_type=None, has_changed=None, delimiter='##comma##', pattern_type=None, datatype='unsignedInt', refanging_transform=None, is_case_sensitive=True, bit_mask=None, appears_random=None, observed_encoding=None, defanging_algorithm_ref=None, is_obfuscated=None, regex_syntax=None, apply_condition='ANY', trend=None, idref=None, is_defanged=None, id=None, condition=None, valueOf_=None, extensiontype_=None): 4225 # PROP: This is a BaseObjectPropertyType subclass 4226 super(UnsignedIntegerObjectPropertyType, self).__init__(obfuscation_algorithm_ref, refanging_transform_type, has_changed, delimiter, pattern_type, datatype, refanging_transform, is_case_sensitive, bit_mask, appears_random, observed_encoding, defanging_algorithm_ref, is_obfuscated, regex_syntax, apply_condition, trend, idref, is_defanged, id, condition, valueOf_, extensiontype_) 4227 def factory(*args_, **kwargs_): 4228 if UnsignedIntegerObjectPropertyType.subclass: 4229 return UnsignedIntegerObjectPropertyType.subclass(*args_, **kwargs_) 4230 else: 4231 return UnsignedIntegerObjectPropertyType(*args_, **kwargs_) 4232 factory = staticmethod(factory) 4233 def hasContent_(self): 4234 if ( 4235 self.valueOf_ or 4236 super(UnsignedIntegerObjectPropertyType, self).hasContent_() 4237 ): 4238 return True 4239 else: 4240 return False 4241 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='UnsignedIntegerObjectPropertyType', namespacedef_='', pretty_print=True): 4242 if pretty_print: 4243 eol_ = '\n' 4244 else: 4245 eol_ = '' 4246 showIndent(lwrite, level, pretty_print) 4247 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 4248 already_processed = set() 4249 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='UnsignedIntegerObjectPropertyType') 4250 if self.hasContent_(): 4251 lwrite('>') 4252 lwrite(quote_xml(self.valueOf_)) 4253 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 4254 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 4255 else: 4256 lwrite('/>%s' % (eol_, )) 4257 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='UnsignedIntegerObjectPropertyType'): 4258 super(UnsignedIntegerObjectPropertyType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='UnsignedIntegerObjectPropertyType') 4259 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='UnsignedIntegerObjectPropertyType', fromsubclass_=False, pretty_print=True): 4260 super(UnsignedIntegerObjectPropertyType, self).exportChildren(lwrite, level, 'cyboxCommon:', name_, True, pretty_print=pretty_print) 4261 pass 4262 def build(self, node): 4263 self.__sourcenode__ = node 4264 already_processed = set() 4265 self.buildAttributes(node, node.attrib, already_processed) 4266 self.valueOf_ = get_all_text_(node) 4267 for child in node: 4268 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 4269 self.buildChildren(child, node, nodeName_) 4270 def buildAttributes(self, node, attrs, already_processed): 4271 value = find_attr_value_('datatype', node) 4272 if value is not None: 4273 4274 self.datatype = value 4275 super(UnsignedIntegerObjectPropertyType, self).buildAttributes(node, attrs, already_processed) 4276 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 4277 pass 4278# end class UnsignedIntegerObjectPropertyType 4279 4280class PositiveIntegerObjectPropertyType(BaseObjectPropertyType): 4281 subclass = None 4282 superclass = BaseObjectPropertyType 4283 def __init__(self, obfuscation_algorithm_ref=None, refanging_transform_type=None, has_changed=None, delimiter='##comma##', pattern_type=None, datatype='positiveInteger', refanging_transform=None, is_case_sensitive=True, bit_mask=None, appears_random=None, observed_encoding=None, defanging_algorithm_ref=None, is_obfuscated=None, regex_syntax=None, apply_condition='ANY', trend=None, idref=None, is_defanged=None, id=None, condition=None, valueOf_=None, extensiontype_=None): 4284 # PROP: This is a BaseObjectPropertyType subclass 4285 super(PositiveIntegerObjectPropertyType, self).__init__(obfuscation_algorithm_ref, refanging_transform_type, has_changed, delimiter, pattern_type, datatype, refanging_transform, is_case_sensitive, bit_mask, appears_random, observed_encoding, defanging_algorithm_ref, is_obfuscated, regex_syntax, apply_condition, trend, idref, is_defanged, id, condition, valueOf_, extensiontype_) 4286 def factory(*args_, **kwargs_): 4287 if PositiveIntegerObjectPropertyType.subclass: 4288 return PositiveIntegerObjectPropertyType.subclass(*args_, **kwargs_) 4289 else: 4290 return PositiveIntegerObjectPropertyType(*args_, **kwargs_) 4291 factory = staticmethod(factory) 4292 def hasContent_(self): 4293 if ( 4294 self.valueOf_ or 4295 super(PositiveIntegerObjectPropertyType, self).hasContent_() 4296 ): 4297 return True 4298 else: 4299 return False 4300 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='PositiveIntegerObjectPropertyType', namespacedef_='', pretty_print=True): 4301 if pretty_print: 4302 eol_ = '\n' 4303 else: 4304 eol_ = '' 4305 showIndent(lwrite, level, pretty_print) 4306 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 4307 already_processed = set() 4308 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='PositiveIntegerObjectPropertyType') 4309 if self.hasContent_(): 4310 lwrite('>') 4311 lwrite(quote_xml(self.valueOf_)) 4312 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 4313 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 4314 else: 4315 lwrite('/>%s' % (eol_, )) 4316 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='PositiveIntegerObjectPropertyType'): 4317 super(PositiveIntegerObjectPropertyType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='PositiveIntegerObjectPropertyType') 4318 4319 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='PositiveIntegerObjectPropertyType', fromsubclass_=False, pretty_print=True): 4320 super(PositiveIntegerObjectPropertyType, self).exportChildren(lwrite, level, 'cyboxCommon:', name_, True, pretty_print=pretty_print) 4321 pass 4322 def build(self, node): 4323 self.__sourcenode__ = node 4324 already_processed = set() 4325 self.buildAttributes(node, node.attrib, already_processed) 4326 self.valueOf_ = get_all_text_(node) 4327 for child in node: 4328 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 4329 self.buildChildren(child, node, nodeName_) 4330 def buildAttributes(self, node, attrs, already_processed): 4331 value = find_attr_value_('datatype', node) 4332 if value is not None: 4333 4334 self.datatype = value 4335 super(PositiveIntegerObjectPropertyType, self).buildAttributes(node, attrs, already_processed) 4336 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 4337 pass 4338# end class PositiveIntegerObjectPropertyType 4339 4340class HexBinaryObjectPropertyType(BaseObjectPropertyType): 4341 subclass = None 4342 superclass = BaseObjectPropertyType 4343 def __init__(self, obfuscation_algorithm_ref=None, refanging_transform_type=None, has_changed=None, delimiter='##comma##', pattern_type=None, datatype='hexBinary', refanging_transform=None, is_case_sensitive=True, bit_mask=None, appears_random=None, observed_encoding=None, defanging_algorithm_ref=None, is_obfuscated=None, regex_syntax=None, apply_condition='ANY', trend=None, idref=None, is_defanged=None, id=None, condition=None, valueOf_=None, extensiontype_=None): 4344 # PROP: This is a BaseObjectPropertyType subclass 4345 super(HexBinaryObjectPropertyType, self).__init__(obfuscation_algorithm_ref, refanging_transform_type, has_changed, delimiter, pattern_type, datatype, refanging_transform, is_case_sensitive, bit_mask, appears_random, observed_encoding, defanging_algorithm_ref, is_obfuscated, regex_syntax, apply_condition, trend, idref, is_defanged, id, condition, valueOf_, extensiontype_) 4346 def factory(*args_, **kwargs_): 4347 if HexBinaryObjectPropertyType.subclass: 4348 return HexBinaryObjectPropertyType.subclass(*args_, **kwargs_) 4349 else: 4350 return HexBinaryObjectPropertyType(*args_, **kwargs_) 4351 factory = staticmethod(factory) 4352 def hasContent_(self): 4353 if ( 4354 self.valueOf_ or 4355 super(HexBinaryObjectPropertyType, self).hasContent_() 4356 ): 4357 return True 4358 else: 4359 return False 4360 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='HexBinaryObjectPropertyType', namespacedef_='', pretty_print=True): 4361 if pretty_print: 4362 eol_ = '\n' 4363 else: 4364 eol_ = '' 4365 showIndent(lwrite, level, pretty_print) 4366 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 4367 already_processed = set() 4368 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='HexBinaryObjectPropertyType') 4369 if self.hasContent_(): 4370 lwrite('>') 4371 lwrite(quote_xml(self.valueOf_)) 4372 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 4373 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 4374 else: 4375 lwrite('/>%s' % (eol_, )) 4376 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='HexBinaryObjectPropertyType'): 4377 super(HexBinaryObjectPropertyType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='HexBinaryObjectPropertyType') 4378 4379 if self.extensiontype_ is not None: 4380 4381 lwrite(' xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"') 4382 lwrite(' xsi:type="%s"' % self.extensiontype_) 4383 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='HexBinaryObjectPropertyType', fromsubclass_=False, pretty_print=True): 4384 super(HexBinaryObjectPropertyType, self).exportChildren(lwrite, level, 'cyboxCommon:', name_, True, pretty_print=pretty_print) 4385 pass 4386 def build(self, node): 4387 self.__sourcenode__ = node 4388 already_processed = set() 4389 self.buildAttributes(node, node.attrib, already_processed) 4390 self.valueOf_ = get_all_text_(node) 4391 for child in node: 4392 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 4393 self.buildChildren(child, node, nodeName_) 4394 def buildAttributes(self, node, attrs, already_processed): 4395 value = find_attr_value_('datatype', node) 4396 if value is not None: 4397 4398 self.datatype = value 4399 value = find_attr_value_('xsi:type', node) 4400 if value is not None: 4401 4402 self.extensiontype_ = value 4403 super(HexBinaryObjectPropertyType, self).buildAttributes(node, attrs, already_processed) 4404 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 4405 pass 4406# end class HexBinaryObjectPropertyType 4407 4408class LongObjectPropertyType(BaseObjectPropertyType): 4409 subclass = None 4410 superclass = BaseObjectPropertyType 4411 def __init__(self, obfuscation_algorithm_ref=None, refanging_transform_type=None, has_changed=None, delimiter='##comma##', pattern_type=None, datatype='long', refanging_transform=None, is_case_sensitive=True, bit_mask=None, appears_random=None, observed_encoding=None, defanging_algorithm_ref=None, is_obfuscated=None, regex_syntax=None, apply_condition='ANY', trend=None, idref=None, is_defanged=None, id=None, condition=None, valueOf_=None, extensiontype_=None): 4412 # PROP: This is a BaseObjectPropertyType subclass 4413 super(LongObjectPropertyType, self).__init__(obfuscation_algorithm_ref, refanging_transform_type, has_changed, delimiter, pattern_type, datatype, refanging_transform, is_case_sensitive, bit_mask, appears_random, observed_encoding, defanging_algorithm_ref, is_obfuscated, regex_syntax, apply_condition, trend, idref, is_defanged, id, condition, valueOf_, extensiontype_) 4414 def factory(*args_, **kwargs_): 4415 if LongObjectPropertyType.subclass: 4416 return LongObjectPropertyType.subclass(*args_, **kwargs_) 4417 else: 4418 return LongObjectPropertyType(*args_, **kwargs_) 4419 factory = staticmethod(factory) 4420 def hasContent_(self): 4421 if ( 4422 self.valueOf_ or 4423 super(LongObjectPropertyType, self).hasContent_() 4424 ): 4425 return True 4426 else: 4427 return False 4428 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='LongObjectPropertyType', namespacedef_='', pretty_print=True): 4429 if pretty_print: 4430 eol_ = '\n' 4431 else: 4432 eol_ = '' 4433 showIndent(lwrite, level, pretty_print) 4434 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 4435 already_processed = set() 4436 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='LongObjectPropertyType') 4437 if self.hasContent_(): 4438 lwrite('>') 4439 lwrite(quote_xml(self.valueOf_)) 4440 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 4441 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 4442 else: 4443 lwrite('/>%s' % (eol_, )) 4444 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='LongObjectPropertyType'): 4445 super(LongObjectPropertyType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='LongObjectPropertyType') 4446 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='LongObjectPropertyType', fromsubclass_=False, pretty_print=True): 4447 super(LongObjectPropertyType, self).exportChildren(lwrite, level, 'cyboxCommon:', name_, True, pretty_print=pretty_print) 4448 pass 4449 def build(self, node): 4450 self.__sourcenode__ = node 4451 already_processed = set() 4452 self.buildAttributes(node, node.attrib, already_processed) 4453 self.valueOf_ = get_all_text_(node) 4454 for child in node: 4455 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 4456 self.buildChildren(child, node, nodeName_) 4457 def buildAttributes(self, node, attrs, already_processed): 4458 value = find_attr_value_('datatype', node) 4459 if value is not None: 4460 4461 self.datatype = value 4462 super(LongObjectPropertyType, self).buildAttributes(node, attrs, already_processed) 4463 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 4464 pass 4465# end class LongObjectPropertyType 4466 4467class NonNegativeIntegerObjectPropertyType(BaseObjectPropertyType): 4468 subclass = None 4469 superclass = BaseObjectPropertyType 4470 def __init__(self, obfuscation_algorithm_ref=None, refanging_transform_type=None, has_changed=None, delimiter='##comma##', pattern_type=None, datatype='nonNegativeInteger', refanging_transform=None, is_case_sensitive=True, bit_mask=None, appears_random=None, observed_encoding=None, defanging_algorithm_ref=None, is_obfuscated=None, regex_syntax=None, apply_condition='ANY', trend=None, idref=None, is_defanged=None, id=None, condition=None, valueOf_=None, extensiontype_=None): 4471 # PROP: This is a BaseObjectPropertyType subclass 4472 super(NonNegativeIntegerObjectPropertyType, self).__init__(obfuscation_algorithm_ref, refanging_transform_type, has_changed, delimiter, pattern_type, datatype, refanging_transform, is_case_sensitive, bit_mask, appears_random, observed_encoding, defanging_algorithm_ref, is_obfuscated, regex_syntax, apply_condition, trend, idref, is_defanged, id, condition, valueOf_, extensiontype_) 4473 def factory(*args_, **kwargs_): 4474 if NonNegativeIntegerObjectPropertyType.subclass: 4475 return NonNegativeIntegerObjectPropertyType.subclass(*args_, **kwargs_) 4476 else: 4477 return NonNegativeIntegerObjectPropertyType(*args_, **kwargs_) 4478 factory = staticmethod(factory) 4479 def hasContent_(self): 4480 if ( 4481 self.valueOf_ or 4482 super(NonNegativeIntegerObjectPropertyType, self).hasContent_() 4483 ): 4484 return True 4485 else: 4486 return False 4487 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='NonNegativeIntegerObjectPropertyType', namespacedef_='', pretty_print=True): 4488 if pretty_print: 4489 eol_ = '\n' 4490 else: 4491 eol_ = '' 4492 showIndent(lwrite, level, pretty_print) 4493 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 4494 already_processed = set() 4495 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='NonNegativeIntegerObjectPropertyType') 4496 if self.hasContent_(): 4497 lwrite('>') 4498 lwrite(quote_xml(self.valueOf_)) 4499 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 4500 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 4501 else: 4502 lwrite('/>%s' % (eol_, )) 4503 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='NonNegativeIntegerObjectPropertyType'): 4504 super(NonNegativeIntegerObjectPropertyType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='NonNegativeIntegerObjectPropertyType') 4505 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='NonNegativeIntegerObjectPropertyType', fromsubclass_=False, pretty_print=True): 4506 super(NonNegativeIntegerObjectPropertyType, self).exportChildren(lwrite, level, 'cyboxCommon:', name_, True, pretty_print=pretty_print) 4507 pass 4508 def build(self, node): 4509 self.__sourcenode__ = node 4510 already_processed = set() 4511 self.buildAttributes(node, node.attrib, already_processed) 4512 self.valueOf_ = get_all_text_(node) 4513 for child in node: 4514 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 4515 self.buildChildren(child, node, nodeName_) 4516 def buildAttributes(self, node, attrs, already_processed): 4517 value = find_attr_value_('datatype', node) 4518 if value is not None: 4519 4520 self.datatype = value 4521 super(NonNegativeIntegerObjectPropertyType, self).buildAttributes(node, attrs, already_processed) 4522 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 4523 pass 4524# end class NonNegativeIntegerObjectPropertyType 4525 4526class AnyURIObjectPropertyType(BaseObjectPropertyType): 4527 subclass = None 4528 superclass = BaseObjectPropertyType 4529 def __init__(self, obfuscation_algorithm_ref=None, refanging_transform_type=None, has_changed=None, delimiter='##comma##', pattern_type=None, datatype='anyURI', refanging_transform=None, is_case_sensitive=True, bit_mask=None, appears_random=None, observed_encoding=None, defanging_algorithm_ref=None, is_obfuscated=None, regex_syntax=None, apply_condition='ANY', trend=None, idref=None, is_defanged=None, id=None, condition=None, valueOf_=None, extensiontype_=None): 4530 # PROP: This is a BaseObjectPropertyType subclass 4531 super(AnyURIObjectPropertyType, self).__init__(obfuscation_algorithm_ref, refanging_transform_type, has_changed, delimiter, pattern_type, datatype, refanging_transform, is_case_sensitive, bit_mask, appears_random, observed_encoding, defanging_algorithm_ref, is_obfuscated, regex_syntax, apply_condition, trend, idref, is_defanged, id, condition, valueOf_, extensiontype_) 4532 def factory(*args_, **kwargs_): 4533 if AnyURIObjectPropertyType.subclass: 4534 return AnyURIObjectPropertyType.subclass(*args_, **kwargs_) 4535 else: 4536 return AnyURIObjectPropertyType(*args_, **kwargs_) 4537 factory = staticmethod(factory) 4538 def hasContent_(self): 4539 if ( 4540 self.valueOf_ or 4541 super(AnyURIObjectPropertyType, self).hasContent_() 4542 ): 4543 return True 4544 else: 4545 return False 4546 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='AnyURIObjectPropertyType', namespacedef_='', pretty_print=True): 4547 if pretty_print: 4548 eol_ = '\n' 4549 else: 4550 eol_ = '' 4551 showIndent(lwrite, level, pretty_print) 4552 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 4553 already_processed = set() 4554 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='AnyURIObjectPropertyType') 4555 if self.hasContent_(): 4556 lwrite('>') 4557 lwrite(quote_xml(self.valueOf_)) 4558 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 4559 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 4560 else: 4561 lwrite('/>%s' % (eol_, )) 4562 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='AnyURIObjectPropertyType'): 4563 super(AnyURIObjectPropertyType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='AnyURIObjectPropertyType') 4564 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='AnyURIObjectPropertyType', fromsubclass_=False, pretty_print=True): 4565 super(AnyURIObjectPropertyType, self).exportChildren(lwrite, level, 'cyboxCommon:', name_, True, pretty_print=pretty_print) 4566 pass 4567 def build(self, node): 4568 self.__sourcenode__ = node 4569 already_processed = set() 4570 self.buildAttributes(node, node.attrib, already_processed) 4571 self.valueOf_ = get_all_text_(node) 4572 for child in node: 4573 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 4574 self.buildChildren(child, node, nodeName_) 4575 def buildAttributes(self, node, attrs, already_processed): 4576 value = find_attr_value_('datatype', node) 4577 if value is not None: 4578 4579 self.datatype = value 4580 super(AnyURIObjectPropertyType, self).buildAttributes(node, attrs, already_processed) 4581 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 4582 pass 4583# end class AnyURIObjectPropertyType 4584 4585class DurationObjectPropertyType(BaseObjectPropertyType): 4586 subclass = None 4587 superclass = BaseObjectPropertyType 4588 def __init__(self, obfuscation_algorithm_ref=None, refanging_transform_type=None, has_changed=None, delimiter='##comma##', pattern_type=None, datatype='duration', refanging_transform=None, is_case_sensitive=True, bit_mask=None, appears_random=None, observed_encoding=None, defanging_algorithm_ref=None, is_obfuscated=None, regex_syntax=None, apply_condition='ANY', trend=None, idref=None, is_defanged=None, id=None, condition=None, valueOf_=None, extensiontype_=None): 4589 # PROP: This is a BaseObjectPropertyType subclass 4590 super(DurationObjectPropertyType, self).__init__(obfuscation_algorithm_ref, refanging_transform_type, has_changed, delimiter, pattern_type, datatype, refanging_transform, is_case_sensitive, bit_mask, appears_random, observed_encoding, defanging_algorithm_ref, is_obfuscated, regex_syntax, apply_condition, trend, idref, is_defanged, id, condition, valueOf_, extensiontype_) 4591 def factory(*args_, **kwargs_): 4592 if DurationObjectPropertyType.subclass: 4593 return DurationObjectPropertyType.subclass(*args_, **kwargs_) 4594 else: 4595 return DurationObjectPropertyType(*args_, **kwargs_) 4596 factory = staticmethod(factory) 4597 def hasContent_(self): 4598 if ( 4599 self.valueOf_ or 4600 super(DurationObjectPropertyType, self).hasContent_() 4601 ): 4602 return True 4603 else: 4604 return False 4605 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='DurationObjectPropertyType', namespacedef_='', pretty_print=True): 4606 if pretty_print: 4607 eol_ = '\n' 4608 else: 4609 eol_ = '' 4610 showIndent(lwrite, level, pretty_print) 4611 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 4612 already_processed = set() 4613 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='DurationObjectPropertyType') 4614 if self.hasContent_(): 4615 lwrite('>') 4616 lwrite(quote_xml(self.valueOf_)) 4617 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 4618 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 4619 else: 4620 lwrite('/>%s' % (eol_, )) 4621 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='DurationObjectPropertyType'): 4622 super(DurationObjectPropertyType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='DurationObjectPropertyType') 4623 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='DurationObjectPropertyType', fromsubclass_=False, pretty_print=True): 4624 super(DurationObjectPropertyType, self).exportChildren(lwrite, level, 'cyboxCommon:', name_, True, pretty_print=pretty_print) 4625 pass 4626 def build(self, node): 4627 self.__sourcenode__ = node 4628 already_processed = set() 4629 self.buildAttributes(node, node.attrib, already_processed) 4630 self.valueOf_ = get_all_text_(node) 4631 for child in node: 4632 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 4633 self.buildChildren(child, node, nodeName_) 4634 def buildAttributes(self, node, attrs, already_processed): 4635 value = find_attr_value_('datatype', node) 4636 if value is not None: 4637 4638 self.datatype = value 4639 super(DurationObjectPropertyType, self).buildAttributes(node, attrs, already_processed) 4640 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 4641 pass 4642# end class DurationObjectPropertyType 4643 4644class TimeObjectPropertyRestrictionType(BaseObjectPropertyType): 4645 """This type is an intermediate type to allow for the addition of the 4646 precision attribute to TimeObjectPropertyType. It should not be 4647 used directly.This attribute is optional and specifies the type 4648 of the value of the specified property. If a type different than 4649 the default is used, it MUST be specified here.""" 4650 subclass = None 4651 superclass = BaseObjectPropertyType 4652 def __init__(self, obfuscation_algorithm_ref=None, refanging_transform_type=None, has_changed=None, delimiter='##comma##', pattern_type=None, datatype='time', refanging_transform=None, is_case_sensitive=True, bit_mask=None, appears_random=None, observed_encoding=None, defanging_algorithm_ref=None, is_obfuscated=None, regex_syntax=None, apply_condition='ANY', trend=None, idref=None, is_defanged=None, id=None, condition=None, valueOf_=None, extensiontype_=None): 4653 # PROP: This is a BaseObjectPropertyType subclass 4654 super(TimeObjectPropertyRestrictionType, self).__init__(obfuscation_algorithm_ref, refanging_transform_type, has_changed, delimiter, pattern_type, datatype, refanging_transform, is_case_sensitive, bit_mask, appears_random, observed_encoding, defanging_algorithm_ref, is_obfuscated, regex_syntax, apply_condition, trend, idref, is_defanged, id, condition, valueOf_, extensiontype_) 4655 def factory(*args_, **kwargs_): 4656 if TimeObjectPropertyRestrictionType.subclass: 4657 return TimeObjectPropertyRestrictionType.subclass(*args_, **kwargs_) 4658 else: 4659 return TimeObjectPropertyRestrictionType(*args_, **kwargs_) 4660 factory = staticmethod(factory) 4661 def hasContent_(self): 4662 if ( 4663 self.valueOf_ or 4664 super(TimeObjectPropertyRestrictionType, self).hasContent_() 4665 ): 4666 return True 4667 else: 4668 return False 4669 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='TimeObjectPropertyRestrictionType', namespacedef_='', pretty_print=True): 4670 if pretty_print: 4671 eol_ = '\n' 4672 else: 4673 eol_ = '' 4674 showIndent(lwrite, level, pretty_print) 4675 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 4676 already_processed = set() 4677 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='TimeObjectPropertyRestrictionType') 4678 if self.hasContent_(): 4679 lwrite('>') 4680 lwrite(quote_xml(self.valueOf_)) 4681 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 4682 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 4683 else: 4684 lwrite('/>%s' % (eol_, )) 4685 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='TimeObjectPropertyRestrictionType'): 4686 super(TimeObjectPropertyRestrictionType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='TimeObjectPropertyRestrictionType') 4687 if self.extensiontype_ is not None: 4688 4689 lwrite(' xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"') 4690 lwrite(' xsi:type="%s"' % self.extensiontype_) 4691 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='TimeObjectPropertyRestrictionType', fromsubclass_=False, pretty_print=True): 4692 super(TimeObjectPropertyRestrictionType, self).exportChildren(lwrite, level, 'cyboxCommon:', name_, True, pretty_print=pretty_print) 4693 pass 4694 def build(self, node): 4695 self.__sourcenode__ = node 4696 already_processed = set() 4697 self.buildAttributes(node, node.attrib, already_processed) 4698 self.valueOf_ = get_all_text_(node) 4699 for child in node: 4700 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 4701 self.buildChildren(child, node, nodeName_) 4702 def buildAttributes(self, node, attrs, already_processed): 4703 value = find_attr_value_('datatype', node) 4704 if value is not None: 4705 4706 self.datatype = value 4707 value = find_attr_value_('xsi:type', node) 4708 if value is not None: 4709 4710 self.extensiontype_ = value 4711 super(TimeObjectPropertyRestrictionType, self).buildAttributes(node, attrs, already_processed) 4712 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 4713 pass 4714# end class TimeObjectPropertyRestrictionType 4715 4716class TimeObjectPropertyType(TimeObjectPropertyRestrictionType): 4717 """The TimeObjectPropertyType is a type (extended from 4718 BaseObjectPropertyType) representing the specification of a 4719 single Object property whose core value is of type time. This 4720 type will be assigned to any property of a CybOX object that 4721 should contain content of type Time and enables the use of 4722 relevant metadata for the property. In order to avoid ambiguity, 4723 it is strongly suggested that any time representation in this 4724 field include a specification of the timezone if it is known. As 4725 with the rest of the field, this should be formatted per the 4726 xs:time specification.Properties that use this type can express 4727 multiple values by providing them using a delimiter-separated 4728 list. The default delimiter is '##comma##' (no quotes) but can 4729 be overridden through use of the delimiter field. Note that 4730 whitespace is preserved and so, when specifying a list of 4731 values, do not include a space following the delimiter in a list 4732 unless the first character of the next list item should, in 4733 fact, be a space.For fields of this type using CybOX patterning, 4734 it is strongly suggested that the condition (pattern type) is 4735 limited to one of Equals, DoesNotEqual, GreaterThan, LessThan, 4736 GreaterThanOrEqual, LessThanOrEqual, ExclusiveBetween, or 4737 InclusiveBetween. The use of other conditions may lead to 4738 ambiguity or unexpected results. When evaluating data against a 4739 pattern, the evaluator should take into account the precision of 4740 the field (as given by the precision attribute) and any timezone 4741 information that is available to perform a data-aware 4742 comparison. The usage of simple string comparisons is 4743 discouraged due to ambiguities in how precision and timezone 4744 information is processed.The precision of the associated time. 4745 If omitted, the default is "second", meaning the full field 4746 value (including fractional seconds). Digits in the time that 4747 are required by the xs:time datatype but are beyond the 4748 specified precision should be zeroed out.When used in 4749 conjunction with CybOX patterning, the pattern should only be 4750 evaluated against the target up to the given precision.""" 4751 subclass = None 4752 superclass = TimeObjectPropertyRestrictionType 4753 def __init__(self, obfuscation_algorithm_ref=None, refanging_transform_type=None, has_changed=None, delimiter='##comma##', pattern_type=None, datatype='time', refanging_transform=None, is_case_sensitive=True, bit_mask=None, appears_random=None, observed_encoding=None, defanging_algorithm_ref=None, is_obfuscated=None, regex_syntax=None, apply_condition='ANY', trend=None, idref=None, is_defanged=None, id=None, condition=None, valueOf_=None, extensiontype_=None, precision='second'): 4754 # PROP: This is a BaseObjectPropertyType subclass 4755 super(TimeObjectPropertyType, self).__init__(obfuscation_algorithm_ref, refanging_transform_type, has_changed, delimiter, pattern_type, datatype, refanging_transform, is_case_sensitive, bit_mask, appears_random, observed_encoding, defanging_algorithm_ref, is_obfuscated, regex_syntax, apply_condition, trend, idref, is_defanged, id, condition, valueOf_, extensiontype_) 4756 self.precision = _cast(None, precision) 4757 def factory(*args_, **kwargs_): 4758 if TimeObjectPropertyType.subclass: 4759 return TimeObjectPropertyType.subclass(*args_, **kwargs_) 4760 else: 4761 return TimeObjectPropertyType(*args_, **kwargs_) 4762 factory = staticmethod(factory) 4763 def get_precision(self): return self.precision 4764 def set_precision(self, precision): self.precision = precision 4765 def hasContent_(self): 4766 if ( 4767 self.valueOf_ or 4768 super(TimeObjectPropertyType, self).hasContent_() 4769 ): 4770 return True 4771 else: 4772 return False 4773 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='TimeObjectPropertyType', namespacedef_='', pretty_print=True): 4774 if pretty_print: 4775 eol_ = '\n' 4776 else: 4777 eol_ = '' 4778 showIndent(lwrite, level, pretty_print) 4779 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 4780 already_processed = set() 4781 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='TimeObjectPropertyType') 4782 if self.hasContent_(): 4783 lwrite('>') 4784 lwrite(quote_xml(self.valueOf_)) 4785 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 4786 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 4787 else: 4788 lwrite('/>%s' % (eol_, )) 4789 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='TimeObjectPropertyType'): 4790 super(TimeObjectPropertyType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='TimeObjectPropertyType') 4791 if self.precision not in (None, 'second'): 4792 4793 lwrite(' precision=%s' % (quote_attrib(self.precision), )) 4794 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='TimeObjectPropertyType', fromsubclass_=False, pretty_print=True): 4795 super(TimeObjectPropertyType, self).exportChildren(lwrite, level, 'cyboxCommon:', name_, True, pretty_print=pretty_print) 4796 pass 4797 def build(self, node): 4798 self.__sourcenode__ = node 4799 already_processed = set() 4800 self.buildAttributes(node, node.attrib, already_processed) 4801 self.valueOf_ = get_all_text_(node) 4802 for child in node: 4803 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 4804 self.buildChildren(child, node, nodeName_) 4805 def buildAttributes(self, node, attrs, already_processed): 4806 value = find_attr_value_('precision', node) 4807 if value is not None: 4808 4809 self.precision = value 4810 super(TimeObjectPropertyType, self).buildAttributes(node, attrs, already_processed) 4811 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 4812 pass 4813# end class TimeObjectPropertyType 4814 4815class Base64BinaryObjectPropertyType(BaseObjectPropertyType): 4816 subclass = None 4817 superclass = BaseObjectPropertyType 4818 def __init__(self, obfuscation_algorithm_ref=None, refanging_transform_type=None, has_changed=None, delimiter='##comma##', pattern_type=None, datatype='base64Binary', refanging_transform=None, is_case_sensitive=True, bit_mask=None, appears_random=None, observed_encoding=None, defanging_algorithm_ref=None, is_obfuscated=None, regex_syntax=None, apply_condition='ANY', trend=None, idref=None, is_defanged=None, id=None, condition=None, valueOf_=None, extensiontype_=None): 4819 # PROP: This is a BaseObjectPropertyType subclass 4820 super(Base64BinaryObjectPropertyType, self).__init__(obfuscation_algorithm_ref, refanging_transform_type, has_changed, delimiter, pattern_type, datatype, refanging_transform, is_case_sensitive, bit_mask, appears_random, observed_encoding, defanging_algorithm_ref, is_obfuscated, regex_syntax, apply_condition, trend, idref, is_defanged, id, condition, valueOf_, extensiontype_) 4821 def factory(*args_, **kwargs_): 4822 if Base64BinaryObjectPropertyType.subclass: 4823 return Base64BinaryObjectPropertyType.subclass(*args_, **kwargs_) 4824 else: 4825 return Base64BinaryObjectPropertyType(*args_, **kwargs_) 4826 factory = staticmethod(factory) 4827 def hasContent_(self): 4828 if ( 4829 self.valueOf_ or 4830 super(Base64BinaryObjectPropertyType, self).hasContent_() 4831 ): 4832 return True 4833 else: 4834 return False 4835 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='Base64BinaryObjectPropertyType', namespacedef_='', pretty_print=True): 4836 if pretty_print: 4837 eol_ = '\n' 4838 else: 4839 eol_ = '' 4840 showIndent(lwrite, level, pretty_print) 4841 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 4842 already_processed = set() 4843 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='Base64BinaryObjectPropertyType') 4844 if self.hasContent_(): 4845 lwrite('>') 4846 lwrite(quote_xml(self.valueOf_)) 4847 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 4848 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 4849 else: 4850 lwrite('/>%s' % (eol_, )) 4851 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='Base64BinaryObjectPropertyType'): 4852 super(Base64BinaryObjectPropertyType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='Base64BinaryObjectPropertyType') 4853 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='Base64BinaryObjectPropertyType', fromsubclass_=False, pretty_print=True): 4854 super(Base64BinaryObjectPropertyType, self).exportChildren(lwrite, level, 'cyboxCommon:', name_, True, pretty_print=pretty_print) 4855 pass 4856 def build(self, node): 4857 self.__sourcenode__ = node 4858 already_processed = set() 4859 self.buildAttributes(node, node.attrib, already_processed) 4860 self.valueOf_ = get_all_text_(node) 4861 for child in node: 4862 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 4863 self.buildChildren(child, node, nodeName_) 4864 def buildAttributes(self, node, attrs, already_processed): 4865 value = find_attr_value_('datatype', node) 4866 if value is not None: 4867 4868 self.datatype = value 4869 super(Base64BinaryObjectPropertyType, self).buildAttributes(node, attrs, already_processed) 4870 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 4871 pass 4872# end class Base64BinaryObjectPropertyType 4873 4874class Layer4ProtocolType(BaseObjectPropertyType): 4875 """Layer4ProtocolType specifies Layer 4 protocol types, via a union of 4876 the Layer4ProtocolEnum type and the atomic xs:string type. Its 4877 base type is the CybOX Core BaseObjectPropertyType, for 4878 permitting complex (i.e. regular-expression based) 4879 specifications.This attribute is optional and specifies the 4880 expected type for the value of the specified property.""" 4881 subclass = None 4882 superclass = BaseObjectPropertyType 4883 def __init__(self, obfuscation_algorithm_ref=None, refanging_transform_type=None, has_changed=None, delimiter='##comma##', pattern_type=None, datatype='string', refanging_transform=None, is_case_sensitive=True, bit_mask=None, appears_random=None, observed_encoding=None, defanging_algorithm_ref=None, is_obfuscated=None, regex_syntax=None, apply_condition='ANY', trend=None, idref=None, is_defanged=None, id=None, condition=None, valueOf_=None, extensiontype_=None): 4884 # PROP: This is a BaseObjectPropertyType subclass 4885 super(Layer4ProtocolType, self).__init__(obfuscation_algorithm_ref, refanging_transform_type, has_changed, delimiter, pattern_type, datatype, refanging_transform, is_case_sensitive, bit_mask, appears_random, observed_encoding, defanging_algorithm_ref, is_obfuscated, regex_syntax, apply_condition, trend, idref, is_defanged, id, condition, valueOf_, extensiontype_) 4886 def factory(*args_, **kwargs_): 4887 if Layer4ProtocolType.subclass: 4888 return Layer4ProtocolType.subclass(*args_, **kwargs_) 4889 else: 4890 return Layer4ProtocolType(*args_, **kwargs_) 4891 factory = staticmethod(factory) 4892 def hasContent_(self): 4893 if ( 4894 self.valueOf_ or 4895 super(Layer4ProtocolType, self).hasContent_() 4896 ): 4897 return True 4898 else: 4899 return False 4900 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='Layer4ProtocolType', namespacedef_='', pretty_print=True): 4901 if pretty_print: 4902 eol_ = '\n' 4903 else: 4904 eol_ = '' 4905 showIndent(lwrite, level, pretty_print) 4906 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 4907 already_processed = set() 4908 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='Layer4ProtocolType') 4909 if self.hasContent_(): 4910 lwrite('>') 4911 lwrite(quote_xml(self.valueOf_)) 4912 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 4913 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 4914 else: 4915 lwrite('/>%s' % (eol_, )) 4916 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='Layer4ProtocolType'): 4917 super(Layer4ProtocolType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='Layer4ProtocolType') 4918 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='Layer4ProtocolType', fromsubclass_=False, pretty_print=True): 4919 super(Layer4ProtocolType, self).exportChildren(lwrite, level, 'cyboxCommon:', name_, True, pretty_print=pretty_print) 4920 pass 4921 def build(self, node): 4922 self.__sourcenode__ = node 4923 already_processed = set() 4924 self.buildAttributes(node, node.attrib, already_processed) 4925 self.valueOf_ = get_all_text_(node) 4926 for child in node: 4927 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 4928 self.buildChildren(child, node, nodeName_) 4929 def buildAttributes(self, node, attrs, already_processed): 4930 value = find_attr_value_('datatype', node) 4931 if value is not None: 4932 4933 self.datatype = value 4934 super(Layer4ProtocolType, self).buildAttributes(node, attrs, already_processed) 4935 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 4936 pass 4937# end class Layer4ProtocolType 4938 4939class EndiannessType(BaseObjectPropertyType): 4940 """The EndiannessType specifies names for byte ordering methods.This 4941 attribute is optional and specifies the expected type for the 4942 value of the specified property.""" 4943 subclass = None 4944 superclass = BaseObjectPropertyType 4945 def __init__(self, obfuscation_algorithm_ref=None, refanging_transform_type=None, has_changed=None, delimiter='##comma##', pattern_type=None, datatype='string', refanging_transform=None, is_case_sensitive=True, bit_mask=None, appears_random=None, observed_encoding=None, defanging_algorithm_ref=None, is_obfuscated=None, regex_syntax=None, apply_condition='ANY', trend=None, idref=None, is_defanged=None, id=None, condition=None, valueOf_=None, extensiontype_=None): 4946 # PROP: This is a BaseObjectPropertyType subclass 4947 super(EndiannessType, self).__init__(obfuscation_algorithm_ref, refanging_transform_type, has_changed, delimiter, pattern_type, datatype, refanging_transform, is_case_sensitive, bit_mask, appears_random, observed_encoding, defanging_algorithm_ref, is_obfuscated, regex_syntax, apply_condition, trend, idref, is_defanged, id, condition, valueOf_, extensiontype_) 4948 def factory(*args_, **kwargs_): 4949 if EndiannessType.subclass: 4950 return EndiannessType.subclass(*args_, **kwargs_) 4951 else: 4952 return EndiannessType(*args_, **kwargs_) 4953 factory = staticmethod(factory) 4954 def hasContent_(self): 4955 if ( 4956 self.valueOf_ or 4957 super(EndiannessType, self).hasContent_() 4958 ): 4959 return True 4960 else: 4961 return False 4962 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='EndiannessType', namespacedef_='', pretty_print=True): 4963 if pretty_print: 4964 eol_ = '\n' 4965 else: 4966 eol_ = '' 4967 showIndent(lwrite, level, pretty_print) 4968 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 4969 already_processed = set() 4970 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='EndiannessType') 4971 if self.hasContent_(): 4972 lwrite('>') 4973 lwrite(quote_xml(self.valueOf_)) 4974 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 4975 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 4976 else: 4977 lwrite('/>%s' % (eol_, )) 4978 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='EndiannessType'): 4979 super(EndiannessType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='EndiannessType') 4980 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='EndiannessType', fromsubclass_=False, pretty_print=True): 4981 super(EndiannessType, self).exportChildren(lwrite, level, 'cyboxCommon:', name_, True, pretty_print=pretty_print) 4982 pass 4983 def build(self, node): 4984 self.__sourcenode__ = node 4985 already_processed = set() 4986 self.buildAttributes(node, node.attrib, already_processed) 4987 self.valueOf_ = get_all_text_(node) 4988 for child in node: 4989 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 4990 self.buildChildren(child, node, nodeName_) 4991 def buildAttributes(self, node, attrs, already_processed): 4992 value = find_attr_value_('datatype', node) 4993 if value is not None: 4994 4995 self.datatype = value 4996 super(EndiannessType, self).buildAttributes(node, attrs, already_processed) 4997 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 4998 pass 4999# end class EndiannessType 5000 5001class CipherType(BaseObjectPropertyType): 5002 """CipherType specifies encryption algorithms, via a union of the 5003 CipherEnum type and the atomic xs:string type. Its base type is 5004 the CybOX Core BaseObjectPropertyType, for permitting complex 5005 (i.e. regular-expression based) specifications.""" 5006 subclass = None 5007 superclass = BaseObjectPropertyType 5008 def __init__(self, obfuscation_algorithm_ref=None, refanging_transform_type=None, has_changed=None, delimiter='##comma##', pattern_type=None, datatype='string', refanging_transform=None, is_case_sensitive=True, bit_mask=None, appears_random=None, observed_encoding=None, defanging_algorithm_ref=None, is_obfuscated=None, regex_syntax=None, apply_condition='ANY', trend=None, idref=None, is_defanged=None, id=None, condition=None, valueOf_=None, extensiontype_=None): 5009 # PROP: This is a BaseObjectPropertyType subclass 5010 super(CipherType, self).__init__(obfuscation_algorithm_ref, refanging_transform_type, has_changed, delimiter, pattern_type, datatype, refanging_transform, is_case_sensitive, bit_mask, appears_random, observed_encoding, defanging_algorithm_ref, is_obfuscated, regex_syntax, apply_condition, trend, idref, is_defanged, id, condition, valueOf_, extensiontype_) 5011 def factory(*args_, **kwargs_): 5012 if CipherType.subclass: 5013 return CipherType.subclass(*args_, **kwargs_) 5014 else: 5015 return CipherType(*args_, **kwargs_) 5016 factory = staticmethod(factory) 5017 def hasContent_(self): 5018 if ( 5019 self.valueOf_ or 5020 super(CipherType, self).hasContent_() 5021 ): 5022 return True 5023 else: 5024 return False 5025 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='CipherType', namespacedef_='', pretty_print=True): 5026 if pretty_print: 5027 eol_ = '\n' 5028 else: 5029 eol_ = '' 5030 showIndent(lwrite, level, pretty_print) 5031 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 5032 already_processed = set() 5033 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='CipherType') 5034 if self.hasContent_(): 5035 lwrite('>') 5036 lwrite(quote_xml(self.valueOf_)) 5037 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 5038 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 5039 else: 5040 lwrite('/>%s' % (eol_, )) 5041 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='CipherType'): 5042 super(CipherType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='CipherType') 5043 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='CipherType', fromsubclass_=False, pretty_print=True): 5044 super(CipherType, self).exportChildren(lwrite, level, 'cyboxCommon:', name_, True, pretty_print=pretty_print) 5045 pass 5046 def build(self, node): 5047 self.__sourcenode__ = node 5048 already_processed = set() 5049 self.buildAttributes(node, node.attrib, already_processed) 5050 self.valueOf_ = get_all_text_(node) 5051 for child in node: 5052 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 5053 self.buildChildren(child, node, nodeName_) 5054 def buildAttributes(self, node, attrs, already_processed): 5055 super(CipherType, self).buildAttributes(node, attrs, already_processed) 5056 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 5057 pass 5058# end class CipherType 5059 5060class RegionalRegistryType(BaseObjectPropertyType): 5061 """The RegionalRegistryType specifies a Regional Internet Registry 5062 (RIR) for a given WHOIS entry. RIRs defined by the 5063 RegionalRegistryTypeEnum may be used, as well as those specified 5064 by a free form text string.""" 5065 subclass = None 5066 superclass = BaseObjectPropertyType 5067 def __init__(self, obfuscation_algorithm_ref=None, refanging_transform_type=None, has_changed=None, delimiter='##comma##', pattern_type=None, datatype='string', refanging_transform=None, is_case_sensitive=True, bit_mask=None, appears_random=None, observed_encoding=None, defanging_algorithm_ref=None, is_obfuscated=None, regex_syntax=None, apply_condition='ANY', trend=None, idref=None, is_defanged=None, id=None, condition=None, valueOf_=None, extensiontype_=None): 5068 # PROP: This is a BaseObjectPropertyType subclass 5069 super(RegionalRegistryType, self).__init__(obfuscation_algorithm_ref, refanging_transform_type, has_changed, delimiter, pattern_type, datatype, refanging_transform, is_case_sensitive, bit_mask, appears_random, observed_encoding, defanging_algorithm_ref, is_obfuscated, regex_syntax, apply_condition, trend, idref, is_defanged, id, condition, valueOf_, extensiontype_) 5070 def factory(*args_, **kwargs_): 5071 if RegionalRegistryType.subclass: 5072 return RegionalRegistryType.subclass(*args_, **kwargs_) 5073 else: 5074 return RegionalRegistryType(*args_, **kwargs_) 5075 factory = staticmethod(factory) 5076 def hasContent_(self): 5077 if ( 5078 self.valueOf_ or 5079 super(RegionalRegistryType, self).hasContent_() 5080 ): 5081 return True 5082 else: 5083 return False 5084 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='RegionalRegistryType', namespacedef_='', pretty_print=True): 5085 if pretty_print: 5086 eol_ = '\n' 5087 else: 5088 eol_ = '' 5089 showIndent(lwrite, level, pretty_print) 5090 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 5091 already_processed = set() 5092 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='RegionalRegistryType') 5093 if self.hasContent_(): 5094 lwrite('>') 5095 lwrite(quote_xml(self.valueOf_)) 5096 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 5097 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 5098 else: 5099 lwrite('/>%s' % (eol_, )) 5100 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='RegionalRegistryType'): 5101 super(RegionalRegistryType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='RegionalRegistryType') 5102 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='RegionalRegistryType', fromsubclass_=False, pretty_print=True): 5103 super(RegionalRegistryType, self).exportChildren(lwrite, level, 'cyboxCommon:', name_, True, pretty_print=pretty_print) 5104 pass 5105 def build(self, node): 5106 self.__sourcenode__ = node 5107 already_processed = set() 5108 self.buildAttributes(node, node.attrib, already_processed) 5109 self.valueOf_ = get_all_text_(node) 5110 for child in node: 5111 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 5112 self.buildChildren(child, node, nodeName_) 5113 def buildAttributes(self, node, attrs, already_processed): 5114 super(RegionalRegistryType, self).buildAttributes(node, attrs, already_processed) 5115 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 5116 pass 5117# end class RegionalRegistryType 5118 5119class ExtractedFeaturesType(GeneratedsSuper): 5120 """The ExtractedFeaturesType is a type representing a description of 5121 features extracted from an object such as a file.""" 5122 subclass = None 5123 superclass = None 5124 def __init__(self, Strings=None, Imports=None, Functions=None, Code_Snippets=None): 5125 self.Strings = Strings 5126 self.Imports = Imports 5127 self.Functions = Functions 5128 self.Code_Snippets = Code_Snippets 5129 def factory(*args_, **kwargs_): 5130 if ExtractedFeaturesType.subclass: 5131 return ExtractedFeaturesType.subclass(*args_, **kwargs_) 5132 else: 5133 return ExtractedFeaturesType(*args_, **kwargs_) 5134 factory = staticmethod(factory) 5135 def get_Strings(self): return self.Strings 5136 def set_Strings(self, Strings): self.Strings = Strings 5137 def get_Imports(self): return self.Imports 5138 def set_Imports(self, Imports): self.Imports = Imports 5139 def get_Functions(self): return self.Functions 5140 def set_Functions(self, Functions): self.Functions = Functions 5141 def get_Code_Snippets(self): return self.Code_Snippets 5142 def set_Code_Snippets(self, Code_Snippets): self.Code_Snippets = Code_Snippets 5143 def hasContent_(self): 5144 if ( 5145 self.Strings is not None or 5146 self.Imports is not None or 5147 self.Functions is not None or 5148 self.Code_Snippets is not None 5149 ): 5150 return True 5151 else: 5152 return False 5153 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='ExtractedFeaturesType', namespacedef_='', pretty_print=True): 5154 if pretty_print: 5155 eol_ = '\n' 5156 else: 5157 eol_ = '' 5158 showIndent(lwrite, level, pretty_print) 5159 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 5160 already_processed = set() 5161 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='ExtractedFeaturesType') 5162 if self.hasContent_(): 5163 lwrite('>%s' % (eol_, )) 5164 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 5165 showIndent(lwrite, level, pretty_print) 5166 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 5167 else: 5168 lwrite('/>%s' % (eol_, )) 5169 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='ExtractedFeaturesType'): 5170 pass 5171 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='ExtractedFeaturesType', fromsubclass_=False, pretty_print=True): 5172 if pretty_print: 5173 eol_ = '\n' 5174 else: 5175 eol_ = '' 5176 if self.Strings is not None: 5177 self.Strings.export(lwrite, level, 'cyboxCommon:', name_='Strings', pretty_print=pretty_print) 5178 if self.Imports is not None: 5179 self.Imports.export(lwrite, level, 'cyboxCommon:', name_='Imports', pretty_print=pretty_print) 5180 if self.Functions is not None: 5181 self.Functions.export(lwrite, level, 'cyboxCommon:', name_='Functions', pretty_print=pretty_print) 5182 if self.Code_Snippets is not None: 5183 self.Code_Snippets.export(lwrite, level, 'cyboxCommon:', name_='Code_Snippets', pretty_print=pretty_print) 5184 def build(self, node): 5185 self.__sourcenode__ = node 5186 already_processed = set() 5187 self.buildAttributes(node, node.attrib, already_processed) 5188 for child in node: 5189 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 5190 self.buildChildren(child, node, nodeName_) 5191 def buildAttributes(self, node, attrs, already_processed): 5192 pass 5193 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 5194 if nodeName_ == 'Strings': 5195 obj_ = ExtractedStringsType.factory() 5196 obj_.build(child_) 5197 self.set_Strings(obj_) 5198 elif nodeName_ == 'Imports': 5199 obj_ = ImportsType.factory() 5200 obj_.build(child_) 5201 self.set_Imports(obj_) 5202 elif nodeName_ == 'Functions': 5203 obj_ = FunctionsType.factory() 5204 obj_.build(child_) 5205 self.set_Functions(obj_) 5206 elif nodeName_ == 'Code_Snippets': 5207 obj_ = CodeSnippetsType.factory() 5208 obj_.build(child_) 5209 self.set_Code_Snippets(obj_) 5210# end class ExtractedFeaturesType 5211 5212class ExtractedStringsType(GeneratedsSuper): 5213 """The ExtractedStringsType type is intended as container for strings 5214 extracted from CybOX objects.""" 5215 5216 subclass = None 5217 superclass = None 5218 def __init__(self, String=None): 5219 if String is None: 5220 self.String = [] 5221 else: 5222 self.String = String 5223 def factory(*args_, **kwargs_): 5224 if ExtractedStringsType.subclass: 5225 return ExtractedStringsType.subclass(*args_, **kwargs_) 5226 else: 5227 return ExtractedStringsType(*args_, **kwargs_) 5228 factory = staticmethod(factory) 5229 def get_String(self): return self.String 5230 def set_String(self, String): self.String = String 5231 def add_String(self, value): self.String.append(value) 5232 def insert_String(self, index, value): self.String[index] = value 5233 def hasContent_(self): 5234 if ( 5235 self.String 5236 ): 5237 return True 5238 else: 5239 return False 5240 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='ExtractedStringsType', namespacedef_='', pretty_print=True): 5241 if pretty_print: 5242 eol_ = '\n' 5243 else: 5244 eol_ = '' 5245 showIndent(lwrite, level, pretty_print) 5246 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 5247 already_processed = set() 5248 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='ExtractedStringsType') 5249 if self.hasContent_(): 5250 lwrite('>%s' % (eol_, )) 5251 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 5252 showIndent(lwrite, level, pretty_print) 5253 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 5254 else: 5255 lwrite('/>%s' % (eol_, )) 5256 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='ExtractedStringsType'): 5257 pass 5258 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='ExtractedStringsType', fromsubclass_=False, pretty_print=True): 5259 if pretty_print: 5260 eol_ = '\n' 5261 else: 5262 eol_ = '' 5263 for String_ in self.String: 5264 String_.export(lwrite, level, 'cyboxCommon:', name_='String', pretty_print=pretty_print) 5265 def build(self, node): 5266 self.__sourcenode__ = node 5267 already_processed = set() 5268 self.buildAttributes(node, node.attrib, already_processed) 5269 for child in node: 5270 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 5271 self.buildChildren(child, node, nodeName_) 5272 def buildAttributes(self, node, attrs, already_processed): 5273 pass 5274 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 5275 if nodeName_ == 'String': 5276 obj_ = ExtractedStringType.factory() 5277 obj_.build(child_) 5278 self.String.append(obj_) 5279# end class ExtractedStringsType 5280 5281class ExtractedStringType(GeneratedsSuper): 5282 """The ExtractedStringType type is intended as container a single 5283 string extracted from a CybOX object.""" 5284 5285 subclass = None 5286 superclass = None 5287 def __init__(self, Encoding=None, String_Value=None, Byte_String_Value=None, Hashes=None, Address=None, Length=None, Language=None, English_Translation=None): 5288 self.Encoding = Encoding 5289 self.String_Value = String_Value 5290 self.Byte_String_Value = Byte_String_Value 5291 self.Hashes = Hashes 5292 self.Address = Address 5293 self.Length = Length 5294 self.Language = Language 5295 self.English_Translation = English_Translation 5296 def factory(*args_, **kwargs_): 5297 if ExtractedStringType.subclass: 5298 return ExtractedStringType.subclass(*args_, **kwargs_) 5299 else: 5300 return ExtractedStringType(*args_, **kwargs_) 5301 factory = staticmethod(factory) 5302 def get_Encoding(self): return self.Encoding 5303 def set_Encoding(self, Encoding): self.Encoding = Encoding 5304 def get_String_Value(self): return self.String_Value 5305 def set_String_Value(self, String_Value): self.String_Value = String_Value 5306 def validate_StringObjectPropertyType(self, value): 5307 # Validate type StringObjectPropertyType, a restriction on None. 5308 pass 5309 def get_Byte_String_Value(self): return self.Byte_String_Value 5310 def set_Byte_String_Value(self, Byte_String_Value): self.Byte_String_Value = Byte_String_Value 5311 def validate_HexBinaryObjectPropertyType(self, value): 5312 # Validate type HexBinaryObjectPropertyType, a restriction on None. 5313 pass 5314 def get_Hashes(self): return self.Hashes 5315 def set_Hashes(self, Hashes): self.Hashes = Hashes 5316 def get_Address(self): return self.Address 5317 def set_Address(self, Address): self.Address = Address 5318 def get_Length(self): return self.Length 5319 def set_Length(self, Length): self.Length = Length 5320 def validate_PositiveIntegerObjectPropertyType(self, value): 5321 # Validate type PositiveIntegerObjectPropertyType, a restriction on None. 5322 pass 5323 def get_Language(self): return self.Language 5324 def set_Language(self, Language): self.Language = Language 5325 def get_English_Translation(self): return self.English_Translation 5326 def set_English_Translation(self, English_Translation): self.English_Translation = English_Translation 5327 def hasContent_(self): 5328 if ( 5329 self.Encoding is not None or 5330 self.String_Value is not None or 5331 self.Byte_String_Value is not None or 5332 self.Hashes is not None or 5333 self.Address is not None or 5334 self.Length is not None or 5335 self.Language is not None or 5336 self.English_Translation is not None 5337 ): 5338 return True 5339 else: 5340 return False 5341 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='ExtractedStringType', namespacedef_='', pretty_print=True): 5342 if pretty_print: 5343 eol_ = '\n' 5344 else: 5345 eol_ = '' 5346 showIndent(lwrite, level, pretty_print) 5347 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 5348 already_processed = set() 5349 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='ExtractedStringType') 5350 if self.hasContent_(): 5351 lwrite('>%s' % (eol_, )) 5352 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 5353 showIndent(lwrite, level, pretty_print) 5354 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 5355 else: 5356 lwrite('/>%s' % (eol_, )) 5357 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='ExtractedStringType'): 5358 pass 5359 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='ExtractedStringType', fromsubclass_=False, pretty_print=True): 5360 if pretty_print: 5361 eol_ = '\n' 5362 else: 5363 eol_ = '' 5364 if self.Encoding is not None: 5365 self.Encoding.export(lwrite, level, 'cyboxCommon:', name_='Encoding', pretty_print=pretty_print) 5366 if self.String_Value is not None: 5367 self.String_Value.export(lwrite, level, 'cyboxCommon:', name_='String_Value', pretty_print=pretty_print) 5368 if self.Byte_String_Value is not None: 5369 self.Byte_String_Value.export(lwrite, level, 'cyboxCommon:', name_='Byte_String_Value', pretty_print=pretty_print) 5370 if self.Hashes is not None: 5371 self.Hashes.export(lwrite, level, 'cyboxCommon:', name_='Hashes', pretty_print=pretty_print) 5372 if self.Address is not None: 5373 self.Address.export(lwrite, level, 'cyboxCommon:', name_='Address', pretty_print=pretty_print) 5374 if self.Length is not None: 5375 self.Length.export(lwrite, level, 'cyboxCommon:', name_='Length', pretty_print=pretty_print) 5376 if self.Language is not None: 5377 self.Language.export(lwrite, level, 'cyboxCommon:', name_='Language', pretty_print=pretty_print) 5378 if self.English_Translation is not None: 5379 self.English_Translation.export(lwrite, level, 'cyboxCommon:', name_='English_Translation', pretty_print=pretty_print) 5380 def build(self, node): 5381 self.__sourcenode__ = node 5382 already_processed = set() 5383 self.buildAttributes(node, node.attrib, already_processed) 5384 for child in node: 5385 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 5386 self.buildChildren(child, node, nodeName_) 5387 def buildAttributes(self, node, attrs, already_processed): 5388 pass 5389 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 5390 if nodeName_ == 'Encoding': 5391 obj_ = ControlledVocabularyStringType.factory() 5392 obj_.build(child_) 5393 self.set_Encoding(obj_) 5394 elif nodeName_ == 'String_Value': 5395 obj_ = StringObjectPropertyType.factory() 5396 obj_.build(child_) 5397 self.set_String_Value(obj_) 5398 elif nodeName_ == 'Byte_String_Value': 5399 obj_ = HexBinaryObjectPropertyType.factory() 5400 obj_.build(child_) 5401 self.set_Byte_String_Value(obj_) 5402 elif nodeName_ == 'Hashes': 5403 obj_ = HashListType.factory() 5404 obj_.build(child_) 5405 self.set_Hashes(obj_) 5406 elif nodeName_ == 'Address': 5407 obj_ = HexBinaryObjectPropertyType.factory() 5408 obj_.build(child_) 5409 self.set_Address(obj_) 5410 elif nodeName_ == 'Length': 5411 obj_ = PositiveIntegerObjectPropertyType.factory() 5412 obj_.build(child_) 5413 self.set_Length(obj_) 5414 elif nodeName_ == 'Language': 5415 obj_ = StringObjectPropertyType.factory() 5416 obj_.build(child_) 5417 self.set_Language(obj_) 5418 elif nodeName_ == 'English_Translation': 5419 obj_ = StringObjectPropertyType.factory() 5420 obj_.build(child_) 5421 self.set_English_Translation(obj_) 5422# end class ExtractedStringType 5423 5424class ImportsType(GeneratedsSuper): 5425 """The ImportsType is intended to represent an extracted list of 5426 imports specified within a CybOX object.""" 5427 5428 subclass = None 5429 superclass = None 5430 def __init__(self, Import=None): 5431 if Import is None: 5432 self.Import = [] 5433 else: 5434 self.Import = Import 5435 def factory(*args_, **kwargs_): 5436 if ImportsType.subclass: 5437 return ImportsType.subclass(*args_, **kwargs_) 5438 else: 5439 return ImportsType(*args_, **kwargs_) 5440 factory = staticmethod(factory) 5441 def get_Import(self): return self.Import 5442 def set_Import(self, Import): self.Import = Import 5443 def add_Import(self, value): self.Import.append(value) 5444 def insert_Import(self, index, value): self.Import[index] = value 5445 def validate_StringObjectPropertyType(self, value): 5446 # Validate type StringObjectPropertyType, a restriction on None. 5447 pass 5448 def hasContent_(self): 5449 if ( 5450 self.Import 5451 ): 5452 return True 5453 else: 5454 return False 5455 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='ImportsType', namespacedef_='', pretty_print=True): 5456 if pretty_print: 5457 eol_ = '\n' 5458 else: 5459 eol_ = '' 5460 showIndent(lwrite, level, pretty_print) 5461 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 5462 already_processed = set() 5463 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='ImportsType') 5464 if self.hasContent_(): 5465 lwrite('>%s' % (eol_, )) 5466 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 5467 showIndent(lwrite, level, pretty_print) 5468 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 5469 else: 5470 lwrite('/>%s' % (eol_, )) 5471 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='ImportsType'): 5472 pass 5473 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='ImportsType', fromsubclass_=False, pretty_print=True): 5474 if pretty_print: 5475 eol_ = '\n' 5476 else: 5477 eol_ = '' 5478 for Import_ in self.Import: 5479 Import_.export(lwrite, level, 'cyboxCommon:', name_='Import', pretty_print=pretty_print) 5480 def build(self, node): 5481 self.__sourcenode__ = node 5482 already_processed = set() 5483 self.buildAttributes(node, node.attrib, already_processed) 5484 for child in node: 5485 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 5486 self.buildChildren(child, node, nodeName_) 5487 def buildAttributes(self, node, attrs, already_processed): 5488 pass 5489 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 5490 if nodeName_ == 'Import': 5491 obj_ = StringObjectPropertyType.factory() 5492 obj_.build(child_) 5493 self.Import.append(obj_) 5494# end class ImportsType 5495 5496class FunctionsType(GeneratedsSuper): 5497 """The FunctionsType is intended to represent an extracted list of 5498 functions leveraged within a CybOX object.""" 5499 5500 subclass = None 5501 superclass = None 5502 def __init__(self, Function=None): 5503 if Function is None: 5504 self.Function = [] 5505 else: 5506 self.Function = Function 5507 def factory(*args_, **kwargs_): 5508 if FunctionsType.subclass: 5509 return FunctionsType.subclass(*args_, **kwargs_) 5510 else: 5511 return FunctionsType(*args_, **kwargs_) 5512 factory = staticmethod(factory) 5513 def get_Function(self): return self.Function 5514 def set_Function(self, Function): self.Function = Function 5515 def add_Function(self, value): self.Function.append(value) 5516 def insert_Function(self, index, value): self.Function[index] = value 5517 def validate_StringObjectPropertyType(self, value): 5518 # Validate type StringObjectPropertyType, a restriction on None. 5519 pass 5520 def hasContent_(self): 5521 if ( 5522 self.Function 5523 ): 5524 return True 5525 else: 5526 return False 5527 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='FunctionsType', namespacedef_='', pretty_print=True): 5528 if pretty_print: 5529 eol_ = '\n' 5530 else: 5531 eol_ = '' 5532 showIndent(lwrite, level, pretty_print) 5533 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 5534 already_processed = set() 5535 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='FunctionsType') 5536 if self.hasContent_(): 5537 lwrite('>%s' % (eol_, )) 5538 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 5539 showIndent(lwrite, level, pretty_print) 5540 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 5541 else: 5542 lwrite('/>%s' % (eol_, )) 5543 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='FunctionsType'): 5544 pass 5545 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='FunctionsType', fromsubclass_=False, pretty_print=True): 5546 if pretty_print: 5547 eol_ = '\n' 5548 else: 5549 eol_ = '' 5550 for Function_ in self.Function: 5551 Function_.export(lwrite, level, 'cyboxCommon:', name_='Function', pretty_print=pretty_print) 5552 def build(self, node): 5553 self.__sourcenode__ = node 5554 already_processed = set() 5555 self.buildAttributes(node, node.attrib, already_processed) 5556 for child in node: 5557 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 5558 self.buildChildren(child, node, nodeName_) 5559 def buildAttributes(self, node, attrs, already_processed): 5560 pass 5561 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 5562 if nodeName_ == 'Function': 5563 obj_ = StringObjectPropertyType.factory() 5564 obj_.build(child_) 5565 self.Function.append(obj_) 5566# end class FunctionsType 5567 5568class CodeSnippetsType(GeneratedsSuper): 5569 """The CodeSnippetsType is intended to represent an set of code 5570 snippets extracted from within a CybOX object.""" 5571 5572 subclass = None 5573 superclass = None 5574 def __init__(self, Code_Snippet=None): 5575 if Code_Snippet is None: 5576 self.Code_Snippet = [] 5577 else: 5578 self.Code_Snippet = Code_Snippet 5579 def factory(*args_, **kwargs_): 5580 if CodeSnippetsType.subclass: 5581 return CodeSnippetsType.subclass(*args_, **kwargs_) 5582 else: 5583 return CodeSnippetsType(*args_, **kwargs_) 5584 factory = staticmethod(factory) 5585 def get_Code_Snippet(self): return self.Code_Snippet 5586 def set_Code_Snippet(self, Code_Snippet): self.Code_Snippet = Code_Snippet 5587 def add_Code_Snippet(self, value): self.Code_Snippet.append(value) 5588 def insert_Code_Snippet(self, index, value): self.Code_Snippet[index] = value 5589 def hasContent_(self): 5590 if ( 5591 self.Code_Snippet 5592 ): 5593 return True 5594 else: 5595 return False 5596 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='CodeSnippetsType', namespacedef_='', pretty_print=True): 5597 if pretty_print: 5598 eol_ = '\n' 5599 else: 5600 eol_ = '' 5601 showIndent(lwrite, level, pretty_print) 5602 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 5603 already_processed = set() 5604 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='CodeSnippetsType') 5605 if self.hasContent_(): 5606 lwrite('>%s' % (eol_, )) 5607 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 5608 showIndent(lwrite, level, pretty_print) 5609 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 5610 else: 5611 lwrite('/>%s' % (eol_, )) 5612 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='CodeSnippetsType'): 5613 pass 5614 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='CodeSnippetsType', fromsubclass_=False, pretty_print=True): 5615 if pretty_print: 5616 eol_ = '\n' 5617 else: 5618 eol_ = '' 5619 for Code_Snippet_ in self.get_Code_Snippet(): 5620 Code_Snippet_.export(lwrite, level, 'cyboxCommon:', name_='Code_Snippet', pretty_print=pretty_print) 5621 def build(self, node): 5622 self.__sourcenode__ = node 5623 already_processed = set() 5624 self.buildAttributes(node, node.attrib, already_processed) 5625 for child in node: 5626 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 5627 self.buildChildren(child, node, nodeName_) 5628 def buildAttributes(self, node, attrs, already_processed): 5629 pass 5630 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 5631 if nodeName_ == 'Code_Snippet': 5632 type_name_ = child_.attrib.get( 5633 '{http://www.w3.org/2001/XMLSchema-instance}type') 5634 if type_name_ is None: 5635 type_name_ = child_.attrib.get('type') 5636 if type_name_ is not None: 5637 type_names_ = type_name_.split(':') 5638 if len(type_names_) == 1: 5639 type_name_ = type_names_[0] 5640 else: 5641 type_name_ = type_names_[1] 5642 class_ = globals()[type_name_] 5643 obj_ = class_.factory() 5644 obj_.build(child_) 5645 else: 5646 raise NotImplementedError( 5647 'Class not implemented for <Code_Snippet> element') 5648 self.Code_Snippet.append(obj_) 5649# end class CodeSnippetsType 5650 5651class ByteRunsType(GeneratedsSuper): 5652 """The ByteRunsType is used for representing a list of byte runs from 5653 within a raw object.""" 5654 5655 subclass = None 5656 superclass = None 5657 def __init__(self, Byte_Run=None): 5658 if Byte_Run is None: 5659 self.Byte_Run = [] 5660 else: 5661 self.Byte_Run = Byte_Run 5662 def factory(*args_, **kwargs_): 5663 if ByteRunsType.subclass: 5664 return ByteRunsType.subclass(*args_, **kwargs_) 5665 else: 5666 return ByteRunsType(*args_, **kwargs_) 5667 factory = staticmethod(factory) 5668 def get_Byte_Run(self): return self.Byte_Run 5669 def set_Byte_Run(self, Byte_Run): self.Byte_Run = Byte_Run 5670 def add_Byte_Run(self, value): self.Byte_Run.append(value) 5671 def insert_Byte_Run(self, index, value): self.Byte_Run[index] = value 5672 def hasContent_(self): 5673 if ( 5674 self.Byte_Run 5675 ): 5676 return True 5677 else: 5678 return False 5679 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='ByteRunsType', namespacedef_='', pretty_print=True): 5680 if pretty_print: 5681 eol_ = '\n' 5682 else: 5683 eol_ = '' 5684 showIndent(lwrite, level, pretty_print) 5685 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 5686 already_processed = set() 5687 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='ByteRunsType') 5688 if self.hasContent_(): 5689 lwrite('>%s' % (eol_, )) 5690 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 5691 showIndent(lwrite, level, pretty_print) 5692 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 5693 else: 5694 lwrite('/>%s' % (eol_, )) 5695 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='ByteRunsType'): 5696 pass 5697 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='ByteRunsType', fromsubclass_=False, pretty_print=True): 5698 if pretty_print: 5699 eol_ = '\n' 5700 else: 5701 eol_ = '' 5702 for Byte_Run_ in self.Byte_Run: 5703 Byte_Run_.export(lwrite, level, 'cyboxCommon:', name_='Byte_Run', pretty_print=pretty_print) 5704 def build(self, node): 5705 self.__sourcenode__ = node 5706 already_processed = set() 5707 self.buildAttributes(node, node.attrib, already_processed) 5708 for child in node: 5709 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 5710 self.buildChildren(child, node, nodeName_) 5711 def buildAttributes(self, node, attrs, already_processed): 5712 pass 5713 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 5714 if nodeName_ == 'Byte_Run': 5715 obj_ = ByteRunType.factory() 5716 obj_.build(child_) 5717 self.Byte_Run.append(obj_) 5718# end class ByteRunsType 5719 5720class ByteRunType(GeneratedsSuper): 5721 """The ByteRunType is used for representing a single byte run from 5722 within a raw object.""" 5723 subclass = None 5724 superclass = None 5725 def __init__(self, Offset=None, Byte_Order=None, File_System_Offset=None, Image_Offset=None, Length=None, Hashes=None, Byte_Run_Data=None): 5726 self.Offset = Offset 5727 self.Byte_Order = Byte_Order 5728 self.File_System_Offset = File_System_Offset 5729 self.Image_Offset = Image_Offset 5730 self.Length = Length 5731 self.Hashes = Hashes 5732 self.Byte_Run_Data = Byte_Run_Data 5733 def factory(*args_, **kwargs_): 5734 if ByteRunType.subclass: 5735 return ByteRunType.subclass(*args_, **kwargs_) 5736 else: 5737 return ByteRunType(*args_, **kwargs_) 5738 factory = staticmethod(factory) 5739 def get_Offset(self): return self.Offset 5740 def set_Offset(self, Offset): self.Offset = Offset 5741 def validate_IntegerObjectPropertyType(self, value): 5742 # Validate type IntegerObjectPropertyType, a restriction on None. 5743 pass 5744 def get_Byte_Order(self): return self.Byte_Order 5745 def set_Byte_Order(self, Byte_Order): self.Byte_Order = Byte_Order 5746 def validate_EndiannessType(self, value): 5747 # Validate type EndiannessType, a restriction on None. 5748 pass 5749 def get_File_System_Offset(self): return self.File_System_Offset 5750 def set_File_System_Offset(self, File_System_Offset): self.File_System_Offset = File_System_Offset 5751 def get_Image_Offset(self): return self.Image_Offset 5752 def set_Image_Offset(self, Image_Offset): self.Image_Offset = Image_Offset 5753 def get_Length(self): return self.Length 5754 def set_Length(self, Length): self.Length = Length 5755 def get_Hashes(self): return self.Hashes 5756 def set_Hashes(self, Hashes): self.Hashes = Hashes 5757 def get_Byte_Run_Data(self): return self.Byte_Run_Data 5758 def set_Byte_Run_Data(self, Byte_Run_Data): self.Byte_Run_Data = Byte_Run_Data 5759 def hasContent_(self): 5760 if ( 5761 self.Offset is not None or 5762 self.Byte_Order is not None or 5763 self.File_System_Offset is not None or 5764 self.Image_Offset is not None or 5765 self.Length is not None or 5766 self.Hashes is not None or 5767 self.Byte_Run_Data is not None 5768 ): 5769 return True 5770 else: 5771 return False 5772 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='ByteRunType', namespacedef_='', pretty_print=True): 5773 if pretty_print: 5774 eol_ = '\n' 5775 else: 5776 eol_ = '' 5777 showIndent(lwrite, level, pretty_print) 5778 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 5779 already_processed = set() 5780 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='ByteRunType') 5781 if self.hasContent_(): 5782 lwrite('>%s' % (eol_, )) 5783 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 5784 showIndent(lwrite, level, pretty_print) 5785 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 5786 else: 5787 lwrite('/>%s' % (eol_, )) 5788 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='ByteRunType'): 5789 pass 5790 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='ByteRunType', fromsubclass_=False, pretty_print=True): 5791 if pretty_print: 5792 eol_ = '\n' 5793 else: 5794 eol_ = '' 5795 if self.Offset is not None: 5796 self.Offset.export(lwrite, level, 'cyboxCommon:', name_='Offset', pretty_print=pretty_print) 5797 if self.Byte_Order is not None: 5798 self.Byte_Order.export(lwrite, level, 'cyboxCommon:', name_='Byte_Order', pretty_print=pretty_print) 5799 if self.File_System_Offset is not None: 5800 self.File_System_Offset.export(lwrite, level, 'cyboxCommon:', name_='File_System_Offset', pretty_print=pretty_print) 5801 if self.Image_Offset is not None: 5802 self.Image_Offset.export(lwrite, level, 'cyboxCommon:', name_='Image_Offset', pretty_print=pretty_print) 5803 if self.Length is not None: 5804 self.Length.export(lwrite, level, 'cyboxCommon:', name_='Length', pretty_print=pretty_print) 5805 if self.Hashes is not None: 5806 self.Hashes.export(lwrite, level, 'cyboxCommon:', name_='Hashes', pretty_print=pretty_print) 5807 if self.Byte_Run_Data is not None: 5808 showIndent(lwrite, level, pretty_print) 5809 lwrite('<%sByte_Run_Data>%s</%sByte_Run_Data>%s' % ('cyboxCommon:', self.gds_format_string(quote_xml(self.Byte_Run_Data), input_name='Byte_Run_Data'), 'cyboxCommon:', eol_)) 5810 def build(self, node): 5811 self.__sourcenode__ = node 5812 already_processed = set() 5813 self.buildAttributes(node, node.attrib, already_processed) 5814 for child in node: 5815 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 5816 self.buildChildren(child, node, nodeName_) 5817 def buildAttributes(self, node, attrs, already_processed): 5818 pass 5819 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 5820 if nodeName_ == 'Offset': 5821 obj_ = IntegerObjectPropertyType.factory() 5822 obj_.build(child_) 5823 self.set_Offset(obj_) 5824 elif nodeName_ == 'Byte_Order': 5825 obj_ = EndiannessType.factory() 5826 obj_.build(child_) 5827 self.set_Byte_Order(obj_) 5828 elif nodeName_ == 'File_System_Offset': 5829 obj_ = IntegerObjectPropertyType.factory() 5830 obj_.build(child_) 5831 self.set_File_System_Offset(obj_) 5832 elif nodeName_ == 'Image_Offset': 5833 obj_ = IntegerObjectPropertyType.factory() 5834 obj_.build(child_) 5835 self.set_Image_Offset(obj_) 5836 elif nodeName_ == 'Length': 5837 obj_ = PositiveIntegerObjectPropertyType.factory() 5838 obj_.build(child_) 5839 self.set_Length(obj_) 5840 elif nodeName_ == 'Hashes': 5841 obj_ = HashListType.factory() 5842 obj_.build(child_) 5843 self.set_Hashes(obj_) 5844 elif nodeName_ == 'Byte_Run_Data': 5845 Byte_Run_Data_ = child_.text 5846 Byte_Run_Data_ = self.gds_validate_string(Byte_Run_Data_, node, 'Byte_Run_Data') 5847 self.Byte_Run_Data = Byte_Run_Data_ 5848# end class ByteRunType 5849 5850class HashListType(GeneratedsSuper): 5851 """The HashListType type is used for representing a list of hash 5852 values.""" 5853 5854 subclass = None 5855 superclass = None 5856 def __init__(self, Hash=None): 5857 if Hash is None: 5858 self.Hash = [] 5859 else: 5860 self.Hash = Hash 5861 def factory(*args_, **kwargs_): 5862 if HashListType.subclass: 5863 return HashListType.subclass(*args_, **kwargs_) 5864 else: 5865 return HashListType(*args_, **kwargs_) 5866 factory = staticmethod(factory) 5867 def get_Hash(self): return self.Hash 5868 def set_Hash(self, Hash): self.Hash = Hash 5869 def add_Hash(self, value): self.Hash.append(value) 5870 def insert_Hash(self, index, value): self.Hash[index] = value 5871 def hasContent_(self): 5872 if ( 5873 self.Hash 5874 ): 5875 return True 5876 else: 5877 return False 5878 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='HashListType', namespacedef_='', pretty_print=True): 5879 if pretty_print: 5880 eol_ = '\n' 5881 else: 5882 eol_ = '' 5883 showIndent(lwrite, level, pretty_print) 5884 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 5885 already_processed = set() 5886 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='HashListType') 5887 if self.hasContent_(): 5888 lwrite('>%s' % (eol_, )) 5889 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 5890 showIndent(lwrite, level, pretty_print) 5891 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 5892 else: 5893 lwrite('/>%s' % (eol_, )) 5894 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='HashListType'): 5895 pass 5896 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='HashListType', fromsubclass_=False, pretty_print=True): 5897 if pretty_print: 5898 eol_ = '\n' 5899 else: 5900 eol_ = '' 5901 for Hash_ in self.Hash: 5902 Hash_.export(lwrite, level, 'cyboxCommon:', name_='Hash', pretty_print=pretty_print) 5903 def build(self, node): 5904 self.__sourcenode__ = node 5905 already_processed = set() 5906 self.buildAttributes(node, node.attrib, already_processed) 5907 for child in node: 5908 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 5909 self.buildChildren(child, node, nodeName_) 5910 def buildAttributes(self, node, attrs, already_processed): 5911 pass 5912 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 5913 if nodeName_ == 'Hash': 5914 obj_ = HashType.factory() 5915 obj_.build(child_) 5916 self.Hash.append(obj_) 5917# end class HashListType 5918 5919class HashValueType(GeneratedsSuper): 5920 """The HashValueType is used for specifying the resulting value from a 5921 hash calculation.""" 5922 5923 subclass = None 5924 superclass = None 5925 def __init__(self, Simple_Hash_Value=None, Fuzzy_Hash_Value=None): 5926 self.Simple_Hash_Value = Simple_Hash_Value 5927 self.Fuzzy_Hash_Value = Fuzzy_Hash_Value 5928 def factory(*args_, **kwargs_): 5929 if HashValueType.subclass: 5930 return HashValueType.subclass(*args_, **kwargs_) 5931 else: 5932 return HashValueType(*args_, **kwargs_) 5933 factory = staticmethod(factory) 5934 def get_Simple_Hash_Value(self): return self.Simple_Hash_Value 5935 def set_Simple_Hash_Value(self, Simple_Hash_Value): self.Simple_Hash_Value = Simple_Hash_Value 5936 def get_Fuzzy_Hash_Value(self): return self.Fuzzy_Hash_Value 5937 def set_Fuzzy_Hash_Value(self, Fuzzy_Hash_Value): self.Fuzzy_Hash_Value = Fuzzy_Hash_Value 5938 def hasContent_(self): 5939 if ( 5940 self.Simple_Hash_Value is not None or 5941 self.Fuzzy_Hash_Value is not None 5942 ): 5943 return True 5944 else: 5945 return False 5946 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='HashValueType', namespacedef_='', pretty_print=True): 5947 if pretty_print: 5948 eol_ = '\n' 5949 else: 5950 eol_ = '' 5951 showIndent(lwrite, level, pretty_print) 5952 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 5953 already_processed = set() 5954 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='HashValueType') 5955 if self.hasContent_(): 5956 lwrite('>%s' % (eol_, )) 5957 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 5958 showIndent(lwrite, level, pretty_print) 5959 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 5960 else: 5961 lwrite('/>%s' % (eol_, )) 5962 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='HashValueType'): 5963 pass 5964 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='HashValueType', fromsubclass_=False, pretty_print=True): 5965 if pretty_print: 5966 eol_ = '\n' 5967 else: 5968 eol_ = '' 5969 if self.Simple_Hash_Value is not None: 5970 self.Simple_Hash_Value.export(lwrite, level, 'cyboxCommon:', name_='Simple_Hash_Value', pretty_print=pretty_print) 5971 if self.Fuzzy_Hash_Value is not None: 5972 self.Fuzzy_Hash_Value.export(lwrite, level, 'cyboxCommon:', name_='Fuzzy_Hash_Value', pretty_print=pretty_print) 5973 def build(self, node): 5974 self.__sourcenode__ = node 5975 already_processed = set() 5976 self.buildAttributes(node, node.attrib, already_processed) 5977 for child in node: 5978 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 5979 self.buildChildren(child, node, nodeName_) 5980 def buildAttributes(self, node, attrs, already_processed): 5981 pass 5982 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 5983 if nodeName_ == 'Simple_Hash_Value': 5984 obj_ = HexBinaryObjectPropertyType.factory() 5985 obj_.build(child_) 5986 self.set_Simple_Hash_Value(obj_) 5987 elif nodeName_ == 'Fuzzy_Hash_Value': 5988 obj_ = FuzzyHashValueType.factory() 5989 obj_.build(child_) 5990 self.set_Fuzzy_Hash_Value(obj_) 5991# end class HashValueType 5992 5993class SimpleHashValueType(HexBinaryObjectPropertyType): 5994 """The SimpleHashValueType is used for characterizing the output of 5995 basic cryptograhic hash functions outputing a single hexbinary 5996 hash value.""" 5997 5998 subclass = None 5999 superclass = HexBinaryObjectPropertyType 6000 def __init__(self, obfuscation_algorithm_ref=None, refanging_transform_type=None, has_changed=None, delimiter='##comma##', pattern_type=None, datatype='hexBinary', refanging_transform=None, is_case_sensitive=True, bit_mask=None, appears_random=None, observed_encoding=None, defanging_algorithm_ref=None, is_obfuscated=None, regex_syntax=None, apply_condition='ANY', trend=None, idref=None, is_defanged=None, id=None, condition=None, valueOf_=None, extensiontype_=None): 6001 # PROP: This is a BaseObjectPropertyType subclass 6002 super(SimpleHashValueType, self).__init__(obfuscation_algorithm_ref, refanging_transform_type, has_changed, delimiter, pattern_type, datatype, refanging_transform, is_case_sensitive, bit_mask, appears_random, observed_encoding, defanging_algorithm_ref, is_obfuscated, regex_syntax, apply_condition, trend, idref, is_defanged, id, condition, valueOf_, extensiontype_) 6003 def factory(*args_, **kwargs_): 6004 if SimpleHashValueType.subclass: 6005 return SimpleHashValueType.subclass(*args_, **kwargs_) 6006 else: 6007 return SimpleHashValueType(*args_, **kwargs_) 6008 factory = staticmethod(factory) 6009 def hasContent_(self): 6010 if ( 6011 super(SimpleHashValueType, self).hasContent_() 6012 ): 6013 return True 6014 else: 6015 return False 6016 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='SimpleHashValueType', namespacedef_='', pretty_print=True): 6017 if pretty_print: 6018 eol_ = '\n' 6019 else: 6020 eol_ = '' 6021 showIndent(lwrite, level, pretty_print) 6022 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 6023 already_processed = set() 6024 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='SimpleHashValueType') 6025 if self.hasContent_(): 6026 lwrite('>') 6027 lwrite(quote_xml(self.valueOf_)) 6028 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 6029 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 6030 else: 6031 lwrite('/>%s' % (eol_, )) 6032 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='SimpleHashValueType'): 6033 super(SimpleHashValueType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='SimpleHashValueType') 6034 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='SimpleHashValueType', fromsubclass_=False, pretty_print=True): 6035 super(SimpleHashValueType, self).exportChildren(lwrite, level, 'cyboxCommon:', name_, True, pretty_print=pretty_print) 6036 pass 6037 def build(self, node): 6038 self.__sourcenode__ = node 6039 already_processed = set() 6040 self.buildAttributes(node, node.attrib, already_processed) 6041 self.valueOf_ = get_all_text_(node) 6042 for child in node: 6043 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 6044 self.buildChildren(child, node, nodeName_) 6045 def buildAttributes(self, node, attrs, already_processed): 6046 super(SimpleHashValueType, self).buildAttributes(node, attrs, already_processed) 6047 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 6048 super(SimpleHashValueType, self).buildChildren(child_, node, nodeName_, True) 6049 pass 6050# end class SimpleHashValueType 6051 6052class FuzzyHashValueType(StringObjectPropertyType): 6053 """The FuzzyHashValueType is used for characterizing the output of 6054 cryptograhic fuzzy hash functions outputing a single complex 6055 string based hash value.""" 6056 6057 subclass = None 6058 superclass = StringObjectPropertyType 6059 def __init__(self, obfuscation_algorithm_ref=None, refanging_transform_type=None, has_changed=None, delimiter='##comma##', pattern_type=None, datatype='string', refanging_transform=None, is_case_sensitive=True, bit_mask=None, appears_random=None, observed_encoding=None, defanging_algorithm_ref=None, is_obfuscated=None, regex_syntax=None, apply_condition='ANY', trend=None, idref=None, is_defanged=None, id=None, condition=None, valueOf_=None, extensiontype_=None): 6060 # PROP: This is a BaseObjectPropertyType subclass 6061 super(FuzzyHashValueType, self).__init__(obfuscation_algorithm_ref, refanging_transform_type, has_changed, delimiter, pattern_type, datatype, refanging_transform, is_case_sensitive, bit_mask, appears_random, observed_encoding, defanging_algorithm_ref, is_obfuscated, regex_syntax, apply_condition, trend, idref, is_defanged, id, condition, valueOf_, extensiontype_) 6062 def factory(*args_, **kwargs_): 6063 if FuzzyHashValueType.subclass: 6064 return FuzzyHashValueType.subclass(*args_, **kwargs_) 6065 else: 6066 return FuzzyHashValueType(*args_, **kwargs_) 6067 factory = staticmethod(factory) 6068 def hasContent_(self): 6069 if ( 6070 super(FuzzyHashValueType, self).hasContent_() 6071 ): 6072 return True 6073 else: 6074 return False 6075 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='FuzzyHashValueType', namespacedef_='', pretty_print=True): 6076 if pretty_print: 6077 eol_ = '\n' 6078 else: 6079 eol_ = '' 6080 showIndent(lwrite, level, pretty_print) 6081 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 6082 already_processed = set() 6083 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='FuzzyHashValueType') 6084 if self.hasContent_(): 6085 lwrite('>') 6086 lwrite(quote_xml(self.valueOf_)) 6087 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 6088 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 6089 else: 6090 lwrite('/>%s' % (eol_, )) 6091 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='FuzzyHashValueType'): 6092 super(FuzzyHashValueType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='FuzzyHashValueType') 6093 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='FuzzyHashValueType', fromsubclass_=False, pretty_print=True): 6094 super(FuzzyHashValueType, self).exportChildren(lwrite, level, 'cyboxCommon:', name_, True, pretty_print=pretty_print) 6095 pass 6096 def build(self, node): 6097 self.__sourcenode__ = node 6098 already_processed = set() 6099 self.buildAttributes(node, node.attrib, already_processed) 6100 self.valueOf_ = get_all_text_(node) 6101 for child in node: 6102 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 6103 self.buildChildren(child, node, nodeName_) 6104 def buildAttributes(self, node, attrs, already_processed): 6105 super(FuzzyHashValueType, self).buildAttributes(node, attrs, already_processed) 6106 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 6107 super(FuzzyHashValueType, self).buildChildren(child_, node, nodeName_, True) 6108 pass 6109# end class FuzzyHashValueType 6110 6111class FuzzyHashStructureType(GeneratedsSuper): 6112 """The FuzzyHashStructureType is used for characterizing the internal 6113 components of a cryptograhic fuzzy hash algorithmic calculation.""" 6114 6115 subclass = None 6116 superclass = None 6117 def __init__(self, Block_Size=None, Block_Hash=None): 6118 self.Block_Size = Block_Size 6119 self.Block_Hash = Block_Hash 6120 def factory(*args_, **kwargs_): 6121 if FuzzyHashStructureType.subclass: 6122 return FuzzyHashStructureType.subclass(*args_, **kwargs_) 6123 else: 6124 return FuzzyHashStructureType(*args_, **kwargs_) 6125 factory = staticmethod(factory) 6126 def get_Block_Size(self): return self.Block_Size 6127 def set_Block_Size(self, Block_Size): self.Block_Size = Block_Size 6128 def validate_IntegerObjectPropertyType(self, value): 6129 # Validate type IntegerObjectPropertyType, a restriction on None. 6130 pass 6131 def get_Block_Hash(self): return self.Block_Hash 6132 def set_Block_Hash(self, Block_Hash): self.Block_Hash = Block_Hash 6133 def hasContent_(self): 6134 if ( 6135 self.Block_Size is not None or 6136 self.Block_Hash is not None 6137 ): 6138 return True 6139 else: 6140 return False 6141 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='FuzzyHashStructureType', namespacedef_='', pretty_print=True): 6142 if pretty_print: 6143 eol_ = '\n' 6144 else: 6145 eol_ = '' 6146 showIndent(lwrite, level, pretty_print) 6147 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 6148 already_processed = set() 6149 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='FuzzyHashStructureType') 6150 if self.hasContent_(): 6151 lwrite('>%s' % (eol_, )) 6152 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 6153 showIndent(lwrite, level, pretty_print) 6154 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 6155 else: 6156 lwrite('/>%s' % (eol_, )) 6157 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='FuzzyHashStructureType'): 6158 pass 6159 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='FuzzyHashStructureType', fromsubclass_=False, pretty_print=True): 6160 if pretty_print: 6161 eol_ = '\n' 6162 else: 6163 eol_ = '' 6164 if self.Block_Size is not None: 6165 self.Block_Size.export(lwrite, level, 'cyboxCommon:', name_='Block_Size', pretty_print=pretty_print) 6166 if self.Block_Hash is not None: 6167 self.Block_Hash.export(lwrite, level, 'cyboxCommon:', name_='Block_Hash', pretty_print=pretty_print) 6168 def build(self, node): 6169 self.__sourcenode__ = node 6170 already_processed = set() 6171 self.buildAttributes(node, node.attrib, already_processed) 6172 for child in node: 6173 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 6174 self.buildChildren(child, node, nodeName_) 6175 def buildAttributes(self, node, attrs, already_processed): 6176 pass 6177 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 6178 if nodeName_ == 'Block_Size': 6179 obj_ = IntegerObjectPropertyType.factory() 6180 obj_.build(child_) 6181 self.set_Block_Size(obj_) 6182 elif nodeName_ == 'Block_Hash': 6183 obj_ = FuzzyHashBlockType.factory() 6184 obj_.build(child_) 6185 self.set_Block_Hash(obj_) 6186# end class FuzzyHashStructureType 6187 6188class FuzzyHashBlockType(GeneratedsSuper): 6189 """The FuzzyHashBlockType is used for characterizing the internal 6190 components of a single block in a cryptograhic fuzzy hash 6191 algorithmic calculation.""" 6192 6193 subclass = None 6194 superclass = None 6195 def __init__(self, Block_Hash_Value=None, Segment_Count=None, Segments=None): 6196 self.Block_Hash_Value = Block_Hash_Value 6197 self.Segment_Count = Segment_Count 6198 self.Segments = Segments 6199 def factory(*args_, **kwargs_): 6200 if FuzzyHashBlockType.subclass: 6201 return FuzzyHashBlockType.subclass(*args_, **kwargs_) 6202 else: 6203 return FuzzyHashBlockType(*args_, **kwargs_) 6204 factory = staticmethod(factory) 6205 def get_Block_Hash_Value(self): return self.Block_Hash_Value 6206 def set_Block_Hash_Value(self, Block_Hash_Value): self.Block_Hash_Value = Block_Hash_Value 6207 def get_Segment_Count(self): return self.Segment_Count 6208 def set_Segment_Count(self, Segment_Count): self.Segment_Count = Segment_Count 6209 def validate_IntegerObjectPropertyType(self, value): 6210 # Validate type IntegerObjectPropertyType, a restriction on None. 6211 pass 6212 def get_Segments(self): return self.Segments 6213 def set_Segments(self, Segments): self.Segments = Segments 6214 def hasContent_(self): 6215 if ( 6216 self.Block_Hash_Value is not None or 6217 self.Segment_Count is not None or 6218 self.Segments is not None 6219 ): 6220 return True 6221 else: 6222 return False 6223 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='FuzzyHashBlockType', namespacedef_='', pretty_print=True): 6224 if pretty_print: 6225 eol_ = '\n' 6226 else: 6227 eol_ = '' 6228 showIndent(lwrite, level, pretty_print) 6229 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 6230 already_processed = set() 6231 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='FuzzyHashBlockType') 6232 if self.hasContent_(): 6233 lwrite('>%s' % (eol_, )) 6234 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 6235 showIndent(lwrite, level, pretty_print) 6236 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 6237 else: 6238 lwrite('/>%s' % (eol_, )) 6239 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='FuzzyHashBlockType'): 6240 pass 6241 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='FuzzyHashBlockType', fromsubclass_=False, pretty_print=True): 6242 if pretty_print: 6243 eol_ = '\n' 6244 else: 6245 eol_ = '' 6246 if self.Block_Hash_Value is not None: 6247 self.Block_Hash_Value.export(lwrite, level, 'cyboxCommon:', name_='Block_Hash_Value', pretty_print=pretty_print) 6248 if self.Segment_Count is not None: 6249 self.Segment_Count.export(lwrite, level, 'cyboxCommon:', name_='Segment_Count', pretty_print=pretty_print) 6250 if self.Segments is not None: 6251 self.Segments.export(lwrite, level, 'cyboxCommon:', name_='Segments', pretty_print=pretty_print) 6252 def build(self, node): 6253 self.__sourcenode__ = node 6254 already_processed = set() 6255 self.buildAttributes(node, node.attrib, already_processed) 6256 for child in node: 6257 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 6258 self.buildChildren(child, node, nodeName_) 6259 def buildAttributes(self, node, attrs, already_processed): 6260 pass 6261 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 6262 if nodeName_ == 'Block_Hash_Value': 6263 obj_ = HashValueType.factory() 6264 obj_.build(child_) 6265 self.set_Block_Hash_Value(obj_) 6266 elif nodeName_ == 'Segment_Count': 6267 obj_ = IntegerObjectPropertyType.factory() 6268 obj_.build(child_) 6269 self.set_Segment_Count(obj_) 6270 elif nodeName_ == 'Segments': 6271 obj_ = HashSegmentsType.factory() 6272 obj_.build(child_) 6273 self.set_Segments(obj_) 6274# end class FuzzyHashBlockType 6275 6276class HashSegmentsType(GeneratedsSuper): 6277 """The HashSegmentsType is used for characterizing the internal 6278 components of a set of trigger point-delimited segments in a 6279 cryptograhic fuzzy hash algorithmic calculation.""" 6280 6281 subclass = None 6282 superclass = None 6283 def __init__(self, Segment=None): 6284 if Segment is None: 6285 self.Segment = [] 6286 else: 6287 self.Segment = Segment 6288 def factory(*args_, **kwargs_): 6289 if HashSegmentsType.subclass: 6290 return HashSegmentsType.subclass(*args_, **kwargs_) 6291 else: 6292 return HashSegmentsType(*args_, **kwargs_) 6293 factory = staticmethod(factory) 6294 def get_Segment(self): return self.Segment 6295 def set_Segment(self, Segment): self.Segment = Segment 6296 def add_Segment(self, value): self.Segment.append(value) 6297 def insert_Segment(self, index, value): self.Segment[index] = value 6298 def hasContent_(self): 6299 if ( 6300 self.Segment 6301 ): 6302 return True 6303 else: 6304 return False 6305 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='HashSegmentsType', namespacedef_='', pretty_print=True): 6306 if pretty_print: 6307 eol_ = '\n' 6308 else: 6309 eol_ = '' 6310 showIndent(lwrite, level, pretty_print) 6311 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 6312 already_processed = set() 6313 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='HashSegmentsType') 6314 if self.hasContent_(): 6315 lwrite('>%s' % (eol_, )) 6316 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 6317 showIndent(lwrite, level, pretty_print) 6318 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 6319 else: 6320 lwrite('/>%s' % (eol_, )) 6321 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='HashSegmentsType'): 6322 pass 6323 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='HashSegmentsType', fromsubclass_=False, pretty_print=True): 6324 if pretty_print: 6325 eol_ = '\n' 6326 else: 6327 eol_ = '' 6328 for Segment_ in self.Segment: 6329 Segment_.export(lwrite, level, 'cyboxCommon:', name_='Segment', pretty_print=pretty_print) 6330 def build(self, node): 6331 self.__sourcenode__ = node 6332 already_processed = set() 6333 self.buildAttributes(node, node.attrib, already_processed) 6334 for child in node: 6335 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 6336 self.buildChildren(child, node, nodeName_) 6337 def buildAttributes(self, node, attrs, already_processed): 6338 pass 6339 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 6340 if nodeName_ == 'Segment': 6341 obj_ = HashSegmentType.factory() 6342 obj_.build(child_) 6343 self.Segment.append(obj_) 6344# end class HashSegmentsType 6345 6346class HashSegmentType(GeneratedsSuper): 6347 """The HashSegmentType is used for characterizing the internal 6348 components of a single trigger point-delimited segment in a 6349 cryptograhic fuzzy hash algorithmic calculation.""" 6350 6351 subclass = None 6352 superclass = None 6353 def __init__(self, Trigger_Point=None, Segment_Hash=None, Raw_Segment_Content=None): 6354 self.Trigger_Point = Trigger_Point 6355 self.Segment_Hash = Segment_Hash 6356 self.Raw_Segment_Content = Raw_Segment_Content 6357 def factory(*args_, **kwargs_): 6358 if HashSegmentType.subclass: 6359 return HashSegmentType.subclass(*args_, **kwargs_) 6360 else: 6361 return HashSegmentType(*args_, **kwargs_) 6362 factory = staticmethod(factory) 6363 def get_Trigger_Point(self): return self.Trigger_Point 6364 def set_Trigger_Point(self, Trigger_Point): self.Trigger_Point = Trigger_Point 6365 def validate_HexBinaryObjectPropertyType(self, value): 6366 # Validate type HexBinaryObjectPropertyType, a restriction on None. 6367 pass 6368 def get_Segment_Hash(self): return self.Segment_Hash 6369 def set_Segment_Hash(self, Segment_Hash): self.Segment_Hash = Segment_Hash 6370 def get_Raw_Segment_Content(self): return self.Raw_Segment_Content 6371 def set_Raw_Segment_Content(self, Raw_Segment_Content): self.Raw_Segment_Content = Raw_Segment_Content 6372 def hasContent_(self): 6373 if ( 6374 self.Trigger_Point is not None or 6375 self.Segment_Hash is not None or 6376 self.Raw_Segment_Content is not None 6377 ): 6378 return True 6379 else: 6380 return False 6381 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='HashSegmentType', namespacedef_='', pretty_print=True): 6382 if pretty_print: 6383 eol_ = '\n' 6384 else: 6385 eol_ = '' 6386 showIndent(lwrite, level, pretty_print) 6387 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 6388 already_processed = set() 6389 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='HashSegmentType') 6390 if self.hasContent_(): 6391 lwrite('>%s' % (eol_, )) 6392 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 6393 showIndent(lwrite, level, pretty_print) 6394 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 6395 else: 6396 lwrite('/>%s' % (eol_, )) 6397 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='HashSegmentType'): 6398 pass 6399 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='HashSegmentType', fromsubclass_=False, pretty_print=True): 6400 if pretty_print: 6401 eol_ = '\n' 6402 else: 6403 eol_ = '' 6404 if self.Trigger_Point is not None: 6405 self.Trigger_Point.export(lwrite, level, 'cyboxCommon:', name_='Trigger_Point', pretty_print=pretty_print) 6406 if self.Segment_Hash is not None: 6407 self.Segment_Hash.export(lwrite, level, 'cyboxCommon:', name_='Segment_Hash', pretty_print=pretty_print) 6408 if self.Raw_Segment_Content is not None: 6409 showIndent(lwrite, level, pretty_print) 6410 lwrite('<%sRaw_Segment_Content>%s</%sRaw_Segment_Content>%s' % ('cyboxCommon:', self.gds_format_string(quote_xml(self.Raw_Segment_Content), input_name='Raw_Segment_Content'), 'cyboxCommon:', eol_)) 6411 def build(self, node): 6412 self.__sourcenode__ = node 6413 already_processed = set() 6414 self.buildAttributes(node, node.attrib, already_processed) 6415 for child in node: 6416 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 6417 self.buildChildren(child, node, nodeName_) 6418 def buildAttributes(self, node, attrs, already_processed): 6419 pass 6420 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 6421 if nodeName_ == 'Trigger_Point': 6422 obj_ = HexBinaryObjectPropertyType.factory() 6423 obj_.build(child_) 6424 self.set_Trigger_Point(obj_) 6425 elif nodeName_ == 'Segment_Hash': 6426 obj_ = HashValueType.factory() 6427 obj_.build(child_) 6428 self.set_Segment_Hash(obj_) 6429 elif nodeName_ == 'Raw_Segment_Content': 6430 Raw_Segment_Content_ = child_.text 6431 Raw_Segment_Content_ = self.gds_validate_string(Raw_Segment_Content_, node, 'Raw_Segment_Content') 6432 self.Raw_Segment_Content = Raw_Segment_Content_ 6433# end class HashSegmentType 6434 6435class HashType(GeneratedsSuper): 6436 """The HashType type is intended to characterize hash values.""" 6437 6438 subclass = None 6439 superclass = None 6440 def __init__(self, Type=None, Simple_Hash_Value=None, Fuzzy_Hash_Value=None, Fuzzy_Hash_Structure=None): 6441 self.Type = Type 6442 self.Simple_Hash_Value = Simple_Hash_Value 6443 self.Fuzzy_Hash_Value = Fuzzy_Hash_Value 6444 if Fuzzy_Hash_Structure is None: 6445 self.Fuzzy_Hash_Structure = [] 6446 else: 6447 self.Fuzzy_Hash_Structure = Fuzzy_Hash_Structure 6448 def factory(*args_, **kwargs_): 6449 if HashType.subclass: 6450 return HashType.subclass(*args_, **kwargs_) 6451 else: 6452 return HashType(*args_, **kwargs_) 6453 factory = staticmethod(factory) 6454 def get_Type(self): return self.Type 6455 def set_Type(self, Type): self.Type = Type 6456 def get_Simple_Hash_Value(self): return self.Simple_Hash_Value 6457 def set_Simple_Hash_Value(self, Simple_Hash_Value): self.Simple_Hash_Value = Simple_Hash_Value 6458 def get_Fuzzy_Hash_Value(self): return self.Fuzzy_Hash_Value 6459 def set_Fuzzy_Hash_Value(self, Fuzzy_Hash_Value): self.Fuzzy_Hash_Value = Fuzzy_Hash_Value 6460 def get_Fuzzy_Hash_Structure(self): return self.Fuzzy_Hash_Structure 6461 def set_Fuzzy_Hash_Structure(self, Fuzzy_Hash_Structure): self.Fuzzy_Hash_Structure = Fuzzy_Hash_Structure 6462 def add_Fuzzy_Hash_Structure(self, value): self.Fuzzy_Hash_Structure.append(value) 6463 def insert_Fuzzy_Hash_Structure(self, index, value): self.Fuzzy_Hash_Structure[index] = value 6464 def hasContent_(self): 6465 if ( 6466 self.Type is not None or 6467 self.Simple_Hash_Value is not None or 6468 self.Fuzzy_Hash_Value is not None or 6469 self.Fuzzy_Hash_Structure 6470 ): 6471 return True 6472 else: 6473 return False 6474 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='HashType', namespacedef_='', pretty_print=True): 6475 if pretty_print: 6476 eol_ = '\n' 6477 else: 6478 eol_ = '' 6479 showIndent(lwrite, level, pretty_print) 6480 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 6481 already_processed = set() 6482 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='HashType') 6483 if self.hasContent_(): 6484 lwrite('>%s' % (eol_, )) 6485 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 6486 showIndent(lwrite, level, pretty_print) 6487 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 6488 else: 6489 lwrite('/>%s' % (eol_, )) 6490 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='HashType'): 6491 pass 6492 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='HashType', fromsubclass_=False, pretty_print=True): 6493 if pretty_print: 6494 eol_ = '\n' 6495 else: 6496 eol_ = '' 6497 if self.Type is not None: 6498 self.Type.export(lwrite, level, 'cyboxCommon:', name_='Type', pretty_print=pretty_print) 6499 if self.Simple_Hash_Value is not None: 6500 self.Simple_Hash_Value.export(lwrite, level, 'cyboxCommon:', name_='Simple_Hash_Value', pretty_print=pretty_print) 6501 if self.Fuzzy_Hash_Value is not None: 6502 self.Fuzzy_Hash_Value.export(lwrite, level, 'cyboxCommon:', name_='Fuzzy_Hash_Value', pretty_print=pretty_print) 6503 for Fuzzy_Hash_Structure_ in self.Fuzzy_Hash_Structure: 6504 Fuzzy_Hash_Structure_.export(lwrite, level, 'cyboxCommon:', name_='Fuzzy_Hash_Structure', pretty_print=pretty_print) 6505 def build(self, node): 6506 self.__sourcenode__ = node 6507 already_processed = set() 6508 self.buildAttributes(node, node.attrib, already_processed) 6509 for child in node: 6510 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 6511 self.buildChildren(child, node, nodeName_) 6512 def buildAttributes(self, node, attrs, already_processed): 6513 pass 6514 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 6515 if nodeName_ == 'Type': 6516 obj_ = ControlledVocabularyStringType.factory() 6517 obj_.build(child_) 6518 self.set_Type(obj_) 6519 elif nodeName_ == 'Simple_Hash_Value': 6520 obj_ = HexBinaryObjectPropertyType.factory() 6521 obj_.build(child_) 6522 self.set_Simple_Hash_Value(obj_) 6523 elif nodeName_ == 'Fuzzy_Hash_Value': 6524 obj_ = FuzzyHashValueType.factory() 6525 obj_.build(child_) 6526 self.set_Fuzzy_Hash_Value(obj_) 6527 elif nodeName_ == 'Fuzzy_Hash_Structure': 6528 obj_ = FuzzyHashStructureType.factory() 6529 obj_.build(child_) 6530 self.Fuzzy_Hash_Structure.append(obj_) 6531# end class HashType 6532 6533class StructuredTextType(GeneratedsSuper): 6534 """The StructuredTextType is a type representing a generalized 6535 structure for capturing structured or unstructured textual 6536 information such as descriptions of things.Used to indicate a 6537 particular structuring format (e.g., HTML5) used within an 6538 instance of StructuredTextType. Note that if the markup tags 6539 used by this format would be interpreted as XML information 6540 (such as the bracket-based tags of HTML) the text area should be 6541 enclosed in a CDATA section to prevent the markup from 6542 interferring with XML validation of the CybOX document. If this 6543 attribute is absent, the implication is that no markup is being 6544 used.""" 6545 6546 subclass = None 6547 superclass = None 6548 def __init__(self, structuring_format=None, valueOf_=None): 6549 self.structuring_format = _cast(None, structuring_format) 6550 self.valueOf_ = valueOf_ 6551 def factory(*args_, **kwargs_): 6552 if StructuredTextType.subclass: 6553 return StructuredTextType.subclass(*args_, **kwargs_) 6554 else: 6555 return StructuredTextType(*args_, **kwargs_) 6556 factory = staticmethod(factory) 6557 def get_structuring_format(self): return self.structuring_format 6558 def set_structuring_format(self, structuring_format): self.structuring_format = structuring_format 6559 def get_valueOf_(self): return self.valueOf_ 6560 def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ 6561 def hasContent_(self): 6562 if ( 6563 self.valueOf_ 6564 ): 6565 return True 6566 else: 6567 return False 6568 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='StructuredTextType', namespacedef_='', pretty_print=True): 6569 if pretty_print: 6570 eol_ = '\n' 6571 else: 6572 eol_ = '' 6573 showIndent(lwrite, level, pretty_print) 6574 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 6575 already_processed = set() 6576 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='StructuredTextType') 6577 if self.hasContent_(): 6578 lwrite('>') 6579 lwrite(quote_xml(self.valueOf_)) 6580 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 6581 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 6582 else: 6583 lwrite('/>%s' % (eol_, )) 6584 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='StructuredTextType'): 6585 if self.structuring_format is not None: 6586 6587 lwrite(' structuring_format=%s' % (self.gds_format_string(quote_attrib(self.structuring_format), input_name='structuring_format'), )) 6588 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='StructuredTextType', fromsubclass_=False, pretty_print=True): 6589 pass 6590 def build(self, node): 6591 self.__sourcenode__ = node 6592 already_processed = set() 6593 self.buildAttributes(node, node.attrib, already_processed) 6594 self.valueOf_ = get_all_text_(node) 6595 for child in node: 6596 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 6597 self.buildChildren(child, node, nodeName_) 6598 def buildAttributes(self, node, attrs, already_processed): 6599 value = find_attr_value_('structuring_format', node) 6600 if value is not None: 6601 6602 self.structuring_format = value 6603 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 6604 pass 6605# end class StructuredTextType 6606 6607 6608class DataSegmentType(GeneratedsSuper): 6609 """The DataSegmentType is intended to provide a relatively abstract way 6610 of characterizing data segments that may be 6611 written/read/transmitted or otherwise utilized in actions or 6612 behaviors.The id field specifies a unique id for this data 6613 segment.""" 6614 subclass = None 6615 superclass = None 6616 def __init__(self, id=None, Data_Format=None, Data_Size=None, Byte_Order=None, Data_Segment=None, Offset=None, Search_Distance=None, Search_Within=None): 6617 self.id = _cast(None, id) 6618 self.Data_Format = Data_Format 6619 self.Data_Size = Data_Size 6620 self.Byte_Order = Byte_Order 6621 self.Data_Segment = Data_Segment 6622 self.Offset = Offset 6623 self.Search_Distance = Search_Distance 6624 self.Search_Within = Search_Within 6625 def factory(*args_, **kwargs_): 6626 if DataSegmentType.subclass: 6627 return DataSegmentType.subclass(*args_, **kwargs_) 6628 else: 6629 return DataSegmentType(*args_, **kwargs_) 6630 factory = staticmethod(factory) 6631 def get_Data_Format(self): return self.Data_Format 6632 def set_Data_Format(self, Data_Format): self.Data_Format = Data_Format 6633 def validate_DataFormatEnum(self, value): 6634 # Validate type DataFormatEnum, a restriction on xs:string. 6635 pass 6636 def get_Data_Size(self): return self.Data_Size 6637 def set_Data_Size(self, Data_Size): self.Data_Size = Data_Size 6638 def get_Byte_Order(self): return self.Byte_Order 6639 def set_Byte_Order(self, Byte_Order): self.Byte_Order = Byte_Order 6640 def validate_EndiannessType(self, value): 6641 # Validate type EndiannessType, a restriction on None. 6642 pass 6643 def get_Data_Segment(self): return self.Data_Segment 6644 def set_Data_Segment(self, Data_Segment): self.Data_Segment = Data_Segment 6645 def validate_StringObjectPropertyType(self, value): 6646 # Validate type StringObjectPropertyType, a restriction on None. 6647 pass 6648 def get_Offset(self): return self.Offset 6649 def set_Offset(self, Offset): self.Offset = Offset 6650 def validate_IntegerObjectPropertyType(self, value): 6651 # Validate type IntegerObjectPropertyType, a restriction on None. 6652 pass 6653 def get_Search_Distance(self): return self.Search_Distance 6654 def set_Search_Distance(self, Search_Distance): self.Search_Distance = Search_Distance 6655 def get_Search_Within(self): return self.Search_Within 6656 def set_Search_Within(self, Search_Within): self.Search_Within = Search_Within 6657 def get_id(self): return self.id 6658 def set_id(self, id): self.id = id 6659 def hasContent_(self): 6660 if ( 6661 self.Data_Format is not None or 6662 self.Data_Size is not None or 6663 self.Byte_Order is not None or 6664 self.Data_Segment is not None or 6665 self.Offset is not None or 6666 self.Search_Distance is not None or 6667 self.Search_Within is not None 6668 ): 6669 return True 6670 else: 6671 return False 6672 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='DataSegmentType', namespacedef_='', pretty_print=True): 6673 if pretty_print: 6674 eol_ = '\n' 6675 else: 6676 eol_ = '' 6677 showIndent(lwrite, level, pretty_print) 6678 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 6679 already_processed = set() 6680 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='DataSegmentType') 6681 if self.hasContent_(): 6682 lwrite('>%s' % (eol_, )) 6683 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 6684 showIndent(lwrite, level, pretty_print) 6685 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 6686 else: 6687 lwrite('/>%s' % (eol_, )) 6688 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='DataSegmentType'): 6689 if self.id is not None: 6690 6691 lwrite(' id=%s' % (quote_attrib(self.id), )) 6692 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='DataSegmentType', fromsubclass_=False, pretty_print=True): 6693 if pretty_print: 6694 eol_ = '\n' 6695 else: 6696 eol_ = '' 6697 if self.Data_Format is not None: 6698 showIndent(lwrite, level, pretty_print) 6699 lwrite('<%sData_Format>%s</%sData_Format>%s' % ('cyboxCommon:', self.gds_format_string(quote_xml(self.Data_Format), input_name='Data_Format'), 'cyboxCommon:', eol_)) 6700 if self.Data_Size is not None: 6701 self.Data_Size.export(lwrite, level, 'cyboxCommon:', name_='Data_Size', pretty_print=pretty_print) 6702 if self.Byte_Order is not None: 6703 self.Byte_Order.export(lwrite, level, 'cyboxCommon:', name_='Byte_Order', pretty_print=pretty_print) 6704 if self.Data_Segment is not None: 6705 self.Data_Segment.export(lwrite, level, 'cyboxCommon:', name_='Data_Segment', pretty_print=pretty_print) 6706 if self.Offset is not None: 6707 self.Offset.export(lwrite, level, 'cyboxCommon:', name_='Offset', pretty_print=pretty_print) 6708 if self.Search_Distance is not None: 6709 self.Search_Distance.export(lwrite, level, 'cyboxCommon:', name_='Search_Distance', pretty_print=pretty_print) 6710 if self.Search_Within is not None: 6711 self.Search_Within.export(lwrite, level, 'cyboxCommon:', name_='Search_Within', pretty_print=pretty_print) 6712 def build(self, node): 6713 self.__sourcenode__ = node 6714 already_processed = set() 6715 self.buildAttributes(node, node.attrib, already_processed) 6716 for child in node: 6717 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 6718 self.buildChildren(child, node, nodeName_) 6719 def buildAttributes(self, node, attrs, already_processed): 6720 value = find_attr_value_('id', node) 6721 if value is not None: 6722 6723 self.id = value 6724 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 6725 if nodeName_ == 'Data_Format': 6726 Data_Format = child_.text 6727 Data_Format = self.gds_validate_string(Data_Format, node, 'Data_Format') 6728 self.Data_Format = Data_Format 6729 elif nodeName_ == 'Data_Size': 6730 obj_ = DataSizeType.factory() 6731 obj_.build(child_) 6732 self.set_Data_Size(obj_) 6733 elif nodeName_ == 'Byte_Order': 6734 obj_ = EndiannessType.factory() 6735 obj_.build(child_) 6736 self.set_Byte_Order(obj_) 6737 elif nodeName_ == 'Data_Segment': 6738 obj_ = StringObjectPropertyType.factory() 6739 obj_.build(child_) 6740 self.set_Data_Segment(obj_) 6741 elif nodeName_ == 'Offset': 6742 obj_ = IntegerObjectPropertyType.factory() 6743 obj_.build(child_) 6744 self.set_Offset(obj_) 6745 elif nodeName_ == 'Search_Distance': 6746 obj_ = IntegerObjectPropertyType.factory() 6747 obj_.build(child_) 6748 self.set_Search_Distance(obj_) 6749 elif nodeName_ == 'Search_Within': 6750 obj_ = IntegerObjectPropertyType.factory() 6751 obj_.build(child_) 6752 self.set_Search_Within(obj_) 6753# end class DataSegmentType 6754 6755class DataSizeType(StringObjectPropertyType): 6756 """The DataSizeType specifies the size of the data segment.This field 6757 represents the Units used in the object size element. Possible 6758 values are: Bytes, Kilobytes, Megabytes.""" 6759 6760 subclass = None 6761 superclass = StringObjectPropertyType 6762 def __init__(self, obfuscation_algorithm_ref=None, refanging_transform_type=None, has_changed=None, delimiter='##comma##', pattern_type=None, datatype='string', refanging_transform=None, is_case_sensitive=True, bit_mask=None, appears_random=None, observed_encoding=None, defanging_algorithm_ref=None, is_obfuscated=None, regex_syntax=None, apply_condition='ANY', trend=None, idref=None, is_defanged=None, id=None, condition=None, valueOf_=None, extensiontype_=None, units=None): 6763 # PROP: This is a BaseObjectPropertyType subclass 6764 super(DataSizeType, self).__init__(obfuscation_algorithm_ref, refanging_transform_type, has_changed, delimiter, pattern_type, datatype, refanging_transform, is_case_sensitive, bit_mask, appears_random, observed_encoding, defanging_algorithm_ref, is_obfuscated, regex_syntax, apply_condition, trend, idref, is_defanged, id, condition, valueOf_, extensiontype_) 6765 self.units = _cast(None, units) 6766 def factory(*args_, **kwargs_): 6767 if DataSizeType.subclass: 6768 return DataSizeType.subclass(*args_, **kwargs_) 6769 else: 6770 return DataSizeType(*args_, **kwargs_) 6771 factory = staticmethod(factory) 6772 def get_units(self): return self.units 6773 def set_units(self, units): self.units = units 6774 def hasContent_(self): 6775 if ( 6776 self.valueOf_ or 6777 super(DataSizeType, self).hasContent_() 6778 ): 6779 return True 6780 else: 6781 return False 6782 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='DataSizeType', namespacedef_='', pretty_print=True): 6783 if pretty_print: 6784 eol_ = '\n' 6785 else: 6786 eol_ = '' 6787 showIndent(lwrite, level, pretty_print) 6788 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 6789 already_processed = set() 6790 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='DataSizeType') 6791 if self.hasContent_(): 6792 lwrite('>') 6793 lwrite(quote_xml(self.valueOf_)) 6794 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 6795 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 6796 else: 6797 lwrite('/>%s' % (eol_, )) 6798 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='DataSizeType'): 6799 super(DataSizeType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='DataSizeType') 6800 if self.units is not None: 6801 lwrite(' units=%s' % (quote_attrib(self.units), )) 6802 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='DataSizeType', fromsubclass_=False, pretty_print=True): 6803 super(DataSizeType, self).exportChildren(lwrite, level, 'cyboxCommon:', name_, True, pretty_print=pretty_print) 6804 pass 6805 def build(self, node): 6806 self.__sourcenode__ = node 6807 already_processed = set() 6808 self.buildAttributes(node, node.attrib, already_processed) 6809 self.valueOf_ = get_all_text_(node) 6810 for child in node: 6811 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 6812 self.buildChildren(child, node, nodeName_) 6813 def buildAttributes(self, node, attrs, already_processed): 6814 value = find_attr_value_('units', node) 6815 if value is not None: 6816 self.units = value 6817 super(DataSizeType, self).buildAttributes(node, attrs, already_processed) 6818 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 6819 pass 6820# end class DataSizeType 6821 6822class PlatformSpecificationType(GeneratedsSuper): 6823 """PlatformSpecificationType is a modularized data type intended for 6824 providing a consistent approach to uniquely specifying the 6825 identity of a specific platform.In addition to capturing basic 6826 information, this type is intended to be extended to enable the 6827 structured description of a platform instance using the XML 6828 Schema extension feature. The CybOX default extension uses the 6829 Common Platform Enumeration (CPE) Applicability Language schema 6830 to do so. The extension that defines this is captured in the 6831 CPE23PlatformSpecificationType in the 6832 http://cybox.mitre.org/extensions/platform#CPE2.3-1 namespace. 6833 This type is defined in the extensions/platform/cpe2.3.xsd file.""" 6834 6835 subclass = None 6836 superclass = None 6837 def __init__(self, Description=None, Identifier=None): 6838 self.Description = Description 6839 if Identifier is None: 6840 self.Identifier = [] 6841 else: 6842 self.Identifier = Identifier 6843 def factory(*args_, **kwargs_): 6844 if PlatformSpecificationType.subclass: 6845 return PlatformSpecificationType.subclass(*args_, **kwargs_) 6846 else: 6847 return PlatformSpecificationType(*args_, **kwargs_) 6848 factory = staticmethod(factory) 6849 def get_Description(self): return self.Description 6850 def set_Description(self, Description): self.Description = Description 6851 def get_Identifier(self): return self.Identifier 6852 def set_Identifier(self, Identifier): self.Identifier = Identifier 6853 def add_Identifier(self, value): self.Identifier.append(value) 6854 def insert_Identifier(self, index, value): self.Identifier[index] = value 6855 def hasContent_(self): 6856 if ( 6857 self.Description is not None or 6858 self.Identifier 6859 ): 6860 return True 6861 else: 6862 return False 6863 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='PlatformSpecificationType', namespacedef_='', pretty_print=True): 6864 if pretty_print: 6865 eol_ = '\n' 6866 else: 6867 eol_ = '' 6868 showIndent(lwrite, level, pretty_print) 6869 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 6870 already_processed = set() 6871 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='PlatformSpecificationType') 6872 if self.hasContent_(): 6873 lwrite('>%s' % (eol_, )) 6874 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 6875 showIndent(lwrite, level, pretty_print) 6876 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 6877 else: 6878 lwrite('/>%s' % (eol_, )) 6879 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='PlatformSpecificationType'): 6880 pass 6881 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='PlatformSpecificationType', fromsubclass_=False, pretty_print=True): 6882 if pretty_print: 6883 eol_ = '\n' 6884 else: 6885 eol_ = '' 6886 if self.Description is not None: 6887 self.Description.export(lwrite, level, 'cyboxCommon:', name_='Description', pretty_print=pretty_print) 6888 for Identifier_ in self.Identifier: 6889 Identifier_.export(lwrite, level, 'cyboxCommon:', name_='Identifier', pretty_print=pretty_print) 6890 def build(self, node): 6891 self.__sourcenode__ = node 6892 already_processed = set() 6893 self.buildAttributes(node, node.attrib, already_processed) 6894 for child in node: 6895 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 6896 self.buildChildren(child, node, nodeName_) 6897 def buildAttributes(self, node, attrs, already_processed): 6898 pass 6899 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 6900 if nodeName_ == 'Description': 6901 obj_ = StructuredTextType.factory() 6902 obj_.build(child_) 6903 self.set_Description(obj_) 6904 elif nodeName_ == 'Identifier': 6905 obj_ = PlatformIdentifierType.factory() 6906 obj_.build(child_) 6907 self.Identifier.append(obj_) 6908# end class PlatformSpecificationType 6909 6910class PlatformIdentifierType(StringObjectPropertyType): 6911 """Used to specify a name for a platform using a particular naming 6912 system and also allowing a reference pointing to more 6913 information about that naming scheme. For example, one could 6914 provide a CPE (Common Platform Enumeration) name using the CPE 6915 naming format. In this case, the system value could be "CPE" 6916 while the system_ref value could be 6917 "http://scap.nist.gov/specifications/cpe/".Indicates the naming 6918 system from which the indicated name was drawn.A reference to 6919 information about the naming system from which the indicated 6920 name was drawn.""" 6921 6922 subclass = None 6923 superclass = StringObjectPropertyType 6924 def __init__(self, obfuscation_algorithm_ref=None, refanging_transform_type=None, has_changed=None, delimiter='##comma##', pattern_type=None, datatype='string', refanging_transform=None, is_case_sensitive=True, bit_mask=None, appears_random=None, observed_encoding=None, defanging_algorithm_ref=None, is_obfuscated=None, regex_syntax=None, apply_condition='ANY', trend=None, idref=None, is_defanged=None, id=None, condition=None, valueOf_=None, extensiontype_=None, system_ref=None, system=None): 6925 # PROP: This is a BaseObjectPropertyType subclass 6926 super(PlatformIdentifierType, self).__init__(obfuscation_algorithm_ref, refanging_transform_type, has_changed, delimiter, pattern_type, datatype, refanging_transform, is_case_sensitive, bit_mask, appears_random, observed_encoding, defanging_algorithm_ref, is_obfuscated, regex_syntax, apply_condition, trend, idref, is_defanged, id, condition, valueOf_, extensiontype_) 6927 self.system_ref = _cast(None, system_ref) 6928 self.system = _cast(None, system) 6929 def factory(*args_, **kwargs_): 6930 if PlatformIdentifierType.subclass: 6931 return PlatformIdentifierType.subclass(*args_, **kwargs_) 6932 else: 6933 return PlatformIdentifierType(*args_, **kwargs_) 6934 factory = staticmethod(factory) 6935 def get_system_ref(self): return self.system_ref 6936 def set_system_ref(self, system_ref): self.system_ref = system_ref 6937 def get_system(self): return self.system 6938 def set_system(self, system): self.system = system 6939 def hasContent_(self): 6940 if ( 6941 self.valueOf_ or 6942 super(PlatformIdentifierType, self).hasContent_() 6943 ): 6944 return True 6945 else: 6946 return False 6947 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='PlatformIdentifierType', namespacedef_='', pretty_print=True): 6948 if pretty_print: 6949 eol_ = '\n' 6950 else: 6951 eol_ = '' 6952 showIndent(lwrite, level, pretty_print) 6953 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 6954 already_processed = set() 6955 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='PlatformIdentifierType') 6956 if self.hasContent_(): 6957 lwrite('>') 6958 lwrite(quote_xml(self.valueOf_)) 6959 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 6960 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 6961 else: 6962 lwrite('/>%s' % (eol_, )) 6963 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='PlatformIdentifierType'): 6964 super(PlatformIdentifierType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='PlatformIdentifierType') 6965 if self.system_ref is not None: 6966 6967 lwrite(' system-ref=%s' % (self.gds_format_string(quote_attrib(self.system_ref), input_name='system-ref'), )) 6968 if self.system is not None: 6969 6970 lwrite(' system=%s' % (self.gds_format_string(quote_attrib(self.system), input_name='system'), )) 6971 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='PlatformIdentifierType', fromsubclass_=False, pretty_print=True): 6972 super(PlatformIdentifierType, self).exportChildren(lwrite, level, 'cyboxCommon:', name_, True, pretty_print=pretty_print) 6973 pass 6974 def build(self, node): 6975 self.__sourcenode__ = node 6976 already_processed = set() 6977 self.buildAttributes(node, node.attrib, already_processed) 6978 self.valueOf_ = get_all_text_(node) 6979 for child in node: 6980 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 6981 self.buildChildren(child, node, nodeName_) 6982 def buildAttributes(self, node, attrs, already_processed): 6983 value = find_attr_value_('system-ref', node) 6984 if value is not None: 6985 6986 self.system_ref = value 6987 value = find_attr_value_('system', node) 6988 if value is not None: 6989 6990 self.system = value 6991 super(PlatformIdentifierType, self).buildAttributes(node, attrs, already_processed) 6992 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 6993 pass 6994# end class PlatformIdentifierType 6995 6996class MetadataType(GeneratedsSuper): 6997 """The MetadataType is intended as mechanism to capture any non- 6998 context-specific metadataThis field specifies the type of name 6999 of a single metadata field.""" 7000 7001 subclass = None 7002 superclass = None 7003 def __init__(self, type_=None, Value=None, SubDatum=None): 7004 self.type_ = _cast(None, type_) 7005 self.Value = Value 7006 if SubDatum is None: 7007 self.SubDatum = [] 7008 else: 7009 self.SubDatum = SubDatum 7010 def factory(*args_, **kwargs_): 7011 if MetadataType.subclass: 7012 return MetadataType.subclass(*args_, **kwargs_) 7013 else: 7014 return MetadataType(*args_, **kwargs_) 7015 factory = staticmethod(factory) 7016 def get_Value(self): return self.Value 7017 def set_Value(self, Value): self.Value = Value 7018 def get_SubDatum(self): return self.SubDatum 7019 def set_SubDatum(self, SubDatum): self.SubDatum = SubDatum 7020 def add_SubDatum(self, value): self.SubDatum.append(value) 7021 def insert_SubDatum(self, index, value): self.SubDatum[index] = value 7022 def get_type(self): return self.type_ 7023 def set_type(self, type_): self.type_ = type_ 7024 def hasContent_(self): 7025 if ( 7026 self.Value is not None or 7027 self.SubDatum 7028 ): 7029 return True 7030 else: 7031 return False 7032 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='MetadataType', namespacedef_='', pretty_print=True): 7033 if pretty_print: 7034 eol_ = '\n' 7035 else: 7036 eol_ = '' 7037 showIndent(lwrite, level, pretty_print) 7038 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 7039 already_processed = set() 7040 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='MetadataType') 7041 if self.hasContent_(): 7042 lwrite('>%s' % (eol_, )) 7043 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 7044 showIndent(lwrite, level, pretty_print) 7045 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 7046 else: 7047 lwrite('/>%s' % (eol_, )) 7048 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='MetadataType'): 7049 if self.type_ is not None: 7050 7051 lwrite(' type=%s' % (self.gds_format_string(quote_attrib(self.type_), input_name='type'), )) 7052 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='MetadataType', fromsubclass_=False, pretty_print=True): 7053 if pretty_print: 7054 eol_ = '\n' 7055 else: 7056 eol_ = '' 7057 if self.Value is not None: 7058 lwrite('<%sValue>%s</%sValue>%s' % ('cyboxCommon:', self.gds_format_string(quote_xml(self.Value), input_name='Value'), 'cyboxCommon:', eol_)) 7059 for SubDatum_ in self.SubDatum: 7060 SubDatum_.export(lwrite, level, 'cyboxCommon:', name_='SubDatum', pretty_print=pretty_print) 7061 def build(self, node): 7062 self.__sourcenode__ = node 7063 already_processed = set() 7064 self.buildAttributes(node, node.attrib, already_processed) 7065 for child in node: 7066 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 7067 self.buildChildren(child, node, nodeName_) 7068 def buildAttributes(self, node, attrs, already_processed): 7069 value = find_attr_value_('type', node) 7070 if value is not None: 7071 7072 self.type_ = value 7073 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 7074 if nodeName_ == 'Value': 7075 Value_ = child_.text 7076 Value_ = self.gds_validate_string(Value_, node, 'Value') 7077 self.Value = Value_ 7078 elif nodeName_ == 'SubDatum': 7079 obj_ = MetadataType.factory() 7080 obj_.build(child_) 7081 self.SubDatum.append(obj_) 7082# end class MetadataType 7083 7084class EnvironmentVariableListType(GeneratedsSuper): 7085 """The EnvironmentVariableListType type is used for representing a list 7086 of environment variables.""" 7087 7088 subclass = None 7089 superclass = None 7090 def __init__(self, Environment_Variable=None): 7091 if Environment_Variable is None: 7092 self.Environment_Variable = [] 7093 else: 7094 self.Environment_Variable = Environment_Variable 7095 def factory(*args_, **kwargs_): 7096 if EnvironmentVariableListType.subclass: 7097 return EnvironmentVariableListType.subclass(*args_, **kwargs_) 7098 else: 7099 return EnvironmentVariableListType(*args_, **kwargs_) 7100 factory = staticmethod(factory) 7101 def get_Environment_Variable(self): return self.Environment_Variable 7102 def set_Environment_Variable(self, Environment_Variable): self.Environment_Variable = Environment_Variable 7103 def add_Environment_Variable(self, value): self.Environment_Variable.append(value) 7104 def insert_Environment_Variable(self, index, value): self.Environment_Variable[index] = value 7105 def hasContent_(self): 7106 if ( 7107 self.Environment_Variable 7108 ): 7109 return True 7110 else: 7111 return False 7112 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='EnvironmentVariableListType', namespacedef_='', pretty_print=True): 7113 if pretty_print: 7114 eol_ = '\n' 7115 else: 7116 eol_ = '' 7117 showIndent(lwrite, level, pretty_print) 7118 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 7119 already_processed = set() 7120 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='EnvironmentVariableListType') 7121 if self.hasContent_(): 7122 lwrite('>%s' % (eol_, )) 7123 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 7124 showIndent(lwrite, level, pretty_print) 7125 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 7126 else: 7127 lwrite('/>%s' % (eol_, )) 7128 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='EnvironmentVariableListType'): 7129 pass 7130 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='EnvironmentVariableListType', fromsubclass_=False, pretty_print=True): 7131 if pretty_print: 7132 eol_ = '\n' 7133 else: 7134 eol_ = '' 7135 for Environment_Variable_ in self.Environment_Variable: 7136 Environment_Variable_.export(lwrite, level, 'cyboxCommon:', name_='Environment_Variable', pretty_print=pretty_print) 7137 def build(self, node): 7138 self.__sourcenode__ = node 7139 already_processed = set() 7140 self.buildAttributes(node, node.attrib, already_processed) 7141 for child in node: 7142 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 7143 self.buildChildren(child, node, nodeName_) 7144 def buildAttributes(self, node, attrs, already_processed): 7145 pass 7146 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 7147 if nodeName_ == 'Environment_Variable': 7148 obj_ = EnvironmentVariableType.factory() 7149 obj_.build(child_) 7150 self.Environment_Variable.append(obj_) 7151# end class EnvironmentVariableListType 7152 7153class EnvironmentVariableType(GeneratedsSuper): 7154 """The EnvironmentVariableType type is used for representing 7155 environment variables using a name/value pair.""" 7156 7157 subclass = None 7158 superclass = None 7159 def __init__(self, Name=None, Value=None): 7160 self.Name = Name 7161 self.Value = Value 7162 def factory(*args_, **kwargs_): 7163 if EnvironmentVariableType.subclass: 7164 return EnvironmentVariableType.subclass(*args_, **kwargs_) 7165 else: 7166 return EnvironmentVariableType(*args_, **kwargs_) 7167 factory = staticmethod(factory) 7168 def get_Name(self): return self.Name 7169 def set_Name(self, Name): self.Name = Name 7170 def validate_StringObjectPropertyType(self, value): 7171 # Validate type StringObjectPropertyType, a restriction on None. 7172 pass 7173 def get_Value(self): return self.Value 7174 def set_Value(self, Value): self.Value = Value 7175 def hasContent_(self): 7176 if ( 7177 self.Name is not None or 7178 self.Value is not None 7179 ): 7180 return True 7181 else: 7182 return False 7183 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='EnvironmentVariableType', namespacedef_='', pretty_print=True): 7184 if pretty_print: 7185 eol_ = '\n' 7186 else: 7187 eol_ = '' 7188 showIndent(lwrite, level, pretty_print) 7189 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 7190 already_processed = set() 7191 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='EnvironmentVariableType') 7192 if self.hasContent_(): 7193 lwrite('>%s' % (eol_, )) 7194 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 7195 showIndent(lwrite, level, pretty_print) 7196 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 7197 else: 7198 lwrite('/>%s' % (eol_, )) 7199 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='EnvironmentVariableType'): 7200 pass 7201 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='EnvironmentVariableType', fromsubclass_=False, pretty_print=True): 7202 if pretty_print: 7203 eol_ = '\n' 7204 else: 7205 eol_ = '' 7206 if self.Name is not None: 7207 self.Name.export(lwrite, level, 'cyboxCommon:', name_='Name', pretty_print=pretty_print) 7208 if self.Value is not None: 7209 self.Value.export(lwrite, level, 'cyboxCommon:', name_='Value', pretty_print=pretty_print) 7210 def build(self, node): 7211 self.__sourcenode__ = node 7212 already_processed = set() 7213 self.buildAttributes(node, node.attrib, already_processed) 7214 for child in node: 7215 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 7216 self.buildChildren(child, node, nodeName_) 7217 def buildAttributes(self, node, attrs, already_processed): 7218 pass 7219 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 7220 if nodeName_ == 'Name': 7221 obj_ = StringObjectPropertyType.factory() 7222 obj_.build(child_) 7223 self.set_Name(obj_) 7224 elif nodeName_ == 'Value': 7225 obj_ = StringObjectPropertyType.factory() 7226 obj_.build(child_) 7227 self.set_Value(obj_) 7228# end class EnvironmentVariableType 7229 7230class DigitalSignaturesType(GeneratedsSuper): 7231 """The DigitalSignaturesType is used for representing a list of digital 7232 signatures.""" 7233 7234 subclass = None 7235 superclass = None 7236 def __init__(self, Digital_Signature=None): 7237 if Digital_Signature is None: 7238 self.Digital_Signature = [] 7239 else: 7240 self.Digital_Signature = Digital_Signature 7241 def factory(*args_, **kwargs_): 7242 if DigitalSignaturesType.subclass: 7243 return DigitalSignaturesType.subclass(*args_, **kwargs_) 7244 else: 7245 return DigitalSignaturesType(*args_, **kwargs_) 7246 factory = staticmethod(factory) 7247 def get_Digital_Signature(self): return self.Digital_Signature 7248 def set_Digital_Signature(self, Digital_Signature): self.Digital_Signature = Digital_Signature 7249 def add_Digital_Signature(self, value): self.Digital_Signature.append(value) 7250 def insert_Digital_Signature(self, index, value): self.Digital_Signature[index] = value 7251 def hasContent_(self): 7252 if ( 7253 self.Digital_Signature 7254 ): 7255 return True 7256 else: 7257 return False 7258 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='DigitalSignaturesType', namespacedef_='', pretty_print=True): 7259 if pretty_print: 7260 eol_ = '\n' 7261 else: 7262 eol_ = '' 7263 showIndent(lwrite, level, pretty_print) 7264 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 7265 already_processed = set() 7266 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='DigitalSignaturesType') 7267 if self.hasContent_(): 7268 lwrite('>%s' % (eol_, )) 7269 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 7270 showIndent(lwrite, level, pretty_print) 7271 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 7272 else: 7273 lwrite('/>%s' % (eol_, )) 7274 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='DigitalSignaturesType'): 7275 pass 7276 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='DigitalSignaturesType', fromsubclass_=False, pretty_print=True): 7277 if pretty_print: 7278 eol_ = '\n' 7279 else: 7280 eol_ = '' 7281 for Digital_Signature_ in self.Digital_Signature: 7282 Digital_Signature_.export(lwrite, level, 'cyboxCommon:', name_='Digital_Signature', pretty_print=pretty_print) 7283 def build(self, node): 7284 self.__sourcenode__ = node 7285 already_processed = set() 7286 self.buildAttributes(node, node.attrib, already_processed) 7287 for child in node: 7288 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 7289 self.buildChildren(child, node, nodeName_) 7290 def buildAttributes(self, node, attrs, already_processed): 7291 pass 7292 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 7293 if nodeName_ == 'Digital_Signature': 7294 obj_ = DigitalSignatureInfoType.factory() 7295 obj_.build(child_) 7296 self.Digital_Signature.append(obj_) 7297# end class DigitalSignaturesType 7298 7299class DigitalSignatureInfoType(GeneratedsSuper): 7300 """The DigitalSignatureInfoType type is used as a way to represent some 7301 of the basic information about a digital signature.Specifies 7302 whether the digital signature exists.Specifies if the digital 7303 signature is verified.""" 7304 7305 subclass = None 7306 superclass = None 7307 def __init__(self, signature_verified=None, signature_exists=None, Certificate_Issuer=None, Certificate_Subject=None, Signature_Description=None): 7308 self.signature_verified = _cast(bool, signature_verified) 7309 self.signature_exists = _cast(bool, signature_exists) 7310 self.Certificate_Issuer = Certificate_Issuer 7311 self.Certificate_Subject = Certificate_Subject 7312 self.Signature_Description = Signature_Description 7313 def factory(*args_, **kwargs_): 7314 if DigitalSignatureInfoType.subclass: 7315 return DigitalSignatureInfoType.subclass(*args_, **kwargs_) 7316 else: 7317 return DigitalSignatureInfoType(*args_, **kwargs_) 7318 factory = staticmethod(factory) 7319 def get_Certificate_Issuer(self): return self.Certificate_Issuer 7320 def set_Certificate_Issuer(self, Certificate_Issuer): self.Certificate_Issuer = Certificate_Issuer 7321 def validate_StringObjectPropertyType(self, value): 7322 # Validate type StringObjectPropertyType, a restriction on None. 7323 pass 7324 def get_Certificate_Subject(self): return self.Certificate_Subject 7325 def set_Certificate_Subject(self, Certificate_Subject): self.Certificate_Subject = Certificate_Subject 7326 def get_Signature_Description(self): return self.Signature_Description 7327 def set_Signature_Description(self, Signature_Description): self.Signature_Description = Signature_Description 7328 def get_signature_verified(self): return self.signature_verified 7329 def set_signature_verified(self, signature_verified): self.signature_verified = signature_verified 7330 def get_signature_exists(self): return self.signature_exists 7331 def set_signature_exists(self, signature_exists): self.signature_exists = signature_exists 7332 def hasContent_(self): 7333 if ( 7334 self.Certificate_Issuer is not None or 7335 self.Certificate_Subject is not None or 7336 self.Signature_Description is not None 7337 ): 7338 return True 7339 else: 7340 return False 7341 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='DigitalSignatureInfoType', namespacedef_='', pretty_print=True): 7342 if pretty_print: 7343 eol_ = '\n' 7344 else: 7345 eol_ = '' 7346 showIndent(lwrite, level, pretty_print) 7347 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 7348 already_processed = set() 7349 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='DigitalSignatureInfoType') 7350 if self.hasContent_(): 7351 lwrite('>%s' % (eol_, )) 7352 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 7353 showIndent(lwrite, level, pretty_print) 7354 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 7355 else: 7356 lwrite('/>%s' % (eol_, )) 7357 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='DigitalSignatureInfoType'): 7358 if self.signature_verified is not None: 7359 7360 lwrite(' signature_verified="%s"' % self.gds_format_boolean(self.signature_verified, input_name='signature_verified')) 7361 if self.signature_exists is not None: 7362 7363 lwrite(' signature_exists="%s"' % self.gds_format_boolean(self.signature_exists, input_name='signature_exists')) 7364 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='DigitalSignatureInfoType', fromsubclass_=False, pretty_print=True): 7365 if pretty_print: 7366 eol_ = '\n' 7367 else: 7368 eol_ = '' 7369 if self.Certificate_Issuer is not None: 7370 self.Certificate_Issuer.export(lwrite, level, 'cyboxCommon:', name_='Certificate_Issuer', pretty_print=pretty_print) 7371 if self.Certificate_Subject is not None: 7372 self.Certificate_Subject.export(lwrite, level, 'cyboxCommon:', name_='Certificate_Subject', pretty_print=pretty_print) 7373 if self.Signature_Description is not None: 7374 self.Signature_Description.export(lwrite, level, 'cyboxCommon:', name_='Signature_Description', pretty_print=pretty_print) 7375 def build(self, node): 7376 self.__sourcenode__ = node 7377 already_processed = set() 7378 self.buildAttributes(node, node.attrib, already_processed) 7379 for child in node: 7380 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 7381 self.buildChildren(child, node, nodeName_) 7382 def buildAttributes(self, node, attrs, already_processed): 7383 value = find_attr_value_('signature_verified', node) 7384 if value is not None: 7385 7386 if value in ('true', '1'): 7387 self.signature_verified = True 7388 elif value in ('false', '0'): 7389 self.signature_verified = False 7390 else: 7391 raise_parse_error(node, 'Bad boolean attribute') 7392 value = find_attr_value_('signature_exists', node) 7393 if value is not None: 7394 7395 if value in ('true', '1'): 7396 self.signature_exists = True 7397 elif value in ('false', '0'): 7398 self.signature_exists = False 7399 else: 7400 raise_parse_error(node, 'Bad boolean attribute') 7401 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 7402 if nodeName_ == 'Certificate_Issuer': 7403 obj_ = StringObjectPropertyType.factory() 7404 obj_.build(child_) 7405 self.set_Certificate_Issuer(obj_) 7406 elif nodeName_ == 'Certificate_Subject': 7407 obj_ = StringObjectPropertyType.factory() 7408 obj_.build(child_) 7409 self.set_Certificate_Subject(obj_) 7410 elif nodeName_ == 'Signature_Description': 7411 obj_ = StringObjectPropertyType.factory() 7412 obj_.build(child_) 7413 self.set_Signature_Description(obj_) 7414# end class DigitalSignatureInfoType 7415 7416class PatternableFieldType(GeneratedsSuper): 7417 """The PatternableFieldType is a grouping of attributes applicable to 7418 defining patterns on a specific field.""" 7419 7420 subclass = None 7421 superclass = None 7422 def __init__(self, pattern_type=None, has_changed=None, trend=None, apply_condition='ANY', bit_mask=None, regex_syntax=None, condition=None, is_case_sensitive=True, delimiter='##comma##', valueOf_=None, extensiontype_=None): 7423 self.pattern_type = _cast(None, pattern_type) 7424 self.has_changed = _cast(bool, has_changed) 7425 self.trend = _cast(bool, trend) 7426 self.apply_condition = _cast(None, apply_condition) 7427 self.bit_mask = _cast(None, bit_mask) 7428 self.regex_syntax = _cast(None, regex_syntax) 7429 self.condition = _cast(None, condition) 7430 self.is_case_sensitive = _cast(bool, is_case_sensitive) 7431 self.delimiter = _cast(None, delimiter) 7432 self.valueOf_ = valueOf_ 7433 self.extensiontype_ = extensiontype_ 7434 def factory(*args_, **kwargs_): 7435 if PatternableFieldType.subclass: 7436 return PatternableFieldType.subclass(*args_, **kwargs_) 7437 else: 7438 return PatternableFieldType(*args_, **kwargs_) 7439 factory = staticmethod(factory) 7440 def get_pattern_type(self): return self.pattern_type 7441 def set_pattern_type(self, pattern_type): self.pattern_type = pattern_type 7442 def get_has_changed(self): return self.has_changed 7443 def set_has_changed(self, has_changed): self.has_changed = has_changed 7444 def get_trend(self): return self.trend 7445 def set_trend(self, trend): self.trend = trend 7446 def get_apply_condition(self): return self.apply_condition 7447 def set_apply_condition(self, apply_condition): self.apply_condition = apply_condition 7448 def get_bit_mask(self): return self.bit_mask 7449 def set_bit_mask(self, bit_mask): self.bit_mask = bit_mask 7450 def get_regex_syntax(self): return self.regex_syntax 7451 def set_regex_syntax(self, regex_syntax): self.regex_syntax = regex_syntax 7452 def get_condition(self): return self.condition 7453 def set_condition(self, condition): self.condition = condition 7454 def get_is_case_sensitive(self): return self.is_case_sensitive 7455 def set_is_case_sensitive(self, is_case_sensitive): self.is_case_sensitive = is_case_sensitive 7456 def get_delimiter(self): return self.delimiter 7457 def set_delimiter(self, delimiter): self.delimiter = delimiter 7458 def get_valueOf_(self): return self.valueOf_ 7459 def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ 7460 def get_extensiontype_(self): return self.extensiontype_ 7461 def set_extensiontype_(self, extensiontype_): self.extensiontype_ = extensiontype_ 7462 def hasContent_(self): 7463 if ( 7464 self.valueOf_ 7465 ): 7466 return True 7467 else: 7468 return False 7469 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='PatternableFieldType', namespacedef_='', pretty_print=True): 7470 if pretty_print: 7471 eol_ = '\n' 7472 else: 7473 eol_ = '' 7474 showIndent(lwrite, level, pretty_print) 7475 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 7476 already_processed = set() 7477 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='PatternableFieldType') 7478 if self.hasContent_(): 7479 lwrite('>') 7480 lwrite(quote_xml(self.valueOf_)) 7481 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 7482 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 7483 else: 7484 lwrite('/>%s' % (eol_, )) 7485 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='PatternableFieldType'): 7486 if self.pattern_type is not None: 7487 7488 lwrite(' pattern_type=%s' % (quote_attrib(self.pattern_type), )) 7489 if self.has_changed is not None: 7490 7491 lwrite(' has_changed="%s"' % self.gds_format_boolean(self.has_changed, input_name='has_changed')) 7492 if self.trend is not None: 7493 7494 lwrite(' trend="%s"' % self.gds_format_boolean(self.trend, input_name='trend')) 7495 # Only add 'apply_condition' if 'condition' is set, and the value 7496 # appears to be a list (by presence of a comma) 7497 if (self.apply_condition is not None and self.valueOf_ is not None and ',' in self.valueOf_ 7498 and 'apply_condition' not in already_processed): 7499 7500 lwrite(' apply_condition=%s' % (quote_attrib(self.apply_condition), )) 7501 if self.bit_mask is not None: 7502 7503 lwrite(' bit_mask=%s' % (self.gds_format_string(quote_attrib(self.bit_mask), input_name='bit_mask'), )) 7504 if self.regex_syntax is not None: 7505 7506 lwrite(' regex_syntax=%s' % (self.gds_format_string(quote_attrib(self.regex_syntax), input_name='regex_syntax'), )) 7507 if self.condition is not None: 7508 7509 lwrite(' condition=%s' % (quote_attrib(self.condition), )) 7510 if self.is_case_sensitive not in (None, True): 7511 7512 lwrite(' is_case_sensitive="%s"' % self.gds_format_boolean(self.is_case_sensitive, input_name='is_case_sensitive')) 7513 if self.delimiter not in (None, "##comma##"): 7514 7515 lwrite(' delimiter=%s' % (self.gds_format_string(quote_attrib(self.delimiter), input_name='delimiter'), )) 7516 if self.extensiontype_ is not None: 7517 7518 lwrite(' xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"') 7519 lwrite(' xsi:type="%s"' % self.extensiontype_) 7520 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='PatternableFieldType', fromsubclass_=False, pretty_print=True): 7521 pass 7522 def build(self, node): 7523 self.__sourcenode__ = node 7524 already_processed = set() 7525 self.buildAttributes(node, node.attrib, already_processed) 7526 self.valueOf_ = get_all_text_(node) 7527 for child in node: 7528 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 7529 self.buildChildren(child, node, nodeName_) 7530 def buildAttributes(self, node, attrs, already_processed): 7531 value = find_attr_value_('pattern_type', node) 7532 if value is not None: 7533 7534 self.pattern_type = value 7535 value = find_attr_value_('has_changed', node) 7536 if value is not None: 7537 7538 if value in ('true', '1'): 7539 self.has_changed = True 7540 elif value in ('false', '0'): 7541 self.has_changed = False 7542 else: 7543 raise_parse_error(node, 'Bad boolean attribute') 7544 value = find_attr_value_('trend', node) 7545 if value is not None: 7546 7547 if value in ('true', '1'): 7548 self.trend = True 7549 elif value in ('false', '0'): 7550 self.trend = False 7551 else: 7552 raise_parse_error(node, 'Bad boolean attribute') 7553 value = find_attr_value_('apply_condition', node) 7554 if value is not None: 7555 7556 self.apply_condition = value 7557 value = find_attr_value_('bit_mask', node) 7558 if value is not None: 7559 7560 self.bit_mask = value 7561 value = find_attr_value_('regex_syntax', node) 7562 if value is not None: 7563 7564 self.regex_syntax = value 7565 value = find_attr_value_('condition', node) 7566 if value is not None: 7567 7568 self.condition = value 7569 value = find_attr_value_('is_case_sensitive', node) 7570 if value is not None: 7571 7572 if value in ('true', '1'): 7573 self.is_case_sensitive = True 7574 elif value in ('false', '0'): 7575 self.is_case_sensitive = False 7576 else: 7577 raise_parse_error(node, 'Bad boolean attribute') 7578 value = find_attr_value_('delimiter', node) 7579 if value is not None: 7580 7581 self.delimiter = value 7582 value = find_attr_value_('xsi:type', node) 7583 if value is not None: 7584 7585 self.extensiontype_ = value 7586 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 7587 pass 7588# end class PatternableFieldType 7589 7590class ControlledVocabularyStringType(PatternableFieldType): 7591 """The ControlledVocabularyStringType is used as the basis for defining 7592 controlled vocabularies.The vocab_name field specifies the name 7593 of the controlled vocabulary.The vocab_reference field specifies 7594 the URI to the location of where the controlled vocabulary is 7595 defined, e.g., in an externally located XML schema file.""" 7596 7597 subclass = None 7598 superclass = PatternableFieldType 7599 def __init__(self, pattern_type=None, has_changed=None, trend=None, apply_condition='ANY', bit_mask=None, regex_syntax=None, condition=None, is_case_sensitive=True, delimiter='##comma##', vocab_reference=None, vocab_name=None, valueOf_=None, xsi_type=None): 7600 super(ControlledVocabularyStringType, self).__init__(pattern_type, has_changed, trend, apply_condition, bit_mask, regex_syntax, condition, is_case_sensitive, delimiter, valueOf_, ) 7601 self.vocab_reference = _cast(None, vocab_reference) 7602 self.vocab_name = _cast(None, vocab_name) 7603 self.valueOf_ = valueOf_ 7604 self.xsi_type = xsi_type 7605 def factory(*args_, **kwargs_): 7606 if ControlledVocabularyStringType.subclass: 7607 return ControlledVocabularyStringType.subclass(*args_, **kwargs_) 7608 else: 7609 return ControlledVocabularyStringType(*args_, **kwargs_) 7610 factory = staticmethod(factory) 7611 def get_vocab_reference(self): return self.vocab_reference 7612 def set_vocab_reference(self, vocab_reference): self.vocab_reference = vocab_reference 7613 def get_vocab_name(self): return self.vocab_name 7614 def set_vocab_name(self, vocab_name): self.vocab_name = vocab_name 7615 def get_valueOf_(self): return self.valueOf_ 7616 def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ 7617 def get_xsi_type(self): return self.xsi_type 7618 def set_xsi_type(self, xsi_type): self.xsi_type = xsi_type 7619 def hasContent_(self): 7620 if ( 7621 self.valueOf_ or 7622 self.xsi_type is not None or 7623 super(ControlledVocabularyStringType, self).hasContent_() 7624 ): 7625 return True 7626 else: 7627 return False 7628 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='ControlledVocabularyStringType', namespacedef_='', pretty_print=True): 7629 if pretty_print: 7630 eol_ = '\n' 7631 else: 7632 eol_ = '' 7633 showIndent(lwrite, level, pretty_print) 7634 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 7635 already_processed = set() 7636 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='ControlledVocabularyStringType') 7637 if self.hasContent_(): 7638 lwrite('>') 7639 lwrite(quote_xml(self.valueOf_)) 7640 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 7641 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 7642 else: 7643 lwrite('/>%s' % (eol_, )) 7644 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='ControlledVocabularyStringType'): 7645 super(ControlledVocabularyStringType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='ControlledVocabularyStringType') 7646 if self.vocab_reference is not None: 7647 7648 lwrite(' vocab_reference=%s' % (self.gds_format_string(quote_attrib(self.vocab_reference), input_name='vocab_reference'), )) 7649 if self.vocab_name is not None: 7650 7651 lwrite(' vocab_name=%s' % (self.gds_format_string(quote_attrib(self.vocab_name), input_name='vocab_name'), )) 7652 if self.xsi_type is not None: 7653 7654 lwrite(' xsi:type=%s' % (self.gds_format_string(quote_attrib(self.xsi_type), input_name='xsi:type'), )) 7655 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='ControlledVocabularyStringType', fromsubclass_=False, pretty_print=True): 7656 super(ControlledVocabularyStringType, self).exportChildren(lwrite, level, 'cyboxCommon:', name_, True, pretty_print=pretty_print) 7657 pass 7658 def build(self, node): 7659 self.__sourcenode__ = node 7660 already_processed = set() 7661 self.buildAttributes(node, node.attrib, already_processed) 7662 self.valueOf_ = get_all_text_(node) 7663 for child in node: 7664 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 7665 self.buildChildren(child, node, nodeName_) 7666 def buildAttributes(self, node, attrs, already_processed): 7667 value = find_attr_value_('vocab_reference', node) 7668 if value is not None: 7669 self.vocab_reference = value 7670 value = find_attr_value_('vocab_name', node) 7671 if value is not None: 7672 self.vocab_name = value 7673 value = find_attr_value_('xsi:type', node) 7674 if value is not None: 7675 self.xsi_type = value 7676 super(ControlledVocabularyStringType, self).buildAttributes(node, attrs, already_processed) 7677 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 7678 pass 7679# end class ControlledVocabularyStringType 7680 7681class SIDType(BaseObjectPropertyType): 7682 subclass = None 7683 superclass = BaseObjectPropertyType 7684 def __init__(self, obfuscation_algorithm_ref=None, refanging_transform_type=None, has_changed=None, delimiter='##comma##', pattern_type=None, datatype='string', refanging_transform=None, is_case_sensitive=True, bit_mask=None, appears_random=None, observed_encoding=None, defanging_algorithm_ref=None, is_obfuscated=None, regex_syntax=None, apply_condition='ANY', trend=None, idref=None, is_defanged=None, id=None, condition=None, valueOf_=None, extensiontype_=None): 7685 # PROP: This is a BaseObjectPropertyType subclass 7686 super(SIDType, self).__init__(obfuscation_algorithm_ref, refanging_transform_type, has_changed, delimiter, pattern_type, datatype, refanging_transform, is_case_sensitive, bit_mask, appears_random, observed_encoding, defanging_algorithm_ref, is_obfuscated, regex_syntax, apply_condition, trend, idref, is_defanged, id, condition, valueOf_, extensiontype_) 7687 def factory(*args_, **kwargs_): 7688 if SIDType.subclass: 7689 return SIDType.subclass(*args_, **kwargs_) 7690 else: 7691 return SIDType(*args_, **kwargs_) 7692 factory = staticmethod(factory) 7693 def hasContent_(self): 7694 if ( 7695 self.valueOf_ or 7696 super(SIDType, self).hasContent_() 7697 ): 7698 return True 7699 else: 7700 return False 7701 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='SIDType', namespacedef_='', pretty_print=True): 7702 if pretty_print: 7703 eol_ = '\n' 7704 else: 7705 eol_ = '' 7706 showIndent(lwrite, level, pretty_print) 7707 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 7708 already_processed = set() 7709 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='SIDType') 7710 if self.hasContent_(): 7711 lwrite('>') 7712 lwrite(quote_xml(self.valueOf_)) 7713 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 7714 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 7715 else: 7716 lwrite('/>%s' % (eol_, )) 7717 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='SIDType'): 7718 super(SIDType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='SIDType') 7719# if self.datatype is not None: 7720# 7721# lwrite(' datatype=%s' % (quote_attrib(self.datatype), )) 7722 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='SIDType', fromsubclass_=False, pretty_print=True): 7723 super(SIDType, self).exportChildren(lwrite, level, 'cyboxCommon:', name_, True, pretty_print=pretty_print) 7724 pass 7725 def build(self, node): 7726 self.__sourcenode__ = node 7727 already_processed = set() 7728 self.buildAttributes(node, node.attrib, already_processed) 7729 self.valueOf_ = get_all_text_(node) 7730 for child in node: 7731 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 7732 self.buildChildren(child, node, nodeName_) 7733 def buildAttributes(self, node, attrs, already_processed): 7734 value = find_attr_value_('datatype', node) 7735 if value is not None: 7736 7737 self.datatype = value 7738 super(SIDType, self).buildAttributes(node, attrs, already_processed) 7739 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 7740 pass 7741# end class SIDType 7742 7743class PropertyType(BaseObjectPropertyType): 7744 """The PropertyType is a type representing the specification of a 7745 single Object Property.The name field specifies a name for this 7746 property.A description of what this property represents.""" 7747 subclass = None 7748 superclass = BaseObjectPropertyType 7749 def __init__(self, obfuscation_algorithm_ref=None, refanging_transform_type=None, has_changed=None, delimiter='##comma##', pattern_type=None, datatype='string', refanging_transform=None, is_case_sensitive=True, bit_mask=None, appears_random=None, observed_encoding=None, defanging_algorithm_ref=None, is_obfuscated=None, regex_syntax=None, apply_condition='ANY', trend=None, idref=None, is_defanged=None, id=None, condition=None, valueOf_=None, extensiontype_=None, name=None, description=None): 7750 # PROP: This is a BaseObjectPropertyType subclass 7751 super(PropertyType, self).__init__(obfuscation_algorithm_ref, refanging_transform_type, has_changed, delimiter, pattern_type, datatype, refanging_transform, is_case_sensitive, bit_mask, appears_random, observed_encoding, defanging_algorithm_ref, is_obfuscated, regex_syntax, apply_condition, trend, idref, is_defanged, id, condition, valueOf_, extensiontype_) 7752 self.name = _cast(None, name) 7753 self.description = _cast(None, description) 7754 def factory(*args_, **kwargs_): 7755 if PropertyType.subclass: 7756 return PropertyType.subclass(*args_, **kwargs_) 7757 else: 7758 return PropertyType(*args_, **kwargs_) 7759 factory = staticmethod(factory) 7760 def get_name(self): return self.name 7761 def set_name(self, name): self.name = name 7762 def get_description(self): return self.description 7763 def set_description(self, description): self.description = description 7764 def hasContent_(self): 7765 if ( 7766 self.valueOf_ or 7767 super(PropertyType, self).hasContent_() 7768 ): 7769 return True 7770 else: 7771 return False 7772 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='PropertyType', namespacedef_='', pretty_print=True): 7773 if pretty_print: 7774 eol_ = '\n' 7775 else: 7776 eol_ = '' 7777 showIndent(lwrite, level, pretty_print) 7778 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 7779 already_processed = set() 7780 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='PropertyType') 7781 if self.hasContent_(): 7782 lwrite('>') 7783 lwrite(quote_xml(self.valueOf_)) 7784 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 7785 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 7786 else: 7787 lwrite('/>%s' % (eol_, )) 7788 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='PropertyType'): 7789 super(PropertyType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='PropertyType') 7790 if self.name is not None: 7791 7792 lwrite(' name=%s' % (self.gds_format_string(quote_attrib(self.name), input_name='name'), )) 7793 if self.description is not None: 7794 7795 lwrite(' description=%s' % (self.gds_format_string(quote_attrib(self.description), input_name='description'), )) 7796 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='PropertyType', fromsubclass_=False, pretty_print=True): 7797 super(PropertyType, self).exportChildren(lwrite, level, 'cyboxCommon:', name_, True, pretty_print=pretty_print) 7798 pass 7799 def build(self, node): 7800 self.__sourcenode__ = node 7801 already_processed = set() 7802 self.buildAttributes(node, node.attrib, already_processed) 7803 self.valueOf_ = get_all_text_(node) 7804 for child in node: 7805 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 7806 self.buildChildren(child, node, nodeName_) 7807 def buildAttributes(self, node, attrs, already_processed): 7808 value = find_attr_value_('name', node) 7809 if value is not None: 7810 7811 self.name = value 7812 value = find_attr_value_('description', node) 7813 if value is not None: 7814 7815 self.description = value 7816 super(PropertyType, self).buildAttributes(node, attrs, already_processed) 7817 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 7818 pass 7819# end class PropertyType 7820 7821class CompensationModelType(BaseObjectPropertyType): 7822 """The CompensationModelType characterizes the compensation model for a 7823 tool.This attribute is optional and specifies the expected type 7824 for the value of the specified property.""" 7825 subclass = None 7826 superclass = BaseObjectPropertyType 7827 def __init__(self, obfuscation_algorithm_ref=None, refanging_transform_type=None, has_changed=None, delimiter='##comma##', pattern_type=None, datatype='string', refanging_transform=None, is_case_sensitive=True, bit_mask=None, appears_random=None, observed_encoding=None, defanging_algorithm_ref=None, is_obfuscated=None, regex_syntax=None, apply_condition='ANY', trend=None, idref=None, is_defanged=None, id=None, condition=None, valueOf_=None, extensiontype_=None): 7828 # PROP: This is a BaseObjectPropertyType subclass 7829 super(CompensationModelType, self).__init__(obfuscation_algorithm_ref, refanging_transform_type, has_changed, delimiter, pattern_type, datatype, refanging_transform, is_case_sensitive, bit_mask, appears_random, observed_encoding, defanging_algorithm_ref, is_obfuscated, regex_syntax, apply_condition, trend, idref, is_defanged, id, condition, valueOf_, extensiontype_) 7830 def factory(*args_, **kwargs_): 7831 if CompensationModelType.subclass: 7832 return CompensationModelType.subclass(*args_, **kwargs_) 7833 else: 7834 return CompensationModelType(*args_, **kwargs_) 7835 factory = staticmethod(factory) 7836 def hasContent_(self): 7837 if ( 7838 self.valueOf_ or 7839 super(CompensationModelType, self).hasContent_() 7840 ): 7841 return True 7842 else: 7843 return False 7844 def export(self, lwrite, level, namespace_='cyboxCommon:', name_='CompensationModelType', namespacedef_='', pretty_print=True): 7845 if pretty_print: 7846 eol_ = '\n' 7847 else: 7848 eol_ = '' 7849 showIndent(lwrite, level, pretty_print) 7850 lwrite('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 7851 already_processed = set() 7852 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='CompensationModelType') 7853 if self.hasContent_(): 7854 lwrite('>') 7855 lwrite(quote_xml(self.valueOf_)) 7856 self.exportChildren(lwrite, level + 1, namespace_, name_, pretty_print=pretty_print) 7857 lwrite('</%s%s>%s' % (namespace_, name_, eol_)) 7858 else: 7859 lwrite('/>%s' % (eol_, )) 7860 def exportAttributes(self, lwrite, level, already_processed, namespace_='cyboxCommon:', name_='CompensationModelType'): 7861 super(CompensationModelType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='CompensationModelType') 7862 def exportChildren(self, lwrite, level, namespace_='cyboxCommon:', name_='CompensationModelType', fromsubclass_=False, pretty_print=True): 7863 super(CompensationModelType, self).exportChildren(lwrite, level, 'cyboxCommon:', name_, True, pretty_print=pretty_print) 7864 pass 7865 def build(self, node): 7866 self.__sourcenode__ = node 7867 already_processed = set() 7868 self.buildAttributes(node, node.attrib, already_processed) 7869 self.valueOf_ = get_all_text_(node) 7870 for child in node: 7871 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 7872 self.buildChildren(child, node, nodeName_) 7873 def buildAttributes(self, node, attrs, already_processed): 7874 value = find_attr_value_('datatype', node) 7875 if value is not None: 7876 7877 self.datatype = value 7878 super(CompensationModelType, self).buildAttributes(node, attrs, already_processed) 7879 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 7880 pass 7881# end class CompensationModelType 7882 7883 7884USAGE_TEXT = """ 7885Usage: python <Parser>.py [ -s ] <in_xml_file> 7886""" 7887 7888def usage(): 7889 print(USAGE_TEXT) 7890 sys.exit(1) 7891 7892def get_root_tag(node): 7893 tag = Tag_pattern_.match(node.tag).groups()[-1] 7894 rootClass = globals().get(tag) 7895 return tag, rootClass 7896 7897def parse(inFileName): 7898 doc = parsexml_(inFileName) 7899 rootNode = doc.getroot() 7900 rootTag, rootClass = get_root_tag(rootNode) 7901 if rootClass is None: 7902 rootTag = 'MeasureSourceType' 7903 rootClass = MeasureSourceType 7904 rootObj = rootClass.factory() 7905 rootObj.build(rootNode) 7906 # Enable Python to collect the space used by the DOM. 7907 doc = None 7908# sys.stdout.write('<?xml version="1.0" ?>\n') 7909# rootObj.export(sys.stdout.write, 0, name_=rootTag, 7910# namespacedef_='', 7911# pretty_print=True) 7912 return rootObj 7913 7914 7915def parseString(inString): 7916 from mixbox.vendor.six import StringIO 7917 doc = parsexml_(StringIO(inString)) 7918 rootNode = doc.getroot() 7919 rootTag, rootClass = get_root_tag(rootNode) 7920 if rootClass is None: 7921 rootTag = 'MeasureSourceType' 7922 rootClass = MeasureSourceType 7923 rootObj = rootClass.factory() 7924 rootObj.build(rootNode) 7925 # Enable Python to collect the space used by the DOM. 7926 doc = None 7927# sys.stdout.write('<?xml version="1.0" ?>\n') 7928# rootObj.export(sys.stdout.write, 0, name_="MeasureSourceType", 7929# namespacedef_='') 7930 return rootObj 7931 7932def main(): 7933 args = sys.argv[1:] 7934 if len(args) == 1: 7935 parse(args[0]) 7936 else: 7937 usage() 7938 7939if __name__ == '__main__': 7940 #import pdb; pdb.set_trace() 7941 main() 7942 7943__all__ = [ 7944 "MeasureSourceType", 7945 "ContributorType", 7946 "DateRangeType", 7947 "PersonnelType", 7948 "TimeType", 7949 "ToolSpecificDataType", 7950 "ToolsInformationType", 7951 "ToolInformationType", 7952 "CompensationModelType", 7953 "ToolReferencesType", 7954 "ToolReferenceType", 7955 "ToolConfigurationType", 7956 "ConfigurationSettingsType", 7957 "ConfigurationSettingType", 7958 "DependenciesType", 7959 "DependencyType", 7960 "UsageContextAssumptionsType", 7961 "InternationalizationSettingsType", 7962 "InternalStringsType", 7963 "BuildInformationType", 7964 "BuildUtilityType", 7965 "CompilersType", 7966 "CompilerType", 7967 "CompilerInformalDescriptionType", 7968 "BuildConfigurationType", 7969 "LibrariesType", 7970 "LibraryType", 7971 "ExecutionEnvironmentType", 7972 "ErrorsType", 7973 "ErrorType", 7974 "ErrorInstancesType", 7975 "ObjectPropertiesType", 7976 "CustomPropertiesType", 7977 "PropertyType", 7978 "BaseObjectPropertyType", 7979 "IntegerObjectPropertyType", 7980 "StringObjectPropertyType", 7981 "NameObjectPropertyType", 7982 "DateObjectPropertyRestrictionType", 7983 "DateObjectPropertyType", 7984 "DateTimeObjectPropertyRestrictionType", 7985 "DateTimeObjectPropertyType", 7986 "FloatObjectPropertyType", 7987 "DoubleObjectPropertyType", 7988 "UnsignedLongObjectPropertyType", 7989 "UnsignedIntegerObjectPropertyType", 7990 "PositiveIntegerObjectPropertyType", 7991 "HexBinaryObjectPropertyType", 7992 "LongObjectPropertyType", 7993 "NonNegativeIntegerObjectPropertyType", 7994 "AnyURIObjectPropertyType", 7995 "DurationObjectPropertyType", 7996 "TimeObjectPropertyRestrictionType", 7997 "TimeObjectPropertyType", 7998 "Base64BinaryObjectPropertyType", 7999 "LocationType", 8000 "ExtractedFeaturesType", 8001 "ExtractedStringsType", 8002 "ExtractedStringType", 8003 "ImportsType", 8004 "FunctionsType", 8005 "CodeSnippetsType", 8006 "ByteRunsType", 8007 "ByteRunType", 8008 "HashListType", 8009 "HashValueType", 8010 "SimpleHashValueType", 8011 "FuzzyHashValueType", 8012 "FuzzyHashStructureType", 8013 "FuzzyHashBlockType", 8014 "HashSegmentsType", 8015 "HashSegmentType", 8016 "HashType", 8017 "StructuredTextType", 8018 "DataSegmentType", 8019 "DataSizeType", 8020 "PlatformSpecificationType", 8021 "PlatformIdentifierType", 8022 "MetadataType", 8023 "EnvironmentVariableListType", 8024 "EnvironmentVariableType", 8025 "DigitalSignaturesType", 8026 "DigitalSignatureInfoType", 8027 "PatternableFieldType", 8028 "ControlledVocabularyStringType", 8029 "DateWithPrecisionType", 8030 "DateTimeWithPrecisionType", 8031 "SIDType", 8032 "Layer4ProtocolType", 8033 "EndiannessType", 8034 "CipherType", 8035 "RegionalRegistryType" 8036 ] 8037