"""
Generated Mon Feb  9 19:08:05 2009 by generateDS.py.
This file contains manual modifications.
"""

from __future__ import annotations

from xml.dom import Node, minidom
from xml.parsers.expat import ExpatError

from breathe.parser import compoundsuper as supermod
from breathe.parser.compoundsuper import MixedContainer


class DoxygenTypeSub(supermod.DoxygenType):
    node_type = "doxygendef"

    def __init__(self, version=None, compounddef=None):
        supermod.DoxygenType.__init__(self, version, compounddef)


supermod.DoxygenType.subclass = DoxygenTypeSub
# end class DoxygenTypeSub


class compounddefTypeSub(supermod.compounddefType):
    node_type = "compounddef"

    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,
        language=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,
            language,
        )


supermod.compounddefType.subclass = compounddefTypeSub
# end class compounddefTypeSub


class listofallmembersTypeSub(supermod.listofallmembersType):
    node_type = "listofallmembers"

    def __init__(self, member=None):
        supermod.listofallmembersType.__init__(self, member)


supermod.listofallmembersType.subclass = listofallmembersTypeSub
# end class listofallmembersTypeSub


class memberRefTypeSub(supermod.memberRefType):
    node_type = "memberref"

    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.subclass = memberRefTypeSub
# end class memberRefTypeSub


class compoundRefTypeSub(supermod.compoundRefType):
    node_type = "compoundref"

    def __init__(
        self, virt=None, prot=None, refid=None, valueOf_="", mixedclass_=None, content_=None
    ):
        supermod.compoundRefType.__init__(self, mixedclass_, content_)


supermod.compoundRefType.subclass = compoundRefTypeSub
# end class compoundRefTypeSub


class reimplementTypeSub(supermod.reimplementType):
    node_type = "reimplement"

    def __init__(self, refid=None, valueOf_="", mixedclass_=None, content_=None):
        supermod.reimplementType.__init__(self, mixedclass_, content_)


supermod.reimplementType.subclass = reimplementTypeSub
# end class reimplementTypeSub


class incTypeSub(supermod.incType):
    node_type = "inc"

    def __init__(self, local=None, refid=None, valueOf_="", mixedclass_=None, content_=None):
        supermod.incType.__init__(self, mixedclass_, content_)


supermod.incType.subclass = incTypeSub
# end class incTypeSub


class refTypeSub(supermod.refType):
    node_type = "ref"

    def __init__(
        self, node_name, prot=None, refid=None, valueOf_="", mixedclass_=None, content_=None
    ):
        supermod.refType.__init__(self, mixedclass_, content_)

        self.node_name = node_name


supermod.refType.subclass = refTypeSub


class refTextTypeSub(supermod.refTextType):
    node_type = "reftex"

    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):
    node_type = "sectiondef"

    def __init__(self, kind=None, header="", description=None, memberdef=None):
        supermod.sectiondefType.__init__(self, kind, header, description, memberdef)


supermod.sectiondefType.subclass = sectiondefTypeSub
# end class sectiondefTypeSub


class memberdefTypeSub(supermod.memberdefType):
    node_type = "memberdef"

    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,
        strong=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,
        refqual=None,
    ):
        supermod.memberdefType.__init__(
            self,
            initonly,
            kind,
            volatile,
            const,
            raise_,
            virt,
            readable,
            prot,
            explicit,
            new,
            final,
            writable,
            add,
            static,
            strong,
            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,
            refqual,
        )

        self.parameterlist = supermod.docParamListType.factory()
        self.parameterlist.kind = "param"

    def buildChildren(self, child_, nodeName_):
        supermod.memberdefType.buildChildren(self, child_, nodeName_)

        if child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "param":
            # Get latest param
            param = self.param[-1]

            # If it doesn't have a description we're done
            if not param.briefdescription:
                return

            # Construct our own param list from the descriptions stored inline
            # with the parameters
            paramdescription = param.briefdescription
            paramname = supermod.docParamName.factory()

            # Add parameter name
            obj_ = paramname.mixedclass_(
                MixedContainer.CategoryText, MixedContainer.TypeNone, "", param.declname
            )
            paramname.content_.append(obj_)

            paramnamelist = supermod.docParamNameList.factory()
            paramnamelist.parametername.append(paramname)

            paramlistitem = supermod.docParamListItem.factory()
            paramlistitem.parameternamelist.append(paramnamelist)

            # Add parameter description
            paramlistitem.parameterdescription = paramdescription

            self.parameterlist.parameteritem.append(paramlistitem)

        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "detaileddescription":
            if not self.parameterlist.parameteritem:
                # No items in our list
                return

            # Assume supermod.memberdefType.buildChildren has already built the
            # description object, we just want to slot our parameterlist in at
            # a reasonable point

            if not self.detaileddescription:
                # Create one if it doesn't exist
                self.detaileddescription = supermod.descriptionType.factory()

            detaileddescription = self.detaileddescription

            para = supermod.docParaType.factory()
            para.parameterlist.append(self.parameterlist)

            obj_ = detaileddescription.mixedclass_(
                MixedContainer.CategoryComplex, MixedContainer.TypeNone, "para", para
            )

            index = 0
            detaileddescription.content_.insert(index, obj_)


