from .doxyindex import DoxyIndex, DoxyFunction, DoxyParam, DoxyClass, DoxyFile, DoxyNamespace, DoxyGroup, DoxyFriend, DoxyOther

def _test():

import os

this_dir = os.path.dirname(globals()['__file__'])

import doctest

return doctest.testmod()

if __name__ == "__main__":

_test()

for cls in self.mem_classes:

if cls.can_parse(mem):

return cls

def convert_mem(self, mem):

try:

from .base import Base

from .text import description

class DoxyIndex(Base):

"""

Parses a doxygen xml directory.

class DoxyCompMem(Base):

kind = None

def __init__(self, *args, **kwargs):

class DoxyCompound(DoxyCompMem):

pass

class DoxyMember(DoxyCompMem):

pass

class DoxyFunction(DoxyMember):

__module__ = "gnuradio.utils.doxyxml"

self._data['params'].append(DoxyParam(prm))

brief_description = property(lambda self: self.data()['brief_description'])

params = property(lambda self: self.data()['params'])

Base.mem_classes.append(DoxyFunction)

return '\n\n'.join(descriptions)

brief_description = property(lambda self: self.data()['brief_description'])

name = property(lambda self: self.data()['declname'])

class DoxyParameterItem(DoxyMember):

"""A different representation of a parameter in Doxygen."""

self.process_memberdefs()

brief_description = property(lambda self: self.data()['brief_description'])

params = property(lambda self: self.data()['params'])

Base.mem_classes.append(DoxyClass)

self.process_memberdefs()

brief_description = property(lambda self: self.data()['brief_description'])

Base.mem_classes.append(DoxyFile)

return

self.process_memberdefs()

Base.mem_classes.append(DoxyNamespace)

kind = 'friend'

Base.mem_classes.append(DoxyFriend)

def can_parse(cls, obj):

return obj.kind in cls.kinds

Base.mem_classes.append(DoxyOther)

return self.compounddef.find(details)

supermod.DoxygenType.subclass = DoxygenTypeSub

# end class DoxygenTypeSub

class compounddefTypeSub(supermod.compounddefType):

def __init__(self, kind=None, prot=None, id=None, compoundname='', title='', 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):

def find(self, details):

class listofallmembersTypeSub(supermod.listofallmembersType):

def __init__(self, member=None):

supermod.listofallmembersType.__init__(self, member)

supermod.listofallmembersType.subclass = listofallmembersTypeSub

# end class listofallmembersTypeSub

class memberRefTypeSub(supermod.memberRefType):

def __init__(self, virt=None, prot=None, refid=None, ambiguityscope=None, scope='', name=''):

supermod.memberRefType.subclass = memberRefTypeSub

# end class memberRefTypeSub

class compoundRefTypeSub(supermod.compoundRefType):

def __init__(self, virt=None, prot=None, refid=None, valueOf_='', mixedclass_=None, content_=None):

supermod.compoundRefType.__init__(self, mixedclass_, content_)

supermod.compoundRefType.subclass = compoundRefTypeSub

# end class compoundRefTypeSub

class reimplementTypeSub(supermod.reimplementType):

def __init__(self, refid=None, valueOf_='', mixedclass_=None, content_=None):

supermod.reimplementType.__init__(self, mixedclass_, content_)

supermod.reimplementType.subclass = reimplementTypeSub

# end class reimplementTypeSub

class incTypeSub(supermod.incType):

def __init__(self, local=None, refid=None, valueOf_='', mixedclass_=None, content_=None):

supermod.incType.__init__(self, mixedclass_, content_)

supermod.incType.subclass = incTypeSub

# end class incTypeSub

class refTypeSub(supermod.refType):

def __init__(self, prot=None, refid=None, valueOf_='', mixedclass_=None, content_=None):

supermod.refType.__init__(self, mixedclass_, content_)

supermod.refType.subclass = refTypeSub

# end class refTypeSub

class refTextTypeSub(supermod.refTextType):

def __init__(self, refid=None, kindref=None, external=None, valueOf_='', mixedclass_=None, content_=None):

supermod.refTextType.__init__(self, mixedclass_, content_)

supermod.refTextType.subclass = refTextTypeSub

# end class refTextTypeSub

def __init__(self, kind=None, header='', description=None, memberdef=None):

def find(self, details):

class memberdefTypeSub(supermod.memberdefType):

def __init__(self, initonly=None, kind=None, volatile=None, const=None, raise_=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='', argsstring='', name='', read='', write='', bitfield='', reimplements=None, reimplementedby=None, param=None, enumvalue=None, initializer=None, exceptions=None, briefdescription=None, detaileddescription=None, inbodydescription=None, location=None, references=None, referencedby=None):

supermod.memberdefType.subclass = memberdefTypeSub

# end class memberdefTypeSub

class descriptionTypeSub(supermod.descriptionType):

def __init__(self, title='', para=None, sect1=None, internal=None, mixedclass_=None, content_=None):

supermod.descriptionType.__init__(self, mixedclass_, content_)

supermod.descriptionType.subclass = descriptionTypeSub

# end class descriptionTypeSub

class enumvalueTypeSub(supermod.enumvalueType):

def __init__(self, prot=None, id=None, name='', initializer=None, briefdescription=None, detaileddescription=None, mixedclass_=None, content_=None):

supermod.enumvalueType.__init__(self, mixedclass_, content_)

supermod.enumvalueType.subclass = enumvalueTypeSub

# end class enumvalueTypeSub

class templateparamlistTypeSub(supermod.templateparamlistType):

def __init__(self, param=None):

supermod.templateparamlistType.__init__(self, param)

supermod.templateparamlistType.subclass = templateparamlistTypeSub

# end class templateparamlistTypeSub

class paramTypeSub(supermod.paramType):

def __init__(self, type_=None, declname='', defname='', array='', defval=None, briefdescription=None):

supermod.paramType.subclass = paramTypeSub

# end class paramTypeSub

class linkedTextTypeSub(supermod.linkedTextType):

def __init__(self, ref=None, mixedclass_=None, content_=None):

supermod.linkedTextType.__init__(self, mixedclass_, content_)

supermod.linkedTextType.subclass = linkedTextTypeSub

# end class linkedTextTypeSub

class graphTypeSub(supermod.graphType):

def __init__(self, node=None):

supermod.graphType.__init__(self, node)

supermod.graphType.subclass = graphTypeSub

# end class graphTypeSub

class nodeTypeSub(supermod.nodeType):

def __init__(self, id=None, label='', link=None, childnode=None):

supermod.nodeType.__init__(self, id, label, link, childnode)

supermod.nodeType.subclass = nodeTypeSub

# end class nodeTypeSub

class childnodeTypeSub(supermod.childnodeType):

def __init__(self, relation=None, refid=None, edgelabel=None):

supermod.childnodeType.__init__(self, relation, refid, edgelabel)

supermod.childnodeType.subclass = childnodeTypeSub

# end class childnodeTypeSub

class linkTypeSub(supermod.linkType):

def __init__(self, refid=None, external=None, valueOf_=''):

supermod.linkType.__init__(self, refid, external)

supermod.linkType.subclass = linkTypeSub

# end class linkTypeSub

class listingTypeSub(supermod.listingType):

def __init__(self, codeline=None):

supermod.listingType.__init__(self, codeline)

supermod.listingType.subclass = listingTypeSub

# end class listingTypeSub

class codelineTypeSub(supermod.codelineType):

def __init__(self, external=None, lineno=None, refkind=None, refid=None, highlight=None):

supermod.codelineType.subclass = codelineTypeSub

# end class codelineTypeSub

class highlightTypeSub(supermod.highlightType):

def __init__(self, class_=None, sp=None, ref=None, mixedclass_=None, content_=None):

supermod.highlightType.__init__(self, mixedclass_, content_)

supermod.highlightType.subclass = highlightTypeSub

# end class highlightTypeSub

class referenceTypeSub(supermod.referenceType):

def __init__(self, endline=None, startline=None, refid=None, compoundref=None, valueOf_='', mixedclass_=None, content_=None):

supermod.referenceType.__init__(self, mixedclass_, content_)

supermod.referenceType.subclass = referenceTypeSub

# end class referenceTypeSub

class locationTypeSub(supermod.locationType):

def __init__(self, bodystart=None, line=None, bodyend=None, bodyfile=None, file=None, valueOf_=''):

supermod.locationType.subclass = locationTypeSub

# end class locationTypeSub

class docSect1TypeSub(supermod.docSect1Type):

def __init__(self, id=None, title='', para=None, sect2=None, internal=None, mixedclass_=None, content_=None):

supermod.docSect1Type.__init__(self, mixedclass_, content_)

supermod.docSect1Type.subclass = docSect1TypeSub

# end class docSect1TypeSub

class docSect2TypeSub(supermod.docSect2Type):

def __init__(self, id=None, title='', para=None, sect3=None, internal=None, mixedclass_=None, content_=None):

supermod.docSect2Type.__init__(self, mixedclass_, content_)

supermod.docSect2Type.subclass = docSect2TypeSub

# end class docSect2TypeSub

class docSect3TypeSub(supermod.docSect3Type):

def __init__(self, id=None, title='', para=None, sect4=None, internal=None, mixedclass_=None, content_=None):

supermod.docSect3Type.__init__(self, mixedclass_, content_)

supermod.docSect3Type.subclass = docSect3TypeSub

# end class docSect3TypeSub

class docSect4TypeSub(supermod.docSect4Type):

def __init__(self, id=None, title='', para=None, internal=None, mixedclass_=None, content_=None):

supermod.docSect4Type.__init__(self, mixedclass_, content_)

supermod.docSect4Type.subclass = docSect4TypeSub

# end class docSect4TypeSub

class docInternalTypeSub(supermod.docInternalType):

def __init__(self, para=None, sect1=None, mixedclass_=None, content_=None):

supermod.docInternalType.__init__(self, mixedclass_, content_)

supermod.docInternalType.subclass = docInternalTypeSub

# end class docInternalTypeSub

class docInternalS1TypeSub(supermod.docInternalS1Type):

def __init__(self, para=None, sect2=None, mixedclass_=None, content_=None):

supermod.docInternalS1Type.__init__(self, mixedclass_, content_)

supermod.docInternalS1Type.subclass = docInternalS1TypeSub

# end class docInternalS1TypeSub

class docInternalS2TypeSub(supermod.docInternalS2Type):

def __init__(self, para=None, sect3=None, mixedclass_=None, content_=None):

supermod.docInternalS2Type.__init__(self, mixedclass_, content_)

supermod.docInternalS2Type.subclass = docInternalS2TypeSub

# end class docInternalS2TypeSub

class docInternalS3TypeSub(supermod.docInternalS3Type):

def __init__(self, para=None, sect3=None, mixedclass_=None, content_=None):

supermod.docInternalS3Type.__init__(self, mixedclass_, content_)

supermod.docInternalS3Type.subclass = docInternalS3TypeSub

# end class docInternalS3TypeSub

class docInternalS4TypeSub(supermod.docInternalS4Type):

def __init__(self, para=None, mixedclass_=None, content_=None):

supermod.docInternalS4Type.__init__(self, mixedclass_, content_)

supermod.docInternalS4Type.subclass = docInternalS4TypeSub

# end class docInternalS4TypeSub

class docURLLinkSub(supermod.docURLLink):

def __init__(self, url=None, valueOf_='', mixedclass_=None, content_=None):

supermod.docURLLink.__init__(self, mixedclass_, content_)

supermod.docURLLink.subclass = docURLLinkSub

# end class docURLLinkSub

class docAnchorTypeSub(supermod.docAnchorType):

def __init__(self, id=None, valueOf_='', mixedclass_=None, content_=None):

supermod.docAnchorType.__init__(self, mixedclass_, content_)

supermod.docAnchorType.subclass = docAnchorTypeSub

# end class docAnchorTypeSub

class docFormulaTypeSub(supermod.docFormulaType):

def __init__(self, id=None, valueOf_='', mixedclass_=None, content_=None):

supermod.docFormulaType.__init__(self, mixedclass_, content_)

supermod.docFormulaType.subclass = docFormulaTypeSub

# end class docFormulaTypeSub

class docIndexEntryTypeSub(supermod.docIndexEntryType):

def __init__(self, primaryie='', secondaryie=''):

supermod.docIndexEntryType.__init__(self, primaryie, secondaryie)

supermod.docIndexEntryType.subclass = docIndexEntryTypeSub

# end class docIndexEntryTypeSub

class docListTypeSub(supermod.docListType):

def __init__(self, listitem=None):

supermod.docListType.__init__(self, listitem)

supermod.docListType.subclass = docListTypeSub

# end class docListTypeSub

class docListItemTypeSub(supermod.docListItemType):

def __init__(self, para=None):

supermod.docListItemType.__init__(self, para)

supermod.docListItemType.subclass = docListItemTypeSub

# end class docListItemTypeSub

class docSimpleSectTypeSub(supermod.docSimpleSectType):

def __init__(self, kind=None, title=None, para=None):

supermod.docSimpleSectType.__init__(self, kind, title, para)

supermod.docSimpleSectType.subclass = docSimpleSectTypeSub

# end class docSimpleSectTypeSub

class docVarListEntryTypeSub(supermod.docVarListEntryType):

def __init__(self, term=None):

supermod.docVarListEntryType.__init__(self, term)

supermod.docVarListEntryType.subclass = docVarListEntryTypeSub

# end class docVarListEntryTypeSub

class docRefTextTypeSub(supermod.docRefTextType):

def __init__(self, refid=None, kindref=None, external=None, valueOf_='', mixedclass_=None, content_=None):

supermod.docRefTextType.__init__(self, mixedclass_, content_)

supermod.docRefTextType.subclass = docRefTextTypeSub

# end class docRefTextTypeSub

class docTableTypeSub(supermod.docTableType):

def __init__(self, rows=None, cols=None, row=None, caption=None):

supermod.docTableType.__init__(self, rows, cols, row, caption)

supermod.docTableType.subclass = docTableTypeSub

# end class docTableTypeSub

class docRowTypeSub(supermod.docRowType):

def __init__(self, entry=None):

supermod.docRowType.__init__(self, entry)

supermod.docRowType.subclass = docRowTypeSub

# end class docRowTypeSub

class docEntryTypeSub(supermod.docEntryType):

def __init__(self, thead=None, para=None):

supermod.docEntryType.__init__(self, thead, para)

supermod.docEntryType.subclass = docEntryTypeSub

# end class docEntryTypeSub

class docHeadingTypeSub(supermod.docHeadingType):

def __init__(self, level=None, valueOf_='', mixedclass_=None, content_=None):

supermod.docHeadingType.__init__(self, mixedclass_, content_)

supermod.docHeadingType.subclass = docHeadingTypeSub

# end class docHeadingTypeSub

class docImageTypeSub(supermod.docImageType):

def __init__(self, width=None, type_=None, name=None, height=None, valueOf_='', mixedclass_=None, content_=None):

supermod.docImageType.__init__(self, mixedclass_, content_)

supermod.docImageType.subclass = docImageTypeSub

# end class docImageTypeSub

class docDotFileTypeSub(supermod.docDotFileType):

def __init__(self, name=None, valueOf_='', mixedclass_=None, content_=None):

supermod.docDotFileType.__init__(self, mixedclass_, content_)

supermod.docDotFileType.subclass = docDotFileTypeSub

# end class docDotFileTypeSub

class docTocItemTypeSub(supermod.docTocItemType):

def __init__(self, id=None, valueOf_='', mixedclass_=None, content_=None):

supermod.docTocItemType.__init__(self, mixedclass_, content_)

supermod.docTocItemType.subclass = docTocItemTypeSub

# end class docTocItemTypeSub

class docTocListTypeSub(supermod.docTocListType):

def __init__(self, tocitem=None):

supermod.docTocListType.__init__(self, tocitem)

supermod.docTocListType.subclass = docTocListTypeSub

# end class docTocListTypeSub

class docLanguageTypeSub(supermod.docLanguageType):

def __init__(self, langid=None, para=None):

supermod.docLanguageType.__init__(self, langid, para)

supermod.docLanguageType.subclass = docLanguageTypeSub

# end class docLanguageTypeSub

class docParamListTypeSub(supermod.docParamListType):

def __init__(self, kind=None, parameteritem=None):

supermod.docParamListType.__init__(self, kind, parameteritem)

supermod.docParamListType.subclass = docParamListTypeSub

# end class docParamListTypeSub

class docParamListItemSub(supermod.docParamListItem):

def __init__(self, parameternamelist=None, parameterdescription=None):

supermod.docParamListItem.subclass = docParamListItemSub

# end class docParamListItemSub

class docParamNameListSub(supermod.docParamNameList):

def __init__(self, parametername=None):

supermod.docParamNameList.__init__(self, parametername)

supermod.docParamNameList.subclass = docParamNameListSub

# end class docParamNameListSub

class docParamNameSub(supermod.docParamName):

def __init__(self, direction=None, ref=None, mixedclass_=None, content_=None):

supermod.docParamName.__init__(self, mixedclass_, content_)

supermod.docParamName.subclass = docParamNameSub

# end class docParamNameSub

class docXRefSectTypeSub(supermod.docXRefSectType):

def __init__(self, id=None, xreftitle=None, xrefdescription=None):

supermod.docXRefSectType.__init__(self, id, xreftitle, xrefdescription)

supermod.docXRefSectType.subclass = docXRefSectTypeSub

# end class docXRefSectTypeSub

class docCopyTypeSub(supermod.docCopyType):

def __init__(self, link=None, para=None, sect1=None, internal=None):

supermod.docCopyType.__init__(self, link, para, sect1, internal)

supermod.docCopyType.subclass = docCopyTypeSub

# end class docCopyTypeSub

class docCharTypeSub(supermod.docCharType):

def __init__(self, char=None, valueOf_=''):

supermod.docCharType.__init__(self, char)

supermod.docCharType.subclass = docCharTypeSub

# end class docCharTypeSub

class docParaTypeSub(supermod.docParaType):

def __init__(self, char=None, valueOf_=''):

supermod.docParaType.__init__(self, char)

if child_.nodeType == Node.TEXT_NODE:

obj_ = self.mixedclass_(MixedContainer.CategoryText,

self.content.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

nodeName_ == "ref":

# end class docParaTypeSub

def parse(inFilename):

doc = minidom.parse(inFilename)

rootNode = doc.documentElement

class GeneratedsSuper(object):

def format_string(self, input_data, input_name=''):

return input_data

def format_integer(self, input_data, input_name=''):

return '%d' % input_data

def format_float(self, input_data, input_name=''):

return '%f' % input_data

def format_double(self, input_data, input_name=''):

return '%e' % input_data

def format_boolean(self, input_data, input_name=''):

return '%s' % input_data

## from IPython.Shell import IPShellEmbed

## args = ''

## banner = 'Dropping into IPython',

# Then use the following line where and when you want to drop into the

# IPython shell:

# Support/utility functions.

#

def showIndent(outfile, level):

for idx in range(level):

outfile.write(' ')

def quote_xml(inStr):

s1 = (isinstance(inStr, str) and inStr or

'%s' % inStr)

s1 = s1.replace('>', '>')

return s1

def quote_attrib(inStr):

s1 = (isinstance(inStr, str) and inStr or

'%s' % inStr)

s1 = '"%s"' % s1

return s1

def quote_python(inStr):

s1 = inStr

if s1.find("'") == -1:

TypeDecimal = 5

TypeDouble = 6

TypeBoolean = 7

def __init__(self, category, content_type, name, value):

self.category = category

self.content_type = content_type

self.name = name

self.value = value

def getCategory(self):

return self.category

def getContenttype(self, content_type):

return self.content_type

def getValue(self):

return self.value

def getName(self):

return self.name

def export(self, outfile, level, name, namespace):

if self.category == MixedContainer.CategoryText:

outfile.write(self.value)

elif self.category == MixedContainer.CategorySimple:

self.exportSimple(outfile, level, name)

else: # category == MixedContainer.CategoryComplex

def exportSimple(self, outfile, level, name):

if self.content_type == MixedContainer.TypeString:

outfile.write('<%s>%s</%s>' % (self.name, self.value, self.name))

outfile.write('<%s>%f</%s>' % (self.name, self.value, self.name))

elif self.content_type == MixedContainer.TypeDouble:

outfile.write('<%s>%g</%s>' % (self.name, self.value, self.name))

def exportLiteral(self, outfile, level, name):

if self.category == MixedContainer.CategoryText:

showIndent(outfile, level)

elif self.category == MixedContainer.CategorySimple:

showIndent(outfile, level)

else: # category == MixedContainer.CategoryComplex

showIndent(outfile, level)

self.value.exportLiteral(outfile, level + 1)

showIndent(outfile, level)

outfile.write(')\n')

self.name = name

self.data_type = data_type

self.container = container

def set_name(self, name): self.name = name

def get_name(self): return self.name

def set_data_type(self, data_type): self.data_type = data_type

class DoxygenType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, version=None, compounddef=None):

self.version = version

self.compounddef = compounddef

def factory(*args_, **kwargs_):

if DoxygenType.subclass:

return DoxygenType.subclass(*args_, **kwargs_)

def set_compounddef(self, compounddef): self.compounddef = compounddef

def get_version(self): return self.version

def set_version(self, version): self.version = version

def export(self, outfile, level, namespace_='', name_='DoxygenType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='DoxygenType'):

outfile.write(' version=%s' % (quote_attrib(self.version), ))

def exportChildren(self, outfile, level, namespace_='', name_='DoxygenType'):

if self.compounddef:

def hasContent_(self):

if (

self.compounddef is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='DoxygenType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.version is not None:

showIndent(outfile, level)

outfile.write('version = "%s",\n' % (self.version,))

def exportLiteralChildren(self, outfile, level, name_):

if self.compounddef:

showIndent(outfile, level)

self.compounddef.exportLiteral(outfile, level, name_='compounddef')

showIndent(outfile, level)

outfile.write('),\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('version'):

self.version = attrs.get('version').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

obj_ = compounddefType.factory()

obj_.build(child_)

self.set_compounddef(obj_)

class compounddefType(GeneratedsSuper):

subclass = None

superclass = None

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):

self.kind = kind

self.prot = prot

self.programlisting = programlisting

self.location = location

self.listofallmembers = listofallmembers

def factory(*args_, **kwargs_):

if compounddefType.subclass:

return compounddefType.subclass(*args_, **kwargs_)

def get_title(self): return self.title

def set_title(self, title): self.title = title

def get_basecompoundref(self): return self.basecompoundref

def add_basecompoundref(self, value): self.basecompoundref.append(value)

def get_derivedcompoundref(self): return self.derivedcompoundref

def get_includes(self): return self.includes

def set_includes(self, includes): self.includes = includes

def add_includes(self, value): self.includes.append(value)

def get_incdepgraph(self): return self.incdepgraph

def set_incdepgraph(self, incdepgraph): self.incdepgraph = incdepgraph

def get_invincdepgraph(self): return self.invincdepgraph

def get_innerdir(self): return self.innerdir

def set_innerdir(self, innerdir): self.innerdir = innerdir

def add_innerdir(self, value): self.innerdir.append(value)

def add_innerclass(self, value): self.innerclass.append(value)

def insert_innerclass(self, index, value): self.innerclass[index] = value

def get_innernamespace(self): return self.innernamespace

def add_innernamespace(self, value): self.innernamespace.append(value)

def get_innerpage(self): return self.innerpage

def set_innerpage(self, innerpage): self.innerpage = innerpage

def add_innerpage(self, value): self.innerpage.append(value)

def add_innergroup(self, value): self.innergroup.append(value)

def insert_innergroup(self, index, value): self.innergroup[index] = value

def get_templateparamlist(self): return self.templateparamlist

def get_sectiondef(self): return self.sectiondef

def set_sectiondef(self, sectiondef): self.sectiondef = sectiondef

def add_sectiondef(self, value): self.sectiondef.append(value)

def insert_sectiondef(self, index, value): self.sectiondef[index] = value

def get_briefdescription(self): return self.briefdescription

def get_detaileddescription(self): return self.detaileddescription

def get_inheritancegraph(self): return self.inheritancegraph

def get_collaborationgraph(self): return self.collaborationgraph

def get_programlisting(self): return self.programlisting

def get_location(self): return self.location

def set_location(self, location): self.location = location

def get_listofallmembers(self): return self.listofallmembers

def get_kind(self): return self.kind

def set_kind(self, kind): self.kind = kind

def get_prot(self): return self.prot

def set_prot(self, prot): self.prot = prot

def get_id(self): return self.id

def set_id(self, id): self.id = id

def export(self, outfile, level, namespace_='', name_='compounddefType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

if self.hasContent_():

outfile.write('>\n')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='compounddefType'):

if self.kind is not None:

outfile.write(' kind=%s' % (quote_attrib(self.kind), ))

if self.prot is not None:

outfile.write(' prot=%s' % (quote_attrib(self.prot), ))

if self.id is not None:

def exportChildren(self, outfile, level, namespace_='', name_='compounddefType'):

if self.compoundname is not None:

showIndent(outfile, level)

if self.title is not None:

showIndent(outfile, level)

for basecompoundref_ in self.basecompoundref:

for derivedcompoundref_ in self.derivedcompoundref:

for includes_ in self.includes:

includes_.export(outfile, level, namespace_, name_='includes')

for includedby_ in self.includedby:

includedby_.export(outfile, level, namespace_, name_='includedby')

if self.incdepgraph:

if self.invincdepgraph:

for innerdir_ in self.innerdir:

innerdir_.export(outfile, level, namespace_, name_='innerdir')

for innerfile_ in self.innerfile:

for innerclass_ in self.innerclass:

innerclass_.export(outfile, level, namespace_, name_='innerclass')

for innernamespace_ in self.innernamespace:

for innerpage_ in self.innerpage:

innerpage_.export(outfile, level, namespace_, name_='innerpage')

for innergroup_ in self.innergroup:

innergroup_.export(outfile, level, namespace_, name_='innergroup')

if self.templateparamlist:

for sectiondef_ in self.sectiondef:

sectiondef_.export(outfile, level, namespace_, name_='sectiondef')

if self.briefdescription:

if self.detaileddescription:

if self.inheritancegraph:

if self.collaborationgraph:

if self.programlisting:

if self.location:

self.location.export(outfile, level, namespace_, name_='location')

if self.listofallmembers:

def hasContent_(self):

if (

self.compoundname is not None or

self.programlisting is not None or

self.location is not None or

self.listofallmembers is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='compounddefType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.kind is not None:

showIndent(outfile, level)

if self.id is not None:

showIndent(outfile, level)

outfile.write('id = %s,\n' % (self.id,))

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

if self.title:

showIndent(outfile, level)

outfile.write('title=model_.xsd_string(\n')

for basecompoundref in self.basecompoundref:

showIndent(outfile, level)

outfile.write('model_.basecompoundref(\n')

showIndent(outfile, level)

outfile.write('),\n')

level -= 1

for derivedcompoundref in self.derivedcompoundref:

showIndent(outfile, level)

outfile.write('model_.derivedcompoundref(\n')

showIndent(outfile, level)

outfile.write('),\n')

level -= 1

if self.invincdepgraph:

showIndent(outfile, level)

outfile.write('invincdepgraph=model_.graphType(\n')

showIndent(outfile, level)

outfile.write('),\n')

showIndent(outfile, level)

for innernamespace in self.innernamespace:

showIndent(outfile, level)

outfile.write('model_.innernamespace(\n')

showIndent(outfile, level)

outfile.write('),\n')

level -= 1

if self.templateparamlist:

showIndent(outfile, level)

outfile.write('templateparamlist=model_.templateparamlistType(\n')

showIndent(outfile, level)

outfile.write('),\n')

showIndent(outfile, level)

if self.briefdescription:

showIndent(outfile, level)

outfile.write('briefdescription=model_.descriptionType(\n')

showIndent(outfile, level)

outfile.write('),\n')

if self.detaileddescription:

showIndent(outfile, level)

outfile.write('detaileddescription=model_.descriptionType(\n')

showIndent(outfile, level)

outfile.write('),\n')

if self.inheritancegraph:

showIndent(outfile, level)

outfile.write('inheritancegraph=model_.graphType(\n')

showIndent(outfile, level)

outfile.write('),\n')

if self.collaborationgraph:

showIndent(outfile, level)

outfile.write('collaborationgraph=model_.graphType(\n')

showIndent(outfile, level)

outfile.write('),\n')

if self.programlisting:

showIndent(outfile, level)

outfile.write('programlisting=model_.listingType(\n')

showIndent(outfile, level)

outfile.write('),\n')

if self.location:

if self.listofallmembers:

showIndent(outfile, level)

outfile.write('listofallmembers=model_.listofallmembersType(\n')

showIndent(outfile, level)

outfile.write('),\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('kind'):

self.kind = attrs.get('kind').value

self.prot = attrs.get('prot').value

if attrs.get('id'):

self.id = attrs.get('id').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

compoundname_ = ''

for text__content_ in child_.childNodes:

compoundname_ += text__content_.nodeValue

self.compoundname = compoundname_

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = docTitleType.factory()

obj_.build(child_)

self.set_title(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = compoundRefType.factory()

obj_.build(child_)

self.basecompoundref.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = compoundRefType.factory()

obj_.build(child_)

self.derivedcompoundref.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = incType.factory()

obj_.build(child_)

self.includes.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = incType.factory()

obj_.build(child_)

self.includedby.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = graphType.factory()

obj_.build(child_)

self.set_incdepgraph(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = graphType.factory()

obj_.build(child_)

self.set_invincdepgraph(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = refType.factory()

obj_.build(child_)

self.innerdir.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = refType.factory()

obj_.build(child_)

self.innerfile.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = refType.factory()

obj_.build(child_)

self.innerclass.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = refType.factory()

obj_.build(child_)

self.innernamespace.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = refType.factory()

obj_.build(child_)

self.innerpage.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = refType.factory()

obj_.build(child_)

self.innergroup.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = templateparamlistType.factory()

obj_.build(child_)

self.set_templateparamlist(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = sectiondefType.factory()

obj_.build(child_)

self.sectiondef.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = descriptionType.factory()

obj_.build(child_)

self.set_briefdescription(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = descriptionType.factory()

obj_.build(child_)

self.set_detaileddescription(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = graphType.factory()

obj_.build(child_)

self.set_inheritancegraph(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = graphType.factory()

obj_.build(child_)

self.set_collaborationgraph(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = listingType.factory()

obj_.build(child_)

self.set_programlisting(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = locationType.factory()

obj_.build(child_)

self.set_location(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = listofallmembersType.factory()

obj_.build(child_)

self.set_listofallmembers(obj_)

class listofallmembersType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, member=None):

if member is None:

self.member = []

else:

self.member = member

def factory(*args_, **kwargs_):

if listofallmembersType.subclass:

return listofallmembersType.subclass(*args_, **kwargs_)

def set_member(self, member): self.member = member

def add_member(self, value): self.member.append(value)

def insert_member(self, index, value): self.member[index] = value

def export(self, outfile, level, namespace_='', name_='listofallmembersType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

if self.hasContent_():

outfile.write('>\n')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='listofallmembersType'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='listofallmembersType'):

for member_ in self.member:

member_.export(outfile, level, namespace_, name_='member')

def hasContent_(self):

if (

self.member is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='listofallmembersType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('member=[\n')

level -= 1

showIndent(outfile, level)

outfile.write('],\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

obj_ = memberRefType.factory()

obj_.build(child_)

self.member.append(obj_)

class memberRefType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, virt=None, prot=None, refid=None, ambiguityscope=None, scope=None, name=None):

self.virt = virt

self.prot = prot

self.ambiguityscope = ambiguityscope

self.scope = scope

self.name = name

def factory(*args_, **kwargs_):

if memberRefType.subclass:

return memberRefType.subclass(*args_, **kwargs_)

def get_refid(self): return self.refid

def set_refid(self, refid): self.refid = refid

def get_ambiguityscope(self): return self.ambiguityscope

def export(self, outfile, level, namespace_='', name_='memberRefType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

if self.hasContent_():

outfile.write('>\n')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='memberRefType'):

if self.virt is not None:

outfile.write(' virt=%s' % (quote_attrib(self.virt), ))

if self.prot is not None:

outfile.write(' prot=%s' % (quote_attrib(self.prot), ))

if self.refid is not None:

if self.ambiguityscope is not None:

def exportChildren(self, outfile, level, namespace_='', name_='memberRefType'):

if self.scope is not None:

showIndent(outfile, level)

if self.name is not None:

showIndent(outfile, level)

def hasContent_(self):

if (

self.scope is not None or

self.name is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='memberRefType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.virt is not None:

showIndent(outfile, level)

if self.ambiguityscope is not None:

showIndent(outfile, level)

outfile.write('ambiguityscope = %s,\n' % (self.ambiguityscope,))

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

showIndent(outfile, level)

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('virt'):

self.virt = attrs.get('virt').value

self.refid = attrs.get('refid').value

if attrs.get('ambiguityscope'):

self.ambiguityscope = attrs.get('ambiguityscope').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

scope_ = ''

for text__content_ in child_.childNodes:

scope_ += text__content_.nodeValue

self.scope = scope_

elif child_.nodeType == Node.ELEMENT_NODE and \

name_ = ''

for text__content_ in child_.childNodes:

name_ += text__content_.nodeValue

class scope(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, valueOf_=''):

self.valueOf_ = valueOf_

def factory(*args_, **kwargs_):

if scope.subclass:

return scope.subclass(*args_, **kwargs_)

factory = staticmethod(factory)

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='scope', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='scope'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='scope'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='scope'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class scope

class name(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, valueOf_=''):

self.valueOf_ = valueOf_

def factory(*args_, **kwargs_):

if name.subclass:

return name.subclass(*args_, **kwargs_)

factory = staticmethod(factory)

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='name', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='name'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='name'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='name'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class name

class compoundRefType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, virt=None, prot=None, refid=None, valueOf_='', mixedclass_=None, content_=None):

self.virt = virt

self.prot = prot

self.content_ = []

else:

self.content_ = content_

def factory(*args_, **kwargs_):

if compoundRefType.subclass:

return compoundRefType.subclass(*args_, **kwargs_)

def set_refid(self, refid): self.refid = refid

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='compoundRefType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('>')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

def exportAttributes(self, outfile, level, namespace_='', name_='compoundRefType'):

if self.virt is not None:

outfile.write(' virt=%s' % (quote_attrib(self.virt), ))

if self.prot is not None:

outfile.write(' prot=%s' % (quote_attrib(self.prot), ))

if self.refid is not None:

def exportChildren(self, outfile, level, namespace_='', name_='compoundRefType'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='compoundRefType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.virt is not None:

showIndent(outfile, level)

if self.refid is not None:

showIndent(outfile, level)

outfile.write('refid = %s,\n' % (self.refid,))

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('virt'):

self.virt = attrs.get('virt').value

self.prot = attrs.get('prot').value

if attrs.get('refid'):

self.refid = attrs.get('refid').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

obj_ = self.mixedclass_(MixedContainer.CategoryText,

self.content_.append(obj_)

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class compoundRefType

class reimplementType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, refid=None, valueOf_='', mixedclass_=None, content_=None):

self.refid = refid

if mixedclass_ is None:

self.content_ = []

else:

self.content_ = content_

def factory(*args_, **kwargs_):

if reimplementType.subclass:

return reimplementType.subclass(*args_, **kwargs_)

def set_refid(self, refid): self.refid = refid

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='reimplementType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('>')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

def exportAttributes(self, outfile, level, namespace_='', name_='reimplementType'):

if self.refid is not None:

def exportChildren(self, outfile, level, namespace_='', name_='reimplementType'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='reimplementType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.refid is not None:

showIndent(outfile, level)

outfile.write('refid = %s,\n' % (self.refid,))

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('refid'):

self.refid = attrs.get('refid').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

obj_ = self.mixedclass_(MixedContainer.CategoryText,

self.content_.append(obj_)

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class reimplementType

class incType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, local=None, refid=None, valueOf_='', mixedclass_=None, content_=None):

self.local = local

self.refid = refid

self.content_ = []

else:

self.content_ = content_

def factory(*args_, **kwargs_):

if incType.subclass:

return incType.subclass(*args_, **kwargs_)

def set_refid(self, refid): self.refid = refid

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='incType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('>')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

def exportAttributes(self, outfile, level, namespace_='', name_='incType'):

if self.local is not None:

outfile.write(' local=%s' % (quote_attrib(self.local), ))

if self.refid is not None:

def exportChildren(self, outfile, level, namespace_='', name_='incType'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='incType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.local is not None:

showIndent(outfile, level)

if self.refid is not None:

showIndent(outfile, level)

outfile.write('refid = %s,\n' % (self.refid,))

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('local'):

self.local = attrs.get('local').value

if attrs.get('refid'):

self.refid = attrs.get('refid').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

obj_ = self.mixedclass_(MixedContainer.CategoryText,

self.content_.append(obj_)

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class incType

class refType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, prot=None, refid=None, valueOf_='', mixedclass_=None, content_=None):

self.prot = prot

self.refid = refid

self.content_ = []

else:

self.content_ = content_

def factory(*args_, **kwargs_):

if refType.subclass:

return refType.subclass(*args_, **kwargs_)

def set_refid(self, refid): self.refid = refid

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='refType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('>')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

def exportAttributes(self, outfile, level, namespace_='', name_='refType'):

if self.prot is not None:

outfile.write(' prot=%s' % (quote_attrib(self.prot), ))

if self.refid is not None:

def exportChildren(self, outfile, level, namespace_='', name_='refType'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='refType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.prot is not None:

showIndent(outfile, level)

if self.refid is not None:

showIndent(outfile, level)

outfile.write('refid = %s,\n' % (self.refid,))

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('prot'):

self.prot = attrs.get('prot').value

if attrs.get('refid'):

self.refid = attrs.get('refid').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

obj_ = self.mixedclass_(MixedContainer.CategoryText,

self.content_.append(obj_)

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class refType

class refTextType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, refid=None, kindref=None, external=None, valueOf_='', mixedclass_=None, content_=None):

self.refid = refid

self.kindref = kindref

self.content_ = []

else:

self.content_ = content_

def factory(*args_, **kwargs_):

if refTextType.subclass:

return refTextType.subclass(*args_, **kwargs_)

def set_external(self, external): self.external = external

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='refTextType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('>')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

def exportAttributes(self, outfile, level, namespace_='', name_='refTextType'):

if self.refid is not None:

if self.kindref is not None:

outfile.write(' kindref=%s' % (quote_attrib(self.kindref), ))

if self.external is not None:

def exportChildren(self, outfile, level, namespace_='', name_='refTextType'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='refTextType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.refid is not None:

showIndent(outfile, level)

if self.external is not None:

showIndent(outfile, level)

outfile.write('external = %s,\n' % (self.external,))

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('refid'):

self.refid = attrs.get('refid').value

self.kindref = attrs.get('kindref').value

if attrs.get('external'):

self.external = attrs.get('external').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

obj_ = self.mixedclass_(MixedContainer.CategoryText,

self.content_.append(obj_)

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class refTextType

class sectiondefType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, kind=None, header=None, description=None, memberdef=None):

self.kind = kind

self.header = header

self.memberdef = []

else:

self.memberdef = memberdef

def factory(*args_, **kwargs_):

if sectiondefType.subclass:

return sectiondefType.subclass(*args_, **kwargs_)

def insert_memberdef(self, index, value): self.memberdef[index] = value

def get_kind(self): return self.kind

def set_kind(self, kind): self.kind = kind

def export(self, outfile, level, namespace_='', name_='sectiondefType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

if self.hasContent_():

outfile.write('>\n')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='sectiondefType'):

if self.kind is not None:

outfile.write(' kind=%s' % (quote_attrib(self.kind), ))

def exportChildren(self, outfile, level, namespace_='', name_='sectiondefType'):

if self.header is not None:

showIndent(outfile, level)

if self.description:

for memberdef_ in self.memberdef:

memberdef_.export(outfile, level, namespace_, name_='memberdef')

def hasContent_(self):

if (

self.header is not None or

self.description is not None or

self.memberdef is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='sectiondefType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.kind is not None:

showIndent(outfile, level)

outfile.write('kind = "%s",\n' % (self.kind,))

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

if self.description:

showIndent(outfile, level)

outfile.write('description=model_.descriptionType(\n')

level -= 1

showIndent(outfile, level)

outfile.write('],\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('kind'):

self.kind = attrs.get('kind').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

header_ = ''

for text__content_ in child_.childNodes:

header_ += text__content_.nodeValue

self.header = header_

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = descriptionType.factory()

obj_.build(child_)

self.set_description(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = memberdefType.factory()

obj_.build(child_)

self.memberdef.append(obj_)

class memberdefType(GeneratedsSuper):

subclass = None

superclass = None

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):

self.initonly = initonly

self.kind = kind

self.referencedby = []

else:

self.referencedby = referencedby

def factory(*args_, **kwargs_):

if memberdefType.subclass:

return memberdefType.subclass(*args_, **kwargs_)

return memberdefType(*args_, **kwargs_)

factory = staticmethod(factory)

def get_templateparamlist(self): return self.templateparamlist

def get_type(self): return self.type_

def set_type(self, type_): self.type_ = type_

def get_definition(self): return self.definition

def get_reimplements(self): return self.reimplements

def set_reimplements(self, reimplements): self.reimplements = reimplements

def add_reimplements(self, value): self.reimplements.append(value)

def get_reimplementedby(self): return self.reimplementedby

def add_reimplementedby(self, value): self.reimplementedby.append(value)

def get_param(self): return self.param

def set_param(self, param): self.param = param

def add_param(self, value): self.param.append(value)

def get_exceptions(self): return self.exceptions

def set_exceptions(self, exceptions): self.exceptions = exceptions

def get_briefdescription(self): return self.briefdescription

def get_detaileddescription(self): return self.detaileddescription

def get_inbodydescription(self): return self.inbodydescription

def get_location(self): return self.location

def set_location(self, location): self.location = location

def get_references(self): return self.references

def get_referencedby(self): return self.referencedby

def set_referencedby(self, referencedby): self.referencedby = referencedby

def add_referencedby(self, value): self.referencedby.append(value)

def get_initonly(self): return self.initonly

def set_initonly(self, initonly): self.initonly = initonly

def get_kind(self): return self.kind

def set_settable(self, settable): self.settable = settable

def get_id(self): return self.id

def set_id(self, id): self.id = id

def export(self, outfile, level, namespace_='', name_='memberdefType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

if self.hasContent_():

outfile.write('>\n')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='memberdefType'):

if self.initonly is not None:

outfile.write(' initonly=%s' % (quote_attrib(self.initonly), ))

if self.settable is not None:

outfile.write(' settable=%s' % (quote_attrib(self.settable), ))

if self.id is not None:

def exportChildren(self, outfile, level, namespace_='', name_='memberdefType'):

if self.templateparamlist:

if self.type_:

self.type_.export(outfile, level, namespace_, name_='type')

if self.definition is not None:

showIndent(outfile, level)

if self.argsstring is not None:

showIndent(outfile, level)

if self.name is not None:

showIndent(outfile, level)

if self.read is not None:

showIndent(outfile, level)

if self.write is not None:

showIndent(outfile, level)

if self.bitfield is not None:

showIndent(outfile, level)

for reimplements_ in self.reimplements:

for reimplementedby_ in self.reimplementedby:

for param_ in self.param:

param_.export(outfile, level, namespace_, name_='param')

for enumvalue_ in self.enumvalue:

enumvalue_.export(outfile, level, namespace_, name_='enumvalue')

if self.initializer:

if self.exceptions:

if self.briefdescription:

if self.detaileddescription:

if self.inbodydescription:

if self.location:

for references_ in self.references:

references_.export(outfile, level, namespace_, name_='references')

for referencedby_ in self.referencedby:

def hasContent_(self):

if (

self.templateparamlist is not None or

self.location is not None or

self.references is not None or

self.referencedby is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='memberdefType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.initonly is not None:

showIndent(outfile, level)

if self.id is not None:

showIndent(outfile, level)

outfile.write('id = %s,\n' % (self.id,))

def exportLiteralChildren(self, outfile, level, name_):

if self.templateparamlist:

showIndent(outfile, level)

outfile.write('templateparamlist=model_.templateparamlistType(\n')

showIndent(outfile, level)

outfile.write('),\n')

if self.type_:

showIndent(outfile, level)

outfile.write('),\n')

showIndent(outfile, level)

showIndent(outfile, level)

showIndent(outfile, level)

showIndent(outfile, level)

showIndent(outfile, level)

showIndent(outfile, level)

showIndent(outfile, level)

outfile.write('reimplements=[\n')

level += 1

for reimplementedby in self.reimplementedby:

showIndent(outfile, level)

outfile.write('model_.reimplementedby(\n')

showIndent(outfile, level)

outfile.write('),\n')

level -= 1

if self.briefdescription:

showIndent(outfile, level)

outfile.write('briefdescription=model_.descriptionType(\n')

showIndent(outfile, level)

outfile.write('),\n')

if self.detaileddescription:

showIndent(outfile, level)

outfile.write('detaileddescription=model_.descriptionType(\n')

showIndent(outfile, level)

outfile.write('),\n')

if self.inbodydescription:

showIndent(outfile, level)

outfile.write('inbodydescription=model_.descriptionType(\n')

showIndent(outfile, level)

outfile.write('),\n')

if self.location:

level -= 1

showIndent(outfile, level)

outfile.write('],\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('initonly'):

self.initonly = attrs.get('initonly').value

self.settable = attrs.get('settable').value

if attrs.get('id'):

self.id = attrs.get('id').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

obj_ = templateparamlistType.factory()

obj_.build(child_)

self.set_templateparamlist(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = linkedTextType.factory()

obj_.build(child_)

self.set_type(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

definition_ = ''

for text__content_ in child_.childNodes:

definition_ += text__content_.nodeValue

self.definition = definition_

elif child_.nodeType == Node.ELEMENT_NODE and \

argsstring_ = ''

for text__content_ in child_.childNodes:

argsstring_ += text__content_.nodeValue

self.argsstring = argsstring_

elif child_.nodeType == Node.ELEMENT_NODE and \

name_ = ''

for text__content_ in child_.childNodes:

name_ += text__content_.nodeValue

self.name = name_

elif child_.nodeType == Node.ELEMENT_NODE and \

read_ = ''

for text__content_ in child_.childNodes:

read_ += text__content_.nodeValue

self.read = read_

elif child_.nodeType == Node.ELEMENT_NODE and \

write_ = ''

for text__content_ in child_.childNodes:

write_ += text__content_.nodeValue

self.write = write_

elif child_.nodeType == Node.ELEMENT_NODE and \

bitfield_ = ''

for text__content_ in child_.childNodes:

bitfield_ += text__content_.nodeValue

self.bitfield = bitfield_

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = reimplementType.factory()

obj_.build(child_)

self.reimplements.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = reimplementType.factory()

obj_.build(child_)

self.reimplementedby.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = paramType.factory()

obj_.build(child_)

self.param.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = enumvalueType.factory()

obj_.build(child_)

self.enumvalue.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = linkedTextType.factory()

obj_.build(child_)

self.set_initializer(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = linkedTextType.factory()

obj_.build(child_)

self.set_exceptions(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = descriptionType.factory()

obj_.build(child_)

self.set_briefdescription(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = descriptionType.factory()

obj_.build(child_)

self.set_detaileddescription(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = descriptionType.factory()

obj_.build(child_)

self.set_inbodydescription(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = locationType.factory()

obj_.build(child_)

self.set_location(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = referenceType.factory()

obj_.build(child_)

self.references.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = referenceType.factory()

obj_.build(child_)

self.referencedby.append(obj_)

class definition(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, valueOf_=''):

self.valueOf_ = valueOf_

def factory(*args_, **kwargs_):

if definition.subclass:

return definition.subclass(*args_, **kwargs_)

factory = staticmethod(factory)

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='definition', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='definition'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='definition'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='definition'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class definition

class argsstring(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, valueOf_=''):

self.valueOf_ = valueOf_

def factory(*args_, **kwargs_):

if argsstring.subclass:

return argsstring.subclass(*args_, **kwargs_)

factory = staticmethod(factory)

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='argsstring', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='argsstring'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='argsstring'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='argsstring'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class argsstring

class read(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, valueOf_=''):

self.valueOf_ = valueOf_

def factory(*args_, **kwargs_):

if read.subclass:

return read.subclass(*args_, **kwargs_)

factory = staticmethod(factory)

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='read', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='read'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='read'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='read'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class read

class write(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, valueOf_=''):

self.valueOf_ = valueOf_

def factory(*args_, **kwargs_):

if write.subclass:

return write.subclass(*args_, **kwargs_)

factory = staticmethod(factory)

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='write', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='write'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='write'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='write'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class write

class bitfield(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, valueOf_=''):

self.valueOf_ = valueOf_

def factory(*args_, **kwargs_):

if bitfield.subclass:

return bitfield.subclass(*args_, **kwargs_)

factory = staticmethod(factory)

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='bitfield', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='bitfield'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='bitfield'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='bitfield'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class bitfield

class descriptionType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, title=None, para=None, sect1=None, internal=None, mixedclass_=None, content_=None):

if mixedclass_ is None:

self.mixedclass_ = MixedContainer

self.content_ = []

else:

self.content_ = content_

def factory(*args_, **kwargs_):

if descriptionType.subclass:

return descriptionType.subclass(*args_, **kwargs_)

def insert_sect1(self, index, value): self.sect1[index] = value

def get_internal(self): return self.internal

def set_internal(self, internal): self.internal = internal

def export(self, outfile, level, namespace_='', name_='descriptionType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('>')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

def exportAttributes(self, outfile, level, namespace_='', name_='descriptionType'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='descriptionType'):

for item_ in self.content_:

item_.export(outfile, level, item_.name, namespace_)

def hasContent_(self):

if (

self.title is not None or

self.para is not None or

self.sect1 is not None or

self.internal is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='descriptionType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('content_ = [\n')

item_.exportLiteral(outfile, level, name_)

showIndent(outfile, level)

outfile.write('],\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = docTitleType.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = docParaType.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = docSect1Type.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = docInternalType.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.TEXT_NODE:

obj_ = self.mixedclass_(MixedContainer.CategoryText,

self.content_.append(obj_)

# end class descriptionType

class enumvalueType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, prot=None, id=None, name=None, initializer=None, briefdescription=None, detaileddescription=None, mixedclass_=None, content_=None):

self.prot = prot

self.id = id

self.content_ = []

else:

self.content_ = content_

def factory(*args_, **kwargs_):

if enumvalueType.subclass:

return enumvalueType.subclass(*args_, **kwargs_)

def get_initializer(self): return self.initializer

def set_initializer(self, initializer): self.initializer = initializer

def get_briefdescription(self): return self.briefdescription

def get_detaileddescription(self): return self.detaileddescription

def get_prot(self): return self.prot

def set_prot(self, prot): self.prot = prot

def get_id(self): return self.id

def set_id(self, id): self.id = id

def export(self, outfile, level, namespace_='', name_='enumvalueType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('>')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

def exportAttributes(self, outfile, level, namespace_='', name_='enumvalueType'):

if self.prot is not None:

outfile.write(' prot=%s' % (quote_attrib(self.prot), ))

if self.id is not None:

def exportChildren(self, outfile, level, namespace_='', name_='enumvalueType'):

for item_ in self.content_:

item_.export(outfile, level, item_.name, namespace_)

def hasContent_(self):

if (

self.name is not None or

self.initializer is not None or

self.briefdescription is not None or

self.detaileddescription is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='enumvalueType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.prot is not None:

showIndent(outfile, level)

if self.id is not None:

showIndent(outfile, level)

outfile.write('id = %s,\n' % (self.id,))

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('content_ = [\n')

item_.exportLiteral(outfile, level, name_)

showIndent(outfile, level)

outfile.write('],\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('prot'):

self.prot = attrs.get('prot').value

if attrs.get('id'):

self.id = attrs.get('id').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

value_ = []

for text_ in child_.childNodes:

value_.append(text_.nodeValue)

valuestr_ = ''.join(value_)

obj_ = self.mixedclass_(MixedContainer.CategorySimple,

self.content_.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = linkedTextType.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = descriptionType.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = descriptionType.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.TEXT_NODE:

obj_ = self.mixedclass_(MixedContainer.CategoryText,

self.content_.append(obj_)

# end class enumvalueType

class templateparamlistType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, param=None):

if param is None:

self.param = []

else:

self.param = param

def factory(*args_, **kwargs_):

if templateparamlistType.subclass:

return templateparamlistType.subclass(*args_, **kwargs_)

def set_param(self, param): self.param = param

def add_param(self, value): self.param.append(value)

def insert_param(self, index, value): self.param[index] = value

def export(self, outfile, level, namespace_='', name_='templateparamlistType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

if self.hasContent_():

outfile.write('>\n')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='templateparamlistType'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='templateparamlistType'):

for param_ in self.param:

param_.export(outfile, level, namespace_, name_='param')

def hasContent_(self):

if (

self.param is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='templateparamlistType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('param=[\n')

level -= 1

showIndent(outfile, level)

outfile.write('],\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

obj_ = paramType.factory()

obj_.build(child_)

self.param.append(obj_)

class paramType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, type_=None, declname=None, defname=None, array=None, defval=None, briefdescription=None):

self.type_ = type_

self.declname = declname

self.array = array

self.defval = defval

self.briefdescription = briefdescription

def factory(*args_, **kwargs_):

if paramType.subclass:

return paramType.subclass(*args_, **kwargs_)

def get_defval(self): return self.defval

def set_defval(self, defval): self.defval = defval

def get_briefdescription(self): return self.briefdescription

def export(self, outfile, level, namespace_='', name_='paramType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='paramType'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='paramType'):

if self.type_:

self.type_.export(outfile, level, namespace_, name_='type')

if self.declname is not None:

showIndent(outfile, level)

if self.defname is not None:

showIndent(outfile, level)

if self.array is not None:

showIndent(outfile, level)

if self.defval:

self.defval.export(outfile, level, namespace_, name_='defval')

if self.briefdescription:

def hasContent_(self):

if (

self.type_ is not None or

self.array is not None or

self.defval is not None or

self.briefdescription is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='paramType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

if self.type_:

showIndent(outfile, level)

showIndent(outfile, level)

outfile.write('),\n')

showIndent(outfile, level)

showIndent(outfile, level)

showIndent(outfile, level)

if self.defval:

showIndent(outfile, level)

outfile.write('defval=model_.linkedTextType(\n')

if self.briefdescription:

showIndent(outfile, level)

outfile.write('briefdescription=model_.descriptionType(\n')

showIndent(outfile, level)

outfile.write('),\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

obj_ = linkedTextType.factory()

obj_.build(child_)

self.set_type(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

declname_ = ''

for text__content_ in child_.childNodes:

declname_ += text__content_.nodeValue

self.declname = declname_

elif child_.nodeType == Node.ELEMENT_NODE and \

defname_ = ''

for text__content_ in child_.childNodes:

defname_ += text__content_.nodeValue

self.defname = defname_

elif child_.nodeType == Node.ELEMENT_NODE and \

array_ = ''

for text__content_ in child_.childNodes:

array_ += text__content_.nodeValue

self.array = array_

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = linkedTextType.factory()

obj_.build(child_)

self.set_defval(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = descriptionType.factory()

obj_.build(child_)

self.set_briefdescription(obj_)

class declname(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, valueOf_=''):

self.valueOf_ = valueOf_

def factory(*args_, **kwargs_):

if declname.subclass:

return declname.subclass(*args_, **kwargs_)

factory = staticmethod(factory)

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='declname', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='declname'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='declname'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='declname'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class declname

class defname(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, valueOf_=''):

self.valueOf_ = valueOf_

def factory(*args_, **kwargs_):

if defname.subclass:

return defname.subclass(*args_, **kwargs_)

factory = staticmethod(factory)

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='defname', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='defname'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='defname'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='defname'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class defname

class array(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, valueOf_=''):

self.valueOf_ = valueOf_

def factory(*args_, **kwargs_):

if array.subclass:

return array.subclass(*args_, **kwargs_)

factory = staticmethod(factory)

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='array', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='array'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='array'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='array'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class array

class linkedTextType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, ref=None, mixedclass_=None, content_=None):

if mixedclass_ is None:

self.mixedclass_ = MixedContainer

self.content_ = []

else:

self.content_ = content_

def factory(*args_, **kwargs_):

if linkedTextType.subclass:

return linkedTextType.subclass(*args_, **kwargs_)

def set_ref(self, ref): self.ref = ref

def add_ref(self, value): self.ref.append(value)

def insert_ref(self, index, value): self.ref[index] = value

def export(self, outfile, level, namespace_='', name_='linkedTextType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('>')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

def exportAttributes(self, outfile, level, namespace_='', name_='linkedTextType'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='linkedTextType'):

for item_ in self.content_:

item_.export(outfile, level, item_.name, namespace_)

def hasContent_(self):

if (

self.ref is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='linkedTextType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('content_ = [\n')

item_.exportLiteral(outfile, level, name_)

showIndent(outfile, level)

outfile.write('],\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = docRefTextType.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.TEXT_NODE:

obj_ = self.mixedclass_(MixedContainer.CategoryText,

self.content_.append(obj_)

# end class linkedTextType

class graphType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, node=None):

if node is None:

self.node = []

else:

self.node = node

def factory(*args_, **kwargs_):

if graphType.subclass:

return graphType.subclass(*args_, **kwargs_)

def set_node(self, node): self.node = node

def add_node(self, value): self.node.append(value)

def insert_node(self, index, value): self.node[index] = value

def export(self, outfile, level, namespace_='', name_='graphType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='graphType'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='graphType'):

for node_ in self.node:

node_.export(outfile, level, namespace_, name_='node')

def hasContent_(self):

if (

self.node is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='graphType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('node=[\n')

level -= 1

showIndent(outfile, level)

outfile.write('],\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

obj_ = nodeType.factory()

obj_.build(child_)

self.node.append(obj_)

class nodeType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, id=None, label=None, link=None, childnode=None):

self.id = id

self.label = label

self.childnode = []

else:

self.childnode = childnode

def factory(*args_, **kwargs_):

if nodeType.subclass:

return nodeType.subclass(*args_, **kwargs_)

def insert_childnode(self, index, value): self.childnode[index] = value

def get_id(self): return self.id

def set_id(self, id): self.id = id

def export(self, outfile, level, namespace_='', name_='nodeType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='nodeType'):

if self.id is not None:

def exportChildren(self, outfile, level, namespace_='', name_='nodeType'):

if self.label is not None:

showIndent(outfile, level)

if self.link:

self.link.export(outfile, level, namespace_, name_='link')

for childnode_ in self.childnode:

childnode_.export(outfile, level, namespace_, name_='childnode')

def hasContent_(self):

if (

self.label is not None or

self.link is not None or

self.childnode is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='nodeType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.id is not None:

showIndent(outfile, level)

outfile.write('id = %s,\n' % (self.id,))

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

if self.link:

showIndent(outfile, level)

outfile.write('link=model_.linkType(\n')

level -= 1

showIndent(outfile, level)

outfile.write('],\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('id'):

self.id = attrs.get('id').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

label_ = ''

for text__content_ in child_.childNodes:

label_ += text__content_.nodeValue

self.label = label_

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = linkType.factory()

obj_.build(child_)

self.set_link(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = childnodeType.factory()

obj_.build(child_)

self.childnode.append(obj_)

class label(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, valueOf_=''):

self.valueOf_ = valueOf_

def factory(*args_, **kwargs_):

if label.subclass:

return label.subclass(*args_, **kwargs_)

factory = staticmethod(factory)

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='label', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='label'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='label'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='label'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class label

class childnodeType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, relation=None, refid=None, edgelabel=None):

self.relation = relation

self.refid = refid

self.edgelabel = []

else:

self.edgelabel = edgelabel

def factory(*args_, **kwargs_):

if childnodeType.subclass:

return childnodeType.subclass(*args_, **kwargs_)

def set_relation(self, relation): self.relation = relation

def get_refid(self): return self.refid

def set_refid(self, refid): self.refid = refid

def export(self, outfile, level, namespace_='', name_='childnodeType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

if self.hasContent_():

outfile.write('>\n')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='childnodeType'):

if self.relation is not None:

outfile.write(' relation=%s' % (quote_attrib(self.relation), ))

if self.refid is not None:

def exportChildren(self, outfile, level, namespace_='', name_='childnodeType'):

for edgelabel_ in self.edgelabel:

showIndent(outfile, level)

def hasContent_(self):

if (

self.edgelabel is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='childnodeType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.relation is not None:

showIndent(outfile, level)

if self.refid is not None:

showIndent(outfile, level)

outfile.write('refid = %s,\n' % (self.refid,))

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('edgelabel=[\n')

level += 1

for edgelabel in self.edgelabel:

showIndent(outfile, level)

level -= 1

showIndent(outfile, level)

outfile.write('],\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('relation'):

self.relation = attrs.get('relation').value

if attrs.get('refid'):

self.refid = attrs.get('refid').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

edgelabel_ = ''

for text__content_ in child_.childNodes:

edgelabel_ += text__content_.nodeValue

class edgelabel(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, valueOf_=''):

self.valueOf_ = valueOf_

def factory(*args_, **kwargs_):

if edgelabel.subclass:

return edgelabel.subclass(*args_, **kwargs_)

factory = staticmethod(factory)

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='edgelabel', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='edgelabel'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='edgelabel'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='edgelabel'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class edgelabel

class linkType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, refid=None, external=None, valueOf_=''):

self.refid = refid

self.external = external

self.valueOf_ = valueOf_

def factory(*args_, **kwargs_):

if linkType.subclass:

return linkType.subclass(*args_, **kwargs_)

def set_external(self, external): self.external = external

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='linkType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='linkType'):

if self.refid is not None:

if self.external is not None:

def exportChildren(self, outfile, level, namespace_='', name_='linkType'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='linkType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.refid is not None:

showIndent(outfile, level)

if self.external is not None:

showIndent(outfile, level)

outfile.write('external = %s,\n' % (self.external,))

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('refid'):

self.refid = attrs.get('refid').value

if attrs.get('external'):

self.external = attrs.get('external').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class linkType

class listingType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, codeline=None):

if codeline is None:

self.codeline = []

else:

self.codeline = codeline

def factory(*args_, **kwargs_):

if listingType.subclass:

return listingType.subclass(*args_, **kwargs_)

def set_codeline(self, codeline): self.codeline = codeline

def add_codeline(self, value): self.codeline.append(value)

def insert_codeline(self, index, value): self.codeline[index] = value

def export(self, outfile, level, namespace_='', name_='listingType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='listingType'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='listingType'):

for codeline_ in self.codeline:

codeline_.export(outfile, level, namespace_, name_='codeline')

def hasContent_(self):

if (

self.codeline is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='listingType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('codeline=[\n')

level -= 1

showIndent(outfile, level)

outfile.write('],\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

obj_ = codelineType.factory()

obj_.build(child_)

self.codeline.append(obj_)

class codelineType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, external=None, lineno=None, refkind=None, refid=None, highlight=None):

self.external = external

self.lineno = lineno

self.highlight = []

else:

self.highlight = highlight

def factory(*args_, **kwargs_):

if codelineType.subclass:

return codelineType.subclass(*args_, **kwargs_)

def set_refkind(self, refkind): self.refkind = refkind

def get_refid(self): return self.refid

def set_refid(self, refid): self.refid = refid

def export(self, outfile, level, namespace_='', name_='codelineType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='codelineType'):

if self.external is not None:

outfile.write(' external=%s' % (quote_attrib(self.external), ))

if self.lineno is not None:

if self.refkind is not None:

outfile.write(' refkind=%s' % (quote_attrib(self.refkind), ))

if self.refid is not None:

def exportChildren(self, outfile, level, namespace_='', name_='codelineType'):

for highlight_ in self.highlight:

highlight_.export(outfile, level, namespace_, name_='highlight')

def hasContent_(self):

if (

self.highlight is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='codelineType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.external is not None:

showIndent(outfile, level)

if self.refid is not None:

showIndent(outfile, level)

outfile.write('refid = %s,\n' % (self.refid,))

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('highlight=[\n')

level -= 1

showIndent(outfile, level)

outfile.write('],\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('external'):

self.external = attrs.get('external').value

self.refkind = attrs.get('refkind').value

if attrs.get('refid'):

self.refid = attrs.get('refid').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

obj_ = highlightType.factory()

obj_.build(child_)

self.highlight.append(obj_)

class highlightType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, classxx=None, sp=None, ref=None, mixedclass_=None, content_=None):

self.classxx = classxx

if mixedclass_ is None:

self.content_ = []

else:

self.content_ = content_

def factory(*args_, **kwargs_):

if highlightType.subclass:

return highlightType.subclass(*args_, **kwargs_)

def insert_ref(self, index, value): self.ref[index] = value

def get_class(self): return self.classxx

def set_class(self, classxx): self.classxx = classxx

def export(self, outfile, level, namespace_='', name_='highlightType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('>')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

def exportAttributes(self, outfile, level, namespace_='', name_='highlightType'):

if self.classxx is not None:

outfile.write(' class=%s' % (quote_attrib(self.classxx), ))

def exportChildren(self, outfile, level, namespace_='', name_='highlightType'):

for item_ in self.content_:

item_.export(outfile, level, item_.name, namespace_)

def hasContent_(self):

if (

self.sp is not None or

self.ref is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='highlightType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.classxx is not None:

showIndent(outfile, level)

outfile.write('classxx = "%s",\n' % (self.classxx,))

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('content_ = [\n')

item_.exportLiteral(outfile, level, name_)

showIndent(outfile, level)

outfile.write('],\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('class'):

self.classxx = attrs.get('class').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

value_ = []

for text_ in child_.childNodes:

value_.append(text_.nodeValue)

valuestr_ = ''.join(value_)

obj_ = self.mixedclass_(MixedContainer.CategorySimple,

self.content_.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = docRefTextType.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.TEXT_NODE:

obj_ = self.mixedclass_(MixedContainer.CategoryText,

self.content_.append(obj_)

# end class highlightType

class sp(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, valueOf_=''):

self.valueOf_ = valueOf_

def factory(*args_, **kwargs_):

if sp.subclass:

return sp.subclass(*args_, **kwargs_)

factory = staticmethod(factory)

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='sp', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='sp'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='sp'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='sp'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class sp

class referenceType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, endline=None, startline=None, refid=None, compoundref=None, valueOf_='', mixedclass_=None, content_=None):

self.endline = endline

self.startline = startline

self.content_ = []

else:

self.content_ = content_

def factory(*args_, **kwargs_):

if referenceType.subclass:

return referenceType.subclass(*args_, **kwargs_)

def set_compoundref(self, compoundref): self.compoundref = compoundref

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='referenceType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('>')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

def exportAttributes(self, outfile, level, namespace_='', name_='referenceType'):

if self.endline is not None:

if self.startline is not None:

if self.refid is not None:

if self.compoundref is not None:

def exportChildren(self, outfile, level, namespace_='', name_='referenceType'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='referenceType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.endline is not None:

showIndent(outfile, level)

if self.compoundref is not None:

showIndent(outfile, level)

outfile.write('compoundref = %s,\n' % (self.compoundref,))

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('endline'):

try:

self.refid = attrs.get('refid').value

if attrs.get('compoundref'):

self.compoundref = attrs.get('compoundref').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

obj_ = self.mixedclass_(MixedContainer.CategoryText,

self.content_.append(obj_)

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class referenceType

class locationType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, bodystart=None, line=None, bodyend=None, bodyfile=None, file=None, valueOf_=''):

self.bodystart = bodystart

self.line = line

self.bodyfile = bodyfile

self.file = file

self.valueOf_ = valueOf_

def factory(*args_, **kwargs_):

if locationType.subclass:

return locationType.subclass(*args_, **kwargs_)

def set_file(self, file): self.file = file

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='locationType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='locationType'):

if self.bodystart is not None:

if self.line is not None:

if self.bodyend is not None:

if self.bodyfile is not None:

if self.file is not None:

def exportChildren(self, outfile, level, namespace_='', name_='locationType'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='locationType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.bodystart is not None:

showIndent(outfile, level)

if self.file is not None:

showIndent(outfile, level)

outfile.write('file = %s,\n' % (self.file,))

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('bodystart'):

try:

self.bodyfile = attrs.get('bodyfile').value

if attrs.get('file'):

self.file = attrs.get('file').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class locationType

class docSect1Type(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, id=None, title=None, para=None, sect2=None, internal=None, mixedclass_=None, content_=None):

self.id = id

if mixedclass_ is None:

self.content_ = []

else:

self.content_ = content_

def factory(*args_, **kwargs_):

if docSect1Type.subclass:

return docSect1Type.subclass(*args_, **kwargs_)

def set_internal(self, internal): self.internal = internal

def get_id(self): return self.id

def set_id(self, id): self.id = id

def export(self, outfile, level, namespace_='', name_='docSect1Type', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('>')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

def exportAttributes(self, outfile, level, namespace_='', name_='docSect1Type'):

if self.id is not None:

def exportChildren(self, outfile, level, namespace_='', name_='docSect1Type'):

for item_ in self.content_:

item_.export(outfile, level, item_.name, namespace_)

def hasContent_(self):

if (

self.title is not None or

self.para is not None or

self.sect2 is not None or

self.internal is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='docSect1Type'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.id is not None:

showIndent(outfile, level)

outfile.write('id = %s,\n' % (self.id,))

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('content_ = [\n')

item_.exportLiteral(outfile, level, name_)

showIndent(outfile, level)

outfile.write('],\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('id'):

self.id = attrs.get('id').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = docTitleType.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = docParaType.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = docSect2Type.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = docInternalS1Type.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.TEXT_NODE:

obj_ = self.mixedclass_(MixedContainer.CategoryText,

self.content_.append(obj_)

# end class docSect1Type

class docSect2Type(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, id=None, title=None, para=None, sect3=None, internal=None, mixedclass_=None, content_=None):

self.id = id

if mixedclass_ is None:

self.content_ = []

else:

self.content_ = content_

def factory(*args_, **kwargs_):

if docSect2Type.subclass:

return docSect2Type.subclass(*args_, **kwargs_)

def set_internal(self, internal): self.internal = internal

def get_id(self): return self.id

def set_id(self, id): self.id = id

def export(self, outfile, level, namespace_='', name_='docSect2Type', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('>')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

def exportAttributes(self, outfile, level, namespace_='', name_='docSect2Type'):

if self.id is not None:

def exportChildren(self, outfile, level, namespace_='', name_='docSect2Type'):

for item_ in self.content_:

item_.export(outfile, level, item_.name, namespace_)

def hasContent_(self):

if (

self.title is not None or

self.para is not None or

self.sect3 is not None or

self.internal is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='docSect2Type'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.id is not None:

showIndent(outfile, level)

outfile.write('id = %s,\n' % (self.id,))

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('content_ = [\n')

item_.exportLiteral(outfile, level, name_)

showIndent(outfile, level)

outfile.write('],\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('id'):

self.id = attrs.get('id').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = docTitleType.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = docParaType.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = docSect3Type.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = docInternalS2Type.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.TEXT_NODE:

obj_ = self.mixedclass_(MixedContainer.CategoryText,

self.content_.append(obj_)

# end class docSect2Type

class docSect3Type(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, id=None, title=None, para=None, sect4=None, internal=None, mixedclass_=None, content_=None):

self.id = id

if mixedclass_ is None:

self.content_ = []

else:

self.content_ = content_

def factory(*args_, **kwargs_):

if docSect3Type.subclass:

return docSect3Type.subclass(*args_, **kwargs_)

def set_internal(self, internal): self.internal = internal

def get_id(self): return self.id

def set_id(self, id): self.id = id

def export(self, outfile, level, namespace_='', name_='docSect3Type', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('>')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

def exportAttributes(self, outfile, level, namespace_='', name_='docSect3Type'):

if self.id is not None:

def exportChildren(self, outfile, level, namespace_='', name_='docSect3Type'):

for item_ in self.content_:

item_.export(outfile, level, item_.name, namespace_)

def hasContent_(self):

if (

self.title is not None or

self.para is not None or

self.sect4 is not None or

self.internal is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='docSect3Type'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.id is not None:

showIndent(outfile, level)

outfile.write('id = %s,\n' % (self.id,))

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('content_ = [\n')

item_.exportLiteral(outfile, level, name_)

showIndent(outfile, level)

outfile.write('],\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('id'):

self.id = attrs.get('id').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = docTitleType.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = docParaType.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = docSect4Type.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = docInternalS3Type.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.TEXT_NODE:

obj_ = self.mixedclass_(MixedContainer.CategoryText,

self.content_.append(obj_)

# end class docSect3Type

class docSect4Type(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, id=None, title=None, para=None, internal=None, mixedclass_=None, content_=None):

self.id = id

if mixedclass_ is None:

self.content_ = []

else:

self.content_ = content_

def factory(*args_, **kwargs_):

if docSect4Type.subclass:

return docSect4Type.subclass(*args_, **kwargs_)

def set_internal(self, internal): self.internal = internal

def get_id(self): return self.id

def set_id(self, id): self.id = id

def export(self, outfile, level, namespace_='', name_='docSect4Type', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('>')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

def exportAttributes(self, outfile, level, namespace_='', name_='docSect4Type'):

if self.id is not None:

def exportChildren(self, outfile, level, namespace_='', name_='docSect4Type'):

for item_ in self.content_:

item_.export(outfile, level, item_.name, namespace_)

def hasContent_(self):

if (

self.title is not None or

self.para is not None or

self.internal is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='docSect4Type'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.id is not None:

showIndent(outfile, level)

outfile.write('id = %s,\n' % (self.id,))

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('content_ = [\n')

item_.exportLiteral(outfile, level, name_)

showIndent(outfile, level)

outfile.write('],\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('id'):

self.id = attrs.get('id').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = docTitleType.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = docParaType.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = docInternalS4Type.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.TEXT_NODE:

obj_ = self.mixedclass_(MixedContainer.CategoryText,

self.content_.append(obj_)

# end class docSect4Type

class docInternalType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, para=None, sect1=None, mixedclass_=None, content_=None):

if mixedclass_ is None:

self.mixedclass_ = MixedContainer

self.content_ = []

else:

self.content_ = content_

def factory(*args_, **kwargs_):

if docInternalType.subclass:

return docInternalType.subclass(*args_, **kwargs_)

def set_sect1(self, sect1): self.sect1 = sect1

def add_sect1(self, value): self.sect1.append(value)

def insert_sect1(self, index, value): self.sect1[index] = value

def export(self, outfile, level, namespace_='', name_='docInternalType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('>')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

def exportAttributes(self, outfile, level, namespace_='', name_='docInternalType'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='docInternalType'):

for item_ in self.content_:

item_.export(outfile, level, item_.name, namespace_)

def hasContent_(self):

if (

self.para is not None or

self.sect1 is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='docInternalType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('content_ = [\n')

item_.exportLiteral(outfile, level, name_)

showIndent(outfile, level)

outfile.write('],\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = docParaType.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = docSect1Type.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.TEXT_NODE:

obj_ = self.mixedclass_(MixedContainer.CategoryText,

self.content_.append(obj_)

# end class docInternalType

class docInternalS1Type(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, para=None, sect2=None, mixedclass_=None, content_=None):

if mixedclass_ is None:

self.mixedclass_ = MixedContainer

self.content_ = []

else:

self.content_ = content_

def factory(*args_, **kwargs_):

if docInternalS1Type.subclass:

return docInternalS1Type.subclass(*args_, **kwargs_)

def set_sect2(self, sect2): self.sect2 = sect2

def add_sect2(self, value): self.sect2.append(value)

def insert_sect2(self, index, value): self.sect2[index] = value

def export(self, outfile, level, namespace_='', name_='docInternalS1Type', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('>')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

def exportAttributes(self, outfile, level, namespace_='', name_='docInternalS1Type'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='docInternalS1Type'):

for item_ in self.content_:

item_.export(outfile, level, item_.name, namespace_)

def hasContent_(self):

if (

self.para is not None or

self.sect2 is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='docInternalS1Type'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('content_ = [\n')

item_.exportLiteral(outfile, level, name_)

showIndent(outfile, level)

outfile.write('],\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = docParaType.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = docSect2Type.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.TEXT_NODE:

obj_ = self.mixedclass_(MixedContainer.CategoryText,

self.content_.append(obj_)

# end class docInternalS1Type

class docInternalS2Type(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, para=None, sect3=None, mixedclass_=None, content_=None):

if mixedclass_ is None:

self.mixedclass_ = MixedContainer

self.content_ = []

else:

self.content_ = content_

def factory(*args_, **kwargs_):

if docInternalS2Type.subclass:

return docInternalS2Type.subclass(*args_, **kwargs_)

def set_sect3(self, sect3): self.sect3 = sect3

def add_sect3(self, value): self.sect3.append(value)

def insert_sect3(self, index, value): self.sect3[index] = value

def export(self, outfile, level, namespace_='', name_='docInternalS2Type', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('>')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

def exportAttributes(self, outfile, level, namespace_='', name_='docInternalS2Type'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='docInternalS2Type'):

for item_ in self.content_:

item_.export(outfile, level, item_.name, namespace_)

def hasContent_(self):

if (

self.para is not None or

self.sect3 is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='docInternalS2Type'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('content_ = [\n')

item_.exportLiteral(outfile, level, name_)

showIndent(outfile, level)

outfile.write('],\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = docParaType.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = docSect3Type.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.TEXT_NODE:

obj_ = self.mixedclass_(MixedContainer.CategoryText,

self.content_.append(obj_)

# end class docInternalS2Type

class docInternalS3Type(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, para=None, sect3=None, mixedclass_=None, content_=None):

if mixedclass_ is None:

self.mixedclass_ = MixedContainer

self.content_ = []

else:

self.content_ = content_

def factory(*args_, **kwargs_):

if docInternalS3Type.subclass:

return docInternalS3Type.subclass(*args_, **kwargs_)

def set_sect3(self, sect3): self.sect3 = sect3

def add_sect3(self, value): self.sect3.append(value)

def insert_sect3(self, index, value): self.sect3[index] = value

def export(self, outfile, level, namespace_='', name_='docInternalS3Type', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('>')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

def exportAttributes(self, outfile, level, namespace_='', name_='docInternalS3Type'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='docInternalS3Type'):

for item_ in self.content_:

item_.export(outfile, level, item_.name, namespace_)

def hasContent_(self):

if (

self.para is not None or

self.sect3 is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='docInternalS3Type'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('content_ = [\n')

item_.exportLiteral(outfile, level, name_)

showIndent(outfile, level)

outfile.write('],\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = docParaType.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = docSect4Type.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.TEXT_NODE:

obj_ = self.mixedclass_(MixedContainer.CategoryText,

self.content_.append(obj_)

# end class docInternalS3Type

class docInternalS4Type(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, para=None, mixedclass_=None, content_=None):

if mixedclass_ is None:

self.mixedclass_ = MixedContainer

self.content_ = []

else:

self.content_ = content_

def factory(*args_, **kwargs_):

if docInternalS4Type.subclass:

return docInternalS4Type.subclass(*args_, **kwargs_)

def set_para(self, para): self.para = para

def add_para(self, value): self.para.append(value)

def insert_para(self, index, value): self.para[index] = value

def export(self, outfile, level, namespace_='', name_='docInternalS4Type', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('>')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

def exportAttributes(self, outfile, level, namespace_='', name_='docInternalS4Type'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='docInternalS4Type'):

for item_ in self.content_:

item_.export(outfile, level, item_.name, namespace_)

def hasContent_(self):

if (

self.para is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='docInternalS4Type'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('content_ = [\n')

item_.exportLiteral(outfile, level, name_)

showIndent(outfile, level)

outfile.write('],\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = docParaType.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.TEXT_NODE:

obj_ = self.mixedclass_(MixedContainer.CategoryText,

self.content_.append(obj_)

# end class docInternalS4Type

class docTitleType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, valueOf_='', mixedclass_=None, content_=None):

if mixedclass_ is None:

self.mixedclass_ = MixedContainer

self.content_ = []

else:

self.content_ = content_

def factory(*args_, **kwargs_):

if docTitleType.subclass:

return docTitleType.subclass(*args_, **kwargs_)

factory = staticmethod(factory)

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='docTitleType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('>')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

def exportAttributes(self, outfile, level, namespace_='', name_='docTitleType'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='docTitleType'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='docTitleType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

obj_ = self.mixedclass_(MixedContainer.CategoryText,

self.content_.append(obj_)

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class docTitleType

class docParaType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, valueOf_='', mixedclass_=None, content_=None):

if mixedclass_ is None:

self.mixedclass_ = MixedContainer

self.content_ = []

else:

self.content_ = content_

def factory(*args_, **kwargs_):

if docParaType.subclass:

return docParaType.subclass(*args_, **kwargs_)

factory = staticmethod(factory)

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='docParaType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('>')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

def exportAttributes(self, outfile, level, namespace_='', name_='docParaType'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='docParaType'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='docParaType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

obj_ = self.mixedclass_(MixedContainer.CategoryText,

self.content_.append(obj_)

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class docParaType

class docMarkupType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, valueOf_='', mixedclass_=None, content_=None):

if mixedclass_ is None:

self.mixedclass_ = MixedContainer

self.content_ = []

else:

self.content_ = content_

def factory(*args_, **kwargs_):

if docMarkupType.subclass:

return docMarkupType.subclass(*args_, **kwargs_)

factory = staticmethod(factory)

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='docMarkupType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('>')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

def exportAttributes(self, outfile, level, namespace_='', name_='docMarkupType'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='docMarkupType'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='docMarkupType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

obj_ = self.mixedclass_(MixedContainer.CategoryText,

self.content_.append(obj_)

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class docMarkupType

class docURLLink(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, url=None, valueOf_='', mixedclass_=None, content_=None):

self.url = url

if mixedclass_ is None:

self.content_ = []

else:

self.content_ = content_

def factory(*args_, **kwargs_):

if docURLLink.subclass:

return docURLLink.subclass(*args_, **kwargs_)

def set_url(self, url): self.url = url

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='docURLLink', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('>')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

def exportAttributes(self, outfile, level, namespace_='', name_='docURLLink'):

if self.url is not None:

def exportChildren(self, outfile, level, namespace_='', name_='docURLLink'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='docURLLink'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.url is not None:

showIndent(outfile, level)

outfile.write('url = %s,\n' % (self.url,))

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('url'):

self.url = attrs.get('url').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

obj_ = self.mixedclass_(MixedContainer.CategoryText,

self.content_.append(obj_)

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class docURLLink

class docAnchorType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, id=None, valueOf_='', mixedclass_=None, content_=None):

self.id = id

if mixedclass_ is None:

self.content_ = []

else:

self.content_ = content_

def factory(*args_, **kwargs_):

if docAnchorType.subclass:

return docAnchorType.subclass(*args_, **kwargs_)

def set_id(self, id): self.id = id

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='docAnchorType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('>')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

def exportAttributes(self, outfile, level, namespace_='', name_='docAnchorType'):

if self.id is not None:

def exportChildren(self, outfile, level, namespace_='', name_='docAnchorType'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='docAnchorType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.id is not None:

showIndent(outfile, level)

outfile.write('id = %s,\n' % (self.id,))

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('id'):

self.id = attrs.get('id').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

obj_ = self.mixedclass_(MixedContainer.CategoryText,

self.content_.append(obj_)

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class docAnchorType

class docFormulaType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, id=None, valueOf_='', mixedclass_=None, content_=None):

self.id = id

if mixedclass_ is None:

self.content_ = []

else:

self.content_ = content_

def factory(*args_, **kwargs_):

if docFormulaType.subclass:

return docFormulaType.subclass(*args_, **kwargs_)

def set_id(self, id): self.id = id

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='docFormulaType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('>')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

def exportAttributes(self, outfile, level, namespace_='', name_='docFormulaType'):

if self.id is not None:

def exportChildren(self, outfile, level, namespace_='', name_='docFormulaType'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='docFormulaType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.id is not None:

showIndent(outfile, level)

outfile.write('id = %s,\n' % (self.id,))

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('id'):

self.id = attrs.get('id').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

obj_ = self.mixedclass_(MixedContainer.CategoryText,

self.content_.append(obj_)

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class docFormulaType

class docIndexEntryType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, primaryie=None, secondaryie=None):

self.primaryie = primaryie

self.secondaryie = secondaryie

def factory(*args_, **kwargs_):

if docIndexEntryType.subclass:

return docIndexEntryType.subclass(*args_, **kwargs_)

def set_primaryie(self, primaryie): self.primaryie = primaryie

def get_secondaryie(self): return self.secondaryie

def set_secondaryie(self, secondaryie): self.secondaryie = secondaryie

def export(self, outfile, level, namespace_='', name_='docIndexEntryType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

if self.hasContent_():

outfile.write('>\n')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='docIndexEntryType'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='docIndexEntryType'):

if self.primaryie is not None:

showIndent(outfile, level)

if self.secondaryie is not None:

showIndent(outfile, level)

def hasContent_(self):

if (

self.primaryie is not None or

self.secondaryie is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='docIndexEntryType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

showIndent(outfile, level)

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

primaryie_ = ''

for text__content_ in child_.childNodes:

primaryie_ += text__content_.nodeValue

self.primaryie = primaryie_

elif child_.nodeType == Node.ELEMENT_NODE and \

secondaryie_ = ''

for text__content_ in child_.childNodes:

secondaryie_ += text__content_.nodeValue

class docListType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, listitem=None):

if listitem is None:

self.listitem = []

else:

self.listitem = listitem

def factory(*args_, **kwargs_):

if docListType.subclass:

return docListType.subclass(*args_, **kwargs_)

def set_listitem(self, listitem): self.listitem = listitem

def add_listitem(self, value): self.listitem.append(value)

def insert_listitem(self, index, value): self.listitem[index] = value

def export(self, outfile, level, namespace_='', name_='docListType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='docListType'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='docListType'):

for listitem_ in self.listitem:

listitem_.export(outfile, level, namespace_, name_='listitem')

def hasContent_(self):

if (

self.listitem is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='docListType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('listitem=[\n')

level -= 1

showIndent(outfile, level)

outfile.write('],\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

obj_ = docListItemType.factory()

obj_.build(child_)

self.listitem.append(obj_)

class docListItemType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, para=None):

if para is None:

self.para = []

else:

self.para = para

def factory(*args_, **kwargs_):

if docListItemType.subclass:

return docListItemType.subclass(*args_, **kwargs_)

def set_para(self, para): self.para = para

def add_para(self, value): self.para.append(value)

def insert_para(self, index, value): self.para[index] = value

def export(self, outfile, level, namespace_='', name_='docListItemType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

if self.hasContent_():

outfile.write('>\n')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='docListItemType'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='docListItemType'):

for para_ in self.para:

para_.export(outfile, level, namespace_, name_='para')

def hasContent_(self):

if (

self.para is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='docListItemType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('para=[\n')

level -= 1

showIndent(outfile, level)

outfile.write('],\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

obj_ = docParaType.factory()

obj_.build(child_)

self.para.append(obj_)

class docSimpleSectType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, kind=None, title=None, para=None):

self.kind = kind

self.title = title

self.para = []

else:

self.para = para

def factory(*args_, **kwargs_):

if docSimpleSectType.subclass:

return docSimpleSectType.subclass(*args_, **kwargs_)

def insert_para(self, index, value): self.para[index] = value

def get_kind(self): return self.kind

def set_kind(self, kind): self.kind = kind

def export(self, outfile, level, namespace_='', name_='docSimpleSectType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

if self.hasContent_():

outfile.write('>\n')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='docSimpleSectType'):

if self.kind is not None:

outfile.write(' kind=%s' % (quote_attrib(self.kind), ))

def exportChildren(self, outfile, level, namespace_='', name_='docSimpleSectType'):

if self.title:

self.title.export(outfile, level, namespace_, name_='title')

for para_ in self.para:

para_.export(outfile, level, namespace_, name_='para')

def hasContent_(self):

if (

self.title is not None or

self.para is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='docSimpleSectType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.kind is not None:

showIndent(outfile, level)

outfile.write('kind = "%s",\n' % (self.kind,))

def exportLiteralChildren(self, outfile, level, name_):

if self.title:

showIndent(outfile, level)

level -= 1

showIndent(outfile, level)

outfile.write('],\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('kind'):

self.kind = attrs.get('kind').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

obj_ = docTitleType.factory()

obj_.build(child_)

self.set_title(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = docParaType.factory()

obj_.build(child_)

self.para.append(obj_)

class docVarListEntryType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, term=None):

self.term = term

def factory(*args_, **kwargs_):

if docVarListEntryType.subclass:

return docVarListEntryType.subclass(*args_, **kwargs_)

factory = staticmethod(factory)

def get_term(self): return self.term

def set_term(self, term): self.term = term

def export(self, outfile, level, namespace_='', name_='docVarListEntryType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

if self.hasContent_():

outfile.write('>\n')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='docVarListEntryType'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='docVarListEntryType'):

if self.term:

self.term.export(outfile, level, namespace_, name_='term', )

def hasContent_(self):

if (

self.term is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='docVarListEntryType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

if self.term:

showIndent(outfile, level)

self.term.exportLiteral(outfile, level, name_='term')

showIndent(outfile, level)

outfile.write('),\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

obj_ = docTitleType.factory()

obj_.build(child_)

self.set_term(obj_)

class docVariableListType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, valueOf_=''):

self.valueOf_ = valueOf_

def factory(*args_, **kwargs_):

if docVariableListType.subclass:

return docVariableListType.subclass(*args_, **kwargs_)

factory = staticmethod(factory)

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='docVariableListType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

if self.hasContent_():

outfile.write('>\n')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='docVariableListType'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='docVariableListType'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='docVariableListType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class docVariableListType

class docRefTextType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, refid=None, kindref=None, external=None, valueOf_='', mixedclass_=None, content_=None):

self.refid = refid

self.kindref = kindref

self.content_ = []

else:

self.content_ = content_

def factory(*args_, **kwargs_):

if docRefTextType.subclass:

return docRefTextType.subclass(*args_, **kwargs_)

def set_external(self, external): self.external = external

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='docRefTextType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('>')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

def exportAttributes(self, outfile, level, namespace_='', name_='docRefTextType'):

if self.refid is not None:

if self.kindref is not None:

outfile.write(' kindref=%s' % (quote_attrib(self.kindref), ))

if self.external is not None:

def exportChildren(self, outfile, level, namespace_='', name_='docRefTextType'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='docRefTextType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.refid is not None:

showIndent(outfile, level)

if self.external is not None:

showIndent(outfile, level)

outfile.write('external = %s,\n' % (self.external,))

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('refid'):

self.refid = attrs.get('refid').value

self.kindref = attrs.get('kindref').value

if attrs.get('external'):

self.external = attrs.get('external').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

obj_ = self.mixedclass_(MixedContainer.CategoryText,

self.content_.append(obj_)

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class docRefTextType

class docTableType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, rows=None, cols=None, row=None, caption=None):

self.rows = rows

self.cols = cols

else:

self.row = row

self.caption = caption

def factory(*args_, **kwargs_):

if docTableType.subclass:

return docTableType.subclass(*args_, **kwargs_)

def set_rows(self, rows): self.rows = rows

def get_cols(self): return self.cols

def set_cols(self, cols): self.cols = cols

def export(self, outfile, level, namespace_='', name_='docTableType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='docTableType'):

if self.rows is not None:

if self.cols is not None:

def exportChildren(self, outfile, level, namespace_='', name_='docTableType'):

for row_ in self.row:

row_.export(outfile, level, namespace_, name_='row')

if self.caption:

self.caption.export(outfile, level, namespace_, name_='caption')

def hasContent_(self):

if (

self.row is not None or

self.caption is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='docTableType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.rows is not None:

showIndent(outfile, level)

if self.cols is not None:

showIndent(outfile, level)

outfile.write('cols = %s,\n' % (self.cols,))

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('row=[\n')

self.caption.exportLiteral(outfile, level, name_='caption')

showIndent(outfile, level)

outfile.write('),\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('rows'):

try:

self.cols = int(attrs.get('cols').value)

except ValueError as exp:

raise ValueError('Bad integer attribute (cols): %s' % exp)

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

obj_ = docRowType.factory()

obj_.build(child_)

self.row.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = docCaptionType.factory()

obj_.build(child_)

self.set_caption(obj_)

class docRowType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, entry=None):

if entry is None:

self.entry = []

else:

self.entry = entry

def factory(*args_, **kwargs_):

if docRowType.subclass:

return docRowType.subclass(*args_, **kwargs_)

def set_entry(self, entry): self.entry = entry

def add_entry(self, value): self.entry.append(value)

def insert_entry(self, index, value): self.entry[index] = value

def export(self, outfile, level, namespace_='', name_='docRowType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='docRowType'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='docRowType'):

for entry_ in self.entry:

entry_.export(outfile, level, namespace_, name_='entry')

def hasContent_(self):

if (

self.entry is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='docRowType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('entry=[\n')

level -= 1

showIndent(outfile, level)

outfile.write('],\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

obj_ = docEntryType.factory()

obj_.build(child_)

self.entry.append(obj_)

class docEntryType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, thead=None, para=None):

self.thead = thead

if para is None:

self.para = []

else:

self.para = para

def factory(*args_, **kwargs_):

if docEntryType.subclass:

return docEntryType.subclass(*args_, **kwargs_)

def insert_para(self, index, value): self.para[index] = value

def get_thead(self): return self.thead

def set_thead(self, thead): self.thead = thead

def export(self, outfile, level, namespace_='', name_='docEntryType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='docEntryType'):

if self.thead is not None:

outfile.write(' thead=%s' % (quote_attrib(self.thead), ))

def exportChildren(self, outfile, level, namespace_='', name_='docEntryType'):

for para_ in self.para:

para_.export(outfile, level, namespace_, name_='para')

def hasContent_(self):

if (

self.para is not None

return True