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('&', '&amp;')
67    s1 = s1.replace('<', '&lt;')
68    s1 = s1.replace('>', '&gt;')
69    return s1
70
71def quote_attrib(inStr):
72    s1 = (isinstance(inStr, basestring) and inStr or
73          '%s' % inStr)
74    s1 = s1.replace('&', '&amp;')
75    s1 = s1.replace('<', '&lt;')
76    s1 = s1.replace('>', '&gt;')
77    if '"' in s1:
78        if "'" in s1:
79            s1 = '"%s"' % s1.replace('"', "&quot;")
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