supermod.memberdefType.subclass = memberdefTypeSub
# end class memberdefTypeSub


class descriptionTypeSub(supermod.descriptionType):
    node_type = "description"

    def __init__(
        self, title="", para=None, sect1=None, internal=None, mixedclass_=None, content_=None
    ):
        supermod.descriptionType.__init__(self, mixedclass_, content_)


supermod.descriptionType.subclass = descriptionTypeSub
# end class descriptionTypeSub


class enumvalueTypeSub(supermod.enumvalueType):
    node_type = "enumvalue"

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

        self.initializer = None

    def buildChildren(self, child_, nodeName_):
        # Get text from <name> child and put it in self.name
        if child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "name":
            valuestr_ = "".join(text_.nodeValue for text_ in child_.childNodes)
            self.name = valuestr_
        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "briefdescription":
            obj_ = supermod.descriptionType.factory()
            obj_.build(child_)
            self.set_briefdescription(obj_)
        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "detaileddescription":
            obj_ = supermod.descriptionType.factory()
            obj_.build(child_)
            self.set_detaileddescription(obj_)
        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "initializer":
            childobj_ = supermod.linkedTextType.factory()
            childobj_.build(child_)
            obj_ = self.mixedclass_(
                MixedContainer.CategoryComplex, MixedContainer.TypeNone, "initializer", childobj_
            )
            self.set_initializer(obj_)
            self.content_.append(obj_)


supermod.enumvalueType.subclass = enumvalueTypeSub
# end class enumvalueTypeSub


class templateparamlistTypeSub(supermod.templateparamlistType):
    node_type = "templateparamlist"

    def __init__(self, param=None):
        supermod.templateparamlistType.__init__(self, param)


supermod.templateparamlistType.subclass = templateparamlistTypeSub
# end class templateparamlistTypeSub


class paramTypeSub(supermod.paramType):
    node_type = "param"

    def __init__(
        self, type_=None, declname="", defname="", array="", defval=None, briefdescription=None
    ):
        supermod.paramType.__init__(self, type_, declname, defname, array, defval, briefdescription)


supermod.paramType.subclass = paramTypeSub
# end class paramTypeSub


class linkedTextTypeSub(supermod.linkedTextType):
    node_type = "linkedtext"

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


supermod.linkedTextType.subclass = linkedTextTypeSub
# end class linkedTextTypeSub


class graphTypeSub(supermod.graphType):
    node_type = "graph"

    def __init__(self, node=None, direction="forward", caption=""):
        supermod.graphType.__init__(self, node, direction, caption)


supermod.graphType.subclass = graphTypeSub
# end class graphTypeSub


class nodeTypeSub(supermod.nodeType):
    node_type = "node"

    def __init__(self, id=None, label="", link=None, childnode=None):
        supermod.nodeType.__init__(self, id, label, link, childnode)


supermod.nodeType.subclass = nodeTypeSub
# end class nodeTypeSub


class childnodeTypeSub(supermod.childnodeType):
    node_type = "childnode"

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


supermod.childnodeType.subclass = childnodeTypeSub
# end class childnodeTypeSub


class linkTypeSub(supermod.linkType):
    node_type = "link"

    def __init__(self, refid=None, external=None, valueOf_=""):
        supermod.linkType.__init__(self, refid, external)


supermod.linkType.subclass = linkTypeSub
# end class linkTypeSub


class listingTypeSub(supermod.listingType):
    node_type = "listing"

    def __init__(self, codeline=None, domain=None):
        supermod.listingType.__init__(self, codeline, domain)


