1# 2# Generated Thu Jun 11 18:44:25 2009 by generateDS.py. 3# 4 5import sys 6import getopt 7from xml.dom import minidom 8from xml.dom import Node 9 10# 11# User methods 12# 13# Calls to the methods in these classes are generated by generateDS.py. 14# You can replace these methods by re-implementing the following class 15# in a module named generatedssuper.py. 16 17try: 18 from generatedssuper import GeneratedsSuper 19except ImportError as exp: 20 21 class GeneratedsSuper: 22 def format_string(self, input_data, input_name=''): 23 return input_data 24 def format_integer(self, input_data, input_name=''): 25 return '%d' % input_data 26 def format_float(self, input_data, input_name=''): 27 return '%f' % input_data 28 def format_double(self, input_data, input_name=''): 29 return '%e' % input_data 30 def format_boolean(self, input_data, input_name=''): 31 return '%s' % input_data 32 33 34# 35# If you have installed IPython you can uncomment and use the following. 36# IPython is available from http://ipython.scipy.org/. 37# 38 39## from IPython.Shell import IPShellEmbed 40## args = '' 41## ipshell = IPShellEmbed(args, 42## banner = 'Dropping into IPython', 43## exit_msg = 'Leaving Interpreter, back to program.') 44 45# Then use the following line where and when you want to drop into the 46# IPython shell: 47# ipshell('<some message> -- Entering ipshell.\nHit Ctrl-D to exit') 48 49# 50# Globals 51# 52 53ExternalEncoding = 'ascii' 54 55# 56# Support/utility functions. 57# 58 59def showIndent(outfile, level): 60 for idx in range(level): 61 outfile.write(' ') 62 63def quote_xml(inStr): 64 s1 = (isinstance(inStr, basestring) and inStr or 65 '%s' % inStr) 66 s1 = s1.replace('&', '&') 67 s1 = s1.replace('<', '<') 68 s1 = s1.replace('>', '>') 69 return s1 70 71def quote_attrib(inStr): 72 s1 = (isinstance(inStr, basestring) and inStr or 73 '%s' % inStr) 74 s1 = s1.replace('&', '&') 75 s1 = s1.replace('<', '<') 76 s1 = s1.replace('>', '>') 77 if '"' in s1: 78 if "'" in s1: 79 s1 = '"%s"' % s1.replace('"', """) 80 else: 81 s1 = "'%s'" % s1 82 else: 83 s1 = '"%s"' % s1 84 return s1 85 86def quote_python(inStr): 87 s1 = inStr 88 if s1.find("'") == -1: 89 if s1.find('\n') == -1: 90 return "'%s'" % s1 91 else: 92 return "'''%s'''" % s1 93 else: 94 if s1.find('"') != -1: 95 s1 = s1.replace('"', '\\"') 96 if s1.find('\n') == -1: 97 return '"%s"' % s1 98 else: 99 return '"""%s"""' % s1 100 101 102class MixedContainer: 103 104 node_type = "mixedcontainer" 105 106 # Constants for category: 107 CategoryNone = 0 108 CategoryText = 1 109 CategorySimple = 2 110 CategoryComplex = 3 111 # Constants for content_type: 112 TypeNone = 0 113 TypeText = 1 114 TypeString = 2 115 TypeInteger = 3 116 TypeFloat = 4 117 TypeDecimal = 5 118 TypeDouble = 6 119 TypeBoolean = 7 120 def __init__(self, category, content_type, name, value): 121 self.category = category 122 self.content_type = content_type 123 self.name = name 124 self.value = value 125 def getCategory(self): 126 return self.category 127 def getContenttype(self, content_type): 128 return self.content_type 129 def getValue(self): 130 return self.value 131 def getName(self): 132 return self.name 133 134 135class _MemberSpec(object): 136 def __init__(self, name='', data_type='', container=0): 137 self.name = name 138 self.data_type = data_type 139 self.container = container 140 def set_name(self, name): self.name = name 141 def get_name(self): return self.name 142 def set_data_type(self, data_type): self.data_type = data_type 143 def get_data_type(self): return self.data_type 144 def set_container(self, container): self.container = container 145 def get_container(self): return self.container 146 147 148# 149# Data representation classes. 150# 151 152class DoxygenType(GeneratedsSuper): 153 subclass = None 154 superclass = None 155 def __init__(self, version=None, compounddef=None): 156 self.version = version 157 self.compounddef = compounddef 158 def factory(*args_, **kwargs_): 159 if DoxygenType.subclass: 160 return DoxygenType.subclass(*args_, **kwargs_) 161 else: 162 return DoxygenType(*args_, **kwargs_) 163 factory = staticmethod(factory) 164 def get_compounddef(self): return self.compounddef 165 def set_compounddef(self, compounddef): self.compounddef = compounddef 166 def get_version(self): return self.version 167 def set_version(self, version): self.version = version 168 def hasContent_(self): 169 if ( 170 self.compounddef is not None 171 ): 172 return True 173 else: 174 return False 175 def build(self, node_): 176 attrs = node_.attributes 177 self.buildAttributes(attrs) 178 for child_ in node_.childNodes: 179 nodeName_ = child_.nodeName.split(':')[-1] 180 self.buildChildren(child_, nodeName_) 181 def buildAttributes(self, attrs): 182 if attrs.get('version'): 183 self.version = attrs.get('version').value 184 def buildChildren(self, child_, nodeName_): 185 if child_.nodeType == Node.ELEMENT_NODE and \ 186 nodeName_ == 'compounddef': 187 obj_ = compounddefType.factory() 188 obj_.build(child_) 189 self.set_compounddef(obj_) 190# end class DoxygenType 191 192 193class compounddefType(GeneratedsSuper): 194 subclass = None 195 superclass = None 196 def __init__(self, kind=None, prot=None, id=None, compoundname=None, title=None, basecompoundref=None, derivedcompoundref=None, includes=None, includedby=None, incdepgraph=None, invincdepgraph=None, innerdir=None, innerfile=None, innerclass=None, innernamespace=None, innerpage=None, innergroup=None, templateparamlist=None, sectiondef=None, briefdescription=None, detaileddescription=None, inheritancegraph=None, collaborationgraph=None, programlisting=None, location=None, listofallmembers=None): 197 self.kind = kind 198 self.prot = prot 199 self.id = id 200 self.compoundname = compoundname 201 self.title = title 202 if basecompoundref is None: 203 self.basecompoundref = [] 204 else: 205 self.basecompoundref = basecompoundref 206 if derivedcompoundref is None: 207 self.derivedcompoundref = [] 208 else: 209 self.derivedcompoundref = derivedcompoundref 210 if includes is None: 211 self.includes = [] 212 else: 213 self.includes = includes 214 if includedby is None: 215 self.includedby = [] 216 else: 217 self.includedby = includedby 218 self.incdepgraph = incdepgraph 219 self.invincdepgraph = invincdepgraph 220 if innerdir is None: 221 self.innerdir = [] 222 else: 223 self.innerdir = innerdir 224 if innerfile is None: 225 self.innerfile = [] 226 else: 227 self.innerfile = innerfile 228 if innerclass is None: 229 self.innerclass = [] 230 else: 231 self.innerclass = innerclass 232 if innernamespace is None: 233 self.innernamespace = [] 234 else: 235 self.innernamespace = innernamespace 236 if innerpage is None: 237 self.innerpage = [] 238 else: 239 self.innerpage = innerpage 240 if innergroup is None: 241 self.innergroup = [] 242 else: 243 self.innergroup = innergroup 244 self.templateparamlist = templateparamlist 245 if sectiondef is None: 246 self.sectiondef = [] 247 else: 248 self.sectiondef = sectiondef 249 self.briefdescription = briefdescription 250 self.detaileddescription = detaileddescription 251 self.inheritancegraph = inheritancegraph 252 self.collaborationgraph = collaborationgraph 253 self.programlisting = programlisting 254 self.location = location 255 self.listofallmembers = listofallmembers 256 self.namespaces = [] 257 def factory(*args_, **kwargs_): 258 if compounddefType.subclass: 259 return compounddefType.subclass(*args_, **kwargs_) 260 else: 261 return compounddefType(*args_, **kwargs_) 262 factory = staticmethod(factory) 263 def get_compoundname(self): return self.compoundname 264 def set_compoundname(self, compoundname): self.compoundname = compoundname 265 def get_title(self): return self.title 266 def set_title(self, title): self.title = title 267 def get_basecompoundref(self): return self.basecompoundref 268 def set_basecompoundref(self, basecompoundref): self.basecompoundref = basecompoundref 269 def add_basecompoundref(self, value): self.basecompoundref.append(value) 270 def insert_basecompoundref(self, index, value): self.basecompoundref[index] = value 271 def get_derivedcompoundref(self): return self.derivedcompoundref 272 def set_derivedcompoundref(self, derivedcompoundref): self.derivedcompoundref = derivedcompoundref 273 def add_derivedcompoundref(self, value): self.derivedcompoundref.append(value) 274 def insert_derivedcompoundref(self, index, value): self.derivedcompoundref[index] = value 275 def get_includes(self): return self.includes 276 def set_includes(self, includes): self.includes = includes 277 def add_includes(self, value): self.includes.append(value) 278 def insert_includes(self, index, value): self.includes[index] = value 279 def get_includedby(self): return self.includedby 280 def set_includedby(self, includedby): self.includedby = includedby 281 def add_includedby(self, value): self.includedby.append(value) 282 def insert_includedby(self, index, value): self.includedby[index] = value 283 def get_incdepgraph(self): return self.incdepgraph 284 def set_incdepgraph(self, incdepgraph): self.incdepgraph = incdepgraph 285 def get_invincdepgraph(self): return self.invincdepgraph 286 def set_invincdepgraph(self, invincdepgraph): self.invincdepgraph = invincdepgraph 287 def get_innerdir(self): return self.innerdir 288 def set_innerdir(self, innerdir): self.innerdir = innerdir 289 def add_innerdir(self, value): self.innerdir.append(value) 290 def insert_innerdir(self, index, value): self.innerdir[index] = value 291 def get_innerfile(self): return self.innerfile 292 def set_innerfile(self, innerfile): self.innerfile = innerfile 293 def add_innerfile(self, value): self.innerfile.append(value) 294 def insert_innerfile(self, index, value): self.innerfile[index] = value 295 def get_innerclass(self): return self.innerclass 296 def set_innerclass(self, innerclass): self.innerclass = innerclass 297 def add_innerclass(self, value): self.innerclass.append(value) 298 def insert_innerclass(self, index, value): self.innerclass[index] = value 299 def get_innernamespace(self): return self.innernamespace 300 def set_innernamespace(self, innernamespace): self.innernamespace = innernamespace 301 def add_innernamespace(self, value): self.innernamespace.append(value) 302 def insert_innernamespace(self, index, value): self.innernamespace[index] = value 303 def get_innerpage(self): return self.innerpage 304 def set_innerpage(self, innerpage): self.innerpage = innerpage 305 def add_innerpage(self, value): self.innerpage.append(value) 306 def insert_innerpage(self, index, value): self.innerpage[index] = value 307 def get_innergroup(self): return self.innergroup 308 def set_innergroup(self, innergroup): self.innergroup = innergroup 309 def add_innergroup(self, value): self.innergroup.append(value) 310 def insert_innergroup(self, index, value): self.innergroup[index] = value 311 def get_templateparamlist(self): return self.templateparamlist 312 def set_templateparamlist(self, templateparamlist): self.templateparamlist = templateparamlist 313 def get_sectiondef(self): return self.sectiondef 314 def set_sectiondef(self, sectiondef): self.sectiondef = sectiondef 315 def add_sectiondef(self, value): self.sectiondef.append(value) 316 def insert_sectiondef(self, index, value): self.sectiondef[index] = value 317 def get_briefdescription(self): return self.briefdescription 318 def set_briefdescription(self, briefdescription): self.briefdescription = briefdescription 319 def get_detaileddescription(self): return self.detaileddescription 320 def set_detaileddescription(self, detaileddescription): self.detaileddescription = detaileddescription 321 def get_inheritancegraph(self): return self.inheritancegraph 322 def set_inheritancegraph(self, inheritancegraph): self.inheritancegraph = inheritancegraph 323 def get_collaborationgraph(self): return self.collaborationgraph 324 def set_collaborationgraph(self, collaborationgraph): self.collaborationgraph = collaborationgraph 325 def get_programlisting(self): return self.programlisting 326 def set_programlisting(self, programlisting): self.programlisting = programlisting 327 def get_location(self): return self.location 328 def set_location(self, location): self.location = location 329 def get_listofallmembers(self): return self.listofallmembers 330 def set_listofallmembers(self, listofallmembers): self.listofallmembers = listofallmembers 331 def get_kind(self): return self.kind 332 def set_kind(self, kind): self.kind = kind 333 def get_prot(self): return self.prot 334 def set_prot(self, prot): self.prot = prot 335 def get_id(self): return self.id 336 def set_id(self, id): self.id = id 337 def hasContent_(self): 338 if ( 339 self.compoundname is not None or 340 self.title is not None or 341 self.basecompoundref is not None or 342 self.derivedcompoundref is not None or 343 self.includes is not None or 344 self.includedby is not None or 345 self.incdepgraph is not None or 346 self.invincdepgraph is not None or 347 self.innerdir is not None or 348 self.innerfile is not None or 349 self.innerclass is not None or 350 self.innernamespace is not None or 351 self.innerpage is not None or 352 self.innergroup is not None or 353 self.templateparamlist is not None or 354 self.sectiondef is not None or 355 self.briefdescription is not None or 356 self.detaileddescription is not None or 357 self.inheritancegraph is not None or 358 self.collaborationgraph is not None or 359 self.programlisting is not None or 360 self.location is not None or 361 self.listofallmembers is not None 362 ): 363 return True 364 else: 365 return False 366 def build(self, node_): 367 attrs = node_.attributes 368 self.buildAttributes(attrs) 369 for child_ in node_.childNodes: 370 nodeName_ = child_.nodeName.split(':')[-1] 371 self.buildChildren(child_, nodeName_) 372 def buildAttributes(self, attrs): 373 if attrs.get('kind'): 374 self.kind = attrs.get('kind').value 375 if attrs.get('prot'): 376 self.prot = attrs.get('prot').value 377 if attrs.get('id'): 378 self.id = attrs.get('id').value 379 def buildChildren(self, child_, nodeName_): 380 if child_.nodeType == Node.ELEMENT_NODE and \ 381 nodeName_ == 'compoundname': 382 compoundname_ = '' 383 for text__content_ in child_.childNodes: 384 compoundname_ += text__content_.nodeValue 385 self.compoundname = compoundname_ 386 elif child_.nodeType == Node.ELEMENT_NODE and \ 387 nodeName_ == 'title': 388 obj_ = docTitleType.factory() 389 obj_.build(child_) 390 self.set_title(obj_) 391 elif child_.nodeType == Node.ELEMENT_NODE and \ 392 nodeName_ == 'basecompoundref': 393 obj_ = compoundRefType.factory() 394 obj_.build(child_) 395 self.basecompoundref.append(obj_) 396 elif child_.nodeType == Node.ELEMENT_NODE and \ 397 nodeName_ == 'derivedcompoundref': 398 obj_ = compoundRefType.factory() 399 obj_.build(child_) 400 self.derivedcompoundref.append(obj_) 401 elif child_.nodeType == Node.ELEMENT_NODE and \ 402 nodeName_ == 'includes': 403 obj_ = incType.factory() 404 obj_.build(child_) 405 self.includes.append(obj_) 406 elif child_.nodeType == Node.ELEMENT_NODE and \ 407 nodeName_ == 'includedby': 408 obj_ = incType.factory() 409 obj_.build(child_) 410 self.includedby.append(obj_) 411 elif child_.nodeType == Node.ELEMENT_NODE and \ 412 nodeName_ == 'incdepgraph': 413 obj_ = graphType.factory() 414 obj_.build(child_) 415 self.set_incdepgraph(obj_) 416 elif child_.nodeType == Node.ELEMENT_NODE and \ 417 nodeName_ == 'invincdepgraph': 418 obj_ = graphType.factory() 419 obj_.build(child_) 420 self.set_invincdepgraph(obj_) 421 elif child_.nodeType == Node.ELEMENT_NODE and \ 422 nodeName_ == 'innerdir': 423 obj_ = refType.factory(nodeName_) 424 obj_.build(child_) 425 self.innerdir.append(obj_) 426 elif child_.nodeType == Node.ELEMENT_NODE and \ 427 nodeName_ == 'innerfile': 428 obj_ = refType.factory(nodeName_) 429 obj_.build(child_) 430 self.innerfile.append(obj_) 431 elif child_.nodeType == Node.ELEMENT_NODE and \ 432 nodeName_ == 'innerclass': 433 obj_ = refType.factory(nodeName_) 434 obj_.build(child_) 435 self.innerclass.append(obj_) 436 self.namespaces.append(obj_.content_[0].getValue()) 437 elif child_.nodeType == Node.ELEMENT_NODE and \ 438 nodeName_ == 'innernamespace': 439 obj_ = refType.factory(nodeName_) 440 obj_.build(child_) 441 self.innernamespace.append(obj_) 442 self.namespaces.append(obj_.content_[0].getValue()) 443 elif child_.nodeType == Node.ELEMENT_NODE and \ 444 nodeName_ == 'innerpage': 445 obj_ = refType.factory(nodeName_) 446 obj_.build(child_) 447 self.innerpage.append(obj_) 448 elif child_.nodeType == Node.ELEMENT_NODE and \ 449 nodeName_ == 'innergroup': 450 obj_ = refType.factory(nodeName_) 451 obj_.build(child_) 452 self.innergroup.append(obj_) 453 elif child_.nodeType == Node.ELEMENT_NODE and \ 454 nodeName_ == 'templateparamlist': 455 obj_ = templateparamlistType.factory() 456 obj_.build(child_) 457 self.set_templateparamlist(obj_) 458 elif child_.nodeType == Node.ELEMENT_NODE and \ 459 nodeName_ == 'sectiondef': 460 obj_ = sectiondefType.factory() 461 obj_.build(child_) 462 self.sectiondef.append(obj_) 463 elif child_.nodeType == Node.ELEMENT_NODE and \ 464 nodeName_ == 'briefdescription': 465 obj_ = descriptionType.factory() 466 obj_.build(child_) 467 self.set_briefdescription(obj_) 468 elif child_.nodeType == Node.ELEMENT_NODE and \ 469 nodeName_ == 'detaileddescription': 470 obj_ = descriptionType.factory() 471 obj_.build(child_) 472 self.set_detaileddescription(obj_) 473 elif child_.nodeType == Node.ELEMENT_NODE and \ 474 nodeName_ == 'inheritancegraph': 475 obj_ = graphType.factory() 476 obj_.build(child_) 477 self.set_inheritancegraph(obj_) 478 elif child_.nodeType == Node.ELEMENT_NODE and \ 479 nodeName_ == 'collaborationgraph': 480 obj_ = graphType.factory() 481 obj_.build(child_) 482 self.set_collaborationgraph(obj_) 483 elif child_.nodeType == Node.ELEMENT_NODE and \ 484 nodeName_ == 'programlisting': 485 obj_ = listingType.factory() 486 obj_.build(child_) 487 self.set_programlisting(obj_) 488 elif child_.nodeType == Node.ELEMENT_NODE and \ 489 nodeName_ == 'location': 490 obj_ = locationType.factory() 491 obj_.build(child_) 492 self.set_location(obj_) 493 elif child_.nodeType == Node.ELEMENT_NODE and \ 494 nodeName_ == 'listofallmembers': 495 obj_ = listofallmembersType.factory() 496 obj_.build(child_) 497 self.set_listofallmembers(obj_) 498# end class compounddefType 499 500 501class listofallmembersType(GeneratedsSuper): 502 subclass = None 503 superclass = None 504 def __init__(self, member=None): 505 if member is None: 506 self.member = [] 507 else: 508 self.member = member 509 def factory(*args_, **kwargs_): 510 if listofallmembersType.subclass: 511 return listofallmembersType.subclass(*args_, **kwargs_) 512 else: 513 return listofallmembersType(*args_, **kwargs_) 514 factory = staticmethod(factory) 515 def get_member(self): return self.member 516 def set_member(self, member): self.member = member 517 def add_member(self, value): self.member.append(value) 518 def insert_member(self, index, value): self.member[index] = value 519 def hasContent_(self): 520 if ( 521 self.member is not None 522 ): 523 return True 524 else: 525 return False 526 def build(self, node_): 527 attrs = node_.attributes 528 self.buildAttributes(attrs) 529 for child_ in node_.childNodes: 530 nodeName_ = child_.nodeName.split(':')[-1] 531 self.buildChildren(child_, nodeName_) 532 def buildAttributes(self, attrs): 533 pass 534 def buildChildren(self, child_, nodeName_): 535 if child_.nodeType == Node.ELEMENT_NODE and \ 536 nodeName_ == 'member': 537 obj_ = memberRefType.factory() 538 obj_.build(child_) 539 self.member.append(obj_) 540# end class listofallmembersType 541 542 543class memberRefType(GeneratedsSuper): 544 subclass = None 545 superclass = None 546 def __init__(self, virt=None, prot=None, refid=None, ambiguityscope=None, scope=None, name=None): 547 self.virt = virt 548 self.prot = prot 549 self.refid = refid 550 self.ambiguityscope = ambiguityscope 551 self.scope = scope 552 self.name = name 553 def factory(*args_, **kwargs_): 554 if memberRefType.subclass: 555 return memberRefType.subclass(*args_, **kwargs_) 556 else: 557 return memberRefType(*args_, **kwargs_) 558 factory = staticmethod(factory) 559 def get_scope(self): return self.scope 560 def set_scope(self, scope): self.scope = scope 561 def get_name(self): return self.name 562 def set_name(self, name): self.name = name 563 def get_virt(self): return self.virt 564 def set_virt(self, virt): self.virt = virt 565 def get_prot(self): return self.prot 566 def set_prot(self, prot): self.prot = prot 567 def get_refid(self): return self.refid 568 def set_refid(self, refid): self.refid = refid 569 def get_ambiguityscope(self): return self.ambiguityscope 570 def set_ambiguityscope(self, ambiguityscope): self.ambiguityscope = ambiguityscope 571 def hasContent_(self): 572 if ( 573 self.scope is not None or 574 self.name is not None 575 ): 576 return True 577 else: 578 return False 579 def build(self, node_): 580 attrs = node_.attributes 581 self.buildAttributes(attrs) 582 for child_ in node_.childNodes: 583 nodeName_ = child_.nodeName.split(':')[-1] 584 self.buildChildren(child_, nodeName_) 585 def buildAttributes(self, attrs): 586 if attrs.get('virt'): 587 self.virt = attrs.get('virt').value 588 if attrs.get('prot'): 589 self.prot = attrs.get('prot').value 590 if attrs.get('refid'): 591 self.refid = attrs.get('refid').value 592 if attrs.get('ambiguityscope'): 593 self.ambiguityscope = attrs.get('ambiguityscope').value 594 def buildChildren(self, child_, nodeName_): 595 if child_.nodeType == Node.ELEMENT_NODE and \ 596 nodeName_ == 'scope': 597 scope_ = '' 598 for text__content_ in child_.childNodes: 599 scope_ += text__content_.nodeValue 600 self.scope = scope_ 601 elif child_.nodeType == Node.ELEMENT_NODE and \ 602 nodeName_ == 'name': 603 name_ = '' 604 for text__content_ in child_.childNodes: 605 name_ += text__content_.nodeValue 606 self.name = name_ 607# end class memberRefType 608 609 610class scope(GeneratedsSuper): 611 subclass = None 612 superclass = None 613 def __init__(self, valueOf_=''): 614 self.valueOf_ = valueOf_ 615 def factory(*args_, **kwargs_): 616 if scope.subclass: 617 return scope.subclass(*args_, **kwargs_) 618 else: 619 return scope(*args_, **kwargs_) 620 factory = staticmethod(factory) 621 def getValueOf_(self): return self.valueOf_ 622 def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ 623 def hasContent_(self): 624 if ( 625 self.valueOf_ is not None 626 ): 627 return True 628 else: 629 return False 630 def build(self, node_): 631 attrs = node_.attributes 632 self.buildAttributes(attrs) 633 self.valueOf_ = '' 634 for child_ in node_.childNodes: 635 nodeName_ = child_.nodeName.split(':')[-1] 636 self.buildChildren(child_, nodeName_) 637 def buildAttributes(self, attrs): 638 pass 639 def buildChildren(self, child_, nodeName_): 640 if child_.nodeType == Node.TEXT_NODE: 641 self.valueOf_ += child_.nodeValue 642 elif child_.nodeType == Node.CDATA_SECTION_NODE: 643 self.valueOf_ += '![CDATA['+child_.nodeValue+']]' 644# end class scope 645 646 647class name(GeneratedsSuper): 648 subclass = None 649 superclass = None 650 def __init__(self, valueOf_=''): 651 self.valueOf_ = valueOf_ 652 def factory(*args_, **kwargs_): 653 if name.subclass: 654 return name.subclass(*args_, **kwargs_) 655 else: 656 return name(*args_, **kwargs_) 657 factory = staticmethod(factory) 658 def getValueOf_(self): return self.valueOf_ 659 def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ 660 def hasContent_(self): 661 if ( 662 self.valueOf_ is not None 663 ): 664 return True 665 else: 666 return False 667 def build(self, node_): 668 attrs = node_.attributes 669 self.buildAttributes(attrs) 670 self.valueOf_ = '' 671 for child_ in node_.childNodes: 672 nodeName_ = child_.nodeName.split(':')[-1] 673 self.buildChildren(child_, nodeName_) 674 def buildAttributes(self, attrs): 675 pass 676 def buildChildren(self, child_, nodeName_): 677 if child_.nodeType == Node.TEXT_NODE: 678 self.valueOf_ += child_.nodeValue 679 elif child_.nodeType == Node.CDATA_SECTION_NODE: 680 self.valueOf_ += '![CDATA['+child_.nodeValue+']]' 681# end class name 682 683 684class compoundRefType(GeneratedsSuper): 685 subclass = None 686 superclass = None 687 def __init__(self, virt=None, prot=None, refid=None, valueOf_='', mixedclass_=None, content_=None): 688 self.virt = virt 689 self.prot = prot 690 self.refid = refid 691 if mixedclass_ is None: 692 self.mixedclass_ = MixedContainer 693 else: 694 self.mixedclass_ = mixedclass_ 695 if content_ is None: 696 self.content_ = [] 697 else: 698 self.content_ = content_ 699 def factory(*args_, **kwargs_): 700 if compoundRefType.subclass: 701 return compoundRefType.subclass(*args_, **kwargs_) 702 else: 703 return compoundRefType(*args_, **kwargs_) 704 factory = staticmethod(factory) 705 def get_virt(self): return self.virt 706 def set_virt(self, virt): self.virt = virt 707 def get_prot(self): return self.prot 708 def set_prot(self, prot): self.prot = prot 709 def get_refid(self): return self.refid 710 def set_refid(self, refid): self.refid = refid 711 def getValueOf_(self): return self.valueOf_ 712 def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ 713 def hasContent_(self): 714 if ( 715 self.valueOf_ is not None 716 ): 717 return True 718 else: 719 return False 720 def build(self, node_): 721 attrs = node_.attributes 722 self.buildAttributes(attrs) 723 self.valueOf_ = '' 724 for child_ in node_.childNodes: 725 nodeName_ = child_.nodeName.split(':')[-1] 726 self.buildChildren(child_, nodeName_) 727 def buildAttributes(self, attrs): 728 if attrs.get('virt'): 729 self.virt = attrs.get('virt').value 730 if attrs.get('prot'): 731 self.prot = attrs.get('prot').value 732 if attrs.get('refid'): 733 self.refid = attrs.get('refid').value 734 def buildChildren(self, child_, nodeName_): 735 if child_.nodeType == Node.TEXT_NODE: 736 obj_ = self.mixedclass_(MixedContainer.CategoryText, 737 MixedContainer.TypeNone, '', child_.nodeValue) 738 self.content_.append(obj_) 739 if child_.nodeType == Node.TEXT_NODE: 740 self.valueOf_ += child_.nodeValue 741 elif child_.nodeType == Node.CDATA_SECTION_NODE: 742 self.valueOf_ += '![CDATA['+child_.nodeValue+']]' 743# end class compoundRefType 744 745 746class reimplementType(GeneratedsSuper): 747 subclass = None 748 superclass = None 749 def __init__(self, refid=None, valueOf_='', mixedclass_=None, content_=None): 750 self.refid = refid 751 if mixedclass_ is None: 752 self.mixedclass_ = MixedContainer 753 else: 754 self.mixedclass_ = mixedclass_ 755 if content_ is None: 756 self.content_ = [] 757 else: 758 self.content_ = content_ 759 def factory(*args_, **kwargs_): 760 if reimplementType.subclass: 761 return reimplementType.subclass(*args_, **kwargs_) 762 else: 763 return reimplementType(*args_, **kwargs_) 764 factory = staticmethod(factory) 765 def get_refid(self): return self.refid 766 def set_refid(self, refid): self.refid = refid 767 def getValueOf_(self): return self.valueOf_ 768 def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ 769 def hasContent_(self): 770 if ( 771 self.valueOf_ is not None 772 ): 773 return True 774 else: 775 return False 776 def build(self, node_): 777 attrs = node_.attributes 778 self.buildAttributes(attrs) 779 self.valueOf_ = '' 780 for child_ in node_.childNodes: 781 nodeName_ = child_.nodeName.split(':')[-1] 782 self.buildChildren(child_, nodeName_) 783 def buildAttributes(self, attrs): 784 if attrs.get('refid'): 785 self.refid = attrs.get('refid').value 786 def buildChildren(self, child_, nodeName_): 787 if child_.nodeType == Node.TEXT_NODE: 788 obj_ = self.mixedclass_(MixedContainer.CategoryText, 789 MixedContainer.TypeNone, '', child_.nodeValue) 790 self.content_.append(obj_) 791 if child_.nodeType == Node.TEXT_NODE: 792 self.valueOf_ += child_.nodeValue 793 elif child_.nodeType == Node.CDATA_SECTION_NODE: 794 self.valueOf_ += '![CDATA['+child_.nodeValue+']]' 795# end class reimplementType 796 797 798class incType(GeneratedsSuper): 799 subclass = None 800 superclass = None 801 def __init__(self, local=None, refid=None, valueOf_='', mixedclass_=None, content_=None): 802 self.local = local 803 self.refid = refid 804 if mixedclass_ is None: 805 self.mixedclass_ = MixedContainer 806 else: 807 self.mixedclass_ = mixedclass_ 808 if content_ is None: 809 self.content_ = [] 810 else: 811 self.content_ = content_ 812 def factory(*args_, **kwargs_): 813 if incType.subclass: 814 return incType.subclass(*args_, **kwargs_) 815 else: 816 return incType(*args_, **kwargs_) 817 factory = staticmethod(factory) 818 def get_local(self): return self.local 819 def set_local(self, local): self.local = local 820 def get_refid(self): return self.refid 821 def set_refid(self, refid): self.refid = refid 822 def getValueOf_(self): return self.valueOf_ 823 def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ 824 def hasContent_(self): 825 if ( 826 self.valueOf_ is not None 827 ): 828 return True 829 else: 830 return False 831 def build(self, node_): 832 attrs = node_.attributes 833 self.buildAttributes(attrs) 834 self.valueOf_ = '' 835 for child_ in node_.childNodes: 836 nodeName_ = child_.nodeName.split(':')[-1] 837 self.buildChildren(child_, nodeName_) 838 def buildAttributes(self, attrs): 839 if attrs.get('local'): 840 self.local = attrs.get('local').value 841 if attrs.get('refid'): 842 self.refid = attrs.get('refid').value 843 def buildChildren(self, child_, nodeName_): 844 if child_.nodeType == Node.TEXT_NODE: 845 obj_ = self.mixedclass_(MixedContainer.CategoryText, 846 MixedContainer.TypeNone, '', child_.nodeValue) 847 self.content_.append(obj_) 848 if child_.nodeType == Node.TEXT_NODE: 849 self.valueOf_ += child_.nodeValue 850 elif child_.nodeType == Node.CDATA_SECTION_NODE: 851 self.valueOf_ += '![CDATA['+child_.nodeValue+']]' 852# end class incType 853 854 855class refType(GeneratedsSuper): 856 subclass = None 857 superclass = None 858 def __init__(self, prot=None, refid=None, valueOf_='', mixedclass_=None, content_=None): 859 self.prot = prot 860 self.refid = refid 861 if mixedclass_ is None: 862 self.mixedclass_ = MixedContainer 863 else: 864 self.mixedclass_ = mixedclass_ 865 if content_ is None: 866 self.content_ = [] 867 else: 868 self.content_ = content_ 869 def factory(*args_, **kwargs_): 870 if refType.subclass: 871 return refType.subclass(*args_, **kwargs_) 872 else: 873 return refType(*args_, **kwargs_) 874 factory = staticmethod(factory) 875 def get_prot(self): return self.prot 876 def set_prot(self, prot): self.prot = prot 877 def get_refid(self): return self.refid 878 def set_refid(self, refid): self.refid = refid 879 def getValueOf_(self): return self.valueOf_ 880 def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ 881 def hasContent_(self): 882 if ( 883 self.valueOf_ is not None 884 ): 885 return True 886 else: 887 return False 888 def build(self, node_): 889 attrs = node_.attributes 890 self.buildAttributes(attrs) 891 self.valueOf_ = '' 892 for child_ in node_.childNodes: 893 nodeName_ = child_.nodeName.split(':')[-1] 894 self.buildChildren(child_, nodeName_) 895 def buildAttributes(self, attrs): 896 if attrs.get('prot'): 897 self.prot = attrs.get('prot').value 898 if attrs.get('refid'): 899 self.refid = attrs.get('refid').value 900 def buildChildren(self, child_, nodeName_): 901 if child_.nodeType == Node.TEXT_NODE: 902 obj_ = self.mixedclass_(MixedContainer.CategoryText, 903 MixedContainer.TypeNone, '', child_.nodeValue) 904 self.content_.append(obj_) 905 if child_.nodeType == Node.TEXT_NODE: 906 self.valueOf_ += child_.nodeValue 907 elif child_.nodeType == Node.CDATA_SECTION_NODE: 908 self.valueOf_ += '![CDATA['+child_.nodeValue+']]' 909# end class refType 910 911 912class refTextType(GeneratedsSuper): 913 subclass = None 914 superclass = None 915 def __init__(self, refid=None, kindref=None, external=None, valueOf_='', mixedclass_=None, content_=None): 916 self.refid = refid 917 self.kindref = kindref 918 self.external = external 919 if mixedclass_ is None: 920 self.mixedclass_ = MixedContainer 921 else: 922 self.mixedclass_ = mixedclass_ 923 if content_ is None: 924 self.content_ = [] 925 else: 926 self.content_ = content_ 927 def factory(*args_, **kwargs_): 928 if refTextType.subclass: 929 return refTextType.subclass(*args_, **kwargs_) 930 else: 931 return refTextType(*args_, **kwargs_) 932 factory = staticmethod(factory) 933 def get_refid(self): return self.refid 934 def set_refid(self, refid): self.refid = refid 935 def get_kindref(self): return self.kindref 936 def set_kindref(self, kindref): self.kindref = kindref 937 def get_external(self): return self.external 938 def set_external(self, external): self.external = external 939 def getValueOf_(self): return self.valueOf_ 940 def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ 941 def hasContent_(self): 942 if ( 943 self.valueOf_ is not None 944 ): 945 return True 946 else: 947 return False 948 def build(self, node_): 949 attrs = node_.attributes 950 self.buildAttributes(attrs) 951 self.valueOf_ = '' 952 for child_ in node_.childNodes: 953 nodeName_ = child_.nodeName.split(':')[-1] 954 self.buildChildren(child_, nodeName_) 955 def buildAttributes(self, attrs): 956 if attrs.get('refid'): 957 self.refid = attrs.get('refid').value 958 if attrs.get('kindref'): 959 self.kindref = attrs.get('kindref').value 960 if attrs.get('external'): 961 self.external = attrs.get('external').value 962 def buildChildren(self, child_, nodeName_): 963 if child_.nodeType == Node.TEXT_NODE: 964 obj_ = self.mixedclass_(MixedContainer.CategoryText, 965 MixedContainer.TypeNone, '', child_.nodeValue) 966 self.content_.append(obj_) 967 if child_.nodeType == Node.TEXT_NODE: 968 self.valueOf_ += child_.nodeValue 969 elif child_.nodeType == Node.CDATA_SECTION_NODE: 970 self.valueOf_ += '![CDATA['+child_.nodeValue+']]' 971# end class refTextType 972 973 974class sectiondefType(GeneratedsSuper): 975 subclass = None 976 superclass = None 977 def __init__(self, kind=None, header=None, description=None, memberdef=None): 978 self.kind = kind 979 self.header = header 980 self.description = description 981 if memberdef is None: 982 self.memberdef = [] 983 else: 984 self.memberdef = memberdef 985 def factory(*args_, **kwargs_): 986 if sectiondefType.subclass: 987 return sectiondefType.subclass(*args_, **kwargs_) 988 else: 989 return sectiondefType(*args_, **kwargs_) 990 factory = staticmethod(factory) 991 def get_header(self): return self.header 992 def set_header(self, header): self.header = header 993 def get_description(self): return self.description 994 def set_description(self, description): self.description = description 995 def get_memberdef(self): return self.memberdef 996 def set_memberdef(self, memberdef): self.memberdef = memberdef 997 def add_memberdef(self, value): self.memberdef.append(value) 998 def insert_memberdef(self, index, value): self.memberdef[index] = value 999 def get_kind(self): return self.kind 1000 def set_kind(self, kind): self.kind = kind 1001 def hasContent_(self): 1002 if ( 1003 self.header is not None or 1004 self.description is not None or 1005 self.memberdef is not None 1006 ): 1007 return True 1008 else: 1009 return False 1010 def build(self, node_): 1011 attrs = node_.attributes 1012 self.buildAttributes(attrs) 1013 for child_ in node_.childNodes: 1014 nodeName_ = child_.nodeName.split(':')[-1] 1015 self.buildChildren(child_, nodeName_) 1016 def buildAttributes(self, attrs): 1017 if attrs.get('kind'): 1018 self.kind = attrs.get('kind').value 1019 def buildChildren(self, child_, nodeName_): 1020 if child_.nodeType == Node.ELEMENT_NODE and \ 1021 nodeName_ == 'header': 1022 header_ = '' 1023 for text__content_ in child_.childNodes: 1024 header_ += text__content_.nodeValue 1025 self.header = header_ 1026 elif child_.nodeType == Node.ELEMENT_NODE and \ 1027 nodeName_ == 'description': 1028 obj_ = descriptionType.factory() 1029 obj_.build(child_) 1030 self.set_description(obj_) 1031 elif child_.nodeType == Node.ELEMENT_NODE and \ 1032 nodeName_ == 'memberdef': 1033 obj_ = memberdefType.factory() 1034 obj_.build(child_) 1035 self.memberdef.append(obj_) 1036# end class sectiondefType 1037 1038 1039class memberdefType(GeneratedsSuper): 1040 subclass = None 1041 superclass = None 1042 def __init__(self, initonly=None, kind=None, volatile=None, const=None, raisexx=None, virt=None, readable=None, prot=None, explicit=None, new=None, final=None, writable=None, add=None, static=None, remove=None, sealed=None, mutable=None, gettable=None, inline=None, settable=None, id=None, templateparamlist=None, type_=None, definition=None, argsstring=None, name=None, read=None, write=None, bitfield=None, reimplements=None, reimplementedby=None, param=None, enumvalue=None, initializer=None, exceptions=None, briefdescription=None, detaileddescription=None, inbodydescription=None, location=None, references=None, referencedby=None, refqual=None): 1043 self.initonly = initonly 1044 self.kind = kind 1045 self.volatile = volatile 1046 self.const = const 1047 self.raisexx = raisexx 1048 self.virt = virt 1049 self.readable = readable 1050 self.prot = prot 1051 self.explicit = explicit 1052 self.new = new 1053 self.final = final 1054 self.writable = writable 1055 self.add = add 1056 self.static = static 1057 self.remove = remove 1058 self.sealed = sealed 1059 self.mutable = mutable 1060 self.gettable = gettable 1061 self.inline = inline 1062 self.settable = settable 1063 self.id = id 1064 self.templateparamlist = templateparamlist 1065 self.type_ = type_ 1066 self.definition = definition 1067 self.argsstring = argsstring 1068 self.name = name 1069 self.read = read 1070 self.write = write 1071 self.bitfield = bitfield 1072 if reimplements is None: 1073 self.reimplements = [] 1074 else: 1075 self.reimplements = reimplements 1076 if reimplementedby is None: 1077 self.reimplementedby = [] 1078 else: 1079 self.reimplementedby = reimplementedby 1080 if param is None: 1081 self.param = [] 1082 else: 1083 self.param = param 1084 if enumvalue is None: 1085 self.enumvalue = [] 1086 else: 1087 self.enumvalue = enumvalue 1088 self.initializer = initializer 1089 self.exceptions = exceptions 1090 self.briefdescription = briefdescription 1091 self.detaileddescription = detaileddescription 1092 self.inbodydescription = inbodydescription 1093 self.location = location 1094 if references is None: 1095 self.references = [] 1096 else: 1097 self.references = references 1098 if referencedby is None: 1099 self.referencedby = [] 1100 else: 1101 self.referencedby = referencedby 1102 self.refqual = refqual 1103 def factory(*args_, **kwargs_): 1104 if memberdefType.subclass: 1105 return memberdefType.subclass(*args_, **kwargs_) 1106 else: 1107 return memberdefType(*args_, **kwargs_) 1108 factory = staticmethod(factory) 1109 def get_templateparamlist(self): return self.templateparamlist 1110 def set_templateparamlist(self, templateparamlist): self.templateparamlist = templateparamlist 1111 def get_type(self): return self.type_ 1112 def set_type(self, type_): self.type_ = type_ 1113 def get_definition(self): return self.definition 1114 def set_definition(self, definition): self.definition = definition 1115 def get_argsstring(self): return self.argsstring 1116 def set_argsstring(self, argsstring): self.argsstring = argsstring 1117 def get_name(self): return self.name 1118 def set_name(self, name): self.name = name 1119 def get_read(self): return self.read 1120 def set_read(self, read): self.read = read 1121 def get_write(self): return self.write 1122 def set_write(self, write): self.write = write 1123 def get_bitfield(self): return self.bitfield 1124 def set_bitfield(self, bitfield): self.bitfield = bitfield 1125 def get_reimplements(self): return self.reimplements 1126 def set_reimplements(self, reimplements): self.reimplements = reimplements 1127 def add_reimplements(self, value): self.reimplements.append(value) 1128 def insert_reimplements(self, index, value): self.reimplements[index] = value 1129 def get_reimplementedby(self): return self.reimplementedby 1130 def set_reimplementedby(self, reimplementedby): self.reimplementedby = reimplementedby 1131 def add_reimplementedby(self, value): self.reimplementedby.append(value) 1132 def insert_reimplementedby(self, index, value): self.reimplementedby[index] = value 1133 def get_param(self): return self.param 1134 def set_param(self, param): self.param = param 1135 def add_param(self, value): self.param.append(value) 1136 def insert_param(self, index, value): self.param[index] = value 1137 def get_enumvalue(self): return self.enumvalue 1138 def set_enumvalue(self, enumvalue): self.enumvalue = enumvalue 1139 def add_enumvalue(self, value): self.enumvalue.append(value) 1140 def insert_enumvalue(self, index, value): self.enumvalue[index] = value 1141 def get_initializer(self): return self.initializer 1142 def set_initializer(self, initializer): self.initializer = initializer 1143 def get_exceptions(self): return self.exceptions 1144 def set_exceptions(self, exceptions): self.exceptions = exceptions 1145 def get_briefdescription(self): return self.briefdescription 1146 def set_briefdescription(self, briefdescription): self.briefdescription = briefdescription 1147 def get_detaileddescription(self): return self.detaileddescription 1148 def set_detaileddescription(self, detaileddescription): self.detaileddescription = detaileddescription 1149 def get_inbodydescription(self): return self.inbodydescription 1150 def set_inbodydescription(self, inbodydescription): self.inbodydescription = inbodydescription 1151 def get_location(self): return self.location 1152 def set_location(self, location): self.location = location 1153 def get_references(self): return self.references 1154 def set_references(self, references): self.references = references 1155 def add_references(self, value): self.references.append(value) 1156 def insert_references(self, index, value): self.references[index] = value 1157 def get_referencedby(self): return self.referencedby 1158 def set_referencedby(self, referencedby): self.referencedby = referencedby 1159 def add_referencedby(self, value): self.referencedby.append(value) 1160 def insert_referencedby(self, index, value): self.referencedby[index] = value 1161 def get_initonly(self): return self.initonly 1162 def set_initonly(self, initonly): self.initonly = initonly 1163 def get_kind(self): return self.kind 1164 def set_kind(self, kind): self.kind = kind 1165 def get_volatile(self): return self.volatile 1166 def set_volatile(self, volatile): self.volatile = volatile 1167 def get_const(self): return self.const 1168 def set_const(self, const): self.const = const 1169 def get_raise(self): return self.raisexx 1170 def set_raise(self, raisexx): self.raisexx = raisexx 1171 def get_virt(self): return self.virt 1172 def set_virt(self, virt): self.virt = virt 1173 def get_readable(self): return self.readable 1174 def set_readable(self, readable): self.readable = readable 1175 def get_prot(self): return self.prot 1176 def set_prot(self, prot): self.prot = prot 1177 def get_explicit(self): return self.explicit 1178 def set_explicit(self, explicit): self.explicit = explicit 1179 def get_new(self): return self.new 1180 def set_new(self, new): self.new = new 1181 def get_final(self): return self.final 1182 def set_final(self, final): self.final = final 1183 def get_writable(self): return self.writable 1184 def set_writable(self, writable): self.writable = writable 1185 def get_add(self): return self.add 1186 def set_add(self, add): self.add = add 1187 def get_static(self): return self.static 1188 def set_static(self, static): self.static = static 1189 def get_remove(self): return self.remove 1190 def set_remove(self, remove): self.remove = remove 1191 def get_sealed(self): return self.sealed 1192 def set_sealed(self, sealed): self.sealed = sealed 1193 def get_mutable(self): return self.mutable 1194 def set_mutable(self, mutable): self.mutable = mutable 1195 def get_gettable(self): return self.gettable 1196 def set_gettable(self, gettable): self.gettable = gettable 1197 def get_inline(self): return self.inline 1198 def set_inline(self, inline): self.inline = inline 1199 def get_settable(self): return self.settable 1200 def set_settable(self, settable): self.settable = settable 1201 def get_id(self): return self.id 1202 def set_id(self, id): self.id = id 1203 def get_refqual(self): return self.refqual 1204 def set_refqual(self, refqual): self.refqual = refqual 1205 def hasContent_(self): 1206 if ( 1207 self.templateparamlist is not None or 1208 self.type_ is not None or 1209 self.definition is not None or 1210 self.argsstring is not None or 1211 self.name is not None or 1212 self.read is not None or 1213 self.write is not None or 1214 self.bitfield is not None or 1215 self.reimplements is not None or 1216 self.reimplementedby is not None or 1217 self.param is not None or 1218 self.enumvalue is not None or 1219 self.initializer is not None or 1220 self.exceptions is not None or 1221 self.briefdescription is not None or 1222 self.detaileddescription is not None or 1223 self.inbodydescription is not None or 1224 self.location is not None or 1225 self.references is not None or 1226 self.referencedby is not None 1227 ): 1228 return True 1229 else: 1230 return False 1231 def build(self, node_): 1232 attrs = node_.attributes 1233 self.buildAttributes(attrs) 1234 for child_ in node_.childNodes: 1235 nodeName_ = child_.nodeName.split(':')[-1] 1236 self.buildChildren(child_, nodeName_) 1237 def buildAttributes(self, attrs): 1238 if attrs.get('initonly'): 1239 self.initonly = attrs.get('initonly').value 1240 if attrs.get('kind'): 1241 self.kind = attrs.get('kind').value 1242 if attrs.get('volatile'): 1243 self.volatile = attrs.get('volatile').value 1244 if attrs.get('const'): 1245 self.const = attrs.get('const').value 1246 if attrs.get('raise'): 1247 self.raisexx = attrs.get('raise').value 1248 if attrs.get('virt'): 1249 self.virt = attrs.get('virt').value 1250 if attrs.get('readable'): 1251 self.readable = attrs.get('readable').value 1252 if attrs.get('prot'): 1253 self.prot = attrs.get('prot').value 1254 if attrs.get('explicit'): 1255 self.explicit = attrs.get('explicit').value 1256 if attrs.get('new'): 1257 self.new = attrs.get('new').value 1258 if attrs.get('final'): 1259 self.final = attrs.get('final').value 1260 if attrs.get('writable'): 1261 self.writable = attrs.get('writable').value 1262 if attrs.get('add'): 1263 self.add = attrs.get('add').value 1264 if attrs.get('static'): 1265 self.static = attrs.get('static').value 1266 if attrs.get('remove'): 1267 self.remove = attrs.get('remove').value 1268 if attrs.get('sealed'): 1269 self.sealed = attrs.get('sealed').value 1270 if attrs.get('mutable'): 1271 self.mutable = attrs.get('mutable').value 1272 if attrs.get('gettable'): 1273 self.gettable = attrs.get('gettable').value 1274 if attrs.get('inline'): 1275 self.inline = attrs.get('inline').value 1276 if attrs.get('settable'): 1277 self.settable = attrs.get('settable').value 1278 if attrs.get('id'): 1279 self.id = attrs.get('id').value 1280 if attrs.get('refqual'): 1281 self.refqual = attrs.get('refqual').value 1282 def buildChildren(self, child_, nodeName_): 1283 if child_.nodeType == Node.ELEMENT_NODE and \ 1284 nodeName_ == 'templateparamlist': 1285 obj_ = templateparamlistType.factory() 1286 obj_.build(child_) 1287 self.set_templateparamlist(obj_) 1288 elif child_.nodeType == Node.ELEMENT_NODE and \ 1289 nodeName_ == 'type': 1290 obj_ = linkedTextType.factory() 1291 obj_.build(child_) 1292 self.set_type(obj_) 1293 elif child_.nodeType == Node.ELEMENT_NODE and \ 1294 nodeName_ == 'definition': 1295 definition_ = '' 1296 for text__content_ in child_.childNodes: 1297 definition_ += text__content_.nodeValue 1298 self.definition = definition_ 1299 elif child_.nodeType == Node.ELEMENT_NODE and \ 1300 nodeName_ == 'argsstring': 1301 argsstring_ = '' 1302 for text__content_ in child_.childNodes: 1303 argsstring_ += text__content_.nodeValue 1304 self.argsstring = argsstring_ 1305 elif child_.nodeType == Node.ELEMENT_NODE and \ 1306 nodeName_ == 'name': 1307 name_ = '' 1308 for text__content_ in child_.childNodes: 1309 name_ += text__content_.nodeValue 1310 self.name = name_ 1311 elif child_.nodeType == Node.ELEMENT_NODE and \ 1312 nodeName_ == 'read': 1313 read_ = '' 1314 for text__content_ in child_.childNodes: 1315 read_ += text__content_.nodeValue 1316 self.read = read_ 1317 elif child_.nodeType == Node.ELEMENT_NODE and \ 1318 nodeName_ == 'write': 1319 write_ = '' 1320 for text__content_ in child_.childNodes: 1321 write_ += text__content_.nodeValue 1322 self.write = write_ 1323 elif child_.nodeType == Node.ELEMENT_NODE and \ 1324 nodeName_ == 'bitfield': 1325 bitfield_ = '' 1326 for text__content_ in child_.childNodes: 1327 bitfield_ += text__content_.nodeValue 1328 self.bitfield = bitfield_ 1329 elif child_.nodeType == Node.ELEMENT_NODE and \ 1330 nodeName_ == 'reimplements': 1331 obj_ = reimplementType.factory() 1332 obj_.build(child_) 1333 self.reimplements.append(obj_) 1334 elif child_.nodeType == Node.ELEMENT_NODE and \ 1335 nodeName_ == 'reimplementedby': 1336 obj_ = reimplementType.factory() 1337 obj_.build(child_) 1338 self.reimplementedby.append(obj_) 1339 elif child_.nodeType == Node.ELEMENT_NODE and \ 1340 nodeName_ == 'param': 1341 obj_ = paramType.factory() 1342 obj_.build(child_) 1343 self.param.append(obj_) 1344 elif child_.nodeType == Node.ELEMENT_NODE and \ 1345 nodeName_ == 'enumvalue': 1346 obj_ = enumvalueType.factory() 1347 obj_.build(child_) 1348 self.enumvalue.append(obj_) 1349 elif child_.nodeType == Node.ELEMENT_NODE and \ 1350 nodeName_ == 'initializer': 1351 obj_ = linkedTextType.factory() 1352 obj_.build(child_) 1353 self.set_initializer(obj_) 1354 elif child_.nodeType == Node.ELEMENT_NODE and \ 1355 nodeName_ == 'exceptions': 1356 obj_ = linkedTextType.factory() 1357 obj_.build(child_) 1358 self.set_exceptions(obj_) 1359 elif child_.nodeType == Node.ELEMENT_NODE and \ 1360 nodeName_ == 'briefdescription': 1361 obj_ = descriptionType.factory() 1362 obj_.build(child_) 1363 self.set_briefdescription(obj_) 1364 elif child_.nodeType == Node.ELEMENT_NODE and \ 1365 nodeName_ == 'detaileddescription': 1366 obj_ = descriptionType.factory() 1367 obj_.build(child_) 1368 self.set_detaileddescription(obj_) 1369 elif child_.nodeType == Node.ELEMENT_NODE and \ 1370 nodeName_ == 'inbodydescription': 1371 obj_ = descriptionType.factory() 1372 obj_.build(child_) 1373 self.set_inbodydescription(obj_) 1374 elif child_.nodeType == Node.ELEMENT_NODE and \ 1375 nodeName_ == 'location': 1376 obj_ = locationType.factory() 1377 obj_.build(child_) 1378 self.set_location(obj_) 1379 elif child_.nodeType == Node.ELEMENT_NODE and \ 1380 nodeName_ == 'references': 1381 obj_ = referenceType.factory() 1382 obj_.build(child_) 1383 self.references.append(obj_) 1384 elif child_.nodeType == Node.ELEMENT_NODE and \ 1385 nodeName_ == 'referencedby': 1386 obj_ = referenceType.factory() 1387 obj_.build(child_) 1388 self.referencedby.append(obj_) 1389# end class memberdefType 1390 1391 1392class definition(GeneratedsSuper): 1393 subclass = None 1394 superclass = None 1395 def __init__(self, valueOf_=''): 1396 self.valueOf_ = valueOf_ 1397 def factory(*args_, **kwargs_): 1398 if definition.subclass: 1399 return definition.subclass(*args_, **kwargs_) 1400 else: 1401 return definition(*args_, **kwargs_) 1402 factory = staticmethod(factory) 1403 def getValueOf_(self): return self.valueOf_ 1404 def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ 1405 def hasContent_(self): 1406 if ( 1407 self.valueOf_ is not None 1408 ): 1409 return True 1410 else: 1411 return False 1412 def build(self, node_): 1413 attrs = node_.attributes 1414 self.buildAttributes(attrs) 1415 self.valueOf_ = '' 1416 for child_ in node_.childNodes: 1417 nodeName_ = child_.nodeName.split(':')[-1] 1418 self.buildChildren(child_, nodeName_) 1419 def buildAttributes(self, attrs): 1420 pass 1421 def buildChildren(self, child_, nodeName_): 1422 if child_.nodeType == Node.TEXT_NODE: 1423 self.valueOf_ += child_.nodeValue 1424 elif child_.nodeType == Node.CDATA_SECTION_NODE: 1425 self.valueOf_ += '![CDATA['+child_.nodeValue+']]' 1426# end class definition 1427 1428 1429class argsstring(GeneratedsSuper): 1430 subclass = None 1431 superclass = None 1432 def __init__(self, valueOf_=''): 1433 self.valueOf_ = valueOf_ 1434 def factory(*args_, **kwargs_): 1435 if argsstring.subclass: 1436 return argsstring.subclass(*args_, **kwargs_) 1437 else: 1438 return argsstring(*args_, **kwargs_) 1439 factory = staticmethod(factory) 1440 def getValueOf_(self): return self.valueOf_ 1441 def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ 1442 def export(self, outfile, level, namespace_='', name_='argsstring', namespacedef_=''): 1443 showIndent(outfile, level) 1444 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 1445 self.exportAttributes(outfile, level, namespace_, name_='argsstring') 1446 if self.hasContent_(): 1447 outfile.write('>\n') 1448 self.exportChildren(outfile, level + 1, namespace_, name_) 1449 showIndent(outfile, level) 1450 outfile.write('</%s%s>\n' % (namespace_, name_)) 1451 else: 1452 outfile.write(' />\n') 1453 def hasContent_(self): 1454 if ( 1455 self.valueOf_ is not None 1456 ): 1457 return True 1458 else: 1459 return False 1460 def build(self, node_): 1461 attrs = node_.attributes 1462 self.buildAttributes(attrs) 1463 self.valueOf_ = '' 1464 for child_ in node_.childNodes: 1465 nodeName_ = child_.nodeName.split(':')[-1] 1466 self.buildChildren(child_, nodeName_) 1467 def buildAttributes(self, attrs): 1468 pass 1469 def buildChildren(self, child_, nodeName_): 1470 if child_.nodeType == Node.TEXT_NODE: 1471 self.valueOf_ += child_.nodeValue 1472 elif child_.nodeType == Node.CDATA_SECTION_NODE: 1473 self.valueOf_ += '![CDATA['+child_.nodeValue+']]' 1474# end class argsstring 1475 1476 1477class read(GeneratedsSuper): 1478 subclass = None 1479 superclass = None 1480 def __init__(self, valueOf_=''): 1481 self.valueOf_ = valueOf_ 1482 def factory(*args_, **kwargs_): 1483 if read.subclass: 1484 return read.subclass(*args_, **kwargs_) 1485 else: 1486 return read(*args_, **kwargs_) 1487 factory = staticmethod(factory) 1488 def getValueOf_(self): return self.valueOf_ 1489 def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ 1490 def hasContent_(self): 1491 if ( 1492 self.valueOf_ is not None 1493 ): 1494 return True 1495 else: 1496 return False 1497 def build(self, node_): 1498 attrs = node_.attributes 1499 self.buildAttributes(attrs) 1500 self.valueOf_ = '' 1501 for child_ in node_.childNodes: 1502 nodeName_ = child_.nodeName.split(':')[-1] 1503 self.buildChildren(child_, nodeName_) 1504 def buildAttributes(self, attrs): 1505 pass 1506 def buildChildren(self, child_, nodeName_): 1507 if child_.nodeType == Node.TEXT_NODE: 1508 self.valueOf_ += child_.nodeValue 1509 elif child_.nodeType == Node.CDATA_SECTION_NODE: 1510 self.valueOf_ += '![CDATA['+child_.nodeValue+']]' 1511# end class read 1512 1513 1514class write(GeneratedsSuper): 1515 subclass = None 1516 superclass = None 1517 def __init__(self, valueOf_=''): 1518 self.valueOf_ = valueOf_ 1519 def factory(*args_, **kwargs_): 1520 if write.subclass: 1521 return write.subclass(*args_, **kwargs_) 1522 else: 1523 return write(*args_, **kwargs_) 1524 factory = staticmethod(factory) 1525 def getValueOf_(self): return self.valueOf_ 1526 def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ 1527 def hasContent_(self): 1528 if ( 1529 self.valueOf_ is not None 1530 ): 1531 return True 1532 else: 1533 return False 1534 def build(self, node_): 1535 attrs = node_.attributes 1536 self.buildAttributes(attrs) 1537 self.valueOf_ = '' 1538 for child_ in node_.childNodes: 1539 nodeName_ = child_.nodeName.split(':')[-1] 1540 self.buildChildren(child_, nodeName_) 1541 def buildAttributes(self, attrs): 1542 pass 1543 def buildChildren(self, child_, nodeName_): 1544 if child_.nodeType == Node.TEXT_NODE: 1545 self.valueOf_ += child_.nodeValue 1546 elif child_.nodeType == Node.CDATA_SECTION_NODE: 1547 self.valueOf_ += '![CDATA['+child_.nodeValue+']]' 1548# end class write 1549 1550 1551class bitfield(GeneratedsSuper): 1552 subclass = None 1553 superclass = None 1554 def __init__(self, valueOf_=''): 1555 self.valueOf_ = valueOf_ 1556 def factory(*args_, **kwargs_): 1557 if bitfield.subclass: 1558 return bitfield.subclass(*args_, **kwargs_) 1559 else: 1560 return bitfield(*args_, **kwargs_) 1561 factory = staticmethod(factory) 1562 def getValueOf_(self): return self.valueOf_ 1563 def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ 1564 def hasContent_(self): 1565 if ( 1566 self.valueOf_ is not None 1567 ): 1568 return True 1569 else: 1570 return False 1571 def build(self, node_): 1572 attrs = node_.attributes 1573 self.buildAttributes(attrs) 1574 self.valueOf_ = '' 1575 for child_ in node_.childNodes: 1576 nodeName_ = child_.nodeName.split(':')[-1] 1577 self.buildChildren(child_, nodeName_) 1578 def buildAttributes(self, attrs): 1579 pass 1580 def buildChildren(self, child_, nodeName_): 1581 if child_.nodeType == Node.TEXT_NODE: 1582 self.valueOf_ += child_.nodeValue 1583 elif child_.nodeType == Node.CDATA_SECTION_NODE: 1584 self.valueOf_ += '![CDATA['+child_.nodeValue+']]' 1585# end class bitfield 1586 1587 1588class descriptionType(GeneratedsSuper): 1589 subclass = None 1590 superclass = None 1591 def __init__(self, title=None, para=None, sect1=None, internal=None, mixedclass_=None, content_=None): 1592 if mixedclass_ is None: 1593 self.mixedclass_ = MixedContainer 1594 else: 1595 self.mixedclass_ = mixedclass_ 1596 if content_ is None: 1597 self.content_ = [] 1598 else: 1599 self.content_ = content_ 1600 def factory(*args_, **kwargs_): 1601 if descriptionType.subclass: 1602 return descriptionType.subclass(*args_, **kwargs_) 1603 else: 1604 return descriptionType(*args_, **kwargs_) 1605 factory = staticmethod(factory) 1606 def get_title(self): return self.title 1607 def set_title(self, title): self.title = title 1608 def get_para(self): return self.para 1609 def set_para(self, para): self.para = para 1610 def add_para(self, value): self.para.append(value) 1611 def insert_para(self, index, value): self.para[index] = value 1612 def get_sect1(self): return self.sect1 1613 def set_sect1(self, sect1): self.sect1 = sect1 1614 def add_sect1(self, value): self.sect1.append(value) 1615 def insert_sect1(self, index, value): self.sect1[index] = value 1616 def get_internal(self): return self.internal 1617 def set_internal(self, internal): self.internal = internal 1618 def hasContent_(self): 1619 if ( 1620 self.title is not None or 1621 self.para is not None or 1622 self.sect1 is not None or 1623 self.internal is not None 1624 ): 1625 return True 1626 else: 1627 return False 1628 def build(self, node_): 1629 attrs = node_.attributes 1630 self.buildAttributes(attrs) 1631 for child_ in node_.childNodes: 1632 nodeName_ = child_.nodeName.split(':')[-1] 1633 self.buildChildren(child_, nodeName_) 1634 def buildAttributes(self, attrs): 1635 pass 1636 def buildChildren(self, child_, nodeName_): 1637 if child_.nodeType == Node.ELEMENT_NODE and \ 1638 nodeName_ == 'title': 1639 childobj_ = docTitleType.factory() 1640 childobj_.build(child_) 1641 obj_ = self.mixedclass_(MixedContainer.CategoryComplex, 1642 MixedContainer.TypeNone, 'title', childobj_) 1643 self.content_.append(obj_) 1644 elif child_.nodeType == Node.ELEMENT_NODE and \ 1645 nodeName_ == 'para': 1646 childobj_ = docParaType.factory() 1647 childobj_.build(child_) 1648 obj_ = self.mixedclass_(MixedContainer.CategoryComplex, 1649 MixedContainer.TypeNone, 'para', childobj_) 1650 self.content_.append(obj_) 1651 elif child_.nodeType == Node.ELEMENT_NODE and \ 1652 nodeName_ == 'sect1': 1653 childobj_ = docSect1Type.factory() 1654 childobj_.build(child_) 1655 obj_ = self.mixedclass_(MixedContainer.CategoryComplex, 1656 MixedContainer.TypeNone, 'sect1', childobj_) 1657 self.content_.append(obj_) 1658 elif child_.nodeType == Node.ELEMENT_NODE and \ 1659 nodeName_ == 'internal': 1660 childobj_ = docInternalType.factory() 1661 childobj_.build(child_) 1662 obj_ = self.mixedclass_(MixedContainer.CategoryComplex, 1663 MixedContainer.TypeNone, 'internal', childobj_) 1664 self.content_.append(obj_) 1665# end class descriptionType 1666 1667 1668class enumvalueType(GeneratedsSuper): 1669 subclass = None 1670 superclass = None 1671 def __init__(self, prot=None, id=None, name=None, initializer=None, briefdescription=None, detaileddescription=None, mixedclass_=None, content_=None): 1672 self.prot = prot 1673 self.id = id 1674 if mixedclass_ is None: 1675 self.mixedclass_ = MixedContainer 1676 else: 1677 self.mixedclass_ = mixedclass_ 1678 if content_ is None: 1679 self.content_ = [] 1680 else: 1681 self.content_ = content_ 1682 def factory(*args_, **kwargs_): 1683 if enumvalueType.subclass: 1684 return enumvalueType.subclass(*args_, **kwargs_) 1685 else: 1686 return enumvalueType(*args_, **kwargs_) 1687 factory = staticmethod(factory) 1688 def get_name(self): return self.name 1689 def set_name(self, name): self.name = name 1690 def get_initializer(self): return self.initializer 1691 def set_initializer(self, initializer): self.initializer = initializer 1692 def get_briefdescription(self): return self.briefdescription 1693 def set_briefdescription(self, briefdescription): self.briefdescription = briefdescription 1694 def get_detaileddescription(self): return self.detaileddescription 1695 def set_detaileddescription(self, detaileddescription): self.detaileddescription = detaileddescription 1696 def get_prot(self): return self.prot 1697 def set_prot(self, prot): self.prot = prot 1698 def get_id(self): return self.id 1699 def set_id(self, id): self.id = id 1700 def hasContent_(self): 1701 if ( 1702 self.name is not None or 1703 self.initializer is not None or 1704 self.briefdescription is not None or 1705 self.detaileddescription is not None 1706 ): 1707 return True 1708 else: 1709 return False 1710 def build(self, node_): 1711 attrs = node_.attributes 1712 self.buildAttributes(attrs) 1713 for child_ in node_.childNodes: 1714 nodeName_ = child_.nodeName.split(':')[-1] 1715 self.buildChildren(child_, nodeName_) 1716 def buildAttributes(self, attrs): 1717 if attrs.get('prot'): 1718 self.prot = attrs.get('prot').value 1719 if attrs.get('id'): 1720 self.id = attrs.get('id').value 1721 def buildChildren(self, child_, nodeName_): 1722 if child_.nodeType == Node.ELEMENT_NODE and \ 1723 nodeName_ == 'name': 1724 value_ = [] 1725 for text_ in child_.childNodes: 1726 value_.append(text_.nodeValue) 1727 valuestr_ = ''.join(value_) 1728 obj_ = self.mixedclass_(MixedContainer.CategorySimple, 1729 MixedContainer.TypeString, 'name', valuestr_) 1730 self.content_.append(obj_) 1731 elif child_.nodeType == Node.ELEMENT_NODE and \ 1732 nodeName_ == 'initializer': 1733 childobj_ = linkedTextType.factory() 1734 childobj_.build(child_) 1735 obj_ = self.mixedclass_(MixedContainer.CategoryComplex, 1736 MixedContainer.TypeNone, 'initializer', childobj_) 1737 self.content_.append(obj_) 1738 elif child_.nodeType == Node.ELEMENT_NODE and \ 1739 nodeName_ == 'briefdescription': 1740 childobj_ = descriptionType.factory() 1741 childobj_.build(child_) 1742 obj_ = self.mixedclass_(MixedContainer.CategoryComplex, 1743 MixedContainer.TypeNone, 'briefdescription', childobj_) 1744 self.content_.append(obj_) 1745 elif child_.nodeType == Node.ELEMENT_NODE and \ 1746 nodeName_ == 'detaileddescription': 1747 childobj_ = descriptionType.factory() 1748 childobj_.build(child_) 1749 obj_ = self.mixedclass_(MixedContainer.CategoryComplex, 1750 MixedContainer.TypeNone, 'detaileddescription', childobj_) 1751 self.content_.append(obj_) 1752 elif child_.nodeType == Node.TEXT_NODE: 1753 obj_ = self.mixedclass_(MixedContainer.CategoryText, 1754 MixedContainer.TypeNone, '', child_.nodeValue) 1755 self.content_.append(obj_) 1756# end class enumvalueType 1757 1758 1759class templateparamlistType(GeneratedsSuper): 1760 subclass = None 1761 superclass = None 1762 def __init__(self, param=None): 1763 if param is None: 1764 self.param = [] 1765 else: 1766 self.param = param 1767 def factory(*args_, **kwargs_): 1768 if templateparamlistType.subclass: 1769 return templateparamlistType.subclass(*args_, **kwargs_) 1770 else: 1771 return templateparamlistType(*args_, **kwargs_) 1772 factory = staticmethod(factory) 1773 def get_param(self): return self.param 1774 def set_param(self, param): self.param = param 1775 def add_param(self, value): self.param.append(value) 1776 def insert_param(self, index, value): self.param[index] = value 1777 def hasContent_(self): 1778 if ( 1779 self.param is not None 1780 ): 1781 return True 1782 else: 1783 return False 1784 def build(self, node_): 1785 attrs = node_.attributes 1786 self.buildAttributes(attrs) 1787 for child_ in node_.childNodes: 1788 nodeName_ = child_.nodeName.split(':')[-1] 1789 self.buildChildren(child_, nodeName_) 1790 def buildAttributes(self, attrs): 1791 pass 1792 def buildChildren(self, child_, nodeName_): 1793 if child_.nodeType == Node.ELEMENT_NODE and \ 1794 nodeName_ == 'param': 1795 obj_ = paramType.factory() 1796 obj_.build(child_) 1797 self.param.append(obj_) 1798# end class templateparamlistType 1799 1800 1801class paramType(GeneratedsSuper): 1802 subclass = None 1803 superclass = None 1804 def __init__(self, type_=None, declname=None, defname=None, array=None, defval=None, briefdescription=None): 1805 self.type_ = type_ 1806 self.declname = declname 1807 self.defname = defname 1808 self.array = array 1809 self.defval = defval 1810 self.briefdescription = briefdescription 1811 def factory(*args_, **kwargs_): 1812 if paramType.subclass: 1813 return paramType.subclass(*args_, **kwargs_) 1814 else: 1815 return paramType(*args_, **kwargs_) 1816 factory = staticmethod(factory) 1817 def get_type(self): return self.type_ 1818 def set_type(self, type_): self.type_ = type_ 1819 def get_declname(self): return self.declname 1820 def set_declname(self, declname): self.declname = declname 1821 def get_defname(self): return self.defname 1822 def set_defname(self, defname): self.defname = defname 1823 def get_array(self): return self.array 1824 def set_array(self, array): self.array = array 1825 def get_defval(self): return self.defval 1826 def set_defval(self, defval): self.defval = defval 1827 def get_briefdescription(self): return self.briefdescription 1828 def set_briefdescription(self, briefdescription): self.briefdescription = briefdescription 1829 def hasContent_(self): 1830 if ( 1831 self.type_ is not None or 1832 self.declname is not None or 1833 self.defname is not None or 1834 self.array is not None or 1835 self.defval is not None or 1836 self.briefdescription is not None 1837 ): 1838 return True 1839 else: 1840 return False 1841 def build(self, node_): 1842 attrs = node_.attributes 1843 self.buildAttributes(attrs) 1844 for child_ in node_.childNodes: 1845 nodeName_ = child_.nodeName.split(':')[-1] 1846 self.buildChildren(child_, nodeName_) 1847 def buildAttributes(self, attrs): 1848 pass 1849 def buildChildren(self, child_, nodeName_): 1850 if child_.nodeType == Node.ELEMENT_NODE and \ 1851 nodeName_ == 'type': 1852 obj_ = linkedTextType.factory() 1853 obj_.build(child_) 1854 self.set_type(obj_) 1855 elif child_.nodeType == Node.ELEMENT_NODE and \ 1856 nodeName_ == 'declname': 1857 declname_ = '' 1858 for text__content_ in child_.childNodes: 1859 declname_ += text__content_.nodeValue 1860 self.declname = declname_ 1861 elif child_.nodeType == Node.ELEMENT_NODE and \ 1862 nodeName_ == 'defname': 1863 defname_ = '' 1864 for text__content_ in child_.childNodes: 1865 defname_ += text__content_.nodeValue 1866 self.defname = defname_ 1867 elif child_.nodeType == Node.ELEMENT_NODE and \ 1868 nodeName_ == 'array': 1869 array_ = '' 1870 for text__content_ in child_.childNodes: 1871 array_ += text__content_.nodeValue 1872 self.array = array_ 1873 elif child_.nodeType == Node.ELEMENT_NODE and \ 1874 nodeName_ == 'defval': 1875 obj_ = linkedTextType.factory() 1876 obj_.build(child_) 1877 self.set_defval(obj_) 1878 elif child_.nodeType == Node.ELEMENT_NODE and \ 1879 nodeName_ == 'briefdescription': 1880 obj_ = descriptionType.factory() 1881 obj_.build(child_) 1882 self.set_briefdescription(obj_) 1883# end class paramType 1884 1885 1886class declname(GeneratedsSuper): 1887 subclass = None 1888 superclass = None 1889 def __init__(self, valueOf_=''): 1890 self.valueOf_ = valueOf_ 1891 def factory(*args_, **kwargs_): 1892 if declname.subclass: 1893 return declname.subclass(*args_, **kwargs_) 1894 else: 1895 return declname(*args_, **kwargs_) 1896 factory = staticmethod(factory) 1897 def getValueOf_(self): return self.valueOf_ 1898 def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ 1899 def hasContent_(self): 1900 if ( 1901 self.valueOf_ is not None 1902 ): 1903 return True 1904 else: 1905 return False 1906 def build(self, node_): 1907 attrs = node_.attributes 1908 self.buildAttributes(attrs) 1909 self.valueOf_ = '' 1910 for child_ in node_.childNodes: 1911 nodeName_ = child_.nodeName.split(':')[-1] 1912 self.buildChildren(child_, nodeName_) 1913 def buildAttributes(self, attrs): 1914 pass 1915 def buildChildren(self, child_, nodeName_): 1916 if child_.nodeType == Node.TEXT_NODE: 1917 self.valueOf_ += child_.nodeValue 1918 elif child_.nodeType == Node.CDATA_SECTION_NODE: 1919 self.valueOf_ += '![CDATA['+child_.nodeValue+']]' 1920# end class declname 1921 1922 1923class defname(GeneratedsSuper): 1924 subclass = None 1925 superclass = None 1926 def __init__(self, valueOf_=''): 1927 self.valueOf_ = valueOf_ 1928 def factory(*args_, **kwargs_): 1929 if defname.subclass: 1930 return defname.subclass(*args_, **kwargs_) 1931 else: 1932 return defname(*args_, **kwargs_) 1933 factory = staticmethod(factory) 1934 def getValueOf_(self): return self.valueOf_ 1935 def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ 1936 def hasContent_(self): 1937 if ( 1938 self.valueOf_ is not None 1939 ): 1940 return True 1941 else: 1942 return False 1943 def build(self, node_): 1944 attrs = node_.attributes 1945 self.buildAttributes(attrs) 1946 self.valueOf_ = '' 1947 for child_ in node_.childNodes: 1948 nodeName_ = child_.nodeName.split(':')[-1] 1949 self.buildChildren(child_, nodeName_) 1950 def buildAttributes(self, attrs): 1951 pass 1952 def buildChildren(self, child_, nodeName_): 1953 if child_.nodeType == Node.TEXT_NODE: 1954 self.valueOf_ += child_.nodeValue 1955 elif child_.nodeType == Node.CDATA_SECTION_NODE: 1956 self.valueOf_ += '![CDATA['+child_.nodeValue+']]' 1957# end class defname 1958 1959 1960class array(GeneratedsSuper): 1961 subclass = None 1962 superclass = None 1963 def __init__(self, valueOf_=''): 1964 self.valueOf_ = valueOf_ 1965 def factory(*args_, **kwargs_): 1966 if array.subclass: 1967 return array.subclass(*args_, **kwargs_) 1968 else: 1969 return array(*args_, **kwargs_) 1970 factory = staticmethod(factory) 1971 def getValueOf_(self): return self.valueOf_ 1972 def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ 1973 def hasContent_(self): 1974 if ( 1975 self.valueOf_ is not None 1976 ): 1977 return True 1978 else: 1979 return False 1980 def build(self, node_): 1981 attrs = node_.attributes 1982 self.buildAttributes(attrs) 1983 self.valueOf_ = '' 1984 for child_ in node_.childNodes: 1985 nodeName_ = child_.nodeName.split(':')[-1] 1986 self.buildChildren(child_, nodeName_) 1987 def buildAttributes(self, attrs): 1988 pass 1989 def buildChildren(self, child_, nodeName_): 1990 if child_.nodeType == Node.TEXT_NODE: 1991 self.valueOf_ += child_.nodeValue 1992 elif child_.nodeType == Node.CDATA_SECTION_NODE: 1993 self.valueOf_ += '![CDATA['+child_.nodeValue+']]' 1994# end class array 1995 1996 1997class linkedTextType(GeneratedsSuper): 1998 subclass = None 1999 superclass = None 2000 def __init__(self, ref=None, mixedclass_=None, content_=None): 2001 if mixedclass_ is None: 2002 self.mixedclass_ = MixedContainer 2003 else: 2004 self.mixedclass_ = mixedclass_ 2005 if content_ is None: 2006 self.content_ = [] 2007 else: 2008 self.content_ = content_ 2009 def factory(*args_, **kwargs_): 2010 if linkedTextType.subclass: 2011 return linkedTextType.subclass(*args_, **kwargs_) 2012 else: 2013 return linkedTextType(*args_, **kwargs_) 2014 factory = staticmethod(factory) 2015 def get_ref(self): return self.ref 2016 def set_ref(self, ref): self.ref = ref 2017 def add_ref(self, value): self.ref.append(value) 2018 def insert_ref(self, index, value): self.ref[index] = value 2019 def hasContent_(self): 2020 if ( 2021 self.ref is not None 2022 ): 2023 return True 2024 else: 2025 return False 2026 def build(self, node_): 2027 attrs = node_.attributes 2028 self.buildAttributes(attrs) 2029 for child_ in node_.childNodes: 2030 nodeName_ = child_.nodeName.split(':')[-1] 2031 self.buildChildren(child_, nodeName_) 2032 def buildAttributes(self, attrs): 2033 pass 2034 def buildChildren(self, child_, nodeName_): 2035 if child_.nodeType == Node.ELEMENT_NODE and \ 2036 nodeName_ == 'ref': 2037 childobj_ = docRefTextType.factory() 2038 childobj_.build(child_) 2039 obj_ = self.mixedclass_(MixedContainer.CategoryComplex, 2040 MixedContainer.TypeNone, 'ref', childobj_) 2041 self.content_.append(obj_) 2042 elif child_.nodeType == Node.TEXT_NODE: 2043 obj_ = self.mixedclass_(MixedContainer.CategoryText, 2044 MixedContainer.TypeNone, '', child_.nodeValue) 2045 self.content_.append(obj_) 2046# end class linkedTextType 2047 2048 2049class graphType(GeneratedsSuper): 2050 subclass = None 2051 superclass = None 2052 def __init__(self, node=None): 2053 if node is None: 2054 self.node = [] 2055 else: 2056 self.node = node 2057 def factory(*args_, **kwargs_): 2058 if graphType.subclass: 2059 return graphType.subclass(*args_, **kwargs_) 2060 else: 2061 return graphType(*args_, **kwargs_) 2062 factory = staticmethod(factory) 2063 def get_node(self): return self.node 2064 def set_node(self, node): self.node = node 2065 def add_node(self, value): self.node.append(value) 2066 def insert_node(self, index, value): self.node[index] = value 2067 def hasContent_(self): 2068 if ( 2069 self.node is not None 2070 ): 2071 return True 2072 else: 2073 return False 2074 def build(self, node_): 2075 attrs = node_.attributes 2076 self.buildAttributes(attrs) 2077 for child_ in node_.childNodes: 2078 nodeName_ = child_.nodeName.split(':')[-1] 2079 self.buildChildren(child_, nodeName_) 2080 def buildAttributes(self, attrs): 2081 pass 2082 def buildChildren(self, child_, nodeName_): 2083 if child_.nodeType == Node.ELEMENT_NODE and \ 2084 nodeName_ == 'node': 2085 obj_ = nodeType.factory() 2086 obj_.build(child_) 2087 self.node.append(obj_) 2088# end class graphType 2089 2090 2091class nodeType(GeneratedsSuper): 2092 subclass = None 2093 superclass = None 2094 def __init__(self, id=None, label=None, link=None, childnode=None): 2095 self.id = id 2096 self.label = label 2097 self.link = link 2098 if childnode is None: 2099 self.childnode = [] 2100 else: 2101 self.childnode = childnode 2102 def factory(*args_, **kwargs_): 2103 if nodeType.subclass: 2104 return nodeType.subclass(*args_, **kwargs_) 2105 else: 2106 return nodeType(*args_, **kwargs_) 2107 factory = staticmethod(factory) 2108 def get_label(self): return self.label 2109 def set_label(self, label): self.label = label 2110 def get_link(self): return self.link 2111 def set_link(self, link): self.link = link 2112 def get_childnode(self): return self.childnode 2113 def set_childnode(self, childnode): self.childnode = childnode 2114 def add_childnode(self, value): self.childnode.append(value) 2115 def insert_childnode(self, index, value): self.childnode[index] = value 2116 def get_id(self): return self.id 2117 def set_id(self, id): self.id = id 2118 def hasContent_(self): 2119 if ( 2120 self.label is not None or 2121 self.link is not None or 2122 self.childnode is not None 2123 ): 2124 return True 2125 else: 2126 return False 2127 def build(self, node_): 2128 attrs = node_.attributes 2129 self.buildAttributes(attrs) 2130 for child_ in node_.childNodes: 2131 nodeName_ = child_.nodeName.split(':')[-1] 2132 self.buildChildren(child_, nodeName_) 2133 def buildAttributes(self, attrs): 2134 if attrs.get('id'): 2135 self.id = attrs.get('id').value 2136 def buildChildren(self, child_, nodeName_): 2137 if child_.nodeType == Node.ELEMENT_NODE and \ 2138 nodeName_ == 'label': 2139 label_ = '' 2140 for text__content_ in child_.childNodes: 2141 label_ += text__content_.nodeValue 2142 self.label = label_ 2143 elif child_.nodeType == Node.ELEMENT_NODE and \ 2144 nodeName_ == 'link': 2145 obj_ = linkType.factory() 2146 obj_.build(child_) 2147 self.set_link(obj_) 2148 elif child_.nodeType == Node.ELEMENT_NODE and \ 2149 nodeName_ == 'childnode': 2150 obj_ = childnodeType.factory() 2151 obj_.build(child_) 2152 self.childnode.append(obj_) 2153# end class nodeType 2154 2155 2156class label(GeneratedsSuper): 2157 subclass = None 2158 superclass = None 2159 def __init__(self, valueOf_=''): 2160 self.valueOf_ = valueOf_ 2161 def factory(*args_, **kwargs_): 2162 if label.subclass: 2163 return label.subclass(*args_, **kwargs_) 2164 else: 2165 return label(*args_, **kwargs_) 2166 factory = staticmethod(factory) 2167 def getValueOf_(self): return self.valueOf_ 2168 def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ 2169 def hasContent_(self): 2170 if ( 2171 self.valueOf_ is not None 2172 ): 2173 return True 2174 else: 2175 return False 2176 def build(self, node_): 2177 attrs = node_.attributes 2178 self.buildAttributes(attrs) 2179 self.valueOf_ = '' 2180 for child_ in node_.childNodes: 2181 nodeName_ = child_.nodeName.split(':')[-1] 2182 self.buildChildren(child_, nodeName_) 2183 def buildAttributes(self, attrs): 2184 pass 2185 def buildChildren(self, child_, nodeName_): 2186 if child_.nodeType == Node.TEXT_NODE: 2187 self.valueOf_ += child_.nodeValue 2188 elif child_.nodeType == Node.CDATA_SECTION_NODE: 2189 self.valueOf_ += '![CDATA['+child_.nodeValue+']]' 2190# end class label 2191 2192 2193class childnodeType(GeneratedsSuper): 2194 subclass = None 2195 superclass = None 2196 def __init__(self, relation=None, refid=None, edgelabel=None): 2197 self.relation = relation 2198 self.refid = refid 2199 if edgelabel is None: 2200 self.edgelabel = [] 2201 else: 2202 self.edgelabel = edgelabel 2203 def factory(*args_, **kwargs_): 2204 if childnodeType.subclass: 2205 return childnodeType.subclass(*args_, **kwargs_) 2206 else: 2207 return childnodeType(*args_, **kwargs_) 2208 factory = staticmethod(factory) 2209 def get_edgelabel(self): return self.edgelabel 2210 def set_edgelabel(self, edgelabel): self.edgelabel = edgelabel 2211 def add_edgelabel(self, value): self.edgelabel.append(value) 2212 def insert_edgelabel(self, index, value): self.edgelabel[index] = value 2213 def get_relation(self): return self.relation 2214 def set_relation(self, relation): self.relation = relation 2215 def get_refid(self): return self.refid 2216 def set_refid(self, refid): self.refid = refid 2217 def export(self, outfile, level, namespace_='', name_='childnodeType', namespacedef_=''): 2218 showIndent(outfile, level) 2219 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 2220 self.exportAttributes(outfile, level, namespace_, name_='childnodeType') 2221 if self.hasContent_(): 2222 outfile.write('>\n') 2223 self.exportChildren(outfile, level + 1, namespace_, name_) 2224 showIndent(outfile, level) 2225 outfile.write('</%s%s>\n' % (namespace_, name_)) 2226 else: 2227 outfile.write(' />\n') 2228 def exportAttributes(self, outfile, level, namespace_='', name_='childnodeType'): 2229 if self.relation is not None: 2230 outfile.write(' relation=%s' % (quote_attrib(self.relation), )) 2231 if self.refid is not None: 2232 outfile.write(' refid=%s' % (self.format_string(quote_attrib(self.refid).encode(ExternalEncoding), input_name='refid'), )) 2233 def exportChildren(self, outfile, level, namespace_='', name_='childnodeType'): 2234 for edgelabel_ in self.edgelabel: 2235 showIndent(outfile, level) 2236 outfile.write('<%sedgelabel>%s</%sedgelabel>\n' % (namespace_, self.format_string(quote_xml(edgelabel_).encode(ExternalEncoding), input_name='edgelabel'), namespace_)) 2237 def hasContent_(self): 2238 if ( 2239 self.edgelabel is not None 2240 ): 2241 return True 2242 else: 2243 return False 2244 def build(self, node_): 2245 attrs = node_.attributes 2246 self.buildAttributes(attrs) 2247 for child_ in node_.childNodes: 2248 nodeName_ = child_.nodeName.split(':')[-1] 2249 self.buildChildren(child_, nodeName_) 2250 def buildAttributes(self, attrs): 2251 if attrs.get('relation'): 2252 self.relation = attrs.get('relation').value 2253 if attrs.get('refid'): 2254 self.refid = attrs.get('refid').value 2255 def buildChildren(self, child_, nodeName_): 2256 if child_.nodeType == Node.ELEMENT_NODE and \ 2257 nodeName_ == 'edgelabel': 2258 edgelabel_ = '' 2259 for text__content_ in child_.childNodes: 2260 edgelabel_ += text__content_.nodeValue 2261 self.edgelabel.append(edgelabel_) 2262# end class childnodeType 2263 2264 2265class edgelabel(GeneratedsSuper): 2266 subclass = None 2267 superclass = None 2268 def __init__(self, valueOf_=''): 2269 self.valueOf_ = valueOf_ 2270 def factory(*args_, **kwargs_): 2271 if edgelabel.subclass: 2272 return edgelabel.subclass(*args_, **kwargs_) 2273 else: 2274 return edgelabel(*args_, **kwargs_) 2275 factory = staticmethod(factory) 2276 def getValueOf_(self): return self.valueOf_ 2277 def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ 2278 def export(self, outfile, level, namespace_='', name_='edgelabel', namespacedef_=''): 2279 showIndent(outfile, level) 2280 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 2281 self.exportAttributes(outfile, level, namespace_, name_='edgelabel') 2282 if self.hasContent_(): 2283 outfile.write('>\n') 2284 self.exportChildren(outfile, level + 1, namespace_, name_) 2285 showIndent(outfile, level) 2286 outfile.write('</%s%s>\n' % (namespace_, name_)) 2287 else: 2288 outfile.write(' />\n') 2289 def exportAttributes(self, outfile, level, namespace_='', name_='edgelabel'): 2290 pass 2291 def exportChildren(self, outfile, level, namespace_='', name_='edgelabel'): 2292 if self.valueOf_.find('![CDATA')>-1: 2293 value=quote_xml('%s' % self.valueOf_) 2294 value=value.replace('![CDATA','<![CDATA') 2295 value=value.replace(']]',']]>') 2296 outfile.write(value) 2297 else: 2298 outfile.write(quote_xml('%s' % self.valueOf_)) 2299 def hasContent_(self): 2300 if ( 2301 self.valueOf_ is not None 2302 ): 2303 return True 2304 else: 2305 return False 2306 def build(self, node_): 2307 attrs = node_.attributes 2308 self.buildAttributes(attrs) 2309 self.valueOf_ = '' 2310 for child_ in node_.childNodes: 2311 nodeName_ = child_.nodeName.split(':')[-1] 2312 self.buildChildren(child_, nodeName_) 2313 def buildAttributes(self, attrs): 2314 pass 2315 def buildChildren(self, child_, nodeName_): 2316 if child_.nodeType == Node.TEXT_NODE: 2317 self.valueOf_ += child_.nodeValue 2318 elif child_.nodeType == Node.CDATA_SECTION_NODE: 2319 self.valueOf_ += '![CDATA['+child_.nodeValue+']]' 2320# end class edgelabel 2321 2322 2323class linkType(GeneratedsSuper): 2324 subclass = None 2325 superclass = None 2326 def __init__(self, refid=None, external=None, valueOf_=''): 2327 self.refid = refid 2328 self.external = external 2329 self.valueOf_ = valueOf_ 2330 def factory(*args_, **kwargs_): 2331 if linkType.subclass: 2332 return linkType.subclass(*args_, **kwargs_) 2333 else: 2334 return linkType(*args_, **kwargs_) 2335 factory = staticmethod(factory) 2336 def get_refid(self): return self.refid 2337 def set_refid(self, refid): self.refid = refid 2338 def get_external(self): return self.external 2339 def set_external(self, external): self.external = external 2340 def getValueOf_(self): return self.valueOf_ 2341 def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ 2342 def export(self, outfile, level, namespace_='', name_='linkType', namespacedef_=''): 2343 showIndent(outfile, level) 2344 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 2345 self.exportAttributes(outfile, level, namespace_, name_='linkType') 2346 if self.hasContent_(): 2347 outfile.write('>\n') 2348 self.exportChildren(outfile, level + 1, namespace_, name_) 2349 showIndent(outfile, level) 2350 outfile.write('</%s%s>\n' % (namespace_, name_)) 2351 else: 2352 outfile.write(' />\n') 2353 def exportAttributes(self, outfile, level, namespace_='', name_='linkType'): 2354 if self.refid is not None: 2355 outfile.write(' refid=%s' % (self.format_string(quote_attrib(self.refid).encode(ExternalEncoding), input_name='refid'), )) 2356 if self.external is not None: 2357 outfile.write(' external=%s' % (self.format_string(quote_attrib(self.external).encode(ExternalEncoding), input_name='external'), )) 2358 def exportChildren(self, outfile, level, namespace_='', name_='linkType'): 2359 if self.valueOf_.find('![CDATA')>-1: 2360 value=quote_xml('%s' % self.valueOf_) 2361 value=value.replace('![CDATA','<![CDATA') 2362 value=value.replace(']]',']]>') 2363 outfile.write(value) 2364 else: 2365 outfile.write(quote_xml('%s' % self.valueOf_)) 2366 def hasContent_(self): 2367 if ( 2368 self.valueOf_ is not None 2369 ): 2370 return True 2371 else: 2372 return False 2373 def build(self, node_): 2374 attrs = node_.attributes 2375 self.buildAttributes(attrs) 2376 self.valueOf_ = '' 2377 for child_ in node_.childNodes: 2378 nodeName_ = child_.nodeName.split(':')[-1] 2379 self.buildChildren(child_, nodeName_) 2380 def buildAttributes(self, attrs): 2381 if attrs.get('refid'): 2382 self.refid = attrs.get('refid').value 2383 if attrs.get('external'): 2384 self.external = attrs.get('external').value 2385 def buildChildren(self, child_, nodeName_): 2386 if child_.nodeType == Node.TEXT_NODE: 2387 self.valueOf_ += child_.nodeValue 2388 elif child_.nodeType == Node.CDATA_SECTION_NODE: 2389 self.valueOf_ += '![CDATA['+child_.nodeValue+']]' 2390# end class linkType 2391 2392 2393class listingType(GeneratedsSuper): 2394 subclass = None 2395 superclass = None 2396 def __init__(self, codeline=None): 2397 if codeline is None: 2398 self.codeline = [] 2399 else: 2400 self.codeline = codeline 2401 def factory(*args_, **kwargs_): 2402 if listingType.subclass: 2403 return listingType.subclass(*args_, **kwargs_) 2404 else: 2405 return listingType(*args_, **kwargs_) 2406 factory = staticmethod(factory) 2407 def get_codeline(self): return self.codeline 2408 def set_codeline(self, codeline): self.codeline = codeline 2409 def add_codeline(self, value): self.codeline.append(value) 2410 def insert_codeline(self, index, value): self.codeline[index] = value 2411 def export(self, outfile, level, namespace_='', name_='listingType', namespacedef_=''): 2412 showIndent(outfile, level) 2413 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 2414 self.exportAttributes(outfile, level, namespace_, name_='listingType') 2415 if self.hasContent_(): 2416 outfile.write('>\n') 2417 self.exportChildren(outfile, level + 1, namespace_, name_) 2418 showIndent(outfile, level) 2419 outfile.write('</%s%s>\n' % (namespace_, name_)) 2420 else: 2421 outfile.write(' />\n') 2422 def exportAttributes(self, outfile, level, namespace_='', name_='listingType'): 2423 pass 2424 def exportChildren(self, outfile, level, namespace_='', name_='listingType'): 2425 for codeline_ in self.codeline: 2426 codeline_.export(outfile, level, namespace_, name_='codeline') 2427 def hasContent_(self): 2428 if ( 2429 self.codeline is not None 2430 ): 2431 return True 2432 else: 2433 return False 2434 def build(self, node_): 2435 attrs = node_.attributes 2436 self.buildAttributes(attrs) 2437 for child_ in node_.childNodes: 2438 nodeName_ = child_.nodeName.split(':')[-1] 2439 self.buildChildren(child_, nodeName_) 2440 def buildAttributes(self, attrs): 2441 pass 2442 def buildChildren(self, child_, nodeName_): 2443 if child_.nodeType == Node.ELEMENT_NODE and \ 2444 nodeName_ == 'codeline': 2445 obj_ = codelineType.factory() 2446 obj_.build(child_) 2447 self.codeline.append(obj_) 2448# end class listingType 2449 2450 2451class codelineType(GeneratedsSuper): 2452 subclass = None 2453 superclass = None 2454 def __init__(self, external=None, lineno=None, refkind=None, refid=None, highlight=None): 2455 self.external = external 2456 self.lineno = lineno 2457 self.refkind = refkind 2458 self.refid = refid 2459 if highlight is None: 2460 self.highlight = [] 2461 else: 2462 self.highlight = highlight 2463 def factory(*args_, **kwargs_): 2464 if codelineType.subclass: 2465 return codelineType.subclass(*args_, **kwargs_) 2466 else: 2467 return codelineType(*args_, **kwargs_) 2468 factory = staticmethod(factory) 2469 def get_highlight(self): return self.highlight 2470 def set_highlight(self, highlight): self.highlight = highlight 2471 def add_highlight(self, value): self.highlight.append(value) 2472 def insert_highlight(self, index, value): self.highlight[index] = value 2473 def get_external(self): return self.external 2474 def set_external(self, external): self.external = external 2475 def get_lineno(self): return self.lineno 2476 def set_lineno(self, lineno): self.lineno = lineno 2477 def get_refkind(self): return self.refkind 2478 def set_refkind(self, refkind): self.refkind = refkind 2479 def get_refid(self): return self.refid 2480 def set_refid(self, refid): self.refid = refid 2481 def export(self, outfile, level, namespace_='', name_='codelineType', namespacedef_=''): 2482 showIndent(outfile, level) 2483 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 2484 self.exportAttributes(outfile, level, namespace_, name_='codelineType') 2485 if self.hasContent_(): 2486 outfile.write('>\n') 2487 self.exportChildren(outfile, level + 1, namespace_, name_) 2488 showIndent(outfile, level) 2489 outfile.write('</%s%s>\n' % (namespace_, name_)) 2490 else: 2491 outfile.write(' />\n') 2492 def exportAttributes(self, outfile, level, namespace_='', name_='codelineType'): 2493 if self.external is not None: 2494 outfile.write(' external=%s' % (quote_attrib(self.external), )) 2495 if self.lineno is not None: 2496 outfile.write(' lineno="%s"' % self.format_integer(self.lineno, input_name='lineno')) 2497 if self.refkind is not None: 2498 outfile.write(' refkind=%s' % (quote_attrib(self.refkind), )) 2499 if self.refid is not None: 2500 outfile.write(' refid=%s' % (self.format_string(quote_attrib(self.refid).encode(ExternalEncoding), input_name='refid'), )) 2501 def exportChildren(self, outfile, level, namespace_='', name_='codelineType'): 2502 for highlight_ in self.highlight: 2503 highlight_.export(outfile, level, namespace_, name_='highlight') 2504 def hasContent_(self): 2505 if ( 2506 self.highlight is not None 2507 ): 2508 return True 2509 else: 2510 return False 2511 def build(self, node_): 2512 attrs = node_.attributes 2513 self.buildAttributes(attrs) 2514 for child_ in node_.childNodes: 2515 nodeName_ = child_.nodeName.split(':')[-1] 2516 self.buildChildren(child_, nodeName_) 2517 def buildAttributes(self, attrs): 2518 if attrs.get('external'): 2519 self.external = attrs.get('external').value 2520 if attrs.get('lineno'): 2521 try: 2522 self.lineno = int(attrs.get('lineno').value) 2523 except ValueError as exp: 2524 raise ValueError('Bad integer attribute (lineno): %s' % exp) 2525 if attrs.get('refkind'): 2526 self.refkind = attrs.get('refkind').value 2527 if attrs.get('refid'): 2528 self.refid = attrs.get('refid').value 2529 def buildChildren(self, child_, nodeName_): 2530 if child_.nodeType == Node.ELEMENT_NODE and \ 2531 nodeName_ == 'highlight': 2532 obj_ = highlightType.factory() 2533 obj_.build(child_) 2534 self.highlight.append(obj_) 2535# end class codelineType 2536 2537 2538class highlightType(GeneratedsSuper): 2539 subclass = None 2540 superclass = None 2541 def __init__(self, classxx=None, sp=None, ref=None, mixedclass_=None, content_=None): 2542 self.classxx = classxx 2543 if mixedclass_ is None: 2544 self.mixedclass_ = MixedContainer 2545 else: 2546 self.mixedclass_ = mixedclass_ 2547 if content_ is None: 2548 self.content_ = [] 2549 else: 2550 self.content_ = content_ 2551 def factory(*args_, **kwargs_): 2552 if highlightType.subclass: 2553 return highlightType.subclass(*args_, **kwargs_) 2554 else: 2555 return highlightType(*args_, **kwargs_) 2556 factory = staticmethod(factory) 2557 def get_sp(self): return self.sp 2558 def set_sp(self, sp): self.sp = sp 2559 def add_sp(self, value): self.sp.append(value) 2560 def insert_sp(self, index, value): self.sp[index] = value 2561 def get_ref(self): return self.ref 2562 def set_ref(self, ref): self.ref = ref 2563 def add_ref(self, value): self.ref.append(value) 2564 def insert_ref(self, index, value): self.ref[index] = value 2565 def get_class(self): return self.classxx 2566 def set_class(self, classxx): self.classxx = classxx 2567 def export(self, outfile, level, namespace_='', name_='highlightType', namespacedef_=''): 2568 showIndent(outfile, level) 2569 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 2570 self.exportAttributes(outfile, level, namespace_, name_='highlightType') 2571 outfile.write('>') 2572 self.exportChildren(outfile, level + 1, namespace_, name_) 2573 outfile.write('</%s%s>\n' % (namespace_, name_)) 2574 def exportAttributes(self, outfile, level, namespace_='', name_='highlightType'): 2575 if self.classxx is not None: 2576 outfile.write(' class=%s' % (quote_attrib(self.classxx), )) 2577 def exportChildren(self, outfile, level, namespace_='', name_='highlightType'): 2578 for item_ in self.content_: 2579 item_.export(outfile, level, item_.name, namespace_) 2580 def hasContent_(self): 2581 if ( 2582 self.sp is not None or 2583 self.ref is not None 2584 ): 2585 return True 2586 else: 2587 return False 2588 def build(self, node_): 2589 attrs = node_.attributes 2590 self.buildAttributes(attrs) 2591 for child_ in node_.childNodes: 2592 nodeName_ = child_.nodeName.split(':')[-1] 2593 self.buildChildren(child_, nodeName_) 2594 def buildAttributes(self, attrs): 2595 if attrs.get('class'): 2596 self.classxx = attrs.get('class').value 2597 def buildChildren(self, child_, nodeName_): 2598 if child_.nodeType == Node.ELEMENT_NODE and \ 2599 nodeName_ == 'sp': 2600 value_ = [] 2601 for text_ in child_.childNodes: 2602 value_.append(text_.nodeValue) 2603 # We make this unicode so that our unicode renderer catch-all picks it up 2604 # otherwise it would go through as 'str' and we'd have to pick it up too 2605 valuestr_ = u' ' 2606 obj_ = self.mixedclass_(MixedContainer.CategorySimple, 2607 MixedContainer.TypeString, 'sp', valuestr_) 2608 self.content_.append(obj_) 2609 elif child_.nodeType == Node.ELEMENT_NODE and \ 2610 nodeName_ == 'ref': 2611 childobj_ = docRefTextType.factory() 2612 childobj_.build(child_) 2613 obj_ = self.mixedclass_(MixedContainer.CategoryComplex, 2614 MixedContainer.TypeNone, 'ref', childobj_) 2615 self.content_.append(obj_) 2616 elif child_.nodeType == Node.TEXT_NODE: 2617 obj_ = self.mixedclass_(MixedContainer.CategoryText, 2618 MixedContainer.TypeNone, '', child_.nodeValue) 2619 self.content_.append(obj_) 2620# end class highlightType 2621 2622 2623class sp(GeneratedsSuper): 2624 subclass = None 2625 superclass = None 2626 def __init__(self, valueOf_=''): 2627 self.valueOf_ = valueOf_ 2628 def factory(*args_, **kwargs_): 2629 if sp.subclass: 2630 return sp.subclass(*args_, **kwargs_) 2631 else: 2632 return sp(*args_, **kwargs_) 2633 factory = staticmethod(factory) 2634 def getValueOf_(self): return self.valueOf_ 2635 def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ 2636 def export(self, outfile, level, namespace_='', name_='sp', namespacedef_=''): 2637 showIndent(outfile, level) 2638 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 2639 self.exportAttributes(outfile, level, namespace_, name_='sp') 2640 if self.hasContent_(): 2641 outfile.write('>\n') 2642 self.exportChildren(outfile, level + 1, namespace_, name_) 2643 showIndent(outfile, level) 2644 outfile.write('</%s%s>\n' % (namespace_, name_)) 2645 else: 2646 outfile.write(' />\n') 2647 def exportAttributes(self, outfile, level, namespace_='', name_='sp'): 2648 pass 2649 def exportChildren(self, outfile, level, namespace_='', name_='sp'): 2650 if self.valueOf_.find('![CDATA')>-1: 2651 value=quote_xml('%s' % self.valueOf_) 2652 value=value.replace('![CDATA','<![CDATA') 2653 value=value.replace(']]',']]>') 2654 outfile.write(value) 2655 else: 2656 outfile.write(quote_xml('%s' % self.valueOf_)) 2657 def hasContent_(self): 2658 if ( 2659 self.valueOf_ is not None 2660 ): 2661 return True 2662 else: 2663 return False 2664 def build(self, node_): 2665 attrs = node_.attributes 2666 self.buildAttributes(attrs) 2667 self.valueOf_ = '' 2668 for child_ in node_.childNodes: 2669 nodeName_ = child_.nodeName.split(':')[-1] 2670 self.buildChildren(child_, nodeName_) 2671 def buildAttributes(self, attrs): 2672 pass 2673 def buildChildren(self, child_, nodeName_): 2674 if child_.nodeType == Node.TEXT_NODE: 2675 self.valueOf_ += child_.nodeValue 2676 elif child_.nodeType == Node.CDATA_SECTION_NODE: 2677 self.valueOf_ += '![CDATA['+child_.nodeValue+']]' 2678# end class sp 2679 2680 2681class referenceType(GeneratedsSuper): 2682 subclass = None 2683 superclass = None 2684 def __init__(self, endline=None, startline=None, refid=None, compoundref=None, valueOf_='', mixedclass_=None, content_=None): 2685 self.endline = endline 2686 self.startline = startline 2687 self.refid = refid 2688 self.compoundref = compoundref 2689 if mixedclass_ is None: 2690 self.mixedclass_ = MixedContainer 2691 else: 2692 self.mixedclass_ = mixedclass_ 2693 if content_ is None: 2694 self.content_ = [] 2695 else: 2696 self.content_ = content_ 2697 def factory(*args_, **kwargs_): 2698 if referenceType.subclass: 2699 return referenceType.subclass(*args_, **kwargs_) 2700 else: 2701 return referenceType(*args_, **kwargs_) 2702 factory = staticmethod(factory) 2703 def get_endline(self): return self.endline 2704 def set_endline(self, endline): self.endline = endline 2705 def get_startline(self): return self.startline 2706 def set_startline(self, startline): self.startline = startline 2707 def get_refid(self): return self.refid 2708 def set_refid(self, refid): self.refid = refid 2709 def get_compoundref(self): return self.compoundref 2710 def set_compoundref(self, compoundref): self.compoundref = compoundref 2711 def getValueOf_(self): return self.valueOf_ 2712 def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ 2713 def export(self, outfile, level, namespace_='', name_='referenceType', namespacedef_=''): 2714 showIndent(outfile, level) 2715 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 2716 self.exportAttributes(outfile, level, namespace_, name_='referenceType') 2717 outfile.write('>') 2718 self.exportChildren(outfile, level + 1, namespace_, name_) 2719 outfile.write('</%s%s>\n' % (namespace_, name_)) 2720 def exportAttributes(self, outfile, level, namespace_='', name_='referenceType'): 2721 if self.endline is not None: 2722 outfile.write(' endline="%s"' % self.format_integer(self.endline, input_name='endline')) 2723 if self.startline is not None: 2724 outfile.write(' startline="%s"' % self.format_integer(self.startline, input_name='startline')) 2725 if self.refid is not None: 2726 outfile.write(' refid=%s' % (self.format_string(quote_attrib(self.refid).encode(ExternalEncoding), input_name='refid'), )) 2727 if self.compoundref is not None: 2728 outfile.write(' compoundref=%s' % (self.format_string(quote_attrib(self.compoundref).encode(ExternalEncoding), input_name='compoundref'), )) 2729 def exportChildren(self, outfile, level, namespace_='', name_='referenceType'): 2730 if self.valueOf_.find('![CDATA')>-1: 2731 value=quote_xml('%s' % self.valueOf_) 2732 value=value.replace('![CDATA','<![CDATA') 2733 value=value.replace(']]',']]>') 2734 outfile.write(value) 2735 else: 2736 outfile.write(quote_xml('%s' % self.valueOf_)) 2737 def hasContent_(self): 2738 if ( 2739 self.valueOf_ is not None 2740 ): 2741 return True 2742 else: 2743 return False 2744 def build(self, node_): 2745 attrs = node_.attributes 2746 self.buildAttributes(attrs) 2747 self.valueOf_ = '' 2748 for child_ in node_.childNodes: 2749 nodeName_ = child_.nodeName.split(':')[-1] 2750 self.buildChildren(child_, nodeName_) 2751 def buildAttributes(self, attrs): 2752 if attrs.get('endline'): 2753 try: 2754 self.endline = int(attrs.get('endline').value) 2755 except ValueError as exp: 2756 raise ValueError('Bad integer attribute (endline): %s' % exp) 2757 if attrs.get('startline'): 2758 try: 2759 self.startline = int(attrs.get('startline').value) 2760 except ValueError as exp: 2761 raise ValueError('Bad integer attribute (startline): %s' % exp) 2762 if attrs.get('refid'): 2763 self.refid = attrs.get('refid').value 2764 if attrs.get('compoundref'): 2765 self.compoundref = attrs.get('compoundref').value 2766 def buildChildren(self, child_, nodeName_): 2767 if child_.nodeType == Node.TEXT_NODE: 2768 obj_ = self.mixedclass_(MixedContainer.CategoryText, 2769 MixedContainer.TypeNone, '', child_.nodeValue) 2770 self.content_.append(obj_) 2771 if child_.nodeType == Node.TEXT_NODE: 2772 self.valueOf_ += child_.nodeValue 2773 elif child_.nodeType == Node.CDATA_SECTION_NODE: 2774 self.valueOf_ += '![CDATA['+child_.nodeValue+']]' 2775# end class referenceType 2776 2777 2778class locationType(GeneratedsSuper): 2779 subclass = None 2780 superclass = None 2781 def __init__(self, bodystart=None, line=None, bodyend=None, bodyfile=None, file=None, valueOf_=''): 2782 self.bodystart = bodystart 2783 self.line = line 2784 self.bodyend = bodyend 2785 self.bodyfile = bodyfile 2786 self.file = file 2787 self.valueOf_ = valueOf_ 2788 def factory(*args_, **kwargs_): 2789 if locationType.subclass: 2790 return locationType.subclass(*args_, **kwargs_) 2791 else: 2792 return locationType(*args_, **kwargs_) 2793 factory = staticmethod(factory) 2794 def get_bodystart(self): return self.bodystart 2795 def set_bodystart(self, bodystart): self.bodystart = bodystart 2796 def get_line(self): return self.line 2797 def set_line(self, line): self.line = line 2798 def get_bodyend(self): return self.bodyend 2799 def set_bodyend(self, bodyend): self.bodyend = bodyend 2800 def get_bodyfile(self): return self.bodyfile 2801 def set_bodyfile(self, bodyfile): self.bodyfile = bodyfile 2802 def get_file(self): return self.file 2803 def set_file(self, file): self.file = file 2804 def getValueOf_(self): return self.valueOf_ 2805 def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ 2806 def export(self, outfile, level, namespace_='', name_='locationType', namespacedef_=''): 2807 showIndent(outfile, level) 2808 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 2809 self.exportAttributes(outfile, level, namespace_, name_='locationType') 2810 if self.hasContent_(): 2811 outfile.write('>\n') 2812 self.exportChildren(outfile, level + 1, namespace_, name_) 2813 showIndent(outfile, level) 2814 outfile.write('</%s%s>\n' % (namespace_, name_)) 2815 else: 2816 outfile.write(' />\n') 2817 def exportAttributes(self, outfile, level, namespace_='', name_='locationType'): 2818 if self.bodystart is not None: 2819 outfile.write(' bodystart="%s"' % self.format_integer(self.bodystart, input_name='bodystart')) 2820 if self.line is not None: 2821 outfile.write(' line="%s"' % self.format_integer(self.line, input_name='line')) 2822 if self.bodyend is not None: 2823 outfile.write(' bodyend="%s"' % self.format_integer(self.bodyend, input_name='bodyend')) 2824 if self.bodyfile is not None: 2825 outfile.write(' bodyfile=%s' % (self.format_string(quote_attrib(self.bodyfile).encode(ExternalEncoding), input_name='bodyfile'), )) 2826 if self.file is not None: 2827 outfile.write(' file=%s' % (self.format_string(quote_attrib(self.file).encode(ExternalEncoding), input_name='file'), )) 2828 def exportChildren(self, outfile, level, namespace_='', name_='locationType'): 2829 if self.valueOf_.find('![CDATA')>-1: 2830 value=quote_xml('%s' % self.valueOf_) 2831 value=value.replace('![CDATA','<![CDATA') 2832 value=value.replace(']]',']]>') 2833 outfile.write(value) 2834 else: 2835 outfile.write(quote_xml('%s' % self.valueOf_)) 2836 def hasContent_(self): 2837 if ( 2838 self.valueOf_ is not None 2839 ): 2840 return True 2841 else: 2842 return False 2843 def build(self, node_): 2844 attrs = node_.attributes 2845 self.buildAttributes(attrs) 2846 self.valueOf_ = '' 2847 for child_ in node_.childNodes: 2848 nodeName_ = child_.nodeName.split(':')[-1] 2849 self.buildChildren(child_, nodeName_) 2850 def buildAttributes(self, attrs): 2851 if attrs.get('bodystart'): 2852 try: 2853 self.bodystart = int(attrs.get('bodystart').value) 2854 except ValueError as exp: 2855 raise ValueError('Bad integer attribute (bodystart): %s' % exp) 2856 if attrs.get('line'): 2857 try: 2858 self.line = int(attrs.get('line').value) 2859 except ValueError as exp: 2860 raise ValueError('Bad integer attribute (line): %s' % exp) 2861 if attrs.get('bodyend'): 2862 try: 2863 self.bodyend = int(attrs.get('bodyend').value) 2864 except ValueError as exp: 2865 raise ValueError('Bad integer attribute (bodyend): %s' % exp) 2866 if attrs.get('bodyfile'): 2867 self.bodyfile = attrs.get('bodyfile').value 2868 if attrs.get('file'): 2869 self.file = attrs.get('file').value 2870 def buildChildren(self, child_, nodeName_): 2871 if child_.nodeType == Node.TEXT_NODE: 2872 self.valueOf_ += child_.nodeValue 2873 elif child_.nodeType == Node.CDATA_SECTION_NODE: 2874 self.valueOf_ += '![CDATA['+child_.nodeValue+']]' 2875# end class locationType 2876 2877 2878class docSect1Type(GeneratedsSuper): 2879 subclass = None 2880 superclass = None 2881 def __init__(self, id=None, title=None, para=None, sect2=None, internal=None, mixedclass_=None, content_=None): 2882 self.id = id 2883 if mixedclass_ is None: 2884 self.mixedclass_ = MixedContainer 2885 else: 2886 self.mixedclass_ = mixedclass_ 2887 if content_ is None: 2888 self.content_ = [] 2889 else: 2890 self.content_ = content_ 2891 if title is None: 2892 self.title = "" 2893 else: 2894 self.title = title 2895 def factory(*args_, **kwargs_): 2896 if docSect1Type.subclass: 2897 return docSect1Type.subclass(*args_, **kwargs_) 2898 else: 2899 return docSect1Type(*args_, **kwargs_) 2900 factory = staticmethod(factory) 2901 def get_title(self): return self.title 2902 def set_title(self, title): self.title = title 2903 def get_para(self): return self.para 2904 def set_para(self, para): self.para = para 2905 def add_para(self, value): self.para.append(value) 2906 def insert_para(self, index, value): self.para[index] = value 2907 def get_sect2(self): return self.sect2 2908 def set_sect2(self, sect2): self.sect2 = sect2 2909 def add_sect2(self, value): self.sect2.append(value) 2910 def insert_sect2(self, index, value): self.sect2[index] = value 2911 def get_internal(self): return self.internal 2912 def set_internal(self, internal): self.internal = internal 2913 def get_id(self): return self.id 2914 def set_id(self, id): self.id = id 2915 def export(self, outfile, level, namespace_='', name_='docSect1Type', namespacedef_=''): 2916 showIndent(outfile, level) 2917 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 2918 self.exportAttributes(outfile, level, namespace_, name_='docSect1Type') 2919 outfile.write('>') 2920 self.exportChildren(outfile, level + 1, namespace_, name_) 2921 outfile.write('</%s%s>\n' % (namespace_, name_)) 2922 def exportAttributes(self, outfile, level, namespace_='', name_='docSect1Type'): 2923 if self.id is not None: 2924 outfile.write(' id=%s' % (self.format_string(quote_attrib(self.id).encode(ExternalEncoding), input_name='id'), )) 2925 def exportChildren(self, outfile, level, namespace_='', name_='docSect1Type'): 2926 for item_ in self.content_: 2927 item_.export(outfile, level, item_.name, namespace_) 2928 def hasContent_(self): 2929 if ( 2930 self.title is not None or 2931 self.para is not None or 2932 self.sect2 is not None or 2933 self.internal is not None 2934 ): 2935 return True 2936 else: 2937 return False 2938 def build(self, node_): 2939 attrs = node_.attributes 2940 self.buildAttributes(attrs) 2941 for child_ in node_.childNodes: 2942 nodeName_ = child_.nodeName.split(':')[-1] 2943 self.buildChildren(child_, nodeName_) 2944 def buildAttributes(self, attrs): 2945 if attrs.get('id'): 2946 self.id = attrs.get('id').value 2947 def buildChildren(self, child_, nodeName_): 2948 if child_.nodeType == Node.ELEMENT_NODE and \ 2949 nodeName_ == 'title': 2950 self.title = child_.childNodes[0].nodeValue 2951 elif child_.nodeType == Node.ELEMENT_NODE and \ 2952 nodeName_ == 'para': 2953 childobj_ = docParaType.factory() 2954 childobj_.build(child_) 2955 obj_ = self.mixedclass_(MixedContainer.CategoryComplex, 2956 MixedContainer.TypeNone, 'para', childobj_) 2957 self.content_.append(obj_) 2958 elif child_.nodeType == Node.ELEMENT_NODE and \ 2959 nodeName_ == 'sect2': 2960 childobj_ = docSect2Type.factory() 2961 childobj_.build(child_) 2962 obj_ = self.mixedclass_(MixedContainer.CategoryComplex, 2963 MixedContainer.TypeNone, 'sect2', childobj_) 2964 self.content_.append(obj_) 2965 elif child_.nodeType == Node.ELEMENT_NODE and \ 2966 nodeName_ == 'internal': 2967 childobj_ = docInternalS1Type.factory() 2968 childobj_.build(child_) 2969 obj_ = self.mixedclass_(MixedContainer.CategoryComplex, 2970 MixedContainer.TypeNone, 'internal', childobj_) 2971 self.content_.append(obj_) 2972 elif child_.nodeType == Node.TEXT_NODE: 2973 obj_ = self.mixedclass_(MixedContainer.CategoryText, 2974 MixedContainer.TypeNone, '', child_.nodeValue) 2975 self.content_.append(obj_) 2976# end class docSect1Type 2977 2978 2979class docSect2Type(GeneratedsSuper): 2980 subclass = None 2981 superclass = None 2982 def __init__(self, id=None, title=None, para=None, sect3=None, internal=None, mixedclass_=None, content_=None): 2983 self.id = id 2984 if mixedclass_ is None: 2985 self.mixedclass_ = MixedContainer 2986 else: 2987 self.mixedclass_ = mixedclass_ 2988 if content_ is None: 2989 self.content_ = [] 2990 else: 2991 self.content_ = content_ 2992 if title is None: 2993 title = "" 2994 else: 2995 title = title 2996 def factory(*args_, **kwargs_): 2997 if docSect2Type.subclass: 2998 return docSect2Type.subclass(*args_, **kwargs_) 2999 else: 3000 return docSect2Type(*args_, **kwargs_) 3001 factory = staticmethod(factory) 3002 def get_title(self): return self.title 3003 def set_title(self, title): self.title = title 3004 def get_para(self): return self.para 3005 def set_para(self, para): self.para = para 3006 def add_para(self, value): self.para.append(value) 3007 def insert_para(self, index, value): self.para[index] = value 3008 def get_sect3(self): return self.sect3 3009 def set_sect3(self, sect3): self.sect3 = sect3 3010 def add_sect3(self, value): self.sect3.append(value) 3011 def insert_sect3(self, index, value): self.sect3[index] = value 3012 def get_internal(self): return self.internal 3013 def set_internal(self, internal): self.internal = internal 3014 def get_id(self): return self.id 3015 def set_id(self, id): self.id = id 3016 def export(self, outfile, level, namespace_='', name_='docSect2Type', namespacedef_=''): 3017 showIndent(outfile, level) 3018 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 3019 self.exportAttributes(outfile, level, namespace_, name_='docSect2Type') 3020 outfile.write('>') 3021 self.exportChildren(outfile, level + 1, namespace_, name_) 3022 outfile.write('</%s%s>\n' % (namespace_, name_)) 3023 def exportAttributes(self, outfile, level, namespace_='', name_='docSect2Type'): 3024 if self.id is not None: 3025 outfile.write(' id=%s' % (self.format_string(quote_attrib(self.id).encode(ExternalEncoding), input_name='id'), )) 3026 def exportChildren(self, outfile, level, namespace_='', name_='docSect2Type'): 3027 for item_ in self.content_: 3028 item_.export(outfile, level, item_.name, namespace_) 3029 def hasContent_(self): 3030 if ( 3031 self.title is not None or 3032 self.para is not None or 3033 self.sect3 is not None or 3034 self.internal is not None 3035 ): 3036 return True 3037 else: 3038 return False 3039 def build(self, node_): 3040 attrs = node_.attributes 3041 self.buildAttributes(attrs) 3042 for child_ in node_.childNodes: 3043 nodeName_ = child_.nodeName.split(':')[-1] 3044 self.buildChildren(child_, nodeName_) 3045 def buildAttributes(self, attrs): 3046 if attrs.get('id'): 3047 self.id = attrs.get('id').value 3048 def buildChildren(self, child_, nodeName_): 3049 if child_.nodeType == Node.ELEMENT_NODE and \ 3050 nodeName_ == 'title': 3051 self.title = child_.childNodes[0].nodeValue 3052 elif child_.nodeType == Node.ELEMENT_NODE and \ 3053 nodeName_ == 'para': 3054 childobj_ = docParaType.factory() 3055 childobj_.build(child_) 3056 obj_ = self.mixedclass_(MixedContainer.CategoryComplex, 3057 MixedContainer.TypeNone, 'para', childobj_) 3058 self.content_.append(obj_) 3059 elif child_.nodeType == Node.ELEMENT_NODE and \ 3060 nodeName_ == 'sect3': 3061 childobj_ = docSect3Type.factory() 3062 childobj_.build(child_) 3063 obj_ = self.mixedclass_(MixedContainer.CategoryComplex, 3064 MixedContainer.TypeNone, 'sect3', childobj_) 3065 self.content_.append(obj_) 3066 elif child_.nodeType == Node.ELEMENT_NODE and \ 3067 nodeName_ == 'internal': 3068 childobj_ = docInternalS2Type.factory() 3069 childobj_.build(child_) 3070 obj_ = self.mixedclass_(MixedContainer.CategoryComplex, 3071 MixedContainer.TypeNone, 'internal', childobj_) 3072 self.content_.append(obj_) 3073 elif child_.nodeType == Node.TEXT_NODE: 3074 obj_ = self.mixedclass_(MixedContainer.CategoryText, 3075 MixedContainer.TypeNone, '', child_.nodeValue) 3076 self.content_.append(obj_) 3077# end class docSect2Type 3078 3079 3080class docSect3Type(GeneratedsSuper): 3081 subclass = None 3082 superclass = None 3083 def __init__(self, id=None, title=None, para=None, sect4=None, internal=None, mixedclass_=None, content_=None): 3084 self.id = id 3085 if mixedclass_ is None: 3086 self.mixedclass_ = MixedContainer 3087 else: 3088 self.mixedclass_ = mixedclass_ 3089 if content_ is None: 3090 self.content_ = [] 3091 else: 3092 self.content_ = content_ 3093 if title is None: 3094 self.title = "" 3095 else: 3096 self.title = title 3097 def factory(*args_, **kwargs_): 3098 if docSect3Type.subclass: 3099 return docSect3Type.subclass(*args_, **kwargs_) 3100 else: 3101 return docSect3Type(*args_, **kwargs_) 3102 factory = staticmethod(factory) 3103 def get_title(self): return self.title 3104 def set_title(self, title): self.title = title 3105 def get_para(self): return self.para 3106 def set_para(self, para): self.para = para 3107 def add_para(self, value): self.para.append(value) 3108 def insert_para(self, index, value): self.para[index] = value 3109 def get_sect4(self): return self.sect4 3110 def set_sect4(self, sect4): self.sect4 = sect4 3111 def add_sect4(self, value): self.sect4.append(value) 3112 def insert_sect4(self, index, value): self.sect4[index] = value 3113 def get_internal(self): return self.internal 3114 def set_internal(self, internal): self.internal = internal 3115 def get_id(self): return self.id 3116 def set_id(self, id): self.id = id 3117 def export(self, outfile, level, namespace_='', name_='docSect3Type', namespacedef_=''): 3118 showIndent(outfile, level) 3119 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 3120 self.exportAttributes(outfile, level, namespace_, name_='docSect3Type') 3121 outfile.write('>') 3122 self.exportChildren(outfile, level + 1, namespace_, name_) 3123 outfile.write('</%s%s>\n' % (namespace_, name_)) 3124 def exportAttributes(self, outfile, level, namespace_='', name_='docSect3Type'): 3125 if self.id is not None: 3126 outfile.write(' id=%s' % (self.format_string(quote_attrib(self.id).encode(ExternalEncoding), input_name='id'), )) 3127 def exportChildren(self, outfile, level, namespace_='', name_='docSect3Type'): 3128 for item_ in self.content_: 3129 item_.export(outfile, level, item_.name, namespace_) 3130 def hasContent_(self): 3131 if ( 3132 self.title is not None or 3133 self.para is not None or 3134 self.sect4 is not None or 3135 self.internal is not None 3136 ): 3137 return True 3138 else: 3139 return False 3140 def build(self, node_): 3141 attrs = node_.attributes 3142 self.buildAttributes(attrs) 3143 for child_ in node_.childNodes: 3144 nodeName_ = child_.nodeName.split(':')[-1] 3145 self.buildChildren(child_, nodeName_) 3146 def buildAttributes(self, attrs): 3147 if attrs.get('id'): 3148 self.id = attrs.get('id').value 3149 def buildChildren(self, child_, nodeName_): 3150 if child_.nodeType == Node.ELEMENT_NODE and \ 3151 nodeName_ == 'title': 3152 self.title = child_.childNodes[0].nodeValue 3153 elif child_.nodeType == Node.ELEMENT_NODE and \ 3154 nodeName_ == 'para': 3155 childobj_ = docParaType.factory() 3156 childobj_.build(child_) 3157 obj_ = self.mixedclass_(MixedContainer.CategoryComplex, 3158 MixedContainer.TypeNone, 'para', childobj_) 3159 self.content_.append(obj_) 3160 elif child_.nodeType == Node.ELEMENT_NODE and \ 3161 nodeName_ == 'sect4': 3162 childobj_ = docSect4Type.factory() 3163 childobj_.build(child_) 3164 obj_ = self.mixedclass_(MixedContainer.CategoryComplex, 3165 MixedContainer.TypeNone, 'sect4', childobj_) 3166 self.content_.append(obj_) 3167 elif child_.nodeType == Node.ELEMENT_NODE and \ 3168 nodeName_ == 'internal': 3169 childobj_ = docInternalS3Type.factory() 3170 childobj_.build(child_) 3171 obj_ = self.mixedclass_(MixedContainer.CategoryComplex, 3172 MixedContainer.TypeNone, 'internal', childobj_) 3173 self.content_.append(obj_) 3174 elif child_.nodeType == Node.TEXT_NODE: 3175 obj_ = self.mixedclass_(MixedContainer.CategoryText, 3176 MixedContainer.TypeNone, '', child_.nodeValue) 3177 self.content_.append(obj_) 3178# end class docSect3Type 3179 3180 3181class docSect4Type(GeneratedsSuper): 3182 subclass = None 3183 superclass = None 3184 def __init__(self, id=None, title=None, para=None, internal=None, mixedclass_=None, content_=None): 3185 self.id = id 3186 if mixedclass_ is None: 3187 self.mixedclass_ = MixedContainer 3188 else: 3189 self.mixedclass_ = mixedclass_ 3190 if content_ is None: 3191 self.content_ = [] 3192 else: 3193 self.content_ = content_ 3194 def factory(*args_, **kwargs_): 3195 if docSect4Type.subclass: 3196 return docSect4Type.subclass(*args_, **kwargs_) 3197 else: 3198 return docSect4Type(*args_, **kwargs_) 3199 factory = staticmethod(factory) 3200 def get_title(self): return self.title 3201 def set_title(self, title): self.title = title 3202 def get_para(self): return self.para 3203 def set_para(self, para): self.para = para 3204 def add_para(self, value): self.para.append(value) 3205 def insert_para(self, index, value): self.para[index] = value 3206 def get_internal(self): return self.internal 3207 def set_internal(self, internal): self.internal = internal 3208 def get_id(self): return self.id 3209 def set_id(self, id): self.id = id 3210 def export(self, outfile, level, namespace_='', name_='docSect4Type', namespacedef_=''): 3211 showIndent(outfile, level) 3212 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 3213 self.exportAttributes(outfile, level, namespace_, name_='docSect4Type') 3214 outfile.write('>') 3215 self.exportChildren(outfile, level + 1, namespace_, name_) 3216 outfile.write('</%s%s>\n' % (namespace_, name_)) 3217 def exportAttributes(self, outfile, level, namespace_='', name_='docSect4Type'): 3218 if self.id is not None: 3219 outfile.write(' id=%s' % (self.format_string(quote_attrib(self.id).encode(ExternalEncoding), input_name='id'), )) 3220 def exportChildren(self, outfile, level, namespace_='', name_='docSect4Type'): 3221 for item_ in self.content_: 3222 item_.export(outfile, level, item_.name, namespace_) 3223 def hasContent_(self): 3224 if ( 3225 self.title is not None or 3226 self.para is not None or 3227 self.internal is not None 3228 ): 3229 return True 3230 else: 3231 return False 3232 def build(self, node_): 3233 attrs = node_.attributes 3234 self.buildAttributes(attrs) 3235 for child_ in node_.childNodes: 3236 nodeName_ = child_.nodeName.split(':')[-1] 3237 self.buildChildren(child_, nodeName_) 3238 def buildAttributes(self, attrs): 3239 if attrs.get('id'): 3240 self.id = attrs.get('id').value 3241 def buildChildren(self, child_, nodeName_): 3242 if child_.nodeType == Node.ELEMENT_NODE and \ 3243 nodeName_ == 'title': 3244 childobj_ = docTitleType.factory() 3245 childobj_.build(child_) 3246 obj_ = self.mixedclass_(MixedContainer.CategoryComplex, 3247 MixedContainer.TypeNone, 'title', childobj_) 3248 self.content_.append(obj_) 3249 elif child_.nodeType == Node.ELEMENT_NODE and \ 3250 nodeName_ == 'para': 3251 childobj_ = docParaType.factory() 3252 childobj_.build(child_) 3253 obj_ = self.mixedclass_(MixedContainer.CategoryComplex, 3254 MixedContainer.TypeNone, 'para', childobj_) 3255 self.content_.append(obj_) 3256 elif child_.nodeType == Node.ELEMENT_NODE and \ 3257 nodeName_ == 'internal': 3258 childobj_ = docInternalS4Type.factory() 3259 childobj_.build(child_) 3260 obj_ = self.mixedclass_(MixedContainer.CategoryComplex, 3261 MixedContainer.TypeNone, 'internal', childobj_) 3262 self.content_.append(obj_) 3263 elif child_.nodeType == Node.TEXT_NODE: 3264 obj_ = self.mixedclass_(MixedContainer.CategoryText, 3265 MixedContainer.TypeNone, '', child_.nodeValue) 3266 self.content_.append(obj_) 3267# end class docSect4Type 3268 3269 3270class docInternalType(GeneratedsSuper): 3271 subclass = None 3272 superclass = None 3273 def __init__(self, para=None, sect1=None, mixedclass_=None, content_=None): 3274 if mixedclass_ is None: 3275 self.mixedclass_ = MixedContainer 3276 else: 3277 self.mixedclass_ = mixedclass_ 3278 if content_ is None: 3279 self.content_ = [] 3280 else: 3281 self.content_ = content_ 3282 def factory(*args_, **kwargs_): 3283 if docInternalType.subclass: 3284 return docInternalType.subclass(*args_, **kwargs_) 3285 else: 3286 return docInternalType(*args_, **kwargs_) 3287 factory = staticmethod(factory) 3288 def get_para(self): return self.para 3289 def set_para(self, para): self.para = para 3290 def add_para(self, value): self.para.append(value) 3291 def insert_para(self, index, value): self.para[index] = value 3292 def get_sect1(self): return self.sect1 3293 def set_sect1(self, sect1): self.sect1 = sect1 3294 def add_sect1(self, value): self.sect1.append(value) 3295 def insert_sect1(self, index, value): self.sect1[index] = value 3296 def export(self, outfile, level, namespace_='', name_='docInternalType', namespacedef_=''): 3297 showIndent(outfile, level) 3298 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 3299 self.exportAttributes(outfile, level, namespace_, name_='docInternalType') 3300 outfile.write('>') 3301 self.exportChildren(outfile, level + 1, namespace_, name_) 3302 outfile.write('</%s%s>\n' % (namespace_, name_)) 3303 def exportAttributes(self, outfile, level, namespace_='', name_='docInternalType'): 3304 pass 3305 def exportChildren(self, outfile, level, namespace_='', name_='docInternalType'): 3306 for item_ in self.content_: 3307 item_.export(outfile, level, item_.name, namespace_) 3308 def hasContent_(self): 3309 if ( 3310 self.para is not None or 3311 self.sect1 is not None 3312 ): 3313 return True 3314 else: 3315 return False 3316 def build(self, node_): 3317 attrs = node_.attributes 3318 self.buildAttributes(attrs) 3319 for child_ in node_.childNodes: 3320 nodeName_ = child_.nodeName.split(':')[-1] 3321 self.buildChildren(child_, nodeName_) 3322 def buildAttributes(self, attrs): 3323 pass 3324 def buildChildren(self, child_, nodeName_): 3325 if child_.nodeType == Node.ELEMENT_NODE and \ 3326 nodeName_ == 'para': 3327 childobj_ = docParaType.factory() 3328 childobj_.build(child_) 3329 obj_ = self.mixedclass_(MixedContainer.CategoryComplex, 3330 MixedContainer.TypeNone, 'para', childobj_) 3331 self.content_.append(obj_) 3332 elif child_.nodeType == Node.ELEMENT_NODE and \ 3333 nodeName_ == 'sect1': 3334 childobj_ = docSect1Type.factory() 3335 childobj_.build(child_) 3336 obj_ = self.mixedclass_(MixedContainer.CategoryComplex, 3337 MixedContainer.TypeNone, 'sect1', childobj_) 3338 self.content_.append(obj_) 3339 elif child_.nodeType == Node.TEXT_NODE: 3340 obj_ = self.mixedclass_(MixedContainer.CategoryText, 3341 MixedContainer.TypeNone, '', child_.nodeValue) 3342 self.content_.append(obj_) 3343# end class docInternalType 3344 3345 3346class docInternalS1Type(GeneratedsSuper): 3347 subclass = None 3348 superclass = None 3349 def __init__(self, para=None, sect2=None, mixedclass_=None, content_=None): 3350 if mixedclass_ is None: 3351 self.mixedclass_ = MixedContainer 3352 else: 3353 self.mixedclass_ = mixedclass_ 3354 if content_ is None: 3355 self.content_ = [] 3356 else: 3357 self.content_ = content_ 3358 def factory(*args_, **kwargs_): 3359 if docInternalS1Type.subclass: 3360 return docInternalS1Type.subclass(*args_, **kwargs_) 3361 else: 3362 return docInternalS1Type(*args_, **kwargs_) 3363 factory = staticmethod(factory) 3364 def get_para(self): return self.para 3365 def set_para(self, para): self.para = para 3366 def add_para(self, value): self.para.append(value) 3367 def insert_para(self, index, value): self.para[index] = value 3368 def get_sect2(self): return self.sect2 3369 def set_sect2(self, sect2): self.sect2 = sect2 3370 def add_sect2(self, value): self.sect2.append(value) 3371 def insert_sect2(self, index, value): self.sect2[index] = value 3372 def export(self, outfile, level, namespace_='', name_='docInternalS1Type', namespacedef_=''): 3373 showIndent(outfile, level) 3374 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 3375 self.exportAttributes(outfile, level, namespace_, name_='docInternalS1Type') 3376 outfile.write('>') 3377 self.exportChildren(outfile, level + 1, namespace_, name_) 3378 outfile.write('</%s%s>\n' % (namespace_, name_)) 3379 def exportAttributes(self, outfile, level, namespace_='', name_='docInternalS1Type'): 3380 pass 3381 def exportChildren(self, outfile, level, namespace_='', name_='docInternalS1Type'): 3382 for item_ in self.content_: 3383 item_.export(outfile, level, item_.name, namespace_) 3384 def hasContent_(self): 3385 if ( 3386 self.para is not None or 3387 self.sect2 is not None 3388 ): 3389 return True 3390 else: 3391 return False 3392 def build(self, node_): 3393 attrs = node_.attributes 3394 self.buildAttributes(attrs) 3395 for child_ in node_.childNodes: 3396 nodeName_ = child_.nodeName.split(':')[-1] 3397 self.buildChildren(child_, nodeName_) 3398 def buildAttributes(self, attrs): 3399 pass 3400 def buildChildren(self, child_, nodeName_): 3401 if child_.nodeType == Node.ELEMENT_NODE and \ 3402 nodeName_ == 'para': 3403 childobj_ = docParaType.factory() 3404 childobj_.build(child_) 3405 obj_ = self.mixedclass_(MixedContainer.CategoryComplex, 3406 MixedContainer.TypeNone, 'para', childobj_) 3407 self.content_.append(obj_) 3408 elif child_.nodeType == Node.ELEMENT_NODE and \ 3409 nodeName_ == 'sect2': 3410 childobj_ = docSect2Type.factory() 3411 childobj_.build(child_) 3412 obj_ = self.mixedclass_(MixedContainer.CategoryComplex, 3413 MixedContainer.TypeNone, 'sect2', childobj_) 3414 self.content_.append(obj_) 3415 elif child_.nodeType == Node.TEXT_NODE: 3416 obj_ = self.mixedclass_(MixedContainer.CategoryText, 3417 MixedContainer.TypeNone, '', child_.nodeValue) 3418 self.content_.append(obj_) 3419# end class docInternalS1Type 3420 3421 3422class docInternalS2Type(GeneratedsSuper): 3423 subclass = None 3424 superclass = None 3425 def __init__(self, para=None, sect3=None, mixedclass_=None, content_=None): 3426 if mixedclass_ is None: 3427 self.mixedclass_ = MixedContainer 3428 else: 3429 self.mixedclass_ = mixedclass_ 3430 if content_ is None: 3431 self.content_ = [] 3432 else: 3433 self.content_ = content_ 3434 def factory(*args_, **kwargs_): 3435 if docInternalS2Type.subclass: 3436 return docInternalS2Type.subclass(*args_, **kwargs_) 3437 else: 3438 return docInternalS2Type(*args_, **kwargs_) 3439 factory = staticmethod(factory) 3440 def get_para(self): return self.para 3441 def set_para(self, para): self.para = para 3442 def add_para(self, value): self.para.append(value) 3443 def insert_para(self, index, value): self.para[index] = value 3444 def get_sect3(self): return self.sect3 3445 def set_sect3(self, sect3): self.sect3 = sect3 3446 def add_sect3(self, value): self.sect3.append(value) 3447 def insert_sect3(self, index, value): self.sect3[index] = value 3448 def export(self, outfile, level, namespace_='', name_='docInternalS2Type', namespacedef_=''): 3449 showIndent(outfile, level) 3450 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 3451 self.exportAttributes(outfile, level, namespace_, name_='docInternalS2Type') 3452 outfile.write('>') 3453 self.exportChildren(outfile, level + 1, namespace_, name_) 3454 outfile.write('</%s%s>\n' % (namespace_, name_)) 3455 def exportAttributes(self, outfile, level, namespace_='', name_='docInternalS2Type'): 3456 pass 3457 def exportChildren(self, outfile, level, namespace_='', name_='docInternalS2Type'): 3458 for item_ in self.content_: 3459 item_.export(outfile, level, item_.name, namespace_) 3460 def hasContent_(self): 3461 if ( 3462 self.para is not None or 3463 self.sect3 is not None 3464 ): 3465 return True 3466 else: 3467 return False 3468 def build(self, node_): 3469 attrs = node_.attributes 3470 self.buildAttributes(attrs) 3471 for child_ in node_.childNodes: 3472 nodeName_ = child_.nodeName.split(':')[-1] 3473 self.buildChildren(child_, nodeName_) 3474 def buildAttributes(self, attrs): 3475 pass 3476 def buildChildren(self, child_, nodeName_): 3477 if child_.nodeType == Node.ELEMENT_NODE and \ 3478 nodeName_ == 'para': 3479 childobj_ = docParaType.factory() 3480 childobj_.build(child_) 3481 obj_ = self.mixedclass_(MixedContainer.CategoryComplex, 3482 MixedContainer.TypeNone, 'para', childobj_) 3483 self.content_.append(obj_) 3484 elif child_.nodeType == Node.ELEMENT_NODE and \ 3485 nodeName_ == 'sect3': 3486 childobj_ = docSect3Type.factory() 3487 childobj_.build(child_) 3488 obj_ = self.mixedclass_(MixedContainer.CategoryComplex, 3489 MixedContainer.TypeNone, 'sect3', childobj_) 3490 self.content_.append(obj_) 3491 elif child_.nodeType == Node.TEXT_NODE: 3492 obj_ = self.mixedclass_(MixedContainer.CategoryText, 3493 MixedContainer.TypeNone, '', child_.nodeValue) 3494 self.content_.append(obj_) 3495# end class docInternalS2Type 3496 3497 3498class docInternalS3Type(GeneratedsSuper): 3499 subclass = None 3500 superclass = None 3501 def __init__(self, para=None, sect3=None, mixedclass_=None, content_=None): 3502 if mixedclass_ is None: 3503 self.mixedclass_ = MixedContainer 3504 else: 3505 self.mixedclass_ = mixedclass_ 3506 if content_ is None: 3507 self.content_ = [] 3508 else: 3509 self.content_ = content_ 3510 def factory(*args_, **kwargs_): 3511 if docInternalS3Type.subclass: 3512 return docInternalS3Type.subclass(*args_, **kwargs_) 3513 else: 3514 return docInternalS3Type(*args_, **kwargs_) 3515 factory = staticmethod(factory) 3516 def get_para(self): return self.para 3517 def set_para(self, para): self.para = para 3518 def add_para(self, value): self.para.append(value) 3519 def insert_para(self, index, value): self.para[index] = value 3520 def get_sect3(self): return self.sect3 3521 def set_sect3(self, sect3): self.sect3 = sect3 3522 def add_sect3(self, value): self.sect3.append(value) 3523 def insert_sect3(self, index, value): self.sect3[index] = value 3524 def export(self, outfile, level, namespace_='', name_='docInternalS3Type', namespacedef_=''): 3525 showIndent(outfile, level) 3526 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 3527 self.exportAttributes(outfile, level, namespace_, name_='docInternalS3Type') 3528 outfile.write('>') 3529 self.exportChildren(outfile, level + 1, namespace_, name_) 3530 outfile.write('</%s%s>\n' % (namespace_, name_)) 3531 def exportAttributes(self, outfile, level, namespace_='', name_='docInternalS3Type'): 3532 pass 3533 def exportChildren(self, outfile, level, namespace_='', name_='docInternalS3Type'): 3534 for item_ in self.content_: 3535 item_.export(outfile, level, item_.name, namespace_) 3536 def hasContent_(self): 3537 if ( 3538 self.para is not None or 3539 self.sect3 is not None 3540 ): 3541 return True 3542 else: 3543 return False 3544 def build(self, node_): 3545 attrs = node_.attributes 3546 self.buildAttributes(attrs) 3547 for child_ in node_.childNodes: 3548 nodeName_ = child_.nodeName.split(':')[-1] 3549 self.buildChildren(child_, nodeName_) 3550 def buildAttributes(self, attrs): 3551 pass 3552 def buildChildren(self, child_, nodeName_): 3553 if child_.nodeType == Node.ELEMENT_NODE and \ 3554 nodeName_ == 'para': 3555 childobj_ = docParaType.factory() 3556 childobj_.build(child_) 3557 obj_ = self.mixedclass_(MixedContainer.CategoryComplex, 3558 MixedContainer.TypeNone, 'para', childobj_) 3559 self.content_.append(obj_) 3560 elif child_.nodeType == Node.ELEMENT_NODE and \ 3561 nodeName_ == 'sect3': 3562 childobj_ = docSect4Type.factory() 3563 childobj_.build(child_) 3564 obj_ = self.mixedclass_(MixedContainer.CategoryComplex, 3565 MixedContainer.TypeNone, 'sect3', childobj_) 3566 self.content_.append(obj_) 3567 elif child_.nodeType == Node.TEXT_NODE: 3568 obj_ = self.mixedclass_(MixedContainer.CategoryText, 3569 MixedContainer.TypeNone, '', child_.nodeValue) 3570 self.content_.append(obj_) 3571# end class docInternalS3Type 3572 3573 3574class docInternalS4Type(GeneratedsSuper): 3575 subclass = None 3576 superclass = None 3577 def __init__(self, para=None, mixedclass_=None, content_=None): 3578 if mixedclass_ is None: 3579 self.mixedclass_ = MixedContainer 3580 else: 3581 self.mixedclass_ = mixedclass_ 3582 if content_ is None: 3583 self.content_ = [] 3584 else: 3585 self.content_ = content_ 3586 def factory(*args_, **kwargs_): 3587 if docInternalS4Type.subclass: 3588 return docInternalS4Type.subclass(*args_, **kwargs_) 3589 else: 3590 return docInternalS4Type(*args_, **kwargs_) 3591 factory = staticmethod(factory) 3592 def get_para(self): return self.para 3593 def set_para(self, para): self.para = para 3594 def add_para(self, value): self.para.append(value) 3595 def insert_para(self, index, value): self.para[index] = value 3596 def export(self, outfile, level, namespace_='', name_='docInternalS4Type', namespacedef_=''): 3597 showIndent(outfile, level) 3598 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 3599 self.exportAttributes(outfile, level, namespace_, name_='docInternalS4Type') 3600 outfile.write('>') 3601 self.exportChildren(outfile, level + 1, namespace_, name_) 3602 outfile.write('</%s%s>\n' % (namespace_, name_)) 3603 def exportAttributes(self, outfile, level, namespace_='', name_='docInternalS4Type'): 3604 pass 3605 def exportChildren(self, outfile, level, namespace_='', name_='docInternalS4Type'): 3606 for item_ in self.content_: 3607 item_.export(outfile, level, item_.name, namespace_) 3608 def hasContent_(self): 3609 if ( 3610 self.para is not None 3611 ): 3612 return True 3613 else: 3614 return False 3615 def build(self, node_): 3616 attrs = node_.attributes 3617 self.buildAttributes(attrs) 3618 for child_ in node_.childNodes: 3619 nodeName_ = child_.nodeName.split(':')[-1] 3620 self.buildChildren(child_, nodeName_) 3621 def buildAttributes(self, attrs): 3622 pass 3623 def buildChildren(self, child_, nodeName_): 3624 if child_.nodeType == Node.ELEMENT_NODE and \ 3625 nodeName_ == 'para': 3626 childobj_ = docParaType.factory() 3627 childobj_.build(child_) 3628 obj_ = self.mixedclass_(MixedContainer.CategoryComplex, 3629 MixedContainer.TypeNone, 'para', childobj_) 3630 self.content_.append(obj_) 3631 elif child_.nodeType == Node.TEXT_NODE: 3632 obj_ = self.mixedclass_(MixedContainer.CategoryText, 3633 MixedContainer.TypeNone, '', child_.nodeValue) 3634 self.content_.append(obj_) 3635# end class docInternalS4Type 3636 3637 3638class docTitleType(GeneratedsSuper): 3639 subclass = None 3640 superclass = None 3641 def __init__(self, valueOf_='', mixedclass_=None, content_=None): 3642 if mixedclass_ is None: 3643 self.mixedclass_ = MixedContainer 3644 else: 3645 self.mixedclass_ = mixedclass_ 3646 if content_ is None: 3647 self.content_ = [] 3648 else: 3649 self.content_ = content_ 3650 def factory(*args_, **kwargs_): 3651 if docTitleType.subclass: 3652 return docTitleType.subclass(*args_, **kwargs_) 3653 else: 3654 return docTitleType(*args_, **kwargs_) 3655 factory = staticmethod(factory) 3656 def getValueOf_(self): return self.valueOf_ 3657 def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ 3658 def export(self, outfile, level, namespace_='', name_='docTitleType', namespacedef_=''): 3659 showIndent(outfile, level) 3660 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 3661 self.exportAttributes(outfile, level, namespace_, name_='docTitleType') 3662 outfile.write('>') 3663 self.exportChildren(outfile, level + 1, namespace_, name_) 3664 outfile.write('</%s%s>\n' % (namespace_, name_)) 3665 def exportAttributes(self, outfile, level, namespace_='', name_='docTitleType'): 3666 pass 3667 def exportChildren(self, outfile, level, namespace_='', name_='docTitleType'): 3668 if self.valueOf_.find('![CDATA')>-1: 3669 value=quote_xml('%s' % self.valueOf_) 3670 value=value.replace('![CDATA','<![CDATA') 3671 value=value.replace(']]',']]>') 3672 outfile.write(value) 3673 else: 3674 outfile.write(quote_xml('%s' % self.valueOf_)) 3675 def hasContent_(self): 3676 if ( 3677 self.valueOf_ is not None 3678 ): 3679 return True 3680 else: 3681 return False 3682 def build(self, node_): 3683 attrs = node_.attributes 3684 self.buildAttributes(attrs) 3685 self.valueOf_ = '' 3686 for child_ in node_.childNodes: 3687 nodeName_ = child_.nodeName.split(':')[-1] 3688 self.buildChildren(child_, nodeName_) 3689 def buildAttributes(self, attrs): 3690 pass 3691 def buildChildren(self, child_, nodeName_): 3692 if child_.nodeType == Node.TEXT_NODE: 3693 obj_ = self.mixedclass_(MixedContainer.CategoryText, 3694 MixedContainer.TypeNone, '', child_.nodeValue) 3695 self.content_.append(obj_) 3696 if child_.nodeType == Node.TEXT_NODE: 3697 self.valueOf_ += child_.nodeValue 3698 elif child_.nodeType == Node.CDATA_SECTION_NODE: 3699 self.valueOf_ += '![CDATA['+child_.nodeValue+']]' 3700# end class docTitleType 3701 3702 3703class docParaType(GeneratedsSuper): 3704 subclass = None 3705 superclass = None 3706 def __init__(self, valueOf_='', mixedclass_=None, content_=None): 3707 if mixedclass_ is None: 3708 self.mixedclass_ = MixedContainer 3709 else: 3710 self.mixedclass_ = mixedclass_ 3711 if content_ is None: 3712 self.content_ = [] 3713 else: 3714 self.content_ = content_ 3715 def factory(*args_, **kwargs_): 3716 if docParaType.subclass: 3717 return docParaType.subclass(*args_, **kwargs_) 3718 else: 3719 return docParaType(*args_, **kwargs_) 3720 factory = staticmethod(factory) 3721 def getValueOf_(self): return self.valueOf_ 3722 def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ 3723 def export(self, outfile, level, namespace_='', name_='docParaType', namespacedef_=''): 3724 showIndent(outfile, level) 3725 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 3726 self.exportAttributes(outfile, level, namespace_, name_='docParaType') 3727 outfile.write('>') 3728 self.exportChildren(outfile, level + 1, namespace_, name_) 3729 outfile.write('</%s%s>\n' % (namespace_, name_)) 3730 def exportAttributes(self, outfile, level, namespace_='', name_='docParaType'): 3731 pass 3732 def exportChildren(self, outfile, level, namespace_='', name_='docParaType'): 3733 if self.valueOf_.find('![CDATA')>-1: 3734 value=quote_xml('%s' % self.valueOf_) 3735 value=value.replace('![CDATA','<![CDATA') 3736 value=value.replace(']]',']]>') 3737 outfile.write(value) 3738 else: 3739 outfile.write(quote_xml('%s' % self.valueOf_)) 3740 def hasContent_(self): 3741 if ( 3742 self.valueOf_ is not None 3743 ): 3744 return True 3745 else: 3746 return False 3747 def build(self, node_): 3748 attrs = node_.attributes 3749 self.buildAttributes(attrs) 3750 self.valueOf_ = '' 3751 for child_ in node_.childNodes: 3752 nodeName_ = child_.nodeName.split(':')[-1] 3753 self.buildChildren(child_, nodeName_) 3754 def buildAttributes(self, attrs): 3755 pass 3756 def buildChildren(self, child_, nodeName_): 3757 if child_.nodeType == Node.TEXT_NODE: 3758 obj_ = self.mixedclass_(MixedContainer.CategoryText, 3759 MixedContainer.TypeNone, '', child_.nodeValue) 3760 self.content_.append(obj_) 3761 if child_.nodeType == Node.TEXT_NODE: 3762 self.valueOf_ += child_.nodeValue 3763 elif child_.nodeType == Node.CDATA_SECTION_NODE: 3764 self.valueOf_ += '![CDATA['+child_.nodeValue+']]' 3765# end class docParaType 3766 3767 3768class docMarkupType(GeneratedsSuper): 3769 subclass = None 3770 superclass = None 3771 def __init__(self, valueOf_='', mixedclass_=None, content_=None): 3772 if mixedclass_ is None: 3773 self.mixedclass_ = MixedContainer 3774 else: 3775 self.mixedclass_ = mixedclass_ 3776 if content_ is None: 3777 self.content_ = [] 3778 else: 3779 self.content_ = content_ 3780 def factory(*args_, **kwargs_): 3781 if docMarkupType.subclass: 3782 return docMarkupType.subclass(*args_, **kwargs_) 3783 else: 3784 return docMarkupType(*args_, **kwargs_) 3785 factory = staticmethod(factory) 3786 def getValueOf_(self): return self.valueOf_ 3787 def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ 3788 def export(self, outfile, level, namespace_='', name_='docMarkupType', namespacedef_=''): 3789 showIndent(outfile, level) 3790 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 3791 self.exportAttributes(outfile, level, namespace_, name_='docMarkupType') 3792 outfile.write('>') 3793 self.exportChildren(outfile, level + 1, namespace_, name_) 3794 outfile.write('</%s%s>\n' % (namespace_, name_)) 3795 def exportAttributes(self, outfile, level, namespace_='', name_='docMarkupType'): 3796 pass 3797 def exportChildren(self, outfile, level, namespace_='', name_='docMarkupType'): 3798 if self.valueOf_.find('![CDATA')>-1: 3799 value=quote_xml('%s' % self.valueOf_) 3800 value=value.replace('![CDATA','<![CDATA') 3801 value=value.replace(']]',']]>') 3802 outfile.write(value) 3803 else: 3804 outfile.write(quote_xml('%s' % self.valueOf_)) 3805 def hasContent_(self): 3806 if ( 3807 self.valueOf_ is not None 3808 ): 3809 return True 3810 else: 3811 return False 3812 def build(self, node_): 3813 attrs = node_.attributes 3814 self.buildAttributes(attrs) 3815 self.valueOf_ = '' 3816 for child_ in node_.childNodes: 3817 nodeName_ = child_.nodeName.split(':')[-1] 3818 self.buildChildren(child_, nodeName_) 3819 def buildAttributes(self, attrs): 3820 pass 3821 def buildChildren(self, child_, nodeName_): 3822 if child_.nodeType == Node.TEXT_NODE: 3823 obj_ = self.mixedclass_(MixedContainer.CategoryText, 3824 MixedContainer.TypeNone, '', child_.nodeValue) 3825 self.content_.append(obj_) 3826 if child_.nodeType == Node.TEXT_NODE: 3827 self.valueOf_ += child_.nodeValue 3828 elif child_.nodeType == Node.CDATA_SECTION_NODE: 3829 self.valueOf_ += '![CDATA['+child_.nodeValue+']]' 3830# end class docMarkupType 3831 3832 3833class docURLLink(GeneratedsSuper): 3834 subclass = None 3835 superclass = None 3836 def __init__(self, url=None, valueOf_='', mixedclass_=None, content_=None): 3837 self.url = url 3838 if mixedclass_ is None: 3839 self.mixedclass_ = MixedContainer 3840 else: 3841 self.mixedclass_ = mixedclass_ 3842 if content_ is None: 3843 self.content_ = [] 3844 else: 3845 self.content_ = content_ 3846 def factory(*args_, **kwargs_): 3847 if docURLLink.subclass: 3848 return docURLLink.subclass(*args_, **kwargs_) 3849 else: 3850 return docURLLink(*args_, **kwargs_) 3851 factory = staticmethod(factory) 3852 def get_url(self): return self.url 3853 def set_url(self, url): self.url = url 3854 def getValueOf_(self): return self.valueOf_ 3855 def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ 3856 def export(self, outfile, level, namespace_='', name_='docURLLink', namespacedef_=''): 3857 showIndent(outfile, level) 3858 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 3859 self.exportAttributes(outfile, level, namespace_, name_='docURLLink') 3860 outfile.write('>') 3861 self.exportChildren(outfile, level + 1, namespace_, name_) 3862 outfile.write('</%s%s>\n' % (namespace_, name_)) 3863 def exportAttributes(self, outfile, level, namespace_='', name_='docURLLink'): 3864 if self.url is not None: 3865 outfile.write(' url=%s' % (self.format_string(quote_attrib(self.url).encode(ExternalEncoding), input_name='url'), )) 3866 def exportChildren(self, outfile, level, namespace_='', name_='docURLLink'): 3867 if self.valueOf_.find('![CDATA')>-1: 3868 value=quote_xml('%s' % self.valueOf_) 3869 value=value.replace('![CDATA','<![CDATA') 3870 value=value.replace(']]',']]>') 3871 outfile.write(value) 3872 else: 3873 outfile.write(quote_xml('%s' % self.valueOf_)) 3874 def hasContent_(self): 3875 if ( 3876 self.valueOf_ is not None 3877 ): 3878 return True 3879 else: 3880 return False 3881 def build(self, node_): 3882 attrs = node_.attributes 3883 self.buildAttributes(attrs) 3884 self.valueOf_ = '' 3885 for child_ in node_.childNodes: 3886 nodeName_ = child_.nodeName.split(':')[-1] 3887 self.buildChildren(child_, nodeName_) 3888 def buildAttributes(self, attrs): 3889 if attrs.get('url'): 3890 self.url = attrs.get('url').value 3891 def buildChildren(self, child_, nodeName_): 3892 if child_.nodeType == Node.TEXT_NODE: 3893 obj_ = self.mixedclass_(MixedContainer.CategoryText, 3894 MixedContainer.TypeNone, '', child_.nodeValue) 3895 self.content_.append(obj_) 3896 if child_.nodeType == Node.TEXT_NODE: 3897 self.valueOf_ += child_.nodeValue 3898 elif child_.nodeType == Node.CDATA_SECTION_NODE: 3899 self.valueOf_ += '![CDATA['+child_.nodeValue+']]' 3900# end class docURLLink 3901 3902 3903class docAnchorType(GeneratedsSuper): 3904 subclass = None 3905 superclass = None 3906 def __init__(self, id=None, valueOf_='', mixedclass_=None, content_=None): 3907 self.id = id 3908 if mixedclass_ is None: 3909 self.mixedclass_ = MixedContainer 3910 else: 3911 self.mixedclass_ = mixedclass_ 3912 if content_ is None: 3913 self.content_ = [] 3914 else: 3915 self.content_ = content_ 3916 def factory(*args_, **kwargs_): 3917 if docAnchorType.subclass: 3918 return docAnchorType.subclass(*args_, **kwargs_) 3919 else: 3920 return docAnchorType(*args_, **kwargs_) 3921 factory = staticmethod(factory) 3922 def get_id(self): return self.id 3923 def set_id(self, id): self.id = id 3924 def getValueOf_(self): return self.valueOf_ 3925 def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ 3926 def export(self, outfile, level, namespace_='', name_='docAnchorType', namespacedef_=''): 3927 showIndent(outfile, level) 3928 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 3929 self.exportAttributes(outfile, level, namespace_, name_='docAnchorType') 3930 outfile.write('>') 3931 self.exportChildren(outfile, level + 1, namespace_, name_) 3932 outfile.write('</%s%s>\n' % (namespace_, name_)) 3933 def exportAttributes(self, outfile, level, namespace_='', name_='docAnchorType'): 3934 if self.id is not None: 3935 outfile.write(' id=%s' % (self.format_string(quote_attrib(self.id).encode(ExternalEncoding), input_name='id'), )) 3936 def exportChildren(self, outfile, level, namespace_='', name_='docAnchorType'): 3937 if self.valueOf_.find('![CDATA')>-1: 3938 value=quote_xml('%s' % self.valueOf_) 3939 value=value.replace('![CDATA','<![CDATA') 3940 value=value.replace(']]',']]>') 3941 outfile.write(value) 3942 else: 3943 outfile.write(quote_xml('%s' % self.valueOf_)) 3944 def hasContent_(self): 3945 if ( 3946 self.valueOf_ is not None 3947 ): 3948 return True 3949 else: 3950 return False 3951 def build(self, node_): 3952 attrs = node_.attributes 3953 self.buildAttributes(attrs) 3954 self.valueOf_ = '' 3955 for child_ in node_.childNodes: 3956 nodeName_ = child_.nodeName.split(':')[-1] 3957 self.buildChildren(child_, nodeName_) 3958 def buildAttributes(self, attrs): 3959 if attrs.get('id'): 3960 self.id = attrs.get('id').value 3961 def buildChildren(self, child_, nodeName_): 3962 if child_.nodeType == Node.TEXT_NODE: 3963 obj_ = self.mixedclass_(MixedContainer.CategoryText, 3964 MixedContainer.TypeNone, '', child_.nodeValue) 3965 self.content_.append(obj_) 3966 if child_.nodeType == Node.TEXT_NODE: 3967 self.valueOf_ += child_.nodeValue 3968 elif child_.nodeType == Node.CDATA_SECTION_NODE: 3969 self.valueOf_ += '![CDATA['+child_.nodeValue+']]' 3970# end class docAnchorType 3971 3972 3973class docFormulaType(GeneratedsSuper): 3974 subclass = None 3975 superclass = None 3976 def __init__(self, id=None, valueOf_='', mixedclass_=None, content_=None): 3977 self.id = id 3978 if mixedclass_ is None: 3979 self.mixedclass_ = MixedContainer 3980 else: 3981 self.mixedclass_ = mixedclass_ 3982 if content_ is None: 3983 self.content_ = [] 3984 else: 3985 self.content_ = content_ 3986 def factory(*args_, **kwargs_): 3987 if docFormulaType.subclass: 3988 return docFormulaType.subclass(*args_, **kwargs_) 3989 else: 3990 return docFormulaType(*args_, **kwargs_) 3991 factory = staticmethod(factory) 3992 def get_id(self): return self.id 3993 def set_id(self, id): self.id = id 3994 def getValueOf_(self): return self.valueOf_ 3995 def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ 3996 def export(self, outfile, level, namespace_='', name_='docFormulaType', namespacedef_=''): 3997 showIndent(outfile, level) 3998 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 3999 self.exportAttributes(outfile, level, namespace_, name_='docFormulaType') 4000 outfile.write('>') 4001 self.exportChildren(outfile, level + 1, namespace_, name_) 4002 outfile.write('</%s%s>\n' % (namespace_, name_)) 4003 def exportAttributes(self, outfile, level, namespace_='', name_='docFormulaType'): 4004 if self.id is not None: 4005 outfile.write(' id=%s' % (self.format_string(quote_attrib(self.id).encode(ExternalEncoding), input_name='id'), )) 4006 def exportChildren(self, outfile, level, namespace_='', name_='docFormulaType'): 4007 if self.valueOf_.find('![CDATA')>-1: 4008 value=quote_xml('%s' % self.valueOf_) 4009 value=value.replace('![CDATA','<![CDATA') 4010 value=value.replace(']]',']]>') 4011 outfile.write(value) 4012 else: 4013 outfile.write(quote_xml('%s' % self.valueOf_)) 4014 def hasContent_(self): 4015 if ( 4016 self.valueOf_ is not None 4017 ): 4018 return True 4019 else: 4020 return False 4021 def build(self, node_): 4022 attrs = node_.attributes 4023 self.buildAttributes(attrs) 4024 self.valueOf_ = '' 4025 for child_ in node_.childNodes: 4026 nodeName_ = child_.nodeName.split(':')[-1] 4027 self.buildChildren(child_, nodeName_) 4028 def buildAttributes(self, attrs): 4029 if attrs.get('id'): 4030 self.id = attrs.get('id').value 4031 def buildChildren(self, child_, nodeName_): 4032 if child_.nodeType == Node.TEXT_NODE: 4033 obj_ = self.mixedclass_(MixedContainer.CategoryText, 4034 MixedContainer.TypeNone, '', child_.nodeValue) 4035 self.content_.append(obj_) 4036 if child_.nodeType == Node.TEXT_NODE: 4037 self.valueOf_ += child_.nodeValue 4038 elif child_.nodeType == Node.CDATA_SECTION_NODE: 4039 self.valueOf_ += '![CDATA['+child_.nodeValue+']]' 4040# end class docFormulaType 4041 4042 4043class docIndexEntryType(GeneratedsSuper): 4044 subclass = None 4045 superclass = None 4046 def __init__(self, primaryie=None, secondaryie=None): 4047 self.primaryie = primaryie 4048 self.secondaryie = secondaryie 4049 def factory(*args_, **kwargs_): 4050 if docIndexEntryType.subclass: 4051 return docIndexEntryType.subclass(*args_, **kwargs_) 4052 else: 4053 return docIndexEntryType(*args_, **kwargs_) 4054 factory = staticmethod(factory) 4055 def get_primaryie(self): return self.primaryie 4056 def set_primaryie(self, primaryie): self.primaryie = primaryie 4057 def get_secondaryie(self): return self.secondaryie 4058 def set_secondaryie(self, secondaryie): self.secondaryie = secondaryie 4059 def export(self, outfile, level, namespace_='', name_='docIndexEntryType', namespacedef_=''): 4060 showIndent(outfile, level) 4061 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 4062 self.exportAttributes(outfile, level, namespace_, name_='docIndexEntryType') 4063 if self.hasContent_(): 4064 outfile.write('>\n') 4065 self.exportChildren(outfile, level + 1, namespace_, name_) 4066 showIndent(outfile, level) 4067 outfile.write('</%s%s>\n' % (namespace_, name_)) 4068 else: 4069 outfile.write(' />\n') 4070 def exportAttributes(self, outfile, level, namespace_='', name_='docIndexEntryType'): 4071 pass 4072 def exportChildren(self, outfile, level, namespace_='', name_='docIndexEntryType'): 4073 if self.primaryie is not None: 4074 showIndent(outfile, level) 4075 outfile.write('<%sprimaryie>%s</%sprimaryie>\n' % (namespace_, self.format_string(quote_xml(self.primaryie).encode(ExternalEncoding), input_name='primaryie'), namespace_)) 4076 if self.secondaryie is not None: 4077 showIndent(outfile, level) 4078 outfile.write('<%ssecondaryie>%s</%ssecondaryie>\n' % (namespace_, self.format_string(quote_xml(self.secondaryie).encode(ExternalEncoding), input_name='secondaryie'), namespace_)) 4079 def hasContent_(self): 4080 if ( 4081 self.primaryie is not None or 4082 self.secondaryie is not None 4083 ): 4084 return True 4085 else: 4086 return False 4087 def build(self, node_): 4088 attrs = node_.attributes 4089 self.buildAttributes(attrs) 4090 for child_ in node_.childNodes: 4091 nodeName_ = child_.nodeName.split(':')[-1] 4092 self.buildChildren(child_, nodeName_) 4093 def buildAttributes(self, attrs): 4094 pass 4095 def buildChildren(self, child_, nodeName_): 4096 if child_.nodeType == Node.ELEMENT_NODE and \ 4097 nodeName_ == 'primaryie': 4098 primaryie_ = '' 4099 for text__content_ in child_.childNodes: 4100 primaryie_ += text__content_.nodeValue 4101 self.primaryie = primaryie_ 4102 elif child_.nodeType == Node.ELEMENT_NODE and \ 4103 nodeName_ == 'secondaryie': 4104 secondaryie_ = '' 4105 for text__content_ in child_.childNodes: 4106 secondaryie_ += text__content_.nodeValue 4107 self.secondaryie = secondaryie_ 4108# end class docIndexEntryType 4109 4110 4111class docListType(GeneratedsSuper): 4112 subclass = None 4113 superclass = None 4114 def __init__(self, listitem=None): 4115 if listitem is None: 4116 self.listitem = [] 4117 else: 4118 self.listitem = listitem 4119 def factory(*args_, **kwargs_): 4120 if docListType.subclass: 4121 return docListType.subclass(*args_, **kwargs_) 4122 else: 4123 return docListType(*args_, **kwargs_) 4124 factory = staticmethod(factory) 4125 def get_listitem(self): return self.listitem 4126 def set_listitem(self, listitem): self.listitem = listitem 4127 def add_listitem(self, value): self.listitem.append(value) 4128 def insert_listitem(self, index, value): self.listitem[index] = value 4129 def export(self, outfile, level, namespace_='', name_='docListType', namespacedef_=''): 4130 showIndent(outfile, level) 4131 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 4132 self.exportAttributes(outfile, level, namespace_, name_='docListType') 4133 if self.hasContent_(): 4134 outfile.write('>\n') 4135 self.exportChildren(outfile, level + 1, namespace_, name_) 4136 showIndent(outfile, level) 4137 outfile.write('</%s%s>\n' % (namespace_, name_)) 4138 else: 4139 outfile.write(' />\n') 4140 def exportAttributes(self, outfile, level, namespace_='', name_='docListType'): 4141 pass 4142 def exportChildren(self, outfile, level, namespace_='', name_='docListType'): 4143 for listitem_ in self.listitem: 4144 listitem_.export(outfile, level, namespace_, name_='listitem') 4145 def hasContent_(self): 4146 if ( 4147 self.listitem is not None 4148 ): 4149 return True 4150 else: 4151 return False 4152 def build(self, node_): 4153 attrs = node_.attributes 4154 self.buildAttributes(attrs) 4155 for child_ in node_.childNodes: 4156 nodeName_ = child_.nodeName.split(':')[-1] 4157 self.buildChildren(child_, nodeName_) 4158 def buildAttributes(self, attrs): 4159 pass 4160 def buildChildren(self, child_, nodeName_): 4161 if child_.nodeType == Node.ELEMENT_NODE and \ 4162 nodeName_ == 'listitem': 4163 obj_ = docListItemType.factory() 4164 obj_.build(child_) 4165 self.listitem.append(obj_) 4166# end class docListType 4167 4168 4169class docListItemType(GeneratedsSuper): 4170 subclass = None 4171 superclass = None 4172 def __init__(self, para=None): 4173 if para is None: 4174 self.para = [] 4175 else: 4176 self.para = para 4177 def factory(*args_, **kwargs_): 4178 if docListItemType.subclass: 4179 return docListItemType.subclass(*args_, **kwargs_) 4180 else: 4181 return docListItemType(*args_, **kwargs_) 4182 factory = staticmethod(factory) 4183 def get_para(self): return self.para 4184 def set_para(self, para): self.para = para 4185 def add_para(self, value): self.para.append(value) 4186 def insert_para(self, index, value): self.para[index] = value 4187 def export(self, outfile, level, namespace_='', name_='docListItemType', namespacedef_=''): 4188 showIndent(outfile, level) 4189 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 4190 self.exportAttributes(outfile, level, namespace_, name_='docListItemType') 4191 if self.hasContent_(): 4192 outfile.write('>\n') 4193 self.exportChildren(outfile, level + 1, namespace_, name_) 4194 showIndent(outfile, level) 4195 outfile.write('</%s%s>\n' % (namespace_, name_)) 4196 else: 4197 outfile.write(' />\n') 4198 def exportAttributes(self, outfile, level, namespace_='', name_='docListItemType'): 4199 pass 4200 def exportChildren(self, outfile, level, namespace_='', name_='docListItemType'): 4201 for para_ in self.para: 4202 para_.export(outfile, level, namespace_, name_='para') 4203 def hasContent_(self): 4204 if ( 4205 self.para is not None 4206 ): 4207 return True 4208 else: 4209 return False 4210 def build(self, node_): 4211 attrs = node_.attributes 4212 self.buildAttributes(attrs) 4213 for child_ in node_.childNodes: 4214 nodeName_ = child_.nodeName.split(':')[-1] 4215 self.buildChildren(child_, nodeName_) 4216 def buildAttributes(self, attrs): 4217 pass 4218 def buildChildren(self, child_, nodeName_): 4219 if child_.nodeType == Node.ELEMENT_NODE and \ 4220 nodeName_ == 'para': 4221 obj_ = docParaType.factory() 4222 obj_.build(child_) 4223 self.para.append(obj_) 4224# end class docListItemType 4225 4226 4227class docSimpleSectType(GeneratedsSuper): 4228 subclass = None 4229 superclass = None 4230 def __init__(self, kind=None, title=None, para=None): 4231 self.kind = kind 4232 self.title = title 4233 if para is None: 4234 self.para = [] 4235 else: 4236 self.para = para 4237 def factory(*args_, **kwargs_): 4238 if docSimpleSectType.subclass: 4239 return docSimpleSectType.subclass(*args_, **kwargs_) 4240 else: 4241 return docSimpleSectType(*args_, **kwargs_) 4242 factory = staticmethod(factory) 4243 def get_title(self): return self.title 4244 def set_title(self, title): self.title = title 4245 def get_para(self): return self.para 4246 def set_para(self, para): self.para = para 4247 def add_para(self, value): self.para.append(value) 4248 def insert_para(self, index, value): self.para[index] = value 4249 def get_kind(self): return self.kind 4250 def set_kind(self, kind): self.kind = kind 4251 def export(self, outfile, level, namespace_='', name_='docSimpleSectType', namespacedef_=''): 4252 showIndent(outfile, level) 4253 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 4254 self.exportAttributes(outfile, level, namespace_, name_='docSimpleSectType') 4255 if self.hasContent_(): 4256 outfile.write('>\n') 4257 self.exportChildren(outfile, level + 1, namespace_, name_) 4258 showIndent(outfile, level) 4259 outfile.write('</%s%s>\n' % (namespace_, name_)) 4260 else: 4261 outfile.write(' />\n') 4262 def exportAttributes(self, outfile, level, namespace_='', name_='docSimpleSectType'): 4263 if self.kind is not None: 4264 outfile.write(' kind=%s' % (quote_attrib(self.kind), )) 4265 def exportChildren(self, outfile, level, namespace_='', name_='docSimpleSectType'): 4266 if self.title: 4267 self.title.export(outfile, level, namespace_, name_='title') 4268 for para_ in self.para: 4269 para_.export(outfile, level, namespace_, name_='para') 4270 def hasContent_(self): 4271 if ( 4272 self.title is not None or 4273 self.para is not None 4274 ): 4275 return True 4276 else: 4277 return False 4278 def build(self, node_): 4279 attrs = node_.attributes 4280 self.buildAttributes(attrs) 4281 for child_ in node_.childNodes: 4282 nodeName_ = child_.nodeName.split(':')[-1] 4283 self.buildChildren(child_, nodeName_) 4284 def buildAttributes(self, attrs): 4285 if attrs.get('kind'): 4286 self.kind = attrs.get('kind').value 4287 def buildChildren(self, child_, nodeName_): 4288 if child_.nodeType == Node.ELEMENT_NODE and \ 4289 nodeName_ == 'title': 4290 obj_ = docTitleType.factory() 4291 obj_.build(child_) 4292 self.set_title(obj_) 4293 elif child_.nodeType == Node.ELEMENT_NODE and \ 4294 nodeName_ == 'para': 4295 obj_ = docParaType.factory() 4296 obj_.build(child_) 4297 self.para.append(obj_) 4298# end class docSimpleSectType 4299 4300 4301class docVarListEntryType(GeneratedsSuper): 4302 subclass = None 4303 superclass = None 4304 def __init__(self, term=None): 4305 self.term = term 4306 def factory(*args_, **kwargs_): 4307 if docVarListEntryType.subclass: 4308 return docVarListEntryType.subclass(*args_, **kwargs_) 4309 else: 4310 return docVarListEntryType(*args_, **kwargs_) 4311 factory = staticmethod(factory) 4312 def get_term(self): return self.term 4313 def set_term(self, term): self.term = term 4314 def export(self, outfile, level, namespace_='', name_='docVarListEntryType', namespacedef_=''): 4315 showIndent(outfile, level) 4316 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 4317 self.exportAttributes(outfile, level, namespace_, name_='docVarListEntryType') 4318 if self.hasContent_(): 4319 outfile.write('>\n') 4320 self.exportChildren(outfile, level + 1, namespace_, name_) 4321 showIndent(outfile, level) 4322 outfile.write('</%s%s>\n' % (namespace_, name_)) 4323 else: 4324 outfile.write(' />\n') 4325 def exportAttributes(self, outfile, level, namespace_='', name_='docVarListEntryType'): 4326 pass 4327 def exportChildren(self, outfile, level, namespace_='', name_='docVarListEntryType'): 4328 if self.term: 4329 self.term.export(outfile, level, namespace_, name_='term', ) 4330 def hasContent_(self): 4331 if ( 4332 self.term is not None 4333 ): 4334 return True 4335 else: 4336 return False 4337 def build(self, node_): 4338 attrs = node_.attributes 4339 self.buildAttributes(attrs) 4340 for child_ in node_.childNodes: 4341 nodeName_ = child_.nodeName.split(':')[-1] 4342 self.buildChildren(child_, nodeName_) 4343 def buildAttributes(self, attrs): 4344 pass 4345 def buildChildren(self, child_, nodeName_): 4346 if child_.nodeType == Node.ELEMENT_NODE and \ 4347 nodeName_ == 'term': 4348 obj_ = docTitleType.factory() 4349 obj_.build(child_) 4350 self.set_term(obj_) 4351# end class docVarListEntryType 4352 4353 4354class docVariableListType(GeneratedsSuper): 4355 subclass = None 4356 superclass = None 4357 def __init__(self, valueOf_=''): 4358 self.valueOf_ = valueOf_ 4359 def factory(*args_, **kwargs_): 4360 if docVariableListType.subclass: 4361 return docVariableListType.subclass(*args_, **kwargs_) 4362 else: 4363 return docVariableListType(*args_, **kwargs_) 4364 factory = staticmethod(factory) 4365 def getValueOf_(self): return self.valueOf_ 4366 def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ 4367 def export(self, outfile, level, namespace_='', name_='docVariableListType', namespacedef_=''): 4368 showIndent(outfile, level) 4369 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 4370 self.exportAttributes(outfile, level, namespace_, name_='docVariableListType') 4371 if self.hasContent_(): 4372 outfile.write('>\n') 4373 self.exportChildren(outfile, level + 1, namespace_, name_) 4374 showIndent(outfile, level) 4375 outfile.write('</%s%s>\n' % (namespace_, name_)) 4376 else: 4377 outfile.write(' />\n') 4378 def exportAttributes(self, outfile, level, namespace_='', name_='docVariableListType'): 4379 pass 4380 def exportChildren(self, outfile, level, namespace_='', name_='docVariableListType'): 4381 if self.valueOf_.find('![CDATA')>-1: 4382 value=quote_xml('%s' % self.valueOf_) 4383 value=value.replace('![CDATA','<![CDATA') 4384 value=value.replace(']]',']]>') 4385 outfile.write(value) 4386 else: 4387 outfile.write(quote_xml('%s' % self.valueOf_)) 4388 def hasContent_(self): 4389 if ( 4390 self.valueOf_ is not None 4391 ): 4392 return True 4393 else: 4394 return False 4395 def build(self, node_): 4396 attrs = node_.attributes 4397 self.buildAttributes(attrs) 4398 self.valueOf_ = '' 4399 for child_ in node_.childNodes: 4400 nodeName_ = child_.nodeName.split(':')[-1] 4401 self.buildChildren(child_, nodeName_) 4402 def buildAttributes(self, attrs): 4403 pass 4404 def buildChildren(self, child_, nodeName_): 4405 if child_.nodeType == Node.TEXT_NODE: 4406 self.valueOf_ += child_.nodeValue 4407 elif child_.nodeType == Node.CDATA_SECTION_NODE: 4408 self.valueOf_ += '![CDATA['+child_.nodeValue+']]' 4409# end class docVariableListType 4410 4411 4412class docRefTextType(GeneratedsSuper): 4413 subclass = None 4414 superclass = None 4415 def __init__(self, refid=None, kindref=None, external=None, valueOf_='', mixedclass_=None, content_=None): 4416 self.refid = refid 4417 self.kindref = kindref 4418 self.external = external 4419 if mixedclass_ is None: 4420 self.mixedclass_ = MixedContainer 4421 else: 4422 self.mixedclass_ = mixedclass_ 4423 if content_ is None: 4424 self.content_ = [] 4425 else: 4426 self.content_ = content_ 4427 def factory(*args_, **kwargs_): 4428 if docRefTextType.subclass: 4429 return docRefTextType.subclass(*args_, **kwargs_) 4430 else: 4431 return docRefTextType(*args_, **kwargs_) 4432 factory = staticmethod(factory) 4433 def get_refid(self): return self.refid 4434 def set_refid(self, refid): self.refid = refid 4435 def get_kindref(self): return self.kindref 4436 def set_kindref(self, kindref): self.kindref = kindref 4437 def get_external(self): return self.external 4438 def set_external(self, external): self.external = external 4439 def getValueOf_(self): return self.valueOf_ 4440 def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ 4441 def export(self, outfile, level, namespace_='', name_='docRefTextType', namespacedef_=''): 4442 showIndent(outfile, level) 4443 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 4444 self.exportAttributes(outfile, level, namespace_, name_='docRefTextType') 4445 outfile.write('>') 4446 self.exportChildren(outfile, level + 1, namespace_, name_) 4447 outfile.write('</%s%s>\n' % (namespace_, name_)) 4448 def exportAttributes(self, outfile, level, namespace_='', name_='docRefTextType'): 4449 if self.refid is not None: 4450 outfile.write(' refid=%s' % (self.format_string(quote_attrib(self.refid).encode(ExternalEncoding), input_name='refid'), )) 4451 if self.kindref is not None: 4452 outfile.write(' kindref=%s' % (quote_attrib(self.kindref), )) 4453 if self.external is not None: 4454 outfile.write(' external=%s' % (self.format_string(quote_attrib(self.external).encode(ExternalEncoding), input_name='external'), )) 4455 def exportChildren(self, outfile, level, namespace_='', name_='docRefTextType'): 4456 if self.valueOf_.find('![CDATA')>-1: 4457 value=quote_xml('%s' % self.valueOf_) 4458 value=value.replace('![CDATA','<![CDATA') 4459 value=value.replace(']]',']]>') 4460 outfile.write(value) 4461 else: 4462 outfile.write(quote_xml('%s' % self.valueOf_)) 4463 def hasContent_(self): 4464 if ( 4465 self.valueOf_ is not None 4466 ): 4467 return True 4468 else: 4469 return False 4470 def build(self, node_): 4471 attrs = node_.attributes 4472 self.buildAttributes(attrs) 4473 self.valueOf_ = '' 4474 for child_ in node_.childNodes: 4475 nodeName_ = child_.nodeName.split(':')[-1] 4476 self.buildChildren(child_, nodeName_) 4477 def buildAttributes(self, attrs): 4478 if attrs.get('refid'): 4479 self.refid = attrs.get('refid').value 4480 if attrs.get('kindref'): 4481 self.kindref = attrs.get('kindref').value 4482 if attrs.get('external'): 4483 self.external = attrs.get('external').value 4484 def buildChildren(self, child_, nodeName_): 4485 if child_.nodeType == Node.TEXT_NODE: 4486 obj_ = self.mixedclass_(MixedContainer.CategoryText, 4487 MixedContainer.TypeNone, '', child_.nodeValue) 4488 self.content_.append(obj_) 4489 if child_.nodeType == Node.TEXT_NODE: 4490 self.valueOf_ += child_.nodeValue 4491 elif child_.nodeType == Node.CDATA_SECTION_NODE: 4492 self.valueOf_ += '![CDATA['+child_.nodeValue+']]' 4493# end class docRefTextType 4494 4495 4496class docTableType(GeneratedsSuper): 4497 subclass = None 4498 superclass = None 4499 def __init__(self, rows=None, cols=None, row=None, caption=None): 4500 self.rows = rows 4501 self.cols = cols 4502 if row is None: 4503 self.row = [] 4504 else: 4505 self.row = row 4506 self.caption = caption 4507 def factory(*args_, **kwargs_): 4508 if docTableType.subclass: 4509 return docTableType.subclass(*args_, **kwargs_) 4510 else: 4511 return docTableType(*args_, **kwargs_) 4512 factory = staticmethod(factory) 4513 def get_row(self): return self.row 4514 def set_row(self, row): self.row = row 4515 def add_row(self, value): self.row.append(value) 4516 def insert_row(self, index, value): self.row[index] = value 4517 def get_caption(self): return self.caption 4518 def set_caption(self, caption): self.caption = caption 4519 def get_rows(self): return self.rows 4520 def set_rows(self, rows): self.rows = rows 4521 def get_cols(self): return self.cols 4522 def set_cols(self, cols): self.cols = cols 4523 def export(self, outfile, level, namespace_='', name_='docTableType', namespacedef_=''): 4524 showIndent(outfile, level) 4525 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 4526 self.exportAttributes(outfile, level, namespace_, name_='docTableType') 4527 if self.hasContent_(): 4528 outfile.write('>\n') 4529 self.exportChildren(outfile, level + 1, namespace_, name_) 4530 showIndent(outfile, level) 4531 outfile.write('</%s%s>\n' % (namespace_, name_)) 4532 else: 4533 outfile.write(' />\n') 4534 def exportAttributes(self, outfile, level, namespace_='', name_='docTableType'): 4535 if self.rows is not None: 4536 outfile.write(' rows="%s"' % self.format_integer(self.rows, input_name='rows')) 4537 if self.cols is not None: 4538 outfile.write(' cols="%s"' % self.format_integer(self.cols, input_name='cols')) 4539 def exportChildren(self, outfile, level, namespace_='', name_='docTableType'): 4540 for row_ in self.row: 4541 row_.export(outfile, level, namespace_, name_='row') 4542 if self.caption: 4543 self.caption.export(outfile, level, namespace_, name_='caption') 4544 def hasContent_(self): 4545 if ( 4546 self.row is not None or 4547 self.caption is not None 4548 ): 4549 return True 4550 else: 4551 return False 4552 def build(self, node_): 4553 attrs = node_.attributes 4554 self.buildAttributes(attrs) 4555 for child_ in node_.childNodes: 4556 nodeName_ = child_.nodeName.split(':')[-1] 4557 self.buildChildren(child_, nodeName_) 4558 def buildAttributes(self, attrs): 4559 if attrs.get('rows'): 4560 try: 4561 self.rows = int(attrs.get('rows').value) 4562 except ValueError as exp: 4563 raise ValueError('Bad integer attribute (rows): %s' % exp) 4564 if attrs.get('cols'): 4565 try: 4566 self.cols = int(attrs.get('cols').value) 4567 except ValueError as exp: 4568 raise ValueError('Bad integer attribute (cols): %s' % exp) 4569 def buildChildren(self, child_, nodeName_): 4570 if child_.nodeType == Node.ELEMENT_NODE and \ 4571 nodeName_ == 'row': 4572 obj_ = docRowType.factory() 4573 obj_.build(child_) 4574 self.row.append(obj_) 4575 elif child_.nodeType == Node.ELEMENT_NODE and \ 4576 nodeName_ == 'caption': 4577 obj_ = docCaptionType.factory() 4578 obj_.build(child_) 4579 self.set_caption(obj_) 4580# end class docTableType 4581 4582 4583class docRowType(GeneratedsSuper): 4584 subclass = None 4585 superclass = None 4586 def __init__(self, entry=None): 4587 if entry is None: 4588 self.entry = [] 4589 else: 4590 self.entry = entry 4591 def factory(*args_, **kwargs_): 4592 if docRowType.subclass: 4593 return docRowType.subclass(*args_, **kwargs_) 4594 else: 4595 return docRowType(*args_, **kwargs_) 4596 factory = staticmethod(factory) 4597 def get_entry(self): return self.entry 4598 def set_entry(self, entry): self.entry = entry 4599 def add_entry(self, value): self.entry.append(value) 4600 def insert_entry(self, index, value): self.entry[index] = value 4601 def export(self, outfile, level, namespace_='', name_='docRowType', namespacedef_=''): 4602 showIndent(outfile, level) 4603 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 4604 self.exportAttributes(outfile, level, namespace_, name_='docRowType') 4605 if self.hasContent_(): 4606 outfile.write('>\n') 4607 self.exportChildren(outfile, level + 1, namespace_, name_) 4608 showIndent(outfile, level) 4609 outfile.write('</%s%s>\n' % (namespace_, name_)) 4610 else: 4611 outfile.write(' />\n') 4612 def exportAttributes(self, outfile, level, namespace_='', name_='docRowType'): 4613 pass 4614 def exportChildren(self, outfile, level, namespace_='', name_='docRowType'): 4615 for entry_ in self.entry: 4616 entry_.export(outfile, level, namespace_, name_='entry') 4617 def hasContent_(self): 4618 if ( 4619 self.entry is not None 4620 ): 4621 return True 4622 else: 4623 return False 4624 def build(self, node_): 4625 attrs = node_.attributes 4626 self.buildAttributes(attrs) 4627 for child_ in node_.childNodes: 4628 nodeName_ = child_.nodeName.split(':')[-1] 4629 self.buildChildren(child_, nodeName_) 4630 def buildAttributes(self, attrs): 4631 pass 4632 def buildChildren(self, child_, nodeName_): 4633 if child_.nodeType == Node.ELEMENT_NODE and \ 4634 nodeName_ == 'entry': 4635 obj_ = docEntryType.factory() 4636 obj_.build(child_) 4637 self.entry.append(obj_) 4638# end class docRowType 4639 4640 4641class docEntryType(GeneratedsSuper): 4642 subclass = None 4643 superclass = None 4644 def __init__(self, thead=None, align=None, rowspan=None, colspan=None, para=None): 4645 self.thead = thead 4646 self.align = align 4647 self.rowspan = rowspan 4648 self.colspan = colspan 4649 if para is None: 4650 self.para = [] 4651 else: 4652 self.para = para 4653 def factory(*args_, **kwargs_): 4654 if docEntryType.subclass: 4655 return docEntryType.subclass(*args_, **kwargs_) 4656 else: 4657 return docEntryType(*args_, **kwargs_) 4658 factory = staticmethod(factory) 4659 def get_para(self): return self.para 4660 def set_para(self, para): self.para = para 4661 def add_para(self, value): self.para.append(value) 4662 def insert_para(self, index, value): self.para[index] = value 4663 def get_thead(self): return self.thead 4664 def set_thead(self, thead): self.thead = thead 4665 def get_align(self): return self.align 4666 def set_align(self, align): self.align = align 4667 def get_rowspan(self): return self.rowspan 4668 def set_rowspan(self, rowspan): self.rowspan = rowspan 4669 def get_colspan(self): return self.colspan 4670 def set_colspan(self, colspan): self.colspan = colspan 4671 def export(self, outfile, level, namespace_='', name_='docEntryType', namespacedef_=''): 4672 showIndent(outfile, level) 4673 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 4674 self.exportAttributes(outfile, level, namespace_, name_='docEntryType') 4675 if self.hasContent_(): 4676 outfile.write('>\n') 4677 self.exportChildren(outfile, level + 1, namespace_, name_) 4678 showIndent(outfile, level) 4679 outfile.write('</%s%s>\n' % (namespace_, name_)) 4680 else: 4681 outfile.write(' />\n') 4682 def exportAttributes(self, outfile, level, namespace_='', name_='docEntryType'): 4683 if self.thead is not None: 4684 outfile.write(' thead=%s' % (quote_attrib(self.thead), )) 4685 if self.align is not None: 4686 outfile.write(' align=%s' % (quote_attrib(self.align), )) 4687 if self.rowspan is not None: 4688 outfile.write(' rowspan=%s' % (quote_attrib(self.rowspan), )) 4689 if self.colspan is not None: 4690 outfile.write(' colspan=%s' % (quote_attrib(self.colspan), )) 4691 def exportChildren(self, outfile, level, namespace_='', name_='docEntryType'): 4692 for para_ in self.para: 4693 para_.export(outfile, level, namespace_, name_='para') 4694 def hasContent_(self): 4695 if ( 4696 self.para is not None 4697 ): 4698 return True 4699 else: 4700 return False 4701 def build(self, node_): 4702 attrs = node_.attributes 4703 self.buildAttributes(attrs) 4704 for child_ in node_.childNodes: 4705 nodeName_ = child_.nodeName.split(':')[-1] 4706 self.buildChildren(child_, nodeName_) 4707 def buildAttributes(self, attrs): 4708 if attrs.get('thead'): 4709 self.thead = attrs.get('thead').value 4710 if attrs.get('align'): 4711 self.align = attrs.get('align').value 4712 if attrs.get('rowspan'): 4713 self.rowspan = attrs.get('rowspan').value 4714 if attrs.get('colspan'): 4715 self.colspan = attrs.get('colspan').value 4716 def buildChildren(self, child_, nodeName_): 4717 if child_.nodeType == Node.ELEMENT_NODE and \ 4718 nodeName_ == 'para': 4719 obj_ = docParaType.factory() 4720 obj_.build(child_) 4721 self.para.append(obj_) 4722# end class docEntryType 4723 4724 4725class docCaptionType(GeneratedsSuper): 4726 subclass = None 4727 superclass = None 4728 def __init__(self, valueOf_='', mixedclass_=None, content_=None): 4729 if mixedclass_ is None: 4730 self.mixedclass_ = MixedContainer 4731 else: 4732 self.mixedclass_ = mixedclass_ 4733 if content_ is None: 4734 self.content_ = [] 4735 else: 4736 self.content_ = content_ 4737 def factory(*args_, **kwargs_): 4738 if docCaptionType.subclass: 4739 return docCaptionType.subclass(*args_, **kwargs_) 4740 else: 4741 return docCaptionType(*args_, **kwargs_) 4742 factory = staticmethod(factory) 4743 def getValueOf_(self): return self.valueOf_ 4744 def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ 4745 def export(self, outfile, level, namespace_='', name_='docCaptionType', namespacedef_=''): 4746 showIndent(outfile, level) 4747 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 4748 self.exportAttributes(outfile, level, namespace_, name_='docCaptionType') 4749 outfile.write('>') 4750 self.exportChildren(outfile, level + 1, namespace_, name_) 4751 outfile.write('</%s%s>\n' % (namespace_, name_)) 4752 def exportAttributes(self, outfile, level, namespace_='', name_='docCaptionType'): 4753 pass 4754 def exportChildren(self, outfile, level, namespace_='', name_='docCaptionType'): 4755 if self.valueOf_.find('![CDATA')>-1: 4756 value=quote_xml('%s' % self.valueOf_) 4757 value=value.replace('![CDATA','<![CDATA') 4758 value=value.replace(']]',']]>') 4759 outfile.write(value) 4760 else: 4761 outfile.write(quote_xml('%s' % self.valueOf_)) 4762 def hasContent_(self): 4763 if ( 4764 self.valueOf_ is not None 4765 ): 4766 return True 4767 else: 4768 return False 4769 def build(self, node_): 4770 attrs = node_.attributes 4771 self.buildAttributes(attrs) 4772 self.valueOf_ = '' 4773 for child_ in node_.childNodes: 4774 nodeName_ = child_.nodeName.split(':')[-1] 4775 self.buildChildren(child_, nodeName_) 4776 def buildAttributes(self, attrs): 4777 pass 4778 def buildChildren(self, child_, nodeName_): 4779 if child_.nodeType == Node.TEXT_NODE: 4780 obj_ = self.mixedclass_(MixedContainer.CategoryText, 4781 MixedContainer.TypeNone, '', child_.nodeValue) 4782 self.content_.append(obj_) 4783 if child_.nodeType == Node.TEXT_NODE: 4784 self.valueOf_ += child_.nodeValue 4785 elif child_.nodeType == Node.CDATA_SECTION_NODE: 4786 self.valueOf_ += '![CDATA['+child_.nodeValue+']]' 4787# end class docCaptionType 4788 4789 4790class docHeadingType(GeneratedsSuper): 4791 subclass = None 4792 superclass = None 4793 def __init__(self, level=None, valueOf_='', mixedclass_=None, content_=None): 4794 self.level = level 4795 if mixedclass_ is None: 4796 self.mixedclass_ = MixedContainer 4797 else: 4798 self.mixedclass_ = mixedclass_ 4799 if content_ is None: 4800 self.content_ = [] 4801 else: 4802 self.content_ = content_ 4803 def factory(*args_, **kwargs_): 4804 if docHeadingType.subclass: 4805 return docHeadingType.subclass(*args_, **kwargs_) 4806 else: 4807 return docHeadingType(*args_, **kwargs_) 4808 factory = staticmethod(factory) 4809 def get_level(self): return self.level 4810 def set_level(self, level): self.level = level 4811 def getValueOf_(self): return self.valueOf_ 4812 def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ 4813 def export(self, outfile, level, namespace_='', name_='docHeadingType', namespacedef_=''): 4814 showIndent(outfile, level) 4815 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 4816 self.exportAttributes(outfile, level, namespace_, name_='docHeadingType') 4817 outfile.write('>') 4818 self.exportChildren(outfile, level + 1, namespace_, name_) 4819 outfile.write('</%s%s>\n' % (namespace_, name_)) 4820 def exportAttributes(self, outfile, level, namespace_='', name_='docHeadingType'): 4821 if self.level is not None: 4822 outfile.write(' level="%s"' % self.format_integer(self.level, input_name='level')) 4823 def exportChildren(self, outfile, level, namespace_='', name_='docHeadingType'): 4824 if self.valueOf_.find('![CDATA')>-1: 4825 value=quote_xml('%s' % self.valueOf_) 4826 value=value.replace('![CDATA','<![CDATA') 4827 value=value.replace(']]',']]>') 4828 outfile.write(value) 4829 else: 4830 outfile.write(quote_xml('%s' % self.valueOf_)) 4831 def hasContent_(self): 4832 if ( 4833 self.valueOf_ is not None 4834 ): 4835 return True 4836 else: 4837 return False 4838 def build(self, node_): 4839 attrs = node_.attributes 4840 self.buildAttributes(attrs) 4841 self.valueOf_ = '' 4842 for child_ in node_.childNodes: 4843 nodeName_ = child_.nodeName.split(':')[-1] 4844 self.buildChildren(child_, nodeName_) 4845 def buildAttributes(self, attrs): 4846 if attrs.get('level'): 4847 try: 4848 self.level = int(attrs.get('level').value) 4849 except ValueError as exp: 4850 raise ValueError('Bad integer attribute (level): %s' % exp) 4851 def buildChildren(self, child_, nodeName_): 4852 if child_.nodeType == Node.TEXT_NODE: 4853 obj_ = self.mixedclass_(MixedContainer.CategoryText, 4854 MixedContainer.TypeNone, '', child_.nodeValue) 4855 self.content_.append(obj_) 4856 if child_.nodeType == Node.TEXT_NODE: 4857 self.valueOf_ += child_.nodeValue 4858 elif child_.nodeType == Node.CDATA_SECTION_NODE: 4859 self.valueOf_ += '![CDATA['+child_.nodeValue+']]' 4860# end class docHeadingType 4861 4862 4863class docImageType(GeneratedsSuper): 4864 subclass = None 4865 superclass = None 4866 def __init__(self, width=None, type_=None, name=None, height=None, valueOf_='', mixedclass_=None, content_=None): 4867 self.width = width 4868 self.type_ = type_ 4869 self.name = name 4870 self.height = height 4871 if mixedclass_ is None: 4872 self.mixedclass_ = MixedContainer 4873 else: 4874 self.mixedclass_ = mixedclass_ 4875 if content_ is None: 4876 self.content_ = [] 4877 else: 4878 self.content_ = content_ 4879 def factory(*args_, **kwargs_): 4880 if docImageType.subclass: 4881 return docImageType.subclass(*args_, **kwargs_) 4882 else: 4883 return docImageType(*args_, **kwargs_) 4884 factory = staticmethod(factory) 4885 def get_width(self): return self.width 4886 def set_width(self, width): self.width = width 4887 def get_type(self): return self.type_ 4888 def set_type(self, type_): self.type_ = type_ 4889 def get_name(self): return self.name 4890 def set_name(self, name): self.name = name 4891 def get_height(self): return self.height 4892 def set_height(self, height): self.height = height 4893 def getValueOf_(self): return self.valueOf_ 4894 def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ 4895 def export(self, outfile, level, namespace_='', name_='docImageType', namespacedef_=''): 4896 showIndent(outfile, level) 4897 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 4898 self.exportAttributes(outfile, level, namespace_, name_='docImageType') 4899 outfile.write('>') 4900 self.exportChildren(outfile, level + 1, namespace_, name_) 4901 outfile.write('</%s%s>\n' % (namespace_, name_)) 4902 def exportAttributes(self, outfile, level, namespace_='', name_='docImageType'): 4903 if self.width is not None: 4904 outfile.write(' width=%s' % (self.format_string(quote_attrib(self.width).encode(ExternalEncoding), input_name='width'), )) 4905 if self.type_ is not None: 4906 outfile.write(' type=%s' % (quote_attrib(self.type_), )) 4907 if self.name is not None: 4908 outfile.write(' name=%s' % (self.format_string(quote_attrib(self.name).encode(ExternalEncoding), input_name='name'), )) 4909 if self.height is not None: 4910 outfile.write(' height=%s' % (self.format_string(quote_attrib(self.height).encode(ExternalEncoding), input_name='height'), )) 4911 def exportChildren(self, outfile, level, namespace_='', name_='docImageType'): 4912 if self.valueOf_.find('![CDATA')>-1: 4913 value=quote_xml('%s' % self.valueOf_) 4914 value=value.replace('![CDATA','<![CDATA') 4915 value=value.replace(']]',']]>') 4916 outfile.write(value) 4917 else: 4918 outfile.write(quote_xml('%s' % self.valueOf_)) 4919 def hasContent_(self): 4920 if ( 4921 self.valueOf_ is not None 4922 ): 4923 return True 4924 else: 4925 return False 4926 def build(self, node_): 4927 attrs = node_.attributes 4928 self.buildAttributes(attrs) 4929 self.valueOf_ = '' 4930 for child_ in node_.childNodes: 4931 nodeName_ = child_.nodeName.split(':')[-1] 4932 self.buildChildren(child_, nodeName_) 4933 def buildAttributes(self, attrs): 4934 if attrs.get('width'): 4935 self.width = attrs.get('width').value 4936 if attrs.get('type'): 4937 self.type_ = attrs.get('type').value 4938 if attrs.get('name'): 4939 self.name = attrs.get('name').value 4940 if attrs.get('height'): 4941 self.height = attrs.get('height').value 4942 def buildChildren(self, child_, nodeName_): 4943 if child_.nodeType == Node.TEXT_NODE: 4944 obj_ = self.mixedclass_(MixedContainer.CategoryText, 4945 MixedContainer.TypeNone, '', child_.nodeValue) 4946 self.content_.append(obj_) 4947 if child_.nodeType == Node.TEXT_NODE: 4948 self.valueOf_ += child_.nodeValue 4949 elif child_.nodeType == Node.CDATA_SECTION_NODE: 4950 self.valueOf_ += '![CDATA['+child_.nodeValue+']]' 4951# end class docImageType 4952 4953 4954class docDotFileType(GeneratedsSuper): 4955 subclass = None 4956 superclass = None 4957 def __init__(self, name=None, valueOf_='', mixedclass_=None, content_=None): 4958 self.name = name 4959 if mixedclass_ is None: 4960 self.mixedclass_ = MixedContainer 4961 else: 4962 self.mixedclass_ = mixedclass_ 4963 if content_ is None: 4964 self.content_ = [] 4965 else: 4966 self.content_ = content_ 4967 def factory(*args_, **kwargs_): 4968 if docDotFileType.subclass: 4969 return docDotFileType.subclass(*args_, **kwargs_) 4970 else: 4971 return docDotFileType(*args_, **kwargs_) 4972 factory = staticmethod(factory) 4973 def get_name(self): return self.name 4974 def set_name(self, name): self.name = name 4975 def getValueOf_(self): return self.valueOf_ 4976 def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ 4977 def export(self, outfile, level, namespace_='', name_='docDotFileType', namespacedef_=''): 4978 showIndent(outfile, level) 4979 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 4980 self.exportAttributes(outfile, level, namespace_, name_='docDotFileType') 4981 outfile.write('>') 4982 self.exportChildren(outfile, level + 1, namespace_, name_) 4983 outfile.write('</%s%s>\n' % (namespace_, name_)) 4984 def exportAttributes(self, outfile, level, namespace_='', name_='docDotFileType'): 4985 if self.name is not None: 4986 outfile.write(' name=%s' % (self.format_string(quote_attrib(self.name).encode(ExternalEncoding), input_name='name'), )) 4987 def exportChildren(self, outfile, level, namespace_='', name_='docDotFileType'): 4988 if self.valueOf_.find('![CDATA')>-1: 4989 value=quote_xml('%s' % self.valueOf_) 4990 value=value.replace('![CDATA','<![CDATA') 4991 value=value.replace(']]',']]>') 4992 outfile.write(value) 4993 else: 4994 outfile.write(quote_xml('%s' % self.valueOf_)) 4995 def hasContent_(self): 4996 if ( 4997 self.valueOf_ is not None 4998 ): 4999 return True 5000 else: 5001 return False 5002 def build(self, node_): 5003 attrs = node_.attributes 5004 self.buildAttributes(attrs) 5005 self.valueOf_ = '' 5006 for child_ in node_.childNodes: 5007 nodeName_ = child_.nodeName.split(':')[-1] 5008 self.buildChildren(child_, nodeName_) 5009 def buildAttributes(self, attrs): 5010 if attrs.get('name'): 5011 self.name = attrs.get('name').value 5012 def buildChildren(self, child_, nodeName_): 5013 if child_.nodeType == Node.TEXT_NODE: 5014 obj_ = self.mixedclass_(MixedContainer.CategoryText, 5015 MixedContainer.TypeNone, '', child_.nodeValue) 5016 self.content_.append(obj_) 5017 if child_.nodeType == Node.TEXT_NODE: 5018 self.valueOf_ += child_.nodeValue 5019 elif child_.nodeType == Node.CDATA_SECTION_NODE: 5020 self.valueOf_ += '![CDATA['+child_.nodeValue+']]' 5021# end class docDotFileType 5022 5023 5024class docTocItemType(GeneratedsSuper): 5025 subclass = None 5026 superclass = None 5027 def __init__(self, id=None, valueOf_='', mixedclass_=None, content_=None): 5028 self.id = id 5029 if mixedclass_ is None: 5030 self.mixedclass_ = MixedContainer 5031 else: 5032 self.mixedclass_ = mixedclass_ 5033 if content_ is None: 5034 self.content_ = [] 5035 else: 5036 self.content_ = content_ 5037 def factory(*args_, **kwargs_): 5038 if docTocItemType.subclass: 5039 return docTocItemType.subclass(*args_, **kwargs_) 5040 else: 5041 return docTocItemType(*args_, **kwargs_) 5042 factory = staticmethod(factory) 5043 def get_id(self): return self.id 5044 def set_id(self, id): self.id = id 5045 def getValueOf_(self): return self.valueOf_ 5046 def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ 5047 def export(self, outfile, level, namespace_='', name_='docTocItemType', namespacedef_=''): 5048 showIndent(outfile, level) 5049 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 5050 self.exportAttributes(outfile, level, namespace_, name_='docTocItemType') 5051 outfile.write('>') 5052 self.exportChildren(outfile, level + 1, namespace_, name_) 5053 outfile.write('</%s%s>\n' % (namespace_, name_)) 5054 def exportAttributes(self, outfile, level, namespace_='', name_='docTocItemType'): 5055 if self.id is not None: 5056 outfile.write(' id=%s' % (self.format_string(quote_attrib(self.id).encode(ExternalEncoding), input_name='id'), )) 5057 def exportChildren(self, outfile, level, namespace_='', name_='docTocItemType'): 5058 if self.valueOf_.find('![CDATA')>-1: 5059 value=quote_xml('%s' % self.valueOf_) 5060 value=value.replace('![CDATA','<![CDATA') 5061 value=value.replace(']]',']]>') 5062 outfile.write(value) 5063 else: 5064 outfile.write(quote_xml('%s' % self.valueOf_)) 5065 def hasContent_(self): 5066 if ( 5067 self.valueOf_ is not None 5068 ): 5069 return True 5070 else: 5071 return False 5072 def build(self, node_): 5073 attrs = node_.attributes 5074 self.buildAttributes(attrs) 5075 self.valueOf_ = '' 5076 for child_ in node_.childNodes: 5077 nodeName_ = child_.nodeName.split(':')[-1] 5078 self.buildChildren(child_, nodeName_) 5079 def buildAttributes(self, attrs): 5080 if attrs.get('id'): 5081 self.id = attrs.get('id').value 5082 def buildChildren(self, child_, nodeName_): 5083 if child_.nodeType == Node.TEXT_NODE: 5084 obj_ = self.mixedclass_(MixedContainer.CategoryText, 5085 MixedContainer.TypeNone, '', child_.nodeValue) 5086 self.content_.append(obj_) 5087 if child_.nodeType == Node.TEXT_NODE: 5088 self.valueOf_ += child_.nodeValue 5089 elif child_.nodeType == Node.CDATA_SECTION_NODE: 5090 self.valueOf_ += '![CDATA['+child_.nodeValue+']]' 5091# end class docTocItemType 5092 5093 5094class docTocListType(GeneratedsSuper): 5095 subclass = None 5096 superclass = None 5097 def __init__(self, tocitem=None): 5098 if tocitem is None: 5099 self.tocitem = [] 5100 else: 5101 self.tocitem = tocitem 5102 def factory(*args_, **kwargs_): 5103 if docTocListType.subclass: 5104 return docTocListType.subclass(*args_, **kwargs_) 5105 else: 5106 return docTocListType(*args_, **kwargs_) 5107 factory = staticmethod(factory) 5108 def get_tocitem(self): return self.tocitem 5109 def set_tocitem(self, tocitem): self.tocitem = tocitem 5110 def add_tocitem(self, value): self.tocitem.append(value) 5111 def insert_tocitem(self, index, value): self.tocitem[index] = value 5112 def export(self, outfile, level, namespace_='', name_='docTocListType', namespacedef_=''): 5113 showIndent(outfile, level) 5114 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 5115 self.exportAttributes(outfile, level, namespace_, name_='docTocListType') 5116 if self.hasContent_(): 5117 outfile.write('>\n') 5118 self.exportChildren(outfile, level + 1, namespace_, name_) 5119 showIndent(outfile, level) 5120 outfile.write('</%s%s>\n' % (namespace_, name_)) 5121 else: 5122 outfile.write(' />\n') 5123 def exportAttributes(self, outfile, level, namespace_='', name_='docTocListType'): 5124 pass 5125 def exportChildren(self, outfile, level, namespace_='', name_='docTocListType'): 5126 for tocitem_ in self.tocitem: 5127 tocitem_.export(outfile, level, namespace_, name_='tocitem') 5128 def hasContent_(self): 5129 if ( 5130 self.tocitem is not None 5131 ): 5132 return True 5133 else: 5134 return False 5135 def build(self, node_): 5136 attrs = node_.attributes 5137 self.buildAttributes(attrs) 5138 for child_ in node_.childNodes: 5139 nodeName_ = child_.nodeName.split(':')[-1] 5140 self.buildChildren(child_, nodeName_) 5141 def buildAttributes(self, attrs): 5142 pass 5143 def buildChildren(self, child_, nodeName_): 5144 if child_.nodeType == Node.ELEMENT_NODE and \ 5145 nodeName_ == 'tocitem': 5146 obj_ = docTocItemType.factory() 5147 obj_.build(child_) 5148 self.tocitem.append(obj_) 5149# end class docTocListType 5150 5151 5152class docLanguageType(GeneratedsSuper): 5153 subclass = None 5154 superclass = None 5155 def __init__(self, langid=None, para=None): 5156 self.langid = langid 5157 if para is None: 5158 self.para = [] 5159 else: 5160 self.para = para 5161 def factory(*args_, **kwargs_): 5162 if docLanguageType.subclass: 5163 return docLanguageType.subclass(*args_, **kwargs_) 5164 else: 5165 return docLanguageType(*args_, **kwargs_) 5166 factory = staticmethod(factory) 5167 def get_para(self): return self.para 5168 def set_para(self, para): self.para = para 5169 def add_para(self, value): self.para.append(value) 5170 def insert_para(self, index, value): self.para[index] = value 5171 def get_langid(self): return self.langid 5172 def set_langid(self, langid): self.langid = langid 5173 def export(self, outfile, level, namespace_='', name_='docLanguageType', namespacedef_=''): 5174 showIndent(outfile, level) 5175 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 5176 self.exportAttributes(outfile, level, namespace_, name_='docLanguageType') 5177 if self.hasContent_(): 5178 outfile.write('>\n') 5179 self.exportChildren(outfile, level + 1, namespace_, name_) 5180 showIndent(outfile, level) 5181 outfile.write('</%s%s>\n' % (namespace_, name_)) 5182 else: 5183 outfile.write(' />\n') 5184 def exportAttributes(self, outfile, level, namespace_='', name_='docLanguageType'): 5185 if self.langid is not None: 5186 outfile.write(' langid=%s' % (self.format_string(quote_attrib(self.langid).encode(ExternalEncoding), input_name='langid'), )) 5187 def exportChildren(self, outfile, level, namespace_='', name_='docLanguageType'): 5188 for para_ in self.para: 5189 para_.export(outfile, level, namespace_, name_='para') 5190 def hasContent_(self): 5191 if ( 5192 self.para is not None 5193 ): 5194 return True 5195 else: 5196 return False 5197 def build(self, node_): 5198 attrs = node_.attributes 5199 self.buildAttributes(attrs) 5200 for child_ in node_.childNodes: 5201 nodeName_ = child_.nodeName.split(':')[-1] 5202 self.buildChildren(child_, nodeName_) 5203 def buildAttributes(self, attrs): 5204 if attrs.get('langid'): 5205 self.langid = attrs.get('langid').value 5206 def buildChildren(self, child_, nodeName_): 5207 if child_.nodeType == Node.ELEMENT_NODE and \ 5208 nodeName_ == 'para': 5209 obj_ = docParaType.factory() 5210 obj_.build(child_) 5211 self.para.append(obj_) 5212# end class docLanguageType 5213 5214 5215class docParamListType(GeneratedsSuper): 5216 subclass = None 5217 superclass = None 5218 def __init__(self, kind=None, parameteritem=None): 5219 self.kind = kind 5220 if parameteritem is None: 5221 self.parameteritem = [] 5222 else: 5223 self.parameteritem = parameteritem 5224 def factory(*args_, **kwargs_): 5225 if docParamListType.subclass: 5226 return docParamListType.subclass(*args_, **kwargs_) 5227 else: 5228 return docParamListType(*args_, **kwargs_) 5229 factory = staticmethod(factory) 5230 def get_parameteritem(self): return self.parameteritem 5231 def set_parameteritem(self, parameteritem): self.parameteritem = parameteritem 5232 def add_parameteritem(self, value): self.parameteritem.append(value) 5233 def insert_parameteritem(self, index, value): self.parameteritem[index] = value 5234 def get_kind(self): return self.kind 5235 def set_kind(self, kind): self.kind = kind 5236 def export(self, outfile, level, namespace_='', name_='docParamListType', namespacedef_=''): 5237 showIndent(outfile, level) 5238 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 5239 self.exportAttributes(outfile, level, namespace_, name_='docParamListType') 5240 if self.hasContent_(): 5241 outfile.write('>\n') 5242 self.exportChildren(outfile, level + 1, namespace_, name_) 5243 showIndent(outfile, level) 5244 outfile.write('</%s%s>\n' % (namespace_, name_)) 5245 else: 5246 outfile.write(' />\n') 5247 def exportAttributes(self, outfile, level, namespace_='', name_='docParamListType'): 5248 if self.kind is not None: 5249 outfile.write(' kind=%s' % (quote_attrib(self.kind), )) 5250 def exportChildren(self, outfile, level, namespace_='', name_='docParamListType'): 5251 for parameteritem_ in self.parameteritem: 5252 parameteritem_.export(outfile, level, namespace_, name_='parameteritem') 5253 def hasContent_(self): 5254 if ( 5255 self.parameteritem is not None 5256 ): 5257 return True 5258 else: 5259 return False 5260 def build(self, node_): 5261 attrs = node_.attributes 5262 self.buildAttributes(attrs) 5263 for child_ in node_.childNodes: 5264 nodeName_ = child_.nodeName.split(':')[-1] 5265 self.buildChildren(child_, nodeName_) 5266 def buildAttributes(self, attrs): 5267 if attrs.get('kind'): 5268 self.kind = attrs.get('kind').value 5269 def buildChildren(self, child_, nodeName_): 5270 if child_.nodeType == Node.ELEMENT_NODE and \ 5271 nodeName_ == 'parameteritem': 5272 obj_ = docParamListItem.factory() 5273 obj_.build(child_) 5274 self.parameteritem.append(obj_) 5275# end class docParamListType 5276 5277 5278class docParamListItem(GeneratedsSuper): 5279 subclass = None 5280 superclass = None 5281 def __init__(self, parameternamelist=None, parameterdescription=None): 5282 if parameternamelist is None: 5283 self.parameternamelist = [] 5284 else: 5285 self.parameternamelist = parameternamelist 5286 self.parameterdescription = parameterdescription 5287 def factory(*args_, **kwargs_): 5288 if docParamListItem.subclass: 5289 return docParamListItem.subclass(*args_, **kwargs_) 5290 else: 5291 return docParamListItem(*args_, **kwargs_) 5292 factory = staticmethod(factory) 5293 def get_parameternamelist(self): return self.parameternamelist 5294 def set_parameternamelist(self, parameternamelist): self.parameternamelist = parameternamelist 5295 def add_parameternamelist(self, value): self.parameternamelist.append(value) 5296 def insert_parameternamelist(self, index, value): self.parameternamelist[index] = value 5297 def get_parameterdescription(self): return self.parameterdescription 5298 def set_parameterdescription(self, parameterdescription): self.parameterdescription = parameterdescription 5299 def export(self, outfile, level, namespace_='', name_='docParamListItem', namespacedef_=''): 5300 showIndent(outfile, level) 5301 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 5302 self.exportAttributes(outfile, level, namespace_, name_='docParamListItem') 5303 if self.hasContent_(): 5304 outfile.write('>\n') 5305 self.exportChildren(outfile, level + 1, namespace_, name_) 5306 showIndent(outfile, level) 5307 outfile.write('</%s%s>\n' % (namespace_, name_)) 5308 else: 5309 outfile.write(' />\n') 5310 def exportAttributes(self, outfile, level, namespace_='', name_='docParamListItem'): 5311 pass 5312 def exportChildren(self, outfile, level, namespace_='', name_='docParamListItem'): 5313 for parameternamelist_ in self.parameternamelist: 5314 parameternamelist_.export(outfile, level, namespace_, name_='parameternamelist') 5315 if self.parameterdescription: 5316 self.parameterdescription.export(outfile, level, namespace_, name_='parameterdescription', ) 5317 def hasContent_(self): 5318 if ( 5319 self.parameternamelist is not None or 5320 self.parameterdescription is not None 5321 ): 5322 return True 5323 else: 5324 return False 5325 def build(self, node_): 5326 attrs = node_.attributes 5327 self.buildAttributes(attrs) 5328 for child_ in node_.childNodes: 5329 nodeName_ = child_.nodeName.split(':')[-1] 5330 self.buildChildren(child_, nodeName_) 5331 def buildAttributes(self, attrs): 5332 pass 5333 def buildChildren(self, child_, nodeName_): 5334 if child_.nodeType == Node.ELEMENT_NODE and \ 5335 nodeName_ == 'parameternamelist': 5336 obj_ = docParamNameList.factory() 5337 obj_.build(child_) 5338 self.parameternamelist.append(obj_) 5339 elif child_.nodeType == Node.ELEMENT_NODE and \ 5340 nodeName_ == 'parameterdescription': 5341 obj_ = descriptionType.factory() 5342 obj_.build(child_) 5343 self.set_parameterdescription(obj_) 5344# end class docParamListItem 5345 5346 5347class docParamNameList(GeneratedsSuper): 5348 subclass = None 5349 superclass = None 5350 def __init__(self, parametername=None): 5351 if parametername is None: 5352 self.parametername = [] 5353 else: 5354 self.parametername = parametername 5355 def factory(*args_, **kwargs_): 5356 if docParamNameList.subclass: 5357 return docParamNameList.subclass(*args_, **kwargs_) 5358 else: 5359 return docParamNameList(*args_, **kwargs_) 5360 factory = staticmethod(factory) 5361 def get_parametername(self): return self.parametername 5362 def set_parametername(self, parametername): self.parametername = parametername 5363 def add_parametername(self, value): self.parametername.append(value) 5364 def insert_parametername(self, index, value): self.parametername[index] = value 5365 def export(self, outfile, level, namespace_='', name_='docParamNameList', namespacedef_=''): 5366 showIndent(outfile, level) 5367 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 5368 self.exportAttributes(outfile, level, namespace_, name_='docParamNameList') 5369 if self.hasContent_(): 5370 outfile.write('>\n') 5371 self.exportChildren(outfile, level + 1, namespace_, name_) 5372 showIndent(outfile, level) 5373 outfile.write('</%s%s>\n' % (namespace_, name_)) 5374 else: 5375 outfile.write(' />\n') 5376 def exportAttributes(self, outfile, level, namespace_='', name_='docParamNameList'): 5377 pass 5378 def exportChildren(self, outfile, level, namespace_='', name_='docParamNameList'): 5379 for parametername_ in self.parametername: 5380 parametername_.export(outfile, level, namespace_, name_='parametername') 5381 def hasContent_(self): 5382 if ( 5383 self.parametername is not None 5384 ): 5385 return True 5386 else: 5387 return False 5388 def build(self, node_): 5389 attrs = node_.attributes 5390 self.buildAttributes(attrs) 5391 for child_ in node_.childNodes: 5392 nodeName_ = child_.nodeName.split(':')[-1] 5393 self.buildChildren(child_, nodeName_) 5394 def buildAttributes(self, attrs): 5395 pass 5396 def buildChildren(self, child_, nodeName_): 5397 if child_.nodeType == Node.ELEMENT_NODE and \ 5398 nodeName_ == 'parametername': 5399 obj_ = docParamName.factory() 5400 obj_.build(child_) 5401 self.parametername.append(obj_) 5402# end class docParamNameList 5403 5404 5405class docParamName(GeneratedsSuper): 5406 subclass = None 5407 superclass = None 5408 def __init__(self, direction=None, ref=None, mixedclass_=None, content_=None): 5409 self.direction = direction 5410 if mixedclass_ is None: 5411 self.mixedclass_ = MixedContainer 5412 else: 5413 self.mixedclass_ = mixedclass_ 5414 if content_ is None: 5415 self.content_ = [] 5416 else: 5417 self.content_ = content_ 5418 def factory(*args_, **kwargs_): 5419 if docParamName.subclass: 5420 return docParamName.subclass(*args_, **kwargs_) 5421 else: 5422 return docParamName(*args_, **kwargs_) 5423 factory = staticmethod(factory) 5424 def get_ref(self): return self.ref 5425 def set_ref(self, ref): self.ref = ref 5426 def get_direction(self): return self.direction 5427 def set_direction(self, direction): self.direction = direction 5428 def export(self, outfile, level, namespace_='', name_='docParamName', namespacedef_=''): 5429 showIndent(outfile, level) 5430 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 5431 self.exportAttributes(outfile, level, namespace_, name_='docParamName') 5432 outfile.write('>') 5433 self.exportChildren(outfile, level + 1, namespace_, name_) 5434 outfile.write('</%s%s>\n' % (namespace_, name_)) 5435 def exportAttributes(self, outfile, level, namespace_='', name_='docParamName'): 5436 if self.direction is not None: 5437 outfile.write(' direction=%s' % (quote_attrib(self.direction), )) 5438 def exportChildren(self, outfile, level, namespace_='', name_='docParamName'): 5439 for item_ in self.content_: 5440 item_.export(outfile, level, item_.name, namespace_) 5441 def hasContent_(self): 5442 if ( 5443 self.ref is not None 5444 ): 5445 return True 5446 else: 5447 return False 5448 def build(self, node_): 5449 attrs = node_.attributes 5450 self.buildAttributes(attrs) 5451 for child_ in node_.childNodes: 5452 nodeName_ = child_.nodeName.split(':')[-1] 5453 self.buildChildren(child_, nodeName_) 5454 def buildAttributes(self, attrs): 5455 if attrs.get('direction'): 5456 self.direction = attrs.get('direction').value 5457 def buildChildren(self, child_, nodeName_): 5458 if child_.nodeType == Node.ELEMENT_NODE and \ 5459 nodeName_ == 'ref': 5460 childobj_ = docRefTextType.factory() 5461 childobj_.build(child_) 5462 obj_ = self.mixedclass_(MixedContainer.CategoryComplex, 5463 MixedContainer.TypeNone, 'ref', childobj_) 5464 self.content_.append(obj_) 5465 elif child_.nodeType == Node.TEXT_NODE: 5466 obj_ = self.mixedclass_(MixedContainer.CategoryText, 5467 MixedContainer.TypeNone, '', child_.nodeValue) 5468 self.content_.append(obj_) 5469 d = child_.parentNode.attributes.get('direction') 5470 if d is not None: 5471 self.content_.insert(0, self.mixedclass_(MixedContainer.CategoryText, 5472 MixedContainer.TypeNone, 5473 '', '[{}] '.format(d.value))) 5474# end class docParamName 5475 5476 5477class docXRefSectType(GeneratedsSuper): 5478 subclass = None 5479 superclass = None 5480 def __init__(self, id=None, xreftitle=None, xrefdescription=None): 5481 self.id = id 5482 if xreftitle is None: 5483 self.xreftitle = [] 5484 else: 5485 self.xreftitle = xreftitle 5486 self.xrefdescription = xrefdescription 5487 def factory(*args_, **kwargs_): 5488 if docXRefSectType.subclass: 5489 return docXRefSectType.subclass(*args_, **kwargs_) 5490 else: 5491 return docXRefSectType(*args_, **kwargs_) 5492 factory = staticmethod(factory) 5493 def get_xreftitle(self): return self.xreftitle 5494 def set_xreftitle(self, xreftitle): self.xreftitle = xreftitle 5495 def add_xreftitle(self, value): self.xreftitle.append(value) 5496 def insert_xreftitle(self, index, value): self.xreftitle[index] = value 5497 def get_xrefdescription(self): return self.xrefdescription 5498 def set_xrefdescription(self, xrefdescription): self.xrefdescription = xrefdescription 5499 def get_id(self): return self.id 5500 def set_id(self, id): self.id = id 5501 def export(self, outfile, level, namespace_='', name_='docXRefSectType', namespacedef_=''): 5502 showIndent(outfile, level) 5503 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 5504 self.exportAttributes(outfile, level, namespace_, name_='docXRefSectType') 5505 if self.hasContent_(): 5506 outfile.write('>\n') 5507 self.exportChildren(outfile, level + 1, namespace_, name_) 5508 showIndent(outfile, level) 5509 outfile.write('</%s%s>\n' % (namespace_, name_)) 5510 else: 5511 outfile.write(' />\n') 5512 def exportAttributes(self, outfile, level, namespace_='', name_='docXRefSectType'): 5513 if self.id is not None: 5514 outfile.write(' id=%s' % (self.format_string(quote_attrib(self.id).encode(ExternalEncoding), input_name='id'), )) 5515 def exportChildren(self, outfile, level, namespace_='', name_='docXRefSectType'): 5516 for xreftitle_ in self.xreftitle: 5517 showIndent(outfile, level) 5518 outfile.write('<%sxreftitle>%s</%sxreftitle>\n' % (namespace_, self.format_string(quote_xml(xreftitle_).encode(ExternalEncoding), input_name='xreftitle'), namespace_)) 5519 if self.xrefdescription: 5520 self.xrefdescription.export(outfile, level, namespace_, name_='xrefdescription', ) 5521 def hasContent_(self): 5522 if ( 5523 self.xreftitle is not None or 5524 self.xrefdescription is not None 5525 ): 5526 return True 5527 else: 5528 return False 5529 def build(self, node_): 5530 attrs = node_.attributes 5531 self.buildAttributes(attrs) 5532 for child_ in node_.childNodes: 5533 nodeName_ = child_.nodeName.split(':')[-1] 5534 self.buildChildren(child_, nodeName_) 5535 def buildAttributes(self, attrs): 5536 if attrs.get('id'): 5537 self.id = attrs.get('id').value 5538 def buildChildren(self, child_, nodeName_): 5539 if child_.nodeType == Node.ELEMENT_NODE and \ 5540 nodeName_ == 'xreftitle': 5541 xreftitle_ = '' 5542 for text__content_ in child_.childNodes: 5543 xreftitle_ += text__content_.nodeValue 5544 self.xreftitle.append(xreftitle_) 5545 elif child_.nodeType == Node.ELEMENT_NODE and \ 5546 nodeName_ == 'xrefdescription': 5547 obj_ = descriptionType.factory() 5548 obj_.build(child_) 5549 self.set_xrefdescription(obj_) 5550# end class docXRefSectType 5551 5552 5553class docCopyType(GeneratedsSuper): 5554 subclass = None 5555 superclass = None 5556 def __init__(self, link=None, para=None, sect1=None, internal=None): 5557 self.link = link 5558 if para is None: 5559 self.para = [] 5560 else: 5561 self.para = para 5562 if sect1 is None: 5563 self.sect1 = [] 5564 else: 5565 self.sect1 = sect1 5566 self.internal = internal 5567 def factory(*args_, **kwargs_): 5568 if docCopyType.subclass: 5569 return docCopyType.subclass(*args_, **kwargs_) 5570 else: 5571 return docCopyType(*args_, **kwargs_) 5572 factory = staticmethod(factory) 5573 def get_para(self): return self.para 5574 def set_para(self, para): self.para = para 5575 def add_para(self, value): self.para.append(value) 5576 def insert_para(self, index, value): self.para[index] = value 5577 def get_sect1(self): return self.sect1 5578 def set_sect1(self, sect1): self.sect1 = sect1 5579 def add_sect1(self, value): self.sect1.append(value) 5580 def insert_sect1(self, index, value): self.sect1[index] = value 5581 def get_internal(self): return self.internal 5582 def set_internal(self, internal): self.internal = internal 5583 def get_link(self): return self.link 5584 def set_link(self, link): self.link = link 5585 def export(self, outfile, level, namespace_='', name_='docCopyType', namespacedef_=''): 5586 showIndent(outfile, level) 5587 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 5588 self.exportAttributes(outfile, level, namespace_, name_='docCopyType') 5589 if self.hasContent_(): 5590 outfile.write('>\n') 5591 self.exportChildren(outfile, level + 1, namespace_, name_) 5592 showIndent(outfile, level) 5593 outfile.write('</%s%s>\n' % (namespace_, name_)) 5594 else: 5595 outfile.write(' />\n') 5596 def exportAttributes(self, outfile, level, namespace_='', name_='docCopyType'): 5597 if self.link is not None: 5598 outfile.write(' link=%s' % (self.format_string(quote_attrib(self.link).encode(ExternalEncoding), input_name='link'), )) 5599 def exportChildren(self, outfile, level, namespace_='', name_='docCopyType'): 5600 for para_ in self.para: 5601 para_.export(outfile, level, namespace_, name_='para') 5602 for sect1_ in self.sect1: 5603 sect1_.export(outfile, level, namespace_, name_='sect1') 5604 if self.internal: 5605 self.internal.export(outfile, level, namespace_, name_='internal') 5606 def hasContent_(self): 5607 if ( 5608 self.para is not None or 5609 self.sect1 is not None or 5610 self.internal is not None 5611 ): 5612 return True 5613 else: 5614 return False 5615 def build(self, node_): 5616 attrs = node_.attributes 5617 self.buildAttributes(attrs) 5618 for child_ in node_.childNodes: 5619 nodeName_ = child_.nodeName.split(':')[-1] 5620 self.buildChildren(child_, nodeName_) 5621 def buildAttributes(self, attrs): 5622 if attrs.get('link'): 5623 self.link = attrs.get('link').value 5624 def buildChildren(self, child_, nodeName_): 5625 if child_.nodeType == Node.ELEMENT_NODE and \ 5626 nodeName_ == 'para': 5627 obj_ = docParaType.factory() 5628 obj_.build(child_) 5629 self.para.append(obj_) 5630 elif child_.nodeType == Node.ELEMENT_NODE and \ 5631 nodeName_ == 'sect1': 5632 obj_ = docSect1Type.factory() 5633 obj_.build(child_) 5634 self.sect1.append(obj_) 5635 elif child_.nodeType == Node.ELEMENT_NODE and \ 5636 nodeName_ == 'internal': 5637 obj_ = docInternalType.factory() 5638 obj_.build(child_) 5639 self.set_internal(obj_) 5640# end class docCopyType 5641 5642 5643class docCharType(GeneratedsSuper): 5644 subclass = None 5645 superclass = None 5646 def __init__(self, char=None, valueOf_=''): 5647 self.char = char 5648 self.valueOf_ = valueOf_ 5649 def factory(*args_, **kwargs_): 5650 if docCharType.subclass: 5651 return docCharType.subclass(*args_, **kwargs_) 5652 else: 5653 return docCharType(*args_, **kwargs_) 5654 factory = staticmethod(factory) 5655 def get_char(self): return self.char 5656 def set_char(self, char): self.char = char 5657 def getValueOf_(self): return self.valueOf_ 5658 def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ 5659 def export(self, outfile, level, namespace_='', name_='docCharType', namespacedef_=''): 5660 showIndent(outfile, level) 5661 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 5662 self.exportAttributes(outfile, level, namespace_, name_='docCharType') 5663 if self.hasContent_(): 5664 outfile.write('>\n') 5665 self.exportChildren(outfile, level + 1, namespace_, name_) 5666 showIndent(outfile, level) 5667 outfile.write('</%s%s>\n' % (namespace_, name_)) 5668 else: 5669 outfile.write(' />\n') 5670 def exportAttributes(self, outfile, level, namespace_='', name_='docCharType'): 5671 if self.char is not None: 5672 outfile.write(' char=%s' % (quote_attrib(self.char), )) 5673 def exportChildren(self, outfile, level, namespace_='', name_='docCharType'): 5674 if self.valueOf_.find('![CDATA')>-1: 5675 value=quote_xml('%s' % self.valueOf_) 5676 value=value.replace('![CDATA','<![CDATA') 5677 value=value.replace(']]',']]>') 5678 outfile.write(value) 5679 else: 5680 outfile.write(quote_xml('%s' % self.valueOf_)) 5681 def hasContent_(self): 5682 if ( 5683 self.valueOf_ is not None 5684 ): 5685 return True 5686 else: 5687 return False 5688 def build(self, node_): 5689 attrs = node_.attributes 5690 self.buildAttributes(attrs) 5691 self.valueOf_ = '' 5692 for child_ in node_.childNodes: 5693 nodeName_ = child_.nodeName.split(':')[-1] 5694 self.buildChildren(child_, nodeName_) 5695 def buildAttributes(self, attrs): 5696 if attrs.get('char'): 5697 self.char = attrs.get('char').value 5698 def buildChildren(self, child_, nodeName_): 5699 if child_.nodeType == Node.TEXT_NODE: 5700 self.valueOf_ += child_.nodeValue 5701 elif child_.nodeType == Node.CDATA_SECTION_NODE: 5702 self.valueOf_ += '![CDATA['+child_.nodeValue+']]' 5703# end class docCharType 5704 5705 5706class docParBlockType(GeneratedsSuper): 5707 subclass = None 5708 superclass = None 5709 def __init__(self, mixedclass_=None, para=None): 5710 if mixedclass_ is None: 5711 self.mixedclass_ = MixedContainer 5712 else: 5713 self.mixedclass_ = mixedclass_ 5714 if para is None: 5715 self.para = [] 5716 else: 5717 self.para = para 5718 def factory(*args_, **kwargs_): 5719 if docParBlockType.subclass: 5720 return docParBlockType.subclass(*args_, **kwargs_) 5721 else: 5722 return docParBlockType(*args_, **kwargs_) 5723 factory = staticmethod(factory) 5724 def get_para(self): return self.para 5725 def set_para(self, para): self.para = para 5726 def add_para(self, value): self.para.append(value) 5727 def insert_para(self, index, value): self.para[index] = value 5728 def export(self, outfile, level, namespace_='', name_='docParBlockType', namespacedef_=''): 5729 showIndent(outfile, level) 5730 outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 5731 self.exportAttributes(outfile, level, namespace_, name_='docParBlockType') 5732 if self.hasContent_(): 5733 outfile.write('>\n') 5734 self.exportChildren(outfile, level + 1, namespace_, name_) 5735 showIndent(outfile, level) 5736 outfile.write('</%s%s>\n' % (namespace_, name_)) 5737 else: 5738 outfile.write('/>\n') 5739 def exportAttributes(self, outfile, level, namespace_='', name_='docParBlockType'): 5740 pass 5741 def exportChildren(self, outfile, level, namespace_='', name_='docParBlockType'): 5742 for para_ in self.para: 5743 para_.export(outfile, level, namespace_, name_='para') 5744 def hasContent_(self): 5745 if ( 5746 self.para 5747 ): 5748 return True 5749 else: 5750 return False 5751 def build(self, node_): 5752 attrs = node_.attributes 5753 self.buildAttributes(attrs) 5754 self.valueOf_ = '' 5755 for child_ in node_.childNodes: 5756 nodeName_ = child_.nodeName.split(':')[-1] 5757 self.buildChildren(child_, nodeName_) 5758 def buildAttributes(self, attrs): 5759 pass 5760 def buildChildren(self, child_, nodeName_): 5761 if child_.nodeType == Node.ELEMENT_NODE and \ 5762 nodeName_ == 'para': 5763 obj_ = docParaType.factory() 5764 obj_.build(child_) 5765 obj_ = self.mixedclass_(MixedContainer.CategoryComplex, 5766 MixedContainer.TypeNone, 'para', obj_) 5767 self.para.append(obj_) 5768 5769# end class docParBlockType 5770 5771 5772class docEmptyType(GeneratedsSuper): 5773 subclass = None 5774 superclass = None 5775 def __init__(self, valueOf_=''): 5776 self.valueOf_ = valueOf_ 5777 def factory(*args_, **kwargs_): 5778 if docEmptyType.subclass: 5779 return docEmptyType.subclass(*args_, **kwargs_) 5780 else: 5781 return docEmptyType(*args_, **kwargs_) 5782 factory = staticmethod(factory) 5783 def getValueOf_(self): return self.valueOf_ 5784 def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ 5785 def export(self, outfile, level, namespace_='', name_='docEmptyType', namespacedef_=''): 5786 showIndent(outfile, level) 5787 outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) 5788 self.exportAttributes(outfile, level, namespace_, name_='docEmptyType') 5789 if self.hasContent_(): 5790 outfile.write('>\n') 5791 self.exportChildren(outfile, level + 1, namespace_, name_) 5792 showIndent(outfile, level) 5793 outfile.write('</%s%s>\n' % (namespace_, name_)) 5794 else: 5795 outfile.write(' />\n') 5796 def exportAttributes(self, outfile, level, namespace_='', name_='docEmptyType'): 5797 pass 5798 def exportChildren(self, outfile, level, namespace_='', name_='docEmptyType'): 5799 if self.valueOf_.find('![CDATA')>-1: 5800 value=quote_xml('%s' % self.valueOf_) 5801 value=value.replace('![CDATA','<![CDATA') 5802 value=value.replace(']]',']]>') 5803 outfile.write(value) 5804 else: 5805 outfile.write(quote_xml('%s' % self.valueOf_)) 5806 def hasContent_(self): 5807 if ( 5808 self.valueOf_ is not None 5809 ): 5810 return True 5811 else: 5812 return False 5813 def build(self, node_): 5814 attrs = node_.attributes 5815 self.buildAttributes(attrs) 5816 self.valueOf_ = '' 5817 for child_ in node_.childNodes: 5818 nodeName_ = child_.nodeName.split(':')[-1] 5819 self.buildChildren(child_, nodeName_) 5820 def buildAttributes(self, attrs): 5821 pass 5822 def buildChildren(self, child_, nodeName_): 5823 if child_.nodeType == Node.TEXT_NODE: 5824 self.valueOf_ += child_.nodeValue 5825 elif child_.nodeType == Node.CDATA_SECTION_NODE: 5826 self.valueOf_ += '![CDATA['+child_.nodeValue+']]' 5827# end class docEmptyType 5828 5829 5830USAGE_TEXT = """ 5831Usage: python <Parser>.py [ -s ] <in_xml_file> 5832Options: 5833 -s Use the SAX parser, not the minidom parser. 5834""" 5835 5836def usage(): 5837 print(USAGE_TEXT) 5838 sys.exit(1) 5839 5840 5841def parse(inFileName): 5842 doc = minidom.parse(inFileName) 5843 rootNode = doc.documentElement 5844 rootObj = DoxygenType.factory() 5845 rootObj.build(rootNode) 5846 # Enable Python to collect the space used by the DOM. 5847 doc = None 5848 sys.stdout.write('<?xml version="1.0" ?>\n') 5849 rootObj.export(sys.stdout, 0, name_="doxygen", 5850 namespacedef_='') 5851 return rootObj 5852 5853 5854def parseString(inString): 5855 doc = minidom.parseString(inString) 5856 rootNode = doc.documentElement 5857 rootObj = DoxygenType.factory() 5858 rootObj.build(rootNode) 5859 # Enable Python to collect the space used by the DOM. 5860 doc = None 5861 sys.stdout.write('<?xml version="1.0" ?>\n') 5862 rootObj.export(sys.stdout, 0, name_="doxygen", 5863 namespacedef_='') 5864 return rootObj 5865 5866 5867def parseLiteral(inFileName): 5868 doc = minidom.parse(inFileName) 5869 rootNode = doc.documentElement 5870 rootObj = DoxygenType.factory() 5871 rootObj.build(rootNode) 5872 # Enable Python to collect the space used by the DOM. 5873 doc = None 5874 sys.stdout.write('from compound import *\n\n') 5875 sys.stdout.write('rootObj = doxygen(\n') 5876 rootObj.exportLiteral(sys.stdout, 0, name_="doxygen") 5877 sys.stdout.write(')\n') 5878 return rootObj 5879 5880 5881def main(): 5882 args = sys.argv[1:] 5883 if len(args) == 1: 5884 parse(args[0]) 5885 else: 5886 usage() 5887 5888 5889if __name__ == '__main__': 5890 main() 5891 #import pdb 5892 #pdb.run('main()') 5893