From 0cfb70212d219e8729b7fddb94f393f469665ecd Mon Sep 17 00:00:00 2001
From: Josh Morman <jmorman@gnuradio.org>
Date: Wed, 24 Nov 2021 12:50:06 -0500
Subject: docs: pep8 formatting
Signed-off-by: Josh Morman <jmorman@gnuradio.org>
---
docs/doxygen/doxyxml/generated/compound.py | 143 +-
docs/doxygen/doxyxml/generated/compoundsuper.py | 2531 +++++++++++++++++------
docs/doxygen/doxyxml/generated/index.py | 5 +-
docs/doxygen/doxyxml/generated/indexsuper.py | 115 +-
4 files changed, 2086 insertions(+), 708 deletions(-)
(limited to 'docs/doxygen/doxyxml/generated')
diff --git a/docs/doxygen/doxyxml/generated/compound.py b/docs/doxygen/doxyxml/generated/compound.py
index 294f0216e7..321328bcb7 100644
--- a/docs/doxygen/doxyxml/generated/compound.py
+++ b/docs/doxygen/doxyxml/generated/compound.py
@@ -22,13 +22,15 @@ class DoxygenTypeSub(supermod.DoxygenType):
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):
- supermod.compounddefType.__init__(self, kind, prot, id, compoundname, title, basecompoundref, derivedcompoundref, includes, includedby, incdepgraph, invincdepgraph, innerdir, innerfile, innerclass, innernamespace, innerpage, innergroup, templateparamlist, sectiondef, briefdescription, detaileddescription, inheritancegraph, collaborationgraph, programlisting, location, listofallmembers)
+ supermod.compounddefType.__init__(self, kind, prot, id, compoundname, title, basecompoundref, derivedcompoundref, includes, includedby, incdepgraph, invincdepgraph, innerdir, innerfile, innerclass,
+ innernamespace, innerpage, innergroup, templateparamlist, sectiondef, briefdescription, detaileddescription, inheritancegraph, collaborationgraph, programlisting, location, listofallmembers)
def find(self, details):
@@ -48,13 +50,18 @@ supermod.compounddefType.subclass = compounddefTypeSub
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.__init__(self, virt, prot, refid, ambiguityscope, scope, name)
+ supermod.memberRefType.__init__(
+ self, virt, prot, refid, ambiguityscope, scope, name)
+
+
supermod.memberRefType.subclass = memberRefTypeSub
# end class memberRefTypeSub
@@ -62,6 +69,8 @@ supermod.memberRefType.subclass = 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
@@ -69,6 +78,8 @@ supermod.compoundRefType.subclass = 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
@@ -76,6 +87,8 @@ supermod.reimplementType.subclass = 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
@@ -83,23 +96,26 @@ supermod.incType.subclass = 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
-class sectiondefTypeSub(supermod.sectiondefType):
+class sectiondefTypeSub(supermod.sectiondefType):
def __init__(self, kind=None, header='', description=None, memberdef=None):
- supermod.sectiondefType.__init__(self, kind, header, description, memberdef)
+ supermod.sectiondefType.__init__(
+ self, kind, header, description, memberdef)
def find(self, details):
@@ -116,7 +132,10 @@ supermod.sectiondefType.subclass = sectiondefTypeSub
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.__init__(self, initonly, kind, volatile, const, raise_, virt, readable, prot, explicit, new, final, writable, add, static, remove, sealed, mutable, gettable, inline, settable, id, templateparamlist, type_, definition, argsstring, name, read, write, bitfield, reimplements, reimplementedby, param, enumvalue, initializer, exceptions, briefdescription, detaileddescription, inbodydescription, location, references, referencedby)
+ supermod.memberdefType.__init__(self, initonly, kind, volatile, const, raise_, virt, readable, prot, explicit, new, final, writable, add, static, remove, sealed, mutable, gettable, inline, settable, id, templateparamlist, type_,
+ definition, argsstring, name, read, write, bitfield, reimplements, reimplementedby, param, enumvalue, initializer, exceptions, briefdescription, detaileddescription, inbodydescription, location, references, referencedby)
+
+
supermod.memberdefType.subclass = memberdefTypeSub
# end class memberdefTypeSub
@@ -124,6 +143,8 @@ supermod.memberdefType.subclass = 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
@@ -131,6 +152,8 @@ supermod.descriptionType.subclass = 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
@@ -138,13 +161,18 @@ supermod.enumvalueType.subclass = 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.__init__(self, type_, declname, defname, array, defval, briefdescription)
+ supermod.paramType.__init__(
+ self, type_, declname, defname, array, defval, briefdescription)
+
+
supermod.paramType.subclass = paramTypeSub
# end class paramTypeSub
@@ -152,6 +180,8 @@ supermod.paramType.subclass = 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
@@ -159,6 +189,8 @@ supermod.linkedTextType.subclass = linkedTextTypeSub
class graphTypeSub(supermod.graphType):
def __init__(self, node=None):
supermod.graphType.__init__(self, node)
+
+
supermod.graphType.subclass = graphTypeSub
# end class graphTypeSub
@@ -166,6 +198,8 @@ supermod.graphType.subclass = 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
@@ -173,6 +207,8 @@ supermod.nodeType.subclass = 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
@@ -180,6 +216,8 @@ supermod.childnodeType.subclass = 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
@@ -187,13 +225,18 @@ supermod.linkType.subclass = 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.__init__(self, external, lineno, refkind, refid, highlight)
+ supermod.codelineType.__init__(
+ self, external, lineno, refkind, refid, highlight)
+
+
supermod.codelineType.subclass = codelineTypeSub
# end class codelineTypeSub
@@ -201,6 +244,8 @@ supermod.codelineType.subclass = 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
@@ -208,13 +253,18 @@ supermod.highlightType.subclass = 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.__init__(self, bodystart, line, bodyend, bodyfile, file)
+ supermod.locationType.__init__(
+ self, bodystart, line, bodyend, bodyfile, file)
+
+
supermod.locationType.subclass = locationTypeSub
# end class locationTypeSub
@@ -222,6 +272,8 @@ supermod.locationType.subclass = 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
@@ -229,6 +281,8 @@ supermod.docSect1Type.subclass = 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
@@ -236,6 +290,8 @@ supermod.docSect2Type.subclass = 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
@@ -243,6 +299,8 @@ supermod.docSect3Type.subclass = 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
@@ -250,6 +308,8 @@ supermod.docSect4Type.subclass = 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
@@ -257,6 +317,8 @@ supermod.docInternalType.subclass = 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
@@ -264,6 +326,8 @@ supermod.docInternalS1Type.subclass = 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
@@ -271,6 +335,8 @@ supermod.docInternalS2Type.subclass = 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
@@ -278,6 +344,8 @@ supermod.docInternalS3Type.subclass = 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
@@ -285,6 +353,8 @@ supermod.docInternalS4Type.subclass = 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
@@ -292,6 +362,8 @@ supermod.docURLLink.subclass = 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
@@ -299,6 +371,8 @@ supermod.docAnchorType.subclass = 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
@@ -306,6 +380,8 @@ supermod.docFormulaType.subclass = docFormulaTypeSub
class docIndexEntryTypeSub(supermod.docIndexEntryType):
def __init__(self, primaryie='', secondaryie=''):
supermod.docIndexEntryType.__init__(self, primaryie, secondaryie)
+
+
supermod.docIndexEntryType.subclass = docIndexEntryTypeSub
# end class docIndexEntryTypeSub
@@ -313,6 +389,8 @@ supermod.docIndexEntryType.subclass = docIndexEntryTypeSub
class docListTypeSub(supermod.docListType):
def __init__(self, listitem=None):
supermod.docListType.__init__(self, listitem)
+
+
supermod.docListType.subclass = docListTypeSub
# end class docListTypeSub
@@ -320,6 +398,8 @@ supermod.docListType.subclass = docListTypeSub
class docListItemTypeSub(supermod.docListItemType):
def __init__(self, para=None):
supermod.docListItemType.__init__(self, para)
+
+
supermod.docListItemType.subclass = docListItemTypeSub
# end class docListItemTypeSub
@@ -327,6 +407,8 @@ supermod.docListItemType.subclass = 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
@@ -334,6 +416,8 @@ supermod.docSimpleSectType.subclass = docSimpleSectTypeSub
class docVarListEntryTypeSub(supermod.docVarListEntryType):
def __init__(self, term=None):
supermod.docVarListEntryType.__init__(self, term)
+
+
supermod.docVarListEntryType.subclass = docVarListEntryTypeSub
# end class docVarListEntryTypeSub
@@ -341,6 +425,8 @@ supermod.docVarListEntryType.subclass = 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
@@ -348,6 +434,8 @@ supermod.docRefTextType.subclass = 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
@@ -355,6 +443,8 @@ supermod.docTableType.subclass = docTableTypeSub
class docRowTypeSub(supermod.docRowType):
def __init__(self, entry=None):
supermod.docRowType.__init__(self, entry)
+
+
supermod.docRowType.subclass = docRowTypeSub
# end class docRowTypeSub
@@ -362,6 +452,8 @@ supermod.docRowType.subclass = 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
@@ -369,6 +461,8 @@ supermod.docEntryType.subclass = 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
@@ -376,6 +470,8 @@ supermod.docHeadingType.subclass = 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
@@ -383,6 +479,8 @@ supermod.docImageType.subclass = 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
@@ -390,6 +488,8 @@ supermod.docDotFileType.subclass = 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
@@ -397,6 +497,8 @@ supermod.docTocItemType.subclass = docTocItemTypeSub
class docTocListTypeSub(supermod.docTocListType):
def __init__(self, tocitem=None):
supermod.docTocListType.__init__(self, tocitem)
+
+
supermod.docTocListType.subclass = docTocListTypeSub
# end class docTocListTypeSub
@@ -404,6 +506,8 @@ supermod.docTocListType.subclass = 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
@@ -411,13 +515,18 @@ supermod.docLanguageType.subclass = 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.__init__(self, parameternamelist, parameterdescription)
+ supermod.docParamListItem.__init__(
+ self, parameternamelist, parameterdescription)
+
+
supermod.docParamListItem.subclass = docParamListItemSub
# end class docParamListItemSub
@@ -425,6 +534,8 @@ supermod.docParamListItem.subclass = docParamListItemSub
class docParamNameListSub(supermod.docParamNameList):
def __init__(self, parametername=None):
supermod.docParamNameList.__init__(self, parametername)
+
+
supermod.docParamNameList.subclass = docParamNameListSub
# end class docParamNameListSub
@@ -432,6 +543,8 @@ supermod.docParamNameList.subclass = 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
@@ -439,6 +552,8 @@ supermod.docParamName.subclass = 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
@@ -446,6 +561,8 @@ supermod.docXRefSectType.subclass = 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
@@ -453,9 +570,12 @@ supermod.docCopyType.subclass = 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)
@@ -469,7 +589,7 @@ class docParaTypeSub(supermod.docParaType):
if child_.nodeType == Node.TEXT_NODE:
obj_ = self.mixedclass_(MixedContainer.CategoryText,
- MixedContainer.TypeNone, '', child_.nodeValue)
+ MixedContainer.TypeNone, '', child_.nodeValue)
self.content.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == "ref":
@@ -492,7 +612,6 @@ supermod.docParaType.subclass = docParaTypeSub
# end class docParaTypeSub
-
def parse(inFilename):
doc = minidom.parse(inFilename)
rootNode = doc.documentElement
diff --git a/docs/doxygen/doxyxml/generated/compoundsuper.py b/docs/doxygen/doxyxml/generated/compoundsuper.py
index 05c49281fe..40f548aab0 100644
--- a/docs/doxygen/doxyxml/generated/compoundsuper.py
+++ b/docs/doxygen/doxyxml/generated/compoundsuper.py
@@ -24,12 +24,16 @@ except ImportError as exp:
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
@@ -41,9 +45,9 @@ except ImportError as exp:
## from IPython.Shell import IPShellEmbed
## args = ''
-## ipshell = IPShellEmbed(args,
+# ipshell = IPShellEmbed(args,
## banner = 'Dropping into IPython',
-## exit_msg = 'Leaving Interpreter, back to program.')
+# exit_msg = 'Leaving Interpreter, back to program.')
# Then use the following line where and when you want to drop into the
# IPython shell:
@@ -59,10 +63,12 @@ ExternalEncoding = 'ascii'
# 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)
@@ -71,6 +77,7 @@ def quote_xml(inStr):
s1 = s1.replace('>', '>')
return s1
+
def quote_attrib(inStr):
s1 = (isinstance(inStr, str) and inStr or
'%s' % inStr)
@@ -86,6 +93,7 @@ def quote_attrib(inStr):
s1 = '"%s"' % s1
return s1
+
def quote_python(inStr):
s1 = inStr
if s1.find("'") == -1:
@@ -117,26 +125,33 @@ class MixedContainer(object):
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
- self.value.export(outfile, level, namespace,name)
+ self.value.export(outfile, level, namespace, name)
+
def exportSimple(self, outfile, level, name):
if self.content_type == MixedContainer.TypeString:
outfile.write('<%s>%s</%s>' % (self.name, self.value, self.name))
@@ -148,19 +163,20 @@ class MixedContainer(object):
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)
- outfile.write('MixedContainer(%d, %d, "%s", "%s"),\n' % \
- (self.category, self.content_type, self.name, self.value))
+ outfile.write('MixedContainer(%d, %d, "%s", "%s"),\n' %
+ (self.category, self.content_type, self.name, self.value))
elif self.category == MixedContainer.CategorySimple:
showIndent(outfile, level)
- outfile.write('MixedContainer(%d, %d, "%s", "%s"),\n' % \
- (self.category, self.content_type, self.name, self.value))
+ outfile.write('MixedContainer(%d, %d, "%s", "%s"),\n' %
+ (self.category, self.content_type, self.name, self.value))
else: # category == MixedContainer.CategoryComplex
showIndent(outfile, level)
- outfile.write('MixedContainer(%d, %d, "%s",\n' % \
- (self.category, self.content_type, self.name,))
+ outfile.write('MixedContainer(%d, %d, "%s",\n' %
+ (self.category, self.content_type, self.name,))
self.value.exportLiteral(outfile, level + 1)
showIndent(outfile, level)
outfile.write(')\n')
@@ -171,6 +187,7 @@ class _MemberSpec(object):
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
@@ -186,9 +203,11 @@ class _MemberSpec(object):
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_)
@@ -199,6 +218,7 @@ class DoxygenType(GeneratedsSuper):
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_, ))
@@ -210,27 +230,34 @@ class DoxygenType(GeneratedsSuper):
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:
- self.compounddef.export(outfile, level, namespace_, name_='compounddef')
+ self.compounddef.export(
+ outfile, level, namespace_, name_='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)
@@ -238,18 +265,21 @@ class DoxygenType(GeneratedsSuper):
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 \
- nodeName_ == 'compounddef':
+ nodeName_ == 'compounddef':
obj_ = compounddefType.factory()
obj_.build(child_)
self.set_compounddef(obj_)
@@ -259,6 +289,7 @@ class DoxygenType(GeneratedsSuper):
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
@@ -319,6 +350,7 @@ class compounddefType(GeneratedsSuper):
self.programlisting = programlisting
self.location = location
self.listofallmembers = listofallmembers
+
def factory(*args_, **kwargs_):
if compounddefType.subclass:
return compounddefType.subclass(*args_, **kwargs_)
@@ -330,13 +362,23 @@ class compounddefType(GeneratedsSuper):
def get_title(self): return self.title
def set_title(self, title): self.title = title
def get_basecompoundref(self): return self.basecompoundref
- def set_basecompoundref(self, basecompoundref): self.basecompoundref = basecompoundref
+ def set_basecompoundref(
+ self, basecompoundref): self.basecompoundref = basecompoundref
+
def add_basecompoundref(self, value): self.basecompoundref.append(value)
- def insert_basecompoundref(self, index, value): self.basecompoundref[index] = value
+ def insert_basecompoundref(
+ self, index, value): self.basecompoundref[index] = value
+
def get_derivedcompoundref(self): return self.derivedcompoundref
- def set_derivedcompoundref(self, derivedcompoundref): self.derivedcompoundref = derivedcompoundref
- def add_derivedcompoundref(self, value): self.derivedcompoundref.append(value)
- def insert_derivedcompoundref(self, index, value): self.derivedcompoundref[index] = value
+
+ def set_derivedcompoundref(
+ self, derivedcompoundref): self.derivedcompoundref = derivedcompoundref
+
+ def add_derivedcompoundref(
+ self, value): self.derivedcompoundref.append(value)
+ def insert_derivedcompoundref(
+ self, index, value): self.derivedcompoundref[index] = value
+
def get_includes(self): return self.includes
def set_includes(self, includes): self.includes = includes
def add_includes(self, value): self.includes.append(value)
@@ -348,7 +390,9 @@ class compounddefType(GeneratedsSuper):
def get_incdepgraph(self): return self.incdepgraph
def set_incdepgraph(self, incdepgraph): self.incdepgraph = incdepgraph
def get_invincdepgraph(self): return self.invincdepgraph
- def set_invincdepgraph(self, invincdepgraph): self.invincdepgraph = invincdepgraph
+ def set_invincdepgraph(
+ self, invincdepgraph): self.invincdepgraph = 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)
@@ -362,9 +406,13 @@ class compounddefType(GeneratedsSuper):
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 set_innernamespace(self, innernamespace): self.innernamespace = innernamespace
+ def set_innernamespace(
+ self, innernamespace): self.innernamespace = innernamespace
+
def add_innernamespace(self, value): self.innernamespace.append(value)
- def insert_innernamespace(self, index, value): self.innernamespace[index] = value
+ def insert_innernamespace(
+ self, index, value): self.innernamespace[index] = 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)
@@ -374,35 +422,51 @@ class compounddefType(GeneratedsSuper):
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 set_templateparamlist(self, templateparamlist): self.templateparamlist = templateparamlist
+ def set_templateparamlist(
+ self, templateparamlist): self.templateparamlist = 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 set_briefdescription(self, briefdescription): self.briefdescription = briefdescription
+ def set_briefdescription(
+ self, briefdescription): self.briefdescription = briefdescription
+
def get_detaileddescription(self): return self.detaileddescription
- def set_detaileddescription(self, detaileddescription): self.detaileddescription = detaileddescription
+ def set_detaileddescription(
+ self, detaileddescription): self.detaileddescription = detaileddescription
+
def get_inheritancegraph(self): return self.inheritancegraph
- def set_inheritancegraph(self, inheritancegraph): self.inheritancegraph = inheritancegraph
+ def set_inheritancegraph(
+ self, inheritancegraph): self.inheritancegraph = inheritancegraph
+
def get_collaborationgraph(self): return self.collaborationgraph
- def set_collaborationgraph(self, collaborationgraph): self.collaborationgraph = collaborationgraph
+ def set_collaborationgraph(
+ self, collaborationgraph): self.collaborationgraph = collaborationgraph
+
def get_programlisting(self): return self.programlisting
- def set_programlisting(self, programlisting): self.programlisting = programlisting
+ def set_programlisting(
+ self, programlisting): self.programlisting = programlisting
+
def get_location(self): return self.location
def set_location(self, location): self.location = location
def get_listofallmembers(self): return self.listofallmembers
- def set_listofallmembers(self, listofallmembers): self.listofallmembers = listofallmembers
+ def set_listofallmembers(
+ self, listofallmembers): self.listofallmembers = 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_, ))
- self.exportAttributes(outfile, level, namespace_, name_='compounddefType')
+ self.exportAttributes(outfile, level, namespace_,
+ name_='compounddefType')
if self.hasContent_():
outfile.write('>\n')
self.exportChildren(outfile, level + 1, namespace_, name_)
@@ -410,32 +474,41 @@ class compounddefType(GeneratedsSuper):
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:
- outfile.write(' id=%s' % (self.format_string(quote_attrib(self.id).encode(ExternalEncoding), input_name='id'), ))
+ outfile.write(' id=%s' % (self.format_string(quote_attrib(
+ self.id).encode(ExternalEncoding), input_name='id'), ))
+
def exportChildren(self, outfile, level, namespace_='', name_='compounddefType'):
if self.compoundname is not None:
showIndent(outfile, level)
- outfile.write('<%scompoundname>%s</%scompoundname>\n' % (namespace_, self.format_string(quote_xml(self.compoundname).encode(ExternalEncoding), input_name='compoundname'), namespace_))
+ outfile.write('<%scompoundname>%s</%scompoundname>\n' % (namespace_, self.format_string(
+ quote_xml(self.compoundname).encode(ExternalEncoding), input_name='compoundname'), namespace_))
if self.title is not None:
showIndent(outfile, level)
- outfile.write('<%stitle>%s</%stitle>\n' % (namespace_, self.format_string(quote_xml(self.title).encode(ExternalEncoding), input_name='title'), namespace_))
+ outfile.write('<%stitle>%s</%stitle>\n' % (namespace_, self.format_string(
+ quote_xml(self.title).encode(ExternalEncoding), input_name='title'), namespace_))
for basecompoundref_ in self.basecompoundref:
- basecompoundref_.export(outfile, level, namespace_, name_='basecompoundref')
+ basecompoundref_.export(
+ outfile, level, namespace_, name_='basecompoundref')
for derivedcompoundref_ in self.derivedcompoundref:
- derivedcompoundref_.export(outfile, level, namespace_, name_='derivedcompoundref')
+ derivedcompoundref_.export(
+ outfile, level, namespace_, name_='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:
- self.incdepgraph.export(outfile, level, namespace_, name_='incdepgraph')
+ self.incdepgraph.export(
+ outfile, level, namespace_, name_='incdepgraph')
if self.invincdepgraph:
- self.invincdepgraph.export(outfile, level, namespace_, name_='invincdepgraph')
+ self.invincdepgraph.export(
+ outfile, level, namespace_, name_='invincdepgraph')
for innerdir_ in self.innerdir:
innerdir_.export(outfile, level, namespace_, name_='innerdir')
for innerfile_ in self.innerfile:
@@ -443,29 +516,38 @@ class compounddefType(GeneratedsSuper):
for innerclass_ in self.innerclass:
innerclass_.export(outfile, level, namespace_, name_='innerclass')
for innernamespace_ in self.innernamespace:
- innernamespace_.export(outfile, level, namespace_, name_='innernamespace')
+ innernamespace_.export(
+ outfile, level, namespace_, name_='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:
- self.templateparamlist.export(outfile, level, namespace_, name_='templateparamlist')
+ self.templateparamlist.export(
+ outfile, level, namespace_, name_='templateparamlist')
for sectiondef_ in self.sectiondef:
sectiondef_.export(outfile, level, namespace_, name_='sectiondef')
if self.briefdescription:
- self.briefdescription.export(outfile, level, namespace_, name_='briefdescription')
+ self.briefdescription.export(
+ outfile, level, namespace_, name_='briefdescription')
if self.detaileddescription:
- self.detaileddescription.export(outfile, level, namespace_, name_='detaileddescription')
+ self.detaileddescription.export(
+ outfile, level, namespace_, name_='detaileddescription')
if self.inheritancegraph:
- self.inheritancegraph.export(outfile, level, namespace_, name_='inheritancegraph')
+ self.inheritancegraph.export(
+ outfile, level, namespace_, name_='inheritancegraph')
if self.collaborationgraph:
- self.collaborationgraph.export(outfile, level, namespace_, name_='collaborationgraph')
+ self.collaborationgraph.export(
+ outfile, level, namespace_, name_='collaborationgraph')
if self.programlisting:
- self.programlisting.export(outfile, level, namespace_, name_='programlisting')
+ self.programlisting.export(
+ outfile, level, namespace_, name_='programlisting')
if self.location:
self.location.export(outfile, level, namespace_, name_='location')
if self.listofallmembers:
- self.listofallmembers.export(outfile, level, namespace_, name_='listofallmembers')
+ self.listofallmembers.export(
+ outfile, level, namespace_, name_='listofallmembers')
+
def hasContent_(self):
if (
self.compoundname is not None or
@@ -491,15 +573,17 @@ class compounddefType(GeneratedsSuper):
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)
@@ -510,9 +594,11 @@ class compounddefType(GeneratedsSuper):
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('compoundname=%s,\n' % quote_python(self.compoundname).encode(ExternalEncoding))
+ outfile.write('compoundname=%s,\n' % quote_python(
+ self.compoundname).encode(ExternalEncoding))
if self.title:
showIndent(outfile, level)
outfile.write('title=model_.xsd_string(\n')
@@ -525,7 +611,8 @@ class compounddefType(GeneratedsSuper):
for basecompoundref in self.basecompoundref:
showIndent(outfile, level)
outfile.write('model_.basecompoundref(\n')
- basecompoundref.exportLiteral(outfile, level, name_='basecompoundref')
+ basecompoundref.exportLiteral(
+ outfile, level, name_='basecompoundref')
showIndent(outfile, level)
outfile.write('),\n')
level -= 1
@@ -537,7 +624,8 @@ class compounddefType(GeneratedsSuper):
for derivedcompoundref in self.derivedcompoundref:
showIndent(outfile, level)
outfile.write('model_.derivedcompoundref(\n')
- derivedcompoundref.exportLiteral(outfile, level, name_='derivedcompoundref')
+ derivedcompoundref.exportLiteral(
+ outfile, level, name_='derivedcompoundref')
showIndent(outfile, level)
outfile.write('),\n')
level -= 1
@@ -576,7 +664,8 @@ class compounddefType(GeneratedsSuper):
if self.invincdepgraph:
showIndent(outfile, level)
outfile.write('invincdepgraph=model_.graphType(\n')
- self.invincdepgraph.exportLiteral(outfile, level, name_='invincdepgraph')
+ self.invincdepgraph.exportLiteral(
+ outfile, level, name_='invincdepgraph')
showIndent(outfile, level)
outfile.write('),\n')
showIndent(outfile, level)
@@ -621,7 +710,8 @@ class compounddefType(GeneratedsSuper):
for innernamespace in self.innernamespace:
showIndent(outfile, level)
outfile.write('model_.innernamespace(\n')
- innernamespace.exportLiteral(outfile, level, name_='innernamespace')
+ innernamespace.exportLiteral(
+ outfile, level, name_='innernamespace')
showIndent(outfile, level)
outfile.write('),\n')
level -= 1
@@ -654,7 +744,8 @@ class compounddefType(GeneratedsSuper):
if self.templateparamlist:
showIndent(outfile, level)
outfile.write('templateparamlist=model_.templateparamlistType(\n')
- self.templateparamlist.exportLiteral(outfile, level, name_='templateparamlist')
+ self.templateparamlist.exportLiteral(
+ outfile, level, name_='templateparamlist')
showIndent(outfile, level)
outfile.write('),\n')
showIndent(outfile, level)
@@ -672,31 +763,36 @@ class compounddefType(GeneratedsSuper):
if self.briefdescription:
showIndent(outfile, level)
outfile.write('briefdescription=model_.descriptionType(\n')
- self.briefdescription.exportLiteral(outfile, level, name_='briefdescription')
+ self.briefdescription.exportLiteral(
+ outfile, level, name_='briefdescription')
showIndent(outfile, level)
outfile.write('),\n')
if self.detaileddescription:
showIndent(outfile, level)
outfile.write('detaileddescription=model_.descriptionType(\n')
- self.detaileddescription.exportLiteral(outfile, level, name_='detaileddescription')
+ self.detaileddescription.exportLiteral(
+ outfile, level, name_='detaileddescription')
showIndent(outfile, level)
outfile.write('),\n')
if self.inheritancegraph:
showIndent(outfile, level)
outfile.write('inheritancegraph=model_.graphType(\n')
- self.inheritancegraph.exportLiteral(outfile, level, name_='inheritancegraph')
+ self.inheritancegraph.exportLiteral(
+ outfile, level, name_='inheritancegraph')
showIndent(outfile, level)
outfile.write('),\n')
if self.collaborationgraph:
showIndent(outfile, level)
outfile.write('collaborationgraph=model_.graphType(\n')
- self.collaborationgraph.exportLiteral(outfile, level, name_='collaborationgraph')
+ self.collaborationgraph.exportLiteral(
+ outfile, level, name_='collaborationgraph')
showIndent(outfile, level)
outfile.write('),\n')
if self.programlisting:
showIndent(outfile, level)
outfile.write('programlisting=model_.listingType(\n')
- self.programlisting.exportLiteral(outfile, level, name_='programlisting')
+ self.programlisting.exportLiteral(
+ outfile, level, name_='programlisting')
showIndent(outfile, level)
outfile.write('),\n')
if self.location:
@@ -708,15 +804,18 @@ class compounddefType(GeneratedsSuper):
if self.listofallmembers:
showIndent(outfile, level)
outfile.write('listofallmembers=model_.listofallmembersType(\n')
- self.listofallmembers.exportLiteral(outfile, level, name_='listofallmembers')
+ self.listofallmembers.exportLiteral(
+ outfile, level, name_='listofallmembers')
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
@@ -724,120 +823,121 @@ class compounddefType(GeneratedsSuper):
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 \
- nodeName_ == 'compoundname':
+ nodeName_ == 'compoundname':
compoundname_ = ''
for text__content_ in child_.childNodes:
compoundname_ += text__content_.nodeValue
self.compoundname = compoundname_
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'title':
+ nodeName_ == 'title':
obj_ = docTitleType.factory()
obj_.build(child_)
self.set_title(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'basecompoundref':
+ nodeName_ == 'basecompoundref':
obj_ = compoundRefType.factory()
obj_.build(child_)
self.basecompoundref.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'derivedcompoundref':
+ nodeName_ == 'derivedcompoundref':
obj_ = compoundRefType.factory()
obj_.build(child_)
self.derivedcompoundref.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'includes':
+ nodeName_ == 'includes':
obj_ = incType.factory()
obj_.build(child_)
self.includes.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'includedby':
+ nodeName_ == 'includedby':
obj_ = incType.factory()
obj_.build(child_)
self.includedby.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'incdepgraph':
+ nodeName_ == 'incdepgraph':
obj_ = graphType.factory()
obj_.build(child_)
self.set_incdepgraph(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'invincdepgraph':
+ nodeName_ == 'invincdepgraph':
obj_ = graphType.factory()
obj_.build(child_)
self.set_invincdepgraph(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'innerdir':
+ nodeName_ == 'innerdir':
obj_ = refType.factory()
obj_.build(child_)
self.innerdir.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'innerfile':
+ nodeName_ == 'innerfile':
obj_ = refType.factory()
obj_.build(child_)
self.innerfile.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'innerclass':
+ nodeName_ == 'innerclass':
obj_ = refType.factory()
obj_.build(child_)
self.innerclass.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'innernamespace':
+ nodeName_ == 'innernamespace':
obj_ = refType.factory()
obj_.build(child_)
self.innernamespace.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'innerpage':
+ nodeName_ == 'innerpage':
obj_ = refType.factory()
obj_.build(child_)
self.innerpage.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'innergroup':
+ nodeName_ == 'innergroup':
obj_ = refType.factory()
obj_.build(child_)
self.innergroup.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'templateparamlist':
+ nodeName_ == 'templateparamlist':
obj_ = templateparamlistType.factory()
obj_.build(child_)
self.set_templateparamlist(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'sectiondef':
+ nodeName_ == 'sectiondef':
obj_ = sectiondefType.factory()
obj_.build(child_)
self.sectiondef.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'briefdescription':
+ nodeName_ == 'briefdescription':
obj_ = descriptionType.factory()
obj_.build(child_)
self.set_briefdescription(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'detaileddescription':
+ nodeName_ == 'detaileddescription':
obj_ = descriptionType.factory()
obj_.build(child_)
self.set_detaileddescription(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'inheritancegraph':
+ nodeName_ == 'inheritancegraph':
obj_ = graphType.factory()
obj_.build(child_)
self.set_inheritancegraph(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'collaborationgraph':
+ nodeName_ == 'collaborationgraph':
obj_ = graphType.factory()
obj_.build(child_)
self.set_collaborationgraph(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'programlisting':
+ nodeName_ == 'programlisting':
obj_ = listingType.factory()
obj_.build(child_)
self.set_programlisting(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'location':
+ nodeName_ == 'location':
obj_ = locationType.factory()
obj_.build(child_)
self.set_location(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'listofallmembers':
+ nodeName_ == 'listofallmembers':
obj_ = listofallmembersType.factory()
obj_.build(child_)
self.set_listofallmembers(obj_)
@@ -847,11 +947,13 @@ class compounddefType(GeneratedsSuper):
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_)
@@ -862,10 +964,12 @@ class listofallmembersType(GeneratedsSuper):
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_, ))
- self.exportAttributes(outfile, level, namespace_, name_='listofallmembersType')
+ self.exportAttributes(outfile, level, namespace_,
+ name_='listofallmembersType')
if self.hasContent_():
outfile.write('>\n')
self.exportChildren(outfile, level + 1, namespace_, name_)
@@ -873,25 +977,31 @@ class listofallmembersType(GeneratedsSuper):
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')
@@ -905,17 +1015,20 @@ class listofallmembersType(GeneratedsSuper):
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 \
- nodeName_ == 'member':
+ nodeName_ == 'member':
obj_ = memberRefType.factory()
obj_.build(child_)
self.member.append(obj_)
@@ -925,6 +1038,7 @@ class listofallmembersType(GeneratedsSuper):
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
@@ -932,6 +1046,7 @@ class memberRefType(GeneratedsSuper):
self.ambiguityscope = ambiguityscope
self.scope = scope
self.name = name
+
def factory(*args_, **kwargs_):
if memberRefType.subclass:
return memberRefType.subclass(*args_, **kwargs_)
@@ -949,11 +1064,15 @@ class memberRefType(GeneratedsSuper):
def get_refid(self): return self.refid
def set_refid(self, refid): self.refid = refid
def get_ambiguityscope(self): return self.ambiguityscope
- def set_ambiguityscope(self, ambiguityscope): self.ambiguityscope = ambiguityscope
+
+ def set_ambiguityscope(
+ self, ambiguityscope): self.ambiguityscope = ambiguityscope
+
def export(self, outfile, level, namespace_='', name_='memberRefType', namespacedef_=''):
showIndent(outfile, level)
outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))
- self.exportAttributes(outfile, level, namespace_, name_='memberRefType')
+ self.exportAttributes(outfile, level, namespace_,
+ name_='memberRefType')
if self.hasContent_():
outfile.write('>\n')
self.exportChildren(outfile, level + 1, namespace_, name_)
@@ -961,35 +1080,44 @@ class memberRefType(GeneratedsSuper):
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:
- outfile.write(' refid=%s' % (self.format_string(quote_attrib(self.refid).encode(ExternalEncoding), input_name='refid'), ))
+ outfile.write(' refid=%s' % (self.format_string(quote_attrib(
+ self.refid).encode(ExternalEncoding), input_name='refid'), ))
if self.ambiguityscope is not None:
- outfile.write(' ambiguityscope=%s' % (self.format_string(quote_attrib(self.ambiguityscope).encode(ExternalEncoding), input_name='ambiguityscope'), ))
+ outfile.write(' ambiguityscope=%s' % (self.format_string(quote_attrib(
+ self.ambiguityscope).encode(ExternalEncoding), input_name='ambiguityscope'), ))
+
def exportChildren(self, outfile, level, namespace_='', name_='memberRefType'):
if self.scope is not None:
showIndent(outfile, level)
- outfile.write('<%sscope>%s</%sscope>\n' % (namespace_, self.format_string(quote_xml(self.scope).encode(ExternalEncoding), input_name='scope'), namespace_))
+ outfile.write('<%sscope>%s</%sscope>\n' % (namespace_, self.format_string(
+ quote_xml(self.scope).encode(ExternalEncoding), input_name='scope'), namespace_))
if self.name is not None:
showIndent(outfile, level)
- outfile.write('<%sname>%s</%sname>\n' % (namespace_, self.format_string(quote_xml(self.name).encode(ExternalEncoding), input_name='name'), namespace_))
+ outfile.write('<%sname>%s</%sname>\n' % (namespace_, self.format_string(
+ quote_xml(self.name).encode(ExternalEncoding), input_name='name'), namespace_))
+
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)
@@ -1003,17 +1131,22 @@ class memberRefType(GeneratedsSuper):
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)
- outfile.write('scope=%s,\n' % quote_python(self.scope).encode(ExternalEncoding))
+ outfile.write('scope=%s,\n' % quote_python(
+ self.scope).encode(ExternalEncoding))
showIndent(outfile, level)
- outfile.write('name=%s,\n' % quote_python(self.name).encode(ExternalEncoding))
+ outfile.write('name=%s,\n' % quote_python(
+ self.name).encode(ExternalEncoding))
+
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
@@ -1023,15 +1156,16 @@ class memberRefType(GeneratedsSuper):
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 \
- nodeName_ == 'scope':
+ nodeName_ == 'scope':
scope_ = ''
for text__content_ in child_.childNodes:
scope_ += text__content_.nodeValue
self.scope = scope_
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'name':
+ nodeName_ == 'name':
name_ = ''
for text__content_ in child_.childNodes:
name_ += text__content_.nodeValue
@@ -1042,8 +1176,10 @@ class memberRefType(GeneratedsSuper):
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_)
@@ -1052,6 +1188,7 @@ class scope(GeneratedsSuper):
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_, ))
@@ -1063,33 +1200,40 @@ class scope(GeneratedsSuper):
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'):
- if self.valueOf_.find('![CDATA')>-1:
- value=quote_xml('%s' % self.valueOf_)
- value=value.replace('![CDATA','<![CDATA')
- value=value.replace(']]',']]>')
+ if self.valueOf_.find('![CDATA') > -1:
+ value = quote_xml('%s' % self.valueOf_)
+ value = value.replace('![CDATA', '<![CDATA')
+ value = value.replace(']]', ']]>')
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)
@@ -1097,21 +1241,25 @@ class scope(GeneratedsSuper):
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:
- self.valueOf_ += '![CDATA['+child_.nodeValue+']]'
+ self.valueOf_ += '![CDATA[' + child_.nodeValue + ']]'
# 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_)
@@ -1120,6 +1268,7 @@ class name(GeneratedsSuper):
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_, ))
@@ -1131,33 +1280,40 @@ class name(GeneratedsSuper):
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'):
- if self.valueOf_.find('![CDATA')>-1:
- value=quote_xml('%s' % self.valueOf_)
- value=value.replace('![CDATA','<![CDATA')
- value=value.replace(']]',']]>')
+ if self.valueOf_.find('![CDATA') > -1:
+ value = quote_xml('%s' % self.valueOf_)
+ value = value.replace('![CDATA', '<![CDATA')
+ value = value.replace(']]', ']]>')
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)
@@ -1165,19 +1321,22 @@ class name(GeneratedsSuper):
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:
- self.valueOf_ += '![CDATA['+child_.nodeValue+']]'
+ self.valueOf_ += '![CDATA[' + child_.nodeValue + ']]'
# 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
@@ -1190,6 +1349,7 @@ class compoundRefType(GeneratedsSuper):
self.content_ = []
else:
self.content_ = content_
+
def factory(*args_, **kwargs_):
if compoundRefType.subclass:
return compoundRefType.subclass(*args_, **kwargs_)
@@ -1204,40 +1364,48 @@ class compoundRefType(GeneratedsSuper):
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_, ))
- self.exportAttributes(outfile, level, namespace_, name_='compoundRefType')
+ self.exportAttributes(outfile, level, namespace_,
+ name_='compoundRefType')
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:
- outfile.write(' refid=%s' % (self.format_string(quote_attrib(self.refid).encode(ExternalEncoding), input_name='refid'), ))
+ outfile.write(' refid=%s' % (self.format_string(quote_attrib(
+ self.refid).encode(ExternalEncoding), input_name='refid'), ))
+
def exportChildren(self, outfile, level, namespace_='', name_='compoundRefType'):
- if self.valueOf_.find('![CDATA')>-1:
- value=quote_xml('%s' % self.valueOf_)
- value=value.replace('![CDATA','<![CDATA')
- value=value.replace(']]',']]>')
+ if self.valueOf_.find('![CDATA') > -1:
+ value = quote_xml('%s' % self.valueOf_)
+ value = value.replace('![CDATA', '<![CDATA')
+ value = value.replace(']]', ']]>')
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)
@@ -1248,9 +1416,11 @@ class compoundRefType(GeneratedsSuper):
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)
@@ -1258,6 +1428,7 @@ class compoundRefType(GeneratedsSuper):
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
@@ -1265,21 +1436,23 @@ class compoundRefType(GeneratedsSuper):
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,
- MixedContainer.TypeNone, '', child_.nodeValue)
+ MixedContainer.TypeNone, '', child_.nodeValue)
self.content_.append(obj_)
if child_.nodeType == Node.TEXT_NODE:
self.valueOf_ += child_.nodeValue
elif child_.nodeType == Node.CDATA_SECTION_NODE:
- self.valueOf_ += '![CDATA['+child_.nodeValue+']]'
+ self.valueOf_ += '![CDATA[' + child_.nodeValue + ']]'
# 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:
@@ -1290,6 +1463,7 @@ class reimplementType(GeneratedsSuper):
self.content_ = []
else:
self.content_ = content_
+
def factory(*args_, **kwargs_):
if reimplementType.subclass:
return reimplementType.subclass(*args_, **kwargs_)
@@ -1300,43 +1474,53 @@ class reimplementType(GeneratedsSuper):
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_, ))
- self.exportAttributes(outfile, level, namespace_, name_='reimplementType')
+ self.exportAttributes(outfile, level, namespace_,
+ name_='reimplementType')
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:
- outfile.write(' refid=%s' % (self.format_string(quote_attrib(self.refid).encode(ExternalEncoding), input_name='refid'), ))
+ outfile.write(' refid=%s' % (self.format_string(quote_attrib(
+ self.refid).encode(ExternalEncoding), input_name='refid'), ))
+
def exportChildren(self, outfile, level, namespace_='', name_='reimplementType'):
- if self.valueOf_.find('![CDATA')>-1:
- value=quote_xml('%s' % self.valueOf_)
- value=value.replace('![CDATA','<![CDATA')
- value=value.replace(']]',']]>')
+ if self.valueOf_.find('![CDATA') > -1:
+ value = quote_xml('%s' % self.valueOf_)
+ value = value.replace('![CDATA', '<![CDATA')
+ value = value.replace(']]', ']]>')
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)
@@ -1344,24 +1528,27 @@ class reimplementType(GeneratedsSuper):
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,
- MixedContainer.TypeNone, '', child_.nodeValue)
+ MixedContainer.TypeNone, '', child_.nodeValue)
self.content_.append(obj_)
if child_.nodeType == Node.TEXT_NODE:
self.valueOf_ += child_.nodeValue
elif child_.nodeType == Node.CDATA_SECTION_NODE:
- self.valueOf_ += '![CDATA['+child_.nodeValue+']]'
+ self.valueOf_ += '![CDATA[' + child_.nodeValue + ']]'
# 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
@@ -1373,6 +1560,7 @@ class incType(GeneratedsSuper):
self.content_ = []
else:
self.content_ = content_
+
def factory(*args_, **kwargs_):
if incType.subclass:
return incType.subclass(*args_, **kwargs_)
@@ -1385,6 +1573,7 @@ class incType(GeneratedsSuper):
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_, ))
@@ -1392,31 +1581,37 @@ class incType(GeneratedsSuper):
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:
- outfile.write(' refid=%s' % (self.format_string(quote_attrib(self.refid).encode(ExternalEncoding), input_name='refid'), ))
+ outfile.write(' refid=%s' % (self.format_string(quote_attrib(
+ self.refid).encode(ExternalEncoding), input_name='refid'), ))
+
def exportChildren(self, outfile, level, namespace_='', name_='incType'):
- if self.valueOf_.find('![CDATA')>-1:
- value=quote_xml('%s' % self.valueOf_)
- value=value.replace('![CDATA','<![CDATA')
- value=value.replace(']]',']]>')
+ if self.valueOf_.find('![CDATA') > -1:
+ value = quote_xml('%s' % self.valueOf_)
+ value = value.replace('![CDATA', '<![CDATA')
+ value = value.replace(']]', ']]>')
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)
@@ -1424,9 +1619,11 @@ class incType(GeneratedsSuper):
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)
@@ -1434,26 +1631,29 @@ class incType(GeneratedsSuper):
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,
- MixedContainer.TypeNone, '', child_.nodeValue)
+ MixedContainer.TypeNone, '', child_.nodeValue)
self.content_.append(obj_)
if child_.nodeType == Node.TEXT_NODE:
self.valueOf_ += child_.nodeValue
elif child_.nodeType == Node.CDATA_SECTION_NODE:
- self.valueOf_ += '![CDATA['+child_.nodeValue+']]'
+ self.valueOf_ += '![CDATA[' + child_.nodeValue + ']]'
# 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
@@ -1465,6 +1665,7 @@ class refType(GeneratedsSuper):
self.content_ = []
else:
self.content_ = content_
+
def factory(*args_, **kwargs_):
if refType.subclass:
return refType.subclass(*args_, **kwargs_)
@@ -1477,6 +1678,7 @@ class refType(GeneratedsSuper):
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_, ))
@@ -1484,31 +1686,37 @@ class refType(GeneratedsSuper):
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:
- outfile.write(' refid=%s' % (self.format_string(quote_attrib(self.refid).encode(ExternalEncoding), input_name='refid'), ))
+ outfile.write(' refid=%s' % (self.format_string(quote_attrib(
+ self.refid).encode(ExternalEncoding), input_name='refid'), ))
+
def exportChildren(self, outfile, level, namespace_='', name_='refType'):
- if self.valueOf_.find('![CDATA')>-1:
- value=quote_xml('%s' % self.valueOf_)
- value=value.replace('![CDATA','<![CDATA')
- value=value.replace(']]',']]>')
+ if self.valueOf_.find('![CDATA') > -1:
+ value = quote_xml('%s' % self.valueOf_)
+ value = value.replace('![CDATA', '<![CDATA')
+ value = value.replace(']]', ']]>')
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)
@@ -1516,9 +1724,11 @@ class refType(GeneratedsSuper):
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)
@@ -1526,26 +1736,29 @@ class refType(GeneratedsSuper):
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,
- MixedContainer.TypeNone, '', child_.nodeValue)
+ MixedContainer.TypeNone, '', child_.nodeValue)
self.content_.append(obj_)
if child_.nodeType == Node.TEXT_NODE:
self.valueOf_ += child_.nodeValue
elif child_.nodeType == Node.CDATA_SECTION_NODE:
- self.valueOf_ += '![CDATA['+child_.nodeValue+']]'
+ self.valueOf_ += '![CDATA[' + child_.nodeValue + ']]'
# 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
@@ -1558,6 +1771,7 @@ class refTextType(GeneratedsSuper):
self.content_ = []
else:
self.content_ = content_
+
def factory(*args_, **kwargs_):
if refTextType.subclass:
return refTextType.subclass(*args_, **kwargs_)
@@ -1572,6 +1786,7 @@ class refTextType(GeneratedsSuper):
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_, ))
@@ -1579,33 +1794,40 @@ class refTextType(GeneratedsSuper):
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:
- outfile.write(' refid=%s' % (self.format_string(quote_attrib(self.refid).encode(ExternalEncoding), input_name='refid'), ))
+ outfile.write(' refid=%s' % (self.format_string(quote_attrib(
+ self.refid).encode(ExternalEncoding), input_name='refid'), ))
if self.kindref is not None:
outfile.write(' kindref=%s' % (quote_attrib(self.kindref), ))
if self.external is not None:
- outfile.write(' external=%s' % (self.format_string(quote_attrib(self.external).encode(ExternalEncoding), input_name='external'), ))
+ outfile.write(' external=%s' % (self.format_string(quote_attrib(
+ self.external).encode(ExternalEncoding), input_name='external'), ))
+
def exportChildren(self, outfile, level, namespace_='', name_='refTextType'):
- if self.valueOf_.find('![CDATA')>-1:
- value=quote_xml('%s' % self.valueOf_)
- value=value.replace('![CDATA','<![CDATA')
- value=value.replace(']]',']]>')
+ if self.valueOf_.find('![CDATA') > -1:
+ value = quote_xml('%s' % self.valueOf_)
+ value = value.replace('![CDATA', '<![CDATA')
+ value = value.replace(']]', ']]>')
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)
@@ -1616,9 +1838,11 @@ class refTextType(GeneratedsSuper):
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)
@@ -1626,6 +1850,7 @@ class refTextType(GeneratedsSuper):
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
@@ -1633,21 +1858,23 @@ class refTextType(GeneratedsSuper):
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,
- MixedContainer.TypeNone, '', child_.nodeValue)
+ MixedContainer.TypeNone, '', child_.nodeValue)
self.content_.append(obj_)
if child_.nodeType == Node.TEXT_NODE:
self.valueOf_ += child_.nodeValue
elif child_.nodeType == Node.CDATA_SECTION_NODE:
- self.valueOf_ += '![CDATA['+child_.nodeValue+']]'
+ self.valueOf_ += '![CDATA[' + child_.nodeValue + ']]'
# 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
@@ -1656,6 +1883,7 @@ class sectiondefType(GeneratedsSuper):
self.memberdef = []
else:
self.memberdef = memberdef
+
def factory(*args_, **kwargs_):
if sectiondefType.subclass:
return sectiondefType.subclass(*args_, **kwargs_)
@@ -1672,10 +1900,12 @@ class sectiondefType(GeneratedsSuper):
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_, ))
- self.exportAttributes(outfile, level, namespace_, name_='sectiondefType')
+ self.exportAttributes(outfile, level, namespace_,
+ name_='sectiondefType')
if self.hasContent_():
outfile.write('>\n')
self.exportChildren(outfile, level + 1, namespace_, name_)
@@ -1683,38 +1913,47 @@ class sectiondefType(GeneratedsSuper):
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)
- outfile.write('<%sheader>%s</%sheader>\n' % (namespace_, self.format_string(quote_xml(self.header).encode(ExternalEncoding), input_name='header'), namespace_))
+ outfile.write('<%sheader>%s</%sheader>\n' % (namespace_, self.format_string(
+ quote_xml(self.header).encode(ExternalEncoding), input_name='header'), namespace_))
if self.description:
- self.description.export(outfile, level, namespace_, name_='description')
+ self.description.export(
+ outfile, level, namespace_, name_='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)
- outfile.write('header=%s,\n' % quote_python(self.header).encode(ExternalEncoding))
+ outfile.write('header=%s,\n' % quote_python(
+ self.header).encode(ExternalEncoding))
if self.description:
showIndent(outfile, level)
outfile.write('description=model_.descriptionType(\n')
@@ -1733,29 +1972,32 @@ class sectiondefType(GeneratedsSuper):
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 \
- nodeName_ == 'header':
+ nodeName_ == 'header':
header_ = ''
for text__content_ in child_.childNodes:
header_ += text__content_.nodeValue
self.header = header_
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'description':
+ nodeName_ == 'description':
obj_ = descriptionType.factory()
obj_.build(child_)
self.set_description(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'memberdef':
+ nodeName_ == 'memberdef':
obj_ = memberdefType.factory()
obj_.build(child_)
self.memberdef.append(obj_)
@@ -1765,6 +2007,7 @@ class sectiondefType(GeneratedsSuper):
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
@@ -1825,6 +2068,7 @@ class memberdefType(GeneratedsSuper):
self.referencedby = []
else:
self.referencedby = referencedby
+
def factory(*args_, **kwargs_):
if memberdefType.subclass:
return memberdefType.subclass(*args_, **kwargs_)
@@ -1832,7 +2076,9 @@ class memberdefType(GeneratedsSuper):
return memberdefType(*args_, **kwargs_)
factory = staticmethod(factory)
def get_templateparamlist(self): return self.templateparamlist
- def set_templateparamlist(self, templateparamlist): self.templateparamlist = templateparamlist
+ def set_templateparamlist(
+ self, templateparamlist): self.templateparamlist = templateparamlist
+
def get_type(self): return self.type_
def set_type(self, type_): self.type_ = type_
def get_definition(self): return self.definition
@@ -1850,11 +2096,17 @@ class memberdefType(GeneratedsSuper):
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 insert_reimplements(self, index, value): self.reimplements[index] = value
+ def insert_reimplements(
+ self, index, value): self.reimplements[index] = value
+
def get_reimplementedby(self): return self.reimplementedby
- def set_reimplementedby(self, reimplementedby): self.reimplementedby = reimplementedby
+ def set_reimplementedby(
+ self, reimplementedby): self.reimplementedby = reimplementedby
+
def add_reimplementedby(self, value): self.reimplementedby.append(value)
- def insert_reimplementedby(self, index, value): self.reimplementedby[index] = value
+ def insert_reimplementedby(
+ self, index, value): self.reimplementedby[index] = 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)
@@ -1868,11 +2120,17 @@ class memberdefType(GeneratedsSuper):
def get_exceptions(self): return self.exceptions
def set_exceptions(self, exceptions): self.exceptions = exceptions
def get_briefdescription(self): return self.briefdescription
- def set_briefdescription(self, briefdescription): self.briefdescription = briefdescription
+ def set_briefdescription(
+ self, briefdescription): self.briefdescription = briefdescription
+
def get_detaileddescription(self): return self.detaileddescription
- def set_detaileddescription(self, detaileddescription): self.detaileddescription = detaileddescription
+ def set_detaileddescription(
+ self, detaileddescription): self.detaileddescription = detaileddescription
+
def get_inbodydescription(self): return self.inbodydescription
- def set_inbodydescription(self, inbodydescription): self.inbodydescription = inbodydescription
+ def set_inbodydescription(
+ self, inbodydescription): self.inbodydescription = inbodydescription
+
def get_location(self): return self.location
def set_location(self, location): self.location = location
def get_references(self): return self.references
@@ -1882,7 +2140,9 @@ class memberdefType(GeneratedsSuper):
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 insert_referencedby(self, index, value): self.referencedby[index] = value
+ def insert_referencedby(
+ self, index, value): self.referencedby[index] = value
+
def get_initonly(self): return self.initonly
def set_initonly(self, initonly): self.initonly = initonly
def get_kind(self): return self.kind
@@ -1925,10 +2185,12 @@ class memberdefType(GeneratedsSuper):
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_, ))
- self.exportAttributes(outfile, level, namespace_, name_='memberdefType')
+ self.exportAttributes(outfile, level, namespace_,
+ name_='memberdefType')
if self.hasContent_():
outfile.write('>\n')
self.exportChildren(outfile, level + 1, namespace_, name_)
@@ -1936,6 +2198,7 @@ class memberdefType(GeneratedsSuper):
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), ))
@@ -1978,54 +2241,73 @@ class memberdefType(GeneratedsSuper):
if self.settable is not None:
outfile.write(' settable=%s' % (quote_attrib(self.settable), ))
if self.id is not None:
- outfile.write(' id=%s' % (self.format_string(quote_attrib(self.id).encode(ExternalEncoding), input_name='id'), ))
+ outfile.write(' id=%s' % (self.format_string(quote_attrib(
+ self.id).encode(ExternalEncoding), input_name='id'), ))
+
def exportChildren(self, outfile, level, namespace_='', name_='memberdefType'):
if self.templateparamlist:
- self.templateparamlist.export(outfile, level, namespace_, name_='templateparamlist')
+ self.templateparamlist.export(
+ outfile, level, namespace_, name_='templateparamlist')
if self.type_:
self.type_.export(outfile, level, namespace_, name_='type')
if self.definition is not None:
showIndent(outfile, level)
- outfile.write('<%sdefinition>%s</%sdefinition>\n' % (namespace_, self.format_string(quote_xml(self.definition).encode(ExternalEncoding), input_name='definition'), namespace_))
+ outfile.write('<%sdefinition>%s</%sdefinition>\n' % (namespace_, self.format_string(
+ quote_xml(self.definition).encode(ExternalEncoding), input_name='definition'), namespace_))
if self.argsstring is not None:
showIndent(outfile, level)
- outfile.write('<%sargsstring>%s</%sargsstring>\n' % (namespace_, self.format_string(quote_xml(self.argsstring).encode(ExternalEncoding), input_name='argsstring'), namespace_))
+ outfile.write('<%sargsstring>%s</%sargsstring>\n' % (namespace_, self.format_string(
+ quote_xml(self.argsstring).encode(ExternalEncoding), input_name='argsstring'), namespace_))
if self.name is not None:
showIndent(outfile, level)
- outfile.write('<%sname>%s</%sname>\n' % (namespace_, self.format_string(quote_xml(self.name).encode(ExternalEncoding), input_name='name'), namespace_))
+ outfile.write('<%sname>%s</%sname>\n' % (namespace_, self.format_string(
+ quote_xml(self.name).encode(ExternalEncoding), input_name='name'), namespace_))
if self.read is not None:
showIndent(outfile, level)
- outfile.write('<%sread>%s</%sread>\n' % (namespace_, self.format_string(quote_xml(self.read).encode(ExternalEncoding), input_name='read'), namespace_))
+ outfile.write('<%sread>%s</%sread>\n' % (namespace_, self.format_string(
+ quote_xml(self.read).encode(ExternalEncoding), input_name='read'), namespace_))
if self.write is not None:
showIndent(outfile, level)
- outfile.write('<%swrite>%s</%swrite>\n' % (namespace_, self.format_string(quote_xml(self.write).encode(ExternalEncoding), input_name='write'), namespace_))
+ outfile.write('<%swrite>%s</%swrite>\n' % (namespace_, self.format_string(
+ quote_xml(self.write).encode(ExternalEncoding), input_name='write'), namespace_))
if self.bitfield is not None:
showIndent(outfile, level)
- outfile.write('<%sbitfield>%s</%sbitfield>\n' % (namespace_, self.format_string(quote_xml(self.bitfield).encode(ExternalEncoding), input_name='bitfield'), namespace_))
+ outfile.write('<%sbitfield>%s</%sbitfield>\n' % (namespace_, self.format_string(
+ quote_xml(self.bitfield).encode(ExternalEncoding), input_name='bitfield'), namespace_))
for reimplements_ in self.reimplements:
- reimplements_.export(outfile, level, namespace_, name_='reimplements')
+ reimplements_.export(
+ outfile, level, namespace_, name_='reimplements')
for reimplementedby_ in self.reimplementedby:
- reimplementedby_.export(outfile, level, namespace_, name_='reimplementedby')
+ reimplementedby_.export(
+ outfile, level, namespace_, name_='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:
- self.initializer.export(outfile, level, namespace_, name_='initializer')
+ self.initializer.export(
+ outfile, level, namespace_, name_='initializer')
if self.exceptions:
- self.exceptions.export(outfile, level, namespace_, name_='exceptions')
+ self.exceptions.export(
+ outfile, level, namespace_, name_='exceptions')
if self.briefdescription:
- self.briefdescription.export(outfile, level, namespace_, name_='briefdescription')
+ self.briefdescription.export(
+ outfile, level, namespace_, name_='briefdescription')
if self.detaileddescription:
- self.detaileddescription.export(outfile, level, namespace_, name_='detaileddescription')
+ self.detaileddescription.export(
+ outfile, level, namespace_, name_='detaileddescription')
if self.inbodydescription:
- self.inbodydescription.export(outfile, level, namespace_, name_='inbodydescription')
+ self.inbodydescription.export(
+ outfile, level, namespace_, name_='inbodydescription')
if self.location:
- self.location.export(outfile, level, namespace_, name_='location', )
+ self.location.export(
+ outfile, level, namespace_, name_='location', )
for references_ in self.references:
references_.export(outfile, level, namespace_, name_='references')
for referencedby_ in self.referencedby:
- referencedby_.export(outfile, level, namespace_, name_='referencedby')
+ referencedby_.export(
+ outfile, level, namespace_, name_='referencedby')
+
def hasContent_(self):
if (
self.templateparamlist is not None or
@@ -2048,15 +2330,17 @@ class memberdefType(GeneratedsSuper):
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)
@@ -2121,11 +2405,13 @@ class memberdefType(GeneratedsSuper):
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')
- self.templateparamlist.exportLiteral(outfile, level, name_='templateparamlist')
+ self.templateparamlist.exportLiteral(
+ outfile, level, name_='templateparamlist')
showIndent(outfile, level)
outfile.write('),\n')
if self.type_:
@@ -2135,17 +2421,23 @@ class memberdefType(GeneratedsSuper):
showIndent(outfile, level)
outfile.write('),\n')
showIndent(outfile, level)
- outfile.write('definition=%s,\n' % quote_python(self.definition).encode(ExternalEncoding))
+ outfile.write('definition=%s,\n' % quote_python(
+ self.definition).encode(ExternalEncoding))
showIndent(outfile, level)
- outfile.write('argsstring=%s,\n' % quote_python(self.argsstring).encode(ExternalEncoding))
+ outfile.write('argsstring=%s,\n' % quote_python(
+ self.argsstring).encode(ExternalEncoding))
showIndent(outfile, level)
- outfile.write('name=%s,\n' % quote_python(self.name).encode(ExternalEncoding))
+ outfile.write('name=%s,\n' % quote_python(
+ self.name).encode(ExternalEncoding))
showIndent(outfile, level)
- outfile.write('read=%s,\n' % quote_python(self.read).encode(ExternalEncoding))
+ outfile.write('read=%s,\n' % quote_python(
+ self.read).encode(ExternalEncoding))
showIndent(outfile, level)
- outfile.write('write=%s,\n' % quote_python(self.write).encode(ExternalEncoding))
+ outfile.write('write=%s,\n' % quote_python(
+ self.write).encode(ExternalEncoding))
showIndent(outfile, level)
- outfile.write('bitfield=%s,\n' % quote_python(self.bitfield).encode(ExternalEncoding))
+ outfile.write('bitfield=%s,\n' % quote_python(
+ self.bitfield).encode(ExternalEncoding))
showIndent(outfile, level)
outfile.write('reimplements=[\n')
level += 1
@@ -2164,7 +2456,8 @@ class memberdefType(GeneratedsSuper):
for reimplementedby in self.reimplementedby:
showIndent(outfile, level)
outfile.write('model_.reimplementedby(\n')
- reimplementedby.exportLiteral(outfile, level, name_='reimplementedby')
+ reimplementedby.exportLiteral(
+ outfile, level, name_='reimplementedby')
showIndent(outfile, level)
outfile.write('),\n')
level -= 1
@@ -2209,19 +2502,22 @@ class memberdefType(GeneratedsSuper):
if self.briefdescription:
showIndent(outfile, level)
outfile.write('briefdescription=model_.descriptionType(\n')
- self.briefdescription.exportLiteral(outfile, level, name_='briefdescription')
+ self.briefdescription.exportLiteral(
+ outfile, level, name_='briefdescription')
showIndent(outfile, level)
outfile.write('),\n')
if self.detaileddescription:
showIndent(outfile, level)
outfile.write('detaileddescription=model_.descriptionType(\n')
- self.detaileddescription.exportLiteral(outfile, level, name_='detaileddescription')
+ self.detaileddescription.exportLiteral(
+ outfile, level, name_='detaileddescription')
showIndent(outfile, level)
outfile.write('),\n')
if self.inbodydescription:
showIndent(outfile, level)
outfile.write('inbodydescription=model_.descriptionType(\n')
- self.inbodydescription.exportLiteral(outfile, level, name_='inbodydescription')
+ self.inbodydescription.exportLiteral(
+ outfile, level, name_='inbodydescription')
showIndent(outfile, level)
outfile.write('),\n')
if self.location:
@@ -2254,12 +2550,14 @@ class memberdefType(GeneratedsSuper):
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
@@ -2303,110 +2601,111 @@ class memberdefType(GeneratedsSuper):
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 \
- nodeName_ == 'templateparamlist':
+ nodeName_ == 'templateparamlist':
obj_ = templateparamlistType.factory()
obj_.build(child_)
self.set_templateparamlist(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'type':
+ nodeName_ == 'type':
obj_ = linkedTextType.factory()
obj_.build(child_)
self.set_type(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'definition':
+ nodeName_ == 'definition':
definition_ = ''
for text__content_ in child_.childNodes:
definition_ += text__content_.nodeValue
self.definition = definition_
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'argsstring':
+ nodeName_ == 'argsstring':
argsstring_ = ''
for text__content_ in child_.childNodes:
argsstring_ += text__content_.nodeValue
self.argsstring = argsstring_
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'name':
+ nodeName_ == 'name':
name_ = ''
for text__content_ in child_.childNodes:
name_ += text__content_.nodeValue
self.name = name_
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'read':
+ nodeName_ == 'read':
read_ = ''
for text__content_ in child_.childNodes:
read_ += text__content_.nodeValue
self.read = read_
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'write':
+ nodeName_ == 'write':
write_ = ''
for text__content_ in child_.childNodes:
write_ += text__content_.nodeValue
self.write = write_
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'bitfield':
+ nodeName_ == 'bitfield':
bitfield_ = ''
for text__content_ in child_.childNodes:
bitfield_ += text__content_.nodeValue
self.bitfield = bitfield_
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'reimplements':
+ nodeName_ == 'reimplements':
obj_ = reimplementType.factory()
obj_.build(child_)
self.reimplements.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'reimplementedby':
+ nodeName_ == 'reimplementedby':
obj_ = reimplementType.factory()
obj_.build(child_)
self.reimplementedby.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'param':
+ nodeName_ == 'param':
obj_ = paramType.factory()
obj_.build(child_)
self.param.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'enumvalue':
+ nodeName_ == 'enumvalue':
obj_ = enumvalueType.factory()
obj_.build(child_)
self.enumvalue.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'initializer':
+ nodeName_ == 'initializer':
obj_ = linkedTextType.factory()
obj_.build(child_)
self.set_initializer(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'exceptions':
+ nodeName_ == 'exceptions':
obj_ = linkedTextType.factory()
obj_.build(child_)
self.set_exceptions(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'briefdescription':
+ nodeName_ == 'briefdescription':
obj_ = descriptionType.factory()
obj_.build(child_)
self.set_briefdescription(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'detaileddescription':
+ nodeName_ == 'detaileddescription':
obj_ = descriptionType.factory()
obj_.build(child_)
self.set_detaileddescription(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'inbodydescription':
+ nodeName_ == 'inbodydescription':
obj_ = descriptionType.factory()
obj_.build(child_)
self.set_inbodydescription(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'location':
+ nodeName_ == 'location':
obj_ = locationType.factory()
obj_.build(child_)
self.set_location(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'references':
+ nodeName_ == 'references':
obj_ = referenceType.factory()
obj_.build(child_)
self.references.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'referencedby':
+ nodeName_ == 'referencedby':
obj_ = referenceType.factory()
obj_.build(child_)
self.referencedby.append(obj_)
@@ -2416,8 +2715,10 @@ class memberdefType(GeneratedsSuper):
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_)
@@ -2426,6 +2727,7 @@ class definition(GeneratedsSuper):
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_, ))
@@ -2437,33 +2739,40 @@ class definition(GeneratedsSuper):
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'):
- if self.valueOf_.find('![CDATA')>-1:
- value=quote_xml('%s' % self.valueOf_)
- value=value.replace('![CDATA','<![CDATA')
- value=value.replace(']]',']]>')
+ if self.valueOf_.find('![CDATA') > -1:
+ value = quote_xml('%s' % self.valueOf_)
+ value = value.replace('![CDATA', '<![CDATA')
+ value = value.replace(']]', ']]>')
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)
@@ -2471,21 +2780,25 @@ class definition(GeneratedsSuper):
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:
- self.valueOf_ += '![CDATA['+child_.nodeValue+']]'
+ self.valueOf_ += '![CDATA[' + child_.nodeValue + ']]'
# 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_)
@@ -2494,6 +2807,7 @@ class argsstring(GeneratedsSuper):
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_, ))
@@ -2505,33 +2819,40 @@ class argsstring(GeneratedsSuper):
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'):
- if self.valueOf_.find('![CDATA')>-1:
- value=quote_xml('%s' % self.valueOf_)
- value=value.replace('![CDATA','<![CDATA')
- value=value.replace(']]',']]>')
+ if self.valueOf_.find('![CDATA') > -1:
+ value = quote_xml('%s' % self.valueOf_)
+ value = value.replace('![CDATA', '<![CDATA')
+ value = value.replace(']]', ']]>')
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)
@@ -2539,21 +2860,25 @@ class argsstring(GeneratedsSuper):
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:
- self.valueOf_ += '![CDATA['+child_.nodeValue+']]'
+ self.valueOf_ += '![CDATA[' + child_.nodeValue + ']]'
# 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_)
@@ -2562,6 +2887,7 @@ class read(GeneratedsSuper):
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_, ))
@@ -2573,33 +2899,40 @@ class read(GeneratedsSuper):
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'):
- if self.valueOf_.find('![CDATA')>-1:
- value=quote_xml('%s' % self.valueOf_)
- value=value.replace('![CDATA','<![CDATA')
- value=value.replace(']]',']]>')
+ if self.valueOf_.find('![CDATA') > -1:
+ value = quote_xml('%s' % self.valueOf_)
+ value = value.replace('![CDATA', '<![CDATA')
+ value = value.replace(']]', ']]>')
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)
@@ -2607,21 +2940,25 @@ class read(GeneratedsSuper):
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:
- self.valueOf_ += '![CDATA['+child_.nodeValue+']]'
+ self.valueOf_ += '![CDATA[' + child_.nodeValue + ']]'
# 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_)
@@ -2630,6 +2967,7 @@ class write(GeneratedsSuper):
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_, ))
@@ -2641,33 +2979,40 @@ class write(GeneratedsSuper):
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'):
- if self.valueOf_.find('![CDATA')>-1:
- value=quote_xml('%s' % self.valueOf_)
- value=value.replace('![CDATA','<![CDATA')
- value=value.replace(']]',']]>')
+ if self.valueOf_.find('![CDATA') > -1:
+ value = quote_xml('%s' % self.valueOf_)
+ value = value.replace('![CDATA', '<![CDATA')
+ value = value.replace(']]', ']]>')
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)
@@ -2675,21 +3020,25 @@ class write(GeneratedsSuper):
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:
- self.valueOf_ += '![CDATA['+child_.nodeValue+']]'
+ self.valueOf_ += '![CDATA[' + child_.nodeValue + ']]'
# 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_)
@@ -2698,6 +3047,7 @@ class bitfield(GeneratedsSuper):
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_, ))
@@ -2709,33 +3059,40 @@ class bitfield(GeneratedsSuper):
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'):
- if self.valueOf_.find('![CDATA')>-1:
- value=quote_xml('%s' % self.valueOf_)
- value=value.replace('![CDATA','<![CDATA')
- value=value.replace(']]',']]>')
+ if self.valueOf_.find('![CDATA') > -1:
+ value = quote_xml('%s' % self.valueOf_)
+ value = value.replace('![CDATA', '<![CDATA')
+ value = value.replace(']]', ']]>')
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)
@@ -2743,19 +3100,22 @@ class bitfield(GeneratedsSuper):
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:
- self.valueOf_ += '![CDATA['+child_.nodeValue+']]'
+ self.valueOf_ += '![CDATA[' + child_.nodeValue + ']]'
# 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
@@ -2765,6 +3125,7 @@ class descriptionType(GeneratedsSuper):
self.content_ = []
else:
self.content_ = content_
+
def factory(*args_, **kwargs_):
if descriptionType.subclass:
return descriptionType.subclass(*args_, **kwargs_)
@@ -2783,35 +3144,43 @@ class descriptionType(GeneratedsSuper):
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_, ))
- self.exportAttributes(outfile, level, namespace_, name_='descriptionType')
+ self.exportAttributes(outfile, level, namespace_,
+ name_='descriptionType')
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')
@@ -2837,46 +3206,49 @@ class descriptionType(GeneratedsSuper):
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 \
- nodeName_ == 'title':
+ nodeName_ == 'title':
childobj_ = docTitleType.factory()
childobj_.build(child_)
obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
- MixedContainer.TypeNone, 'title', childobj_)
+ MixedContainer.TypeNone, 'title', childobj_)
self.content_.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'para':
+ nodeName_ == 'para':
childobj_ = docParaType.factory()
childobj_.build(child_)
obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
- MixedContainer.TypeNone, 'para', childobj_)
+ MixedContainer.TypeNone, 'para', childobj_)
self.content_.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'sect1':
+ nodeName_ == 'sect1':
childobj_ = docSect1Type.factory()
childobj_.build(child_)
obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
- MixedContainer.TypeNone, 'sect1', childobj_)
+ MixedContainer.TypeNone, 'sect1', childobj_)
self.content_.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'internal':
+ nodeName_ == 'internal':
childobj_ = docInternalType.factory()
childobj_.build(child_)
obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
- MixedContainer.TypeNone, 'internal', childobj_)
+ MixedContainer.TypeNone, 'internal', childobj_)
self.content_.append(obj_)
elif child_.nodeType == Node.TEXT_NODE:
obj_ = self.mixedclass_(MixedContainer.CategoryText,
- MixedContainer.TypeNone, '', child_.nodeValue)
+ MixedContainer.TypeNone, '', child_.nodeValue)
self.content_.append(obj_)
# end class descriptionType
@@ -2884,6 +3256,7 @@ class descriptionType(GeneratedsSuper):
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
@@ -2895,6 +3268,7 @@ class enumvalueType(GeneratedsSuper):
self.content_ = []
else:
self.content_ = content_
+
def factory(*args_, **kwargs_):
if enumvalueType.subclass:
return enumvalueType.subclass(*args_, **kwargs_)
@@ -2906,43 +3280,55 @@ class enumvalueType(GeneratedsSuper):
def get_initializer(self): return self.initializer
def set_initializer(self, initializer): self.initializer = initializer
def get_briefdescription(self): return self.briefdescription
- def set_briefdescription(self, briefdescription): self.briefdescription = briefdescription
+ def set_briefdescription(
+ self, briefdescription): self.briefdescription = briefdescription
+
def get_detaileddescription(self): return self.detaileddescription
- def set_detaileddescription(self, detaileddescription): self.detaileddescription = detaileddescription
+ def set_detaileddescription(
+ self, detaileddescription): self.detaileddescription = 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_, ))
- self.exportAttributes(outfile, level, namespace_, name_='enumvalueType')
+ self.exportAttributes(outfile, level, namespace_,
+ name_='enumvalueType')
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:
- outfile.write(' id=%s' % (self.format_string(quote_attrib(self.id).encode(ExternalEncoding), input_name='id'), ))
+ outfile.write(' id=%s' % (self.format_string(quote_attrib(
+ self.id).encode(ExternalEncoding), input_name='id'), ))
+
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)
@@ -2950,6 +3336,7 @@ class enumvalueType(GeneratedsSuper):
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')
@@ -2975,51 +3362,54 @@ class enumvalueType(GeneratedsSuper):
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 \
- nodeName_ == 'name':
+ nodeName_ == 'name':
value_ = []
for text_ in child_.childNodes:
value_.append(text_.nodeValue)
valuestr_ = ''.join(value_)
obj_ = self.mixedclass_(MixedContainer.CategorySimple,
- MixedContainer.TypeString, 'name', valuestr_)
+ MixedContainer.TypeString, 'name', valuestr_)
self.content_.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'initializer':
+ nodeName_ == 'initializer':
childobj_ = linkedTextType.factory()
childobj_.build(child_)
obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
- MixedContainer.TypeNone, 'initializer', childobj_)
+ MixedContainer.TypeNone, 'initializer', childobj_)
self.content_.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'briefdescription':
+ nodeName_ == 'briefdescription':
childobj_ = descriptionType.factory()
childobj_.build(child_)
obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
- MixedContainer.TypeNone, 'briefdescription', childobj_)
+ MixedContainer.TypeNone, 'briefdescription', childobj_)
self.content_.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'detaileddescription':
+ nodeName_ == 'detaileddescription':
childobj_ = descriptionType.factory()
childobj_.build(child_)
obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
- MixedContainer.TypeNone, 'detaileddescription', childobj_)
+ MixedContainer.TypeNone, 'detaileddescription', childobj_)
self.content_.append(obj_)
elif child_.nodeType == Node.TEXT_NODE:
obj_ = self.mixedclass_(MixedContainer.CategoryText,
- MixedContainer.TypeNone, '', child_.nodeValue)
+ MixedContainer.TypeNone, '', child_.nodeValue)
self.content_.append(obj_)
# end class enumvalueType
@@ -3027,11 +3417,13 @@ class enumvalueType(GeneratedsSuper):
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_)
@@ -3042,10 +3434,12 @@ class templateparamlistType(GeneratedsSuper):
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_, ))
- self.exportAttributes(outfile, level, namespace_, name_='templateparamlistType')
+ self.exportAttributes(outfile, level, namespace_,
+ name_='templateparamlistType')
if self.hasContent_():
outfile.write('>\n')
self.exportChildren(outfile, level + 1, namespace_, name_)
@@ -3053,25 +3447,31 @@ class templateparamlistType(GeneratedsSuper):
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')
@@ -3085,17 +3485,20 @@ class templateparamlistType(GeneratedsSuper):
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 \
- nodeName_ == 'param':
+ nodeName_ == 'param':
obj_ = paramType.factory()
obj_.build(child_)
self.param.append(obj_)
@@ -3105,6 +3508,7 @@ class templateparamlistType(GeneratedsSuper):
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
@@ -3112,6 +3516,7 @@ class paramType(GeneratedsSuper):
self.array = array
self.defval = defval
self.briefdescription = briefdescription
+
def factory(*args_, **kwargs_):
if paramType.subclass:
return paramType.subclass(*args_, **kwargs_)
@@ -3129,7 +3534,10 @@ class paramType(GeneratedsSuper):
def get_defval(self): return self.defval
def set_defval(self, defval): self.defval = defval
def get_briefdescription(self): return self.briefdescription
- def set_briefdescription(self, briefdescription): self.briefdescription = briefdescription
+
+ def set_briefdescription(
+ self, briefdescription): self.briefdescription = briefdescription
+
def export(self, outfile, level, namespace_='', name_='paramType', namespacedef_=''):
showIndent(outfile, level)
outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))
@@ -3141,24 +3549,31 @@ class paramType(GeneratedsSuper):
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)
- outfile.write('<%sdeclname>%s</%sdeclname>\n' % (namespace_, self.format_string(quote_xml(self.declname).encode(ExternalEncoding), input_name='declname'), namespace_))
+ outfile.write('<%sdeclname>%s</%sdeclname>\n' % (namespace_, self.format_string(
+ quote_xml(self.declname).encode(ExternalEncoding), input_name='declname'), namespace_))
if self.defname is not None:
showIndent(outfile, level)
- outfile.write('<%sdefname>%s</%sdefname>\n' % (namespace_, self.format_string(quote_xml(self.defname).encode(ExternalEncoding), input_name='defname'), namespace_))
+ outfile.write('<%sdefname>%s</%sdefname>\n' % (namespace_, self.format_string(
+ quote_xml(self.defname).encode(ExternalEncoding), input_name='defname'), namespace_))
if self.array is not None:
showIndent(outfile, level)
- outfile.write('<%sarray>%s</%sarray>\n' % (namespace_, self.format_string(quote_xml(self.array).encode(ExternalEncoding), input_name='array'), namespace_))
+ outfile.write('<%sarray>%s</%sarray>\n' % (namespace_, self.format_string(
+ quote_xml(self.array).encode(ExternalEncoding), input_name='array'), namespace_))
if self.defval:
self.defval.export(outfile, level, namespace_, name_='defval')
if self.briefdescription:
- self.briefdescription.export(outfile, level, namespace_, name_='briefdescription')
+ self.briefdescription.export(
+ outfile, level, namespace_, name_='briefdescription')
+
def hasContent_(self):
if (
self.type_ is not None or
@@ -3167,17 +3582,20 @@ class paramType(GeneratedsSuper):
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)
@@ -3186,11 +3604,14 @@ class paramType(GeneratedsSuper):
showIndent(outfile, level)
outfile.write('),\n')
showIndent(outfile, level)
- outfile.write('declname=%s,\n' % quote_python(self.declname).encode(ExternalEncoding))
+ outfile.write('declname=%s,\n' % quote_python(
+ self.declname).encode(ExternalEncoding))
showIndent(outfile, level)
- outfile.write('defname=%s,\n' % quote_python(self.defname).encode(ExternalEncoding))
+ outfile.write('defname=%s,\n' % quote_python(
+ self.defname).encode(ExternalEncoding))
showIndent(outfile, level)
- outfile.write('array=%s,\n' % quote_python(self.array).encode(ExternalEncoding))
+ outfile.write('array=%s,\n' % quote_python(
+ self.array).encode(ExternalEncoding))
if self.defval:
showIndent(outfile, level)
outfile.write('defval=model_.linkedTextType(\n')
@@ -3200,48 +3621,52 @@ class paramType(GeneratedsSuper):
if self.briefdescription:
showIndent(outfile, level)
outfile.write('briefdescription=model_.descriptionType(\n')
- self.briefdescription.exportLiteral(outfile, level, name_='briefdescription')
+ self.briefdescription.exportLiteral(
+ outfile, level, name_='briefdescription')
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 \
- nodeName_ == 'type':
+ nodeName_ == 'type':
obj_ = linkedTextType.factory()
obj_.build(child_)
self.set_type(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'declname':
+ nodeName_ == 'declname':
declname_ = ''
for text__content_ in child_.childNodes:
declname_ += text__content_.nodeValue
self.declname = declname_
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'defname':
+ nodeName_ == 'defname':
defname_ = ''
for text__content_ in child_.childNodes:
defname_ += text__content_.nodeValue
self.defname = defname_
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'array':
+ nodeName_ == 'array':
array_ = ''
for text__content_ in child_.childNodes:
array_ += text__content_.nodeValue
self.array = array_
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'defval':
+ nodeName_ == 'defval':
obj_ = linkedTextType.factory()
obj_.build(child_)
self.set_defval(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'briefdescription':
+ nodeName_ == 'briefdescription':
obj_ = descriptionType.factory()
obj_.build(child_)
self.set_briefdescription(obj_)
@@ -3251,8 +3676,10 @@ class paramType(GeneratedsSuper):
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_)
@@ -3261,6 +3688,7 @@ class declname(GeneratedsSuper):
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_, ))
@@ -3272,33 +3700,40 @@ class declname(GeneratedsSuper):
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'):
- if self.valueOf_.find('![CDATA')>-1:
- value=quote_xml('%s' % self.valueOf_)
- value=value.replace('![CDATA','<![CDATA')
- value=value.replace(']]',']]>')
+ if self.valueOf_.find('![CDATA') > -1:
+ value = quote_xml('%s' % self.valueOf_)
+ value = value.replace('![CDATA', '<![CDATA')
+ value = value.replace(']]', ']]>')
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)
@@ -3306,21 +3741,25 @@ class declname(GeneratedsSuper):
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:
- self.valueOf_ += '![CDATA['+child_.nodeValue+']]'
+ self.valueOf_ += '![CDATA[' + child_.nodeValue + ']]'
# 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_)
@@ -3329,6 +3768,7 @@ class defname(GeneratedsSuper):
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_, ))
@@ -3340,33 +3780,40 @@ class defname(GeneratedsSuper):
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'):
- if self.valueOf_.find('![CDATA')>-1:
- value=quote_xml('%s' % self.valueOf_)
- value=value.replace('![CDATA','<![CDATA')
- value=value.replace(']]',']]>')
+ if self.valueOf_.find('![CDATA') > -1:
+ value = quote_xml('%s' % self.valueOf_)
+ value = value.replace('![CDATA', '<![CDATA')
+ value = value.replace(']]', ']]>')
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)
@@ -3374,21 +3821,25 @@ class defname(GeneratedsSuper):
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:
- self.valueOf_ += '![CDATA['+child_.nodeValue+']]'
+ self.valueOf_ += '![CDATA[' + child_.nodeValue + ']]'
# 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_)
@@ -3397,6 +3848,7 @@ class array(GeneratedsSuper):
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_, ))
@@ -3408,33 +3860,40 @@ class array(GeneratedsSuper):
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'):
- if self.valueOf_.find('![CDATA')>-1:
- value=quote_xml('%s' % self.valueOf_)
- value=value.replace('![CDATA','<![CDATA')
- value=value.replace(']]',']]>')
+ if self.valueOf_.find('![CDATA') > -1:
+ value = quote_xml('%s' % self.valueOf_)
+ value = value.replace('![CDATA', '<![CDATA')
+ value = value.replace(']]', ']]>')
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)
@@ -3442,19 +3901,22 @@ class array(GeneratedsSuper):
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:
- self.valueOf_ += '![CDATA['+child_.nodeValue+']]'
+ self.valueOf_ += '![CDATA[' + child_.nodeValue + ']]'
# 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
@@ -3464,6 +3926,7 @@ class linkedTextType(GeneratedsSuper):
self.content_ = []
else:
self.content_ = content_
+
def factory(*args_, **kwargs_):
if linkedTextType.subclass:
return linkedTextType.subclass(*args_, **kwargs_)
@@ -3474,32 +3937,40 @@ class linkedTextType(GeneratedsSuper):
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_, ))
- self.exportAttributes(outfile, level, namespace_, name_='linkedTextType')
+ self.exportAttributes(outfile, level, namespace_,
+ name_='linkedTextType')
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')
@@ -3507,25 +3978,28 @@ class linkedTextType(GeneratedsSuper):
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 \
- nodeName_ == 'ref':
+ nodeName_ == 'ref':
childobj_ = docRefTextType.factory()
childobj_.build(child_)
obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
- MixedContainer.TypeNone, 'ref', childobj_)
+ MixedContainer.TypeNone, 'ref', childobj_)
self.content_.append(obj_)
elif child_.nodeType == Node.TEXT_NODE:
obj_ = self.mixedclass_(MixedContainer.CategoryText,
- MixedContainer.TypeNone, '', child_.nodeValue)
+ MixedContainer.TypeNone, '', child_.nodeValue)
self.content_.append(obj_)
# end class linkedTextType
@@ -3533,11 +4007,13 @@ class linkedTextType(GeneratedsSuper):
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_)
@@ -3548,6 +4024,7 @@ class graphType(GeneratedsSuper):
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_, ))
@@ -3559,25 +4036,31 @@ class graphType(GeneratedsSuper):
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')
@@ -3591,17 +4074,20 @@ class graphType(GeneratedsSuper):
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 \
- nodeName_ == 'node':
+ nodeName_ == 'node':
obj_ = nodeType.factory()
obj_.build(child_)
self.node.append(obj_)
@@ -3611,6 +4097,7 @@ class graphType(GeneratedsSuper):
class nodeType(GeneratedsSuper):
subclass = None
superclass = None
+
def __init__(self, id=None, label=None, link=None, childnode=None):
self.id = id
self.label = label
@@ -3619,6 +4106,7 @@ class nodeType(GeneratedsSuper):
self.childnode = []
else:
self.childnode = childnode
+
def factory(*args_, **kwargs_):
if nodeType.subclass:
return nodeType.subclass(*args_, **kwargs_)
@@ -3635,6 +4123,7 @@ class nodeType(GeneratedsSuper):
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_, ))
@@ -3646,38 +4135,47 @@ class nodeType(GeneratedsSuper):
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:
- outfile.write(' id=%s' % (self.format_string(quote_attrib(self.id).encode(ExternalEncoding), input_name='id'), ))
+ outfile.write(' id=%s' % (self.format_string(quote_attrib(
+ self.id).encode(ExternalEncoding), input_name='id'), ))
+
def exportChildren(self, outfile, level, namespace_='', name_='nodeType'):
if self.label is not None:
showIndent(outfile, level)
- outfile.write('<%slabel>%s</%slabel>\n' % (namespace_, self.format_string(quote_xml(self.label).encode(ExternalEncoding), input_name='label'), namespace_))
+ outfile.write('<%slabel>%s</%slabel>\n' % (namespace_, self.format_string(
+ quote_xml(self.label).encode(ExternalEncoding), input_name='label'), namespace_))
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)
- outfile.write('label=%s,\n' % quote_python(self.label).encode(ExternalEncoding))
+ outfile.write('label=%s,\n' % quote_python(
+ self.label).encode(ExternalEncoding))
if self.link:
showIndent(outfile, level)
outfile.write('link=model_.linkType(\n')
@@ -3696,29 +4194,32 @@ class nodeType(GeneratedsSuper):
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 \
- nodeName_ == 'label':
+ nodeName_ == 'label':
label_ = ''
for text__content_ in child_.childNodes:
label_ += text__content_.nodeValue
self.label = label_
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'link':
+ nodeName_ == 'link':
obj_ = linkType.factory()
obj_.build(child_)
self.set_link(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'childnode':
+ nodeName_ == 'childnode':
obj_ = childnodeType.factory()
obj_.build(child_)
self.childnode.append(obj_)
@@ -3728,8 +4229,10 @@ class nodeType(GeneratedsSuper):
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_)
@@ -3738,6 +4241,7 @@ class label(GeneratedsSuper):
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_, ))
@@ -3749,33 +4253,40 @@ class label(GeneratedsSuper):
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'):
- if self.valueOf_.find('![CDATA')>-1:
- value=quote_xml('%s' % self.valueOf_)
- value=value.replace('![CDATA','<![CDATA')
- value=value.replace(']]',']]>')
+ if self.valueOf_.find('![CDATA') > -1:
+ value = quote_xml('%s' % self.valueOf_)
+ value = value.replace('![CDATA', '<![CDATA')
+ value = value.replace(']]', ']]>')
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)
@@ -3783,19 +4294,22 @@ class label(GeneratedsSuper):
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:
- self.valueOf_ += '![CDATA['+child_.nodeValue+']]'
+ self.valueOf_ += '![CDATA[' + child_.nodeValue + ']]'
# 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
@@ -3803,6 +4317,7 @@ class childnodeType(GeneratedsSuper):
self.edgelabel = []
else:
self.edgelabel = edgelabel
+
def factory(*args_, **kwargs_):
if childnodeType.subclass:
return childnodeType.subclass(*args_, **kwargs_)
@@ -3817,10 +4332,12 @@ class childnodeType(GeneratedsSuper):
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_, ))
- self.exportAttributes(outfile, level, namespace_, name_='childnodeType')
+ self.exportAttributes(outfile, level, namespace_,
+ name_='childnodeType')
if self.hasContent_():
outfile.write('>\n')
self.exportChildren(outfile, level + 1, namespace_, name_)
@@ -3828,27 +4345,34 @@ class childnodeType(GeneratedsSuper):
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:
- outfile.write(' refid=%s' % (self.format_string(quote_attrib(self.refid).encode(ExternalEncoding), input_name='refid'), ))
+ outfile.write(' refid=%s' % (self.format_string(quote_attrib(
+ self.refid).encode(ExternalEncoding), input_name='refid'), ))
+
def exportChildren(self, outfile, level, namespace_='', name_='childnodeType'):
for edgelabel_ in self.edgelabel:
showIndent(outfile, level)
- outfile.write('<%sedgelabel>%s</%sedgelabel>\n' % (namespace_, self.format_string(quote_xml(edgelabel_).encode(ExternalEncoding), input_name='edgelabel'), namespace_))
+ outfile.write('<%sedgelabel>%s</%sedgelabel>\n' % (namespace_, self.format_string(
+ quote_xml(edgelabel_).encode(ExternalEncoding), input_name='edgelabel'), namespace_))
+
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)
@@ -3856,30 +4380,35 @@ class childnodeType(GeneratedsSuper):
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)
- outfile.write('%s,\n' % quote_python(edgelabel).encode(ExternalEncoding))
+ outfile.write('%s,\n' % quote_python(
+ edgelabel).encode(ExternalEncoding))
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 \
- nodeName_ == 'edgelabel':
+ nodeName_ == 'edgelabel':
edgelabel_ = ''
for text__content_ in child_.childNodes:
edgelabel_ += text__content_.nodeValue
@@ -3890,8 +4419,10 @@ class childnodeType(GeneratedsSuper):
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_)
@@ -3900,6 +4431,7 @@ class edgelabel(GeneratedsSuper):
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_, ))
@@ -3911,33 +4443,40 @@ class edgelabel(GeneratedsSuper):
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'):
- if self.valueOf_.find('![CDATA')>-1:
- value=quote_xml('%s' % self.valueOf_)
- value=value.replace('![CDATA','<![CDATA')
- value=value.replace(']]',']]>')
+ if self.valueOf_.find('![CDATA') > -1:
+ value = quote_xml('%s' % self.valueOf_)
+ value = value.replace('![CDATA', '<![CDATA')
+ value = value.replace(']]', ']]>')
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)
@@ -3945,23 +4484,27 @@ class edgelabel(GeneratedsSuper):
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:
- self.valueOf_ += '![CDATA['+child_.nodeValue+']]'
+ self.valueOf_ += '![CDATA[' + child_.nodeValue + ']]'
# 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_)
@@ -3974,6 +4517,7 @@ class linkType(GeneratedsSuper):
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_, ))
@@ -3985,31 +4529,38 @@ class linkType(GeneratedsSuper):
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:
- outfile.write(' refid=%s' % (self.format_string(quote_attrib(self.refid).encode(ExternalEncoding), input_name='refid'), ))
+ outfile.write(' refid=%s' % (self.format_string(quote_attrib(
+ self.refid).encode(ExternalEncoding), input_name='refid'), ))
if self.external is not None:
- outfile.write(' external=%s' % (self.format_string(quote_attrib(self.external).encode(ExternalEncoding), input_name='external'), ))
+ outfile.write(' external=%s' % (self.format_string(quote_attrib(
+ self.external).encode(ExternalEncoding), input_name='external'), ))
+
def exportChildren(self, outfile, level, namespace_='', name_='linkType'):
- if self.valueOf_.find('![CDATA')>-1:
- value=quote_xml('%s' % self.valueOf_)
- value=value.replace('![CDATA','<![CDATA')
- value=value.replace(']]',']]>')
+ if self.valueOf_.find('![CDATA') > -1:
+ value = quote_xml('%s' % self.valueOf_)
+ value = value.replace('![CDATA', '<![CDATA')
+ value = value.replace(']]', ']]>')
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)
@@ -4017,9 +4568,11 @@ class linkType(GeneratedsSuper):
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)
@@ -4027,27 +4580,31 @@ class linkType(GeneratedsSuper):
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:
- self.valueOf_ += '![CDATA['+child_.nodeValue+']]'
+ self.valueOf_ += '![CDATA[' + child_.nodeValue + ']]'
# 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_)
@@ -4058,6 +4615,7 @@ class listingType(GeneratedsSuper):
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_, ))
@@ -4069,25 +4627,31 @@ class listingType(GeneratedsSuper):
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')
@@ -4101,17 +4665,20 @@ class listingType(GeneratedsSuper):
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 \
- nodeName_ == 'codeline':
+ nodeName_ == 'codeline':
obj_ = codelineType.factory()
obj_.build(child_)
self.codeline.append(obj_)
@@ -4121,6 +4688,7 @@ class listingType(GeneratedsSuper):
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
@@ -4130,6 +4698,7 @@ class codelineType(GeneratedsSuper):
self.highlight = []
else:
self.highlight = highlight
+
def factory(*args_, **kwargs_):
if codelineType.subclass:
return codelineType.subclass(*args_, **kwargs_)
@@ -4148,6 +4717,7 @@ class codelineType(GeneratedsSuper):
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_, ))
@@ -4159,30 +4729,37 @@ class codelineType(GeneratedsSuper):
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:
- outfile.write(' lineno="%s"' % self.format_integer(self.lineno, input_name='lineno'))
+ outfile.write(' lineno="%s"' % self.format_integer(
+ self.lineno, input_name='lineno'))
if self.refkind is not None:
outfile.write(' refkind=%s' % (quote_attrib(self.refkind), ))
if self.refid is not None:
- outfile.write(' refid=%s' % (self.format_string(quote_attrib(self.refid).encode(ExternalEncoding), input_name='refid'), ))
+ outfile.write(' refid=%s' % (self.format_string(quote_attrib(
+ self.refid).encode(ExternalEncoding), input_name='refid'), ))
+
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)
@@ -4196,6 +4773,7 @@ class codelineType(GeneratedsSuper):
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')
@@ -4209,12 +4787,14 @@ class codelineType(GeneratedsSuper):
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
@@ -4227,9 +4807,10 @@ class codelineType(GeneratedsSuper):
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 \
- nodeName_ == 'highlight':
+ nodeName_ == 'highlight':
obj_ = highlightType.factory()
obj_.build(child_)
self.highlight.append(obj_)
@@ -4239,6 +4820,7 @@ class codelineType(GeneratedsSuper):
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:
@@ -4249,6 +4831,7 @@ class highlightType(GeneratedsSuper):
self.content_ = []
else:
self.content_ = content_
+
def factory(*args_, **kwargs_):
if highlightType.subclass:
return highlightType.subclass(*args_, **kwargs_)
@@ -4265,36 +4848,44 @@ class highlightType(GeneratedsSuper):
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_, ))
- self.exportAttributes(outfile, level, namespace_, name_='highlightType')
+ self.exportAttributes(outfile, level, namespace_,
+ name_='highlightType')
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')
@@ -4308,35 +4899,38 @@ class highlightType(GeneratedsSuper):
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 \
- nodeName_ == 'sp':
+ nodeName_ == 'sp':
value_ = []
for text_ in child_.childNodes:
value_.append(text_.nodeValue)
valuestr_ = ''.join(value_)
obj_ = self.mixedclass_(MixedContainer.CategorySimple,
- MixedContainer.TypeString, 'sp', valuestr_)
+ MixedContainer.TypeString, 'sp', valuestr_)
self.content_.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'ref':
+ nodeName_ == 'ref':
childobj_ = docRefTextType.factory()
childobj_.build(child_)
obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
- MixedContainer.TypeNone, 'ref', childobj_)
+ MixedContainer.TypeNone, 'ref', childobj_)
self.content_.append(obj_)
elif child_.nodeType == Node.TEXT_NODE:
obj_ = self.mixedclass_(MixedContainer.CategoryText,
- MixedContainer.TypeNone, '', child_.nodeValue)
+ MixedContainer.TypeNone, '', child_.nodeValue)
self.content_.append(obj_)
# end class highlightType
@@ -4344,8 +4938,10 @@ class highlightType(GeneratedsSuper):
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_)
@@ -4354,6 +4950,7 @@ class sp(GeneratedsSuper):
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_, ))
@@ -4365,33 +4962,40 @@ class sp(GeneratedsSuper):
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'):
- if self.valueOf_.find('![CDATA')>-1:
- value=quote_xml('%s' % self.valueOf_)
- value=value.replace('![CDATA','<![CDATA')
- value=value.replace(']]',']]>')
+ if self.valueOf_.find('![CDATA') > -1:
+ value = quote_xml('%s' % self.valueOf_)
+ value = value.replace('![CDATA', '<![CDATA')
+ value = value.replace(']]', ']]>')
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)
@@ -4399,19 +5003,22 @@ class sp(GeneratedsSuper):
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:
- self.valueOf_ += '![CDATA['+child_.nodeValue+']]'
+ self.valueOf_ += '![CDATA[' + child_.nodeValue + ']]'
# 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
@@ -4425,6 +5032,7 @@ class referenceType(GeneratedsSuper):
self.content_ = []
else:
self.content_ = content_
+
def factory(*args_, **kwargs_):
if referenceType.subclass:
return referenceType.subclass(*args_, **kwargs_)
@@ -4441,42 +5049,53 @@ class referenceType(GeneratedsSuper):
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_, ))
- self.exportAttributes(outfile, level, namespace_, name_='referenceType')
+ self.exportAttributes(outfile, level, namespace_,
+ name_='referenceType')
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:
- outfile.write(' endline="%s"' % self.format_integer(self.endline, input_name='endline'))
+ outfile.write(' endline="%s"' % self.format_integer(
+ self.endline, input_name='endline'))
if self.startline is not None:
- outfile.write(' startline="%s"' % self.format_integer(self.startline, input_name='startline'))
+ outfile.write(' startline="%s"' % self.format_integer(
+ self.startline, input_name='startline'))
if self.refid is not None:
- outfile.write(' refid=%s' % (self.format_string(quote_attrib(self.refid).encode(ExternalEncoding), input_name='refid'), ))
+ outfile.write(' refid=%s' % (self.format_string(quote_attrib(
+ self.refid).encode(ExternalEncoding), input_name='refid'), ))
if self.compoundref is not None:
- outfile.write(' compoundref=%s' % (self.format_string(quote_attrib(self.compoundref).encode(ExternalEncoding), input_name='compoundref'), ))
+ outfile.write(' compoundref=%s' % (self.format_string(quote_attrib(
+ self.compoundref).encode(ExternalEncoding), input_name='compoundref'), ))
+
def exportChildren(self, outfile, level, namespace_='', name_='referenceType'):
- if self.valueOf_.find('![CDATA')>-1:
- value=quote_xml('%s' % self.valueOf_)
- value=value.replace('![CDATA','<![CDATA')
- value=value.replace(']]',']]>')
+ if self.valueOf_.find('![CDATA') > -1:
+ value = quote_xml('%s' % self.valueOf_)
+ value = value.replace('![CDATA', '<![CDATA')
+ value = value.replace(']]', ']]>')
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)
@@ -4490,9 +5109,11 @@ class referenceType(GeneratedsSuper):
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)
@@ -4500,6 +5121,7 @@ class referenceType(GeneratedsSuper):
for child_ in node_.childNodes:
nodeName_ = child_.nodeName.split(':')[-1]
self.buildChildren(child_, nodeName_)
+
def buildAttributes(self, attrs):
if attrs.get('endline'):
try:
@@ -4515,21 +5137,23 @@ class referenceType(GeneratedsSuper):
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,
- MixedContainer.TypeNone, '', child_.nodeValue)
+ MixedContainer.TypeNone, '', child_.nodeValue)
self.content_.append(obj_)
if child_.nodeType == Node.TEXT_NODE:
self.valueOf_ += child_.nodeValue
elif child_.nodeType == Node.CDATA_SECTION_NODE:
- self.valueOf_ += '![CDATA['+child_.nodeValue+']]'
+ self.valueOf_ += '![CDATA[' + child_.nodeValue + ']]'
# 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
@@ -4537,6 +5161,7 @@ class locationType(GeneratedsSuper):
self.bodyfile = bodyfile
self.file = file
self.valueOf_ = valueOf_
+
def factory(*args_, **kwargs_):
if locationType.subclass:
return locationType.subclass(*args_, **kwargs_)
@@ -4555,6 +5180,7 @@ class locationType(GeneratedsSuper):
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_, ))
@@ -4566,37 +5192,47 @@ class locationType(GeneratedsSuper):
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:
- outfile.write(' bodystart="%s"' % self.format_integer(self.bodystart, input_name='bodystart'))
+ outfile.write(' bodystart="%s"' % self.format_integer(
+ self.bodystart, input_name='bodystart'))
if self.line is not None:
- outfile.write(' line="%s"' % self.format_integer(self.line, input_name='line'))
+ outfile.write(' line="%s"' % self.format_integer(
+ self.line, input_name='line'))
if self.bodyend is not None:
- outfile.write(' bodyend="%s"' % self.format_integer(self.bodyend, input_name='bodyend'))
+ outfile.write(' bodyend="%s"' % self.format_integer(
+ self.bodyend, input_name='bodyend'))
if self.bodyfile is not None:
- outfile.write(' bodyfile=%s' % (self.format_string(quote_attrib(self.bodyfile).encode(ExternalEncoding), input_name='bodyfile'), ))
+ outfile.write(' bodyfile=%s' % (self.format_string(quote_attrib(
+ self.bodyfile).encode(ExternalEncoding), input_name='bodyfile'), ))
if self.file is not None:
- outfile.write(' file=%s' % (self.format_string(quote_attrib(self.file).encode(ExternalEncoding), input_name='file'), ))
+ outfile.write(' file=%s' % (self.format_string(quote_attrib(
+ self.file).encode(ExternalEncoding), input_name='file'), ))
+
def exportChildren(self, outfile, level, namespace_='', name_='locationType'):
- if self.valueOf_.find('![CDATA')>-1:
- value=quote_xml('%s' % self.valueOf_)
- value=value.replace('![CDATA','<![CDATA')
- value=value.replace(']]',']]>')
+ if self.valueOf_.find('![CDATA') > -1:
+ value = quote_xml('%s' % self.valueOf_)
+ value = value.replace('![CDATA', '<![CDATA')
+ value = value.replace(']]', ']]>')
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)
@@ -4613,9 +5249,11 @@ class locationType(GeneratedsSuper):
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)
@@ -4623,6 +5261,7 @@ class locationType(GeneratedsSuper):
for child_ in node_.childNodes:
nodeName_ = child_.nodeName.split(':')[-1]
self.buildChildren(child_, nodeName_)
+
def buildAttributes(self, attrs):
if attrs.get('bodystart'):
try:
@@ -4643,17 +5282,19 @@ class locationType(GeneratedsSuper):
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:
- self.valueOf_ += '![CDATA['+child_.nodeValue+']]'
+ self.valueOf_ += '![CDATA[' + child_.nodeValue + ']]'
# 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:
@@ -4664,6 +5305,7 @@ class docSect1Type(GeneratedsSuper):
self.content_ = []
else:
self.content_ = content_
+
def factory(*args_, **kwargs_):
if docSect1Type.subclass:
return docSect1Type.subclass(*args_, **kwargs_)
@@ -4684,6 +5326,7 @@ class docSect1Type(GeneratedsSuper):
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_, ))
@@ -4691,31 +5334,38 @@ class docSect1Type(GeneratedsSuper):
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:
- outfile.write(' id=%s' % (self.format_string(quote_attrib(self.id).encode(ExternalEncoding), input_name='id'), ))
+ outfile.write(' id=%s' % (self.format_string(quote_attrib(
+ self.id).encode(ExternalEncoding), input_name='id'), ))
+
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')
@@ -4741,47 +5391,50 @@ class docSect1Type(GeneratedsSuper):
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 \
- nodeName_ == 'title':
+ nodeName_ == 'title':
childobj_ = docTitleType.factory()
childobj_.build(child_)
obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
- MixedContainer.TypeNone, 'title', childobj_)
+ MixedContainer.TypeNone, 'title', childobj_)
self.content_.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'para':
+ nodeName_ == 'para':
childobj_ = docParaType.factory()
childobj_.build(child_)
obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
- MixedContainer.TypeNone, 'para', childobj_)
+ MixedContainer.TypeNone, 'para', childobj_)
self.content_.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'sect2':
+ nodeName_ == 'sect2':
childobj_ = docSect2Type.factory()
childobj_.build(child_)
obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
- MixedContainer.TypeNone, 'sect2', childobj_)
+ MixedContainer.TypeNone, 'sect2', childobj_)
self.content_.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'internal':
+ nodeName_ == 'internal':
childobj_ = docInternalS1Type.factory()
childobj_.build(child_)
obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
- MixedContainer.TypeNone, 'internal', childobj_)
+ MixedContainer.TypeNone, 'internal', childobj_)
self.content_.append(obj_)
elif child_.nodeType == Node.TEXT_NODE:
obj_ = self.mixedclass_(MixedContainer.CategoryText,
- MixedContainer.TypeNone, '', child_.nodeValue)
+ MixedContainer.TypeNone, '', child_.nodeValue)
self.content_.append(obj_)
# end class docSect1Type
@@ -4789,6 +5442,7 @@ class docSect1Type(GeneratedsSuper):
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:
@@ -4799,6 +5453,7 @@ class docSect2Type(GeneratedsSuper):
self.content_ = []
else:
self.content_ = content_
+
def factory(*args_, **kwargs_):
if docSect2Type.subclass:
return docSect2Type.subclass(*args_, **kwargs_)
@@ -4819,6 +5474,7 @@ class docSect2Type(GeneratedsSuper):
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_, ))
@@ -4826,31 +5482,38 @@ class docSect2Type(GeneratedsSuper):
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:
- outfile.write(' id=%s' % (self.format_string(quote_attrib(self.id).encode(ExternalEncoding), input_name='id'), ))
+ outfile.write(' id=%s' % (self.format_string(quote_attrib(
+ self.id).encode(ExternalEncoding), input_name='id'), ))
+
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')
@@ -4876,47 +5539,50 @@ class docSect2Type(GeneratedsSuper):
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 \
- nodeName_ == 'title':
+ nodeName_ == 'title':
childobj_ = docTitleType.factory()
childobj_.build(child_)
obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
- MixedContainer.TypeNone, 'title', childobj_)
+ MixedContainer.TypeNone, 'title', childobj_)
self.content_.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'para':
+ nodeName_ == 'para':
childobj_ = docParaType.factory()
childobj_.build(child_)
obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
- MixedContainer.TypeNone, 'para', childobj_)
+ MixedContainer.TypeNone, 'para', childobj_)
self.content_.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'sect3':
+ nodeName_ == 'sect3':
childobj_ = docSect3Type.factory()
childobj_.build(child_)
obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
- MixedContainer.TypeNone, 'sect3', childobj_)
+ MixedContainer.TypeNone, 'sect3', childobj_)
self.content_.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'internal':
+ nodeName_ == 'internal':
childobj_ = docInternalS2Type.factory()
childobj_.build(child_)
obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
- MixedContainer.TypeNone, 'internal', childobj_)
+ MixedContainer.TypeNone, 'internal', childobj_)
self.content_.append(obj_)
elif child_.nodeType == Node.TEXT_NODE:
obj_ = self.mixedclass_(MixedContainer.CategoryText,
- MixedContainer.TypeNone, '', child_.nodeValue)
+ MixedContainer.TypeNone, '', child_.nodeValue)
self.content_.append(obj_)
# end class docSect2Type
@@ -4924,6 +5590,7 @@ class docSect2Type(GeneratedsSuper):
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:
@@ -4934,6 +5601,7 @@ class docSect3Type(GeneratedsSuper):
self.content_ = []
else:
self.content_ = content_
+
def factory(*args_, **kwargs_):
if docSect3Type.subclass:
return docSect3Type.subclass(*args_, **kwargs_)
@@ -4954,6 +5622,7 @@ class docSect3Type(GeneratedsSuper):
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_, ))
@@ -4961,31 +5630,38 @@ class docSect3Type(GeneratedsSuper):
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:
- outfile.write(' id=%s' % (self.format_string(quote_attrib(self.id).encode(ExternalEncoding), input_name='id'), ))
+ outfile.write(' id=%s' % (self.format_string(quote_attrib(
+ self.id).encode(ExternalEncoding), input_name='id'), ))
+
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')
@@ -5011,47 +5687,50 @@ class docSect3Type(GeneratedsSuper):
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 \
- nodeName_ == 'title':
+ nodeName_ == 'title':
childobj_ = docTitleType.factory()
childobj_.build(child_)
obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
- MixedContainer.TypeNone, 'title', childobj_)
+ MixedContainer.TypeNone, 'title', childobj_)
self.content_.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'para':
+ nodeName_ == 'para':
childobj_ = docParaType.factory()
childobj_.build(child_)
obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
- MixedContainer.TypeNone, 'para', childobj_)
+ MixedContainer.TypeNone, 'para', childobj_)
self.content_.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'sect4':
+ nodeName_ == 'sect4':
childobj_ = docSect4Type.factory()
childobj_.build(child_)
obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
- MixedContainer.TypeNone, 'sect4', childobj_)
+ MixedContainer.TypeNone, 'sect4', childobj_)
self.content_.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'internal':
+ nodeName_ == 'internal':
childobj_ = docInternalS3Type.factory()
childobj_.build(child_)
obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
- MixedContainer.TypeNone, 'internal', childobj_)
+ MixedContainer.TypeNone, 'internal', childobj_)
self.content_.append(obj_)
elif child_.nodeType == Node.TEXT_NODE:
obj_ = self.mixedclass_(MixedContainer.CategoryText,
- MixedContainer.TypeNone, '', child_.nodeValue)
+ MixedContainer.TypeNone, '', child_.nodeValue)
self.content_.append(obj_)
# end class docSect3Type
@@ -5059,6 +5738,7 @@ class docSect3Type(GeneratedsSuper):
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:
@@ -5069,6 +5749,7 @@ class docSect4Type(GeneratedsSuper):
self.content_ = []
else:
self.content_ = content_
+
def factory(*args_, **kwargs_):
if docSect4Type.subclass:
return docSect4Type.subclass(*args_, **kwargs_)
@@ -5085,6 +5766,7 @@ class docSect4Type(GeneratedsSuper):
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_, ))
@@ -5092,30 +5774,37 @@ class docSect4Type(GeneratedsSuper):
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:
- outfile.write(' id=%s' % (self.format_string(quote_attrib(self.id).encode(ExternalEncoding), input_name='id'), ))
+ outfile.write(' id=%s' % (self.format_string(quote_attrib(
+ self.id).encode(ExternalEncoding), input_name='id'), ))
+
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')
@@ -5135,40 +5824,43 @@ class docSect4Type(GeneratedsSuper):
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 \
- nodeName_ == 'title':
+ nodeName_ == 'title':
childobj_ = docTitleType.factory()
childobj_.build(child_)
obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
- MixedContainer.TypeNone, 'title', childobj_)
+ MixedContainer.TypeNone, 'title', childobj_)
self.content_.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'para':
+ nodeName_ == 'para':
childobj_ = docParaType.factory()
childobj_.build(child_)
obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
- MixedContainer.TypeNone, 'para', childobj_)
+ MixedContainer.TypeNone, 'para', childobj_)
self.content_.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'internal':
+ nodeName_ == 'internal':
childobj_ = docInternalS4Type.factory()
childobj_.build(child_)
obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
- MixedContainer.TypeNone, 'internal', childobj_)
+ MixedContainer.TypeNone, 'internal', childobj_)
self.content_.append(obj_)
elif child_.nodeType == Node.TEXT_NODE:
obj_ = self.mixedclass_(MixedContainer.CategoryText,
- MixedContainer.TypeNone, '', child_.nodeValue)
+ MixedContainer.TypeNone, '', child_.nodeValue)
self.content_.append(obj_)
# end class docSect4Type
@@ -5176,6 +5868,7 @@ class docSect4Type(GeneratedsSuper):
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
@@ -5185,6 +5878,7 @@ class docInternalType(GeneratedsSuper):
self.content_ = []
else:
self.content_ = content_
+
def factory(*args_, **kwargs_):
if docInternalType.subclass:
return docInternalType.subclass(*args_, **kwargs_)
@@ -5199,33 +5893,41 @@ class docInternalType(GeneratedsSuper):
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_, ))
- self.exportAttributes(outfile, level, namespace_, name_='docInternalType')
+ self.exportAttributes(outfile, level, namespace_,
+ name_='docInternalType')
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')
@@ -5239,32 +5941,35 @@ class docInternalType(GeneratedsSuper):
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 \
- nodeName_ == 'para':
+ nodeName_ == 'para':
childobj_ = docParaType.factory()
childobj_.build(child_)
obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
- MixedContainer.TypeNone, 'para', childobj_)
+ MixedContainer.TypeNone, 'para', childobj_)
self.content_.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'sect1':
+ nodeName_ == 'sect1':
childobj_ = docSect1Type.factory()
childobj_.build(child_)
obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
- MixedContainer.TypeNone, 'sect1', childobj_)
+ MixedContainer.TypeNone, 'sect1', childobj_)
self.content_.append(obj_)
elif child_.nodeType == Node.TEXT_NODE:
obj_ = self.mixedclass_(MixedContainer.CategoryText,
- MixedContainer.TypeNone, '', child_.nodeValue)
+ MixedContainer.TypeNone, '', child_.nodeValue)
self.content_.append(obj_)
# end class docInternalType
@@ -5272,6 +5977,7 @@ class docInternalType(GeneratedsSuper):
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
@@ -5281,6 +5987,7 @@ class docInternalS1Type(GeneratedsSuper):
self.content_ = []
else:
self.content_ = content_
+
def factory(*args_, **kwargs_):
if docInternalS1Type.subclass:
return docInternalS1Type.subclass(*args_, **kwargs_)
@@ -5295,33 +6002,41 @@ class docInternalS1Type(GeneratedsSuper):
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_, ))
- self.exportAttributes(outfile, level, namespace_, name_='docInternalS1Type')
+ self.exportAttributes(outfile, level, namespace_,
+ name_='docInternalS1Type')
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')
@@ -5335,32 +6050,35 @@ class docInternalS1Type(GeneratedsSuper):
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 \
- nodeName_ == 'para':
+ nodeName_ == 'para':
childobj_ = docParaType.factory()
childobj_.build(child_)
obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
- MixedContainer.TypeNone, 'para', childobj_)
+ MixedContainer.TypeNone, 'para', childobj_)
self.content_.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'sect2':
+ nodeName_ == 'sect2':
childobj_ = docSect2Type.factory()
childobj_.build(child_)
obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
- MixedContainer.TypeNone, 'sect2', childobj_)
+ MixedContainer.TypeNone, 'sect2', childobj_)
self.content_.append(obj_)
elif child_.nodeType == Node.TEXT_NODE:
obj_ = self.mixedclass_(MixedContainer.CategoryText,
- MixedContainer.TypeNone, '', child_.nodeValue)
+ MixedContainer.TypeNone, '', child_.nodeValue)
self.content_.append(obj_)
# end class docInternalS1Type
@@ -5368,6 +6086,7 @@ class docInternalS1Type(GeneratedsSuper):
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
@@ -5377,6 +6096,7 @@ class docInternalS2Type(GeneratedsSuper):
self.content_ = []
else:
self.content_ = content_
+
def factory(*args_, **kwargs_):
if docInternalS2Type.subclass:
return docInternalS2Type.subclass(*args_, **kwargs_)
@@ -5391,33 +6111,41 @@ class docInternalS2Type(GeneratedsSuper):
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_, ))
- self.exportAttributes(outfile, level, namespace_, name_='docInternalS2Type')
+ self.exportAttributes(outfile, level, namespace_,
+ name_='docInternalS2Type')
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')
@@ -5431,32 +6159,35 @@ class docInternalS2Type(GeneratedsSuper):
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 \
- nodeName_ == 'para':
+ nodeName_ == 'para':
childobj_ = docParaType.factory()
childobj_.build(child_)
obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
- MixedContainer.TypeNone, 'para', childobj_)
+ MixedContainer.TypeNone, 'para', childobj_)
self.content_.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'sect3':
+ nodeName_ == 'sect3':
childobj_ = docSect3Type.factory()
childobj_.build(child_)
obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
- MixedContainer.TypeNone, 'sect3', childobj_)
+ MixedContainer.TypeNone, 'sect3', childobj_)
self.content_.append(obj_)
elif child_.nodeType == Node.TEXT_NODE:
obj_ = self.mixedclass_(MixedContainer.CategoryText,
- MixedContainer.TypeNone, '', child_.nodeValue)
+ MixedContainer.TypeNone, '', child_.nodeValue)
self.content_.append(obj_)
# end class docInternalS2Type
@@ -5464,6 +6195,7 @@ class docInternalS2Type(GeneratedsSuper):
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
@@ -5473,6 +6205,7 @@ class docInternalS3Type(GeneratedsSuper):
self.content_ = []
else:
self.content_ = content_
+
def factory(*args_, **kwargs_):
if docInternalS3Type.subclass:
return docInternalS3Type.subclass(*args_, **kwargs_)
@@ -5487,33 +6220,41 @@ class docInternalS3Type(GeneratedsSuper):
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_, ))
- self.exportAttributes(outfile, level, namespace_, name_='docInternalS3Type')
+ self.exportAttributes(outfile, level, namespace_,
+ name_='docInternalS3Type')
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')
@@ -5527,32 +6268,35 @@ class docInternalS3Type(GeneratedsSuper):
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 \
- nodeName_ == 'para':
+ nodeName_ == 'para':
childobj_ = docParaType.factory()
childobj_.build(child_)
obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
- MixedContainer.TypeNone, 'para', childobj_)
+ MixedContainer.TypeNone, 'para', childobj_)
self.content_.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'sect3':
+ nodeName_ == 'sect3':
childobj_ = docSect4Type.factory()
childobj_.build(child_)
obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
- MixedContainer.TypeNone, 'sect3', childobj_)
+ MixedContainer.TypeNone, 'sect3', childobj_)
self.content_.append(obj_)
elif child_.nodeType == Node.TEXT_NODE:
obj_ = self.mixedclass_(MixedContainer.CategoryText,
- MixedContainer.TypeNone, '', child_.nodeValue)
+ MixedContainer.TypeNone, '', child_.nodeValue)
self.content_.append(obj_)
# end class docInternalS3Type
@@ -5560,6 +6304,7 @@ class docInternalS3Type(GeneratedsSuper):
class docInternalS4Type(GeneratedsSuper):
subclass = None
superclass = None
+
def __init__(self, para=None, mixedclass_=None, content_=None):
if mixedclass_ is None:
self.mixedclass_ = MixedContainer
@@ -5569,6 +6314,7 @@ class docInternalS4Type(GeneratedsSuper):
self.content_ = []
else:
self.content_ = content_
+
def factory(*args_, **kwargs_):
if docInternalS4Type.subclass:
return docInternalS4Type.subclass(*args_, **kwargs_)
@@ -5579,32 +6325,40 @@ class docInternalS4Type(GeneratedsSuper):
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_, ))
- self.exportAttributes(outfile, level, namespace_, name_='docInternalS4Type')
+ self.exportAttributes(outfile, level, namespace_,
+ name_='docInternalS4Type')
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')
@@ -5612,25 +6366,28 @@ class docInternalS4Type(GeneratedsSuper):
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 \
- nodeName_ == 'para':
+ nodeName_ == 'para':
childobj_ = docParaType.factory()
childobj_.build(child_)
obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
- MixedContainer.TypeNone, 'para', childobj_)
+ MixedContainer.TypeNone, 'para', childobj_)
self.content_.append(obj_)
elif child_.nodeType == Node.TEXT_NODE:
obj_ = self.mixedclass_(MixedContainer.CategoryText,
- MixedContainer.TypeNone, '', child_.nodeValue)
+ MixedContainer.TypeNone, '', child_.nodeValue)
self.content_.append(obj_)
# end class docInternalS4Type
@@ -5638,6 +6395,7 @@ class docInternalS4Type(GeneratedsSuper):
class docTitleType(GeneratedsSuper):
subclass = None
superclass = None
+
def __init__(self, valueOf_='', mixedclass_=None, content_=None):
if mixedclass_ is None:
self.mixedclass_ = MixedContainer
@@ -5647,6 +6405,7 @@ class docTitleType(GeneratedsSuper):
self.content_ = []
else:
self.content_ = content_
+
def factory(*args_, **kwargs_):
if docTitleType.subclass:
return docTitleType.subclass(*args_, **kwargs_)
@@ -5655,6 +6414,7 @@ class docTitleType(GeneratedsSuper):
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_, ))
@@ -5662,33 +6422,40 @@ class docTitleType(GeneratedsSuper):
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'):
- if self.valueOf_.find('![CDATA')>-1:
- value=quote_xml('%s' % self.valueOf_)
- value=value.replace('![CDATA','<![CDATA')
- value=value.replace(']]',']]>')
+ if self.valueOf_.find('![CDATA') > -1:
+ value = quote_xml('%s' % self.valueOf_)
+ value = value.replace('![CDATA', '<![CDATA')
+ value = value.replace(']]', ']]>')
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)
@@ -5696,23 +6463,26 @@ class docTitleType(GeneratedsSuper):
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,
- MixedContainer.TypeNone, '', child_.nodeValue)
+ MixedContainer.TypeNone, '', child_.nodeValue)
self.content_.append(obj_)
if child_.nodeType == Node.TEXT_NODE:
self.valueOf_ += child_.nodeValue
elif child_.nodeType == Node.CDATA_SECTION_NODE:
- self.valueOf_ += '![CDATA['+child_.nodeValue+']]'
+ self.valueOf_ += '![CDATA[' + child_.nodeValue + ']]'
# 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
@@ -5722,6 +6492,7 @@ class docParaType(GeneratedsSuper):
self.content_ = []
else:
self.content_ = content_
+
def factory(*args_, **kwargs_):
if docParaType.subclass:
return docParaType.subclass(*args_, **kwargs_)
@@ -5730,6 +6501,7 @@ class docParaType(GeneratedsSuper):
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_, ))
@@ -5737,33 +6509,40 @@ class docParaType(GeneratedsSuper):
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'):
- if self.valueOf_.find('![CDATA')>-1:
- value=quote_xml('%s' % self.valueOf_)
- value=value.replace('![CDATA','<![CDATA')
- value=value.replace(']]',']]>')
+ if self.valueOf_.find('![CDATA') > -1:
+ value = quote_xml('%s' % self.valueOf_)
+ value = value.replace('![CDATA', '<![CDATA')
+ value = value.replace(']]', ']]>')
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)
@@ -5771,23 +6550,26 @@ class docParaType(GeneratedsSuper):
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,
- MixedContainer.TypeNone, '', child_.nodeValue)
+ MixedContainer.TypeNone, '', child_.nodeValue)
self.content_.append(obj_)
if child_.nodeType == Node.TEXT_NODE:
self.valueOf_ += child_.nodeValue
elif child_.nodeType == Node.CDATA_SECTION_NODE:
- self.valueOf_ += '![CDATA['+child_.nodeValue+']]'
+ self.valueOf_ += '![CDATA[' + child_.nodeValue + ']]'
# 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
@@ -5797,6 +6579,7 @@ class docMarkupType(GeneratedsSuper):
self.content_ = []
else:
self.content_ = content_
+
def factory(*args_, **kwargs_):
if docMarkupType.subclass:
return docMarkupType.subclass(*args_, **kwargs_)
@@ -5805,40 +6588,49 @@ class docMarkupType(GeneratedsSuper):
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_, ))
- self.exportAttributes(outfile, level, namespace_, name_='docMarkupType')
+ self.exportAttributes(outfile, level, namespace_,
+ name_='docMarkupType')
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'):
- if self.valueOf_.find('![CDATA')>-1:
- value=quote_xml('%s' % self.valueOf_)
- value=value.replace('![CDATA','<![CDATA')
- value=value.replace(']]',']]>')
+ if self.valueOf_.find('![CDATA') > -1:
+ value = quote_xml('%s' % self.valueOf_)
+ value = value.replace('![CDATA', '<![CDATA')
+ value = value.replace(']]', ']]>')
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)
@@ -5846,23 +6638,26 @@ class docMarkupType(GeneratedsSuper):
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,
- MixedContainer.TypeNone, '', child_.nodeValue)
+ MixedContainer.TypeNone, '', child_.nodeValue)
self.content_.append(obj_)
if child_.nodeType == Node.TEXT_NODE:
self.valueOf_ += child_.nodeValue
elif child_.nodeType == Node.CDATA_SECTION_NODE:
- self.valueOf_ += '![CDATA['+child_.nodeValue+']]'
+ self.valueOf_ += '![CDATA[' + child_.nodeValue + ']]'
# 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:
@@ -5873,6 +6668,7 @@ class docURLLink(GeneratedsSuper):
self.content_ = []
else:
self.content_ = content_
+
def factory(*args_, **kwargs_):
if docURLLink.subclass:
return docURLLink.subclass(*args_, **kwargs_)
@@ -5883,6 +6679,7 @@ class docURLLink(GeneratedsSuper):
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_, ))
@@ -5890,36 +6687,44 @@ class docURLLink(GeneratedsSuper):
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:
- outfile.write(' url=%s' % (self.format_string(quote_attrib(self.url).encode(ExternalEncoding), input_name='url'), ))
+ outfile.write(' url=%s' % (self.format_string(quote_attrib(
+ self.url).encode(ExternalEncoding), input_name='url'), ))
+
def exportChildren(self, outfile, level, namespace_='', name_='docURLLink'):
- if self.valueOf_.find('![CDATA')>-1:
- value=quote_xml('%s' % self.valueOf_)
- value=value.replace('![CDATA','<![CDATA')
- value=value.replace(']]',']]>')
+ if self.valueOf_.find('![CDATA') > -1:
+ value = quote_xml('%s' % self.valueOf_)
+ value = value.replace('![CDATA', '<![CDATA')
+ value = value.replace(']]', ']]>')
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)
@@ -5927,24 +6732,27 @@ class docURLLink(GeneratedsSuper):
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,
- MixedContainer.TypeNone, '', child_.nodeValue)
+ MixedContainer.TypeNone, '', child_.nodeValue)
self.content_.append(obj_)
if child_.nodeType == Node.TEXT_NODE:
self.valueOf_ += child_.nodeValue
elif child_.nodeType == Node.CDATA_SECTION_NODE:
- self.valueOf_ += '![CDATA['+child_.nodeValue+']]'
+ self.valueOf_ += '![CDATA[' + child_.nodeValue + ']]'
# 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:
@@ -5955,6 +6763,7 @@ class docAnchorType(GeneratedsSuper):
self.content_ = []
else:
self.content_ = content_
+
def factory(*args_, **kwargs_):
if docAnchorType.subclass:
return docAnchorType.subclass(*args_, **kwargs_)
@@ -5965,43 +6774,53 @@ class docAnchorType(GeneratedsSuper):
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_, ))
- self.exportAttributes(outfile, level, namespace_, name_='docAnchorType')
+ self.exportAttributes(outfile, level, namespace_,
+ name_='docAnchorType')
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:
- outfile.write(' id=%s' % (self.format_string(quote_attrib(self.id).encode(ExternalEncoding), input_name='id'), ))
+ outfile.write(' id=%s' % (self.format_string(quote_attrib(
+ self.id).encode(ExternalEncoding), input_name='id'), ))
+
def exportChildren(self, outfile, level, namespace_='', name_='docAnchorType'):
- if self.valueOf_.find('![CDATA')>-1:
- value=quote_xml('%s' % self.valueOf_)
- value=value.replace('![CDATA','<![CDATA')
- value=value.replace(']]',']]>')
+ if self.valueOf_.find('![CDATA') > -1:
+ value = quote_xml('%s' % self.valueOf_)
+ value = value.replace('![CDATA', '<![CDATA')
+ value = value.replace(']]', ']]>')
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)
@@ -6009,24 +6828,27 @@ class docAnchorType(GeneratedsSuper):
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,
- MixedContainer.TypeNone, '', child_.nodeValue)
+ MixedContainer.TypeNone, '', child_.nodeValue)
self.content_.append(obj_)
if child_.nodeType == Node.TEXT_NODE:
self.valueOf_ += child_.nodeValue
elif child_.nodeType == Node.CDATA_SECTION_NODE:
- self.valueOf_ += '![CDATA['+child_.nodeValue+']]'
+ self.valueOf_ += '![CDATA[' + child_.nodeValue + ']]'
# 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:
@@ -6037,6 +6859,7 @@ class docFormulaType(GeneratedsSuper):
self.content_ = []
else:
self.content_ = content_
+
def factory(*args_, **kwargs_):
if docFormulaType.subclass:
return docFormulaType.subclass(*args_, **kwargs_)
@@ -6047,43 +6870,53 @@ class docFormulaType(GeneratedsSuper):
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_, ))
- self.exportAttributes(outfile, level, namespace_, name_='docFormulaType')
+ self.exportAttributes(outfile, level, namespace_,
+ name_='docFormulaType')
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:
- outfile.write(' id=%s' % (self.format_string(quote_attrib(self.id).encode(ExternalEncoding), input_name='id'), ))
+ outfile.write(' id=%s' % (self.format_string(quote_attrib(
+ self.id).encode(ExternalEncoding), input_name='id'), ))
+
def exportChildren(self, outfile, level, namespace_='', name_='docFormulaType'):
- if self.valueOf_.find('![CDATA')>-1:
- value=quote_xml('%s' % self.valueOf_)
- value=value.replace('![CDATA','<![CDATA')
- value=value.replace(']]',']]>')
+ if self.valueOf_.find('![CDATA') > -1:
+ value = quote_xml('%s' % self.valueOf_)
+ value = value.replace('![CDATA', '<![CDATA')
+ value = value.replace(']]', ']]>')
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)
@@ -6091,27 +6924,31 @@ class docFormulaType(GeneratedsSuper):
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,
- MixedContainer.TypeNone, '', child_.nodeValue)
+ MixedContainer.TypeNone, '', child_.nodeValue)
self.content_.append(obj_)
if child_.nodeType == Node.TEXT_NODE:
self.valueOf_ += child_.nodeValue
elif child_.nodeType == Node.CDATA_SECTION_NODE:
- self.valueOf_ += '![CDATA['+child_.nodeValue+']]'
+ self.valueOf_ += '![CDATA[' + child_.nodeValue + ']]'
# 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_)
@@ -6122,10 +6959,12 @@ class docIndexEntryType(GeneratedsSuper):
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_, ))
- self.exportAttributes(outfile, level, namespace_, name_='docIndexEntryType')
+ self.exportAttributes(outfile, level, namespace_,
+ name_='docIndexEntryType')
if self.hasContent_():
outfile.write('>\n')
self.exportChildren(outfile, level + 1, namespace_, name_)
@@ -6133,52 +6972,65 @@ class docIndexEntryType(GeneratedsSuper):
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)
- outfile.write('<%sprimaryie>%s</%sprimaryie>\n' % (namespace_, self.format_string(quote_xml(self.primaryie).encode(ExternalEncoding), input_name='primaryie'), namespace_))
+ outfile.write('<%sprimaryie>%s</%sprimaryie>\n' % (namespace_, self.format_string(
+ quote_xml(self.primaryie).encode(ExternalEncoding), input_name='primaryie'), namespace_))
if self.secondaryie is not None:
showIndent(outfile, level)
- outfile.write('<%ssecondaryie>%s</%ssecondaryie>\n' % (namespace_, self.format_string(quote_xml(self.secondaryie).encode(ExternalEncoding), input_name='secondaryie'), namespace_))
+ outfile.write('<%ssecondaryie>%s</%ssecondaryie>\n' % (namespace_, self.format_string(
+ quote_xml(self.secondaryie).encode(ExternalEncoding), input_name='secondaryie'), namespace_))
+
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)
- outfile.write('primaryie=%s,\n' % quote_python(self.primaryie).encode(ExternalEncoding))
+ outfile.write('primaryie=%s,\n' % quote_python(
+ self.primaryie).encode(ExternalEncoding))
showIndent(outfile, level)
- outfile.write('secondaryie=%s,\n' % quote_python(self.secondaryie).encode(ExternalEncoding))
+ outfile.write('secondaryie=%s,\n' % quote_python(
+ self.secondaryie).encode(ExternalEncoding))
+
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 \
- nodeName_ == 'primaryie':
+ nodeName_ == 'primaryie':
primaryie_ = ''
for text__content_ in child_.childNodes:
primaryie_ += text__content_.nodeValue
self.primaryie = primaryie_
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'secondaryie':
+ nodeName_ == 'secondaryie':
secondaryie_ = ''
for text__content_ in child_.childNodes:
secondaryie_ += text__content_.nodeValue
@@ -6189,11 +7041,13 @@ class docIndexEntryType(GeneratedsSuper):
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_)
@@ -6204,6 +7058,7 @@ class docListType(GeneratedsSuper):
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_, ))
@@ -6215,25 +7070,31 @@ class docListType(GeneratedsSuper):
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')
@@ -6247,17 +7108,20 @@ class docListType(GeneratedsSuper):
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 \
- nodeName_ == 'listitem':
+ nodeName_ == 'listitem':
obj_ = docListItemType.factory()
obj_.build(child_)
self.listitem.append(obj_)
@@ -6267,11 +7131,13 @@ class docListType(GeneratedsSuper):
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_)
@@ -6282,10 +7148,12 @@ class docListItemType(GeneratedsSuper):
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_, ))
- self.exportAttributes(outfile, level, namespace_, name_='docListItemType')
+ self.exportAttributes(outfile, level, namespace_,
+ name_='docListItemType')
if self.hasContent_():
outfile.write('>\n')
self.exportChildren(outfile, level + 1, namespace_, name_)
@@ -6293,25 +7161,31 @@ class docListItemType(GeneratedsSuper):
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')
@@ -6325,17 +7199,20 @@ class docListItemType(GeneratedsSuper):
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 \
- nodeName_ == 'para':
+ nodeName_ == 'para':
obj_ = docParaType.factory()
obj_.build(child_)
self.para.append(obj_)
@@ -6345,6 +7222,7 @@ class docListItemType(GeneratedsSuper):
class docSimpleSectType(GeneratedsSuper):
subclass = None
superclass = None
+
def __init__(self, kind=None, title=None, para=None):
self.kind = kind
self.title = title
@@ -6352,6 +7230,7 @@ class docSimpleSectType(GeneratedsSuper):
self.para = []
else:
self.para = para
+
def factory(*args_, **kwargs_):
if docSimpleSectType.subclass:
return docSimpleSectType.subclass(*args_, **kwargs_)
@@ -6366,10 +7245,12 @@ class docSimpleSectType(GeneratedsSuper):
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_, ))
- self.exportAttributes(outfile, level, namespace_, name_='docSimpleSectType')
+ self.exportAttributes(outfile, level, namespace_,
+ name_='docSimpleSectType')
if self.hasContent_():
outfile.write('>\n')
self.exportChildren(outfile, level + 1, namespace_, name_)
@@ -6377,31 +7258,37 @@ class docSimpleSectType(GeneratedsSuper):
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)
@@ -6421,23 +7308,26 @@ class docSimpleSectType(GeneratedsSuper):
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 \
- nodeName_ == 'title':
+ nodeName_ == 'title':
obj_ = docTitleType.factory()
obj_.build(child_)
self.set_title(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'para':
+ nodeName_ == 'para':
obj_ = docParaType.factory()
obj_.build(child_)
self.para.append(obj_)
@@ -6447,8 +7337,10 @@ class docSimpleSectType(GeneratedsSuper):
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_)
@@ -6457,10 +7349,12 @@ class docVarListEntryType(GeneratedsSuper):
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_, ))
- self.exportAttributes(outfile, level, namespace_, name_='docVarListEntryType')
+ self.exportAttributes(outfile, level, namespace_,
+ name_='docVarListEntryType')
if self.hasContent_():
outfile.write('>\n')
self.exportChildren(outfile, level + 1, namespace_, name_)
@@ -6468,25 +7362,31 @@ class docVarListEntryType(GeneratedsSuper):
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)
@@ -6494,17 +7394,20 @@ class docVarListEntryType(GeneratedsSuper):
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 \
- nodeName_ == 'term':
+ nodeName_ == 'term':
obj_ = docTitleType.factory()
obj_.build(child_)
self.set_term(obj_)
@@ -6514,8 +7417,10 @@ class docVarListEntryType(GeneratedsSuper):
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_)
@@ -6524,10 +7429,12 @@ class docVariableListType(GeneratedsSuper):
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_, ))
- self.exportAttributes(outfile, level, namespace_, name_='docVariableListType')
+ self.exportAttributes(outfile, level, namespace_,
+ name_='docVariableListType')
if self.hasContent_():
outfile.write('>\n')
self.exportChildren(outfile, level + 1, namespace_, name_)
@@ -6535,33 +7442,40 @@ class docVariableListType(GeneratedsSuper):
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'):
- if self.valueOf_.find('![CDATA')>-1:
- value=quote_xml('%s' % self.valueOf_)
- value=value.replace('![CDATA','<![CDATA')
- value=value.replace(']]',']]>')
+ if self.valueOf_.find('![CDATA') > -1:
+ value = quote_xml('%s' % self.valueOf_)
+ value = value.replace('![CDATA', '<![CDATA')
+ value = value.replace(']]', ']]>')
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)
@@ -6569,19 +7483,22 @@ class docVariableListType(GeneratedsSuper):
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:
- self.valueOf_ += '![CDATA['+child_.nodeValue+']]'
+ self.valueOf_ += '![CDATA[' + child_.nodeValue + ']]'
# 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
@@ -6594,6 +7511,7 @@ class docRefTextType(GeneratedsSuper):
self.content_ = []
else:
self.content_ = content_
+
def factory(*args_, **kwargs_):
if docRefTextType.subclass:
return docRefTextType.subclass(*args_, **kwargs_)
@@ -6608,40 +7526,49 @@ class docRefTextType(GeneratedsSuper):
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_, ))
- self.exportAttributes(outfile, level, namespace_, name_='docRefTextType')
+ self.exportAttributes(outfile, level, namespace_,
+ name_='docRefTextType')
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:
- outfile.write(' refid=%s' % (self.format_string(quote_attrib(self.refid).encode(ExternalEncoding), input_name='refid'), ))
+ outfile.write(' refid=%s' % (self.format_string(quote_attrib(
+ self.refid).encode(ExternalEncoding), input_name='refid'), ))
if self.kindref is not None:
outfile.write(' kindref=%s' % (quote_attrib(self.kindref), ))
if self.external is not None:
- outfile.write(' external=%s' % (self.format_string(quote_attrib(self.external).encode(ExternalEncoding), input_name='external'), ))
+ outfile.write(' external=%s' % (self.format_string(quote_attrib(
+ self.external).encode(ExternalEncoding), input_name='external'), ))
+
def exportChildren(self, outfile, level, namespace_='', name_='docRefTextType'):
- if self.valueOf_.find('![CDATA')>-1:
- value=quote_xml('%s' % self.valueOf_)
- value=value.replace('![CDATA','<![CDATA')
- value=value.replace(']]',']]>')
+ if self.valueOf_.find('![CDATA') > -1:
+ value = quote_xml('%s' % self.valueOf_)
+ value = value.replace('![CDATA', '<![CDATA')
+ value = value.replace(']]', ']]>')
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)
@@ -6652,9 +7579,11 @@ class docRefTextType(GeneratedsSuper):
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)
@@ -6662,6 +7591,7 @@ class docRefTextType(GeneratedsSuper):
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
@@ -6669,21 +7599,23 @@ class docRefTextType(GeneratedsSuper):
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,
- MixedContainer.TypeNone, '', child_.nodeValue)
+ MixedContainer.TypeNone, '', child_.nodeValue)
self.content_.append(obj_)
if child_.nodeType == Node.TEXT_NODE:
self.valueOf_ += child_.nodeValue
elif child_.nodeType == Node.CDATA_SECTION_NODE:
- self.valueOf_ += '![CDATA['+child_.nodeValue+']]'
+ self.valueOf_ += '![CDATA[' + child_.nodeValue + ']]'
# 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
@@ -6692,6 +7624,7 @@ class docTableType(GeneratedsSuper):
else:
self.row = row
self.caption = caption
+
def factory(*args_, **kwargs_):
if docTableType.subclass:
return docTableType.subclass(*args_, **kwargs_)
@@ -6708,6 +7641,7 @@ class docTableType(GeneratedsSuper):
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_, ))
@@ -6719,29 +7653,36 @@ class docTableType(GeneratedsSuper):
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:
- outfile.write(' rows="%s"' % self.format_integer(self.rows, input_name='rows'))
+ outfile.write(' rows="%s"' % self.format_integer(
+ self.rows, input_name='rows'))
if self.cols is not None:
- outfile.write(' cols="%s"' % self.format_integer(self.cols, input_name='cols'))
+ outfile.write(' cols="%s"' % self.format_integer(
+ self.cols, input_name='cols'))
+
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)
@@ -6749,6 +7690,7 @@ class docTableType(GeneratedsSuper):
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')
@@ -6768,12 +7710,14 @@ class docTableType(GeneratedsSuper):
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:
@@ -6785,14 +7729,15 @@ class docTableType(GeneratedsSuper):
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 \
- nodeName_ == 'row':
+ nodeName_ == 'row':
obj_ = docRowType.factory()
obj_.build(child_)
self.row.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'caption':
+ nodeName_ == 'caption':
obj_ = docCaptionType.factory()
obj_.build(child_)
self.set_caption(obj_)
@@ -6802,11 +7747,13 @@ class docTableType(GeneratedsSuper):
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_)
@@ -6817,6 +7764,7 @@ class docRowType(GeneratedsSuper):
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_, ))
@@ -6828,25 +7776,31 @@ class docRowType(GeneratedsSuper):
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')
@@ -6860,17 +7814,20 @@ class docRowType(GeneratedsSuper):
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 \
- nodeName_ == 'entry':
+ nodeName_ == 'entry':
obj_ = docEntryType.factory()
obj_.build(child_)
self.entry.append(obj_)
@@ -6880,12 +7837,14 @@ class docRowType(GeneratedsSuper):
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_)
@@ -6898,6 +7857,7 @@ class docEntryType(GeneratedsSuper):
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_, ))
@@ -6909,28 +7869,34 @@ class docEntryType(GeneratedsSuper):
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
else:
return False
+
def exportLiteral(self, outfile, level, name_='docEntryType'):
level += 1
self.exportLiteralAttributes(outfile, level, name_)
if self.hasContent_():
self.exportLiteralChildren(outfile, level, name_)
+
def exportLiteralAttributes(self, outfile, level, name_):
if self.thead is not None:
showIndent(outfile, level)
outfile.write('thead = "%s",\n' % (self.thead,))
+
def exportLiteralChildren(self, outfile, level, name_):
showIndent(outfile, level)
outfile.write('para=[\n')
@@ -6944,18 +7910,21 @@ class docEntryType(GeneratedsSuper):
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('thead'):
self.thead = attrs.get('thead').value
+
def buildChildren(self, child_, nodeName_):
if child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'para':
+ nodeName_ == 'para':
obj_ = docParaType.factory()
obj_.build(child_)
self.para.append(obj_)
@@ -6965,6 +7934,7 @@ class docEntryType(GeneratedsSuper):
class docCaptionType(GeneratedsSuper):
subclass = None
superclass = None
+
def __init__(self, valueOf_='', mixedclass_=None, content_=None):
if mixedclass_ is None:
self.mixedclass_ = MixedContainer
@@ -6974,6 +7944,7 @@ class docCaptionType(GeneratedsSuper):
self.content_ = []
else:
self.content_ = content_
+
def factory(*args_, **kwargs_):
if docCaptionType.subclass:
return docCaptionType.subclass(*args_, **kwargs_)
@@ -6982,40 +7953,49 @@ class docCaptionType(GeneratedsSuper):
factory = staticmethod(factory)
def getValueOf_(self): return self.valueOf_
def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_
+
def export(self, outfile, level, namespace_='', name_='docCaptionType', namespacedef_=''):
showIndent(outfile, level)
outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))
- self.exportAttributes(outfile, level, namespace_, name_='docCaptionType')
+ self.exportAttributes(outfile, level, namespace_,
+ name_='docCaptionType')
outfile.write('>')
self.exportChildren(outfile, level + 1, namespace_, name_)
outfile.write('</%s%s>\n' % (namespace_, name_))
+
def exportAttributes(self, outfile, level, namespace_='', name_='docCaptionType'):
pass
+
def exportChildren(self, outfile, level, namespace_='', name_='docCaptionType'):
- if self.valueOf_.find('![CDATA')>-1:
- value=quote_xml('%s' % self.valueOf_)
- value=value.replace('![CDATA','<![CDATA')
- value=value.replace(']]',']]>')
+ if self.valueOf_.find('![CDATA') > -1:
+ value = quote_xml('%s' % self.valueOf_)
+ value = value.replace('![CDATA', '<![CDATA')
+ value = value.replace(']]', ']]>')
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_='docCaptionType'):
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)
@@ -7023,23 +8003,26 @@ class docCaptionType(GeneratedsSuper):
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,
- MixedContainer.TypeNone, '', child_.nodeValue)
+ MixedContainer.TypeNone, '', child_.nodeValue)
self.content_.append(obj_)
if child_.nodeType == Node.TEXT_NODE:
self.valueOf_ += child_.nodeValue
elif child_.nodeType == Node.CDATA_SECTION_NODE:
- self.valueOf_ += '![CDATA['+child_.nodeValue+']]'
+ self.valueOf_ += '![CDATA[' + child_.nodeValue + ']]'
# end class docCaptionType
class docHeadingType(GeneratedsSuper):
subclass = None
superclass = None
+
def __init__(self, level=None, valueOf_='', mixedclass_=None, content_=None):
self.level = level
if mixedclass_ is None:
@@ -7050,6 +8033,7 @@ class docHeadingType(GeneratedsSuper):
self.content_ = []
else:
self.content_ = content_
+
def factory(*args_, **kwargs_):
if docHeadingType.subclass:
return docHeadingType.subclass(*args_, **kwargs_)
@@ -7060,43 +8044,53 @@ class docHeadingType(GeneratedsSuper):
def set_level(self, level): self.level = level
def getValueOf_(self): return self.valueOf_
def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_
+
def export(self, outfile, level, namespace_='', name_='docHeadingType', namespacedef_=''):
showIndent(outfile, level)
outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))
- self.exportAttributes(outfile, level, namespace_, name_='docHeadingType')
+ self.exportAttributes(outfile, level, namespace_,
+ name_='docHeadingType')
outfile.write('>')
self.exportChildren(outfile, level + 1, namespace_, name_)
outfile.write('</%s%s>\n' % (namespace_, name_))
+
def exportAttributes(self, outfile, level, namespace_='', name_='docHeadingType'):
if self.level is not None:
- outfile.write(' level="%s"' % self.format_integer(self.level, input_name='level'))
+ outfile.write(' level="%s"' % self.format_integer(
+ self.level, input_name='level'))
+
def exportChildren(self, outfile, level, namespace_='', name_='docHeadingType'):
- if self.valueOf_.find('![CDATA')>-1:
- value=quote_xml('%s' % self.valueOf_)
- value=value.replace('![CDATA','<![CDATA')
- value=value.replace(']]',']]>')
+ if self.valueOf_.find('![CDATA') > -1:
+ value = quote_xml('%s' % self.valueOf_)
+ value = value.replace('![CDATA', '<![CDATA')
+ value = value.replace(']]', ']]>')
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_='docHeadingType'):
level += 1
self.exportLiteralAttributes(outfile, level, name_)
if self.hasContent_():
self.exportLiteralChildren(outfile, level, name_)
+
def exportLiteralAttributes(self, outfile, level, name_):
if self.level is not None:
showIndent(outfile, level)
outfile.write('level = %s,\n' % (self.level,))
+
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)
@@ -7104,27 +8098,30 @@ class docHeadingType(GeneratedsSuper):
for child_ in node_.childNodes:
nodeName_ = child_.nodeName.split(':')[-1]
self.buildChildren(child_, nodeName_)
+
def buildAttributes(self, attrs):
if attrs.get('level'):
try:
self.level = int(attrs.get('level').value)
except ValueError as exp:
raise ValueError('Bad integer attribute (level): %s' % exp)
+
def buildChildren(self, child_, nodeName_):
if child_.nodeType == Node.TEXT_NODE:
obj_ = self.mixedclass_(MixedContainer.CategoryText,
- MixedContainer.TypeNone, '', child_.nodeValue)
+ MixedContainer.TypeNone, '', child_.nodeValue)
self.content_.append(obj_)
if child_.nodeType == Node.TEXT_NODE:
self.valueOf_ += child_.nodeValue
elif child_.nodeType == Node.CDATA_SECTION_NODE:
- self.valueOf_ += '![CDATA['+child_.nodeValue+']]'
+ self.valueOf_ += '![CDATA[' + child_.nodeValue + ']]'
# end class docHeadingType
class docImageType(GeneratedsSuper):
subclass = None
superclass = None
+
def __init__(self, width=None, type_=None, name=None, height=None, valueOf_='', mixedclass_=None, content_=None):
self.width = width
self.type_ = type_
@@ -7138,6 +8135,7 @@ class docImageType(GeneratedsSuper):
self.content_ = []
else:
self.content_ = content_
+
def factory(*args_, **kwargs_):
if docImageType.subclass:
return docImageType.subclass(*args_, **kwargs_)
@@ -7154,6 +8152,7 @@ class docImageType(GeneratedsSuper):
def set_height(self, height): self.height = height
def getValueOf_(self): return self.valueOf_
def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_
+
def export(self, outfile, level, namespace_='', name_='docImageType', namespacedef_=''):
showIndent(outfile, level)
outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))
@@ -7161,35 +8160,43 @@ class docImageType(GeneratedsSuper):
outfile.write('>')
self.exportChildren(outfile, level + 1, namespace_, name_)
outfile.write('</%s%s>\n' % (namespace_, name_))
+
def exportAttributes(self, outfile, level, namespace_='', name_='docImageType'):
if self.width is not None:
- outfile.write(' width=%s' % (self.format_string(quote_attrib(self.width).encode(ExternalEncoding), input_name='width'), ))
+ outfile.write(' width=%s' % (self.format_string(quote_attrib(
+ self.width).encode(ExternalEncoding), input_name='width'), ))
if self.type_ is not None:
outfile.write(' type=%s' % (quote_attrib(self.type_), ))
if self.name is not None:
- outfile.write(' name=%s' % (self.format_string(quote_attrib(self.name).encode(ExternalEncoding), input_name='name'), ))
+ outfile.write(' name=%s' % (self.format_string(quote_attrib(
+ self.name).encode(ExternalEncoding), input_name='name'), ))
if self.height is not None:
- outfile.write(' height=%s' % (self.format_string(quote_attrib(self.height).encode(ExternalEncoding), input_name='height'), ))
+ outfile.write(' height=%s' % (self.format_string(quote_attrib(
+ self.height).encode(ExternalEncoding), input_name='height'), ))
+
def exportChildren(self, outfile, level, namespace_='', name_='docImageType'):
- if self.valueOf_.find('![CDATA')>-1:
- value=quote_xml('%s' % self.valueOf_)
- value=value.replace('![CDATA','<![CDATA')
- value=value.replace(']]',']]>')
+ if self.valueOf_.find('![CDATA') > -1:
+ value = quote_xml('%s' % self.valueOf_)
+ value = value.replace('![CDATA', '<![CDATA')
+ value = value.replace(']]', ']]>')
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_='docImageType'):
level += 1
self.exportLiteralAttributes(outfile, level, name_)
if self.hasContent_():
self.exportLiteralChildren(outfile, level, name_)
+
def exportLiteralAttributes(self, outfile, level, name_):
if self.width is not None:
showIndent(outfile, level)
@@ -7203,9 +8210,11 @@ class docImageType(GeneratedsSuper):
if self.height is not None:
showIndent(outfile, level)
outfile.write('height = %s,\n' % (self.height,))
+
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)
@@ -7213,6 +8222,7 @@ class docImageType(GeneratedsSuper):
for child_ in node_.childNodes:
nodeName_ = child_.nodeName.split(':')[-1]
self.buildChildren(child_, nodeName_)
+
def buildAttributes(self, attrs):
if attrs.get('width'):
self.width = attrs.get('width').value
@@ -7222,21 +8232,23 @@ class docImageType(GeneratedsSuper):
self.name = attrs.get('name').value
if attrs.get('height'):
self.height = attrs.get('height').value
+
def buildChildren(self, child_, nodeName_):
if child_.nodeType == Node.TEXT_NODE:
obj_ = self.mixedclass_(MixedContainer.CategoryText,
- MixedContainer.TypeNone, '', child_.nodeValue)
+ MixedContainer.TypeNone, '', child_.nodeValue)
self.content_.append(obj_)
if child_.nodeType == Node.TEXT_NODE:
self.valueOf_ += child_.nodeValue
elif child_.nodeType == Node.CDATA_SECTION_NODE:
- self.valueOf_ += '![CDATA['+child_.nodeValue+']]'
+ self.valueOf_ += '![CDATA[' + child_.nodeValue + ']]'
# end class docImageType
class docDotFileType(GeneratedsSuper):
subclass = None
superclass = None
+
def __init__(self, name=None, valueOf_='', mixedclass_=None, content_=None):
self.name = name
if mixedclass_ is None:
@@ -7247,6 +8259,7 @@ class docDotFileType(GeneratedsSuper):
self.content_ = []
else:
self.content_ = content_
+
def factory(*args_, **kwargs_):
if docDotFileType.subclass:
return docDotFileType.subclass(*args_, **kwargs_)
@@ -7257,43 +8270,53 @@ class docDotFileType(GeneratedsSuper):
def set_name(self, name): self.name = name
def getValueOf_(self): return self.valueOf_
def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_
+
def export(self, outfile, level, namespace_='', name_='docDotFileType', namespacedef_=''):
showIndent(outfile, level)
outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))
- self.exportAttributes(outfile, level, namespace_, name_='docDotFileType')
+ self.exportAttributes(outfile, level, namespace_,
+ name_='docDotFileType')
outfile.write('>')
self.exportChildren(outfile, level + 1, namespace_, name_)
outfile.write('</%s%s>\n' % (namespace_, name_))
+
def exportAttributes(self, outfile, level, namespace_='', name_='docDotFileType'):
if self.name is not None:
- outfile.write(' name=%s' % (self.format_string(quote_attrib(self.name).encode(ExternalEncoding), input_name='name'), ))
+ outfile.write(' name=%s' % (self.format_string(quote_attrib(
+ self.name).encode(ExternalEncoding), input_name='name'), ))
+
def exportChildren(self, outfile, level, namespace_='', name_='docDotFileType'):
- if self.valueOf_.find('![CDATA')>-1:
- value=quote_xml('%s' % self.valueOf_)
- value=value.replace('![CDATA','<![CDATA')
- value=value.replace(']]',']]>')
+ if self.valueOf_.find('![CDATA') > -1:
+ value = quote_xml('%s' % self.valueOf_)
+ value = value.replace('![CDATA', '<![CDATA')
+ value = value.replace(']]', ']]>')
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_='docDotFileType'):
level += 1
self.exportLiteralAttributes(outfile, level, name_)
if self.hasContent_():
self.exportLiteralChildren(outfile, level, name_)
+
def exportLiteralAttributes(self, outfile, level, name_):
if self.name is not None:
showIndent(outfile, level)
outfile.write('name = %s,\n' % (self.name,))
+
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)
@@ -7301,24 +8324,27 @@ class docDotFileType(GeneratedsSuper):
for child_ in node_.childNodes:
nodeName_ = child_.nodeName.split(':')[-1]
self.buildChildren(child_, nodeName_)
+
def buildAttributes(self, attrs):
if attrs.get('name'):
self.name = attrs.get('name').value
+
def buildChildren(self, child_, nodeName_):
if child_.nodeType == Node.TEXT_NODE:
obj_ = self.mixedclass_(MixedContainer.CategoryText,
- MixedContainer.TypeNone, '', child_.nodeValue)
+ MixedContainer.TypeNone, '', child_.nodeValue)
self.content_.append(obj_)
if child_.nodeType == Node.TEXT_NODE:
self.valueOf_ += child_.nodeValue
elif child_.nodeType == Node.CDATA_SECTION_NODE:
- self.valueOf_ += '![CDATA['+child_.nodeValue+']]'
+ self.valueOf_ += '![CDATA[' + child_.nodeValue + ']]'
# end class docDotFileType
class docTocItemType(GeneratedsSuper):
subclass = None
superclass = None
+
def __init__(self, id=None, valueOf_='', mixedclass_=None, content_=None):
self.id = id
if mixedclass_ is None:
@@ -7329,6 +8355,7 @@ class docTocItemType(GeneratedsSuper):
self.content_ = []
else:
self.content_ = content_
+
def factory(*args_, **kwargs_):
if docTocItemType.subclass:
return docTocItemType.subclass(*args_, **kwargs_)
@@ -7339,43 +8366,53 @@ class docTocItemType(GeneratedsSuper):
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_='docTocItemType', namespacedef_=''):
showIndent(outfile, level)
outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))
- self.exportAttributes(outfile, level, namespace_, name_='docTocItemType')
+ self.exportAttributes(outfile, level, namespace_,
+ name_='docTocItemType')
outfile.write('>')
self.exportChildren(outfile, level + 1, namespace_, name_)
outfile.write('</%s%s>\n' % (namespace_, name_))
+
def exportAttributes(self, outfile, level, namespace_='', name_='docTocItemType'):
if self.id is not None:
- outfile.write(' id=%s' % (self.format_string(quote_attrib(self.id).encode(ExternalEncoding), input_name='id'), ))
+ outfile.write(' id=%s' % (self.format_string(quote_attrib(
+ self.id).encode(ExternalEncoding), input_name='id'), ))
+
def exportChildren(self, outfile, level, namespace_='', name_='docTocItemType'):
- if self.valueOf_.find('![CDATA')>-1:
- value=quote_xml('%s' % self.valueOf_)
- value=value.replace('![CDATA','<![CDATA')
- value=value.replace(']]',']]>')
+ if self.valueOf_.find('![CDATA') > -1:
+ value = quote_xml('%s' % self.valueOf_)
+ value = value.replace('![CDATA', '<![CDATA')
+ value = value.replace(']]', ']]>')
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_='docTocItemType'):
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)
@@ -7383,29 +8420,33 @@ class docTocItemType(GeneratedsSuper):
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,
- MixedContainer.TypeNone, '', child_.nodeValue)
+ MixedContainer.TypeNone, '', child_.nodeValue)
self.content_.append(obj_)
if child_.nodeType == Node.TEXT_NODE:
self.valueOf_ += child_.nodeValue
elif child_.nodeType == Node.CDATA_SECTION_NODE:
- self.valueOf_ += '![CDATA['+child_.nodeValue+']]'
+ self.valueOf_ += '![CDATA[' + child_.nodeValue + ']]'
# end class docTocItemType
class docTocListType(GeneratedsSuper):
subclass = None
superclass = None
+
def __init__(self, tocitem=None):
if tocitem is None:
self.tocitem = []
else:
self.tocitem = tocitem
+
def factory(*args_, **kwargs_):
if docTocListType.subclass:
return docTocListType.subclass(*args_, **kwargs_)
@@ -7416,10 +8457,12 @@ class docTocListType(GeneratedsSuper):
def set_tocitem(self, tocitem): self.tocitem = tocitem
def add_tocitem(self, value): self.tocitem.append(value)
def insert_tocitem(self, index, value): self.tocitem[index] = value
+
def export(self, outfile, level, namespace_='', name_='docTocListType', namespacedef_=''):
showIndent(outfile, level)
outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))
- self.exportAttributes(outfile, level, namespace_, name_='docTocListType')
+ self.exportAttributes(outfile, level, namespace_,
+ name_='docTocListType')
if self.hasContent_():
outfile.write('>\n')
self.exportChildren(outfile, level + 1, namespace_, name_)
@@ -7427,25 +8470,31 @@ class docTocListType(GeneratedsSuper):
outfile.write('</%s%s>\n' % (namespace_, name_))
else:
outfile.write(' />\n')
+
def exportAttributes(self, outfile, level, namespace_='', name_='docTocListType'):
pass
+
def exportChildren(self, outfile, level, namespace_='', name_='docTocListType'):
for tocitem_ in self.tocitem:
tocitem_.export(outfile, level, namespace_, name_='tocitem')
+
def hasContent_(self):
if (
self.tocitem is not None
- ):
+ ):
return True
else:
return False
+
def exportLiteral(self, outfile, level, name_='docTocListType'):
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('tocitem=[\n')
@@ -7459,17 +8508,20 @@ class docTocListType(GeneratedsSuper):
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 \
- nodeName_ == 'tocitem':
+ nodeName_ == 'tocitem':
obj_ = docTocItemType.factory()
obj_.build(child_)
self.tocitem.append(obj_)
@@ -7479,12 +8531,14 @@ class docTocListType(GeneratedsSuper):
class docLanguageType(GeneratedsSuper):
subclass = None
superclass = None
+
def __init__(self, langid=None, para=None):
self.langid = langid
if para is None:
self.para = []
else:
self.para = para
+
def factory(*args_, **kwargs_):
if docLanguageType.subclass:
return docLanguageType.subclass(*args_, **kwargs_)
@@ -7497,10 +8551,12 @@ class docLanguageType(GeneratedsSuper):
def insert_para(self, index, value): self.para[index] = value
def get_langid(self): return self.langid
def set_langid(self, langid): self.langid = langid
+
def export(self, outfile, level, namespace_='', name_='docLanguageType', namespacedef_=''):
showIndent(outfile, level)
outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))
- self.exportAttributes(outfile, level, namespace_, name_='docLanguageType')
+ self.exportAttributes(outfile, level, namespace_,
+ name_='docLanguageType')
if self.hasContent_():
outfile.write('>\n')
self.exportChildren(outfile, level + 1, namespace_, name_)
@@ -7508,28 +8564,35 @@ class docLanguageType(GeneratedsSuper):
outfile.write('</%s%s>\n' % (namespace_, name_))
else:
outfile.write(' />\n')
+
def exportAttributes(self, outfile, level, namespace_='', name_='docLanguageType'):
if self.langid is not None:
- outfile.write(' langid=%s' % (self.format_string(quote_attrib(self.langid).encode(ExternalEncoding), input_name='langid'), ))
+ outfile.write(' langid=%s' % (self.format_string(quote_attrib(
+ self.langid).encode(ExternalEncoding), input_name='langid'), ))
+
def exportChildren(self, outfile, level, namespace_='', name_='docLanguageType'):
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_='docLanguageType'):
level += 1
self.exportLiteralAttributes(outfile, level, name_)
if self.hasContent_():
self.exportLiteralChildren(outfile, level, name_)
+
def exportLiteralAttributes(self, outfile, level, name_):
if self.langid is not None:
showIndent(outfile, level)
outfile.write('langid = %s,\n' % (self.langid,))
+
def exportLiteralChildren(self, outfile, level, name_):
showIndent(outfile, level)
outfile.write('para=[\n')
@@ -7543,18 +8606,21 @@ class docLanguageType(GeneratedsSuper):
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('langid'):
self.langid = attrs.get('langid').value
+
def buildChildren(self, child_, nodeName_):
if child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'para':
+ nodeName_ == 'para':
obj_ = docParaType.factory()
obj_.build(child_)
self.para.append(obj_)
@@ -7564,12 +8630,14 @@ class docLanguageType(GeneratedsSuper):
class docParamListType(GeneratedsSuper):
subclass = None
superclass = None
+
def __init__(self, kind=None, parameteritem=None):
self.kind = kind
if parameteritem is None:
self.parameteritem = []
else:
self.parameteritem = parameteritem
+
def factory(*args_, **kwargs_):
if docParamListType.subclass:
return docParamListType.subclass(*args_, **kwargs_)
@@ -7577,15 +8645,21 @@ class docParamListType(GeneratedsSuper):
return docParamListType(*args_, **kwargs_)
factory = staticmethod(factory)
def get_parameteritem(self): return self.parameteritem
- def set_parameteritem(self, parameteritem): self.parameteritem = parameteritem
+ def set_parameteritem(
+ self, parameteritem): self.parameteritem = parameteritem
+
def add_parameteritem(self, value): self.parameteritem.append(value)
- def insert_parameteritem(self, index, value): self.parameteritem[index] = value
+ def insert_parameteritem(
+ self, index, value): self.parameteritem[index] = value
+
def get_kind(self): return self.kind
def set_kind(self, kind): self.kind = kind
+
def export(self, outfile, level, namespace_='', name_='docParamListType', namespacedef_=''):
showIndent(outfile, level)
outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))
- self.exportAttributes(outfile, level, namespace_, name_='docParamListType')
+ self.exportAttributes(outfile, level, namespace_,
+ name_='docParamListType')
if self.hasContent_():
outfile.write('>\n')
self.exportChildren(outfile, level + 1, namespace_, name_)
@@ -7593,28 +8667,35 @@ class docParamListType(GeneratedsSuper):
outfile.write('</%s%s>\n' % (namespace_, name_))
else:
outfile.write(' />\n')
+
def exportAttributes(self, outfile, level, namespace_='', name_='docParamListType'):
if self.kind is not None:
outfile.write(' kind=%s' % (quote_attrib(self.kind), ))
+
def exportChildren(self, outfile, level, namespace_='', name_='docParamListType'):
for parameteritem_ in self.parameteritem:
- parameteritem_.export(outfile, level, namespace_, name_='parameteritem')
+ parameteritem_.export(
+ outfile, level, namespace_, name_='parameteritem')
+
def hasContent_(self):
if (
self.parameteritem is not None
- ):
+ ):
return True
else:
return False
+
def exportLiteral(self, outfile, level, name_='docParamListType'):
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)
outfile.write('parameteritem=[\n')
@@ -7628,18 +8709,21 @@ class docParamListType(GeneratedsSuper):
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 \
- nodeName_ == 'parameteritem':
+ nodeName_ == 'parameteritem':
obj_ = docParamListItem.factory()
obj_.build(child_)
self.parameteritem.append(obj_)
@@ -7649,12 +8733,14 @@ class docParamListType(GeneratedsSuper):
class docParamListItem(GeneratedsSuper):
subclass = None
superclass = None
+
def __init__(self, parameternamelist=None, parameterdescription=None):
if parameternamelist is None:
self.parameternamelist = []
else:
self.parameternamelist = parameternamelist
self.parameterdescription = parameterdescription
+
def factory(*args_, **kwargs_):
if docParamListItem.subclass:
return docParamListItem.subclass(*args_, **kwargs_)
@@ -7662,15 +8748,25 @@ class docParamListItem(GeneratedsSuper):
return docParamListItem(*args_, **kwargs_)
factory = staticmethod(factory)
def get_parameternamelist(self): return self.parameternamelist
- def set_parameternamelist(self, parameternamelist): self.parameternamelist = parameternamelist
- def add_parameternamelist(self, value): self.parameternamelist.append(value)
- def insert_parameternamelist(self, index, value): self.parameternamelist[index] = value
+
+ def set_parameternamelist(
+ self, parameternamelist): self.parameternamelist = parameternamelist
+
+ def add_parameternamelist(
+ self, value): self.parameternamelist.append(value)
+ def insert_parameternamelist(
+ self, index, value): self.parameternamelist[index] = value
+
def get_parameterdescription(self): return self.parameterdescription
- def set_parameterdescription(self, parameterdescription): self.parameterdescription = parameterdescription
+
+ def set_parameterdescription(
+ self, parameterdescription): self.parameterdescription = parameterdescription
+
def export(self, outfile, level, namespace_='', name_='docParamListItem', namespacedef_=''):
showIndent(outfile, level)
outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))
- self.exportAttributes(outfile, level, namespace_, name_='docParamListItem')
+ self.exportAttributes(outfile, level, namespace_,
+ name_='docParamListItem')
if self.hasContent_():
outfile.write('>\n')
self.exportChildren(outfile, level + 1, namespace_, name_)
@@ -7678,28 +8774,36 @@ class docParamListItem(GeneratedsSuper):
outfile.write('</%s%s>\n' % (namespace_, name_))
else:
outfile.write(' />\n')
+
def exportAttributes(self, outfile, level, namespace_='', name_='docParamListItem'):
pass
+
def exportChildren(self, outfile, level, namespace_='', name_='docParamListItem'):
for parameternamelist_ in self.parameternamelist:
- parameternamelist_.export(outfile, level, namespace_, name_='parameternamelist')
+ parameternamelist_.export(
+ outfile, level, namespace_, name_='parameternamelist')
if self.parameterdescription:
- self.parameterdescription.export(outfile, level, namespace_, name_='parameterdescription', )
+ self.parameterdescription.export(
+ outfile, level, namespace_, name_='parameterdescription', )
+
def hasContent_(self):
if (
self.parameternamelist is not None or
self.parameterdescription is not None
- ):
+ ):
return True
else:
return False
+
def exportLiteral(self, outfile, level, name_='docParamListItem'):
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('parameternamelist=[\n')
@@ -7707,7 +8811,8 @@ class docParamListItem(GeneratedsSuper):
for parameternamelist in self.parameternamelist:
showIndent(outfile, level)
outfile.write('model_.parameternamelist(\n')
- parameternamelist.exportLiteral(outfile, level, name_='parameternamelist')
+ parameternamelist.exportLiteral(
+ outfile, level, name_='parameternamelist')
showIndent(outfile, level)
outfile.write('),\n')
level -= 1
@@ -7716,25 +8821,29 @@ class docParamListItem(GeneratedsSuper):
if self.parameterdescription:
showIndent(outfile, level)
outfile.write('parameterdescription=model_.descriptionType(\n')
- self.parameterdescription.exportLiteral(outfile, level, name_='parameterdescription')
+ self.parameterdescription.exportLiteral(
+ outfile, level, name_='parameterdescription')
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 \
- nodeName_ == 'parameternamelist':
+ nodeName_ == 'parameternamelist':
obj_ = docParamNameList.factory()
obj_.build(child_)
self.parameternamelist.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'parameterdescription':
+ nodeName_ == 'parameterdescription':
obj_ = descriptionType.factory()
obj_.build(child_)
self.set_parameterdescription(obj_)
@@ -7744,11 +8853,13 @@ class docParamListItem(GeneratedsSuper):
class docParamNameList(GeneratedsSuper):
subclass = None
superclass = None
+
def __init__(self, parametername=None):
if parametername is None:
self.parametername = []
else:
self.parametername = parametername
+
def factory(*args_, **kwargs_):
if docParamNameList.subclass:
return docParamNameList.subclass(*args_, **kwargs_)
@@ -7756,13 +8867,19 @@ class docParamNameList(GeneratedsSuper):
return docParamNameList(*args_, **kwargs_)
factory = staticmethod(factory)
def get_parametername(self): return self.parametername
- def set_parametername(self, parametername): self.parametername = parametername
+ def set_parametername(
+ self, parametername): self.parametername = parametername
+
def add_parametername(self, value): self.parametername.append(value)
- def insert_parametername(self, index, value): self.parametername[index] = value
+
+ def insert_parametername(
+ self, index, value): self.parametername[index] = value
+
def export(self, outfile, level, namespace_='', name_='docParamNameList', namespacedef_=''):
showIndent(outfile, level)
outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))
- self.exportAttributes(outfile, level, namespace_, name_='docParamNameList')
+ self.exportAttributes(outfile, level, namespace_,
+ name_='docParamNameList')
if self.hasContent_():
outfile.write('>\n')
self.exportChildren(outfile, level + 1, namespace_, name_)
@@ -7770,25 +8887,32 @@ class docParamNameList(GeneratedsSuper):
outfile.write('</%s%s>\n' % (namespace_, name_))
else:
outfile.write(' />\n')
+
def exportAttributes(self, outfile, level, namespace_='', name_='docParamNameList'):
pass
+
def exportChildren(self, outfile, level, namespace_='', name_='docParamNameList'):
for parametername_ in self.parametername:
- parametername_.export(outfile, level, namespace_, name_='parametername')
+ parametername_.export(
+ outfile, level, namespace_, name_='parametername')
+
def hasContent_(self):
if (
self.parametername is not None
- ):
+ ):
return True
else:
return False
+
def exportLiteral(self, outfile, level, name_='docParamNameList'):
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('parametername=[\n')
@@ -7802,17 +8926,20 @@ class docParamNameList(GeneratedsSuper):
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 \
- nodeName_ == 'parametername':
+ nodeName_ == 'parametername':
obj_ = docParamName.factory()
obj_.build(child_)
self.parametername.append(obj_)
@@ -7822,6 +8949,7 @@ class docParamNameList(GeneratedsSuper):
class docParamName(GeneratedsSuper):
subclass = None
superclass = None
+
def __init__(self, direction=None, ref=None, mixedclass_=None, content_=None):
self.direction = direction
if mixedclass_ is None:
@@ -7832,6 +8960,7 @@ class docParamName(GeneratedsSuper):
self.content_ = []
else:
self.content_ = content_
+
def factory(*args_, **kwargs_):
if docParamName.subclass:
return docParamName.subclass(*args_, **kwargs_)
@@ -7842,6 +8971,7 @@ class docParamName(GeneratedsSuper):
def set_ref(self, ref): self.ref = ref
def get_direction(self): return self.direction
def set_direction(self, direction): self.direction = direction
+
def export(self, outfile, level, namespace_='', name_='docParamName', namespacedef_=''):
showIndent(outfile, level)
outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))
@@ -7849,28 +8979,34 @@ class docParamName(GeneratedsSuper):
outfile.write('>')
self.exportChildren(outfile, level + 1, namespace_, name_)
outfile.write('</%s%s>\n' % (namespace_, name_))
+
def exportAttributes(self, outfile, level, namespace_='', name_='docParamName'):
if self.direction is not None:
outfile.write(' direction=%s' % (quote_attrib(self.direction), ))
+
def exportChildren(self, outfile, level, namespace_='', name_='docParamName'):
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_='docParamName'):
level += 1
self.exportLiteralAttributes(outfile, level, name_)
if self.hasContent_():
self.exportLiteralChildren(outfile, level, name_)
+
def exportLiteralAttributes(self, outfile, level, name_):
if self.direction is not None:
showIndent(outfile, level)
outfile.write('direction = "%s",\n' % (self.direction,))
+
def exportLiteralChildren(self, outfile, level, name_):
showIndent(outfile, level)
outfile.write('content_ = [\n')
@@ -7878,26 +9014,29 @@ class docParamName(GeneratedsSuper):
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('direction'):
self.direction = attrs.get('direction').value
+
def buildChildren(self, child_, nodeName_):
if child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'ref':
+ nodeName_ == 'ref':
childobj_ = docRefTextType.factory()
childobj_.build(child_)
obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
- MixedContainer.TypeNone, 'ref', childobj_)
+ MixedContainer.TypeNone, 'ref', childobj_)
self.content_.append(obj_)
elif child_.nodeType == Node.TEXT_NODE:
obj_ = self.mixedclass_(MixedContainer.CategoryText,
- MixedContainer.TypeNone, '', child_.nodeValue)
+ MixedContainer.TypeNone, '', child_.nodeValue)
self.content_.append(obj_)
# end class docParamName
@@ -7905,6 +9044,7 @@ class docParamName(GeneratedsSuper):
class docXRefSectType(GeneratedsSuper):
subclass = None
superclass = None
+
def __init__(self, id=None, xreftitle=None, xrefdescription=None):
self.id = id
if xreftitle is None:
@@ -7912,6 +9052,7 @@ class docXRefSectType(GeneratedsSuper):
else:
self.xreftitle = xreftitle
self.xrefdescription = xrefdescription
+
def factory(*args_, **kwargs_):
if docXRefSectType.subclass:
return docXRefSectType.subclass(*args_, **kwargs_)
@@ -7923,13 +9064,17 @@ class docXRefSectType(GeneratedsSuper):
def add_xreftitle(self, value): self.xreftitle.append(value)
def insert_xreftitle(self, index, value): self.xreftitle[index] = value
def get_xrefdescription(self): return self.xrefdescription
- def set_xrefdescription(self, xrefdescription): self.xrefdescription = xrefdescription
+ def set_xrefdescription(
+ self, xrefdescription): self.xrefdescription = xrefdescription
+
def get_id(self): return self.id
def set_id(self, id): self.id = id
+
def export(self, outfile, level, namespace_='', name_='docXRefSectType', namespacedef_=''):
showIndent(outfile, level)
outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))
- self.exportAttributes(outfile, level, namespace_, name_='docXRefSectType')
+ self.exportAttributes(outfile, level, namespace_,
+ name_='docXRefSectType')
if self.hasContent_():
outfile.write('>\n')
self.exportChildren(outfile, level + 1, namespace_, name_)
@@ -7937,66 +9082,80 @@ class docXRefSectType(GeneratedsSuper):
outfile.write('</%s%s>\n' % (namespace_, name_))
else:
outfile.write(' />\n')
+
def exportAttributes(self, outfile, level, namespace_='', name_='docXRefSectType'):
if self.id is not None:
- outfile.write(' id=%s' % (self.format_string(quote_attrib(self.id).encode(ExternalEncoding), input_name='id'), ))
+ outfile.write(' id=%s' % (self.format_string(quote_attrib(
+ self.id).encode(ExternalEncoding), input_name='id'), ))
+
def exportChildren(self, outfile, level, namespace_='', name_='docXRefSectType'):
for xreftitle_ in self.xreftitle:
showIndent(outfile, level)
- outfile.write('<%sxreftitle>%s</%sxreftitle>\n' % (namespace_, self.format_string(quote_xml(xreftitle_).encode(ExternalEncoding), input_name='xreftitle'), namespace_))
+ outfile.write('<%sxreftitle>%s</%sxreftitle>\n' % (namespace_, self.format_string(
+ quote_xml(xreftitle_).encode(ExternalEncoding), input_name='xreftitle'), namespace_))
if self.xrefdescription:
- self.xrefdescription.export(outfile, level, namespace_, name_='xrefdescription', )
+ self.xrefdescription.export(
+ outfile, level, namespace_, name_='xrefdescription', )
+
def hasContent_(self):
if (
self.xreftitle is not None or
self.xrefdescription is not None
- ):
+ ):
return True
else:
return False
+
def exportLiteral(self, outfile, level, name_='docXRefSectType'):
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('xreftitle=[\n')
level += 1
for xreftitle in self.xreftitle:
showIndent(outfile, level)
- outfile.write('%s,\n' % quote_python(xreftitle).encode(ExternalEncoding))
+ outfile.write('%s,\n' % quote_python(
+ xreftitle).encode(ExternalEncoding))
level -= 1
showIndent(outfile, level)
outfile.write('],\n')
if self.xrefdescription:
showIndent(outfile, level)
outfile.write('xrefdescription=model_.descriptionType(\n')
- self.xrefdescription.exportLiteral(outfile, level, name_='xrefdescription')
+ self.xrefdescription.exportLiteral(
+ outfile, level, name_='xrefdescription')
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 \
- nodeName_ == 'xreftitle':
+ nodeName_ == 'xreftitle':
xreftitle_ = ''
for text__content_ in child_.childNodes:
xreftitle_ += text__content_.nodeValue
self.xreftitle.append(xreftitle_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'xrefdescription':
+ nodeName_ == 'xrefdescription':
obj_ = descriptionType.factory()
obj_.build(child_)
self.set_xrefdescription(obj_)
@@ -8006,6 +9165,7 @@ class docXRefSectType(GeneratedsSuper):
class docCopyType(GeneratedsSuper):
subclass = None
superclass = None
+
def __init__(self, link=None, para=None, sect1=None, internal=None):
self.link = link
if para is None:
@@ -8017,6 +9177,7 @@ class docCopyType(GeneratedsSuper):
else:
self.sect1 = sect1
self.internal = internal
+
def factory(*args_, **kwargs_):
if docCopyType.subclass:
return docCopyType.subclass(*args_, **kwargs_)
@@ -8035,6 +9196,7 @@ class docCopyType(GeneratedsSuper):
def set_internal(self, internal): self.internal = internal
def get_link(self): return self.link
def set_link(self, link): self.link = link
+
def export(self, outfile, level, namespace_='', name_='docCopyType', namespacedef_=''):
showIndent(outfile, level)
outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))
@@ -8046,9 +9208,12 @@ class docCopyType(GeneratedsSuper):
outfile.write('</%s%s>\n' % (namespace_, name_))
else:
outfile.write(' />\n')
+
def exportAttributes(self, outfile, level, namespace_='', name_='docCopyType'):
if self.link is not None:
- outfile.write(' link=%s' % (self.format_string(quote_attrib(self.link).encode(ExternalEncoding), input_name='link'), ))
+ outfile.write(' link=%s' % (self.format_string(quote_attrib(
+ self.link).encode(ExternalEncoding), input_name='link'), ))
+
def exportChildren(self, outfile, level, namespace_='', name_='docCopyType'):
for para_ in self.para:
para_.export(outfile, level, namespace_, name_='para')
@@ -8056,24 +9221,28 @@ class docCopyType(GeneratedsSuper):
sect1_.export(outfile, level, namespace_, name_='sect1')
if self.internal:
self.internal.export(outfile, level, namespace_, name_='internal')
+
def hasContent_(self):
if (
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_='docCopyType'):
level += 1
self.exportLiteralAttributes(outfile, level, name_)
if self.hasContent_():
self.exportLiteralChildren(outfile, level, name_)
+
def exportLiteralAttributes(self, outfile, level, name_):
if self.link is not None:
showIndent(outfile, level)
outfile.write('link = %s,\n' % (self.link,))
+
def exportLiteralChildren(self, outfile, level, name_):
showIndent(outfile, level)
outfile.write('para=[\n')
@@ -8105,28 +9274,31 @@ class docCopyType(GeneratedsSuper):
self.internal.exportLiteral(outfile, level, name_='internal')
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('link'):
self.link = attrs.get('link').value
+
def buildChildren(self, child_, nodeName_):
if child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'para':
+ nodeName_ == 'para':
obj_ = docParaType.factory()
obj_.build(child_)
self.para.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'sect1':
+ nodeName_ == 'sect1':
obj_ = docSect1Type.factory()
obj_.build(child_)
self.sect1.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'internal':
+ nodeName_ == 'internal':
obj_ = docInternalType.factory()
obj_.build(child_)
self.set_internal(obj_)
@@ -8136,9 +9308,11 @@ class docCopyType(GeneratedsSuper):
class docCharType(GeneratedsSuper):
subclass = None
superclass = None
+
def __init__(self, char=None, valueOf_=''):
self.char = char
self.valueOf_ = valueOf_
+
def factory(*args_, **kwargs_):
if docCharType.subclass:
return docCharType.subclass(*args_, **kwargs_)
@@ -8149,6 +9323,7 @@ class docCharType(GeneratedsSuper):
def set_char(self, char): self.char = char
def getValueOf_(self): return self.valueOf_
def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_
+
def export(self, outfile, level, namespace_='', name_='docCharType', namespacedef_=''):
showIndent(outfile, level)
outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))
@@ -8160,36 +9335,43 @@ class docCharType(GeneratedsSuper):
outfile.write('</%s%s>\n' % (namespace_, name_))
else:
outfile.write(' />\n')
+
def exportAttributes(self, outfile, level, namespace_='', name_='docCharType'):
if self.char is not None:
outfile.write(' char=%s' % (quote_attrib(self.char), ))
+
def exportChildren(self, outfile, level, namespace_='', name_='docCharType'):
- if self.valueOf_.find('![CDATA')>-1:
- value=quote_xml('%s' % self.valueOf_)
- value=value.replace('![CDATA','<![CDATA')
- value=value.replace(']]',']]>')
+ if self.valueOf_.find('![CDATA') > -1:
+ value = quote_xml('%s' % self.valueOf_)
+ value = value.replace('![CDATA', '<![CDATA')
+ value = value.replace(']]', ']]>')
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_='docCharType'):
level += 1
self.exportLiteralAttributes(outfile, level, name_)
if self.hasContent_():
self.exportLiteralChildren(outfile, level, name_)
+
def exportLiteralAttributes(self, outfile, level, name_):
if self.char is not None:
showIndent(outfile, level)
outfile.write('char = "%s",\n' % (self.char,))
+
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)
@@ -8197,22 +9379,26 @@ class docCharType(GeneratedsSuper):
for child_ in node_.childNodes:
nodeName_ = child_.nodeName.split(':')[-1]
self.buildChildren(child_, nodeName_)
+
def buildAttributes(self, attrs):
if attrs.get('char'):
self.char = attrs.get('char').value
+
def buildChildren(self, child_, nodeName_):
if child_.nodeType == Node.TEXT_NODE:
self.valueOf_ += child_.nodeValue
elif child_.nodeType == Node.CDATA_SECTION_NODE:
- self.valueOf_ += '![CDATA['+child_.nodeValue+']]'
+ self.valueOf_ += '![CDATA[' + child_.nodeValue + ']]'
# end class docCharType
class docEmptyType(GeneratedsSuper):
subclass = None
superclass = None
+
def __init__(self, valueOf_=''):
self.valueOf_ = valueOf_
+
def factory(*args_, **kwargs_):
if docEmptyType.subclass:
return docEmptyType.subclass(*args_, **kwargs_)
@@ -8221,6 +9407,7 @@ class docEmptyType(GeneratedsSuper):
factory = staticmethod(factory)
def getValueOf_(self): return self.valueOf_
def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_
+
def export(self, outfile, level, namespace_='', name_='docEmptyType', namespacedef_=''):
showIndent(outfile, level)
outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))
@@ -8232,33 +9419,40 @@ class docEmptyType(GeneratedsSuper):
outfile.write('</%s%s>\n' % (namespace_, name_))
else:
outfile.write(' />\n')
+
def exportAttributes(self, outfile, level, namespace_='', name_='docEmptyType'):
pass
+
def exportChildren(self, outfile, level, namespace_='', name_='docEmptyType'):
- if self.valueOf_.find('![CDATA')>-1:
- value=quote_xml('%s' % self.valueOf_)
- value=value.replace('![CDATA','<![CDATA')
- value=value.replace(']]',']]>')
+ if self.valueOf_.find('![CDATA') > -1:
+ value = quote_xml('%s' % self.valueOf_)
+ value = value.replace('![CDATA', '<![CDATA')
+ value = value.replace(']]', ']]>')
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_='docEmptyType'):
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)
@@ -8266,13 +9460,15 @@ class docEmptyType(GeneratedsSuper):
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:
- self.valueOf_ += '![CDATA['+child_.nodeValue+']]'
+ self.valueOf_ += '![CDATA[' + child_.nodeValue + ']]'
# end class docEmptyType
@@ -8282,6 +9478,7 @@ Options:
-s Use the SAX parser, not the minidom parser.
"""
+
def usage():
print(USAGE_TEXT)
sys.exit(1)
@@ -8296,7 +9493,7 @@ def parse(inFileName):
doc = None
sys.stdout.write('<?xml version="1.0" ?>\n')
rootObj.export(sys.stdout, 0, name_="doxygen",
- namespacedef_='')
+ namespacedef_='')
return rootObj
@@ -8309,7 +9506,7 @@ def parseString(inString):
doc = None
sys.stdout.write('<?xml version="1.0" ?>\n')
rootObj.export(sys.stdout, 0, name_="doxygen",
- namespacedef_='')
+ namespacedef_='')
return rootObj
@@ -8338,4 +9535,4 @@ def main():
if __name__ == '__main__':
main()
#import pdb
- #pdb.run('main()')
+ # pdb.run('main()')
diff --git a/docs/doxygen/doxyxml/generated/index.py b/docs/doxygen/doxyxml/generated/index.py
index c58407dbfe..7ffbdf191a 100644
--- a/docs/doxygen/doxyxml/generated/index.py
+++ b/docs/doxygen/doxyxml/generated/index.py
@@ -12,6 +12,7 @@ from . import compound
from . import indexsuper as supermod
+
class DoxygenTypeSub(supermod.DoxygenType):
def __init__(self, version=None, compound=None):
supermod.DoxygenType.__init__(self, version, compound)
@@ -32,6 +33,7 @@ class DoxygenTypeSub(supermod.DoxygenType):
return results
+
supermod.DoxygenType.subclass = DoxygenTypeSub
# end class DoxygenTypeSub
@@ -53,6 +55,7 @@ class CompoundTypeSub(supermod.CompoundType):
return results
+
supermod.CompoundType.subclass = CompoundTypeSub
# end class CompoundTypeSub
@@ -62,6 +65,7 @@ class MemberTypeSub(supermod.MemberType):
def __init__(self, kind=None, refid=None, name=''):
supermod.MemberType.__init__(self, kind, refid, name)
+
supermod.MemberType.subclass = MemberTypeSub
# end class MemberTypeSub
@@ -74,4 +78,3 @@ def parse(inFilename):
rootObj.build(rootNode)
return rootObj
-
diff --git a/docs/doxygen/doxyxml/generated/indexsuper.py b/docs/doxygen/doxyxml/generated/indexsuper.py
index cc2c112418..b30e062ae7 100644
--- a/docs/doxygen/doxyxml/generated/indexsuper.py
+++ b/docs/doxygen/doxyxml/generated/indexsuper.py
@@ -24,12 +24,16 @@ except ImportError as exp:
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
@@ -41,9 +45,9 @@ except ImportError as exp:
## from IPython.Shell import IPShellEmbed
## args = ''
-## ipshell = IPShellEmbed(args,
+# ipshell = IPShellEmbed(args,
## banner = 'Dropping into IPython',
-## exit_msg = 'Leaving Interpreter, back to program.')
+# exit_msg = 'Leaving Interpreter, back to program.')
# Then use the following line where and when you want to drop into the
# IPython shell:
@@ -59,10 +63,12 @@ ExternalEncoding = 'ascii'
# 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)
@@ -71,6 +77,7 @@ def quote_xml(inStr):
s1 = s1.replace('>', '>')
return s1
+
def quote_attrib(inStr):
s1 = (isinstance(inStr, str) and inStr or
'%s' % inStr)
@@ -86,6 +93,7 @@ def quote_attrib(inStr):
s1 = '"%s"' % s1
return s1
+
def quote_python(inStr):
s1 = inStr
if s1.find("'") == -1:
@@ -117,26 +125,33 @@ class MixedContainer(object):
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
- self.value.export(outfile, level, namespace,name)
+ self.value.export(outfile, level, namespace, name)
+
def exportSimple(self, outfile, level, name):
if self.content_type == MixedContainer.TypeString:
outfile.write('<%s>%s</%s>' % (self.name, self.value, self.name))
@@ -148,19 +163,20 @@ class MixedContainer(object):
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)
- outfile.write('MixedContainer(%d, %d, "%s", "%s"),\n' % \
- (self.category, self.content_type, self.name, self.value))
+ outfile.write('MixedContainer(%d, %d, "%s", "%s"),\n' %
+ (self.category, self.content_type, self.name, self.value))
elif self.category == MixedContainer.CategorySimple:
showIndent(outfile, level)
- outfile.write('MixedContainer(%d, %d, "%s", "%s"),\n' % \
- (self.category, self.content_type, self.name, self.value))
+ outfile.write('MixedContainer(%d, %d, "%s", "%s"),\n' %
+ (self.category, self.content_type, self.name, self.value))
else: # category == MixedContainer.CategoryComplex
showIndent(outfile, level)
- outfile.write('MixedContainer(%d, %d, "%s",\n' % \
- (self.category, self.content_type, self.name,))
+ outfile.write('MixedContainer(%d, %d, "%s",\n' %
+ (self.category, self.content_type, self.name,))
self.value.exportLiteral(outfile, level + 1)
showIndent(outfile, level)
outfile.write(')\n')
@@ -171,6 +187,7 @@ class _MemberSpec(object):
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
@@ -186,12 +203,14 @@ class _MemberSpec(object):
class DoxygenType(GeneratedsSuper):
subclass = None
superclass = None
+
def __init__(self, version=None, compound=None):
self.version = version
if compound is None:
self.compound = []
else:
self.compound = compound
+
def factory(*args_, **kwargs_):
if DoxygenType.subclass:
return DoxygenType.subclass(*args_, **kwargs_)
@@ -204,6 +223,7 @@ class DoxygenType(GeneratedsSuper):
def insert_compound(self, index, value): self.compound[index] = value
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_, ))
@@ -215,27 +235,34 @@ class DoxygenType(GeneratedsSuper):
outfile.write('</%s%s>\n' % (namespace_, name_))
else:
outfile.write(' />\n')
+
def exportAttributes(self, outfile, level, namespace_='', name_='DoxygenType'):
- outfile.write(' version=%s' % (self.format_string(quote_attrib(self.version).encode(ExternalEncoding), input_name='version'), ))
+ outfile.write(' version=%s' % (self.format_string(quote_attrib(
+ self.version).encode(ExternalEncoding), input_name='version'), ))
+
def exportChildren(self, outfile, level, namespace_='', name_='DoxygenType'):
for compound_ in self.compound:
compound_.export(outfile, level, namespace_, name_='compound')
+
def hasContent_(self):
if (
self.compound 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_):
showIndent(outfile, level)
outfile.write('compound=[\n')
@@ -249,18 +276,21 @@ class DoxygenType(GeneratedsSuper):
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('version'):
self.version = attrs.get('version').value
+
def buildChildren(self, child_, nodeName_):
if child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'compound':
+ nodeName_ == 'compound':
obj_ = CompoundType.factory()
obj_.build(child_)
self.compound.append(obj_)
@@ -270,6 +300,7 @@ class DoxygenType(GeneratedsSuper):
class CompoundType(GeneratedsSuper):
subclass = None
superclass = None
+
def __init__(self, kind=None, refid=None, name=None, member=None):
self.kind = kind
self.refid = refid
@@ -278,6 +309,7 @@ class CompoundType(GeneratedsSuper):
self.member = []
else:
self.member = member
+
def factory(*args_, **kwargs_):
if CompoundType.subclass:
return CompoundType.subclass(*args_, **kwargs_)
@@ -294,6 +326,7 @@ class CompoundType(GeneratedsSuper):
def set_kind(self, kind): self.kind = kind
def get_refid(self): return self.refid
def set_refid(self, refid): self.refid = refid
+
def export(self, outfile, level, namespace_='', name_='CompoundType', namespacedef_=''):
showIndent(outfile, level)
outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))
@@ -305,28 +338,35 @@ class CompoundType(GeneratedsSuper):
outfile.write('</%s%s>\n' % (namespace_, name_))
else:
outfile.write(' />\n')
+
def exportAttributes(self, outfile, level, namespace_='', name_='CompoundType'):
outfile.write(' kind=%s' % (quote_attrib(self.kind), ))
- outfile.write(' refid=%s' % (self.format_string(quote_attrib(self.refid).encode(ExternalEncoding), input_name='refid'), ))
+ outfile.write(' refid=%s' % (self.format_string(quote_attrib(
+ self.refid).encode(ExternalEncoding), input_name='refid'), ))
+
def exportChildren(self, outfile, level, namespace_='', name_='CompoundType'):
if self.name is not None:
showIndent(outfile, level)
- outfile.write('<%sname>%s</%sname>\n' % (namespace_, self.format_string(quote_xml(self.name).encode(ExternalEncoding), input_name='name'), namespace_))
+ outfile.write('<%sname>%s</%sname>\n' % (namespace_, self.format_string(
+ quote_xml(self.name).encode(ExternalEncoding), input_name='name'), namespace_))
for member_ in self.member:
member_.export(outfile, level, namespace_, name_='member')
+
def hasContent_(self):
if (
self.name is not None or
self.member is not None
- ):
+ ):
return True
else:
return False
+
def exportLiteral(self, outfile, level, name_='CompoundType'):
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)
@@ -334,9 +374,11 @@ class CompoundType(GeneratedsSuper):
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('name=%s,\n' % quote_python(self.name).encode(ExternalEncoding))
+ outfile.write('name=%s,\n' % quote_python(
+ self.name).encode(ExternalEncoding))
showIndent(outfile, level)
outfile.write('member=[\n')
level += 1
@@ -349,26 +391,29 @@ class CompoundType(GeneratedsSuper):
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
if attrs.get('refid'):
self.refid = attrs.get('refid').value
+
def buildChildren(self, child_, nodeName_):
if child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'name':
+ nodeName_ == 'name':
name_ = ''
for text__content_ in child_.childNodes:
name_ += text__content_.nodeValue
self.name = name_
elif child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'member':
+ nodeName_ == 'member':
obj_ = MemberType.factory()
obj_.build(child_)
self.member.append(obj_)
@@ -378,10 +423,12 @@ class CompoundType(GeneratedsSuper):
class MemberType(GeneratedsSuper):
subclass = None
superclass = None
+
def __init__(self, kind=None, refid=None, name=None):
self.kind = kind
self.refid = refid
self.name = name
+
def factory(*args_, **kwargs_):
if MemberType.subclass:
return MemberType.subclass(*args_, **kwargs_)
@@ -394,6 +441,7 @@ class MemberType(GeneratedsSuper):
def set_kind(self, kind): self.kind = kind
def get_refid(self): return self.refid
def set_refid(self, refid): self.refid = refid
+
def export(self, outfile, level, namespace_='', name_='MemberType', namespacedef_=''):
showIndent(outfile, level)
outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))
@@ -405,25 +453,32 @@ class MemberType(GeneratedsSuper):
outfile.write('</%s%s>\n' % (namespace_, name_))
else:
outfile.write(' />\n')
+
def exportAttributes(self, outfile, level, namespace_='', name_='MemberType'):
outfile.write(' kind=%s' % (quote_attrib(self.kind), ))
- outfile.write(' refid=%s' % (self.format_string(quote_attrib(self.refid).encode(ExternalEncoding), input_name='refid'), ))
+ outfile.write(' refid=%s' % (self.format_string(quote_attrib(
+ self.refid).encode(ExternalEncoding), input_name='refid'), ))
+
def exportChildren(self, outfile, level, namespace_='', name_='MemberType'):
if self.name is not None:
showIndent(outfile, level)
- outfile.write('<%sname>%s</%sname>\n' % (namespace_, self.format_string(quote_xml(self.name).encode(ExternalEncoding), input_name='name'), namespace_))
+ outfile.write('<%sname>%s</%sname>\n' % (namespace_, self.format_string(
+ quote_xml(self.name).encode(ExternalEncoding), input_name='name'), namespace_))
+
def hasContent_(self):
if (
self.name is not None
- ):
+ ):
return True
else:
return False
+
def exportLiteral(self, outfile, level, name_='MemberType'):
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)
@@ -431,23 +486,28 @@ class MemberType(GeneratedsSuper):
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('name=%s,\n' % quote_python(self.name).encode(ExternalEncoding))
+ outfile.write('name=%s,\n' % quote_python(
+ self.name).encode(ExternalEncoding))
+
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
if attrs.get('refid'):
self.refid = attrs.get('refid').value
+
def buildChildren(self, child_, nodeName_):
if child_.nodeType == Node.ELEMENT_NODE and \
- nodeName_ == 'name':
+ nodeName_ == 'name':
name_ = ''
for text__content_ in child_.childNodes:
name_ += text__content_.nodeValue
@@ -461,6 +521,7 @@ Options:
-s Use the SAX parser, not the minidom parser.
"""
+
def usage():
print(USAGE_TEXT)
sys.exit(1)
@@ -475,7 +536,7 @@ def parse(inFileName):
doc = None
sys.stdout.write('<?xml version="1.0" ?>\n')
rootObj.export(sys.stdout, 0, name_="doxygenindex",
- namespacedef_='')
+ namespacedef_='')
return rootObj
@@ -488,7 +549,7 @@ def parseString(inString):
doc = None
sys.stdout.write('<?xml version="1.0" ?>\n')
rootObj.export(sys.stdout, 0, name_="doxygenindex",
- namespacedef_='')
+ namespacedef_='')
return rootObj
@@ -514,9 +575,7 @@ def main():
usage()
-
-
if __name__ == '__main__':
main()
#import pdb
- #pdb.run('main()')
+ # pdb.run('main()')
--
cgit v1.2.3