supermod.listingType.subclass = listingTypeSub
# end class listingTypeSub


class codelineTypeSub(supermod.codelineType):
    node_type = "codeline"

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


supermod.codelineType.subclass = codelineTypeSub
# end class codelineTypeSub


class highlightTypeSub(supermod.highlightType):
    node_type = "highlight"

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


supermod.highlightType.subclass = highlightTypeSub
# end class highlightTypeSub


class referenceTypeSub(supermod.referenceType):
    node_type = "reference"

    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):
    node_type = "location"

    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.subclass = locationTypeSub
# end class locationTypeSub


class docSect1TypeSub(supermod.docSect1Type):
    node_type = "docsect1"

    def __init__(
        self,
        id=None,
        title="",
        para=None,
        sect2=None,
        internal=None,
        mixedclass_=None,
        content_=None,
    ):
        supermod.docSect1Type.__init__(self, mixedclass_, content_)


supermod.docSect1Type.subclass = docSect1TypeSub
# end class docSect1TypeSub


class docSect2TypeSub(supermod.docSect2Type):
    node_type = "docsect2"

    def __init__(
        self,
        id=None,
        title="",
        para=None,
        sect3=None,
        internal=None,
        mixedclass_=None,
        content_=None,
    ):
        supermod.docSect2Type.__init__(self, mixedclass_, content_)


supermod.docSect2Type.subclass = docSect2TypeSub
# end class docSect2TypeSub


class docSect3TypeSub(supermod.docSect3Type):
    node_type = "docsect3"

    def __init__(
        self,
        id=None,
        title="",
        para=None,
        sect4=None,
        internal=None,
        mixedclass_=None,
        content_=None,
    ):
        supermod.docSect3Type.__init__(self, mixedclass_, content_)


supermod.docSect3Type.subclass = docSect3TypeSub
# end class docSect3TypeSub


class docSect4TypeSub(supermod.docSect4Type):
    node_type = "docsect4"

    def __init__(
        self, id=None, title="", para=None, internal=None, mixedclass_=None, content_=None
    ):
        supermod.docSect4Type.__init__(self, mixedclass_, content_)


supermod.docSect4Type.subclass = docSect4TypeSub
# end class docSect4TypeSub


class docInternalTypeSub(supermod.docInternalType):
    node_type = "docinternal"

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


supermod.docInternalType.subclass = docInternalTypeSub
# end class docInternalTypeSub


class docInternalS1TypeSub(supermod.docInternalS1Type):
    node_type = "docinternals1"

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


supermod.docInternalS1Type.subclass = docInternalS1TypeSub
# end class docInternalS1TypeSub


class docInternalS2TypeSub(supermod.docInternalS2Type):
    node_type = "docinternals2"

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


supermod.docInternalS2Type.subclass = docInternalS2TypeSub
# end class docInternalS2TypeSub


class docInternalS3TypeSub(supermod.docInternalS3Type):
    node_type = "docinternals3"

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


supermod.docInternalS3Type.subclass = docInternalS3TypeSub
# end class docInternalS3TypeSub


class docInternalS4TypeSub(supermod.docInternalS4Type):
    node_type = "docinternals4"

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


supermod.docInternalS4Type.subclass = docInternalS4TypeSub
# end class docInternalS4TypeSub


class docURLLinkSub(supermod.docURLLink):
    node_type = "docurllink"

    def __init__(self, url=None, valueOf_="", mixedclass_=None, content_=None):
        supermod.docURLLink.__init__(self, mixedclass_, content_)


supermod.docURLLink.subclass = docURLLinkSub
# end class docURLLinkSub


class docAnchorTypeSub(supermod.docAnchorType):
    node_type = "docanchor"

    def __init__(self, id=None, valueOf_="", mixedclass_=None, content_=None):
        supermod.docAnchorType.__init__(self, mixedclass_, content_)


supermod.docAnchorType.subclass = docAnchorTypeSub
# end class docAnchorTypeSub


class docFormulaTypeSub(supermod.docFormulaType):
    node_type = "docformula"

    def __init__(self, id=None, valueOf_="", mixedclass_=None, content_=None):
        supermod.docFormulaType.__init__(self, mixedclass_, content_)


supermod.docFormulaType.subclass = docFormulaTypeSub
# end class docFormulaTypeSub


class docIndexEntryTypeSub(supermod.docIndexEntryType):
    node_type = "docindexentry"

    def __init__(self, primaryie="", secondaryie=""):
        supermod.docIndexEntryType.__init__(self, primaryie, secondaryie)


supermod.docIndexEntryType.subclass = docIndexEntryTypeSub
# end class docIndexEntryTypeSub


class docListTypeSub(supermod.docListType):
    node_type = "doclist"

    def __init__(self, listitem=None, subtype=""):
        self.node_subtype = "itemized"
        if subtype != "":
            self.node_subtype = subtype
        supermod.docListType.__init__(self, listitem)


supermod.docListType.subclass = docListTypeSub
# end class docListTypeSub


class docListItemTypeSub(supermod.docListItemType):
    node_type = "doclistitem"

    def __init__(self, para=None):
        supermod.docListItemType.__init__(self, para)


supermod.docListItemType.subclass = docListItemTypeSub
# end class docListItemTypeSub


class docSimpleSectTypeSub(supermod.docSimpleSectType):
    node_type = "docsimplesect"

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


supermod.docSimpleSectType.subclass = docSimpleSectTypeSub
# end class docSimpleSectTypeSub


class docVarListEntryTypeSub(supermod.docVarListEntryType):
    node_type = "docvarlistentry"

    def __init__(self, term=None):
        supermod.docVarListEntryType.__init__(self, term)

    def buildChildren(self, child_, nodeName_):
        if child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "term":
            obj_ = supermod.docTitleType.factory()
            obj_.build(child_)
            self.set_term(obj_)


supermod.docVarListEntryType.subclass = docVarListEntryTypeSub
# end class docVarListEntryTypeSub


class docRefTextTypeSub(supermod.docRefTextType):
    node_type = "docreftext"

    def __init__(
        self, refid=None, kindref=None, external=None, valueOf_="", mixedclass_=None, content_=None
    ):
        supermod.docRefTextType.__init__(self, mixedclass_, content_)

        self.para = []

    def buildChildren(self, child_, nodeName_):
        supermod.docRefTextType.buildChildren(self, child_, nodeName_)

        if child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "para":
            obj_ = supermod.docParaType.factory()
            obj_.build(child_)
            self.para.append(obj_)


supermod.docRefTextType.subclass = docRefTextTypeSub
# end class docRefTextTypeSub


class docTableTypeSub(supermod.docTableType):
    node_type = "doctable"

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


supermod.docTableType.subclass = docTableTypeSub
# end class docTableTypeSub


class docRowTypeSub(supermod.docRowType):
    node_type = "docrow"

    def __init__(self, entry=None):
        supermod.docRowType.__init__(self, entry)


supermod.docRowType.subclass = docRowTypeSub
# end class docRowTypeSub


class docEntryTypeSub(supermod.docEntryType):
    node_type = "docentry"

    def __init__(self, thead=None, align=None, rowspan=None, colspan=None, para=None):
        supermod.docEntryType.__init__(self, thead, align, rowspan, colspan, para)


supermod.docEntryType.subclass = docEntryTypeSub
# end class docEntryTypeSub


class docHeadingTypeSub(supermod.docHeadingType):
    node_type = "docheading"

    def __init__(self, level=None, valueOf_="", mixedclass_=None, content_=None):
        supermod.docHeadingType.__init__(self, mixedclass_, content_)

    def buildChildren(self, child_, nodeName_):
        supermod.docHeadingType.buildChildren(self, child_, nodeName_)

        # Account for styled content in the heading. This might need to be expanded to include other
        # nodes as it seems from the xsd that headings can have a lot of different children but we
        # really don't expect most of them to come up.
        if child_.nodeType == Node.ELEMENT_NODE and (
            nodeName_ == "bold"
            or nodeName_ == "emphasis"
            or nodeName_ == "computeroutput"
            or nodeName_ == "subscript"
            or nodeName_ == "superscript"
            or nodeName_ == "center"
            or nodeName_ == "small"
        ):
            obj_ = supermod.docMarkupType.factory()
            obj_.build(child_)
            obj_.type_ = nodeName_
            self.content_.append(obj_)


supermod.docHeadingType.subclass = docHeadingTypeSub
# end class docHeadingTypeSub


class docImageTypeSub(supermod.docImageType):
    node_type = "docimage"

    def __init__(
        self,
        width=None,
        type_=None,
        name=None,
        height=None,
        valueOf_="",
        mixedclass_=None,
        content_=None,
    ):
        supermod.docImageType.__init__(self, mixedclass_, content_)


supermod.docImageType.subclass = docImageTypeSub
# end class docImageTypeSub


class docDotFileTypeSub(supermod.docDotFileType):
    node_type = "docdotfile"

    def __init__(self, name=None, valueOf_="", mixedclass_=None, content_=None):
        supermod.docDotFileType.__init__(self, mixedclass_, content_)


supermod.docDotFileType.subclass = docDotFileTypeSub
# end class docDotFileTypeSub


class docDotTypeSub(supermod.docDotType):
    node_type = "docdot"

    def __init__(self, name=None, valueOf_="", mixedclass_=None, content_=None):
        supermod.docDotType.__init__(self, mixedclass_, content_)


supermod.docDotType.subclass = docDotTypeSub
# end class docDotTypeSub


class docTocItemTypeSub(supermod.docTocItemType):
    node_type = "doctocitem"

    def __init__(self, id=None, valueOf_="", mixedclass_=None, content_=None):
        supermod.docTocItemType.__init__(self, mixedclass_, content_)


supermod.docTocItemType.subclass = docTocItemTypeSub
# end class docTocItemTypeSub


class docTocListTypeSub(supermod.docTocListType):
    node_type = "doctoclist"

    def __init__(self, tocitem=None):
        supermod.docTocListType.__init__(self, tocitem)


supermod.docTocListType.subclass = docTocListTypeSub
# end class docTocListTypeSub


class docLanguageTypeSub(supermod.docLanguageType):
    node_type = "doclanguage"

    def __init__(self, langid=None, para=None):
        supermod.docLanguageType.__init__(self, langid, para)


supermod.docLanguageType.subclass = docLanguageTypeSub
# end class docLanguageTypeSub


class docParamListTypeSub(supermod.docParamListType):
    node_type = "docparamlist"

    def __init__(self, kind=None, parameteritem=None):
        supermod.docParamListType.__init__(self, kind, parameteritem)


supermod.docParamListType.subclass = docParamListTypeSub
# end class docParamListTypeSub


class docParamListItemSub(supermod.docParamListItem):
    node_type = "docparamlistitem"

    def __init__(self, parameternamelist=None, parameterdescription=None):
        supermod.docParamListItem.__init__(self, parameternamelist, parameterdescription)


supermod.docParamListItem.subclass = docParamListItemSub
# end class docParamListItemSub


class docParamNameListSub(supermod.docParamNameList):
    node_type = "docparamnamelist"

    def __init__(self, parametername=None):
        supermod.docParamNameList.__init__(self, parametername)


supermod.docParamNameList.subclass = docParamNameListSub
# end class docParamNameListSub


class docParamNameSub(supermod.docParamName):
    node_type = "docparamname"

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


supermod.docParamName.subclass = docParamNameSub
# end class docParamNameSub


class docXRefSectTypeSub(supermod.docXRefSectType):
    node_type = "docxrefsect"

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


supermod.docXRefSectType.subclass = docXRefSectTypeSub
# end class docXRefSectTypeSub


class docVariableListTypeSub(supermod.docVariableListType):
    node_type = "docvariablelist"

    def __init__(self, valueOf_=""):
        supermod.docVariableListType.__init__(self, valueOf_)

        self.varlistentries = []
        self.listitems = []

    def buildChildren(self, child_, nodeName_):
        supermod.docVariableListType.buildChildren(self, child_, nodeName_)

        if child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "varlistentry":
            obj_ = supermod.docVarListEntryType.factory()
            obj_.build(child_)
            self.varlistentries.append(obj_)
        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "listitem":
            obj_ = supermod.docListItemType.factory()
            obj_.build(child_)
            self.listitems.append(obj_)


supermod.docVariableListType.subclass = docVariableListTypeSub
# end class docVariableListTypeSub


class docCopyTypeSub(supermod.docCopyType):
    node_type = "doccopy"

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


supermod.docCopyType.subclass = docCopyTypeSub
# end class docCopyTypeSub


class docCharTypeSub(supermod.docCharType):
    node_type = "docchar"

    def __init__(self, char=None, valueOf_=""):
        supermod.docCharType.__init__(self, char)


supermod.docCharType.subclass = docCharTypeSub
# end class docCharTypeSub


class verbatimTypeSub:
    """
    New node type. Structure is largely pillaged from other nodes in order to
    match the set.
    """

    node_type = "verbatim"

    def __init__(self, valueOf_="", mixedclass_=None, content_=None):
        if mixedclass_ is None:
            self.mixedclass_ = MixedContainer
        else:
            self.mixedclass_ = mixedclass_
        if content_ is None:
            self.content_ = []
        else:
            self.content_ = content_
        self.text = ""

    def factory(*args, **kwargs):
        return verbatimTypeSub(*args, **kwargs)

    factory = staticmethod(factory)

    def buildAttributes(self, attrs):
        pass

    def build(self, node_):
        attrs = node_.attributes
        self.buildAttributes(attrs)
        self.valueOf_ = ""
        for child_ in node_.childNodes:
            nodeName_ = child_.nodeName.split(":")[-1]
            self.buildChildren(child_, nodeName_)

    def buildChildren(self, child_, nodeName_):
        if child_.nodeType == Node.TEXT_NODE:
            self.text += child_.nodeValue


class docBlockQuoteTypeSub(supermod.docBlockQuoteType):
    node_type = "docblockquote"

    def __init__(self, para=None):
        supermod.docBlockQuoteType.__init__(self, para)

    def buildChildren(self, child_, nodeName_):
        supermod.docBlockQuoteType.buildChildren(self, child_, nodeName_)


supermod.docBlockQuoteType.subclass = docBlockQuoteTypeSub
# end class docBlockQuoteTypeSub


class docParaTypeSub(supermod.docParaType):
    node_type = "docpara"

    def __init__(self, char=None, valueOf_=""):
        supermod.docParaType.__init__(self, char)

        self.parameterlist = []
        self.simplesects = []
        self.content = []
        self.programlisting = []
        self.images = []

        self.ordered_children = []

    def buildChildren(self, child_, nodeName_):
        supermod.docParaType.buildChildren(self, child_, nodeName_)

        if child_.nodeType == Node.TEXT_NODE:
            obj_ = self.mixedclass_(
                MixedContainer.CategoryText, MixedContainer.TypeNone, "", child_.nodeValue
            )
            self.content.append(obj_)
        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "ref":
            obj_ = supermod.docRefTextType.factory()
            obj_.build(child_)
            self.content.append(obj_)
        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "parameterlist":
            obj_ = supermod.docParamListType.factory()
            obj_.build(child_)
            self.parameterlist.append(obj_)
        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "simplesect":
            obj_ = supermod.docSimpleSectType.factory()
            obj_.build(child_)
            self.simplesects.append(obj_)
        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "programlisting":
            obj_ = supermod.listingType.factory()
            obj_.build(child_)
            # Add programlisting nodes to self.content rather than self.programlisting,
            # because programlisting and content nodes can interleave as shown in
            # https://www.stack.nl/~dimitri/doxygen/manual/examples/include/html/example.html.
            self.content.append(obj_)
        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "image":
            obj_ = supermod.docImageType.factory()
            obj_.build(child_)
            self.images.append(obj_)
        elif child_.nodeType == Node.ELEMENT_NODE and (
            nodeName_ == "bold"
            or nodeName_ == "emphasis"
            or nodeName_ == "computeroutput"
            or nodeName_ == "subscript"
            or nodeName_ == "superscript"
            or nodeName_ == "center"
            or nodeName_ == "small"
        ):
            obj_ = supermod.docMarkupType.factory()
            obj_.build(child_)
            obj_.type_ = nodeName_
            self.content.append(obj_)
        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "verbatim":
            childobj_ = verbatimTypeSub.factory()
            childobj_.build(child_)
            obj_ = self.mixedclass_(
                MixedContainer.CategoryComplex, MixedContainer.TypeNone, "verbatim", childobj_
            )
            self.content.append(obj_)
        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "formula":
            childobj_ = docFormulaTypeSub.factory()
            childobj_.build(child_)
            obj_ = self.mixedclass_(
                MixedContainer.CategoryComplex, MixedContainer.TypeNone, "formula", childobj_
            )
            self.content.append(obj_)
        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "itemizedlist":
            obj_ = supermod.docListType.factory(subtype="itemized")
            obj_.build(child_)
            self.content.append(obj_)
        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "orderedlist":
            obj_ = supermod.docListType.factory(subtype="ordered")
            obj_.build(child_)
            self.content.append(obj_)
        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "heading":
            obj_ = supermod.docHeadingType.factory()
            obj_.build(child_)
            self.content.append(obj_)
        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "ulink":
            obj_ = supermod.docURLLink.factory()
            obj_.build(child_)
            self.content.append(obj_)
        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "xrefsect":
            obj_ = supermod.docXRefSectType.factory()
            obj_.build(child_)
            self.content.append(obj_)
        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "variablelist":
            obj_ = supermod.docVariableListType.factory()
            obj_.build(child_)
            self.content.append(obj_)
        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "anchor":
            obj_ = supermod.docAnchorType.factory()
            obj_.build(child_)
            self.content.append(obj_)
        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "parblock":
            obj_ = supermod.docParBlockType.factory()
            obj_.build(child_)
            self.content.append(obj_)
        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "blockquote":
            obj_ = supermod.docBlockQuoteType.factory()
            obj_.build(child_)
            self.content.append(obj_)
        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "table":
            obj_ = supermod.docTableType.factory()
            obj_.build(child_)
            self.content.append(obj_)
        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "dotfile":
            obj_ = supermod.docDotFileType.factory()
            obj_.build(child_)
            self.content.append(obj_)
        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "dot":
            obj_ = supermod.docDotType.factory()
            obj_.build(child_)
            self.content.append(obj_)
        elif child_.nodeType == Node.ELEMENT_NODE and (
            nodeName_ == "ndash" or nodeName_ == "mdash"
        ):
            # inject a emphasized dash unicode char as a placeholder/flag for rendering
            # later. See visit_docblockquote()
            obj_ = self.mixedclass_(
                MixedContainer.CategoryText, MixedContainer.TypeText, "", "&#8212;"
            )
            self.content.append(obj_)
        else:
            obj_ = None

        if obj_:
            self.ordered_children.append(obj_)


supermod.docParaType.subclass = docParaTypeSub
# end class docParaTypeSub


class docParBlockTypeSub(supermod.docParBlockType):
    node_type = "docparblock"

    def __init__(self, para=None):
        supermod.docParBlockType.__init__(self, para)

    def buildChildren(self, child_, nodeName_):
        supermod.docParBlockType.buildChildren(self, child_, nodeName_)


supermod.docParBlockType.subclass = docParBlockTypeSub
# end class docParBlockTypeSub


class docMarkupTypeSub(supermod.docMarkupType):
    node_type = "docmarkup"

    def __init__(self, valueOf_="", mixedclass_=None, content_=None):
        supermod.docMarkupType.__init__(self, valueOf_, mixedclass_, content_)
        self.type_ = None

    def buildChildren(self, child_, nodeName_):
        if child_.nodeType == Node.TEXT_NODE:
            obj_ = self.mixedclass_(
                MixedContainer.CategoryText, MixedContainer.TypeNone, "", child_.nodeValue
            )
            self.content_.append(obj_)
        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "ref":
            childobj_ = supermod.docRefTextType.factory()
            childobj_.build(child_)
            obj_ = self.mixedclass_(
                MixedContainer.CategoryComplex, MixedContainer.TypeNone, "ref", childobj_
            )
            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 + "]]"


supermod.docMarkupType.subclass = docMarkupTypeSub
# end class docMarkupTypeSub


class docTitleTypeSub(supermod.docTitleType):
    node_type = "doctitle"

    def __init__(self, valueOf_="", mixedclass_=None, content_=None):
        supermod.docTitleType.__init__(self, valueOf_, mixedclass_, content_)
        self.type_ = None

    def buildChildren(self, child_, nodeName_):
        supermod.docTitleType.buildChildren(self, child_, nodeName_)

        if child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "ref":
            obj_ = supermod.docRefTextType.factory()
            obj_.build(child_)
            self.content_.append(obj_)
            self.valueOf_ += obj_.valueOf_
        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "anchor":
            obj_ = supermod.docAnchorType.factory()
            obj_.build(child_)
            self.content_.append(obj_)


supermod.docTitleType.subclass = docTitleTypeSub
# end class docTitleTypeSub


class ParseError(Exception):
    pass


class FileIOError(Exception):
    pass


def parse(inFilename):
    try:
        doc = minidom.parse(str(inFilename))
    except OSError as e:
        raise FileIOError(e)
    except ExpatError as e:
        raise ParseError(e)

    rootNode = doc.documentElement
    rootObj = supermod.DoxygenType.factory()
    rootObj.build(rootNode)
    return rootObj
