From 66296e1c06315e2ebc80c504fd7bdbbe4b73ab72 Mon Sep 17 00:00:00 2001 From: Celine Mercier Date: Mon, 11 May 2015 17:18:23 +0200 Subject: [PATCH] adding the breathe files --- doc/breathe/__init__.py | 16 + doc/breathe/__init__.pyc | Bin 0 -> 491 bytes doc/breathe/directive/__init__.py | 0 doc/breathe/directive/__init__.pyc | Bin 0 -> 194 bytes doc/breathe/directive/base.py | 88 + doc/breathe/directive/base.pyc | Bin 0 -> 3943 bytes doc/breathe/directive/file.py | 123 + doc/breathe/directive/file.pyc | Bin 0 -> 4594 bytes doc/breathe/directive/index.py | 115 + doc/breathe/directive/index.pyc | Bin 0 -> 4470 bytes doc/breathe/directives.py | 1050 +++ doc/breathe/directives.pyc | Bin 0 -> 35541 bytes doc/breathe/exception.py | 3 + doc/breathe/exception.pyc | Bin 0 -> 445 bytes doc/breathe/finder/__init__.py | 0 doc/breathe/finder/__init__.pyc | Bin 0 -> 191 bytes doc/breathe/finder/core.py | 45 + doc/breathe/finder/core.pyc | Bin 0 -> 2655 bytes doc/breathe/finder/doxygen/__init__.py | 1 + doc/breathe/finder/doxygen/__init__.pyc | Bin 0 -> 199 bytes doc/breathe/finder/doxygen/base.py | 18 + doc/breathe/finder/doxygen/base.pyc | Bin 0 -> 1124 bytes doc/breathe/finder/doxygen/compound.py | 75 + doc/breathe/finder/doxygen/compound.pyc | Bin 0 -> 3909 bytes doc/breathe/finder/doxygen/core.py | 55 + doc/breathe/finder/doxygen/core.pyc | Bin 0 -> 3200 bytes doc/breathe/finder/doxygen/index.py | 79 + doc/breathe/finder/doxygen/index.pyc | Bin 0 -> 3370 bytes doc/breathe/parser/__init__.py | 118 + doc/breathe/parser/__init__.pyc | Bin 0 -> 5579 bytes doc/breathe/parser/doxygen/__init__.py | 0 doc/breathe/parser/doxygen/__init__.pyc | Bin 0 -> 199 bytes doc/breathe/parser/doxygen/compound.py | 964 +++ doc/breathe/parser/doxygen/compound.pyc | Bin 0 -> 47683 bytes doc/breathe/parser/doxygen/compoundsuper.py | 5798 +++++++++++++++++ doc/breathe/parser/doxygen/compoundsuper.pyc | Bin 0 -> 398653 bytes doc/breathe/parser/doxygen/index.py | 63 + doc/breathe/parser/doxygen/index.pyc | Bin 0 -> 3240 bytes doc/breathe/parser/doxygen/indexsuper.py | 362 + doc/breathe/parser/doxygen/indexsuper.pyc | Bin 0 -> 21320 bytes doc/breathe/process.py | 87 + doc/breathe/process.pyc | Bin 0 -> 3344 bytes doc/breathe/project.py | 306 + doc/breathe/project.pyc | Bin 0 -> 10021 bytes doc/breathe/renderer/__init__.py | 0 doc/breathe/renderer/__init__.pyc | Bin 0 -> 193 bytes doc/breathe/renderer/rst/__init__.py | 2 + doc/breathe/renderer/rst/__init__.pyc | Bin 0 -> 197 bytes doc/breathe/renderer/rst/doxygen/__init__.py | 383 ++ doc/breathe/renderer/rst/doxygen/__init__.pyc | Bin 0 -> 12815 bytes doc/breathe/renderer/rst/doxygen/base.py | 127 + doc/breathe/renderer/rst/doxygen/base.pyc | Bin 0 -> 5173 bytes doc/breathe/renderer/rst/doxygen/compound.py | 1004 +++ doc/breathe/renderer/rst/doxygen/compound.pyc | Bin 0 -> 43542 bytes doc/breathe/renderer/rst/doxygen/filter.py | 1138 ++++ doc/breathe/renderer/rst/doxygen/filter.pyc | Bin 0 -> 47842 bytes doc/breathe/renderer/rst/doxygen/index.py | 115 + doc/breathe/renderer/rst/doxygen/index.pyc | Bin 0 -> 5495 bytes doc/breathe/renderer/rst/doxygen/mask.py | 62 + doc/breathe/renderer/rst/doxygen/mask.pyc | Bin 0 -> 3385 bytes doc/breathe/renderer/rst/doxygen/target.py | 40 + doc/breathe/renderer/rst/doxygen/target.pyc | Bin 0 -> 2616 bytes 62 files changed, 12237 insertions(+) create mode 100644 doc/breathe/__init__.py create mode 100644 doc/breathe/__init__.pyc create mode 100644 doc/breathe/directive/__init__.py create mode 100644 doc/breathe/directive/__init__.pyc create mode 100644 doc/breathe/directive/base.py create mode 100644 doc/breathe/directive/base.pyc create mode 100644 doc/breathe/directive/file.py create mode 100644 doc/breathe/directive/file.pyc create mode 100644 doc/breathe/directive/index.py create mode 100644 doc/breathe/directive/index.pyc create mode 100644 doc/breathe/directives.py create mode 100644 doc/breathe/directives.pyc create mode 100644 doc/breathe/exception.py create mode 100644 doc/breathe/exception.pyc create mode 100644 doc/breathe/finder/__init__.py create mode 100644 doc/breathe/finder/__init__.pyc create mode 100644 doc/breathe/finder/core.py create mode 100644 doc/breathe/finder/core.pyc create mode 100644 doc/breathe/finder/doxygen/__init__.py create mode 100644 doc/breathe/finder/doxygen/__init__.pyc create mode 100644 doc/breathe/finder/doxygen/base.py create mode 100644 doc/breathe/finder/doxygen/base.pyc create mode 100644 doc/breathe/finder/doxygen/compound.py create mode 100644 doc/breathe/finder/doxygen/compound.pyc create mode 100644 doc/breathe/finder/doxygen/core.py create mode 100644 doc/breathe/finder/doxygen/core.pyc create mode 100644 doc/breathe/finder/doxygen/index.py create mode 100644 doc/breathe/finder/doxygen/index.pyc create mode 100644 doc/breathe/parser/__init__.py create mode 100644 doc/breathe/parser/__init__.pyc create mode 100644 doc/breathe/parser/doxygen/__init__.py create mode 100644 doc/breathe/parser/doxygen/__init__.pyc create mode 100644 doc/breathe/parser/doxygen/compound.py create mode 100644 doc/breathe/parser/doxygen/compound.pyc create mode 100644 doc/breathe/parser/doxygen/compoundsuper.py create mode 100644 doc/breathe/parser/doxygen/compoundsuper.pyc create mode 100644 doc/breathe/parser/doxygen/index.py create mode 100644 doc/breathe/parser/doxygen/index.pyc create mode 100644 doc/breathe/parser/doxygen/indexsuper.py create mode 100644 doc/breathe/parser/doxygen/indexsuper.pyc create mode 100644 doc/breathe/process.py create mode 100644 doc/breathe/process.pyc create mode 100644 doc/breathe/project.py create mode 100644 doc/breathe/project.pyc create mode 100644 doc/breathe/renderer/__init__.py create mode 100644 doc/breathe/renderer/__init__.pyc create mode 100644 doc/breathe/renderer/rst/__init__.py create mode 100644 doc/breathe/renderer/rst/__init__.pyc create mode 100644 doc/breathe/renderer/rst/doxygen/__init__.py create mode 100644 doc/breathe/renderer/rst/doxygen/__init__.pyc create mode 100644 doc/breathe/renderer/rst/doxygen/base.py create mode 100644 doc/breathe/renderer/rst/doxygen/base.pyc create mode 100644 doc/breathe/renderer/rst/doxygen/compound.py create mode 100644 doc/breathe/renderer/rst/doxygen/compound.pyc create mode 100644 doc/breathe/renderer/rst/doxygen/filter.py create mode 100644 doc/breathe/renderer/rst/doxygen/filter.pyc create mode 100644 doc/breathe/renderer/rst/doxygen/index.py create mode 100644 doc/breathe/renderer/rst/doxygen/index.pyc create mode 100644 doc/breathe/renderer/rst/doxygen/mask.py create mode 100644 doc/breathe/renderer/rst/doxygen/mask.pyc create mode 100644 doc/breathe/renderer/rst/doxygen/target.py create mode 100644 doc/breathe/renderer/rst/doxygen/target.pyc diff --git a/doc/breathe/__init__.py b/doc/breathe/__init__.py new file mode 100644 index 0000000..0aaa564 --- /dev/null +++ b/doc/breathe/__init__.py @@ -0,0 +1,16 @@ + +__version__ = '4.0.0' + + +def setup(app): + + # We can't do the import at the module scope as setup.py has to be able to + # import this file to read __version__ without hitting any syntax errors + # from both Python 2 & Python 3. + + # By the time this function is called, the directives code will have been + # converted with 2to3 if appropriate + + from . import directives + + directives.setup(app) diff --git a/doc/breathe/__init__.pyc b/doc/breathe/__init__.pyc new file mode 100644 index 0000000000000000000000000000000000000000..63dcadd294c0273faa9d2d4ed2264e2a9a1a1a2b GIT binary patch literal 491 zcmcgm%}N6?5T5L+Xhjfw0&jb9Q$+A0A_$(Ol!_j_gzRo~WA`T{)5=0U>BIE>d;w?D zif>?GzRb@z^L^>}(WqWeA4}LiLH`X!I3cJ2o(TnfQ6iv9;2}$SxJz)6kMnWK{A3%q zJUS(y4dONct$+^!VkO`$ffc|f6?AlSWny_bW55w_S#L_TOB139QVV7b$a2Bp!euOl zY(YC0XBp)XA!y3vy)C@V+-jbgR5ZC zoHPO2TqRmDKe003mW BGF1Qo literal 0 HcmV?d00001 diff --git a/doc/breathe/directive/base.py b/doc/breathe/directive/base.py new file mode 100644 index 0000000..77f86f1 --- /dev/null +++ b/doc/breathe/directive/base.py @@ -0,0 +1,88 @@ + +from ..renderer.rst.doxygen.base import RenderContext +from ..renderer.rst.doxygen import format_parser_error +from ..parser import ParserError, FileIOError + +from docutils import nodes +from docutils.parsers import rst + + +class WarningHandler(object): + + def __init__(self, state, context): + self.state = state + self.context = context + + def warn(self, raw_text, rendered_nodes=None): + raw_text = self.format(raw_text) + if rendered_nodes is None: + rendered_nodes = [nodes.paragraph("", "", nodes.Text(raw_text))] + return [ + nodes.warning("", *rendered_nodes), + self.state.document.reporter.warning(raw_text, line=self.context['lineno']) + ] + + def format(self, text): + return text.format(**self.context) + + +def create_warning(project_info, state, lineno, **kwargs): + + tail = '' + if project_info: + tail = 'in doxygen xml output for project "{project}" from directory: {path}'.format( + project=project_info.name(), + path=project_info.project_path() + ) + + context = dict( + lineno=lineno, + tail=tail, + **kwargs + ) + + return WarningHandler(state, context) + + +class BaseDirective(rst.Directive): + + def __init__(self, root_data_object, renderer_factory_creator_constructor, finder_factory, + project_info_factory, filter_factory, target_handler_factory, parser_factory, *args): + rst.Directive.__init__(self, *args) + self.directive_args = list(args) # Convert tuple to list to allow modification. + + self.root_data_object = root_data_object + self.renderer_factory_creator_constructor = renderer_factory_creator_constructor + self.finder_factory = finder_factory + self.project_info_factory = project_info_factory + self.filter_factory = filter_factory + self.target_handler_factory = target_handler_factory + self.parser_factory = parser_factory + + def render(self, node_stack, project_info, options, filter_, target_handler, mask_factory): + "Standard render process used by subclasses" + + renderer_factory_creator = self.renderer_factory_creator_constructor.create_factory_creator( + project_info, + self.state.document, + options, + target_handler + ) + + try: + renderer_factory = renderer_factory_creator.create_factory( + node_stack, + self.state, + self.state.document, + filter_, + target_handler, + ) + except ParserError as e: + return format_parser_error("doxygenclass", e.error, e.filename, self.state, + self.lineno, True) + except FileIOError as e: + return format_parser_error("doxygenclass", e.error, e.filename, self.state, self.lineno) + + context = RenderContext(node_stack, mask_factory, self.directive_args) + object_renderer = renderer_factory.create_renderer(context) + return object_renderer.render() diff --git a/doc/breathe/directive/base.pyc b/doc/breathe/directive/base.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e80d74fb93bff685bddc0aacdf51013a28ece169 GIT binary patch literal 3943 zcmc&%U2hvj6ur9}JGPTFRSTs>LNaXu^U+wqLnVX?YD)ouLbWNhtb}(KQvnInpvX(p(IT87BcU`hJ2fG`Rb;NXJbWSzamKvLqt;5G^iR`ob_$t107#`T9E@=YQkR zAJc$lS!KrhA$?O@=g#5xVOp1Yx&KvKW`(Jj?&Ak;quIA14D5lGqK1W%MfBz~xDpNu zb+RGxPHzRO1D?&s1MZ;NOAymQrXmSCp?37J9lgx9w}m&fE_KGOqBofPfCo7qYfUkX zxe~V^dT3tQef0X@=6iKoANTLo>DWB3>OHlDAn^&dnf3$V8U*voJ ziE40Ub7yW$(!pW6Z)|_BHmN%>{VcD|z~w)g{$6U$7S#FaB+1L%CCNJamN%229W0G* zVys3xbYSsFO+N`_1_!`#B8M%hKNA2bKDEyDCl0eXb1w zn5Fx5Iyum_2SB1mN=TG3W3#7&lX zG(zVL;z(O*&w2b>dPIWFU_H1VZUzIwcF{DFRD!b^NjN)@Uj<%f%6j0&%pq?!w|TSG znap9#ynOrgN>}h@%Nt3s-DAM#=q-^UN#baAl8meDsK7AhFy5qije<6v-d%eyGtpw+ zmshgvG{g4FdRtRWhnV_?YmXq19W&$(*z9Ab1A>HH@NqgpUzbK9nfXLQXfmykcSs*3 zV^gM3h!D|m)?m7jr5bX=G$Pe($0S&L7a}jaS@q<2-;~`aujhd$X(EVO@>8o<6Gj_>=C_2?%ATX*5^T+~RCZ-q(>!^P)!kuzKPI#H{Tt$44i2ngCCK*L&U!qxT z5HKWi8PEV&rY-Vo0AQd862?^G!GMlJg)=~lLMvHS*kGnbv~Z~{Q>>!XkttTuStHdi zXoAs+8Cm7mr8Sy#8s{RPzs1WZCt<)Gsi&?gmt?6+lWLDZbJscPS+q`u>A(SEiMq9_ z6TF+&)kmCEcMo$`6bm&+S1+(coGcfZ@WZ?SgDKe8fE+yFL<9(9MP{pV++*p%#6`uS6?om(~u8O3G+dHWMU?Dj3)6r5ROmS{Hu!` z(Q3yJdYXw^m~^1X5+p&*IXH~ppoWiAd$>%A%h 1: + warning = create_warning(None, self.state, self.lineno, file=file_, + directivename=self.directive_name) + return warning.warn('{directivename}: Found multiple matches for file "{file} {tail}') + + elif not matches: + warning = create_warning(None, self.state, self.lineno, file=file_, + directivename=self.directive_name) + return warning.warn('{directivename}: Cannot find file "{file} {tail}') + + target_handler = self.target_handler_factory.create_target_handler( + self.options, project_info, self.state.document) + filter_ = self.filter_factory.create_file_filter(file_, self.options) + + renderer_factory_creator = self.renderer_factory_creator_constructor.create_factory_creator( + project_info, + self.state.document, + self.options, + target_handler + ) + node_list = [] + for node_stack in matches: + + renderer_factory = renderer_factory_creator.create_factory( + node_stack, + self.state, + self.state.document, + filter_, + target_handler, + ) + + mask_factory = NullMaskFactory() + context = RenderContext(node_stack, mask_factory, self.directive_args) + object_renderer = renderer_factory.create_renderer(context) + node_list.extend(object_renderer.render()) + + return node_list + + +class DoxygenFileDirective(BaseFileDirective): + + directive_name = 'doxygenfile' + + required_arguments = 0 + optional_arguments = 2 + option_spec = { + "path": unchanged_required, + "project": unchanged_required, + "outline": flag, + "no-link": flag, + } + has_content = False + + def run(self): + """Get the file from the argument and the project info from the factory.""" + + file_ = self.arguments[0] + + try: + project_info = self.project_info_factory.create_project_info(self.options) + except ProjectError as e: + warning = create_warning(None, self.state, self.lineno) + return warning.warn('doxygenfile: %s' % e) + + return self.handle_contents(file_, project_info) + + +class AutoDoxygenFileDirective(BaseFileDirective): + + directive_name = 'autodoxygenfile' + + required_arguments = 1 + option_spec = { + "project": unchanged_required, + "outline": flag, + "no-link": flag, + } + has_content = False + + def run(self): + """Get the file from the argument and extract the associated project info for the named + project given that it is an auto-project. + """ + + file_ = self.arguments[0] + + try: + project_info = self.project_info_factory.retrieve_project_info_for_auto(self.options) + except ProjectError as e: + warning = create_warning(None, self.state, self.lineno) + return warning.warn('autodoxygenfile: %s' % e) + + return self.handle_contents(file_, project_info) + diff --git a/doc/breathe/directive/file.pyc b/doc/breathe/directive/file.pyc new file mode 100644 index 0000000000000000000000000000000000000000..30c7a49429b59719fec60ebeebfd3a1feb11ddf6 GIT binary patch literal 4594 zcmd5G|xoXo=(s=;fp~LDJr}Nt>MGKD03oG}5#J3W63_GG&TX zc2~JGP67fr?|tiM=w~SUt@;7l-^_}Vj#wAXk4dW-SumfH)y;;y$$s1lr|{e zq;ZpaP4qV?-K4xl<1OlK(RiDB+m70#e22!n)Z0bBMXF8%kJ2sris**uPrW@#w@K{@ zb!SQ4r*yZX?k%YgDBY*?_5&!8`Dof68oPrgQbnrt^Rlq&m38Djkk6)h{z+o4PLsYZ z_4SJXqr|9_Osl@lzEF<54gMFp9D(++)}_vPaW}M!x4u@1Rq@M27g;gP{)JDQWv~Zm zrbYiUDTXSIwfcODbyHgdd5|YVw*nhq8*5o~-upDmSNkuIhB%%>ZV=7CUr8sWtg zN{t}oyiT)#Mm3t@SEn1FJPQ)upqfWlHPT;_ZLpfW;-<7s_C>6cxEcV=q_JBqQYf~J< zY=drUG;fN^EqbL{#gjjeXud_WCXL>p8D5qOZW1<|VMR=<(|nuk_c$2lJ7gaUrxWf_ z1cHbV_Yut?2MmpgEgBusY>!6AJPSnc^T*z2AfLAzIG;1|T<3r|XNixr^7SGaEAwk` zy<-<~EzaJI0CaUn&z0O6}a`&DZQT^YFDzvV3lS`rp=go)krC!H<>1 z$JQsczmG|lqlr0`jt4F-MZ`sbxse4^Zf`LiW8RV}S8=sQ#$0woR+R~sJvLWG#4#v# zI4cVUzk}~uxIg?2<5{5~D+{x`%w4u!0lo;)~pm!J`GeR;tFrSL(RWtLQ0%mq=61cV?^DM2YpGh@m9H3cMCi761& z_vy3ZDb=vqRf}{&9uh8R(nX4NNo!N`h2+|i%b@`sa%S6w@pO~{Y+s$&w0(fLeBPV$q zJCjvsi(h{+@Gz!&>OZ-X4Y!wq}6WQwYej8}GJm0e~@@)bD}tvREK zk2;3fOaN#+a+>5u$;f45DqM*^z{tuT_imKvUF^@^XIS5ck1y~l@HXVzLSItAhf`aA zy^v>p)Ox*)kk0~AH4c0U_EpUH8l-TI+2qLQC~tCa5_$P@Dl-vkMw_jx0B^_An_ClE-? zjj_E$f%+N>a20b01tKoeSHT^9$X(8F5$BC>J%UdlM1sd~#pNQ{#V<$iS(~xSa=~8J zR2|%YJBzUDT;K*AVeo&jaJ?o)?0SXnruvxbLXy!{GO#SkS81HgNoUx?@5ul1#*Ok-UJ6g&$;#aOr`+!w9Y~6it@%0bA{owHF;Sc`} DM0i?z literal 0 HcmV?d00001 diff --git a/doc/breathe/directive/index.py b/doc/breathe/directive/index.py new file mode 100644 index 0000000..a8faa7b --- /dev/null +++ b/doc/breathe/directive/index.py @@ -0,0 +1,115 @@ + +from ..renderer.rst.doxygen.base import RenderContext +from ..renderer.rst.doxygen.mask import NullMaskFactory +from ..renderer.rst.doxygen import format_parser_error +from ..directive.base import BaseDirective +from ..project import ProjectError +from ..parser import ParserError, FileIOError +from .base import create_warning + +from docutils.parsers import rst +from docutils.parsers.rst.directives import unchanged_required, flag + + +class BaseIndexDirective(BaseDirective): + """Base class handle the main work when given the appropriate project info to work from. + """ + + # We use inheritance here rather than a separate object and composition, because so much + # information is present in the Directive class from the docutils framework that we'd have to + # pass way too much stuff to a helper object to be reasonable. + + def handle_contents(self, project_info): + + try: + finder = self.finder_factory.create_finder(project_info) + except ParserError as e: + return format_parser_error(self.name, e.error, e.filename, self.state, + self.lineno, True) + except FileIOError as e: + return format_parser_error(self.name, e.error, e.filename, self.state, self.lineno) + + data_object = finder.root() + + target_handler = self.target_handler_factory.create_target_handler( + self.options, project_info, self.state.document) + filter_ = self.filter_factory.create_index_filter(self.options) + + renderer_factory_creator = self.renderer_factory_creator_constructor.create_factory_creator( + project_info, + self.state.document, + self.options, + target_handler + ) + renderer_factory = renderer_factory_creator.create_factory( + [data_object], + self.state, + self.state.document, + filter_, + target_handler, + ) + + mask_factory = NullMaskFactory() + context = RenderContext([data_object, self.root_data_object], mask_factory, self.directive_args) + object_renderer = renderer_factory.create_renderer(context) + + try: + node_list = object_renderer.render() + except ParserError as e: + return format_parser_error(self.name, e.error, e.filename, self.state, + self.lineno, True) + except FileIOError as e: + return format_parser_error(self.name, e.error, e.filename, self.state, self.lineno) + + return node_list + + +class DoxygenIndexDirective(BaseIndexDirective): + + required_arguments = 0 + optional_arguments = 2 + option_spec = { + "path": unchanged_required, + "project": unchanged_required, + "outline": flag, + "no-link": flag, + } + has_content = False + + def run(self): + """Extract the project info and pass it to the helper method""" + + try: + project_info = self.project_info_factory.create_project_info(self.options) + except ProjectError as e: + warning = create_warning(None, self.state, self.lineno) + return warning.warn('doxygenindex: %s' % e) + + return self.handle_contents(project_info) + + +class AutoDoxygenIndexDirective(BaseIndexDirective): + + required_arguments = 0 + final_argument_whitespace = True + option_spec = { + "project": unchanged_required, + "outline": flag, + "no-link": flag, + } + has_content = False + + def run(self): + """Extract the project info from the auto project info store and pass it to the helper + method + """ + + try: + project_info = self.project_info_factory.retrieve_project_info_for_auto(self.options) + except ProjectError as e: + warning = create_warning(None, self.state, self.lineno) + return warning.warn('autodoxygenindex: %s' % e) + + return self.handle_contents(project_info) + + diff --git a/doc/breathe/directive/index.pyc b/doc/breathe/directive/index.pyc new file mode 100644 index 0000000000000000000000000000000000000000..71aacef9686a9b58f84a8d9cbbad41c7d0041d80 GIT binary patch literal 4470 zcmd55QH2Vd(e}c>W zi6+6nM;TG>QP(4n`#xnpy&L#zD?b2^y`!~DBGdDN!_OFZ%}rP@?GlgQhuGf*CE{`wMKo9 zk}Y~jbV2lE_XZ`~q;80GXCb{wNpmi}wvg^ovP(zp>o{iWqiK6+>=v3(6^YWHmxWcQ z)`@o@KAdFP*ReUd8~1Ff&)fh{@0U7{Z8VOxQ94pumwLI_XR%RVq+0cC`ipYnP0YEk z%MoOEM47j@8!VM2L@52cX{NrsC;gPobMv?H)YB@qDtZv>A}t2#-}t#fet+87wye2} z&ZOuK<6@waNUNVGuq3e+i2GSQusqHNeu)F0F05R{0&n>lF7pf;MH~W%fUeI$0hc2J z!Xw$pbY}~-dRc5t3mYbxYT2P`<#AfH9+di|^HFlJ zBS>u^dKH=mG^$El6Umyi>tyS6QKO@ZZOF8TPdM$ON=H9TeHv|W@SS6Qn6gQuEqT~x zn^>|&qaC^k=p0+4+oaL8nF3qvEZL>e^-KD!i504JQK56#iA8SEv_gaVnv0dESOIEP zI>$k7iY0ZjaE-I)85;OBt;>%4Vn&0e>omGW(}uWggU*^X-JsF4GI#Tm2Y>bcl?Q)+ z!fDQfn?NB)+F|=Sw3eg0pE3fYzC)UTau)DzB&rSx=aB#KO5JoO9-CvfbsOki8n> zBHQE*aKtEyZ5)-yj5e8(%&95Dxs7F>n=LZ8NBrhGZN{Lu%c!hxna5_xjTpJ2>0XfK zt(9=tqdQ*VKIetV?qkw?+xg31oKKGMh>ygC9GpDYmbU?iF>}jd+)+V&98mCd9a|J- zqM|GXNuop2m?54zU!})7)@Pl&8Ue+eWjgoI?652j`g2L=JEaZ3>&}}8?{u>CxHA?F z?wQo8*T!-0BpxW!IcA0)s?Ng09eL#k&}T2Z0OOZy5iEv7&oI}LA9#D-j`y6mh4xi{ z)31B`-c7WDSNCdO-LIj=o%=!Ed*0i@jONOWHbX)}F^U)hQ3PTmilV$sCK-1*WTOay z8bx6T&r3f%eP@K6_Zahr&93>i8d!|zi}Lhrpo+&NCQfpanC{@=k;H_olvYSpxKg>z zw*a>)B^7t8((P`ID~IknB{fN7bxvdKlN6UL1|-PGcz@!nS&%!ZPb`y&Vf~_f4bLY% z4tBPlDM-@OF&@r9v0!ohJI?lnZawhpyU0+1q?&J#YJ6lUF_yLGiHY+C(iRdHti*hu z_K+=*ZlD7)muz>`W;d93(cC$;8gw9e^-?ZH9&U{}Bc~WdYDGdGs%)%u3ye7|6T_%V zoUbK3-)p^M4%-|r_6C|&crP%v!eXoAAy)|@`ypiKhzk$PLWS2@#HEIaxMXorC#o;< z;7i=R!WuktR@5w`^68?Jy{ae0J=_da90h@Q3;5dic75?o_&S8)8)&3}nwM3~pu+q{ z#4abq*-{)b`Gn$I4tl2$nK8JSBj;|M8AqAJ*vyF``~V|MPy7e?d^2 z&Jw7GZ{sPvjpqLY#}iodSU7S?>xy4E>~hs>klt16v3Qj_m}_B&+eOzfN@J{cHHgD^ zFl?Vkqm|XE`b9;nkd5%^67lRuup2U|EO8sY$6d)3S70`LAEV0#jo7gln2Ts?7>pb}dULG~{>WDkayi_$SFG=1qQ&h^ny!h`%>C_oO~2{w1$%Gr?f(OPgDK?z literal 0 HcmV?d00001 diff --git a/doc/breathe/directives.py b/doc/breathe/directives.py new file mode 100644 index 0000000..99a8a77 --- /dev/null +++ b/doc/breathe/directives.py @@ -0,0 +1,1050 @@ + +from .finder.core import FinderFactory +from .parser import DoxygenParserFactory, CacheFactory +from .renderer.rst.doxygen import DoxygenToRstRendererFactoryCreatorConstructor, \ + RstContentCreator, RenderContext +from .renderer.rst.doxygen.filter import FilterFactory, GlobFactory +from .renderer.rst.doxygen.target import TargetHandlerFactory +from .renderer.rst.doxygen.mask import MaskFactory, NullMaskFactory, NoParameterNamesMask + +from .finder.doxygen.core import DoxygenItemFinderFactoryCreator +from .directive.base import BaseDirective, create_warning +from .directive.index import DoxygenIndexDirective, AutoDoxygenIndexDirective +from .directive.file import DoxygenFileDirective, AutoDoxygenFileDirective +from .process import AutoDoxygenProcessHandle +from .exception import BreatheError +from .project import ProjectInfoFactory, ProjectError + +from docutils.parsers.rst.directives import unchanged_required, unchanged, flag +from docutils.statemachine import ViewList +from sphinx.domains import cpp, c, python +from sphinx.writers.text import TextWriter +from sphinx.builders.text import TextBuilder + +import docutils.nodes +import sphinx.addnodes +import sphinx.ext.mathbase + +import os +import fnmatch +import re +import textwrap +import collections +import subprocess + +# Somewhat outrageously, reach in and fix a Sphinx regex +cpp._identifier_re = re.compile(r'(~?\b[a-zA-Z_][a-zA-Z0-9_]*)\b') + + +class NoMatchingFunctionError(BreatheError): + pass + + +class UnableToResolveFunctionError(BreatheError): + + def __init__(self, signatures): + self.signatures = signatures + + +class NodeNotFoundError(BreatheError): + pass + + +class FakeDestination(object): + + def write(self, output): + return output + + +class TextRenderer(object): + + def __init__(self, app): + self.app = app + + def render(self, nodes, document): + + new_document = document.copy() + + new_document.children = nodes + + writer = TextWriter(TextBuilder(self.app)) + output = writer.write(new_document, FakeDestination()) + + return output.strip() + + +# Directives +# ---------- + +class DoxygenFunctionDirective(BaseDirective): + + required_arguments = 1 + option_spec = { + "path": unchanged_required, + "project": unchanged_required, + "outline": flag, + "no-link": flag, + } + has_content = False + final_argument_whitespace = True + + def __init__(self, node_factory, text_renderer, *args, **kwargs): + BaseDirective.__init__(self, *args, **kwargs) + + self.node_factory = node_factory + self.text_renderer = text_renderer + + def run(self): + + # Separate possible arguments (delimited by a "(") from the namespace::name + match = re.match(r"([^(]*)(.*)", self.arguments[0]) + namespaced_function, args = match.group(1), match.group(2) + + # Split the namespace and the function name + try: + (namespace, function_name) = namespaced_function.rsplit("::", 1) + except ValueError: + (namespace, function_name) = "", namespaced_function + + try: + project_info = self.project_info_factory.create_project_info(self.options) + except ProjectError as e: + warning = create_warning(None, self.state, self.lineno) + return warning.warn('doxygenfunction: %s' % e) + + try: + finder = self.finder_factory.create_finder(project_info) + except MTimerError as e: + warning = create_warning(None, self.state, self.lineno) + return warning.warn('doxygenfunction: %s' % e) + + # Extract arguments from the function name. + args = self.parse_args(args) + + finder_filter = self.filter_factory.create_member_finder_filter( + namespace, function_name, 'function') + + matches = [] + finder.filter_(finder_filter, matches) + + # Create it ahead of time as it is cheap and it is ugly to declare it for both exception + # clauses below + warning = create_warning( + project_info, + self.state, + self.lineno, + namespace='%s::' % namespace if namespace else '', + function=function_name, + args=', '.join(args) + ) + + try: + node_stack = self.resolve_function(matches, args, project_info) + except NoMatchingFunctionError: + return warning.warn('doxygenfunction: Cannot find function "{namespace}{function}" ' + '{tail}') + except UnableToResolveFunctionError as error: + message = 'doxygenfunction: Unable to resolve multiple matches for function ' \ + '"{namespace}{function}" with arguments ({args}) {tail}.\n' \ + 'Potential matches:\n' + + # We want to create a raw_text string for the console output and a set of docutils nodes + # for rendering into the final output. We handle the final output as a literal string + # with a txt based list of the options. + raw_text = message + literal_text = '' + + # TODO: We're cheating here with the set() as signatures has repeating entries for some + # reason (failures in the matcher_stack code) so we consolidate them by shoving them in + # a set to remove duplicates. Should be fixed! + for i, entry in enumerate(set(error.signatures)): + if i: + literal_text += '\n' + # Replace new lines with a new line & enough spacing to reach the appropriate + # alignment for our simple plain text list + literal_text += '- %s' % entry.replace('\n', '\n ') + raw_text += ' - %s\n' % entry.replace('\n', '\n ') + block = self.node_factory.literal_block('', '', self.node_factory.Text(literal_text)) + formatted_message = warning.format(message) + warning_nodes = [ + self.node_factory.paragraph( + "", "", + self.node_factory.Text(formatted_message) + ), + block + ] + result = warning.warn(raw_text, warning_nodes) + return result + + target_handler = self.target_handler_factory.create_target_handler( + self.options, project_info, self.state.document + ) + filter_ = self.filter_factory.create_outline_filter(self.options) + + return self.render(node_stack, project_info, self.options, filter_, target_handler, + NullMaskFactory()) + + def parse_args(self, function_description): + # Strip off trailing qualifiers + pattern = re.compile(r'''(?<= \)) \s* + (?: const)? \s* + (?: volatile)? \s* + (?: = \s* 0)? \s* $ ''', + re.VERBOSE) + + function_description = re.sub(pattern, + '', + function_description) + + paren_index = function_description.find('(') + if paren_index == -1: + return [] + # If it is empty parenthesis, then return empty list as we want empty parenthesis coming + # from the xml file to match the user's function when the user doesn't provide parenthesis + # ie. when there are no args anyway + elif function_description == '()': + return [] + else: + # Parse the function name string, eg. f(int, float) to + # extract the types so we can use them for matching + args = [] + num_open_brackets = -1 + start = paren_index + 1 + for i in range(paren_index, len(function_description)): + c = function_description[i] + if c == '(' or c == '<': + num_open_brackets += 1 + elif c == ')' or c == '>': + num_open_brackets -= 1 + elif c == ',' and num_open_brackets == 0: + args.append(function_description[start:i].strip()) + start = i + 1 + args.append(function_description[start:-1].strip()) + + return args + + def resolve_function(self, matches, args, project_info): + + if not matches: + raise NoMatchingFunctionError() + + if len(matches) == 1: + return matches[0] + + node_stack = None + + signatures = [] + + # Iterate over the potential matches + for entry in matches: + + text_options = {'no-link': u'', 'outline': u''} + + # Render the matches to docutils nodes + target_handler = self.target_handler_factory.create_target_handler( + {'no-link': u''}, project_info, self.state.document + ) + filter_ = self.filter_factory.create_outline_filter(text_options) + mask_factory = MaskFactory({'param': NoParameterNamesMask}) + nodes = self.render(entry, project_info, text_options, filter_, target_handler, + mask_factory) + + # Render the nodes to text + signature = self.text_renderer.render(nodes, self.state.document) + signatures.append(signature) + + match = re.match(r"([^(]*)(.*)", signature) + match_args = match.group(2) + + # Parse the text to find the arguments + match_args = self.parse_args(match_args) + + # Match them against the arg spec + if args == match_args: + node_stack = entry + break + + if not node_stack: + raise UnableToResolveFunctionError(signatures) + + return node_stack + + +class DoxygenClassLikeDirective(BaseDirective): + + required_arguments = 1 + optional_arguments = 0 + final_argument_whitespace = True + option_spec = { + "path": unchanged_required, + "project": unchanged_required, + "members": unchanged, + "protected-members": flag, + "private-members": flag, + "undoc-members": flag, + "show": unchanged_required, + "outline": flag, + "no-link": flag, + } + has_content = False + + def run(self): + + name = self.arguments[0] + + try: + project_info = self.project_info_factory.create_project_info(self.options) + except ProjectError as e: + warning = create_warning(None, self.state, self.lineno, kind=self.kind) + return warning.warn('doxygen{kind}: %s' % e) + + try: + finder = self.finder_factory.create_finder(project_info) + except MTimerError as e: + warning = create_warning(None, self.state, self.lineno, kind=self.kind) + return warning.warn('doxygen{kind}: %s' % e) + + finder_filter = self.filter_factory.create_compound_finder_filter(name, self.kind) + + matches = [] + finder.filter_(finder_filter, matches) + + if len(matches) == 0: + warning = create_warning(project_info, self.state, self.lineno, name=name, + kind=self.kind) + return warning.warn('doxygen{kind}: Cannot find class "{name}" {tail}') + + target_handler = self.target_handler_factory.create_target_handler( + self.options, project_info, self.state.document + ) + filter_ = self.filter_factory.create_class_filter(name, self.options) + + mask_factory = NullMaskFactory() + return self.render(matches[0], project_info, self.options, filter_, target_handler, + mask_factory) + + +class DoxygenClassDirective(DoxygenClassLikeDirective): + + kind = "class" + + +class DoxygenStructDirective(DoxygenClassLikeDirective): + + kind = "struct" + + +class DoxygenContentBlockDirective(BaseDirective): + """Base class for namespace and group directives which have very similar behaviours""" + + required_arguments = 1 + optional_arguments = 1 + option_spec = { + "path": unchanged_required, + "project": unchanged_required, + "content-only": flag, + "outline": flag, + "members": flag, + "protected-members": flag, + "private-members": flag, + "undoc-members": flag, + "no-link": flag + } + has_content = False + + def run(self): + + name = self.arguments[0] + + try: + project_info = self.project_info_factory.create_project_info(self.options) + except ProjectError as e: + warning = create_warning(None, self.state, self.lineno, kind=self.kind) + return warning.warn('doxygen{kind}: %s' % e) + + try: + finder = self.finder_factory.create_finder(project_info) + except MTimerError as e: + warning = create_warning(None, self.state, self.lineno, kind=self.kind) + return warning.warn('doxygen{kind}: %s' % e) + + finder_filter = self.filter_factory.create_finder_filter(self.kind, name) + + matches = [] + finder.filter_(finder_filter, matches) + + # It shouldn't be possible to have too many matches as namespaces & groups in their nature + # are merged together if there are multiple declarations, so we only check for no matches + if not matches: + warning = create_warning(project_info, self.state, self.lineno, name=name, + kind=self.kind) + return warning.warn('doxygen{kind}: Cannot find namespace "{name}" {tail}') + + if 'content-only' in self.options: + + # Unpack the single entry in the matches list + (node_stack,) = matches + + filter_ = self.filter_factory.create_content_filter(self.kind, self.options) + + # Having found the compound node for the namespace or group in the index we want to grab + # the contents of it which match the filter + contents_finder = self.finder_factory.create_finder_from_root(node_stack[0], + project_info) + contents = [] + contents_finder.filter_(filter_, contents) + + # Replaces matches with our new starting points + matches = contents + + target_handler = self.target_handler_factory.create_target_handler( + self.options, project_info, self.state.document + ) + filter_ = self.filter_factory.create_render_filter(self.kind, self.options) + + renderer_factory_creator = self.renderer_factory_creator_constructor.create_factory_creator( + project_info, + self.state.document, + self.options, + target_handler + ) + node_list = [] + + for node_stack in matches: + renderer_factory = renderer_factory_creator.create_factory( + node_stack, + self.state, + self.state.document, + filter_, + target_handler, + ) + + mask_factory = NullMaskFactory() + context = RenderContext(node_stack, mask_factory, self.directive_args) + object_renderer = renderer_factory.create_renderer(context) + node_list.extend(object_renderer.render()) + + return node_list + + +class DoxygenNamespaceDirective(DoxygenContentBlockDirective): + + kind = "namespace" + + +class DoxygenGroupDirective(DoxygenContentBlockDirective): + + kind = "group" + + +# This class was the same as the DoxygenBaseDirective above, except that it +# wraps the output in a definition_list before passing it back. This should be +# abstracted in a far nicer way to avoid repeating so much code +# +# Now we've removed the definition_list wrap so we really need to refactor this! +class DoxygenBaseItemDirective(BaseDirective): + + required_arguments = 1 + optional_arguments = 1 + option_spec = { + "path": unchanged_required, + "project": unchanged_required, + "outline": flag, + "no-link": flag, + } + has_content = False + + def create_finder_filter(self, namespace, name): + """Creates a filter to find the node corresponding to this item.""" + + return self.filter_factory.create_member_finder_filter( + namespace, name, self.kind) + + def run(self): + + try: + namespace, name = self.arguments[0].rsplit("::", 1) + except ValueError: + namespace, name = "", self.arguments[0] + + try: + project_info = self.project_info_factory.create_project_info(self.options) + except ProjectError as e: + warning = create_warning(None, self.state, self.lineno, kind=self.kind) + return warning.warn('doxygen{kind}: %s' % e) + + try: + finder = self.finder_factory.create_finder(project_info) + except MTimerError as e: + warning = create_warning(None, self.state, self.lineno, kind=self.kind) + return warning.warn('doxygen{kind}: %s' % e) + + finder_filter = self.create_finder_filter(namespace, name) + + matches = [] + finder.filter_(finder_filter, matches) + + if len(matches) == 0: + display_name = "%s::%s" % (namespace, name) if namespace else name + warning = create_warning(project_info, self.state, self.lineno, kind=self.kind, + display_name=display_name) + return warning.warn('doxygen{kind}: Cannot find {kind} "{display_name}" {tail}') + + target_handler = self.target_handler_factory.create_target_handler( + self.options, project_info, self.state.document + ) + filter_ = self.filter_factory.create_outline_filter(self.options) + + node_stack = matches[0] + mask_factory = NullMaskFactory() + return self.render(node_stack, project_info, self.options, filter_, target_handler, + mask_factory) + + +class DoxygenVariableDirective(DoxygenBaseItemDirective): + + kind = "variable" + + def render(self, node_stack, project_info, options, filter_, target_handler, mask_factory): + # Remove 'extern' keyword as Sphinx doesn't support it. + definition = node_stack[0].definition + extern = 'extern ' + if definition.startswith(extern): + definition = definition[len(extern):] + self.directive_args[1] = [definition] + return DoxygenBaseItemDirective.render(self, node_stack, project_info, options, filter_, + target_handler, mask_factory) + + +class DoxygenDefineDirective(DoxygenBaseItemDirective): + + kind = "define" + + +class DoxygenEnumDirective(DoxygenBaseItemDirective): + + kind = "enum" + + +class DoxygenEnumValueDirective(DoxygenBaseItemDirective): + + kind = "enumvalue" + + def create_finder_filter(self, namespace, name): + + return self.filter_factory.create_enumvalue_finder_filter(name) + + +class DoxygenTypedefDirective(DoxygenBaseItemDirective): + + kind = "typedef" + + +class DoxygenUnionDirective(DoxygenBaseItemDirective): + + kind = "union" + + def create_finder_filter(self, namespace, name): + + # Unions are stored in the xml file with their fully namespaced name + # We're using C++ namespaces here, it might be best to make this file + # type dependent + # + xml_name = "%s::%s" % (namespace, name) if namespace else name + return self.filter_factory.create_compound_finder_filter(xml_name, 'union') + + +# Setup Administration +# -------------------- + +class DirectiveContainer(object): + + def __init__(self, directive, *args): + + self.directive = directive + self.args = args + + # Required for sphinx to inspect + self.required_arguments = directive.required_arguments + self.optional_arguments = directive.optional_arguments + self.option_spec = directive.option_spec + self.has_content = directive.has_content + self.final_argument_whitespace = directive.final_argument_whitespace + + def __call__(self, *args): + + call_args = [] + call_args.extend(self.args) + call_args.extend(args) + + return self.directive(*call_args) + + +class DoxygenDirectiveFactory(object): + + directives = { + "doxygenindex": DoxygenIndexDirective, + "autodoxygenindex": AutoDoxygenIndexDirective, + "doxygenfunction": DoxygenFunctionDirective, + "doxygenstruct": DoxygenStructDirective, + "doxygenclass": DoxygenClassDirective, + "doxygenvariable": DoxygenVariableDirective, + "doxygendefine": DoxygenDefineDirective, + "doxygenenum": DoxygenEnumDirective, + "doxygenenumvalue": DoxygenEnumValueDirective, + "doxygentypedef": DoxygenTypedefDirective, + "doxygenunion": DoxygenUnionDirective, + "doxygennamespace": DoxygenNamespaceDirective, + "doxygengroup": DoxygenGroupDirective, + "doxygenfile": DoxygenFileDirective, + "autodoxygenfile": AutoDoxygenFileDirective, + } + + def __init__(self, node_factory, text_renderer, root_data_object, + renderer_factory_creator_constructor, finder_factory, + project_info_factory, filter_factory, target_handler_factory, parser_factory): + + self.node_factory = node_factory + self.text_renderer = text_renderer + self.root_data_object = root_data_object + self.renderer_factory_creator_constructor = renderer_factory_creator_constructor + self.finder_factory = finder_factory + self.project_info_factory = project_info_factory + self.filter_factory = filter_factory + self.target_handler_factory = target_handler_factory + self.parser_factory = parser_factory + + # TODO: This methods should be scrapped as they are only called in one place. We should just + # inline the code at the call site + def create_index_directive_container(self): + return self.create_directive_container("doxygenindex") + + def create_function_directive_container(self): + + # Pass text_renderer to the function directive + return DirectiveContainer( + self.directives["doxygenfunction"], + self.node_factory, + self.text_renderer, + self.root_data_object, + self.renderer_factory_creator_constructor, + self.finder_factory, + self.project_info_factory, + self.filter_factory, + self.target_handler_factory, + self.parser_factory + ) + + def create_struct_directive_container(self): + return self.create_directive_container("doxygenstruct") + + def create_enum_directive_container(self): + return self.create_directive_container("doxygenenum") + + def create_enumvalue_directive_container(self): + return self.create_directive_container("doxygenenumvalue") + + def create_typedef_directive_container(self): + return self.create_directive_container("doxygentypedef") + + def create_union_directive_container(self): + return self.create_directive_container("doxygenunion") + + def create_class_directive_container(self): + return self.create_directive_container("doxygenclass") + + def create_file_directive_container(self): + return self.create_directive_container("doxygenfile") + + def create_namespace_directive_container(self): + return self.create_directive_container("doxygennamespace") + + def create_group_directive_container(self): + return self.create_directive_container("doxygengroup") + + def create_variable_directive_container(self): + return self.create_directive_container("doxygenvariable") + + def create_define_directive_container(self): + return self.create_directive_container("doxygendefine") + + def create_auto_index_directive_container(self): + return self.create_directive_container("autodoxygenindex") + + def create_auto_file_directive_container(self): + return self.create_directive_container("autodoxygenfile") + + def create_directive_container(self, type_): + + return DirectiveContainer( + self.directives[type_], + self.root_data_object, + self.renderer_factory_creator_constructor, + self.finder_factory, + self.project_info_factory, + self.filter_factory, + self.target_handler_factory, + self.parser_factory + ) + + def get_config_values(self, app): + + # All DirectiveContainers maintain references to this project info factory + # so we can update this to update them + self.project_info_factory.update( + app.config.breathe_projects, + app.config.breathe_default_project, + app.config.breathe_domain_by_extension, + app.config.breathe_domain_by_file_pattern, + app.config.breathe_projects_source, + app.config.breathe_build_directory + ) + + +class NodeFactory(object): + + def __init__(self, *args): + + self.sources = args + + def __getattr__(self, node_name): + + for source in self.sources: + try: + return getattr(source, node_name) + except AttributeError: + pass + + raise NodeNotFoundError(node_name) + + +class RootDataObject(object): + + node_type = "root" + + +class PathHandler(object): + + def __init__(self, config_directory, sep, basename, join): + + self.config_directory = config_directory + + self.sep = sep + self.basename = basename + self.join = join + + def includes_directory(self, file_path): + + # Check for backslash or forward slash as we don't know what platform we're on and sometimes + # the doxygen paths will have forward slash even on Windows. + return bool(file_path.count('\\')) or bool(file_path.count('/')) + + def resolve_path(self, directory, filename): + """Returns a full path to the filename in the given directory assuming that if the directory + path is relative, then it is relative to the conf.py directory. + """ + + # os.path.join does the appropriate handling if _project_path is an absolute path + return self.join(self.config_directory, directory, filename) + + +def write_file(directory, filename, content): + + # Check the directory exists + if not os.path.exists(directory): + os.makedirs(directory) + + # Write the file with the provided contents + with open(os.path.join(directory, filename), "w") as f: + f.write(content) + + +class MTimerError(Exception): + pass + + +class MTimer(object): + + def __init__(self, getmtime): + self.getmtime = getmtime + + def get_mtime(self, filename): + + try: + return self.getmtime(filename) + except OSError: + raise MTimerError('Cannot find file: %s' % os.path.realpath(filename)) + + +class FileStateCache(object): + """ + Stores the modified time of the various doxygen xml files against the + reStructuredText file that they are referenced from so that we know which + reStructuredText files to rebuild if the doxygen xml is modified. + + We store the information in the environment object so that it is pickled + down and stored between builds as Sphinx is designed to do. + """ + + def __init__(self, mtimer, app): + + self.app = app + self.mtimer = mtimer + + def update(self, source_file): + + if not hasattr(self.app.env, "breathe_file_state"): + self.app.env.breathe_file_state = {} + + new_mtime = self.mtimer.get_mtime(source_file) + + mtime, docnames = self.app.env.breathe_file_state.setdefault( + source_file, (new_mtime, set()) + ) + + docnames.add(self.app.env.docname) + + self.app.env.breathe_file_state[source_file] = (new_mtime, docnames) + + def get_outdated(self, app, env, added, changed, removed): + + if not hasattr(self.app.env, "breathe_file_state"): + return [] + + stale = [] + + for filename, info in self.app.env.breathe_file_state.iteritems(): + old_mtime, docnames = info + if self.mtimer.get_mtime(filename) > old_mtime: + stale.extend(docnames) + + return list(set(stale).difference(removed)) + + def purge_doc(self, app, env, docname): + + if not hasattr(self.app.env, "breathe_file_state"): + return + + toremove = [] + + for filename, info in self.app.env.breathe_file_state.iteritems(): + + _, docnames = info + docnames.discard(docname) + if not docnames: + toremove.append(filename) + + for filename in toremove: + del self.app.env.breathe_file_state[filename] + + +class DomainDirectiveFactory(object): + # A mapping from node kinds to cpp domain classes and directive names. + cpp_classes = { + 'class': (cpp.CPPClassObject, 'class'), + 'struct': (cpp.CPPClassObject, 'class'), + 'function': (cpp.CPPFunctionObject, 'function'), + 'friend': (cpp.CPPFunctionObject, 'function'), + 'slot': (cpp.CPPFunctionObject, 'function'), + 'enum': (cpp.CPPTypeObject, 'type'), + 'typedef': (cpp.CPPTypeObject, 'type'), + 'union': (cpp.CPPTypeObject, 'type'), + 'namespace': (cpp.CPPTypeObject, 'type'), + # Use CPPClassObject for enum values as the cpp domain doesn't have a directive for + # enum values and CPPMemberObject requires a type. + 'enumvalue': (cpp.CPPClassObject, 'member'), + 'define': (c.CObject, 'macro') + } + + python_classes = { + 'function': (python.PyModulelevel, 'function'), + 'variable': (python.PyClassmember, 'attribute') + } + + @staticmethod + def fix_python_signature(sig): + def_ = 'def ' + if sig.startswith(def_): + sig = sig[len(def_):] + # Doxygen uses an invalid separator ('::') in Python signatures. Replace them with '.'. + return sig.replace('::', '.') + + @staticmethod + def create(domain, args): + if domain == 'c': + return c.CObject(*args) + if domain == 'py': + cls, name = DomainDirectiveFactory.python_classes.get( + args[0], (python.PyClasslike, 'class')) + args[1] = [DomainDirectiveFactory.fix_python_signature(n) for n in args[1]] + else: + cls, name = DomainDirectiveFactory.cpp_classes.get( + args[0], (cpp.CPPMemberObject, 'member')) + # Replace the directive name because domain directives don't know how to handle + # Breathe's "doxygen" directives. + args = [name] + args[1:] + return cls(*args) + + +# Setup +# ----- + +def setup(app): + + cache_factory = CacheFactory() + cache = cache_factory.create_cache() + path_handler = PathHandler(app.confdir, os.sep, os.path.basename, os.path.join) + mtimer = MTimer(os.path.getmtime) + file_state_cache = FileStateCache(mtimer, app) + parser_factory = DoxygenParserFactory(cache, path_handler, file_state_cache) + glob_factory = GlobFactory(fnmatch.fnmatch) + filter_factory = FilterFactory(glob_factory, path_handler) + item_finder_factory_creator = DoxygenItemFinderFactoryCreator(parser_factory, filter_factory) + index_parser = parser_factory.create_index_parser() + finder_factory = FinderFactory(index_parser, item_finder_factory_creator) + + # Create a math_nodes object with a displaymath member for the displaymath + # node so that we can treat it in the same way as the nodes & addnodes + # modules in the NodeFactory + math_nodes = collections.namedtuple("MathNodes", ["displaymath"]) + math_nodes.displaymath = sphinx.ext.mathbase.displaymath + node_factory = NodeFactory(docutils.nodes, sphinx.addnodes, math_nodes) + + rst_content_creator = RstContentCreator(ViewList, textwrap.dedent) + renderer_factory_creator_constructor = DoxygenToRstRendererFactoryCreatorConstructor( + node_factory, + parser_factory, + DomainDirectiveFactory, + rst_content_creator + ) + + # Assume general build directory is the doctree directory without the last component. We strip + # off any trailing slashes so that dirname correctly drops the last part. This can be overriden + # with the breathe_build_directory config variable + build_dir = os.path.dirname(app.doctreedir.rstrip(os.sep)) + project_info_factory = ProjectInfoFactory(app.srcdir, build_dir, app.confdir, fnmatch.fnmatch) + target_handler_factory = TargetHandlerFactory(node_factory) + + root_data_object = RootDataObject() + + text_renderer = TextRenderer(app) + + directive_factory = DoxygenDirectiveFactory( + node_factory, + text_renderer, + root_data_object, + renderer_factory_creator_constructor, + finder_factory, + project_info_factory, + filter_factory, + target_handler_factory, + parser_factory + ) + + DoxygenFunctionDirective.app = app + + app.add_directive( + "doxygenindex", + directive_factory.create_index_directive_container(), + ) + + app.add_directive( + "doxygenfunction", + directive_factory.create_function_directive_container(), + ) + + app.add_directive( + "doxygenstruct", + directive_factory.create_struct_directive_container(), + ) + + app.add_directive( + "doxygenenum", + directive_factory.create_enum_directive_container(), + ) + + app.add_directive( + "doxygenenumvalue", + directive_factory.create_enumvalue_directive_container(), + ) + + app.add_directive( + "doxygentypedef", + directive_factory.create_typedef_directive_container(), + ) + + app.add_directive( + "doxygenunion", + directive_factory.create_union_directive_container(), + ) + + app.add_directive( + "doxygenclass", + directive_factory.create_class_directive_container(), + ) + + app.add_directive( + "doxygenfile", + directive_factory.create_file_directive_container(), + ) + + app.add_directive( + "doxygennamespace", + directive_factory.create_namespace_directive_container(), + ) + + app.add_directive( + "doxygengroup", + directive_factory.create_group_directive_container(), + ) + + app.add_directive( + "doxygenvariable", + directive_factory.create_variable_directive_container(), + ) + + app.add_directive( + "doxygendefine", + directive_factory.create_define_directive_container(), + ) + + app.add_directive( + "autodoxygenindex", + directive_factory.create_auto_index_directive_container(), + ) + + app.add_directive( + "autodoxygenfile", + directive_factory.create_auto_file_directive_container(), + ) + + app.add_config_value("breathe_projects", {}, True) + app.add_config_value("breathe_default_project", "", True) + # Provide reasonable defaults for domain_by_extension mapping. Can be overridden by users. + app.add_config_value("breathe_domain_by_extension", {'py': 'py'}, True) + app.add_config_value("breathe_domain_by_file_pattern", {}, True) + app.add_config_value("breathe_projects_source", {}, True) + app.add_config_value("breathe_build_directory", '', True) + app.add_config_value("breathe_default_members", (), True) + app.add_config_value("breathe_implementation_filename_extensions", ['.c', '.cc', '.cpp'], True) + + breathe_css = "breathe.css" + if (os.path.exists(os.path.join(app.confdir, "_static", breathe_css))): + app.add_stylesheet(breathe_css) + + doxygen_handle = AutoDoxygenProcessHandle( + path_handler, + subprocess.check_call, + write_file, + project_info_factory + ) + + app.connect("builder-inited", doxygen_handle.generate_xml) + + app.connect("builder-inited", directive_factory.get_config_values) + + app.connect("builder-inited", filter_factory.get_config_values) + + app.connect("env-get-outdated", file_state_cache.get_outdated) + + app.connect("env-purge-doc", file_state_cache.purge_doc) diff --git a/doc/breathe/directives.pyc b/doc/breathe/directives.pyc new file mode 100644 index 0000000000000000000000000000000000000000..562ebf4d712ecef09598dd46517c8129e7938dee GIT binary patch literal 35541 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 literal 0 HcmV?d00001 diff --git a/doc/breathe/finder/__init__.py b/doc/breathe/finder/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/doc/breathe/finder/__init__.pyc b/doc/breathe/finder/__init__.pyc new file mode 100644 index 0000000000000000000000000000000000000000..af53154b0da2ccd8f2a922dcc6ee1dfbd83f2a83 GIT binary patch literal 191 zcmZSn%*&OrA|N!G0SXv_v;z`aYRSMTtd~`ff#u zxvAy(McKvr0hJ{g`FVP2FcJN*)S}|d{Jdg)BRzBdoXjNs0TZlX-=vg$VtUO%m4tpCNT>D literal 0 HcmV?d00001 diff --git a/doc/breathe/finder/core.py b/doc/breathe/finder/core.py new file mode 100644 index 0000000..a519a11 --- /dev/null +++ b/doc/breathe/finder/core.py @@ -0,0 +1,45 @@ + +class FakeParentNode(object): + + node_type = "fakeparent" + + +class Finder(object): + + def __init__(self, root, item_finder_factory): + + self._root = root + self.item_finder_factory = item_finder_factory + + def filter_(self, filter_, matches): + """Adds all nodes which match the filter into the matches list""" + + item_finder = self.item_finder_factory.create_finder(self._root) + item_finder.filter_([FakeParentNode()], filter_, matches) + + def root(self): + + return self._root + + +class FinderFactory(object): + + def __init__(self, parser, item_finder_factory_creator): + + self.parser = parser + self.item_finder_factory_creator = item_finder_factory_creator + + def create_finder(self, project_info): + + root = self.parser.parse(project_info) + item_finder_factory = self.item_finder_factory_creator.create_factory(project_info) + + return Finder(root, item_finder_factory) + + def create_finder_from_root(self, root, project_info): + + item_finder_factory = self.item_finder_factory_creator.create_factory(project_info) + + return Finder(root, item_finder_factory) + + diff --git a/doc/breathe/finder/core.pyc b/doc/breathe/finder/core.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d9ce31b6c27db9560c680003de5e1615e2494589 GIT binary patch literal 2655 zcmc&$O>fgc5MA3%N($v8&?3ZvNIj4XwdjQd2th05grdq7Nc3Vk_L?|N?8v*Qid0VF z$MFC71H3nmB5eS{4lLo{7tYy+wrkt?8HmZ>ksm;}jvP=U_zLrLVCWLi^DV-`&|?Y? z?t6k^_93nubp=E)ab+SHR`?D3w6raVuq+B|A7X|GW?|)Vm`1TJ%0&h27L-O$Q_Bg> z1Lki70IpJ;<(Umbrqs|Q<#rrFfDaskz!4@0e}b>zFmct=QQtgu<*A9M5X(}jFHqqN zm8TrQdnUM;*Le4Rl9*mJo%UEZrgu5c;&E>lSx98Imu6F|%U+h-LY_qfyJ=?ZuuotG zB)f}Q%xcgpXagqQ62NMUP^zL&zXMiqaHrO1p$f=nXu1vG3Nl-bQu11p9Q8kR@f?X)^= zshx@*230%8(8-6;9%GmTi2uzJ^awm_bZMVrdaV>|nh2%Bi&E&Ks^a^w3?4u0wCGDYxr%-8GS}k$MJ$2C14wEkFTt z{)P)*5g-CyCx3)qMao9pRJisr4zJTAw{Do0#Y`^1=TNPxrTcG+AXdR1L{rc=OcD2R s_!IiMriksKl$QLDC`K$Qxl9E4faaU>RW9l`)xWQ|>^;GDzqQ}}1+dj-p#T5? literal 0 HcmV?d00001 diff --git a/doc/breathe/finder/doxygen/__init__.py b/doc/breathe/finder/doxygen/__init__.py new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/doc/breathe/finder/doxygen/__init__.py @@ -0,0 +1 @@ + diff --git a/doc/breathe/finder/doxygen/__init__.pyc b/doc/breathe/finder/doxygen/__init__.pyc new file mode 100644 index 0000000000000000000000000000000000000000..85d7ec67e81ca609e02bb7d11168feb4d4b583c6 GIT binary patch literal 199 zcmZ9GK?=e^3`IwDA%gel#s=KD5pm^8q#(K-rk%7M+Rl_@M0+Fe=LJkfHwOL>dE}E! zU&}@P%r1rc)AXb(8y-W29<+AeMXgiG&E@E}3-;FHZhVbJ F>J5G^G(Z3V literal 0 HcmV?d00001 diff --git a/doc/breathe/finder/doxygen/base.py b/doc/breathe/finder/doxygen/base.py new file mode 100644 index 0000000..0bccb75 --- /dev/null +++ b/doc/breathe/finder/doxygen/base.py @@ -0,0 +1,18 @@ + +class ItemFinder(object): + + def __init__(self, project_info, data_object, item_finder_factory): + + self.data_object = data_object + self.item_finder_factory = item_finder_factory + self.project_info = project_info + + +def stack(element, list_): + """Stack an element on to the start of a list and return as a new list""" + + # Copy list first so we have a new list to insert into + output = list_[:] + output.insert(0, element) + return output + diff --git a/doc/breathe/finder/doxygen/base.pyc b/doc/breathe/finder/doxygen/base.pyc new file mode 100644 index 0000000000000000000000000000000000000000..39f32a8e84d26f210da3331df5f345db00cfc823 GIT binary patch literal 1124 zcmc&yQEL-H5T3i#)>H+h;ESLKzU0L$_~MI5u}~01$^`}cvh3aMHP>8r!|sF{h)?a0 z@&EY;{AMqje^5i_yPdh2+3&uY(eEe6^IsQVYuf!rc%H)IYd}L}iQ0^sjP8hTiN0UL z$;G+MsTt91a)3NO27F?>Jnvj%!@p)3!XIJr833K6n0CeGY$C5~sTa#(XR!DRu+3>p zq;VLfLq=Qt5y7Q|OQrJ5WCY|#fX1-VzPh$G^9lS8RCJrT=+@Ni!-gLtz6xG)bmv+> z5SN>y?b}j%mD08pA`{pEvByb$?y6wIMx6({#nW?@-9(<7}J_ zUpyo@Fwr_Gul3S5>mF|T0I7TO>2&X3P$s^BC{iBgwLC;$u`^hF0l+|C{=}Gby2b$0 zbZ>LY;Lj#f5G8ZQ5Unt-u)SSc$AxzV`vU3}kxhW#7N+RC$Vh66V0j%}VIqRg-lP{D z+E7{;79l$qZQw!3Blx?| aq;@IWy{G$s=AJh9{jiE3(g+2fkN*H!7#Mm0 literal 0 HcmV?d00001 diff --git a/doc/breathe/finder/doxygen/compound.py b/doc/breathe/finder/doxygen/compound.py new file mode 100644 index 0000000..459190c --- /dev/null +++ b/doc/breathe/finder/doxygen/compound.py @@ -0,0 +1,75 @@ + +from .base import ItemFinder, stack + + +class DoxygenTypeSubItemFinder(ItemFinder): + + def filter_(self, ancestors, filter_, matches): + """Find nodes which match the filter. Doesn't test this node, only its children""" + + node_stack = stack(self.data_object, ancestors) + + compound_finder = self.item_finder_factory.create_finder(self.data_object.compounddef) + compound_finder.filter_(node_stack, filter_, matches) + + +class CompoundDefTypeSubItemFinder(ItemFinder): + + def filter_(self, ancestors, filter_, matches): + """Finds nodes which match the filter and continues checks to children""" + + node_stack = stack(self.data_object, ancestors) + + if filter_.allow(node_stack): + matches.append(node_stack) + + for sectiondef in self.data_object.sectiondef: + finder = self.item_finder_factory.create_finder(sectiondef) + finder.filter_(node_stack, filter_, matches) + + for innerclass in self.data_object.innerclass: + finder = self.item_finder_factory.create_finder(innerclass) + finder.filter_(node_stack, filter_, matches) + + +class SectionDefTypeSubItemFinder(ItemFinder): + + def filter_(self, ancestors, filter_, matches): + """Find nodes which match the filter. Doesn't test this node, only its children""" + + node_stack = stack(self.data_object, ancestors) + + if filter_.allow(node_stack): + matches.append(node_stack) + + for memberdef in self.data_object.memberdef: + finder = self.item_finder_factory.create_finder(memberdef) + finder.filter_(node_stack, filter_, matches) + + +class MemberDefTypeSubItemFinder(ItemFinder): + + def filter_(self, ancestors, filter_, matches): + + data_object = self.data_object + node_stack = stack(data_object, ancestors) + + if filter_.allow(node_stack): + matches.append(node_stack) + + if data_object.kind == 'enum': + for value in data_object.enumvalue: + value_stack = stack(value, node_stack) + if filter_.allow(value_stack): + matches.append(value_stack) + + +class RefTypeSubItemFinder(ItemFinder): + + def filter_(self, ancestors, filter_, matches): + + node_stack = stack(self.data_object, ancestors) + + if filter_.allow(node_stack): + matches.append(node_stack) + diff --git a/doc/breathe/finder/doxygen/compound.pyc b/doc/breathe/finder/doxygen/compound.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3adaad45213569735b44711ae3680142974ad2bc GIT binary patch literal 3909 zcmd5SiNp%W51!L^)(bX3(AuA&mM9D8$d;@GKo zLmSllR6Zc_fxp2QejR^+XU0iVV56Ab%-V|zVG5PUqD!*bE2U`=MG)C^s+8f zmxi^uepsgqhh8@5yg@@q7`Sv^ql+4L%|RX>C8*4@uESJ#)Z!IyBw+Fxa}rH9NI9*dqW*ryN!8* zoeKK0RY5wSA#>P<_l;^> z?tQ1rxVLK%L69MeAdozQV4TO(6jNDL1-`=Q8AF129yDG1Hg3D~gWJ>n|Bid!1^xoT z{qGoDf_s1-$QHO4A2Y<612T0oqO(scLhOD2fiMEZ0V$eH4dw_2O&YfT%8`@DbX2Wf zBUuZZ<=WOito@OWDvojN%(0R*SCPyM!NMrdY?4jE#Au+Sk@0N)3bh#QLMooW<|rnLV#AUf%!ee)bP=VYF$c}&;B z6Hau=lM_t-SDsW@zy9~h8j`6%uXqy`zbvKnkM+2xi@yWCD^QlDmm#~uPF{zou(3Kg zzlS)?Er?g)d}D$92I72|Bc22KO^m;mQ@9o!^N}t4oL@2FdQ05iShPCmVajd?{Y+W) zrGOWY7FA!ST=ij!1_-zuxm5f@XHP`aKox(;^`4!Tl#%!;r~-CTLKjL3uG!X z3*;=6fOM#IBxfDak(jQOffOBiEpj9B=UGpRZo}=ZxjRzqG~E80+m~V>qv0+-H3Q^;!)+^dpx26u^j_K}O+s zp$1eU5=k-|hS<)jGZ%?tEPDWO9musv3M5oS9~h}fr+UrZ$EihDTT`cHmblWkM<;HN^73!oU*$G8xxdy^K%lY-awd>K8VCzH}GW{IF~|@gJtP zlWK0`?+(9@r;~BK&=aKW#F=jwS^gqBH#Q#AL>DG5)hcmOy~Epi)tei22*VEK771DH86<1S`3C||H)oP&F#zQ7y zU{D$jm0mdLx=%no^MTd6>BJ{Ojy?U^L>}(oOFo2bLi=gPX_O@IgY-N~vnA8fY)pgy zW?7SIT5!I=w$C!85)$np3Dg~}K{st)Y4xB|ZU8W^3X?k2Kd&NR^vS`@Dl(U))tCv= z2G7Rh#xZzT`R{$i3T`Q?gc|<|%V@&F>7)HaV6DJga@jtFpdf9ue+laUqFozOwbAC| ziz`i6PNwcwxAC#BvBJ1(t+{dct4kj@hFo_TipJWfv0nk1^u=k1L2o`nb7A;5{pAK7 zI|LW3u3+Lgay_O<(eW52i>}8oP4qlA;IyIVcBSac(W_9`sz(RB>X3wc(;aIiC zL?;hs>def>rq)8d+AB<{y{c&{q*-SyQVZRfB;WHFNm0GpltcEYqz~|Rtz6A3ZOPQq z>gNJ_%Y6*+s|xYXQ5`uNF;-pka~yBF<}*{idxr@(@}l0k&k4zY@6K(eL2}2t33KGF zQcH_yz1?ECdHeWjV>Oa}4Y4eBkT42%g9EJQcQ3lL0DXnCtqzK9K5ssP5Rb6d1?W^` y7D)grD_~q{)FzLBAtyw9wfFHv?<9O>+p6e%^Mjvgp0Ms)O1>ZLM+f&0?)?iZC<9Ue literal 0 HcmV?d00001 diff --git a/doc/breathe/finder/doxygen/index.py b/doc/breathe/finder/doxygen/index.py new file mode 100644 index 0000000..f839953 --- /dev/null +++ b/doc/breathe/finder/doxygen/index.py @@ -0,0 +1,79 @@ + +from .base import ItemFinder, stack + + +class DoxygenTypeSubItemFinder(ItemFinder): + + def filter_(self, ancestors, filter_, matches): + """Find nodes which match the filter. Doesn't test this node, only its children""" + + compounds = self.data_object.get_compound() + + node_stack = stack(self.data_object, ancestors) + + for compound in compounds: + + compound_finder = self.item_finder_factory.create_finder(compound) + compound_finder.filter_(node_stack, filter_, matches) + + +class CompoundTypeSubItemFinder(ItemFinder): + + def __init__(self, filter_factory, compound_parser, *args): + ItemFinder.__init__(self, *args) + + self.filter_factory = filter_factory + self.compound_parser = compound_parser + + def filter_(self, ancestors, filter_, matches): + """Finds nodes which match the filter and continues checks to children + + Requires parsing the xml files referenced by the children for which we use the compound + parser and continue at the top level of that pretending that this node is the parent of the + top level node of the compound file. + """ + + node_stack = stack(self.data_object, ancestors) + + # Match against compound object + if filter_.allow(node_stack): + matches.append(node_stack) + + # Descend to member children + members = self.data_object.get_member() + member_matches = [] + for member in members: + member_finder = self.item_finder_factory.create_finder(member) + member_finder.filter_(node_stack, filter_, member_matches) + + results = [] + + # If there are members in this compound that match the criteria + # then load up the file for this compound and get the member data objects + if member_matches: + + file_data = self.compound_parser.parse(self.data_object.refid) + finder = self.item_finder_factory.create_finder(file_data) + + for member_stack in member_matches: + ref_filter = self.filter_factory.create_id_filter('memberdef', member_stack[0].refid) + finder.filter_(node_stack, ref_filter, matches) + + else: + + # Read in the xml file referenced by the compound and descend into that as well + file_data = self.compound_parser.parse(self.data_object.refid) + finder = self.item_finder_factory.create_finder(file_data) + + finder.filter_(node_stack, filter_, matches) + + +class MemberTypeSubItemFinder(ItemFinder): + + def filter_(self, ancestors, filter_, matches): + + node_stack = stack(self.data_object, ancestors) + + # Match against member object + if filter_.allow(node_stack): + matches.append(node_stack) diff --git a/doc/breathe/finder/doxygen/index.pyc b/doc/breathe/finder/doxygen/index.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b1b87a24f844e93836910553002d0beed0299d73 GIT binary patch literal 3370 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 literal 0 HcmV?d00001 diff --git a/doc/breathe/parser/doxygen/__init__.py b/doc/breathe/parser/doxygen/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/doc/breathe/parser/doxygen/__init__.pyc b/doc/breathe/parser/doxygen/__init__.pyc new file mode 100644 index 0000000000000000000000000000000000000000..555c9d56fe9a74409242b4bbeae32016904c8e64 GIT binary patch literal 199 zcmZ9GK?=e^3`IwDA%gel#s=KD5$Vd6NI`TvOxxHFZD)pLM0+Fe=LJkfHwOL>dE}E! zU&}@F%+ICz)iT#jygU)?&~jjypt Fy#aynG*tiq literal 0 HcmV?d00001 diff --git a/doc/breathe/parser/doxygen/compound.py b/doc/breathe/parser/doxygen/compound.py new file mode 100644 index 0000000..c177ec1 --- /dev/null +++ b/doc/breathe/parser/doxygen/compound.py @@ -0,0 +1,964 @@ +#!/usr/bin/env python + +""" +Generated Mon Feb 9 19:08:05 2009 by generateDS.py. +""" + +from xml.dom import minidom +from xml.dom import Node +from xml.parsers.expat import ExpatError + +from . import compoundsuper as supermod +from .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): + + 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.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, 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) + + 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 child and put it in self.name + if child_.nodeType == Node.ELEMENT_NODE and nodeName_ == 'name': + value_ = [] + for text_ in child_.childNodes: + value_.append(text_.nodeValue) + valuestr_ = ''.join(value_) + 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): + supermod.graphType.__init__(self, node) +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): + supermod.listingType.__init__(self, codeline) +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 is not "": + 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) +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, para=None): + supermod.docEntryType.__init__(self, thead, 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 = "docdocfile" + + def __init__(self, name=None, valueOf_='', mixedclass_=None, content_=None): + supermod.docDotFileType.__init__(self, mixedclass_, content_) +supermod.docDotFileType.subclass = docDotFileTypeSub +# end class docDotFileTypeSub + + +class docTocItemTypeSub(supermod.docTocItemType): + + 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 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(object): + """ + 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 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 = [] + + 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_) + self.programlisting.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_) + +supermod.docParaType.subclass = docParaTypeSub +# end class docParaTypeSub + + +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 + +supermod.docTitleType.subclass = docTitleTypeSub +# end class docTitleTypeSub + + +class ParseError(Exception): + pass + + +class FileIOError(Exception): + pass + + +def parse(inFilename): + + try: + doc = minidom.parse(inFilename) + except IOError as e: + raise FileIOError(e) + except ExpatError as e: + raise ParseError(e) + + rootNode = doc.documentElement + rootObj = supermod.DoxygenType.factory() + rootObj.build(rootNode) + return rootObj + + diff --git a/doc/breathe/parser/doxygen/compound.pyc b/doc/breathe/parser/doxygen/compound.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bff7aaefb769a4adc3f1cad024bf70fa12ab5f36 GIT binary patch literal 47683 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 D*46dJ literal 0 HcmV?d00001 diff --git a/doc/breathe/parser/doxygen/compoundsuper.py b/doc/breathe/parser/doxygen/compoundsuper.py new file mode 100644 index 0000000..418a85d --- /dev/null +++ b/doc/breathe/parser/doxygen/compoundsuper.py @@ -0,0 +1,5798 @@ +#!/usr/bin/env python + +# +# Generated Thu Jun 11 18:44:25 2009 by generateDS.py. +# + +import sys +import getopt +from xml.dom import minidom +from xml.dom import Node + +# +# User methods +# +# Calls to the methods in these classes are generated by generateDS.py. +# You can replace these methods by re-implementing the following class +# in a module named generatedssuper.py. + +try: + from generatedssuper import GeneratedsSuper +except ImportError as exp: + + class GeneratedsSuper: + 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 + + +# +# If you have installed IPython you can uncomment and use the following. +# IPython is available from http://ipython.scipy.org/. +# + +## from IPython.Shell import IPShellEmbed +## args = '' +## ipshell = IPShellEmbed(args, +## banner = 'Dropping into IPython', +## exit_msg = 'Leaving Interpreter, back to program.') + +# Then use the following line where and when you want to drop into the +# IPython shell: +# ipshell(' -- Entering ipshell.\nHit Ctrl-D to exit') + +# +# Globals +# + +ExternalEncoding = 'ascii' + +# +# Support/utility functions. +# + +def showIndent(outfile, level): + for idx in range(level): + outfile.write(' ') + +def quote_xml(inStr): + s1 = (isinstance(inStr, basestring) and inStr or + '%s' % inStr) + s1 = s1.replace('&', '&') + s1 = s1.replace('<', '<') + s1 = s1.replace('>', '>') + return s1 + +def quote_attrib(inStr): + s1 = (isinstance(inStr, basestring) and inStr or + '%s' % inStr) + s1 = s1.replace('&', '&') + s1 = s1.replace('<', '<') + s1 = s1.replace('>', '>') + if '"' in s1: + if "'" in s1: + s1 = '"%s"' % s1.replace('"', """) + else: + s1 = "'%s'" % s1 + else: + s1 = '"%s"' % s1 + return s1 + +def quote_python(inStr): + s1 = inStr + if s1.find("'") == -1: + if s1.find('\n') == -1: + return "'%s'" % s1 + else: + return "'''%s'''" % s1 + else: + if s1.find('"') != -1: + s1 = s1.replace('"', '\\"') + if s1.find('\n') == -1: + return '"%s"' % s1 + else: + return '"""%s"""' % s1 + + +class MixedContainer: + + node_type = "mixedcontainer" + + # Constants for category: + CategoryNone = 0 + CategoryText = 1 + CategorySimple = 2 + CategoryComplex = 3 + # Constants for content_type: + TypeNone = 0 + TypeText = 1 + TypeString = 2 + TypeInteger = 3 + TypeFloat = 4 + 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 + + +class _MemberSpec(object): + def __init__(self, name='', data_type='', container=0): + 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 + def get_data_type(self): return self.data_type + def set_container(self, container): self.container = container + def get_container(self): return self.container + + +# +# Data representation classes. +# + +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_) + else: + return DoxygenType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_compounddef(self): return self.compounddef + def set_compounddef(self, compounddef): self.compounddef = compounddef + def get_version(self): return self.version + def set_version(self, version): self.version = version + def hasContent_(self): + if ( + self.compounddef is not None + ): + return True + else: + return False + 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': + obj_ = compounddefType.factory() + obj_.build(child_) + self.set_compounddef(obj_) +# end class DoxygenType + + +class compounddefType(GeneratedsSuper): + subclass = None + superclass = None + def __init__(self, kind=None, prot=None, id=None, compoundname=None, title=None, basecompoundref=None, derivedcompoundref=None, includes=None, includedby=None, incdepgraph=None, invincdepgraph=None, innerdir=None, innerfile=None, innerclass=None, innernamespace=None, innerpage=None, innergroup=None, templateparamlist=None, sectiondef=None, briefdescription=None, detaileddescription=None, inheritancegraph=None, collaborationgraph=None, programlisting=None, location=None, listofallmembers=None): + self.kind = kind + self.prot = prot + self.id = id + self.compoundname = compoundname + self.title = title + if basecompoundref is None: + self.basecompoundref = [] + else: + self.basecompoundref = basecompoundref + if derivedcompoundref is None: + self.derivedcompoundref = [] + else: + self.derivedcompoundref = derivedcompoundref + if includes is None: + self.includes = [] + else: + self.includes = includes + if includedby is None: + self.includedby = [] + else: + self.includedby = includedby + self.incdepgraph = incdepgraph + self.invincdepgraph = invincdepgraph + if innerdir is None: + self.innerdir = [] + else: + self.innerdir = innerdir + if innerfile is None: + self.innerfile = [] + else: + self.innerfile = innerfile + if innerclass is None: + self.innerclass = [] + else: + self.innerclass = innerclass + if innernamespace is None: + self.innernamespace = [] + else: + self.innernamespace = innernamespace + if innerpage is None: + self.innerpage = [] + else: + self.innerpage = innerpage + if innergroup is None: + self.innergroup = [] + else: + self.innergroup = innergroup + self.templateparamlist = templateparamlist + if sectiondef is None: + self.sectiondef = [] + else: + self.sectiondef = sectiondef + self.briefdescription = briefdescription + self.detaileddescription = detaileddescription + self.inheritancegraph = inheritancegraph + self.collaborationgraph = collaborationgraph + self.programlisting = programlisting + self.location = location + self.listofallmembers = listofallmembers + self.namespaces = [] + def factory(*args_, **kwargs_): + if compounddefType.subclass: + return compounddefType.subclass(*args_, **kwargs_) + else: + return compounddefType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_compoundname(self): return self.compoundname + def set_compoundname(self, compoundname): self.compoundname = compoundname + 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 add_basecompoundref(self, value): self.basecompoundref.append(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 get_includes(self): return self.includes + def set_includes(self, includes): self.includes = includes + def add_includes(self, value): self.includes.append(value) + def insert_includes(self, index, value): self.includes[index] = value + def get_includedby(self): return self.includedby + def set_includedby(self, includedby): self.includedby = includedby + def add_includedby(self, value): self.includedby.append(value) + def insert_includedby(self, index, value): self.includedby[index] = value + 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 get_innerdir(self): return self.innerdir + def set_innerdir(self, innerdir): self.innerdir = innerdir + def add_innerdir(self, value): self.innerdir.append(value) + def insert_innerdir(self, index, value): self.innerdir[index] = value + def get_innerfile(self): return self.innerfile + def set_innerfile(self, innerfile): self.innerfile = innerfile + def add_innerfile(self, value): self.innerfile.append(value) + def insert_innerfile(self, index, value): self.innerfile[index] = value + def get_innerclass(self): return self.innerclass + def set_innerclass(self, innerclass): self.innerclass = innerclass + 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 add_innernamespace(self, value): self.innernamespace.append(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) + def insert_innerpage(self, index, value): self.innerpage[index] = value + def get_innergroup(self): return self.innergroup + def set_innergroup(self, innergroup): self.innergroup = innergroup + 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 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 get_detaileddescription(self): return self.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 get_collaborationgraph(self): return self.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 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 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 hasContent_(self): + if ( + self.compoundname is not None or + self.title is not None or + self.basecompoundref is not None or + self.derivedcompoundref is not None or + self.includes is not None or + self.includedby is not None or + self.incdepgraph is not None or + self.invincdepgraph is not None or + self.innerdir is not None or + self.innerfile is not None or + self.innerclass is not None or + self.innernamespace is not None or + self.innerpage is not None or + self.innergroup is not None or + self.templateparamlist is not None or + self.sectiondef is not None or + self.briefdescription is not None or + self.detaileddescription is not None or + self.inheritancegraph is not None or + self.collaborationgraph is not None or + self.programlisting is not None or + self.location is not None or + self.listofallmembers is not None + ): + return True + else: + return False + def 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('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_ == 'compoundname': + compoundname_ = '' + for text__content_ in child_.childNodes: + compoundname_ += text__content_.nodeValue + self.compoundname = compoundname_ + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'title': + obj_ = docTitleType.factory() + obj_.build(child_) + self.set_title(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'basecompoundref': + obj_ = compoundRefType.factory() + obj_.build(child_) + self.basecompoundref.append(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'derivedcompoundref': + obj_ = compoundRefType.factory() + obj_.build(child_) + self.derivedcompoundref.append(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'includes': + obj_ = incType.factory() + obj_.build(child_) + self.includes.append(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'includedby': + obj_ = incType.factory() + obj_.build(child_) + self.includedby.append(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'incdepgraph': + obj_ = graphType.factory() + obj_.build(child_) + self.set_incdepgraph(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'invincdepgraph': + obj_ = graphType.factory() + obj_.build(child_) + self.set_invincdepgraph(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'innerdir': + obj_ = refType.factory(nodeName_) + obj_.build(child_) + self.innerdir.append(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'innerfile': + obj_ = refType.factory(nodeName_) + obj_.build(child_) + self.innerfile.append(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'innerclass': + obj_ = refType.factory(nodeName_) + obj_.build(child_) + self.innerclass.append(obj_) + self.namespaces.append(obj_.content_[0].getValue()) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'innernamespace': + obj_ = refType.factory(nodeName_) + obj_.build(child_) + self.innernamespace.append(obj_) + self.namespaces.append(obj_.content_[0].getValue()) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'innerpage': + obj_ = refType.factory(nodeName_) + obj_.build(child_) + self.innerpage.append(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'innergroup': + obj_ = refType.factory(nodeName_) + obj_.build(child_) + self.innergroup.append(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'templateparamlist': + obj_ = templateparamlistType.factory() + obj_.build(child_) + self.set_templateparamlist(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'sectiondef': + obj_ = sectiondefType.factory() + obj_.build(child_) + self.sectiondef.append(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'briefdescription': + obj_ = descriptionType.factory() + obj_.build(child_) + self.set_briefdescription(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'detaileddescription': + obj_ = descriptionType.factory() + obj_.build(child_) + self.set_detaileddescription(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'inheritancegraph': + obj_ = graphType.factory() + obj_.build(child_) + self.set_inheritancegraph(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'collaborationgraph': + obj_ = graphType.factory() + obj_.build(child_) + self.set_collaborationgraph(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'programlisting': + obj_ = listingType.factory() + obj_.build(child_) + self.set_programlisting(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'location': + obj_ = locationType.factory() + obj_.build(child_) + self.set_location(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'listofallmembers': + obj_ = listofallmembersType.factory() + obj_.build(child_) + self.set_listofallmembers(obj_) +# end class compounddefType + + +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_) + else: + return listofallmembersType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_member(self): return self.member + 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 hasContent_(self): + if ( + self.member is not None + ): + return True + else: + return False + 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': + obj_ = memberRefType.factory() + obj_.build(child_) + self.member.append(obj_) +# end class listofallmembersType + + +class memberRefType(GeneratedsSuper): + subclass = None + superclass = None + def __init__(self, virt=None, prot=None, refid=None, ambiguityscope=None, scope=None, name=None): + self.virt = virt + self.prot = prot + self.refid = refid + self.ambiguityscope = ambiguityscope + self.scope = scope + self.name = name + def factory(*args_, **kwargs_): + if memberRefType.subclass: + return memberRefType.subclass(*args_, **kwargs_) + else: + return memberRefType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_scope(self): return self.scope + def set_scope(self, scope): self.scope = scope + def get_name(self): return self.name + def set_name(self, name): self.name = name + def get_virt(self): return self.virt + def set_virt(self, virt): self.virt = virt + def get_prot(self): return self.prot + def set_prot(self, prot): self.prot = prot + 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 hasContent_(self): + if ( + self.scope is not None or + self.name is not None + ): + return True + else: + return False + 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 + if attrs.get('prot'): + self.prot = attrs.get('prot').value + if attrs.get('refid'): + 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': + scope_ = '' + for text__content_ in child_.childNodes: + scope_ += text__content_.nodeValue + self.scope = scope_ + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'name': + name_ = '' + for text__content_ in child_.childNodes: + name_ += text__content_.nodeValue + self.name = name_ +# end class memberRefType + + +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_) + else: + return scope(*args_, **kwargs_) + factory = staticmethod(factory) + def getValueOf_(self): return self.valueOf_ + def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def hasContent_(self): + if ( + self.valueOf_ is not None + ): + return True + else: + return False + 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 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+']]' +# 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_) + else: + return name(*args_, **kwargs_) + factory = staticmethod(factory) + def getValueOf_(self): return self.valueOf_ + def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def hasContent_(self): + if ( + self.valueOf_ is not None + ): + return True + else: + return False + 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 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+']]' +# end class name + + +class compoundRefType(GeneratedsSuper): + subclass = None + superclass = None + def __init__(self, virt=None, prot=None, refid=None, valueOf_='', mixedclass_=None, content_=None): + self.virt = virt + self.prot = prot + self.refid = refid + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + def factory(*args_, **kwargs_): + if compoundRefType.subclass: + return compoundRefType.subclass(*args_, **kwargs_) + else: + return compoundRefType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_virt(self): return self.virt + def set_virt(self, virt): self.virt = virt + def get_prot(self): return self.prot + def set_prot(self, prot): self.prot = prot + def get_refid(self): return self.refid + def set_refid(self, refid): self.refid = refid + def getValueOf_(self): return self.valueOf_ + def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def hasContent_(self): + if ( + self.valueOf_ is not None + ): + return True + else: + return False + 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 buildAttributes(self, attrs): + if attrs.get('virt'): + self.virt = attrs.get('virt').value + 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) + 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+']]' +# end class compoundRefType + + +class reimplementType(GeneratedsSuper): + subclass = None + superclass = None + def __init__(self, refid=None, valueOf_='', mixedclass_=None, content_=None): + self.refid = refid + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + def factory(*args_, **kwargs_): + if reimplementType.subclass: + return reimplementType.subclass(*args_, **kwargs_) + else: + return reimplementType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_refid(self): return self.refid + def set_refid(self, refid): self.refid = refid + def getValueOf_(self): return self.valueOf_ + def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def hasContent_(self): + if ( + self.valueOf_ is not None + ): + return True + else: + return False + 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 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) + 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+']]' +# 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 + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + def factory(*args_, **kwargs_): + if incType.subclass: + return incType.subclass(*args_, **kwargs_) + else: + return incType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_local(self): return self.local + def set_local(self, local): self.local = local + def get_refid(self): return self.refid + def set_refid(self, refid): self.refid = refid + def getValueOf_(self): return self.valueOf_ + def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def hasContent_(self): + if ( + self.valueOf_ is not None + ): + return True + else: + return False + 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 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) + 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+']]' +# 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 + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + def factory(*args_, **kwargs_): + if refType.subclass: + return refType.subclass(*args_, **kwargs_) + else: + return refType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_prot(self): return self.prot + def set_prot(self, prot): self.prot = prot + def get_refid(self): return self.refid + def set_refid(self, refid): self.refid = refid + def getValueOf_(self): return self.valueOf_ + def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def hasContent_(self): + if ( + self.valueOf_ is not None + ): + return True + else: + return False + 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 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) + 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+']]' +# end class refType + + +class refTextType(GeneratedsSuper): + subclass = None + superclass = None + def __init__(self, refid=None, kindref=None, external=None, valueOf_='', mixedclass_=None, content_=None): + self.refid = refid + self.kindref = kindref + self.external = external + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + def factory(*args_, **kwargs_): + if refTextType.subclass: + return refTextType.subclass(*args_, **kwargs_) + else: + return refTextType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_refid(self): return self.refid + def set_refid(self, refid): self.refid = refid + def get_kindref(self): return self.kindref + def set_kindref(self, kindref): self.kindref = kindref + def get_external(self): return self.external + def set_external(self, external): self.external = external + def getValueOf_(self): return self.valueOf_ + def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def hasContent_(self): + if ( + self.valueOf_ is not None + ): + return True + else: + return False + 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 buildAttributes(self, attrs): + if attrs.get('refid'): + self.refid = attrs.get('refid').value + if attrs.get('kindref'): + 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) + 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+']]' +# end class refTextType + + +class sectiondefType(GeneratedsSuper): + subclass = None + superclass = None + def __init__(self, kind=None, header=None, description=None, memberdef=None): + self.kind = kind + self.header = header + self.description = description + if memberdef is None: + self.memberdef = [] + else: + self.memberdef = memberdef + def factory(*args_, **kwargs_): + if sectiondefType.subclass: + return sectiondefType.subclass(*args_, **kwargs_) + else: + return sectiondefType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_header(self): return self.header + def set_header(self, header): self.header = header + def get_description(self): return self.description + def set_description(self, description): self.description = description + def get_memberdef(self): return self.memberdef + def set_memberdef(self, memberdef): self.memberdef = memberdef + def add_memberdef(self, value): self.memberdef.append(value) + 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 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 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': + header_ = '' + for text__content_ in child_.childNodes: + header_ += text__content_.nodeValue + self.header = header_ + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'description': + obj_ = descriptionType.factory() + obj_.build(child_) + self.set_description(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'memberdef': + obj_ = memberdefType.factory() + obj_.build(child_) + self.memberdef.append(obj_) +# end class sectiondefType + + +class memberdefType(GeneratedsSuper): + subclass = None + superclass = None + def __init__(self, initonly=None, kind=None, volatile=None, const=None, raisexx=None, virt=None, readable=None, prot=None, explicit=None, new=None, final=None, writable=None, add=None, static=None, remove=None, sealed=None, mutable=None, gettable=None, inline=None, settable=None, id=None, templateparamlist=None, type_=None, definition=None, argsstring=None, name=None, read=None, write=None, bitfield=None, reimplements=None, reimplementedby=None, param=None, enumvalue=None, initializer=None, exceptions=None, briefdescription=None, detaileddescription=None, inbodydescription=None, location=None, references=None, referencedby=None): + self.initonly = initonly + self.kind = kind + self.volatile = volatile + self.const = const + self.raisexx = raisexx + self.virt = virt + self.readable = readable + self.prot = prot + self.explicit = explicit + self.new = new + self.final = final + self.writable = writable + self.add = add + self.static = static + self.remove = remove + self.sealed = sealed + self.mutable = mutable + self.gettable = gettable + self.inline = inline + self.settable = settable + self.id = id + self.templateparamlist = templateparamlist + self.type_ = type_ + self.definition = definition + self.argsstring = argsstring + self.name = name + self.read = read + self.write = write + self.bitfield = bitfield + if reimplements is None: + self.reimplements = [] + else: + self.reimplements = reimplements + if reimplementedby is None: + self.reimplementedby = [] + else: + self.reimplementedby = reimplementedby + if param is None: + self.param = [] + else: + self.param = param + if enumvalue is None: + self.enumvalue = [] + else: + self.enumvalue = enumvalue + self.initializer = initializer + self.exceptions = exceptions + self.briefdescription = briefdescription + self.detaileddescription = detaileddescription + self.inbodydescription = inbodydescription + self.location = location + if references is None: + self.references = [] + else: + self.references = references + if referencedby is None: + self.referencedby = [] + else: + self.referencedby = referencedby + def factory(*args_, **kwargs_): + if memberdefType.subclass: + return memberdefType.subclass(*args_, **kwargs_) + else: + return memberdefType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_templateparamlist(self): return self.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 + def set_definition(self, definition): self.definition = definition + def get_argsstring(self): return self.argsstring + def set_argsstring(self, argsstring): self.argsstring = argsstring + def get_name(self): return self.name + def set_name(self, name): self.name = name + def get_read(self): return self.read + def set_read(self, read): self.read = read + def get_write(self): return self.write + def set_write(self, write): self.write = write + def get_bitfield(self): return self.bitfield + def set_bitfield(self, bitfield): self.bitfield = bitfield + 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 get_reimplementedby(self): return self.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 get_param(self): return self.param + 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 get_enumvalue(self): return self.enumvalue + def set_enumvalue(self, enumvalue): self.enumvalue = enumvalue + def add_enumvalue(self, value): self.enumvalue.append(value) + def insert_enumvalue(self, index, value): self.enumvalue[index] = value + def get_initializer(self): return self.initializer + def set_initializer(self, initializer): self.initializer = initializer + 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 get_detaileddescription(self): return self.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 get_location(self): return self.location + def set_location(self, location): self.location = location + def get_references(self): return self.references + def set_references(self, references): self.references = references + def add_references(self, value): self.references.append(value) + def insert_references(self, index, value): self.references[index] = value + 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 get_initonly(self): return self.initonly + def set_initonly(self, initonly): self.initonly = initonly + def get_kind(self): return self.kind + def set_kind(self, kind): self.kind = kind + def get_volatile(self): return self.volatile + def set_volatile(self, volatile): self.volatile = volatile + def get_const(self): return self.const + def set_const(self, const): self.const = const + def get_raise(self): return self.raisexx + def set_raise(self, raisexx): self.raisexx = raisexx + def get_virt(self): return self.virt + def set_virt(self, virt): self.virt = virt + def get_readable(self): return self.readable + def set_readable(self, readable): self.readable = readable + def get_prot(self): return self.prot + def set_prot(self, prot): self.prot = prot + def get_explicit(self): return self.explicit + def set_explicit(self, explicit): self.explicit = explicit + def get_new(self): return self.new + def set_new(self, new): self.new = new + def get_final(self): return self.final + def set_final(self, final): self.final = final + def get_writable(self): return self.writable + def set_writable(self, writable): self.writable = writable + def get_add(self): return self.add + def set_add(self, add): self.add = add + def get_static(self): return self.static + def set_static(self, static): self.static = static + def get_remove(self): return self.remove + def set_remove(self, remove): self.remove = remove + def get_sealed(self): return self.sealed + def set_sealed(self, sealed): self.sealed = sealed + def get_mutable(self): return self.mutable + def set_mutable(self, mutable): self.mutable = mutable + def get_gettable(self): return self.gettable + def set_gettable(self, gettable): self.gettable = gettable + def get_inline(self): return self.inline + def set_inline(self, inline): self.inline = inline + def get_settable(self): return self.settable + def set_settable(self, settable): self.settable = settable + def get_id(self): return self.id + def set_id(self, id): self.id = id + def hasContent_(self): + if ( + self.templateparamlist is not None or + self.type_ is not None or + self.definition is not None or + self.argsstring is not None or + self.name is not None or + self.read is not None or + self.write is not None or + self.bitfield is not None or + self.reimplements is not None or + self.reimplementedby is not None or + self.param is not None or + self.enumvalue is not None or + self.initializer is not None or + self.exceptions is not None or + self.briefdescription is not None or + self.detaileddescription is not None or + self.inbodydescription is not None or + self.location is not None or + self.references is not None or + self.referencedby is not None + ): + return True + else: + return False + def 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 + if attrs.get('kind'): + self.kind = attrs.get('kind').value + if attrs.get('volatile'): + self.volatile = attrs.get('volatile').value + if attrs.get('const'): + self.const = attrs.get('const').value + if attrs.get('raise'): + self.raisexx = attrs.get('raise').value + if attrs.get('virt'): + self.virt = attrs.get('virt').value + if attrs.get('readable'): + self.readable = attrs.get('readable').value + if attrs.get('prot'): + self.prot = attrs.get('prot').value + if attrs.get('explicit'): + self.explicit = attrs.get('explicit').value + if attrs.get('new'): + self.new = attrs.get('new').value + if attrs.get('final'): + self.final = attrs.get('final').value + if attrs.get('writable'): + self.writable = attrs.get('writable').value + if attrs.get('add'): + self.add = attrs.get('add').value + if attrs.get('static'): + self.static = attrs.get('static').value + if attrs.get('remove'): + self.remove = attrs.get('remove').value + if attrs.get('sealed'): + self.sealed = attrs.get('sealed').value + if attrs.get('mutable'): + self.mutable = attrs.get('mutable').value + if attrs.get('gettable'): + self.gettable = attrs.get('gettable').value + if attrs.get('inline'): + self.inline = attrs.get('inline').value + if attrs.get('settable'): + 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': + obj_ = templateparamlistType.factory() + obj_.build(child_) + self.set_templateparamlist(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'type': + obj_ = linkedTextType.factory() + obj_.build(child_) + self.set_type(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + 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': + argsstring_ = '' + for text__content_ in child_.childNodes: + argsstring_ += text__content_.nodeValue + self.argsstring = argsstring_ + elif child_.nodeType == Node.ELEMENT_NODE and \ + 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': + read_ = '' + for text__content_ in child_.childNodes: + read_ += text__content_.nodeValue + self.read = read_ + elif child_.nodeType == Node.ELEMENT_NODE and \ + 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': + bitfield_ = '' + for text__content_ in child_.childNodes: + bitfield_ += text__content_.nodeValue + self.bitfield = bitfield_ + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'reimplements': + obj_ = reimplementType.factory() + obj_.build(child_) + self.reimplements.append(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'reimplementedby': + obj_ = reimplementType.factory() + obj_.build(child_) + self.reimplementedby.append(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'param': + obj_ = paramType.factory() + obj_.build(child_) + self.param.append(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'enumvalue': + obj_ = enumvalueType.factory() + obj_.build(child_) + self.enumvalue.append(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'initializer': + obj_ = linkedTextType.factory() + obj_.build(child_) + self.set_initializer(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'exceptions': + obj_ = linkedTextType.factory() + obj_.build(child_) + self.set_exceptions(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'briefdescription': + obj_ = descriptionType.factory() + obj_.build(child_) + self.set_briefdescription(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'detaileddescription': + obj_ = descriptionType.factory() + obj_.build(child_) + self.set_detaileddescription(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'inbodydescription': + obj_ = descriptionType.factory() + obj_.build(child_) + self.set_inbodydescription(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'location': + obj_ = locationType.factory() + obj_.build(child_) + self.set_location(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'references': + obj_ = referenceType.factory() + obj_.build(child_) + self.references.append(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'referencedby': + obj_ = referenceType.factory() + obj_.build(child_) + self.referencedby.append(obj_) +# end class memberdefType + + +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_) + else: + return definition(*args_, **kwargs_) + factory = staticmethod(factory) + def getValueOf_(self): return self.valueOf_ + def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def hasContent_(self): + if ( + self.valueOf_ is not None + ): + return True + else: + return False + 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 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+']]' +# 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_) + else: + return argsstring(*args_, **kwargs_) + factory = staticmethod(factory) + def getValueOf_(self): return self.valueOf_ + def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def export(self, outfile, level, namespace_='', name_='argsstring', namespacedef_=''): + showIndent(outfile, level) + outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) + self.exportAttributes(outfile, level, namespace_, name_='argsstring') + if self.hasContent_(): + outfile.write('>\n') + self.exportChildren(outfile, level + 1, namespace_, name_) + showIndent(outfile, level) + outfile.write('\n' % (namespace_, name_)) + else: + outfile.write(' />\n') + def hasContent_(self): + if ( + self.valueOf_ is not None + ): + return True + else: + return False + 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 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+']]' +# 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_) + else: + return read(*args_, **kwargs_) + factory = staticmethod(factory) + def getValueOf_(self): return self.valueOf_ + def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def hasContent_(self): + if ( + self.valueOf_ is not None + ): + return True + else: + return False + 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 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+']]' +# 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_) + else: + return write(*args_, **kwargs_) + factory = staticmethod(factory) + def getValueOf_(self): return self.valueOf_ + def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def hasContent_(self): + if ( + self.valueOf_ is not None + ): + return True + else: + return False + 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 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+']]' +# 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_) + else: + return bitfield(*args_, **kwargs_) + factory = staticmethod(factory) + def getValueOf_(self): return self.valueOf_ + def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def hasContent_(self): + if ( + self.valueOf_ is not None + ): + return True + else: + return False + 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 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+']]' +# 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 + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + def factory(*args_, **kwargs_): + if descriptionType.subclass: + return descriptionType.subclass(*args_, **kwargs_) + else: + return descriptionType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_title(self): return self.title + def set_title(self, title): self.title = title + def get_para(self): return self.para + 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 get_sect1(self): return self.sect1 + 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 get_internal(self): return self.internal + def set_internal(self, internal): self.internal = internal + 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 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': + childobj_ = docTitleType.factory() + childobj_.build(child_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'title', childobj_) + self.content_.append(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'para': + childobj_ = docParaType.factory() + childobj_.build(child_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'para', childobj_) + self.content_.append(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'sect1': + childobj_ = docSect1Type.factory() + childobj_.build(child_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sect1', childobj_) + self.content_.append(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'internal': + childobj_ = docInternalType.factory() + childobj_.build(child_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'internal', childobj_) + self.content_.append(obj_) +# end class descriptionType + + +class enumvalueType(GeneratedsSuper): + subclass = None + superclass = None + def __init__(self, prot=None, id=None, name=None, initializer=None, briefdescription=None, detaileddescription=None, mixedclass_=None, content_=None): + self.prot = prot + self.id = id + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + def factory(*args_, **kwargs_): + if enumvalueType.subclass: + return enumvalueType.subclass(*args_, **kwargs_) + else: + return enumvalueType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_name(self): return self.name + def set_name(self, name): self.name = name + 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 get_detaileddescription(self): return self.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 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 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': + value_ = [] + for text_ in child_.childNodes: + value_.append(text_.nodeValue) + valuestr_ = ''.join(value_) + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'name', valuestr_) + self.content_.append(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'initializer': + childobj_ = linkedTextType.factory() + childobj_.build(child_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'initializer', childobj_) + self.content_.append(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'briefdescription': + childobj_ = descriptionType.factory() + childobj_.build(child_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'briefdescription', childobj_) + self.content_.append(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'detaileddescription': + childobj_ = descriptionType.factory() + childobj_.build(child_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'detaileddescription', childobj_) + self.content_.append(obj_) + elif child_.nodeType == Node.TEXT_NODE: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.nodeValue) + self.content_.append(obj_) +# end class enumvalueType + + +class templateparamlistType(GeneratedsSuper): + subclass = None + superclass = None + def __init__(self, param=None): + if param is None: + self.param = [] + else: + self.param = param + def factory(*args_, **kwargs_): + if templateparamlistType.subclass: + return templateparamlistType.subclass(*args_, **kwargs_) + else: + return templateparamlistType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_param(self): return self.param + def set_param(self, param): self.param = param + def add_param(self, value): self.param.append(value) + def insert_param(self, index, value): self.param[index] = value + def hasContent_(self): + if ( + self.param is not None + ): + return True + else: + return False + 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': + obj_ = paramType.factory() + obj_.build(child_) + self.param.append(obj_) +# end class templateparamlistType + + +class paramType(GeneratedsSuper): + subclass = None + superclass = None + def __init__(self, type_=None, declname=None, defname=None, array=None, defval=None, briefdescription=None): + self.type_ = type_ + self.declname = declname + self.defname = defname + self.array = array + self.defval = defval + self.briefdescription = briefdescription + def factory(*args_, **kwargs_): + if paramType.subclass: + return paramType.subclass(*args_, **kwargs_) + else: + return paramType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_type(self): return self.type_ + def set_type(self, type_): self.type_ = type_ + def get_declname(self): return self.declname + def set_declname(self, declname): self.declname = declname + def get_defname(self): return self.defname + def set_defname(self, defname): self.defname = defname + def get_array(self): return self.array + def set_array(self, array): self.array = array + 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 hasContent_(self): + if ( + self.type_ is not None or + self.declname is not None or + self.defname is not None or + self.array is not None or + self.defval is not None or + self.briefdescription is not None + ): + return True + else: + return False + def 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': + obj_ = linkedTextType.factory() + obj_.build(child_) + self.set_type(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + 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': + defname_ = '' + for text__content_ in child_.childNodes: + defname_ += text__content_.nodeValue + self.defname = defname_ + elif child_.nodeType == Node.ELEMENT_NODE and \ + 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': + obj_ = linkedTextType.factory() + obj_.build(child_) + self.set_defval(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'briefdescription': + obj_ = descriptionType.factory() + obj_.build(child_) + self.set_briefdescription(obj_) +# end class paramType + + +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_) + else: + return declname(*args_, **kwargs_) + factory = staticmethod(factory) + def getValueOf_(self): return self.valueOf_ + def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def hasContent_(self): + if ( + self.valueOf_ is not None + ): + return True + else: + return False + 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 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+']]' +# 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_) + else: + return defname(*args_, **kwargs_) + factory = staticmethod(factory) + def getValueOf_(self): return self.valueOf_ + def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def hasContent_(self): + if ( + self.valueOf_ is not None + ): + return True + else: + return False + 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 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+']]' +# 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_) + else: + return array(*args_, **kwargs_) + factory = staticmethod(factory) + def getValueOf_(self): return self.valueOf_ + def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def hasContent_(self): + if ( + self.valueOf_ is not None + ): + return True + else: + return False + 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 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+']]' +# 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 + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + def factory(*args_, **kwargs_): + if linkedTextType.subclass: + return linkedTextType.subclass(*args_, **kwargs_) + else: + return linkedTextType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ref(self): return self.ref + 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 hasContent_(self): + if ( + self.ref is not None + ): + return True + else: + return False + 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': + childobj_ = docRefTextType.factory() + childobj_.build(child_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ref', childobj_) + self.content_.append(obj_) + elif child_.nodeType == Node.TEXT_NODE: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.nodeValue) + self.content_.append(obj_) +# end class linkedTextType + + +class graphType(GeneratedsSuper): + subclass = None + superclass = None + def __init__(self, node=None): + if node is None: + self.node = [] + else: + self.node = node + def factory(*args_, **kwargs_): + if graphType.subclass: + return graphType.subclass(*args_, **kwargs_) + else: + return graphType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_node(self): return self.node + 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 hasContent_(self): + if ( + self.node is not None + ): + return True + else: + return False + 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': + obj_ = nodeType.factory() + obj_.build(child_) + self.node.append(obj_) +# end class graphType + + +class nodeType(GeneratedsSuper): + subclass = None + superclass = None + def __init__(self, id=None, label=None, link=None, childnode=None): + self.id = id + self.label = label + self.link = link + if childnode is None: + self.childnode = [] + else: + self.childnode = childnode + def factory(*args_, **kwargs_): + if nodeType.subclass: + return nodeType.subclass(*args_, **kwargs_) + else: + return nodeType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_label(self): return self.label + def set_label(self, label): self.label = label + def get_link(self): return self.link + def set_link(self, link): self.link = link + def get_childnode(self): return self.childnode + def set_childnode(self, childnode): self.childnode = childnode + def add_childnode(self, value): self.childnode.append(value) + 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 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 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': + label_ = '' + for text__content_ in child_.childNodes: + label_ += text__content_.nodeValue + self.label = label_ + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'link': + obj_ = linkType.factory() + obj_.build(child_) + self.set_link(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'childnode': + obj_ = childnodeType.factory() + obj_.build(child_) + self.childnode.append(obj_) +# end class nodeType + + +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_) + else: + return label(*args_, **kwargs_) + factory = staticmethod(factory) + def getValueOf_(self): return self.valueOf_ + def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def hasContent_(self): + if ( + self.valueOf_ is not None + ): + return True + else: + return False + 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 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+']]' +# 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 + if edgelabel is None: + self.edgelabel = [] + else: + self.edgelabel = edgelabel + def factory(*args_, **kwargs_): + if childnodeType.subclass: + return childnodeType.subclass(*args_, **kwargs_) + else: + return childnodeType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_edgelabel(self): return self.edgelabel + def set_edgelabel(self, edgelabel): self.edgelabel = edgelabel + def add_edgelabel(self, value): self.edgelabel.append(value) + def insert_edgelabel(self, index, value): self.edgelabel[index] = value + def get_relation(self): return self.relation + 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') + if self.hasContent_(): + outfile.write('>\n') + self.exportChildren(outfile, level + 1, namespace_, name_) + showIndent(outfile, level) + outfile.write('\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'), )) + def exportChildren(self, outfile, level, namespace_='', name_='childnodeType'): + for edgelabel_ in self.edgelabel: + showIndent(outfile, level) + outfile.write('<%sedgelabel>%s\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 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': + edgelabel_ = '' + for text__content_ in child_.childNodes: + edgelabel_ += text__content_.nodeValue + self.edgelabel.append(edgelabel_) +# end class childnodeType + + +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_) + else: + return edgelabel(*args_, **kwargs_) + factory = staticmethod(factory) + def getValueOf_(self): return self.valueOf_ + def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def export(self, outfile, level, namespace_='', name_='edgelabel', namespacedef_=''): + showIndent(outfile, level) + outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) + self.exportAttributes(outfile, level, namespace_, name_='edgelabel') + if self.hasContent_(): + outfile.write('>\n') + self.exportChildren(outfile, level + 1, namespace_, name_) + showIndent(outfile, level) + outfile.write('\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','') + 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 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 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+']]' +# 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_) + else: + return linkType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_refid(self): return self.refid + def set_refid(self, refid): self.refid = refid + def get_external(self): return self.external + 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_, )) + self.exportAttributes(outfile, level, namespace_, name_='linkType') + if self.hasContent_(): + outfile.write('>\n') + self.exportChildren(outfile, level + 1, namespace_, name_) + showIndent(outfile, level) + outfile.write('\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'), )) + if self.external is not None: + 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','') + 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 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 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+']]' +# 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_) + else: + return listingType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_codeline(self): return self.codeline + 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_, )) + self.exportAttributes(outfile, level, namespace_, name_='listingType') + if self.hasContent_(): + outfile.write('>\n') + self.exportChildren(outfile, level + 1, namespace_, name_) + showIndent(outfile, level) + outfile.write('\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 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': + obj_ = codelineType.factory() + obj_.build(child_) + self.codeline.append(obj_) +# end class listingType + + +class codelineType(GeneratedsSuper): + subclass = None + superclass = None + def __init__(self, external=None, lineno=None, refkind=None, refid=None, highlight=None): + self.external = external + self.lineno = lineno + self.refkind = refkind + self.refid = refid + if highlight is None: + self.highlight = [] + else: + self.highlight = highlight + def factory(*args_, **kwargs_): + if codelineType.subclass: + return codelineType.subclass(*args_, **kwargs_) + else: + return codelineType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_highlight(self): return self.highlight + def set_highlight(self, highlight): self.highlight = highlight + def add_highlight(self, value): self.highlight.append(value) + def insert_highlight(self, index, value): self.highlight[index] = value + def get_external(self): return self.external + def set_external(self, external): self.external = external + def get_lineno(self): return self.lineno + def set_lineno(self, lineno): self.lineno = lineno + def get_refkind(self): return self.refkind + 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_, )) + self.exportAttributes(outfile, level, namespace_, name_='codelineType') + if self.hasContent_(): + outfile.write('>\n') + self.exportChildren(outfile, level + 1, namespace_, name_) + showIndent(outfile, level) + outfile.write('\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')) + 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'), )) + 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 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 + if attrs.get('lineno'): + try: + self.lineno = int(attrs.get('lineno').value) + except ValueError as exp: + raise ValueError('Bad integer attribute (lineno): %s' % exp) + if attrs.get('refkind'): + 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': + obj_ = highlightType.factory() + obj_.build(child_) + self.highlight.append(obj_) +# end class codelineType + + +class highlightType(GeneratedsSuper): + subclass = None + superclass = None + def __init__(self, classxx=None, sp=None, ref=None, mixedclass_=None, content_=None): + self.classxx = classxx + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + def factory(*args_, **kwargs_): + if highlightType.subclass: + return highlightType.subclass(*args_, **kwargs_) + else: + return highlightType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_sp(self): return self.sp + def set_sp(self, sp): self.sp = sp + def add_sp(self, value): self.sp.append(value) + def insert_sp(self, index, value): self.sp[index] = value + def get_ref(self): return self.ref + 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 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') + outfile.write('>') + self.exportChildren(outfile, level + 1, namespace_, name_) + outfile.write('\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 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': + value_ = [] + for text_ in child_.childNodes: + value_.append(text_.nodeValue) + # We make this unicode so that our unicode renderer catch-all picks it up + # otherwise it would go through as 'str' and we'd have to pick it up too + valuestr_ = u' ' + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'sp', valuestr_) + self.content_.append(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'ref': + childobj_ = docRefTextType.factory() + childobj_.build(child_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ref', childobj_) + self.content_.append(obj_) + elif child_.nodeType == Node.TEXT_NODE: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.nodeValue) + self.content_.append(obj_) +# end class highlightType + + +class sp(GeneratedsSuper): + subclass = None + superclass = None + def __init__(self, valueOf_=''): + self.valueOf_ = valueOf_ + def factory(*args_, **kwargs_): + if sp.subclass: + return sp.subclass(*args_, **kwargs_) + else: + return sp(*args_, **kwargs_) + factory = staticmethod(factory) + def getValueOf_(self): return self.valueOf_ + def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def export(self, outfile, level, namespace_='', name_='sp', namespacedef_=''): + showIndent(outfile, level) + outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) + self.exportAttributes(outfile, level, namespace_, name_='sp') + if self.hasContent_(): + outfile.write('>\n') + self.exportChildren(outfile, level + 1, namespace_, name_) + showIndent(outfile, level) + outfile.write('\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','') + 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 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 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+']]' +# end class sp + + +class referenceType(GeneratedsSuper): + subclass = None + superclass = None + def __init__(self, endline=None, startline=None, refid=None, compoundref=None, valueOf_='', mixedclass_=None, content_=None): + self.endline = endline + self.startline = startline + self.refid = refid + self.compoundref = compoundref + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + def factory(*args_, **kwargs_): + if referenceType.subclass: + return referenceType.subclass(*args_, **kwargs_) + else: + return referenceType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_endline(self): return self.endline + def set_endline(self, endline): self.endline = endline + def get_startline(self): return self.startline + def set_startline(self, startline): self.startline = startline + def get_refid(self): return self.refid + def set_refid(self, refid): self.refid = refid + def get_compoundref(self): return self.compoundref + 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') + outfile.write('>') + self.exportChildren(outfile, level + 1, namespace_, name_) + outfile.write('\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')) + if self.startline is not None: + 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'), )) + if self.compoundref is not None: + 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','') + 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 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 buildAttributes(self, attrs): + if attrs.get('endline'): + try: + self.endline = int(attrs.get('endline').value) + except ValueError as exp: + raise ValueError('Bad integer attribute (endline): %s' % exp) + if attrs.get('startline'): + try: + self.startline = int(attrs.get('startline').value) + except ValueError as exp: + raise ValueError('Bad integer attribute (startline): %s' % exp) + if attrs.get('refid'): + 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) + 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+']]' +# end class referenceType + + +class locationType(GeneratedsSuper): + subclass = None + superclass = None + def __init__(self, bodystart=None, line=None, bodyend=None, bodyfile=None, file=None, valueOf_=''): + self.bodystart = bodystart + self.line = line + self.bodyend = bodyend + self.bodyfile = bodyfile + self.file = file + self.valueOf_ = valueOf_ + def factory(*args_, **kwargs_): + if locationType.subclass: + return locationType.subclass(*args_, **kwargs_) + else: + return locationType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_bodystart(self): return self.bodystart + def set_bodystart(self, bodystart): self.bodystart = bodystart + def get_line(self): return self.line + def set_line(self, line): self.line = line + def get_bodyend(self): return self.bodyend + def set_bodyend(self, bodyend): self.bodyend = bodyend + def get_bodyfile(self): return self.bodyfile + def set_bodyfile(self, bodyfile): self.bodyfile = bodyfile + def get_file(self): return self.file + 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_, )) + self.exportAttributes(outfile, level, namespace_, name_='locationType') + if self.hasContent_(): + outfile.write('>\n') + self.exportChildren(outfile, level + 1, namespace_, name_) + showIndent(outfile, level) + outfile.write('\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')) + if self.line is not None: + 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')) + if self.bodyfile is not None: + 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'), )) + def exportChildren(self, outfile, level, namespace_='', name_='locationType'): + if self.valueOf_.find('![CDATA')>-1: + value=quote_xml('%s' % self.valueOf_) + value=value.replace('![CDATA','') + 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 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 buildAttributes(self, attrs): + if attrs.get('bodystart'): + try: + self.bodystart = int(attrs.get('bodystart').value) + except ValueError as exp: + raise ValueError('Bad integer attribute (bodystart): %s' % exp) + if attrs.get('line'): + try: + self.line = int(attrs.get('line').value) + except ValueError as exp: + raise ValueError('Bad integer attribute (line): %s' % exp) + if attrs.get('bodyend'): + try: + self.bodyend = int(attrs.get('bodyend').value) + except ValueError as exp: + raise ValueError('Bad integer attribute (bodyend): %s' % exp) + if attrs.get('bodyfile'): + 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+']]' +# end class locationType + + +class docSect1Type(GeneratedsSuper): + subclass = None + superclass = None + def __init__(self, id=None, title=None, para=None, sect2=None, internal=None, mixedclass_=None, content_=None): + self.id = id + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + def factory(*args_, **kwargs_): + if docSect1Type.subclass: + return docSect1Type.subclass(*args_, **kwargs_) + else: + return docSect1Type(*args_, **kwargs_) + factory = staticmethod(factory) + def get_title(self): return self.title + def set_title(self, title): self.title = title + def get_para(self): return self.para + 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 get_sect2(self): return self.sect2 + 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 get_internal(self): return self.internal + 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_, )) + self.exportAttributes(outfile, level, namespace_, name_='docSect1Type') + outfile.write('>') + self.exportChildren(outfile, level + 1, namespace_, name_) + outfile.write('\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'), )) + 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 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': + childobj_ = docTitleType.factory() + childobj_.build(child_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'title', childobj_) + self.content_.append(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'para': + childobj_ = docParaType.factory() + childobj_.build(child_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'para', childobj_) + self.content_.append(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'sect2': + childobj_ = docSect2Type.factory() + childobj_.build(child_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sect2', childobj_) + self.content_.append(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'internal': + childobj_ = docInternalS1Type.factory() + childobj_.build(child_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'internal', childobj_) + self.content_.append(obj_) + elif child_.nodeType == Node.TEXT_NODE: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.nodeValue) + self.content_.append(obj_) +# end class docSect1Type + + +class docSect2Type(GeneratedsSuper): + subclass = None + superclass = None + def __init__(self, id=None, title=None, para=None, sect3=None, internal=None, mixedclass_=None, content_=None): + self.id = id + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + def factory(*args_, **kwargs_): + if docSect2Type.subclass: + return docSect2Type.subclass(*args_, **kwargs_) + else: + return docSect2Type(*args_, **kwargs_) + factory = staticmethod(factory) + def get_title(self): return self.title + def set_title(self, title): self.title = title + def get_para(self): return self.para + 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 get_sect3(self): return self.sect3 + 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 get_internal(self): return self.internal + 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_, )) + self.exportAttributes(outfile, level, namespace_, name_='docSect2Type') + outfile.write('>') + self.exportChildren(outfile, level + 1, namespace_, name_) + outfile.write('\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'), )) + 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 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': + childobj_ = docTitleType.factory() + childobj_.build(child_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'title', childobj_) + self.content_.append(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'para': + childobj_ = docParaType.factory() + childobj_.build(child_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'para', childobj_) + self.content_.append(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'sect3': + childobj_ = docSect3Type.factory() + childobj_.build(child_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sect3', childobj_) + self.content_.append(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'internal': + childobj_ = docInternalS2Type.factory() + childobj_.build(child_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'internal', childobj_) + self.content_.append(obj_) + elif child_.nodeType == Node.TEXT_NODE: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.nodeValue) + self.content_.append(obj_) +# end class docSect2Type + + +class docSect3Type(GeneratedsSuper): + subclass = None + superclass = None + def __init__(self, id=None, title=None, para=None, sect4=None, internal=None, mixedclass_=None, content_=None): + self.id = id + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + def factory(*args_, **kwargs_): + if docSect3Type.subclass: + return docSect3Type.subclass(*args_, **kwargs_) + else: + return docSect3Type(*args_, **kwargs_) + factory = staticmethod(factory) + def get_title(self): return self.title + def set_title(self, title): self.title = title + def get_para(self): return self.para + 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 get_sect4(self): return self.sect4 + def set_sect4(self, sect4): self.sect4 = sect4 + def add_sect4(self, value): self.sect4.append(value) + def insert_sect4(self, index, value): self.sect4[index] = value + def get_internal(self): return self.internal + 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_, )) + self.exportAttributes(outfile, level, namespace_, name_='docSect3Type') + outfile.write('>') + self.exportChildren(outfile, level + 1, namespace_, name_) + outfile.write('\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'), )) + 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 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': + childobj_ = docTitleType.factory() + childobj_.build(child_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'title', childobj_) + self.content_.append(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'para': + childobj_ = docParaType.factory() + childobj_.build(child_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'para', childobj_) + self.content_.append(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'sect4': + childobj_ = docSect4Type.factory() + childobj_.build(child_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sect4', childobj_) + self.content_.append(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'internal': + childobj_ = docInternalS3Type.factory() + childobj_.build(child_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'internal', childobj_) + self.content_.append(obj_) + elif child_.nodeType == Node.TEXT_NODE: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.nodeValue) + self.content_.append(obj_) +# end class docSect3Type + + +class docSect4Type(GeneratedsSuper): + subclass = None + superclass = None + def __init__(self, id=None, title=None, para=None, internal=None, mixedclass_=None, content_=None): + self.id = id + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + def factory(*args_, **kwargs_): + if docSect4Type.subclass: + return docSect4Type.subclass(*args_, **kwargs_) + else: + return docSect4Type(*args_, **kwargs_) + factory = staticmethod(factory) + def get_title(self): return self.title + def set_title(self, title): self.title = title + def get_para(self): return self.para + 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 get_internal(self): return self.internal + 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_, )) + self.exportAttributes(outfile, level, namespace_, name_='docSect4Type') + outfile.write('>') + self.exportChildren(outfile, level + 1, namespace_, name_) + outfile.write('\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'), )) + 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 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': + childobj_ = docTitleType.factory() + childobj_.build(child_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'title', childobj_) + self.content_.append(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'para': + childobj_ = docParaType.factory() + childobj_.build(child_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'para', childobj_) + self.content_.append(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'internal': + childobj_ = docInternalS4Type.factory() + childobj_.build(child_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'internal', childobj_) + self.content_.append(obj_) + elif child_.nodeType == Node.TEXT_NODE: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.nodeValue) + self.content_.append(obj_) +# end class docSect4Type + + +class docInternalType(GeneratedsSuper): + subclass = None + superclass = None + def __init__(self, para=None, sect1=None, mixedclass_=None, content_=None): + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + def factory(*args_, **kwargs_): + if docInternalType.subclass: + return docInternalType.subclass(*args_, **kwargs_) + else: + return docInternalType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_para(self): return self.para + 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 get_sect1(self): return self.sect1 + 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') + outfile.write('>') + self.exportChildren(outfile, level + 1, namespace_, name_) + outfile.write('\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 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': + childobj_ = docParaType.factory() + childobj_.build(child_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'para', childobj_) + self.content_.append(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'sect1': + childobj_ = docSect1Type.factory() + childobj_.build(child_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sect1', childobj_) + self.content_.append(obj_) + elif child_.nodeType == Node.TEXT_NODE: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.nodeValue) + self.content_.append(obj_) +# end class docInternalType + + +class docInternalS1Type(GeneratedsSuper): + subclass = None + superclass = None + def __init__(self, para=None, sect2=None, mixedclass_=None, content_=None): + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + def factory(*args_, **kwargs_): + if docInternalS1Type.subclass: + return docInternalS1Type.subclass(*args_, **kwargs_) + else: + return docInternalS1Type(*args_, **kwargs_) + factory = staticmethod(factory) + def get_para(self): return self.para + 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 get_sect2(self): return self.sect2 + 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') + outfile.write('>') + self.exportChildren(outfile, level + 1, namespace_, name_) + outfile.write('\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 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': + childobj_ = docParaType.factory() + childobj_.build(child_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'para', childobj_) + self.content_.append(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'sect2': + childobj_ = docSect2Type.factory() + childobj_.build(child_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sect2', childobj_) + self.content_.append(obj_) + elif child_.nodeType == Node.TEXT_NODE: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.nodeValue) + self.content_.append(obj_) +# end class docInternalS1Type + + +class docInternalS2Type(GeneratedsSuper): + subclass = None + superclass = None + def __init__(self, para=None, sect3=None, mixedclass_=None, content_=None): + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + def factory(*args_, **kwargs_): + if docInternalS2Type.subclass: + return docInternalS2Type.subclass(*args_, **kwargs_) + else: + return docInternalS2Type(*args_, **kwargs_) + factory = staticmethod(factory) + def get_para(self): return self.para + 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 get_sect3(self): return self.sect3 + 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') + outfile.write('>') + self.exportChildren(outfile, level + 1, namespace_, name_) + outfile.write('\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 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': + childobj_ = docParaType.factory() + childobj_.build(child_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'para', childobj_) + self.content_.append(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'sect3': + childobj_ = docSect3Type.factory() + childobj_.build(child_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sect3', childobj_) + self.content_.append(obj_) + elif child_.nodeType == Node.TEXT_NODE: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.nodeValue) + self.content_.append(obj_) +# end class docInternalS2Type + + +class docInternalS3Type(GeneratedsSuper): + subclass = None + superclass = None + def __init__(self, para=None, sect3=None, mixedclass_=None, content_=None): + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + def factory(*args_, **kwargs_): + if docInternalS3Type.subclass: + return docInternalS3Type.subclass(*args_, **kwargs_) + else: + return docInternalS3Type(*args_, **kwargs_) + factory = staticmethod(factory) + def get_para(self): return self.para + 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 get_sect3(self): return self.sect3 + 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') + outfile.write('>') + self.exportChildren(outfile, level + 1, namespace_, name_) + outfile.write('\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 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': + childobj_ = docParaType.factory() + childobj_.build(child_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'para', childobj_) + self.content_.append(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'sect3': + childobj_ = docSect4Type.factory() + childobj_.build(child_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sect3', childobj_) + self.content_.append(obj_) + elif child_.nodeType == Node.TEXT_NODE: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.nodeValue) + self.content_.append(obj_) +# end class docInternalS3Type + + +class docInternalS4Type(GeneratedsSuper): + subclass = None + superclass = None + def __init__(self, para=None, mixedclass_=None, content_=None): + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + def factory(*args_, **kwargs_): + if docInternalS4Type.subclass: + return docInternalS4Type.subclass(*args_, **kwargs_) + else: + return docInternalS4Type(*args_, **kwargs_) + factory = staticmethod(factory) + def get_para(self): return self.para + 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') + outfile.write('>') + self.exportChildren(outfile, level + 1, namespace_, name_) + outfile.write('\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 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': + childobj_ = docParaType.factory() + childobj_.build(child_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'para', childobj_) + self.content_.append(obj_) + elif child_.nodeType == Node.TEXT_NODE: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.nodeValue) + self.content_.append(obj_) +# end class docInternalS4Type + + +class docTitleType(GeneratedsSuper): + subclass = None + superclass = None + def __init__(self, valueOf_='', mixedclass_=None, content_=None): + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + def factory(*args_, **kwargs_): + if docTitleType.subclass: + return docTitleType.subclass(*args_, **kwargs_) + else: + return docTitleType(*args_, **kwargs_) + factory = staticmethod(factory) + def getValueOf_(self): return self.valueOf_ + def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def export(self, outfile, level, namespace_='', name_='docTitleType', namespacedef_=''): + showIndent(outfile, level) + outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) + self.exportAttributes(outfile, level, namespace_, name_='docTitleType') + outfile.write('>') + self.exportChildren(outfile, level + 1, namespace_, name_) + outfile.write('\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','') + 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 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 buildAttributes(self, attrs): + pass + def buildChildren(self, child_, nodeName_): + if child_.nodeType == Node.TEXT_NODE: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + 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+']]' +# 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 + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + def factory(*args_, **kwargs_): + if docParaType.subclass: + return docParaType.subclass(*args_, **kwargs_) + else: + return docParaType(*args_, **kwargs_) + factory = staticmethod(factory) + def getValueOf_(self): return self.valueOf_ + def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def export(self, outfile, level, namespace_='', name_='docParaType', namespacedef_=''): + showIndent(outfile, level) + outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) + self.exportAttributes(outfile, level, namespace_, name_='docParaType') + outfile.write('>') + self.exportChildren(outfile, level + 1, namespace_, name_) + outfile.write('\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','') + 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 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 buildAttributes(self, attrs): + pass + def buildChildren(self, child_, nodeName_): + if child_.nodeType == Node.TEXT_NODE: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + 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+']]' +# 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 + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + def factory(*args_, **kwargs_): + if docMarkupType.subclass: + return docMarkupType.subclass(*args_, **kwargs_) + else: + return docMarkupType(*args_, **kwargs_) + factory = staticmethod(factory) + def getValueOf_(self): return self.valueOf_ + def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def export(self, outfile, level, namespace_='', name_='docMarkupType', namespacedef_=''): + showIndent(outfile, level) + outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) + self.exportAttributes(outfile, level, namespace_, name_='docMarkupType') + outfile.write('>') + self.exportChildren(outfile, level + 1, namespace_, name_) + outfile.write('\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','') + 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 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 buildAttributes(self, attrs): + pass + def buildChildren(self, child_, nodeName_): + if child_.nodeType == Node.TEXT_NODE: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + 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+']]' +# end class docMarkupType + + +class docURLLink(GeneratedsSuper): + subclass = None + superclass = None + def __init__(self, url=None, valueOf_='', mixedclass_=None, content_=None): + self.url = url + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + def factory(*args_, **kwargs_): + if docURLLink.subclass: + return docURLLink.subclass(*args_, **kwargs_) + else: + return docURLLink(*args_, **kwargs_) + factory = staticmethod(factory) + def get_url(self): return self.url + 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_, )) + self.exportAttributes(outfile, level, namespace_, name_='docURLLink') + outfile.write('>') + self.exportChildren(outfile, level + 1, namespace_, name_) + outfile.write('\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'), )) + def exportChildren(self, outfile, level, namespace_='', name_='docURLLink'): + if self.valueOf_.find('![CDATA')>-1: + value=quote_xml('%s' % self.valueOf_) + value=value.replace('![CDATA','') + 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 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 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) + 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+']]' +# end class docURLLink + + +class docAnchorType(GeneratedsSuper): + subclass = None + superclass = None + def __init__(self, id=None, valueOf_='', mixedclass_=None, content_=None): + self.id = id + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + def factory(*args_, **kwargs_): + if docAnchorType.subclass: + return docAnchorType.subclass(*args_, **kwargs_) + else: + return docAnchorType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_id(self): return self.id + 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') + outfile.write('>') + self.exportChildren(outfile, level + 1, namespace_, name_) + outfile.write('\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'), )) + def exportChildren(self, outfile, level, namespace_='', name_='docAnchorType'): + if self.valueOf_.find('![CDATA')>-1: + value=quote_xml('%s' % self.valueOf_) + value=value.replace('![CDATA','') + 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 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 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) + 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+']]' +# end class docAnchorType + + +class docFormulaType(GeneratedsSuper): + subclass = None + superclass = None + def __init__(self, id=None, valueOf_='', mixedclass_=None, content_=None): + self.id = id + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + def factory(*args_, **kwargs_): + if docFormulaType.subclass: + return docFormulaType.subclass(*args_, **kwargs_) + else: + return docFormulaType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_id(self): return self.id + 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') + outfile.write('>') + self.exportChildren(outfile, level + 1, namespace_, name_) + outfile.write('\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'), )) + def exportChildren(self, outfile, level, namespace_='', name_='docFormulaType'): + if self.valueOf_.find('![CDATA')>-1: + value=quote_xml('%s' % self.valueOf_) + value=value.replace('![CDATA','') + 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 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 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) + 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+']]' +# 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_) + else: + return docIndexEntryType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_primaryie(self): return self.primaryie + 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') + if self.hasContent_(): + outfile.write('>\n') + self.exportChildren(outfile, level + 1, namespace_, name_) + showIndent(outfile, level) + outfile.write('\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\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\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 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': + primaryie_ = '' + for text__content_ in child_.childNodes: + primaryie_ += text__content_.nodeValue + self.primaryie = primaryie_ + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'secondaryie': + secondaryie_ = '' + for text__content_ in child_.childNodes: + secondaryie_ += text__content_.nodeValue + self.secondaryie = secondaryie_ +# end class docIndexEntryType + + +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_) + else: + return docListType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_listitem(self): return self.listitem + 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_, )) + self.exportAttributes(outfile, level, namespace_, name_='docListType') + if self.hasContent_(): + outfile.write('>\n') + self.exportChildren(outfile, level + 1, namespace_, name_) + showIndent(outfile, level) + outfile.write('\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 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': + obj_ = docListItemType.factory() + obj_.build(child_) + self.listitem.append(obj_) +# end class docListType + + +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_) + else: + return docListItemType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_para(self): return self.para + 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') + if self.hasContent_(): + outfile.write('>\n') + self.exportChildren(outfile, level + 1, namespace_, name_) + showIndent(outfile, level) + outfile.write('\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 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': + obj_ = docParaType.factory() + obj_.build(child_) + self.para.append(obj_) +# end class docListItemType + + +class docSimpleSectType(GeneratedsSuper): + subclass = None + superclass = None + def __init__(self, kind=None, title=None, para=None): + self.kind = kind + self.title = title + if para is None: + self.para = [] + else: + self.para = para + def factory(*args_, **kwargs_): + if docSimpleSectType.subclass: + return docSimpleSectType.subclass(*args_, **kwargs_) + else: + return docSimpleSectType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_title(self): return self.title + def set_title(self, title): self.title = title + def get_para(self): return self.para + 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 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') + if self.hasContent_(): + outfile.write('>\n') + self.exportChildren(outfile, level + 1, namespace_, name_) + showIndent(outfile, level) + outfile.write('\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 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': + obj_ = docTitleType.factory() + obj_.build(child_) + self.set_title(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'para': + obj_ = docParaType.factory() + obj_.build(child_) + self.para.append(obj_) +# end class docSimpleSectType + + +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_) + else: + return docVarListEntryType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_term(self): return self.term + def set_term(self, term): self.term = term + def export(self, outfile, level, namespace_='', name_='docVarListEntryType', namespacedef_=''): + showIndent(outfile, level) + outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) + self.exportAttributes(outfile, level, namespace_, name_='docVarListEntryType') + if self.hasContent_(): + outfile.write('>\n') + self.exportChildren(outfile, level + 1, namespace_, name_) + showIndent(outfile, level) + outfile.write('\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 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': + obj_ = docTitleType.factory() + obj_.build(child_) + self.set_term(obj_) +# end class docVarListEntryType + + +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_) + else: + return docVariableListType(*args_, **kwargs_) + factory = staticmethod(factory) + def getValueOf_(self): return self.valueOf_ + def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def export(self, outfile, level, namespace_='', name_='docVariableListType', namespacedef_=''): + showIndent(outfile, level) + outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) + self.exportAttributes(outfile, level, namespace_, name_='docVariableListType') + if self.hasContent_(): + outfile.write('>\n') + self.exportChildren(outfile, level + 1, namespace_, name_) + showIndent(outfile, level) + outfile.write('\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','') + 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 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 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+']]' +# end class docVariableListType + + +class docRefTextType(GeneratedsSuper): + subclass = None + superclass = None + def __init__(self, refid=None, kindref=None, external=None, valueOf_='', mixedclass_=None, content_=None): + self.refid = refid + self.kindref = kindref + self.external = external + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + def factory(*args_, **kwargs_): + if docRefTextType.subclass: + return docRefTextType.subclass(*args_, **kwargs_) + else: + return docRefTextType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_refid(self): return self.refid + def set_refid(self, refid): self.refid = refid + def get_kindref(self): return self.kindref + def set_kindref(self, kindref): self.kindref = kindref + def get_external(self): return self.external + 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') + outfile.write('>') + self.exportChildren(outfile, level + 1, namespace_, name_) + outfile.write('\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'), )) + 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'), )) + def exportChildren(self, outfile, level, namespace_='', name_='docRefTextType'): + if self.valueOf_.find('![CDATA')>-1: + value=quote_xml('%s' % self.valueOf_) + value=value.replace('![CDATA','') + 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 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 buildAttributes(self, attrs): + if attrs.get('refid'): + self.refid = attrs.get('refid').value + if attrs.get('kindref'): + 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) + 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+']]' +# 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 + if row is None: + self.row = [] + else: + self.row = row + self.caption = caption + def factory(*args_, **kwargs_): + if docTableType.subclass: + return docTableType.subclass(*args_, **kwargs_) + else: + return docTableType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_row(self): return self.row + def set_row(self, row): self.row = row + def add_row(self, value): self.row.append(value) + def insert_row(self, index, value): self.row[index] = value + def get_caption(self): return self.caption + def set_caption(self, caption): self.caption = caption + def get_rows(self): return self.rows + 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_, )) + self.exportAttributes(outfile, level, namespace_, name_='docTableType') + if self.hasContent_(): + outfile.write('>\n') + self.exportChildren(outfile, level + 1, namespace_, name_) + showIndent(outfile, level) + outfile.write('\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')) + if self.cols is not None: + 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 build(self, node_): + attrs = node_.attributes + self.buildAttributes(attrs) + for child_ in node_.childNodes: + nodeName_ = child_.nodeName.split(':')[-1] + self.buildChildren(child_, nodeName_) + def buildAttributes(self, attrs): + if attrs.get('rows'): + try: + self.rows = int(attrs.get('rows').value) + except ValueError as exp: + raise ValueError('Bad integer attribute (rows): %s' % exp) + if attrs.get('cols'): + try: + self.cols = int(attrs.get('cols').value) + except ValueError as exp: + raise ValueError('Bad integer attribute (cols): %s' % exp) + def buildChildren(self, child_, nodeName_): + if child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'row': + obj_ = docRowType.factory() + obj_.build(child_) + self.row.append(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'caption': + obj_ = docCaptionType.factory() + obj_.build(child_) + self.set_caption(obj_) +# end class docTableType + + +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_) + else: + return docRowType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_entry(self): return self.entry + 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_, )) + self.exportAttributes(outfile, level, namespace_, name_='docRowType') + if self.hasContent_(): + outfile.write('>\n') + self.exportChildren(outfile, level + 1, namespace_, name_) + showIndent(outfile, level) + outfile.write('\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 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': + obj_ = docEntryType.factory() + obj_.build(child_) + self.entry.append(obj_) +# end class docRowType + + +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_) + else: + return docEntryType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_para(self): return self.para + 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 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_, )) + self.exportAttributes(outfile, level, namespace_, name_='docEntryType') + if self.hasContent_(): + outfile.write('>\n') + self.exportChildren(outfile, level + 1, namespace_, name_) + showIndent(outfile, level) + outfile.write('\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 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': + obj_ = docParaType.factory() + obj_.build(child_) + self.para.append(obj_) +# end class docEntryType + + +class docCaptionType(GeneratedsSuper): + subclass = None + superclass = None + 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_ + def factory(*args_, **kwargs_): + if docCaptionType.subclass: + return docCaptionType.subclass(*args_, **kwargs_) + else: + return docCaptionType(*args_, **kwargs_) + factory = staticmethod(factory) + def getValueOf_(self): return self.valueOf_ + def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def export(self, outfile, level, namespace_='', name_='docCaptionType', namespacedef_=''): + showIndent(outfile, level) + outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) + self.exportAttributes(outfile, level, namespace_, name_='docCaptionType') + outfile.write('>') + self.exportChildren(outfile, level + 1, namespace_, name_) + outfile.write('\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','') + 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 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 buildAttributes(self, attrs): + pass + def buildChildren(self, child_, nodeName_): + if child_.nodeType == Node.TEXT_NODE: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + 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+']]' +# 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: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + def factory(*args_, **kwargs_): + if docHeadingType.subclass: + return docHeadingType.subclass(*args_, **kwargs_) + else: + return docHeadingType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_level(self): return self.level + 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') + outfile.write('>') + self.exportChildren(outfile, level + 1, namespace_, name_) + outfile.write('\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')) + def exportChildren(self, outfile, level, namespace_='', name_='docHeadingType'): + if self.valueOf_.find('![CDATA')>-1: + value=quote_xml('%s' % self.valueOf_) + value=value.replace('![CDATA','') + 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 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 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) + 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+']]' +# 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_ + self.name = name + self.height = height + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + def factory(*args_, **kwargs_): + if docImageType.subclass: + return docImageType.subclass(*args_, **kwargs_) + else: + return docImageType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_width(self): return self.width + def set_width(self, width): self.width = width + def get_type(self): return self.type_ + def set_type(self, type_): self.type_ = type_ + def get_name(self): return self.name + def set_name(self, name): self.name = name + def get_height(self): return self.height + 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_, )) + self.exportAttributes(outfile, level, namespace_, name_='docImageType') + outfile.write('>') + self.exportChildren(outfile, level + 1, namespace_, name_) + outfile.write('\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'), )) + 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'), )) + if self.height is not None: + 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','') + 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 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 buildAttributes(self, attrs): + if attrs.get('width'): + self.width = attrs.get('width').value + if attrs.get('type'): + self.type_ = attrs.get('type').value + if attrs.get('name'): + 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) + 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+']]' +# 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: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + def factory(*args_, **kwargs_): + if docDotFileType.subclass: + return docDotFileType.subclass(*args_, **kwargs_) + else: + return docDotFileType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_name(self): return self.name + 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') + outfile.write('>') + self.exportChildren(outfile, level + 1, namespace_, name_) + outfile.write('\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'), )) + def exportChildren(self, outfile, level, namespace_='', name_='docDotFileType'): + if self.valueOf_.find('![CDATA')>-1: + value=quote_xml('%s' % self.valueOf_) + value=value.replace('![CDATA','') + 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 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 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) + 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+']]' +# 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: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + def factory(*args_, **kwargs_): + if docTocItemType.subclass: + return docTocItemType.subclass(*args_, **kwargs_) + else: + return docTocItemType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_id(self): return self.id + 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') + outfile.write('>') + self.exportChildren(outfile, level + 1, namespace_, name_) + outfile.write('\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'), )) + def exportChildren(self, outfile, level, namespace_='', name_='docTocItemType'): + if self.valueOf_.find('![CDATA')>-1: + value=quote_xml('%s' % self.valueOf_) + value=value.replace('![CDATA','') + 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 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 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) + 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+']]' +# 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_) + else: + return docTocListType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_tocitem(self): return self.tocitem + 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') + if self.hasContent_(): + outfile.write('>\n') + self.exportChildren(outfile, level + 1, namespace_, name_) + showIndent(outfile, level) + outfile.write('\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 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': + obj_ = docTocItemType.factory() + obj_.build(child_) + self.tocitem.append(obj_) +# end class docTocListType + + +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_) + else: + return docLanguageType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_para(self): return self.para + 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 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') + if self.hasContent_(): + outfile.write('>\n') + self.exportChildren(outfile, level + 1, namespace_, name_) + showIndent(outfile, level) + outfile.write('\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'), )) + 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 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': + obj_ = docParaType.factory() + obj_.build(child_) + self.para.append(obj_) +# end class docLanguageType + + +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_) + else: + return docParamListType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_parameteritem(self): return self.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 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') + if self.hasContent_(): + outfile.write('>\n') + self.exportChildren(outfile, level + 1, namespace_, name_) + showIndent(outfile, level) + outfile.write('\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') + def hasContent_(self): + if ( + self.parameteritem is not None + ): + return True + else: + return False + 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': + obj_ = docParamListItem.factory() + obj_.build(child_) + self.parameteritem.append(obj_) +# end class docParamListType + + +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_) + else: + 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 get_parameterdescription(self): return self.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') + if self.hasContent_(): + outfile.write('>\n') + self.exportChildren(outfile, level + 1, namespace_, name_) + showIndent(outfile, level) + outfile.write('\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') + if self.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 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': + obj_ = docParamNameList.factory() + obj_.build(child_) + self.parameternamelist.append(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'parameterdescription': + obj_ = descriptionType.factory() + obj_.build(child_) + self.set_parameterdescription(obj_) +# end class docParamListItem + + +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_) + else: + return docParamNameList(*args_, **kwargs_) + factory = staticmethod(factory) + def get_parametername(self): return self.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 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') + if self.hasContent_(): + outfile.write('>\n') + self.exportChildren(outfile, level + 1, namespace_, name_) + showIndent(outfile, level) + outfile.write('\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') + def hasContent_(self): + if ( + self.parametername is not None + ): + return True + else: + return False + 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': + obj_ = docParamName.factory() + obj_.build(child_) + self.parametername.append(obj_) +# end class docParamNameList + + +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: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + def factory(*args_, **kwargs_): + if docParamName.subclass: + return docParamName.subclass(*args_, **kwargs_) + else: + return docParamName(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ref(self): return self.ref + 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_, )) + self.exportAttributes(outfile, level, namespace_, name_='docParamName') + outfile.write('>') + self.exportChildren(outfile, level + 1, namespace_, name_) + outfile.write('\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 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': + childobj_ = docRefTextType.factory() + childobj_.build(child_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ref', childobj_) + self.content_.append(obj_) + elif child_.nodeType == Node.TEXT_NODE: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.nodeValue) + self.content_.append(obj_) +# end class docParamName + + +class docXRefSectType(GeneratedsSuper): + subclass = None + superclass = None + def __init__(self, id=None, xreftitle=None, xrefdescription=None): + self.id = id + if xreftitle is None: + self.xreftitle = [] + else: + self.xreftitle = xreftitle + self.xrefdescription = xrefdescription + def factory(*args_, **kwargs_): + if docXRefSectType.subclass: + return docXRefSectType.subclass(*args_, **kwargs_) + else: + return docXRefSectType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_xreftitle(self): return self.xreftitle + def set_xreftitle(self, xreftitle): self.xreftitle = xreftitle + 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 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') + if self.hasContent_(): + outfile.write('>\n') + self.exportChildren(outfile, level + 1, namespace_, name_) + showIndent(outfile, level) + outfile.write('\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'), )) + def exportChildren(self, outfile, level, namespace_='', name_='docXRefSectType'): + for xreftitle_ in self.xreftitle: + showIndent(outfile, level) + outfile.write('<%sxreftitle>%s\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', ) + def hasContent_(self): + if ( + self.xreftitle is not None or + self.xrefdescription is not None + ): + return True + else: + return False + 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': + xreftitle_ = '' + for text__content_ in child_.childNodes: + xreftitle_ += text__content_.nodeValue + self.xreftitle.append(xreftitle_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'xrefdescription': + obj_ = descriptionType.factory() + obj_.build(child_) + self.set_xrefdescription(obj_) +# end class docXRefSectType + + +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: + self.para = [] + else: + self.para = para + if sect1 is None: + self.sect1 = [] + else: + self.sect1 = sect1 + self.internal = internal + def factory(*args_, **kwargs_): + if docCopyType.subclass: + return docCopyType.subclass(*args_, **kwargs_) + else: + return docCopyType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_para(self): return self.para + 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 get_sect1(self): return self.sect1 + 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 get_internal(self): return self.internal + 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_, )) + self.exportAttributes(outfile, level, namespace_, name_='docCopyType') + if self.hasContent_(): + outfile.write('>\n') + self.exportChildren(outfile, level + 1, namespace_, name_) + showIndent(outfile, level) + outfile.write('\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'), )) + def exportChildren(self, outfile, level, namespace_='', name_='docCopyType'): + for para_ in self.para: + para_.export(outfile, level, namespace_, name_='para') + for sect1_ in self.sect1: + 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 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': + obj_ = docParaType.factory() + obj_.build(child_) + self.para.append(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'sect1': + obj_ = docSect1Type.factory() + obj_.build(child_) + self.sect1.append(obj_) + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'internal': + obj_ = docInternalType.factory() + obj_.build(child_) + self.set_internal(obj_) +# end class docCopyType + + +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_) + else: + return docCharType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_char(self): return self.char + 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_, )) + self.exportAttributes(outfile, level, namespace_, name_='docCharType') + if self.hasContent_(): + outfile.write('>\n') + self.exportChildren(outfile, level + 1, namespace_, name_) + showIndent(outfile, level) + outfile.write('\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','') + 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 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 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+']]' +# 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_) + else: + return docEmptyType(*args_, **kwargs_) + factory = staticmethod(factory) + def getValueOf_(self): return self.valueOf_ + def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def export(self, outfile, level, namespace_='', name_='docEmptyType', namespacedef_=''): + showIndent(outfile, level) + outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, )) + self.exportAttributes(outfile, level, namespace_, name_='docEmptyType') + if self.hasContent_(): + outfile.write('>\n') + self.exportChildren(outfile, level + 1, namespace_, name_) + showIndent(outfile, level) + outfile.write('\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','') + 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 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 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+']]' +# end class docEmptyType + + +USAGE_TEXT = """ +Usage: python .py [ -s ] +Options: + -s Use the SAX parser, not the minidom parser. +""" + +def usage(): + print(USAGE_TEXT) + sys.exit(1) + + +def parse(inFileName): + doc = minidom.parse(inFileName) + rootNode = doc.documentElement + rootObj = DoxygenType.factory() + rootObj.build(rootNode) + # Enable Python to collect the space used by the DOM. + doc = None + sys.stdout.write('\n') + rootObj.export(sys.stdout, 0, name_="doxygen", + namespacedef_='') + return rootObj + + +def parseString(inString): + doc = minidom.parseString(inString) + rootNode = doc.documentElement + rootObj = DoxygenType.factory() + rootObj.build(rootNode) + # Enable Python to collect the space used by the DOM. + doc = None + sys.stdout.write('\n') + rootObj.export(sys.stdout, 0, name_="doxygen", + namespacedef_='') + return rootObj + + +def parseLiteral(inFileName): + doc = minidom.parse(inFileName) + rootNode = doc.documentElement + rootObj = DoxygenType.factory() + rootObj.build(rootNode) + # Enable Python to collect the space used by the DOM. + doc = None + sys.stdout.write('from compound import *\n\n') + sys.stdout.write('rootObj = doxygen(\n') + rootObj.exportLiteral(sys.stdout, 0, name_="doxygen") + sys.stdout.write(')\n') + return rootObj + + +def main(): + args = sys.argv[1:] + if len(args) == 1: + parse(args[0]) + else: + usage() + + +if __name__ == '__main__': + main() + #import pdb + #pdb.run('main()') + diff --git a/doc/breathe/parser/doxygen/compoundsuper.pyc b/doc/breathe/parser/doxygen/compoundsuper.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5b3f94124ff34d5c0a23769154eb4b535ce15414 GIT binary patch literal 398653 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 ln{ literal 0 HcmV?d00001 diff --git a/doc/breathe/parser/doxygen/indexsuper.py b/doc/breathe/parser/doxygen/indexsuper.py new file mode 100644 index 0000000..5641e0b --- /dev/null +++ b/doc/breathe/parser/doxygen/indexsuper.py @@ -0,0 +1,362 @@ +#!/usr/bin/env python + +# +# Generated Thu Jun 11 18:43:54 2009 by generateDS.py. +# + +import sys +import getopt +from xml.dom import minidom +from xml.dom import Node + +# +# User methods +# +# Calls to the methods in these classes are generated by generateDS.py. +# You can replace these methods by re-implementing the following class +# in a module named generatedssuper.py. + +try: + from generatedssuper import GeneratedsSuper +except ImportError as exp: + + class GeneratedsSuper: + 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 + + +# +# If you have installed IPython you can uncomment and use the following. +# IPython is available from http://ipython.scipy.org/. +# + +## from IPython.Shell import IPShellEmbed +## args = '' +## ipshell = IPShellEmbed(args, +## banner = 'Dropping into IPython', +## exit_msg = 'Leaving Interpreter, back to program.') + +# Then use the following line where and when you want to drop into the +# IPython shell: +# ipshell(' -- Entering ipshell.\nHit Ctrl-D to exit') + +# +# Globals +# + +ExternalEncoding = 'ascii' + +# +# Support/utility functions. +# + +def showIndent(outfile, level): + for idx in range(level): + outfile.write(' ') + +def quote_xml(inStr): + s1 = (isinstance(inStr, basestring) and inStr or + '%s' % inStr) + s1 = s1.replace('&', '&') + s1 = s1.replace('<', '<') + s1 = s1.replace('>', '>') + return s1 + +def quote_attrib(inStr): + s1 = (isinstance(inStr, basestring) and inStr or + '%s' % inStr) + s1 = s1.replace('&', '&') + s1 = s1.replace('<', '<') + s1 = s1.replace('>', '>') + if '"' in s1: + if "'" in s1: + s1 = '"%s"' % s1.replace('"', """) + else: + s1 = "'%s'" % s1 + else: + s1 = '"%s"' % s1 + return s1 + +def quote_python(inStr): + s1 = inStr + if s1.find("'") == -1: + if s1.find('\n') == -1: + return "'%s'" % s1 + else: + return "'''%s'''" % s1 + else: + if s1.find('"') != -1: + s1 = s1.replace('"', '\\"') + if s1.find('\n') == -1: + return '"%s"' % s1 + else: + return '"""%s"""' % s1 + + +class MixedContainer: + # Constants for category: + CategoryNone = 0 + CategoryText = 1 + CategorySimple = 2 + CategoryComplex = 3 + # Constants for content_type: + TypeNone = 0 + TypeText = 1 + TypeString = 2 + TypeInteger = 3 + TypeFloat = 4 + 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 + + +class _MemberSpec(object): + def __init__(self, name='', data_type='', container=0): + 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 + def get_data_type(self): return self.data_type + def set_container(self, container): self.container = container + def get_container(self): return self.container + + +# +# Data representation classes. +# + +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_) + else: + return DoxygenType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_compound(self): return self.compound + def set_compound(self, compound): self.compound = compound + def add_compound(self, value): self.compound.append(value) + 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 hasContent_(self): + if ( + self.compound is not None + ): + return True + else: + return False + 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': + obj_ = CompoundType.factory() + obj_.build(child_) + self.compound.append(obj_) +# end class DoxygenType + + +class CompoundType(GeneratedsSuper): + subclass = None + superclass = None + def __init__(self, kind=None, refid=None, name=None, member=None): + self.kind = kind + self.refid = refid + self.name = name + if member is None: + self.member = [] + else: + self.member = member + def factory(*args_, **kwargs_): + if CompoundType.subclass: + return CompoundType.subclass(*args_, **kwargs_) + else: + return CompoundType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_name(self): return self.name + def set_name(self, name): self.name = name + def get_member(self): return self.member + 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 get_kind(self): return self.kind + def set_kind(self, kind): self.kind = kind + def get_refid(self): return self.refid + def set_refid(self, refid): self.refid = refid + 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': + name_ = '' + for text__content_ in child_.childNodes: + name_ += text__content_.nodeValue + self.name = name_ + elif child_.nodeType == Node.ELEMENT_NODE and \ + nodeName_ == 'member': + obj_ = MemberType.factory() + obj_.build(child_) + self.member.append(obj_) +# end class CompoundType + + +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_) + else: + return MemberType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_name(self): return self.name + def set_name(self, name): self.name = name + def get_kind(self): return self.kind + def set_kind(self, kind): self.kind = kind + def get_refid(self): return self.refid + def set_refid(self, refid): self.refid = refid + def hasContent_(self): + if ( + self.name is not None + ): + return True + else: + return False + 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': + name_ = '' + for text__content_ in child_.childNodes: + name_ += text__content_.nodeValue + self.name = name_ +# end class MemberType + + +USAGE_TEXT = """ +Usage: python .py [ -s ] +Options: + -s Use the SAX parser, not the minidom parser. +""" + +def usage(): + print(USAGE_TEXT) + sys.exit(1) + + +def parse(inFileName): + doc = minidom.parse(inFileName) + rootNode = doc.documentElement + rootObj = DoxygenType.factory() + rootObj.build(rootNode) + # Enable Python to collect the space used by the DOM. + doc = None + sys.stdout.write('\n') + rootObj.export(sys.stdout, 0, name_="doxygenindex", + namespacedef_='') + return rootObj + + +def parseString(inString): + doc = minidom.parseString(inString) + rootNode = doc.documentElement + rootObj = DoxygenType.factory() + rootObj.build(rootNode) + # Enable Python to collect the space used by the DOM. + doc = None + sys.stdout.write('\n') + rootObj.export(sys.stdout, 0, name_="doxygenindex", + namespacedef_='') + return rootObj + + +def parseLiteral(inFileName): + doc = minidom.parse(inFileName) + rootNode = doc.documentElement + rootObj = DoxygenType.factory() + rootObj.build(rootNode) + # Enable Python to collect the space used by the DOM. + doc = None + sys.stdout.write('from index import *\n\n') + sys.stdout.write('rootObj = doxygenindex(\n') + rootObj.exportLiteral(sys.stdout, 0, name_="doxygenindex") + sys.stdout.write(')\n') + return rootObj + + +def main(): + args = sys.argv[1:] + if len(args) == 1: + parse(args[0]) + else: + usage() + + + + +if __name__ == '__main__': + main() + #import pdb + #pdb.run('main()') + diff --git a/doc/breathe/parser/doxygen/indexsuper.pyc b/doc/breathe/parser/doxygen/indexsuper.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8576b837b321cea4d8ab54abea24693b2ac5955e GIT binary patch literal 21320 zcmeHPTW}oNSw1}@jWlD)l5euTyV;#6SxZSaRxVHrYpr*Ekv9(O@ota3-c@#)jHX*s zOQRXNyJgD|ha@(Ef^aD)po$a)yg<0T@kAA`RPo3Y_uCUMJn}{r1>g6bzKneLCZQ)O zB%NR9oIcZY{`24ebGpm_Iayo(&RbVICixk~|JPBXYmPA<{v6XaW;v@nX4z4H$#hF* zt8A9b#^JcK+9PIp#5lJOYsiS{j+(8CS*{r8TJMAz@yE<&&4jUWmdEj_QR98YcolQk zm^;S2hhaU(yz7mb<*M<<*}YsdUR9NS#;d6^VZ42+Od1dM=Z!bXrf#s`c>9e%WmYl8 zsjPR}c+#(&0m&za4V37d|8oD+0VE3s~UbfAG_o$10n63}7qh1zvy4c8s8- z(f54YnnLRhzvqYT*!QC5&bA-ACG=%PW8*AJbRNLR3@wQqa~I?)CFEkgta@4fBMFVz z4@zKaqw231w>e+IjbaqjDFd)@qUTT|&h0CXX=-kbd9=(t2gJM(`Q6pHhDy-e-icdY zJ8lm&d+jaXegGp(6ap-~8LWiu@YceG5EpOu!_8>nty}SWzjtyq?OAxo52K*pixxh2 z^5unYu(GhN5o|?4?09^>=Tr`Mrgp=lQ!4*X<-e zIf<`b?T1_KxD~}=&|5pk$#4yglcCF|&>cqwLI8|sn)B>!Xy}Vxj=4+BT}qD2bt@jj z{g_39VbF{HH9vd?Jx`6|>JXzik)ycU?YHCSJ`92hGm?9Uj)ntV>h*V4y8iPY2E%BG zNjSizEB$`gZ};jsiu2To@i;)MMYYjtNsqKzTYYb*i>Au~E(f?(0xBJMAArRe6~Bmp(T+Mn(4jIR>#<1HaOS%orQU_Mx#O7g9~?5bOXe%aY(Sx_ z%eg*ju0dC)s)(AWjvr|z-8*de)_m1&hR}^xHFK@{JMn7JwU@g74Zj=nivw>rU$BDK zN|cS(`!_E_PxskXJa z{FON(?}5!5-P=vT$eb1z17 zVgQ%UgnOKTHdj=3pJkI4s(A8}n3lZl7|zeiMYJPgKS<#TXTmvNnk?0F@uRK~t$!00 z$Xg;)@{ORXAZzq=&xtJPgxqDFKW4lUQKbptBXyd+%jvjEI<9QOEp_5!12PGZnS{RQ zj=w;<>rR#_W|~rol)Z+VIoA=zx0aD7qG->}ky3MWZe~s2pUsKN5wo+T@9eCVPcp$O z+{a-jrgezl#cZR)0LH06V2?QCrF|v-XDz0^y%g;F-no7+ZU=}bIvmO$uGCqS=r(|# z1`rG#Y|v0*SO=ooKmmao`^QLi1aj<0z=qHdA~$N55vn2PLu`gX4ndj?6{Yrszby>7*Tudwsg!0KqV#9yJ;y5w)I_+fL~?{x4f{ZK;AqC{^2_^HA32APg1vZQ66EXyj%_QCbBD{D${A! zBJmq&qGZPBd2?%wWP)B{^Atc%w4&(68T=fI{AFu@I$VadXgMf1*>VgZFI^@rz~MQ9 zg`*|ejQm)ciC-joDCUXH>aZ!caZDbHP1t-Z!zLvW|398g?D!C$Rfr5B z!7`M7HATsqiOh4brgsrnU1q@C(*&;(yiRZiAXj{<6(m;fk7Fv|M2YCPR-A()Hmo3& z!98!cUFcQSiyilf|D&*m?iv&q+)+vrGslJ!3Yrg*7UGCgFa zY?!I5Y4}8RmF>G>x2_aIW}aLJE?$49=h=+W2*$c(X?F=Ar*To_F{_`K|qGpf<|iEY+%yBs-^29g+o5DCUj?|(``qQ&9#i8yB)4Y zEiK&UP1Oru4ozmY-HDMI_&v-p^JJz=Pi*i-*CEnL)HyUFDIfj;@j@|A>6-~JkyJc9 z6zr>bi$*_1?hhZ198+cBS)@I{#b8$G8J=a>!>mLqt^l;Rw|$6gj_w>fi)T;Lvh8^p zy5B+D(vp&zmUHYq0AQ6BFb2Ad1GtJiML>Q;zP7Sm+BzSSq!y!O?5y})N*WUwRF#1^GZ?UOwlHqIrJy5|98Q?Gln~8q&lkcz_>q=s{JKcGRCjGDr;*;VRlF)C zIfTidp`v|zW-KP1X=lc{-!gs*gDkx)8N#_eO;Nc-6sYIJXUT?_HvpdBk3yiRI ztL@Ik_XAujd_CN2n8lx?XoJi+Q}%Qe8J2Sw(>74CivR}0ek?Zuzepp4HL-PwFgW!N zxY{zVwgAc16!(hR7$eKFy?32tipFvGjO`dsxYPr(@JnwlU0P~fX*DjNU$QCI#HZG< zix}p9nLyg&P1FXGWIxFZ*dMYQq`$IJJny+*!gT%uC1JaR*nyn@>ow*Na(oYa%)8 zsa8}Vau)OXEtH6xwKml|RjH0nB->a?)HznIRLd?zEI$uPLFR`e3bKzd5Sz+V3N`_u zHn9hp{UPMU&gK7k$eC?<+T*LsIAXeA;q752kf(_av0$NEkg&au3WSYn1(gSFZekS} zpME}#Pe&A=+D%X3ox8TYuk7b096TxK&|eKarJAjArOUge#CfjI-F0-j0l^6Z*s38= zQ{>UVLP-v)Sho0H$E@Tp$(;=V-eB_!0Q~Yooh+9!|JNuVCNL!xhsYUL;_GjS3(C_5 zqrxROp=$CrqEJyPY!MUqTa>+SFRhp)dJGlX!CWvEhe@tf8^M6WSxlye`2wpC{w~9Z ztDP3%^T-fISmgv73guy~XolL~KOD6u$rTVKSI$O`=5S;QYM2?b1eSvTkfB*dEiIzp zV{-%|8$V+AjhZ zm@$JR%>H!`W^^HGo3KdV-pN620dYdAsME0QP@a7rDl?cC}(*H>h4DF$=kTNjZT}1pni~xKalAj zo^-^&V|K~D)Rc29O-WSHo3Y~WqH%9Z;_ZQy#M|6RL^5Lcc?~Pu$1D&dDRYKg#ml&O z{iM0Z4uo2xriYA%5_5Tu2z%TG%+SCtY11A1GctD8m1Nk{n8BBBX*0+yVU0lOjC5|DdFZyUGhhLSd1+#@ed{ ziv*hlU4ktFWSorKC)g&qPQYgphcg@EVP=1c5`7%NW4z>3@AfGDci5 zuOFI(#dwAg4N+Poj1O_hDOh6N=mEyCglE?$y>s$~eJB;o%@kwq~C2Mx!T zs4VQh42zT`{Qr2e3}bjCZ($-sh%3#KA@nR7uv_rSV5J_tt4+mbH+SgvyG?*$5-7%Z zlSEX;s*oM*AG#p$FxQibxkv3X|9=pu6G-XHI~4Ul!-X5y!VLt0d-4%X7~C7PeV0LC zvW;KHod-fU9j16t)aKG9us$efc26Yc?y&C$z&uK^jwmCp7r3O{Wj2bkY{d2O&F9C& zSr3Y-s6mD^u%f5@Unm3H%sA5gpl#;Sh(xVjjqtLWSL*he+xp^LdfCiryjrIIrTV9% z`UmyJpvR}@TYTTb>DuM(m@lt+rN$RE;Ck|NHS+6tS53Wn=H0q|U(HMPUO!e}@-m>L z|75L$uhmaxT4vD1#NYUW%}LlJDE9Co$29cxZ2n4utIacSEVZsIy?aG(eTZ&F+Wqx+ zgE(hE)e71vQ)*&|3%fv8WCUoOQTzNk8+1J7Brw4N#BEv&IhE|?4mdUSfU_p{1QpCL z#^ES0QZpMkH*Sx5BEf^yjO|5E2+uKl*d*7(U3W?)2bY_A4M`(9iZ5M!4J556N7-JT z{p`ul%+_B!U87%OB+fc`k-Tz9N=rwh_}p-W7ZmxPzuMA6Ve?A#@MA(+wAcA7uix3( z!b8VPU7!Elv%K>~f-e)CC)fqh5vnN0YhhxSCk52@cendttaw-1p`dpG+^4fzR9U#U zlI~%@AM-eujy1D!d1WK#fP#qc-o^}ngmgcM3QrnUdHMy9^-UwmH}(U?1@2D+0~cPO zeFAWR*d)7%ZJ*n8zsfNWqp|xlyh`f2Ujwjo9Y;-X3&CTb?l*Yt4#8axKq=OY{46GL z<_Ty>YbZ(Pw7*A^oJ+Qq_dSxGiuIk6GpD#3_P6Si-8vr3g*??iS*u0I za3v9y`m6Op37;Pje-U2KY=5GbQ(dh6q@?x-Jtx=7SNg^HyKr{h-m2XB7*8zS z!R?{Vn=)-s%Qf}cXKA}Sd^K3h__$Y>^8c!c+TE**v2 z;K<)W=RirS8t=NowbsDl#CZmkxe36QV}CoACWmP{iMIzbTCm#(GAMZWUGmaE`OkVM zm7dVLDCS-YL$Ek00-lShYnFDwb-i|Xsn_XyR5GNe`w@aV!7RbY0AzA-a?+IfSjZ1D9pSr>Qd4g{d(9z6SU$ufPj~05-zEkWpeT?XH06cp+?Mzq8&S7V& obhKWnR7a}g)v4CT$X^bB4M&O`l!aI~>jqXJ%*4&aU(KrSkC~2Zy1W{Tw{+VCb75 zky3r7UMuy~Qjw)%TlK)$>Wv7WJats$%%v*}>57V0Rl8cCl{c1BbLcU*rL z8G+wq1h><&+p6E)b^Qa+ z#R3{`yWMQv!$(itcKOG{ru(n2D1K0XSl`}n`1Qli{#~!>?#$HxOMX7i`<=brJe$^=v&Tuy~ZEijLCC<8mNrshp*o~tfAlqE%d<&&`6p0?5bJfkVc@Nb%$Wy)@ zm|#(F)JNTArLKX*d8I*Z)*EF;iM@8!rowHIb}}3f;>vL_iUx63>7`l49LJSjGKh5r z!pgj=$*7mgbR2}ob7@F$anN1^Lth0sv(%YVJ{VgVAPkPG46G%d&4*xviAnwQ*3BxU z;E=91dOIMYcw z(zWllzON0EZfz_YeA9`EZ;XTRd2kf#S~rUWEWL)1!dUAq=oR6__mfd#eE&Ll&5)E` zvZ`ce(}cV4n=&N6KTM;^fUj%v8l|D{dsJSAF5HF0@4>J77(?PNSOwc~6?G(jJ3To) zibuc?*Lq*7A5xva1%kfB%K|}f-UdTxWfz=ggGg)>Jm0c5NQgO0NV zhop5K-;GfUe+EiHdNvsmER0rC{W3%Ge4@pCMEzOsAxiyT5SlbQtuh*qv3VsDR>N=g^TT^ERzH&o4>gJ0L_2}dg-{yv!bHhb3 z0#ilR$5)_5u~V8!`d~`xwWX%zxjQg$SEicvB2$l~o=kfS3&Cm#rz#g|cz}fIsFxfW zHmBK+n>PXN>vWQZvGf5{cc`UMg4vLpGxp!<83J+HY%_2yn}xYTZ~1rU;bA_3TmvBS z+%a}IQIlq3UqThw7%n0hkIf}K=O&~<8Nuke^Uk~v6;AouWRuWLvRGEzO9xS$NvFWV zO*}GMB9!J9p>4lqiKu@|z`!mTsNx^3A*P-RgMQjbX6GuQEnd4iv+#6Z$t$_ zGGJ^0{LT#Cs}#~Y@Qmxsnu>r=YzSZ#LQwp}0%jd$QBLE6$p=~sFy>>Y)KE(f`ev(Nx#nH>m7MFAeKZg^L`;I_jt#-gP}hKQT96a z&2{V?9K+USht1!yO3oE~!_LnsIjjghxh{C0k)w$`b}%`2F|jk@pJT{gDA=X7(nd?d q6nLP;C1dX!%u6ZLF0cL4i9LS!e?*)EJimS2zRbvZqOLnvOaA~-u@~0> literal 0 HcmV?d00001 diff --git a/doc/breathe/project.py b/doc/breathe/project.py new file mode 100644 index 0000000..6d2d37a --- /dev/null +++ b/doc/breathe/project.py @@ -0,0 +1,306 @@ + +from .exception import BreatheError + +import os + + +class ProjectError(BreatheError): + pass + + +class NoDefaultProjectError(ProjectError): + pass + + +class AutoProjectInfo(object): + """Created as a temporary step in the automatic xml generation process""" + + def __init__( + self, + name, + source_path, + build_dir, + reference, + source_dir, + config_dir, + domain_by_extension, + domain_by_file_pattern, + match + ): + + self._name = name + self._source_path = source_path + self._build_dir = build_dir + self._reference = reference + self._source_dir = source_dir + self._config_dir = config_dir + self._domain_by_extension = domain_by_extension + self._domain_by_file_pattern = domain_by_file_pattern + self._match = match + + def name(self): + return self._name + + def build_dir(self): + return self._build_dir + + def abs_path_to_source_file(self, file_): + """ + Returns full path to the provide file assuming that the provided path is relative to the + projects conf.py directory as specified in the breathe_projects_source config variable. + """ + + # os.path.join does the appropriate handling if _source_path is an absolute path + return os.path.join(self._config_dir, self._source_path, file_) + + def create_project_info(self, project_path): + """Creates a proper ProjectInfo object based on the information in this AutoProjectInfo""" + + return ProjectInfo( + self._name, + project_path, + self._source_path, + self._reference, + self._source_dir, + self._config_dir, + self._domain_by_extension, + self._domain_by_file_pattern, + self._match + ) + + +class ProjectInfo(object): + + def __init__( + self, + name, + path, + source_path, + reference, + source_dir, + config_dir, + domain_by_extension, + domain_by_file_pattern, + match + ): + + self._name = name + self._project_path = path + self._source_path = source_path + self._reference = reference + self._source_dir = source_dir + self._config_dir = config_dir + self._domain_by_extension = domain_by_extension + self._domain_by_file_pattern = domain_by_file_pattern + self._match = match + + def name(self): + return self._name + + def project_path(self): + return self._project_path + + def source_path(self): + return self._source_path + + def relative_path_to_xml_file(self, file_): + """ + Returns relative path from Sphinx documentation top-level source directory to the specified + file assuming that the specified file is a path relative to the doxygen xml output + directory. + """ + + # os.path.join does the appropriate handling if _project_path is an absolute path + full_xml_project_path = os.path.join(self._config_dir, self._project_path, file_) + + return os.path.relpath( + full_xml_project_path, + self._source_dir + ) + + def sphinx_abs_path_to_file(self, file_): + """ + Prepends os.path.sep to the value returned by relative_path_to_file. + + This is to match Sphinx's concept of an absolute path which starts from the top-level source + directory of the project. + """ + return os.path.sep + self.relative_path_to_xml_file(file_) + + def reference(self): + return self._reference + + def domain_for_file(self, file_): + + domain = "" + extension = file_.split(".")[-1] + + try: + domain = self._domain_by_extension[extension] + except KeyError: + pass + + for pattern, pattern_domain in self._domain_by_file_pattern.items(): + if self._match(file_, pattern): + domain = pattern_domain + + return domain + + +class ProjectInfoFactory(object): + + def __init__(self, source_dir, build_dir, config_dir, match): + + self.source_dir = source_dir + self.build_dir = build_dir + self.config_dir = config_dir + self.match = match + + self.projects = {} + self.default_project = None + self.domain_by_extension = {} + self.domain_by_file_pattern = {} + + self.project_count = 0 + self.project_info_store = {} + self.project_info_for_auto_store = {} + self.auto_project_info_store = {} + + def update( + self, + projects, + default_project, + domain_by_extension, + domain_by_file_pattern, + projects_source, + build_dir + ): + + self.projects = projects + self.default_project = default_project + self.domain_by_extension = domain_by_extension + self.domain_by_file_pattern = domain_by_file_pattern + self.projects_source = projects_source + + # If the breathe config values has a non-empty value for build_dir then use that otherwise + # stick with the default + if build_dir: + self.build_dir = build_dir + + def default_path(self): + + if not self.default_project: + raise NoDefaultProjectError( + "No breathe_default_project config setting to fall back on " + "for directive with no 'project' or 'path' specified." + ) + + try: + return self.projects[self.default_project] + except KeyError: + raise ProjectError( + ("breathe_default_project value '%s' does not seem to be a valid key for the " + "breathe_projects dictionary") % self.default_project + ) + + def create_project_info(self, options): + + name = "" + + if "project" in options: + try: + path = self.projects[options["project"]] + name = options["project"] + except KeyError: + raise ProjectError("Unable to find project '%s' in breathe_projects dictionary" + % options["project"]) + + elif "path" in options: + path = options["path"] + + else: + path = self.default_path() + + try: + return self.project_info_store[path] + except KeyError: + + reference = name + + if not name: + name = "project%s" % self.project_count + reference = path + self.project_count += 1 + + project_info = ProjectInfo( + name, + path, + "NoSourcePath", + reference, + self.source_dir, + self.config_dir, + self.domain_by_extension, + self.domain_by_file_pattern, + self.match + ) + + self.project_info_store[path] = project_info + + return project_info + + def store_project_info_for_auto(self, name, project_info): + """Stores the project info by name for later extraction by the auto directives. + + Stored separately to the non-auto project info objects as they should never overlap. + """ + + self.project_info_for_auto_store[name] = project_info + + def retrieve_project_info_for_auto(self, options): + """Retrieves the project info by name for later extraction by the auto directives. + + Looks for the 'project' entry in the options dictionary. This is a less than ideal API but + it is designed to match the use of 'create_project_info' above for which it makes much more + sense. + """ + + name = options.get('project', self.default_project) + + if name is None: + raise NoDefaultProjectError( + "No breathe_default_project config setting to fall back on " + "for directive with no 'project' or 'path' specified." + ) + + return self.project_info_for_auto_store[name] + + def create_auto_project_info(self, name, source_path): + + key = source_path + + try: + return self.auto_project_info_store[key] + except KeyError: + + reference = name + + if not name: + name = "project%s" % self.project_count + reference = source_path + self.project_count += 1 + + auto_project_info = AutoProjectInfo( + name, + source_path, + self.build_dir, + reference, + self.source_dir, + self.config_dir, + self.domain_by_extension, + self.domain_by_file_pattern, + self.match + ) + + self.auto_project_info_store[key] = auto_project_info + + return auto_project_info diff --git a/doc/breathe/project.pyc b/doc/breathe/project.pyc new file mode 100644 index 0000000000000000000000000000000000000000..489ae42a90d87151d5210884249cb4031c61ca10 GIT binary patch literal 10021 zcmdT~&2t<_74O+ut+cWfe~2dX$z#XrH31N?rk=VK+yDVs{I3dz&zkC~pHe!utL z@4dGFujR$eKkp4P0gcg;xBcaB~%Pwc0>o*&Rh` zJkn8Q7o{=E`ja7=?k;pGshMA(w*EoV&EtG;{k8_9E4z^5U_2qHg+l{xhS?{_JSs%NVuZ{OYu6G`n;p$qRJ&Qk`?3NzH zlcD`zzA)rOAtih)-_yj4Pv9!Q=OpUaCpIfS<^6P!Jua)aaFdf2z)0A6Lqu3_B;NfT( zZ0S_zXk}>tq4cydJ%WN4_mOj&+bBNu)TaOrDh;Wi=}QI8rc}_JlM0$Gsh~M86*L#5 zf@WJPz`6p~Dg4fA8>O8?A+Qu^M<$!(JspjKdxz5QBpLRjev-Rpt_M2TX-`{jc6mF8 zrQOTYL9!*czrgW6J~>IF?p~xHTAdQD_WZ$tK>{7X`>f7W%MFdNOTFz?ZiQ{4FnTzU z3YAA*GrdTDM7>6~>LqfD;@@B>JIeMQ~Pu=+<1i2oaB~O5??~tYe7|jq|-yuCyK^*YBeOxl)Z_e#Iak7BGgy z2=9mm-VyV=v!M3drPM#~A+Wt;od+9EIP^_H)}@?+Zfqb8cm=wQ1OqvJ2HGMZ z2>Osub4HxoJT;l9w`_YzgBbEloG8d@!ethuJ5xg8Kp}M5pIOU>#<(Z@Q(`aT*Iz}q zp(jzk@3lN$_3tX}K}|a>aTdYl^r9%dz#-b1kZK!VWbq1$`n#ky8+%6`p`A6{Wvsu^ zKHv87+YVnwM-P|$&^+A0Wj0V~p^)&_pFcY@0Z-;raQ4EJ@3qNQxLL=;F$9j5sH^DAfopTR4C z9d{oemk987Xvs6LTAUI!?pPQQF}yXkYHqoYtBLC-`` zn}6Wx%0-tPqoN4HGX{A!3O2{vN%}B=$()RIYMrOC+4%BM-`B&yapx(@P>_>~HdOC; z0!^uIbUX&`3%-vmr&>!fV?TSihmc4@qikZw6I)GP5tb>^LE(ijvJi_v;^q7su_%53 zFAy6;1G37U6)}fj<2Wq_30H(b?0`j@vE8t=8|6+^tb~i=cJ5$Mk_l?zVxtY$R}m9_ z&P|Te;2j1DsHUgR7hLn7xS`s}ja-j)+BZRF*0?uo2El2u|M%nJL_;cMqu?Liy-GsW zy11sb#cH+>w;@gZ!vqo$6#xOhJJfQ$xXWZ}45=H}SWoHzN00OPA6yqF~W9>*PM}aY)SU{8I-% zWOB!6X6bJ~t5)r>$RLu`MzHt@6{JsKn81*MU1U%IM5IqHJo44v>5@IO-B5SZ)2fN6 zVRupGZ!6F9QcvA|cvWul6(Xj6rEdLvMSa{*kDBU{qt+;B@VXW!G4n4b13~e}~I(&lKFQ z{2uz-qv&~6Qm5#jM(Wd<+WZG~zBYy8))_jnK5t;k@Ovz(*hZvP?4T*K7b0fCqT9nG z9t+>%EL4#h@1|sPC*wXcnT=5({i|nnBS9A=f!7)cr=DGR@v0vu7 zjJ8(tZCNmgk(uk_AcaX8z`9_=Otn2oz+}@bSSe((5@2|R)M};9tgV>=UiqZ=Io`E$ z$*h2cYlGQrV6+~QR&{j{BjYwq`oXT=lXsH>l~a{Kz=C?r5aGPR>5_nk&M*`(yv7Pwlo;{;}G7xezmY z(0_p}qo|T!eDX^G1NVYo+!bKR*kOdE3)4_z{HG%AwpWSeqGv;j%3l20ANS@<^luClnog0B0?sTwhMbVIWI zY)mMdsca94r@XdUiKGQ*Y{(>Y_%|%Xyn{kDT8$+@^|bdKK-==pqP6TVfn1#gscL~} zvG)wxK=qYe|TGKsfZBkO>1Cm-vT2g0e$gVo`P%RQ_!R7v#bn=cg!1u?81hP-50$!jOf@ z6KvO)F3AtFY!|UKTn{B)`y%9XaL7}f>lAu5Or-OHHvn2VCnPFbo{m{tZp%-+o>Bx8Ku!LIddEJY_yA^`HU&290ozkNyq%(4c>7 zh<_7rTv#;M1& literal 0 HcmV?d00001 diff --git a/doc/breathe/renderer/rst/__init__.py b/doc/breathe/renderer/rst/__init__.py new file mode 100644 index 0000000..139597f --- /dev/null +++ b/doc/breathe/renderer/rst/__init__.py @@ -0,0 +1,2 @@ + + diff --git a/doc/breathe/renderer/rst/__init__.pyc b/doc/breathe/renderer/rst/__init__.pyc new file mode 100644 index 0000000000000000000000000000000000000000..434f51a23936bd15468d4b96d494cb968d2e46b1 GIT binary patch literal 197 zcmZ9G!3x4K42COu5W)A@#Ra^05!uO;$UyX3x;478tsO~4_C~&+FJLNqG4TH(ANfh9 zujQh7mgic1Ya+c6@l4Drb;=SsW@75k*b9S$tH{s@don#f0<{d~7@Oep>yN+%iCypv z>wE*9t6=zSq={X`)nMw@+>oInG_gS-^cD#Th$Cq2yo*}rlA6oOZ6EBt!(DoeMd}R< CXft>K literal 0 HcmV?d00001 diff --git a/doc/breathe/renderer/rst/doxygen/__init__.py b/doc/breathe/renderer/rst/doxygen/__init__.py new file mode 100644 index 0000000..0dcc0b8 --- /dev/null +++ b/doc/breathe/renderer/rst/doxygen/__init__.py @@ -0,0 +1,383 @@ + +from .base import Renderer, RenderContext +from . import index as indexrenderer +from . import compound as compoundrenderer + +from docutils import nodes +import textwrap + +class RstContentCreator(object): + + def __init__(self, list_type, dedent): + + self.list_type = list_type + self.dedent = dedent + + def __call__(self, text): + + # Remove the first line which is "embed:rst[:leading-asterisk]" + text = "\n".join(text.split(u"\n")[1:]) + + # Remove starting whitespace + text = self.dedent(text) + + # Inspired by autodoc.py in Sphinx + result = self.list_type() + for line in text.split("\n"): + result.append(line, "") + + return result + +class UnicodeRenderer(Renderer): + + def render(self): + + # Skip any nodes that are pure whitespace + # Probably need a better way to do this as currently we're only doing + # it skip whitespace between higher-level nodes, but this will also + # skip any pure whitespace entries in actual content nodes + # + # We counter that second issue slightly by allowing through single white spaces + # + if self.data_object.strip(): + return [self.node_factory.Text(self.data_object)] + elif self.data_object == unicode(" "): + return [self.node_factory.Text(self.data_object)] + else: + return [] + +class NullRenderer(Renderer): + + def __init__(self): + pass + + def render(self): + return [] + + +class DoxygenToRstRendererFactory(object): + + def __init__( + self, + node_type, + renderers, + renderer_factory_creator, + node_factory, + project_info, + state, + document, + rst_content_creator, + filter_, + target_handler, + domain_directive_factory + ): + + self.node_type = node_type + self.node_factory = node_factory + self.project_info = project_info + self.renderers = renderers + self.renderer_factory_creator = renderer_factory_creator + self.state = state + self.document = document + self.rst_content_creator = rst_content_creator + self.filter_ = filter_ + self.target_handler = target_handler + self.domain_directive_factory = domain_directive_factory + + def create_renderer( + self, + context + ): + + parent_data_object = context.node_stack[1] + data_object = context.node_stack[0] + + if not self.filter_.allow(context.node_stack): + return NullRenderer() + + child_renderer_factory = self.renderer_factory_creator.create_child_factory( + self.project_info, + data_object, + self + ) + + try: + node_type = data_object.node_type + except AttributeError as e: + + # Horrible hack to silence errors on filtering unicode objects + # until we fix the parsing + if type(data_object) == unicode: + node_type = "unicode" + else: + raise e + + Renderer = self.renderers[node_type] + + common_args = [ + self.project_info, + context, + child_renderer_factory, + self.node_factory, + self.state, + self.document, + self.target_handler, + self.domain_directive_factory + ] + + if node_type == "docmarkup": + + creator = self.node_factory.inline + if data_object.type_ == "emphasis": + creator = self.node_factory.emphasis + elif data_object.type_ == "computeroutput": + creator = self.node_factory.literal + elif data_object.type_ == "bold": + creator = self.node_factory.strong + elif data_object.type_ == "superscript": + creator = self.node_factory.superscript + elif data_object.type_ == "subscript": + creator = self.node_factory.subscript + elif data_object.type_ == "center": + print("Warning: does not currently handle 'center' text display") + elif data_object.type_ == "small": + print("Warning: does not currently handle 'small' text display") + + return Renderer( + creator, + *common_args + ) + + if node_type == "verbatim": + + return Renderer( + self.rst_content_creator, + *common_args + ) + + if node_type == "compound": + + kind = data_object.kind + if kind in ["file", "dir", "page", "example", "group"]: + return Renderer(indexrenderer.FileRenderer, *common_args) + + class_ = indexrenderer.CompoundTypeSubRenderer + + # For compound node types Renderer is CreateCompoundTypeSubRenderer + # as defined below. This could be cleaner + return Renderer( + class_, + *common_args + ) + + if node_type == "memberdef": + + if data_object.kind in ("function", "slot") or (data_object.kind == 'friend' and data_object.argsstring): + Renderer = compoundrenderer.FuncMemberDefTypeSubRenderer + elif data_object.kind == "enum": + Renderer = compoundrenderer.EnumMemberDefTypeSubRenderer + elif data_object.kind == "typedef": + Renderer = compoundrenderer.TypedefMemberDefTypeSubRenderer + elif data_object.kind == "variable": + Renderer = compoundrenderer.VariableMemberDefTypeSubRenderer + elif data_object.kind == "define": + Renderer = compoundrenderer.DefineMemberDefTypeSubRenderer + + if node_type == "param": + return Renderer( + parent_data_object.node_type != "templateparamlist", + *common_args + ) + + if node_type == "docsimplesect": + if data_object.kind == "par": + Renderer = compoundrenderer.ParDocSimpleSectTypeSubRenderer + + return Renderer( + *common_args + ) + +class CreateCompoundTypeSubRenderer(object): + + def __init__(self, parser_factory): + + self.parser_factory = parser_factory + + def __call__(self, class_, project_info, *args): + + compound_parser = self.parser_factory.create_compound_parser(project_info) + return class_(compound_parser, project_info, *args) + + +class CreateRefTypeSubRenderer(object): + + def __init__(self, parser_factory): + + self.parser_factory = parser_factory + + def __call__(self, project_info, *args): + + compound_parser = self.parser_factory.create_compound_parser(project_info) + return compoundrenderer.RefTypeSubRenderer(compound_parser, project_info, *args) + + +class DoxygenToRstRendererFactoryCreator(object): + + def __init__( + self, + node_factory, + parser_factory, + domain_directive_factory, + rst_content_creator, + project_info + ): + + self.node_factory = node_factory + self.parser_factory = parser_factory + self.domain_directive_factory = domain_directive_factory + self.rst_content_creator = rst_content_creator + self.project_info = project_info + + def create_factory(self, node_stack, state, document, filter_, target_handler): + + data_object = node_stack[0] + + renderers = { + "doxygen" : indexrenderer.DoxygenTypeSubRenderer, + "compound" : CreateCompoundTypeSubRenderer(self.parser_factory), + "doxygendef" : compoundrenderer.DoxygenTypeSubRenderer, + "compounddef" : compoundrenderer.CompoundDefTypeSubRenderer, + "sectiondef" : compoundrenderer.SectionDefTypeSubRenderer, + "memberdef" : compoundrenderer.MemberDefTypeSubRenderer, + "enumvalue" : compoundrenderer.EnumvalueTypeSubRenderer, + "linkedtext" : compoundrenderer.LinkedTextTypeSubRenderer, + "description" : compoundrenderer.DescriptionTypeSubRenderer, + "param" : compoundrenderer.ParamTypeSubRenderer, + "docreftext" : compoundrenderer.DocRefTextTypeSubRenderer, + "docheading" : compoundrenderer.DocHeadingTypeSubRenderer, + "docpara" : compoundrenderer.DocParaTypeSubRenderer, + "docmarkup" : compoundrenderer.DocMarkupTypeSubRenderer, + "docparamlist" : compoundrenderer.DocParamListTypeSubRenderer, + "docparamlistitem" : compoundrenderer.DocParamListItemSubRenderer, + "docparamnamelist" : compoundrenderer.DocParamNameListSubRenderer, + "docparamname" : compoundrenderer.DocParamNameSubRenderer, + "docsect1" : compoundrenderer.DocSect1TypeSubRenderer, + "docsimplesect" : compoundrenderer.DocSimpleSectTypeSubRenderer, + "doctitle" : compoundrenderer.DocTitleTypeSubRenderer, + "docformula" : compoundrenderer.DocForumlaTypeSubRenderer, + "docimage" : compoundrenderer.DocImageTypeSubRenderer, + "docurllink" : compoundrenderer.DocURLLinkSubRenderer, + "listing" : compoundrenderer.ListingTypeSubRenderer, + "codeline" : compoundrenderer.CodeLineTypeSubRenderer, + "highlight" : compoundrenderer.HighlightTypeSubRenderer, + "templateparamlist" : compoundrenderer.TemplateParamListRenderer, + "inc" : compoundrenderer.IncTypeSubRenderer, + "ref" : CreateRefTypeSubRenderer(self.parser_factory), + "verbatim" : compoundrenderer.VerbatimTypeSubRenderer, + "mixedcontainer" : compoundrenderer.MixedContainerRenderer, + "unicode" : UnicodeRenderer, + "doclist": compoundrenderer.DocListTypeSubRenderer, + "doclistitem": compoundrenderer.DocListItemTypeSubRenderer, + } + + try: + node_type = data_object.node_type + except AttributeError as e: + + # Horrible hack to silence errors on filtering unicode objects + # until we fix the parsing + if type(data_object) == unicode: + node_type = "unicode" + else: + raise e + + return DoxygenToRstRendererFactory( + "root", + renderers, + self, + self.node_factory, + self.project_info, + state, + document, + self.rst_content_creator, + filter_, + target_handler, + self.domain_directive_factory + ) + + def create_child_factory( self, project_info, data_object, parent_renderer_factory ): + + try: + node_type = data_object.node_type + except AttributeError as e: + + # Horrible hack to silence errors on filtering unicode objects + # until we fix the parsing + if type(data_object) == unicode: + node_type = "unicode" + else: + raise e + + return DoxygenToRstRendererFactory( + node_type, + parent_renderer_factory.renderers, + self, + self.node_factory, + parent_renderer_factory.project_info, + parent_renderer_factory.state, + parent_renderer_factory.document, + self.rst_content_creator, + parent_renderer_factory.filter_, + parent_renderer_factory.target_handler, + parent_renderer_factory.domain_directive_factory + ) + + +# FactoryFactoryFactory. Ridiculous but necessary. +class DoxygenToRstRendererFactoryCreatorConstructor(object): + + def __init__( + self, + node_factory, + parser_factory, + domain_directive_factory, + rst_content_creator + ): + + self.node_factory = node_factory + self.parser_factory = parser_factory + self.domain_directive_factory = domain_directive_factory + self.rst_content_creator = rst_content_creator + + def create_factory_creator(self, project_info, document, options, target_handler): + + return DoxygenToRstRendererFactoryCreator( + self.node_factory, + self.parser_factory, + self.domain_directive_factory, + self.rst_content_creator, + project_info, + ) + + +def format_parser_error(name, error, filename, state, lineno, do_unicode_warning): + + warning = '%s: Unable to parse xml file "%s". ' % (name, filename) + explanation = 'Reported error: %s. ' % error + + unicode_explanation_text = "" + unicode_explanation = [] + if do_unicode_warning: + unicode_explanation_text = textwrap.dedent(""" + Parsing errors are often due to unicode errors associated with the encoding of the original + source files. Doxygen propagates invalid characters from the input source files to the + output xml.""").strip().replace("\n", " ") + unicode_explanation = [nodes.paragraph("", "", nodes.Text(unicode_explanation_text))] + + return [nodes.warning("", + nodes.paragraph("", "", nodes.Text(warning)), + nodes.paragraph("", "", nodes.Text(explanation)), + *unicode_explanation + ), + state.document.reporter.warning(warning + explanation + unicode_explanation_text, line=lineno) + ] diff --git a/doc/breathe/renderer/rst/doxygen/__init__.pyc b/doc/breathe/renderer/rst/doxygen/__init__.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8ae1c1796dc04aef4a46ef32f39f18f5ab21a15a GIT binary patch literal 12815 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 J-_wQ5{|Q<>{4D?g literal 0 HcmV?d00001 diff --git a/doc/breathe/renderer/rst/doxygen/base.py b/doc/breathe/renderer/rst/doxygen/base.py new file mode 100644 index 0000000..9506751 --- /dev/null +++ b/doc/breathe/renderer/rst/doxygen/base.py @@ -0,0 +1,127 @@ + +class Renderer(object): + + def __init__(self, + project_info, + context, + renderer_factory, + node_factory, + state, + document, + target_handler, + domain_directive_factory, + ): + + self.project_info = project_info + self.context = context + self.data_object = context.node_stack[0] + self.renderer_factory = renderer_factory + self.node_factory = node_factory + self.state = state + self.document = document + self.target_handler = target_handler + self.domain_directive_factory = domain_directive_factory + + if self.context.domain == '': + self.context.domain = self.get_domain() + + def get_domain(self): + """Returns the domain for the current node.""" + + def get_filename(node): + """Returns the name of a file where the declaration represented by node is located.""" + try: + return node.location.file + except AttributeError: + return None + + node_stack = self.context.node_stack + node = node_stack[0] + # An enumvalue node doesn't have location, so use its parent node for detecting the domain instead. + if type(node) == unicode or node.node_type == "enumvalue": + node = node_stack[1] + filename = get_filename(node) + if not filename and node.node_type == "compound": + file_data = self.compound_parser.parse(node.refid) + filename = get_filename(file_data.compounddef) + return self.project_info.domain_for_file(filename) if filename else '' + + def get_fully_qualified_name(self): + + names = [] + node_stack = self.context.node_stack + node = node_stack[0] + if node.node_type == 'enumvalue': + names.append(node.name) + # Skip the name of the containing enum because it is not a part of the fully qualified name. + node_stack = node_stack[2:] + + # If the node is a namespace, use its name because namespaces are skipped in the main loop. + if node.node_type == 'compound' and node.kind == 'namespace': + names.append(node.name) + + for node in node_stack: + if node.node_type == 'ref' and len(names) == 0: + return node.valueOf_ + if (node.node_type == 'compound' and node.kind not in ['file', 'namespace']) or \ + node.node_type == 'memberdef': + # We skip the 'file' entries because the file name doesn't form part of the + # qualified name for the identifier. We skip the 'namespace' entries because if we + # find an object through the namespace 'compound' entry in the index.xml then we'll + # also have the 'compounddef' entry in our node stack and we'll get it from that. We + # need the 'compounddef' entry because if we find the object through the 'file' + # entry in the index.xml file then we need to get the namespace name from somewhere + names.insert(0, node.name) + if (node.node_type == 'compounddef' and node.kind == 'namespace'): + # Nested namespaces include their parent namespace(s) in compoundname. ie, + # compoundname is 'foo::bar' instead of just 'bar' for namespace 'bar' nested in + # namespace 'foo'. We need full compoundname because node_stack doesn't necessarily + # include parent namespaces and we stop here in case it does. + names.insert(0, node.compoundname) + break + + return '::'.join(names) + + def create_template_node(self, decl): + """Creates a node for the ``template <...>`` part of the declaration.""" + if not decl.templateparamlist: + return None + context = self.context.create_child_context(decl.templateparamlist) + renderer = self.renderer_factory.create_renderer(context) + nodes = [self.node_factory.Text("template <")] + nodes.extend(renderer.render()) + nodes.append(self.node_factory.Text(">")) + signode = self.node_factory.desc_signature() + signode.extend(nodes) + return signode + + def run_domain_directive(self, kind, names): + domain_directive = self.renderer_factory.domain_directive_factory.create( + self.context.domain, [kind, names] + self.context.directive_args[2:]) + + # Translate Breathe's no-link option into the standard noindex option. + if 'no-link' in self.context.directive_args[2]: + domain_directive.options['noindex'] = True + nodes = domain_directive.run() + + # Filter out outer class names if we are rendering a member as a part of a class content. + signode = nodes[1].children[0] + if len(names) > 0 and self.context.child: + signode.children = [n for n in signode.children if not n.tagname == 'desc_addname'] + return nodes + + +class RenderContext(object): + + def __init__(self, node_stack, mask_factory, directive_args, domain='', child=False): + self.node_stack = node_stack + self.mask_factory = mask_factory + self.directive_args = directive_args + self.domain = domain + self.child = child + + def create_child_context(self, data_object): + + node_stack = self.node_stack[:] + node_stack.insert(0, self.mask_factory.mask(data_object)) + return RenderContext(node_stack, self.mask_factory, self.directive_args, self.domain, True) diff --git a/doc/breathe/renderer/rst/doxygen/base.pyc b/doc/breathe/renderer/rst/doxygen/base.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cefbec028e6c239aa96dea93bc8279a31129da12 GIT binary patch literal 5173 zcmd5=-EJGl6`omAlt@XoW7kU51~OBm4H3X(Q=kay8m=2BLE5IOv22>eK(b!$4yEPK zE^ zyPe~|J^Ub3t3M6=dmoSc5t>{nqtsZdT&pjYdZyIJk1&Yp*~a;7r1GX3_BJ5ox6s6< z%#Ahnd|!>pxA3^1puwixM^XF{L}m9!4erdDrpjgKM;qLgGc6T|&9gSd`9ydg;Bin& zooaQeRDw<<9SkEik&XBHqM=UlL#L@u@k3`ro#Ka1OP%6}&ZauW51lP_iXS>{wiB%; z9V#}Bl>MX3Y|{|oRnk$Vm}%H+K##)$jq+@IJM6Jp*lJ=jpA_Y|@|&2*s?wXM-gnS1 ztK1~cr`gnRW0>!CGKC%)1plB!r}|XXXbq0*7-|Oi*jLYkH+>*G|tS%G0h(Hs4*pC9w(Oj z=CYV4ig}J6p3pdp-r)UWWK(-Gc-N+L^Lb^bZt(ELA6I36T+a-CZ>%e-(hYvxe{(P^ zMuUZ{;K&u;++M&)>5*}Rku|A5HiOzY1MB=Cub!S9nQ|~no#{i8N+qy);S=0CwBJLc zw%fX`ui-iW8(r5KvB~3b-2*)CA7}z7&jeW$!ND281x!V1|E!@r1`YL0E8ieA+*X5)EDZ694K)E4vCSqoJ_A4@hRH1%HVHMr*Zy4= zw~0#(v2vKV;Cs9aN5jX)FKy|%uu(T$Vs~6w8D>ihtNAV=)R%Mf?8MNJ(yyU8xgy)k ziH9GS*HsfoopzM{zS3I5D#MT1^oRua5Y6+SD{;NuYTQk`<6>sIpC5w*f*vNDr8f1r z;I1_bYaG-td3SUox^xTIomClNoc9lVya%~JnSzMmk2?ykf8o6?MoVwrv9_}E?yxFN zk4KRaPj~qUr0>&@s5k9$3u8xEs;Hr_=v^Jif{tU#<@~dBwlsyDfs3+gzNnUE9&@Hg zp9*d#wvpy!VT4YWWs%{)o*M}@c)q#%+#bmywGIrxdzP;BtQi-%uulE0+yn;~;T2T? zIdX!Y_&aGOzR89v#NR<97ge88l;9vClU@29#Jf=NWjv0Wsz!TrM|YxEVEY}tr*G<& z@AE9Qp7{QoF!+&D-{AOKyqW$fEI>DZk1jfq@B-h5D{3-CL)`*b&|AaWrug`Y3=z_T z%VT&!6ar7bB5%C?$zK&HW+mMc>93RrH)wtX?#FLqsZho6YhU?y{grJs-Bj*B^)6c? z^I!Ss7Pp`jRF0HhE83PtU({O!MKOe;=Q3@PdHCcDh2MvHM`%d&8cNIyF)$|G77{I9 zL@$67PT;`e29(LrHjZDYU(L;YWGwM_fGJ10J9h%b@N$SKC-|}SS|AMB1}o9#W*NIFa$e|!BFnRy+u8l3>eofY`5`}ZC{?t=L|W0Qo%bvWufW-aU0o`ievFywCn(A7qePv^73`S=D_2pfCSN+ud4 z*>N$;lT~gf*-_x&@V3rXBx4e2{f;Rht&M+)Sa!pz_y_1pq|1%V5?36RDI&UAQ?P81 z;|xIy#*6v`0i%cqPJ#o4zZKE&IZM^HPN>-j&^@qo)YeVmsPWDj`xPU#o47o$KU`FNwAuj_t3XlP(nA9e4k{MCUr@$hD1%V$gC&@NE|U8sacn0MFFDDdPD8+)h{b{a2$AK%b&+Eqcp z(bhu5U9B6bsK1QV^QAfpbFP*=H6w}fVI+Bg$1woWHBpSABW{>T z?!g%h;c4g~VuWfO^%F`F$>a~^KNBR-N^G8|Zd#YC@z1esOoYd8qgfMUh|BNu#f2r9 zy3~SHFyf(vT!K0;KqctXfHa$!>>YH-R!SX&iW5x7d<|1|=tYQR;s#$1CS4Js*bt!< zuKJ8YlD81jvECNC!8ot8M+*rP(5msTIkmReeGJ2$l0IT`uZXVEd|5yyn*M;t(O4?# z=$Cas$uBXCe}zW)>fLnaOmIp{to6QBFQk?EpCOJJZ7aIEc_>B};tv1iBaSM!@$FDq RIPY#?xqAeYB<6dI{{!EGom>C_ literal 0 HcmV?d00001 diff --git a/doc/breathe/renderer/rst/doxygen/compound.py b/doc/breathe/renderer/rst/doxygen/compound.py new file mode 100644 index 0000000..ec82e19 --- /dev/null +++ b/doc/breathe/renderer/rst/doxygen/compound.py @@ -0,0 +1,1004 @@ + +from .base import Renderer +from .index import CompoundRenderer + +class DoxygenTypeSubRenderer(Renderer): + + def render(self): + + context = self.context.create_child_context(self.data_object.compounddef) + compound_renderer = self.renderer_factory.create_renderer(context) + return compound_renderer.render() + + +class CompoundDefTypeSubRenderer(Renderer): + + # We store both the identified and appropriate title text here as we want to define the order + # here and the titles for the SectionDefTypeSubRenderer but we don't want the repetition of + # having two lists in case they fall out of sync + sections = [ + ("user-defined", "User Defined"), + ("public-type", "Public Types"), + ("public-func", "Public Functions"), + ("public-attrib", "Public Members"), + ("public-slot", "Public Slots"), + ("signal", "Signal"), + ("dcop-func", "DCOP Function"), + ("property", "Property"), + ("event", "Event"), + ("public-static-func", "Public Static Functions"), + ("public-static-attrib", "Public Static Attributes"), + ("protected-type", "Protected Types"), + ("protected-func", "Protected Functions"), + ("protected-attrib", "Protected Attributes"), + ("protected-slot", "Protected Slots"), + ("protected-static-func", "Protected Static Functions"), + ("protected-static-attrib", "Protected Static Attributes"), + ("package-type", "Package Types"), + ("package-func", "Package Functions"), + ("package-attrib", "Package Attributes"), + ("package-static-func", "Package Static Functions"), + ("package-static-attrib", "Package Static Attributes"), + ("private-type", "Private Types"), + ("private-func", "Private Functions"), + ("private-attrib", "Private Members"), + ("private-slot", "Private Slots"), + ("private-static-func", "Private Static Functions"), + ("private-static-attrib", "Private Static Attributes"), + ("friend", "Friends"), + ("related", "Related"), + ("define", "Defines"), + ("prototype", "Prototypes"), + ("typedef", "Typedefs"), + ("enum", "Enums"), + ("func", "Functions"), + ("var", "Variables"), + ] + + def render(self): + + nodelist = [] + + if self.data_object.briefdescription: + context = self.context.create_child_context(self.data_object.briefdescription) + renderer = self.renderer_factory.create_renderer(context) + nodelist.extend(renderer.render()) + + if self.data_object.detaileddescription: + context = self.context.create_child_context(self.data_object.detaileddescription) + renderer = self.renderer_factory.create_renderer(context) + nodelist.extend(renderer.render()) + + section_nodelists = {} + + # Get all sub sections + for sectiondef in self.data_object.sectiondef: + context = self.context.create_child_context(sectiondef) + renderer = self.renderer_factory.create_renderer(context) + child_nodes = renderer.render() + if not child_nodes: + # Skip empty section + continue + kind = sectiondef.kind + node = self.node_factory.container(classes=['breathe-sectiondef']) + node.document = self.state.document + node['objtype'] = kind + node.extend(child_nodes) + # We store the nodes as a list against the kind in a dictionary as the kind can be + # 'user-edited' and that can repeat so this allows us to collect all the 'user-edited' + # entries together + nodes = section_nodelists.setdefault(kind, []) + nodes += [node] + + # Order the results in an appropriate manner + for kind, _ in self.sections: + nodelist.extend(section_nodelists.get(kind, [])) + + # Take care of innerclasses + for innerclass in self.data_object.innerclass: + context = self.context.create_child_context(innerclass) + renderer = self.renderer_factory.create_renderer(context) + nodelist.extend(renderer.render()) + + for innernamespace in self.data_object.innernamespace: + context = self.context.create_child_context(innernamespace) + renderer = self.renderer_factory.create_renderer(context) + nodelist.extend(renderer.render()) + + return nodelist + + +class SectionDefTypeSubRenderer(Renderer): + + section_titles = dict(CompoundDefTypeSubRenderer.sections) + + def render(self): + + node_list = [] + + if self.data_object.description: + context = self.context.create_child_context(self.data_object.description) + renderer = self.renderer_factory.create_renderer(context) + node_list.extend(renderer.render()) + + # Get all the memberdef info + for memberdef in self.data_object.memberdef: + context = self.context.create_child_context(memberdef) + renderer = self.renderer_factory.create_renderer(context) + node_list.extend(renderer.render()) + + if node_list: + + text = self.section_titles[self.data_object.kind] + + # Override default name for user-defined sections. Use "Unnamed + # Group" if the user didn't name the section + # This is different to Doxygen which will track the groups and name + # them Group1, Group2, Group3, etc. + if self.data_object.kind == "user-defined": + if self.data_object.header: + text = self.data_object.header + else: + text = "Unnamed Group" + + # Use rubric for the title because, unlike the docutils element "section", + # it doesn't interfere with the document structure. + rubric = self.node_factory.rubric(text=text, classes=['breathe-sectiondef-title']) + + return [rubric] + node_list + + return [] + + +class MemberDefTypeSubRenderer(Renderer): + + def create_doxygen_target(self): + """Can be overridden to create a target node which uses the doxygen refid information + which can be used for creating links between internal doxygen elements. + + The default implementation should suffice most of the time. + """ + + refid = "%s%s" % (self.project_info.name(), self.data_object.id) + return self.target_handler.create_target(refid) + + def title(self): + + nodes = [] + + # Variable type or function return type + if self.data_object.type_: + context = self.context.create_child_context(self.data_object.type_) + renderer = self.renderer_factory.create_renderer(context) + nodes.extend(renderer.render()) + + if nodes: + nodes.append(self.node_factory.Text(" ")) + + nodes.append(self.node_factory.desc_name(text=self.data_object.name)) + + return nodes + + def description(self): + + nodes = [] + + if self.data_object.briefdescription: + context = self.context.create_child_context(self.data_object.briefdescription) + renderer = self.renderer_factory.create_renderer(context) + nodes.extend(renderer.render()) + + if self.data_object.detaileddescription: + context = self.context.create_child_context(self.data_object.detaileddescription) + renderer = self.renderer_factory.create_renderer(context) + nodes.extend(renderer.render()) + + return nodes + + def objtype(self): + """Return the type of the rendered object.""" + return self.data_object.kind + + def declaration(self): + """Return the declaration of the rendered object.""" + return self.get_fully_qualified_name() + + def update_signature(self, signode): + """Update the signature node if necessary, e.g. add qualifiers.""" + prefix = self.objtype() + ' ' + annotation = self.node_factory.desc_annotation(prefix, prefix) + if signode[0].tagname != 'desc_name': + signode[0] = annotation + else: + signode.insert(0, annotation) + + def render(self): + nodes = self.run_domain_directive(self.objtype(), [self.declaration().replace('\n', ' ')]) + node = nodes[1] + signode = node[0] + contentnode = node[-1] + self.update_signature(signode) + signode.insert(0, self.create_doxygen_target()) + contentnode.extend(self.description()) + return nodes + + +class FuncMemberDefTypeSubRenderer(MemberDefTypeSubRenderer): + + def update_signature(self, signode): + + # Note whether a member function is virtual + if self.data_object.virt != 'non-virtual': + signode.insert(0, self.node_factory.Text('virtual ')) + + # Add CV-qualifiers + if self.data_object.const == 'yes': + signode.append(self.node_factory.Text(' const')) + # The doxygen xml output doesn't seem to properly register 'volatile' as the xml attribute + # 'volatile' so we have to check the argsstring for the moment. Maybe it'll change in + # doxygen at some point. Registered as bug: + # https://bugzilla.gnome.org/show_bug.cgi?id=733451 + if self.data_object.volatile == 'yes' or self.data_object.argsstring.endswith('volatile'): + signode.append(self.node_factory.Text(' volatile')) + + # Add `= 0` for pure virtual members. + if self.data_object.virt == 'pure-virtual': + signode.append(self.node_factory.Text(' = 0')) + + def render(self): + # Get full function signature for the domain directive. + params = [] + for param in self.data_object.param: + param = self.context.mask_factory.mask(param) + param_type = [] + for p in param.type_.content_: + value = p.value + if not isinstance(value, unicode): + value = value.valueOf_ + param_type.append(value) + param_type = ' '.join(param_type) + param_name = param.declname if param.declname else param.defname + params.append(param_type if not param_name else param_type + ' ' + param_name) + signature = '{0}({1})'.format(self.data_object.definition, ', '.join(params)) + # Remove 'virtual' keyword as Sphinx 1.2 doesn't support virtual functions. + virtual = 'virtual ' + if signature.startswith(virtual): + signature = signature[len(virtual):] + self.context.directive_args[1] = [signature] + + nodes = self.run_domain_directive(self.data_object.kind, self.context.directive_args[1]) + node = nodes[1] + signode, contentnode = node.children + signode.insert(0, self.create_doxygen_target()) + self.update_signature(signode) + contentnode.extend(self.description()) + + template_node = self.create_template_node(self.data_object) + if template_node: + node.insert(0, template_node) + return nodes + + +class DefineMemberDefTypeSubRenderer(MemberDefTypeSubRenderer): + + def declaration(self): + decl = self.data_object.name + if self.data_object.param: + decl += "(" + for i, parameter in enumerate(self.data_object.param): + if i: + decl += ", " + decl += parameter.defname + decl += ")" + return decl + + def update_signature(self, signode): + pass + + def description(self): + + return MemberDefTypeSubRenderer.description(self) + + +class EnumMemberDefTypeSubRenderer(MemberDefTypeSubRenderer): + + def declaration(self): + + # Sphinx requires a name to be a valid identifier, so replace anonymous enum name of the form @id + # generated by Doxygen with "anonymous". + name = self.get_fully_qualified_name() + return name.replace("@", "__anonymous") if self.data_object.name.startswith("@") else name + + def description(self): + + description_nodes = MemberDefTypeSubRenderer.description(self) + + name = self.node_factory.emphasis("", self.node_factory.Text("Values:")) + title = self.node_factory.paragraph("", "", name) + description_nodes.append(title) + + enums = [] + for item in self.data_object.enumvalue: + context = self.context.create_child_context(item) + renderer = self.renderer_factory.create_renderer(context) + enums.extend(renderer.render()) + + description_nodes.extend(enums) + + return description_nodes + + def update_signature(self, signode): + # Replace "type" with "enum" in the signature. This is needed because Sphinx cpp domain doesn't have an enum + # directive and we use a type directive instead. + signode.children[0][0] = self.node_factory.Text("enum ") + if self.data_object.name.startswith("@"): + signode.children[1][0] = self.node_factory.strong(text="[anonymous]") + + +class TypedefMemberDefTypeSubRenderer(MemberDefTypeSubRenderer): + + def declaration(self): + decl = self.data_object.definition + typedef = "typedef " + if decl.startswith(typedef): + decl = decl[len(typedef):] + return decl + + +class VariableMemberDefTypeSubRenderer(MemberDefTypeSubRenderer): + + def declaration(self): + decl = self.data_object.definition + enum = 'enum ' + return decl[len(enum):] if decl.startswith(enum) else decl + + def update_signature(self, signode): + pass + + +class EnumvalueTypeSubRenderer(MemberDefTypeSubRenderer): + + def objtype(self): + + return 'enumvalue' + + def update_signature(self, signode): + # Remove "class" from the signature. This is needed because Sphinx cpp domain doesn't have an enum value + # directive and we use a class directive instead. + signode.children.pop(0) + initializer = self.data_object.initializer + if initializer: + context = self.context.create_child_context(initializer) + renderer = self.renderer_factory.create_renderer(context) + nodes = renderer.render() + separator = ' ' + if not nodes[0].startswith('='): + separator += '= ' + signode.append(self.node_factory.Text(separator)) + signode.extend(nodes) + + +class DescriptionTypeSubRenderer(Renderer): + + def render(self): + + nodelist = [] + + # Get description in rst_nodes if possible + for item in self.data_object.content_: + context = self.context.create_child_context(item) + renderer = self.renderer_factory.create_renderer(context) + nodelist.extend(renderer.render()) + + return nodelist + + +class LinkedTextTypeSubRenderer(Renderer): + + def render(self): + + nodelist = [] + + # Recursively process where possible + for i, entry in enumerate(self.data_object.content_): + context = self.context.create_child_context(entry) + renderer = self.renderer_factory.create_renderer(context) + nodelist.extend(renderer.render()) + + return nodelist + + +class ParamTypeSubRenderer(Renderer): + + def __init__( + self, + output_defname, + *args + ): + + Renderer.__init__( self, *args ) + + self.output_defname = output_defname + + def render(self): + + nodelist = [] + + # Parameter type + if self.data_object.type_: + context = self.context.create_child_context(self.data_object.type_) + renderer = self.renderer_factory.create_renderer(context) + nodelist.extend(renderer.render()) + + # Parameter name + if self.data_object.declname: + if nodelist: nodelist.append(self.node_factory.Text(" ")) + nodelist.append(self.node_factory.emphasis(text=self.data_object.declname)) + + elif self.output_defname and self.data_object.defname: + # We only want to output the definition name (from the cpp file) if the declaration name + # (from header file) isn't present + if nodelist: nodelist.append(self.node_factory.Text(" ")) + nodelist.append(self.node_factory.emphasis(text=self.data_object.defname)) + + # array information + if self.data_object.array: + nodelist.append(self.node_factory.Text(self.data_object.array)) + + # Default value + if self.data_object.defval: + nodelist.append(self.node_factory.Text(" = ")) + context = self.context.create_child_context(self.data_object.defval) + renderer = self.renderer_factory.create_renderer(context) + nodelist.extend(renderer.render()) + + return nodelist + + + +class DocRefTextTypeSubRenderer(Renderer): + + def render(self): + + nodelist = [] + + for item in self.data_object.content_: + context = self.context.create_child_context(item) + renderer = self.renderer_factory.create_renderer(context) + nodelist.extend(renderer.render()) + + for item in self.data_object.para: + context = self.context.create_child_context(item) + renderer = self.renderer_factory.create_renderer(context) + nodelist.extend(renderer.render()) + + refid = "%s%s" % (self.project_info.name(), self.data_object.refid) + nodelist = [ + self.node_factory.pending_xref( + "", + reftype="ref", + refdomain="std", + refexplicit=True, + refid=refid, + reftarget=refid, + *nodelist + ) + ] + + return nodelist + + +class DocParaTypeSubRenderer(Renderer): + """ + tags in the Doxygen output tend to contain either text or a single other tag of interest. + So whilst it looks like we're combined descriptions and program listings and other things, in + the end we generally only deal with one per para tag. Multiple neighbouring instances of these + things tend to each be in a separate neighbouring para tag. + """ + + def render(self): + + nodelist = [] + for item in self.data_object.content: # Description + context = self.context.create_child_context(item) + renderer = self.renderer_factory.create_renderer(context) + nodelist.extend(renderer.render()) + + for item in self.data_object.programlisting: # Program listings + context = self.context.create_child_context(item) + renderer = self.renderer_factory.create_renderer(context) + nodelist.extend(renderer.render()) + + for item in self.data_object.images: # Images + context = self.context.create_child_context(item) + renderer = self.renderer_factory.create_renderer(context) + nodelist.extend(renderer.render()) + + definition_nodes = [] + for item in self.data_object.simplesects: # Returns, user par's, etc + context = self.context.create_child_context(item) + renderer = self.renderer_factory.create_renderer(context) + definition_nodes.extend(renderer.render()) + + for item in self.data_object.parameterlist: # Parameters/Exceptions + context = self.context.create_child_context(item) + renderer = self.renderer_factory.create_renderer(context) + definition_nodes.extend(renderer.render()) + + if definition_nodes: + definition_list = self.node_factory.definition_list("", *definition_nodes) + nodelist.append(definition_list) + + return [self.node_factory.paragraph("", "", *nodelist)] + + +class DocImageTypeSubRenderer(Renderer): + """Output docutils image node using name attribute from xml as the uri""" + + def render(self): + + path_to_image = self.project_info.sphinx_abs_path_to_file( + self.data_object.name + ) + + options = { "uri" : path_to_image } + + return [self.node_factory.image("", **options)] + +class DocMarkupTypeSubRenderer(Renderer): + + def __init__( + self, + creator, + *args + ): + + Renderer.__init__( self, *args ) + + self.creator = creator + + def render(self): + + nodelist = [] + + for item in self.data_object.content_: + context = self.context.create_child_context(item) + renderer = self.renderer_factory.create_renderer(context) + nodelist.extend(renderer.render()) + + return [self.creator("", "", *nodelist)] + + +class DocParamListTypeSubRenderer(Renderer): + """Parameter/Exception documentation""" + + lookup = { + "param" : "Parameters", + "exception" : "Exceptions", + "templateparam" : "Templates", + "retval" : "Return Value", + } + + def render(self): + + nodelist = [] + for item in self.data_object.parameteritem: + context = self.context.create_child_context(item) + renderer = self.renderer_factory.create_renderer(context) + nodelist.extend(renderer.render()) + + # Fild list entry + nodelist_list = self.node_factory.bullet_list("", classes=["breatheparameterlist"], *nodelist) + + term_text = self.lookup[self.data_object.kind] + term = self.node_factory.term("", "", self.node_factory.strong( "", term_text ) ) + definition = self.node_factory.definition('', nodelist_list) + + return [self.node_factory.definition_list_item('', term, definition)] + + +class DocParamListItemSubRenderer(Renderer): + """ Parameter Description Renderer """ + + def render(self): + + nodelist = [] + for item in self.data_object.parameternamelist: + context = self.context.create_child_context(item) + renderer = self.renderer_factory.create_renderer(context) + nodelist.extend(renderer.render()) + + term = self.node_factory.literal("","", *nodelist) + + separator = self.node_factory.Text(" - ") + + nodelist = [] + + if self.data_object.parameterdescription: + context = self.context.create_child_context(self.data_object.parameterdescription) + renderer = self.renderer_factory.create_renderer(context) + nodelist.extend(renderer.render()) + + return [self.node_factory.list_item("", term, separator, *nodelist)] + +class DocParamNameListSubRenderer(Renderer): + """ Parameter Name Renderer """ + + def render(self): + + nodelist = [] + for item in self.data_object.parametername: + context = self.context.create_child_context(item) + renderer = self.renderer_factory.create_renderer(context) + nodelist.extend(renderer.render()) + + return nodelist + +class DocParamNameSubRenderer(Renderer): + + def render(self): + + nodelist = [] + for item in self.data_object.content_: + context = self.context.create_child_context(item) + renderer = self.renderer_factory.create_renderer(context) + nodelist.extend(renderer.render()) + + return nodelist + +class DocSect1TypeSubRenderer(Renderer): + + def render(self): + + return [] + + +class DocSimpleSectTypeSubRenderer(Renderer): + """Other Type documentation such as Warning, Note, Returns, etc""" + + def title(self): + + text = self.node_factory.Text(self.data_object.kind.capitalize()) + + return [self.node_factory.strong( "", text )] + + def render(self): + + nodelist = [] + for item in self.data_object.para: + context = self.context.create_child_context(item) + renderer = self.renderer_factory.create_renderer(context) + nodelist.append(self.node_factory.paragraph("", "", *renderer.render())) + + term = self.node_factory.term("", "", *self.title()) + definition = self.node_factory.definition("", *nodelist) + + return [self.node_factory.definition_list_item("", term, definition)] + + +class ParDocSimpleSectTypeSubRenderer(DocSimpleSectTypeSubRenderer): + + def title(self): + + context = self.context.create_child_context(self.data_object.title) + renderer = self.renderer_factory.create_renderer(context) + + return [self.node_factory.strong( "", *renderer.render() )] + + +class DocTitleTypeSubRenderer(Renderer): + + def render(self): + + nodelist = [] + + for item in self.data_object.content_: + context = self.context.create_child_context(item) + renderer = self.renderer_factory.create_renderer(context) + nodelist.extend(renderer.render()) + + return nodelist + + +class DocForumlaTypeSubRenderer(Renderer): + + def render(self): + + nodelist = [] + + for item in self.data_object.content_: + + latex = item.getValue() + + # Somewhat hacky if statements to strip out the doxygen markup that slips through + + node = None + + # Either inline + if latex.startswith("$") and latex.endswith("$"): + latex = latex[1:-1] + + # If we're inline create a math node like the :math: role + node = self.node_factory.math() + else: + # Else we're multiline + node = self.node_factory.displaymath() + + # Or multiline + if latex.startswith("\[") and latex.endswith("\]"): + latex = latex[2:-2:] + + # Here we steal the core of the mathbase "math" directive handling code from: + # sphinx.ext.mathbase + node["latex"] = latex + + # Required parameters which we don't have values for + node["label"] = None + node["nowrap"] = False + node["docname"] = self.state.document.settings.env.docname + + nodelist.append(node) + + return nodelist + + +class ListingTypeSubRenderer(Renderer): + + def render(self): + + lines = [] + nodelist = [] + for i, item in enumerate(self.data_object.codeline): + # Put new lines between the lines. There must be a more pythonic way of doing this + if i: + nodelist.append(self.node_factory.Text("\n")) + context = self.context.create_child_context(item) + renderer = self.renderer_factory.create_renderer(context) + nodelist.extend(renderer.render()) + + # Add blank string at the start otherwise for some reason it renders + # the pending_xref tags around the kind in plain text + block = self.node_factory.literal_block( + "", + "", + *nodelist + ) + + return [block] + +class CodeLineTypeSubRenderer(Renderer): + + def render(self): + + nodelist = [] + for item in self.data_object.highlight: + context = self.context.create_child_context(item) + renderer = self.renderer_factory.create_renderer(context) + nodelist.extend(renderer.render()) + + return nodelist + +class HighlightTypeSubRenderer(Renderer): + + def render(self): + + nodelist = [] + for item in self.data_object.content_: + context = self.context.create_child_context(item) + renderer = self.renderer_factory.create_renderer(context) + nodelist.extend(renderer.render()) + + return nodelist + +class TemplateParamListRenderer(Renderer): + + def render(self): + + nodelist = [] + + for i, item in enumerate(self.data_object.param): + if i: + nodelist.append(self.node_factory.Text(", ")) + context = self.context.create_child_context(item) + renderer = self.renderer_factory.create_renderer(context) + nodelist.extend(renderer.render()) + + return nodelist + +class IncTypeSubRenderer(Renderer): + + def render(self): + + if self.data_object.local == u"yes": + text = '#include "%s"' % self.data_object.content_[0].getValue() + else: + text = '#include <%s>' % self.data_object.content_[0].getValue() + + return [self.node_factory.emphasis(text=text)] + + +class RefTypeSubRenderer(CompoundRenderer): + + def __init__(self, compound_parser, *args): + CompoundRenderer.__init__(self, compound_parser, False, *args) + + def get_node_info(self, file_data): + name = self.data_object.content_[0].getValue() + name = name.rsplit("::", 1)[-1] + return name, file_data.compounddef.kind + + +class VerbatimTypeSubRenderer(Renderer): + + def __init__(self, content_creator, *args): + Renderer.__init__(self, *args) + + self.content_creator = content_creator + + def render(self): + + if not self.data_object.text.strip().startswith("embed:rst"): + + # Remove trailing new lines. Purely subjective call from viewing results + text = self.data_object.text.rstrip() + + # Handle has a preformatted text + return [self.node_factory.literal_block(text, text)] + + # do we need to strip leading asterisks? + # NOTE: We could choose to guess this based on every line starting with '*'. + # However This would have a side-effect for any users who have an rst-block + # consisting of a simple bullet list. + # For now we just look for an extended embed tag + if self.data_object.text.strip().startswith("embed:rst:leading-asterisk"): + + lines = self.data_object.text.splitlines() + # Replace the first * on each line with a blank space + lines = map(lambda text: text.replace("*", " ", 1), lines) + self.data_object.text = "\n".join(lines) + + # do we need to strip leading ///? + elif self.data_object.text.strip().startswith("embed:rst:leading-slashes"): + + lines = self.data_object.text.splitlines() + # Replace the /// on each line with three blank spaces + lines = map(lambda text: text.replace("///", " ", 1), lines) + self.data_object.text = "\n".join(lines) + + rst = self.content_creator(self.data_object.text) + + # Parent node for the generated node subtree + node = self.node_factory.paragraph() + node.document = self.state.document + + # Generate node subtree + self.state.nested_parse(rst, 0, node) + + return node + + +class MixedContainerRenderer(Renderer): + + def render(self): + context = self.context.create_child_context(self.data_object.getValue()) + renderer = self.renderer_factory.create_renderer(context) + return renderer.render() + + +class DocListNestedRenderer(object): + """Decorator for the list type renderer. + + Creates the proper docutils node based on the sub-type + of the underlying data object. Takes care of proper numbering + for deeply nested enumerated lists. + """ + + numeral_kind = ['arabic', 'loweralpha', 'lowerroman', 'upperalpha', 'upperroman'] + + def __init__(self, f): + self.__render = f + self.__nesting_level = 0 + + def __get__(self, obj, objtype): + """ Support instance methods. """ + import functools + return functools.partial(self.__call__, obj) + + def __call__(self, rend_self): + """ Call the wrapped render function. Update the nesting level for the enumerated lists. """ + rend_instance = rend_self + if rend_instance.data_object.node_subtype is "itemized": + val = self.__render(rend_instance) + return DocListNestedRenderer.render_unordered(rend_instance, children=val) + elif rend_instance.data_object.node_subtype is "ordered": + self.__nesting_level += 1 + val = self.__render(rend_instance) + self.__nesting_level -= 1 + return DocListNestedRenderer.render_enumerated(rend_instance, children=val, + nesting_level=self.__nesting_level) + + return [] + + @staticmethod + def render_unordered(renderer, children): + nodelist_list = renderer.node_factory.bullet_list("", *children) + + return [nodelist_list] + + @staticmethod + def render_enumerated(renderer, children, nesting_level): + nodelist_list = renderer.node_factory.enumerated_list("", *children) + idx = nesting_level % len(DocListNestedRenderer.numeral_kind) + nodelist_list['enumtype'] = DocListNestedRenderer.numeral_kind[idx] + nodelist_list['prefix'] = '' + nodelist_list['suffix'] = '.' + + return [nodelist_list] + + +class DocListTypeSubRenderer(Renderer): + """List renderer + + The specifics of the actual list rendering are handled by the + decorator around the generic render function. + """ + + @DocListNestedRenderer + def render(self): + """ Render all the children depth-first. """ + nodelist = [] + for item in self.data_object.listitem: + context = self.context.create_child_context(item) + renderer = self.renderer_factory.create_renderer(context) + nodelist.extend(renderer.render()) + + return nodelist + + +class DocListItemTypeSubRenderer(Renderer): + """List item renderer. + """ + + def render(self): + """ Render all the children depth-first. + Upon return expand the children node list into a docutils list-item. + """ + nodelist = [] + for item in self.data_object.para: + context = self.context.create_child_context(item) + renderer = self.renderer_factory.create_renderer(context) + nodelist.extend(renderer.render()) + + return [self.node_factory.list_item("", *nodelist)] + + +class DocHeadingTypeSubRenderer(Renderer): + """Heading renderer. + + Renders embedded headlines as emphasized text. Different heading levels + are not supported. + """ + + def render(self): + + nodelist = [] + for item in self.data_object.content_: + context = self.context.create_child_context(item) + renderer = self.renderer_factory.create_renderer(context) + nodelist.extend(renderer.render()) + + return [self.node_factory.emphasis("", "", *nodelist)] + + +class DocURLLinkSubRenderer(Renderer): + """Url Link Renderer""" + + def render(self): + + nodelist = [] + for item in self.data_object.content_: + context = self.context.create_child_context(item) + renderer = self.renderer_factory.create_renderer(context) + nodelist.extend(renderer.render()) + + return [self.node_factory.reference("", "", refuri=self.data_object.url, *nodelist)] diff --git a/doc/breathe/renderer/rst/doxygen/compound.pyc b/doc/breathe/renderer/rst/doxygen/compound.pyc new file mode 100644 index 0000000000000000000000000000000000000000..44fa4fe92f4e422203d31ab0582a7a19ef39ad60 GIT binary patch literal 43542 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 U&lcpqr@pEF-ulk^b@d(pAJ3m?1poj5 literal 0 HcmV?d00001 diff --git a/doc/breathe/renderer/rst/doxygen/filter.py b/doc/breathe/renderer/rst/doxygen/filter.py new file mode 100644 index 0000000..328bf89 --- /dev/null +++ b/doc/breathe/renderer/rst/doxygen/filter.py @@ -0,0 +1,1138 @@ +""" +Filters +------- + +Filters are an interesting and somewhat challenging part of the code base. They are used for +two different purposes: + + - To figure out which nodes in the xml hierarchy to start rendering from. These are called + 'finder filters' or 'content filters'. This is done before rendering starts. + - To figure out which nodes under a selected nodes in the xml hierarchy should be rendered. These + are called 'render filters'. This is done during the render process with a test in the + DoxygenToRstRendererFactory. + + +General Implementation +~~~~~~~~~~~~~~~~~~~~~~ + +Filters are essential just tests to see if a node matches certain parameters that are needed to +decide whether or not to include it in some output. + +As these filters are declared once and then used on multiple nodes, we model them as object +hierarchies that encapsulate the required test and take a node (with its context) and return True or +False. + +If you wanted a test which figures out if a node has the node_type 'memberdef' you might create the +following object hierarchy: + + node_is_memberdef = InFilter(AttributeAccessor(Node(), 'node_type'), ['memberdef']) + +This reads from the inside out, as get the node, then get the node_type attribute from it, and see +if the value of the attribute is in the list ['memberdef']. + +The Node() is called a 'Selector'. Parent() is also a selector. It means given the current context, +work with the parent of the current node rather than the node itself. This allows you to frame tests +in terms of a node's parent as well as the node which helps when we want nodes with particular +parents and not others. + +The AttributeAccessor() is called an 'Accessor'. It wraps up an attempt to access a particular +attribute on the selected node. There are quite a few different specific accessors but they can +mostly be generalised with the AttributeAccessor. This code has evolved over time and initially the +implementation involved specific accessor classes (which are still used in large parts of it.) + +The InFilter() is unsurprisingly called a 'Filter'. There are lots of different filters. Filters +either act on the results of Accessors or on the results of other Filters and they always return +True or False. The AndFilter and the OrFilter can be used to combine the outputs of other Filters +with logical 'and' and 'or' operations. + +You can build up some pretty complex expressions with this level of freedom as you +might imagine. The complexity is unfortunate but necessary as the nature of filtering the xml is +quite complex. + + +Finder Filters +~~~~~~~~~~~~~~ + +The implementation of the filters can change a little depending on how they are called. Finder +filters are called from the breathe.finder.doxygen.index and breathe.finder.doxygen.compound files. +They are called like this: + + # Descend down the hierarchy + # ... + + if filter_.allow(node_stack): + matches.append(self.data_object) + + # Keep on descending + # ... + +This means that the result of the filter does not stop us descending down the hierarchy and testing +more nodes. This simplifies the filters as they only have to return true for the exact nodes they +are interested in and they don't have to worry about allowing the iteration down the hierarchy to +continue for nodes which don't match. + +An example of a finder filter is: + + AndFilter( + InFilter(NodeTypeAccessor(Node()), ["compound"]), + InFilter(KindAccessor(Node()), ["group"]), + InFilter(NameAccessor(Node()), ["mygroup"]) + ) + +This says, return True for all the nodes of node_type 'compound' with 'kind' set to 'group' which +have the name 'mygroup'. It returns false for everything else, but when a node matching this is +found then it is added to the matches list by the code above. + +It is therefore relatively easy to write finder filters. If you have two separate node filters like +the one above and you want to match on both of them then you can do: + + OrFilter( + node_filter_1, + node_filter_2 + ) + +To combine them. + + +Content Filters +~~~~~~~~~~~~~~~ + +Content filters are harder than the finder filters as they are responsible for halting the iteration +down the hierarchy if they return false. This means that if you're interested in memberdef nodes +with a particular attribute then you have to check for that but also include a clause which allows +all other non-memberdef nodes to pass through as you don't want to interrupt them. + +This means you end up with filters like this: + + OrFilter( + AndFilter( + InFilter(NodeTypeAccessor(Node()), ["compound"]), + InFilter(KindAccessor(Node()), ["group"]), + InFilter(NameAccessor(Node()), ["mygroup"]) + ), + NotFilter( + AndFilter( + InFilter(NodeTypeAccessor(Node()), ["compound"]), + InFilter(KindAccessor(Node()), ["group"]), + ) + ) + ) + +Which is to say that we want to let through a compound, with kind group, with name 'mygroup' but +we're also happy if the node is **not** a compund with kind group. Really we just don't want to let +through any compounds with kind group with name other than 'mygroup'. As such, we can rephrase this +as: + + NotFilter( + AndFilter( + InFilter(NodeTypeAccessor(Node()), ["compound"]), + InFilter(KindAccessor(Node()), ["group"]), + NotFilter(InFilter(NameAccessor(Node()), ["mygroup"])) + ) + ) + +Using logical manipulation we can rewrite this as: + + OrFilter( + NotFilter(InFilter(NodeTypeAccessor(Node()), ["compound"])), + NotFilter(InFilter(KindAccessor(Node()), ["group"])), + InFilter(NameAccessor(Node()), ["mygroup"]) + ) + +We reads: allow if it isn't a compound, or if it is a compound but doesn't have a 'kind' of 'group', +but if it is a compound and has a 'kind' of 'group then only allow it if it is named 'mygroup'. + + +Helper Syntax +~~~~~~~~~~~~~ + +Some of these filter declarations get a little awkward to read and write. They are not laid out in +manner which reads smoothly. Additional helper methods and operator overloads have been introduced +to help with this. + +AttributeAccessor objects are created in property methods on the Selector classes so: + + node.kind + +Where node has been declared as a Node() instance. Results in: + + AttributeAccessor(Node(), 'kind') + +The '==' and '!=' operators on the Accessors have been overloaded to return the appropriate filters +so that: + + node.kind == 'group' + +Results in: + + InFilter(AttributeAccessor(Node(), 'kind'), ['kind']) + +We also override the binary 'and' (&), 'or' (|) and 'not' (~) operators in Python to apply +AndFilters, OrFilters and NotFilters respectively. We have to override the binary operators as they +actual 'and', 'or' and 'not' operators cannot be overridden. So: + + (node.node_type == 'compound') & (node.name == 'mygroup') + +Translates to: + + AndFilter( + InFilter(NodeTypeAccessor(Node()), ["compound"])), + InFilter(NameAccessor(Node()), ["mygroup"]) + ) + +Where the former is hopefully more readable without sacrificing too much to the abstract magic of +operator overloads. + + +Operator Precedences & Extra Parenthesis +'''''''''''''''''''''''''''''''''''''''' + +As the binary operators have a lower operator precedence than '==' and '!=' and some other operators +we have to include additional parenthesis in the expressions to group them as we want. So instead of +writing: + + node.node_type == 'compound' & node.name == 'mygroup' + +We have to write: + + (node.node_type == 'compound') & (node.name == 'mygroup') + +""" + + +class UnrecognisedKindError(Exception): + pass + + +class Selector(object): + + @property + def node_type(self): + return NodeTypeAccessor(self) + + @property + def kind(self): + return AttributeAccessor(self, 'kind') + + @property + def node_name(self): + return AttributeAccessor(self, 'node_name') + + @property + def name(self): + return AttributeAccessor(self, 'name') + + @property + def briefdescription(self): + return AttributeAccessor(self, 'briefdescription') + + @property + def detaileddescription(self): + return AttributeAccessor(self, 'detaileddescription') + + @property + def prot(self): + return AttributeAccessor(self, 'prot') + + @property + def valueOf(self): + return AttributeAccessor(self, 'valueOf_') + + @property + def id(self): + return AttributeAccessor(self, 'id') + + +class Ancestor(Selector): + + def __init__(self, generations): + self.generations = generations + + def __call__(self, node_stack): + return node_stack[self.generations] + + +class Parent(Selector): + + def __call__(self, node_stack): + return node_stack[1] + + +class Node(Selector): + + def __call__(self, node_stack): + return node_stack[0] + + +class Accessor(object): + + def __init__(self, selector): + self.selector = selector + + def __eq__(self, value): + return InFilter(self, [value]) + + def __ne__(self, value): + return NotFilter(InFilter(self, [value])) + + def is_one_of(self, collection): + return InFilter(self, collection) + + def has_content(self): + return HasContentFilter(self) + + def endswith(self, options): + return EndsWithFilter(self, options) + + +class NameAccessor(Accessor): + + def __call__(self, node_stack): + return self.selector(node_stack).name + + +class NodeNameAccessor(Accessor): + """Check the .node_name member which is declared on refTypeSub nodes + + It distinguishes between innerclass, innernamespace, etc. + """ + + def __call__(self, node_stack): + return self.selector(node_stack).node_name + + +class NodeTypeAccessor(Accessor): + + def __call__(self, node_stack): + + data_object = self.selector(node_stack) + try: + return data_object.node_type + except AttributeError as e: + + # Horrible hack to silence errors on filtering unicode objects + # until we fix the parsing + if type(data_object) == unicode: + return "unicode" + else: + raise e + + +class KindAccessor(Accessor): + + def __call__(self, node_stack): + return self.selector(node_stack).kind + + +class AttributeAccessor(Accessor): + """Returns the value of a particular attribute on the selected node. + + AttributeAccessor(Node(), 'name') returns the value of ``node.name``. + """ + + def __init__(self, selector, attribute_name): + Accessor.__init__(self, selector) + + self.attribute_name = attribute_name + + def __call__(self, node_stack): + return getattr(self.selector(node_stack), self.attribute_name) + + +class LambdaAccessor(Accessor): + + def __init__(self, selector, func): + Accessor.__init__(self, selector) + + self.func = func + + def __call__(self, node_stack): + return self.func(self.selector(node_stack)) + + +class NamespaceAccessor(Accessor): + + def __call__(self, node_stack): + return self.selector(node_stack).namespaces + + +class Filter(object): + + def __and__(self, other): + return AndFilter(self, other) + + def __or__(self, other): + return OrFilter(self, other) + + def __invert__(self): + return NotFilter(self) + + +class HasAncestorFilter(Filter): + + def __init__(self, generations): + self.generations = generations + + def allow(self, node_stack): + return len(node_stack) > self.generations + + +class HasContentFilter(Filter): + + def __init__(self, accessor): + self.accessor = accessor + + def allow(self, node_stack): + """Detects if the node in questions has an empty .content_ property. + """ + + return bool(self.accessor(node_stack).content_) + + +class EndsWithFilter(Filter): + """Detects if the string result of the accessor ends with any of the strings in the ``options`` + iterable parameter. + """ + + def __init__(self, accessor, options): + self.accessor = accessor + self.options = options + + def allow(self, node_stack): + string = self.accessor(node_stack) + for entry in self.options: + if string.endswith(entry): + return True + + return False + + +class InFilter(Filter): + """Checks if what is returned from the accessor is 'in' in the members""" + + def __init__(self, accessor, members): + + self.accessor = accessor + self.members = members + + def allow(self, node_stack): + + name = self.accessor(node_stack) + + return name in self.members + + +class GlobFilter(Filter): + + def __init__(self, accessor, glob): + + self.accessor = accessor + self.glob = glob + + def allow(self, node_stack): + + text = self.accessor(node_stack) + return self.glob.match(text) + + +class FilePathFilter(Filter): + + def __init__(self, accessor, target_file, path_handler): + + self.accessor = accessor + self.target_file = target_file + self.path_handler = path_handler + + def allow(self, node_stack): + + location = self.accessor(node_stack).file + + if self.path_handler.includes_directory(self.target_file): + # If the target_file contains directory separators then + # match against the same length at the end of the location + # + location_match = location[-len(self.target_file):] + return location_match == self.target_file + + else: + # If there are no separators, match against the whole filename + # at the end of the location + # + # This is to prevent "Util.cpp" matching "PathUtil.cpp" + # + location_basename = self.path_handler.basename(location) + return location_basename == self.target_file + + +class NamespaceFilter(Filter): + + def __init__(self, namespace_accessor, name_accessor): + + self.namespace_accessor = namespace_accessor + self.name_accessor = name_accessor + + def allow(self, node_stack): + + namespaces = self.namespace_accessor(node_stack) + name = self.name_accessor(node_stack) + + try: + namespace, name = name.rsplit("::", 1) + except ValueError: + namespace, name = "", name + + return namespace in namespaces + + +class OpenFilter(Filter): + + def allow(self, node_stack): + + return True + + +class ClosedFilter(Filter): + + def allow(self, node_stack): + + return False + + +class NotFilter(Filter): + + def __init__(self, child_filter): + self.child_filter = child_filter + + def allow(self, node_stack): + + return not self.child_filter.allow(node_stack) + + +class AndFilter(Filter): + + def __init__(self, *filters): + + self.filters = filters + + def allow(self, node_stack): + + # If any filter returns False then return False + for filter_ in self.filters: + if not filter_.allow(node_stack): + return False + + return True + + +class OrFilter(Filter): + """Provides a short-cutted 'or' operation between two filters""" + + def __init__(self, *filters): + + self.filters = filters + + def allow(self, node_stack): + + # If any filter returns True then return True + for filter_ in self.filters: + if filter_.allow(node_stack): + return True + + return False + + +class IfFilter(Filter): + + def __init__(self, condition, if_true, if_false): + self.condition = condition + self.if_true = if_true + self.if_false = if_false + + def allow(self, node_stack): + + if self.condition.allow(node_stack): + return self.if_true.allow(node_stack) + else: + return self.if_false.allow(node_stack) + + +class Glob(object): + + def __init__(self, method, pattern): + + self.method = method + self.pattern = pattern + + def match(self, name): + + return self.method(name, self.pattern) + + +class GlobFactory(object): + + def __init__(self, method): + + self.method = method + + def create(self, pattern): + + return Glob(self.method, pattern) + + +class Gather(object): + + def __init__(self, accessor, names): + + self.accessor = accessor + self.names = names + + def allow(self, node_stack): + + self.names.extend(self.accessor(node_stack)) + + return False + + +class FilterFactory(object): + + # C++ style public entries + public_kinds = set([ + "public-type", + "public-func", + "public-attrib", + "public-slot", + "public-static-func", + "public-static-attrib", + ]) + + def __init__(self, globber_factory, path_handler): + + self.globber_factory = globber_factory + self.path_handler = path_handler + self.default_members = () + self.implementation_filename_extensions = () + + def create_render_filter(self, kind, options): + """Render filter for group & namespace blocks""" + + if kind not in ['group', 'namespace']: + raise UnrecognisedKindError(kind) + + # Generate new dictionary from defaults + filter_options = dict((entry, u'') for entry in self.default_members) + + # Update from the actual options + filter_options.update(options) + + # Convert the doxygengroup members flag (which just stores None as the value) to an empty + # string to allow the create_class_member_filter to process it properly + if 'members' in filter_options: + filter_options['members'] = u'' + + node = Node() + parent = Parent() + grandparent = Ancestor(2) + has_grandparent = HasAncestorFilter(2) + + non_class_memberdef = \ + has_grandparent \ + & (grandparent.node_type == 'compounddef') \ + & (grandparent.kind != 'class') \ + & (grandparent.kind != 'struct') \ + & (node.node_type == 'memberdef') + + node_is_public = node.prot == 'public' + + non_class_public_memberdefs = non_class_memberdef & node_is_public | ~ non_class_memberdef + + return ( self.create_class_member_filter(filter_options) | non_class_memberdef ) \ + & self.create_innerclass_filter(filter_options) \ + & self.create_outline_filter(filter_options) + + def create_class_filter(self, target, options): + """Content filter for classes based on various directive options""" + + # Generate new dictionary from defaults + filter_options = dict((entry, u'') for entry in self.default_members) + + # Update from the actual options + filter_options.update(options) + + return AndFilter( + self.create_class_member_filter(filter_options), + self.create_innerclass_filter(filter_options, outerclass=target), + self.create_outline_filter(filter_options), + self.create_show_filter(filter_options), + ) + + def create_innerclass_filter(self, options, outerclass=''): + """ + :param outerclass: Should be the class/struct being target by the directive calling this + code. If it is a group or namespace directive then it should be left + blank. It is used when looking for names listed in the :members: option. + + The name should include any additional namespaces that the target class + is in. + """ + + node = Node() + node_is_innerclass = (node.node_type == "ref") & (node.node_name == "innerclass") + + parent = Parent() + parent_is_compounddef = parent.node_type == 'compounddef' + parent_is_class = parent.kind.is_one_of(['class', 'struct']) + + allowed = set() + all_options = { + 'protected-members': 'protected', + 'private-members': 'private', + } + + for option, scope in all_options.iteritems(): + if option in options: + allowed.add(scope) + + node_is_innerclass_in_class = parent_is_compounddef & parent_is_class & node_is_innerclass + + public_innerclass_filter = ClosedFilter() + + if 'members' in options: + + if options['members'].strip(): + + text = options["members"] + + prefix = ('%s::' % outerclass) if outerclass else '' + + # Matches sphinx-autodoc behaviour of comma separated values + members = set(['%s%s' % (prefix, x.strip()) for x in text.split(",")]) + + node_valueOf_is_in_members = node.valueOf.is_one_of(members) + + # Accept any nodes which don't have a "sectiondef" as a parent or, if they do, only + # accept them if their names are in the members list + public_innerclass_filter = ~ node_is_innerclass_in_class | node_valueOf_is_in_members + + else: + allowed.add('public') + + + node_is_in_allowed_scope = node.prot.is_one_of(allowed) + + innerclass = ~ node_is_innerclass_in_class | node_is_in_allowed_scope + description = self._create_description_filter(True, 'compounddef', options) + + # Put parent check last as we only want to check parents of innerclass's otherwise we have + # to check the parent's type as well + return innerclass | public_innerclass_filter | description + + def create_show_filter(self, options): + """Currently only handles the header-file entry""" + + try: + text = options["show"] + except KeyError: + # Allow through everything except the header-file includes nodes + return OrFilter( + NotFilter(InFilter(NodeTypeAccessor(Parent()), ["compounddef"])), + NotFilter(InFilter(NodeTypeAccessor(Node()), ["inc"])) + ) + + if text == "header-file": + # Allow through everything, including header-file includes + return OpenFilter() + + # Allow through everything except the header-file includes nodes + return OrFilter( + NotFilter(InFilter(NodeTypeAccessor(Parent()), ["compounddef"])), + NotFilter(InFilter(NodeTypeAccessor(Node()), ["inc"])) + ) + + def _create_description_filter(self, allow, level, options): + """Whether or not we allow descriptions is determined by the calling function and we just do + whatever the 'allow' function parameter tells us. + """ + + node = Node() + node_is_description = node.node_type == 'description' + parent = Parent() + parent_is_level = parent.node_type == level + + # Nothing with a parent that's a sectiondef + description_filter = ~ parent_is_level + + # Let through any description children of sectiondefs if we output any kind members + if allow: + + description_filter = \ + (parent_is_level & node_is_description) | ~ parent_is_level + + return description_filter + + def _create_public_members_filter(self, options): + + node = Node() + node_is_memberdef = node.node_type == "memberdef" + node_is_public = node.prot == "public" + + parent = Parent() + parent_is_sectiondef = parent.node_type == "sectiondef" + + # Nothing with a parent that's a sectiondef + is_memberdef = parent_is_sectiondef & node_is_memberdef + public_members_filter = ~ is_memberdef + + # If the user has specified the 'members' option with arguments then we only pay attention + # to that and not to any other member settings + if "members" in options: + + if options['members'].strip(): + + text = options["members"] + + # Matches sphinx-autodoc behaviour of comma separated values + members = set([x.strip() for x in text.split(",")]) + + node_name_is_in_members = node.name.is_one_of(members) + + # Accept any nodes which don't have a "sectiondef" as a parent or, if they do, only + # accept them if their names are in the members list + public_members_filter = \ + (parent_is_sectiondef & node_name_is_in_members) | ~ parent_is_sectiondef + + else: + + # Select anything that doesn't have a parent which is a sectiondef, or, if it does, + # only select the public ones + public_members_filter = \ + (is_memberdef & node_is_public) | ~ is_memberdef + + return public_members_filter + + def _create_non_public_members_filter(self, prot, option_name, options): + """'prot' is the doxygen xml term for 'public', 'protected' and 'private' categories.""" + + node = Node() + node_is_memberdef = node.node_type == "memberdef" + node_is_public = node.prot == prot + + parent = Parent() + parent_is_sectiondef = parent.node_type == "sectiondef" + + # Nothing with a parent that's a sectiondef + is_memberdef = parent_is_sectiondef & node_is_memberdef + filter_ = ~ is_memberdef + + if option_name in options: + + # Allow anything that isn't a memberdef, or if it is only allow the public ones + filter_ = ~ is_memberdef | node_is_public + + return filter_ + + def _create_undoc_members_filter(self, options): + + node = Node() + node_is_memberdef = node.node_type == 'memberdef' + + node_has_description = node.briefdescription.has_content() \ + | node.detaileddescription.has_content() + + # Allow anything that isn't a memberdef, or if it is only allow the ones with a description + undoc_members_filter = ~ node_is_memberdef | node_has_description + + if 'undoc-members' in options: + + undoc_members_filter = OpenFilter() + + return undoc_members_filter + + def create_class_member_filter(self, options): + """Content filter based on :members: and :private-members: classes""" + + # I can't fully explain the filtering of descriptions here. More testing needed to figure + # out when it is needed. This approach reflects the old code that was here but it wasn't + # commented (my fault.) I wonder if maybe the public and private declarations themselves can + # be documented and we need to let them through. Not sure. + allow = 'members' in options \ + or 'protected-members' in options \ + or 'private-members' in options + + description = self._create_description_filter(allow, 'sectiondef', options) + + # Create all necessary filters and combine them + public_members = self._create_public_members_filter(options) + + protected_members = self._create_non_public_members_filter( + 'protected', + 'protected-members', + options + ) + + private_members = self._create_non_public_members_filter( + 'private', + 'private-members', + options + ) + + undoc_members = self._create_undoc_members_filter(options) + + # Allow any public/private members which also fit the undoc filter and all the descriptions + allowed_members = ( public_members | protected_members | private_members ) & undoc_members + return allowed_members | description + + def create_outline_filter(self, options): + if 'outline' in options: + node = Node() + return ~ node.node_type.is_one_of(["description", "inc"]) + else: + return OpenFilter() + + def create_file_filter(self, filename, options): + + valid_names = [] + + filter_ = AndFilter( + NotFilter( + # Gather the "namespaces" attribute from the + # compounddef for the file we're rendering and + # store the information in the "valid_names" list + # + # Gather always returns false, so, combined with + # the NotFilter this chunk always returns true and + # so does not affect the result of the filtering + AndFilter( + InFilter(NodeTypeAccessor(Node()), ["compounddef"]), + InFilter(KindAccessor(Node()), ["file"]), + FilePathFilter( + LambdaAccessor(Node(), lambda x: x.location), + filename, self.path_handler + ), + Gather(LambdaAccessor(Node(), lambda x: x.namespaces), valid_names) + ) + ), + NotFilter( + # Take the valid_names and everytime we handle an + # innerclass or innernamespace, check that its name + # was one of those initial valid names so that we + # never end up rendering a namespace or class that + # wasn't in the initial file. Notably this is + # required as the location attribute for the + # namespace in the xml is unreliable. + AndFilter( + InFilter(NodeTypeAccessor(Parent()), ["compounddef"]), + InFilter(NodeTypeAccessor(Node()), ["ref"]), + InFilter(NodeNameAccessor(Node()), ["innerclass", "innernamespace"]), + NotFilter( + InFilter( + LambdaAccessor(Node(), lambda x: x.content_[0].getValue()), + valid_names + ) + ) + ) + ), + NotFilter( + # Ignore innerclasses and innernamespaces that are inside a + # namespace that is going to be rendered as they will be + # rendered with that namespace and we don't want them twice + AndFilter( + InFilter(NodeTypeAccessor(Parent()), ["compounddef"]), + InFilter(NodeTypeAccessor(Node()), ["ref"]), + InFilter(NodeNameAccessor(Node()), ["innerclass", "innernamespace"]), + NamespaceFilter( + NamespaceAccessor(Parent()), + LambdaAccessor(Node(), lambda x: x.content_[0].getValue()) + ) + ) + ), + NotFilter( + # Ignore memberdefs from files which are different to + # the one we're rendering. This happens when we have to + # cross into a namespace xml file which has entries + # from multiple files in it + AndFilter( + InFilter(NodeTypeAccessor(Node()), ["memberdef"]), + NotFilter( + FilePathFilter(LambdaAccessor(Node(), lambda x: x.location), + filename, self.path_handler) + ) + ) + ), + NotFilter( + # Ignore compounddefs which are from another file + # (normally means classes and structs which are in a + # namespace that we have other interests in) but only + # check it if the compounddef is not a namespace + # itself, as for some reason compounddefs for + # namespaces are registered with just a single file + # location even if they namespace is spread over + # multiple files + AndFilter( + InFilter(NodeTypeAccessor(Node()), ["compounddef"]), + NotFilter(InFilter(KindAccessor(Node()), ["namespace"])), + NotFilter( + FilePathFilter(LambdaAccessor(Node(), lambda x: x.location), + filename, self.path_handler) + ) + ) + ) + ) + + return AndFilter( + self.create_outline_filter(options), + filter_ + ) + + def create_content_filter(self, kind, options): + """Returns a filter which matches the contents of the or namespace but not the group or + namepace name or description. + + This allows the groups to be used to structure sections of the documentation rather than to + structure and further document groups of documentation + + As a finder/content filter we only need to match exactly what we're interested in. + """ + + if kind not in ['group', 'namespace']: + raise UnrecognisedKindError(kind) + + node = Node() + + # Filter for public memberdefs + node_is_memberdef = node.node_type == 'memberdef' + node_is_public = node.prot == 'public' + + public_members = node_is_memberdef & node_is_public + + # Filter for public innerclasses + parent = Parent() + parent_is_compounddef = parent.node_type == 'compounddef' + parent_is_class = parent.kind == kind + + node_is_innerclass = (node.node_type == "ref") & (node.node_name == "innerclass") + node_is_public = node.prot == 'public' + + public_innerclass = parent_is_compounddef & parent_is_class \ + & node_is_innerclass & node_is_public + + return public_members | public_innerclass + + def create_index_filter(self, options): + + filter_ = AndFilter( + NotFilter( + AndFilter( + InFilter(NodeTypeAccessor(Parent()), ["compounddef"]), + InFilter(NodeTypeAccessor(Node()), ["ref"]), + InFilter(NodeNameAccessor(Node()), ["innerclass", "innernamespace"]) + ) + ), + NotFilter( + AndFilter( + InFilter(NodeTypeAccessor(Parent()), ["compounddef"]), + InFilter(KindAccessor(Parent()), ["group"]), + InFilter(NodeTypeAccessor(Node()), ["sectiondef"]), + InFilter(KindAccessor(Node()), ["func"]) + ) + ) + ) + + return AndFilter( + self.create_outline_filter(options), + filter_ + ) + + def create_open_filter(self): + """Returns a completely open filter which matches everything""" + + return OpenFilter() + + def create_id_filter(self, node_type, refid): + + node = Node() + return (node.node_type == node_type) & (node.id == refid) + + def create_file_finder_filter(self, filename): + + filter_ = AndFilter( + InFilter(NodeTypeAccessor(Node()), ["compounddef"]), + InFilter(KindAccessor(Node()), ["file"]), + FilePathFilter(LambdaAccessor(Node(), lambda x: x.location), filename, + self.path_handler) + ) + + return filter_ + + def create_member_finder_filter(self, namespace, name, kind): + """Returns a filter which looks for a member with the specified name and kind.""" + + node = Node() + parent = Parent() + + node_matches = (node.node_type == 'member') \ + & (node.kind == kind) \ + & (node.name == name) + + if namespace: + parent_matches = (parent.node_type == 'compound') \ + & ((parent.kind == 'namespace') | (parent.kind == 'class')) \ + & (parent.name == namespace) + + return parent_matches & node_matches + + else: + is_implementation_file = parent.name.endswith(self.implementation_filename_extensions) + parent_is_compound = parent.node_type == 'compound' + parent_is_file = (parent.kind == 'file') & (~ is_implementation_file) + parent_is_not_file = parent.kind != 'file' + + return (parent_is_compound & parent_is_file & node_matches) \ + | (parent_is_compound & parent_is_not_file & node_matches) + + def create_enumvalue_finder_filter(self, name): + """Returns a filter which looks for an enumvalue with the specified name.""" + + node = Node() + return (node.node_type == 'enumvalue') & (node.name == name) + + def create_compound_finder_filter(self, name, kind): + """Returns a filter which looks for a compound with the specified name and kind.""" + + node = Node() + return (node.node_type == 'compound') & (node.kind == kind) & (node.name == name) + + def create_finder_filter(self, kind, name): + """Returns a filter which looks for the compound node from the index which is a group node + (kind=group) and has the appropriate name + + The compound node should reference the group file which we can parse for the group + contents. + """ + + if kind == 'group': + + filter_ = AndFilter( + InFilter(NodeTypeAccessor(Node()), ["compound"]), + InFilter(KindAccessor(Node()), ["group"]), + InFilter(NameAccessor(Node()), [name]) + ) + else: + # Assume kind == 'namespace' + filter_ = AndFilter( + InFilter(NodeTypeAccessor(Node()), ["compound"]), + InFilter(KindAccessor(Node()), ["namespace"]), + InFilter(NameAccessor(Node()), [name]) + ) + + return filter_ + + def get_config_values(self, app): + """Extract the breathe_default_members config value and store it. + + This method is called on the 'builder-init' event in Sphinx""" + + self.default_members = app.config.breathe_default_members + + self.implementation_filename_extensions = \ + app.config.breathe_implementation_filename_extensions + diff --git a/doc/breathe/renderer/rst/doxygen/filter.pyc b/doc/breathe/renderer/rst/doxygen/filter.pyc new file mode 100644 index 0000000000000000000000000000000000000000..13c5acb8f0647776b0746b1d033074d63c2d2c3b GIT binary patch literal 47842 zcmdsgeT*FEdEe~r@p!j9@<>WNi54x5zI;c8I@+==JG7|q%lfcvTAiaLhq1ie+nM7n zxwm_ondR|n(nd?CX<8>vTDJw-6fJ`M(Izcm1WDjO+!RGy)M$YgLFzwZpaoi>DDp>} z7Dd~jEs*|xzxQKi_wFc)QgNdmwWFDLzMl8_exCQ4_ig;Q{ms?C^ZFZ|!2UJx|1ueA|;@~~zTMq{DM}y>`;C$6f0)zV)FX{t4H5!nZyg z#Lv3cMc;Zfh)=rKkNeh-1o0vO*Kks$u0YyFgOJr=~DcCF9*){h49XB^Hx>sucU z;-7S_r+n*ULHs$_`hsr_gZQ*-ebKi*9>hNtEG>w8fAG;DXuj0#cwt_;#V9=9quJyvzZj!ds&gy2E55g?xd-13^NeRYEI#|SG48w4KrOS)( z0`+!29HilVXMnx|4A;n8yLej`#)CfkkO1PO^mx54Tf950L%pXRW=SvU7H)L&)vz7rpr1t|pL}6(bMtD_ zzch%lJQDJf^rdzuAEcX$&1UoEqz@eT!dKVUd&wFQ)Xuwue)AjK{*Cer-ihnGxcS-; zujG3(5h_W-?g}6wGQzcX-dP1%J4u?iL0fQ7do3Xsg3RD7_Pn1YF_4!JnsL(U;--z& z1RYFCxc&f-9-u>=-VkTH>KplzjI%z>(TTHsR01}zwAC~5q#m9fhl75Hyp6}NCjC&% zIp~LL!(QG+mkq^Egd2bq;P!acTG-CQ!SXebwCPx|i!KP>q~B?;XTx4QPk1ee@XoNy z_XzKLPy0GvXnMaOqI7{6@!!q-xIjshe3Pm(l}X}*R$5TS63mvX=34Rt_*s;!3G7$ z^so>z3MT&atZvrw4+>9*ul9}RSU8*KX?J;;Cuck4xk0*c5wBi2ej=RrFwEoVXG(Cq zeZ1L}tO1BPliUjEZa*Wf(W4VY_|*i2wtYFlz5Ym(>0aBt-#n(vTdAj#qzSC>_8aXU zk!lW#%PHzcvGlrN))DxC`AfLd^n@D0s1guheo2BoNaq*B*TGHweBn4R0KEn{ZNz?% zE{3n>;abw}qZi#90GxnyhAD4wgg?>T7^K&Ykn%L-fM=Z^wHFhKVcNz8DINli%uCe> z9!h#ER%=1k4K^|n7_zZKi8AunWG9n!4UFO>a6WVI0+Kh9UXRH3k2T!2n)KFjk~oJT zkpJ{jt5c}(yB)B6+B8rD0YEw>b3jO;C56DP%pqhsZ1%%>$2CAFFt(9GlEUFSo)&^q z$=bR^y)D)PdQ0yu2npFG@FN;miWGW;x&+b)$!v!!$wtZeWb05YE8R|L9zKBf0T=U0 zo1k{Txi-l1-X@hZbR`vHmqtv&%eQUmnWclwAB8ZvG3ec(vbjORbwLhdsN3&SKjOi7 zNV7YlVsX;mvjw&gnhUx$3l|J^*e%#(P)^zlBnBz2iiMz9Kcu%K^5kQ{R~Do z?Pd^n0O1G`&Kqe46)u5%25-HAc~)Vttu|c@&DB{mfq_ByU_78yMFsc@(4&IEkroHg z+gnbHQQVV+96SsDLT{tJnL&wCA2zK%42?b{aN*g0Y+mo~3BR1$2GETJ6HXunox$32 z7nU5)wWdLEjl8%iiuMLqyTC;_4;szux$}_laIg--)B2I0e;RsNFBo=Vw85h?IqLv4 z2O zJsG~1B!s&y(D^v28#9W&I7CK_JeFF#_ScwdCdMMyZ5iPk%(bp42^d>3mLIx;5 zC?;w>@dKRd`P@GZrjJ~_Oz%awb({-bZDek{&cGj}*VOG>7|ffEPBhOKF+jeveaK>) zLTT*YNB{uQu-xF4$$}@R_iQc#QJ3IBIXz|_8~QR&IIer*?c*o5-uW81cDuW-ri0=7 z_P1Pw!QSqcwM}=Ee~ojVGU&+@jx17?Bnyx!(iqf0dbwjgK?n7`(M|K$0p~mnr;O~p zUW8MOyqbpU;K4pUiFpf#vC>92!*8RLDqetoOE)28&^`&;PDokFc_{n*hQv^7&`c|m zSuh4dO!%+xA7bP13wReI$TM4(v4m!XBLs%IA-`Dn;P%u-X+0=vXxYs$X=jQKH&UAY z5xRrztwU|PhiEiQ;8Re&5=}l_pwehk0vQPEo#JEXic=f}BE@+b_QZ;)G+AFx81-a4 zuw3R0RKa8-iq$QjC^)Fx{M-n^N37WzRrz@vzP@B5_)%T{jp73H8ekZ*x!Oh`P;w+k z(POQO(cMr!>o8;8Wrz?N3-P|P07Q!y(&knrO09`&HXUb*ORT;r={H;jbRx7J(-%dM zL1bjcK9@Z|I)*0V;A;%FosL3W*|~1D6Cz2POgZK*R&3Lef_q@o3sO8;lOkiBg8rcY z>=*!~^*Wp{ybRKN74fw3vW>ctV~i`L^U@*RRYZ#*Pf4AVYiMuaGRWC*^cc5HTe)N# z?L<>@{~BuK?t9l#Be%T=O~w04`tjl*H_Ted0k7Dhmpt|UdOGri_tsn9dfW@(=n?eq zTgpyBYk~Ao!yr1i&BaM*>nU=z{34%@>JB*tCS<5}Ln&L^Fsfq7watx$k|Ew*g?35c#Hf!f4~XUeA^k?ZD_v(-QOS0{oU`4-UWF60q@S| zcVUn>7+{4itXOOJyX#C4Aub?644#aEBATF6cC-}RK?cQm501&UlIOekZulwP?eBSa zlz5S$kkElee&>{N@W{e4^>hOb-x{HSZE>ec?NZ+Kb-mY!Tj_rRWkHj-6PMf_*x6T*34zI6+C(Pw=4cwU*<4cEQL^c?jc~}B zXf%PNGFCoPYHwWMfCV=0bQ=jh3NHN=+D98RL9h|ccab?@*N}*4_mO|F7Rw~evb6z( zvA4Mxo{eK96b607uFTlrI%HB;2asbv+QhHGFOv|x0dsA#l*Y(~5i-aWPYDeS}@e+fuKY3`4i?eE4xliwvarMgB5;*wd$NX#Y5N9BPmeFhQW} zW*J2eZHQ!mBAcQG`-D)*=ylqq<7mx!6Zt=y0SlDxV|enE{i-Sojz-uuNhs+%g$vq+@d&edBnk?}*P{hu=;VAbYvK z-rGdrWYa5%Eu2SUxXEiGW@nh9G7k4*2xy!GwjDqPszFcyy4gg~ICR+-3nkgrKv-N3 zHA!JWM#nxjPWp@Cl4B!9p z@5EDwO!(e3ZgJ~-3hazLkeYD0*C5U?4y(Y(%8<5P@jF#On@%|`K6OOa?xf6QD!dvX zGJ!cJJ;kWYS)MXRXO5`@&DnJ5Ep!5di7zYD1x@jKiWC#@j64%C`1zZ-+vd43o&tkD ze~*7|490P#d#x2OXvDz=y62ihq|NMmDMd&Ok4P)I!;J8tQ^j3~4hq)uK7OGRO>SC% zLxBh(x4ua-#+bq zFmZkaH3)C?fw;ldKC{!WL8X2^O$TWQC-hgt_8flM6gCMe6>34Ww7^pfC|wA0Hn&=Y zw$;j;I>4CMu!lo)6`BI=WjXdvezCiZ;n&TRFL8Wc*IhojE)Bz@43_TMb!5-lSCj0dP3WD(s0U)wBt4mC`AM7iJ887);`(Mp5dH;z z86lpm31(+od`Eds9sLe=Oh*&cUj!QXt_7D-h=IeJJDkv=Db>JP6lADagOwXNoYbKy z*}x$RGjMi~yLU>5rgQ^mQJ{gdd)?Wl4owLM&h8_=rvX!kq~MQ`p2sgEx`EVNdgsyt z&t23uKgiv2jl=W#1UAes7R1>#y5#JY7lYp;VC-5@_dRXkNIl(;9n(`#;7%R&2fXs4 zdP9?DdVL6OTdg3w9qqxU0$q;w0*)Wy_nv#|aYa#6ccUrxsZzZokbiJLy(3pvxnq>H ze{(+_qaZG)-DHI+`?R}GPrItr+XqFDsW~l-|LK1ENQ2QehN6O+lX~L67TsDPk4Dn%gj*hq zi;|;Bo+COU>f4CADWdE~x`|8>&2qzM7B)|NyJqVnn(}{zUv?Oq$@=WX=s)%FEMo=~ zk#%s1{)m8c_+=l##`t8h95PnM$`ylK2KR_K>Tu(J-f6g1qkGg+k?n|wM1+~L42{m~ z5%LluYO?}uyM{6AS+m@u)%s(=WL$>Y)_$@prk~e>;Apv*rY}T_x+ecz4wnX?tJ6u2 zfx{*^XU&jbpKi|r~^i0S27i>%R z-b&6Xw1S-AZ_tvoyV&K0rstlP5kt2E8@tA)qDl<_TJ~I^pqD6DDWW|D*!~1R!8%!2 z_`opf11A{XQE7th{g4psVc>C(gB1j$Y`8S*R-(O#vtv@`t%Uii;xfLSXfV)5z#c0+ zN2qQBa|G!SNeb~+k)%!C(UK4*MAS%TqH?v6PnxVM$R}0jeuu)KFdvlD^8}r4f{Crs z#j7^F#tkl)!2bDMr0-w82hH-wD$q&k-c~Dlr`0;RO;@R+)m17ZbTyY#;CqXNjWe3; zp3)LNQyo2mrV?3?@en_=*)_Fmd)!Bw?SXB2?1@Xx^~Aly#7RNfv98HG=%A9DX?aAc z73d`WTU3psgr+rEnJe{^o#2o35@qk63VWrU*;*G{J-~abk`v15zhUUArE30uezeq2 z_K&}NqGx^pSAHHN@NXflZ#&AHjqk^RVW9j&Rt3^d0UTs)GY&xWo5#6%lADiVQ}jc7yC#g$Q2?`#onQn;XVCr2*>JHme$&CR{&2MkZQhG(NL7t+ z25vr-7u43ZQOy<6<|rO4DXc2_iBFUWO_nYZx>A1PJYWkQtZ+MsclwEUrzE{g?|y6( zp=Lje3(l*)j00u#NjC=F@8aqIb@j5?#jbT-kCvx0yX}GL`q0H0*<4cDa-<)7f zY1qy9Db#Y3Z?zTj3}s^YEw z$zUR{2iKcH`dU!C-3V%VgD0U%5DQ(e2kAM+olCbG!Jn-K{aWyqIPhaFG$6x%mqoM- ze4o)abeLs${J@LG4;5PF;M?dKTwq9|o2ZUt@k;gW@W&uIg*M+kMNTdB97#e`8q{ZN zjoQB2?8M>PM7`31EqUPMP6VK^Xm&W3yK}7cftww&M@5yxd50M&hbo($lR)8F2P@RU z6ppv5gAlEW2I3){Wi#VLT*R^LX7NBS=%$b3hALf$DYzcxT59~?|v4|Rp=w>-)argR;yR)B3Xbx z5=N$H$8>4*C@wK2Ahg(3=n`QC#rh~z$4K~~=$45>*)QW${3Q22$IT1a6rgKw_hQQD z0Sty!tWTljU{0lqq_it|*hykP@Un-of`F>jI>=rQ3(9(#^bE_Q4Eo33Gp+^KCwyeU z%aF+k0!$}0-o=XKKcx!wwb0F?pJS;i<2L*h`cWC?Jq=(o0!(L)neFHa>}<6yA2_FK zsJHDV1R{Y=b

=71-H5sb=i*je?S%W66b5vGj4tu_XtW;hf9ZXJ5ei3z)O2gQ-qN zKF#c7x*5*4zzIP3MH4<{;4C(q;i4TNYT;7{e)W)JvMt8u{8KQXq}%df(2LIS3XXXwimtBcHn~n!n)a6x60o%>xyf7tT{SumPwn z3ew~^pR%%g;q9XVQsc~-0|gC=Y`)&DIX$H&q{ZvWmn_rR)?X@y`=_C2kt9R1+$1 zct6rfnb2^Z6tt$S#Mqqqh7;LQKktyUQvA|xzT2O7ABve#y{tp7#t zzq20}5n&Fo(7iVyJ#O_J^YYL!J=QTP?q~yuXyb1^)vwyEZ!0h?uIK5v@J%`XY~mi0h^Q6Tau({_54*Eg zj9GOxO|d~M3x*XYEn~VF4pJI#M~#CLvT|SjMVRv zP^<(9>WAw`CLXNqpE~>@kl!x?;NL09?_|!enfyq_`w`&#GgV?Ca)-*OTF%|enGt8R zZz(DAH*qd{3!AD)?T;KrDYeR0kjwd#%qG~OSYhh|A|AT2Xo%(JF-j&x7zIM8G`Ld_ zzFH3;k2v*K|54NxHB?u0IjGfYsIkYjb#s5NOu^Xuky1PhP zh~SBerm6mrh@jOEwv>U9$dw`5R{_j_bg|jOJ7f0Z>66%9bu+uZ>tYRi=`k|OIw?xLT;ZzmKNVWJs9cqH& z+a>RSQ|B17?ad=rh>4KVHRS6i1OP z%=TpTrhM`_9<>chgBdO@7mT!UOI6skhK^VhA@8aI*!Vk-U-lE&*!(gQ{>(2cH{f{| zIaicrFTK-5ei?aYTkl9LN9>~*IHIbJ__&grsUU@sk3mjp%B9`ay?cm_DZmvpY#Lde zA<@lPef1n3vhtsln0q4PAVCK|{SowY_+=qB@Rl(T7MS#|qdUC+^>lCpv+H3LFT`3s zY5r_yh(#$dQQgSm0RHO@u5M)coE1p-E+OKRk_NAmXdHe&qLJQj^B6&+e38_yDU4XrS5JfWP)t1BLinj<(AHd+xOPm(e z52I4P`hjvAXbcH75v@R(I~-KGKf!3=ZvIG~^Y~>fB-tt$U}EPd@Jc02%=Ebu24s}s z()UaHa0ORISFx!ArOEoAa7gnRDRzWiSGQU5Wf)=p-?8Q0!?&+%s zcHjL(*Sq=oqG-vBA%P17?H+DOt<%H}dxH5XU57lg9z=6)_|@p(F-|3N$2(UMS(N55 zlX0Idy0|UBcF~K19J|b~s{rP61laQHggWvvSAe?D3B*WE{zzT1>OE;*Gv-8BPD2DG zje7=d5eLHxob4_Pzv9rfy~gGDNQJ9`>_40^4F;eBiXRF)-78hbehK3ks76(qse`(} z&Jumq^DDko^!@1e+L-Q9L8)El?rQ+%B?q#+3hGVcaNCtuJ7~}!2!5B<+gh`IBPIA;0Gv>vbdYE$|Y0_cNg{0|*ITsR^d&WA^nzI;dM1KoU z!?Ms?BO3D*V|{40VDV?I4~@Br<5{&}iD#`1eHp7dA5seza@M-gm$7#918Tu?%~})s zGFE6lq82R5to5KTV;$y))Pkj#wHEYcthRhqEm&Y#>p)+|n#zx;1SOZfEU;-N8o_-s(%*7I~P2gCgoUDbxOb`fO%qTU-{dEFsueMPTY8Oz=@+WX& zbeTO>6KFV65~&HaOUkH^8!A;saE07G1*l9J0b(Cwg_Pv~&*PWvg{J|Wg8i=V4bn%7 z4*)nh0T6>zn#_wzs~%hcbK^f#LBKi#72nii3_W6KaxzFSQwXq+mKS(CN)7^!V4?zn zJA0_lAR2teBtNvZ`+I|1_-`_}20_@%NfOTR0Kza8TyOY;X>%~4%bL3E_7sa1u0dM% z@%Z+1a0@NdxMeDsJ$Jh)WsAufRAP#@bL_{AJwC&O{qA6Cf#RP%gG~f&i@8EfmPiX# znHlIYZ@e4)43|-pa6MCnkxoWGgBv^a+kkZ8H^cukR)pa-ZyyS7%WDB|uGI0B;5)z( z>(qJi5I@JOJVu@}2o^scy@dZ29K36GEt>`$FK{AHESvdaAHc~+n+&3taYDd%1vVMW zE$skd5^gk2ii{Wva)+H=nmrfYr7bY^=c%f4-_1IoGfc6MKGr4-)?c~vbN0ZnL z*D=pU5^)~8i1WilR5TI4swhq4O4{a3niw~%CAh4p+rgQfPq3#ot&6$FaDk@rwX*AvX$a0TjrPgrq7zhQiV!avC2hk)DWy|PQi`%S%!wTqCd^OuX6(m1S$lw z41#R_h7&SUT|y@DF~xo6n}FLmQvofRQ%)`5WySGrqJ**H>UQV`R z1myYo*I+=v&v#%eRo{b*40s!s4ZO&@AQbq(IMSekH)T+7?O{$bhWUm01OMU>22oRQ z(jOJ`-`-12$?K;AsA?EpSlQ=cT;Ym751V=OdD={HJTAHL_JXR8n!#<@O&Cy>kEh?H zVTF0VwU5TT_Rcp0{Pz~DGz|9{nBX(FXILJ@cfddOx2@FZTr`8DFwr=dzUhu{AE02S ze@w%Tow+{j;Y@IQmVhE^zjYwE2G4gtUv}Z`W5I2Bwzy+9xOI@$9*=?*o%>onc;`?J zm)t%i1kFgM56Qha9Nd}-W^Wx1&HG;b^VmCf52S-0Iq*f+Tj4b z!WdM5c4!2*j|8{Sz8@aMk>K3Y0<#g>Z-H9=^RQF;_J`|%S(ZN)E@9;#tU`^YkvJKd zxZizS}RpnIgXGU2Zp{# z*#i_tG+ipSpg#? zJNhfMIG+M+L36rx3@+4c?O|*iwY{}w<0x#;gY^UT>H19lV7*zNYkanTc;Z0gVB>Io zU+u_*FRUQW&f}MTADd0+URk1}sH%9Y|EExj8mJVt%~Dh#6(I{)5k4;H2IUML3sZ$J z@-du%{o<^w5YIM>v$$sIE3g5G8DYcHA>%?kW9b8UtSVWv6YR<`<+Slwp3N?o&JO|1 zOj@g0KrBh01;Zrx_!FNB%2lWHA%!3jgHBRDqjar28jXa$mTanSR@DruEz@^#nrhHQ zB#bPguVPcm7D&Lzo>kzRp936!K)#^@2pWyr0XW}{+M~568#DF2IDWL&p$o=P5SJOw zSi+8VR^V2{>ky034?&y{!owGUe}F(9?zS8k_#to?W*M~OgU>H3=-&hP0d42dNUJ<$ zW8&;r@NlfN2Q814um+UIOMYEvL^GA@%hl-U30T>Q<@W(uK||#`6vP>{@al`Yu5DBXSNsqF@iT4StQijY((} zX%iYB@{Y90zr~K_8922XUpEde{at+yY<%3ixwwkb&J@hV^po*Ye=IdM0e4f0r}T&J z7)~w-LB|q)uBM}h61wpA;eaWkrap}c0=knwFK5t9=ef6Vc;VgB*PQ{gP8w!?2k!zq z!}A?yUvk35=mxg3?Q$|QGvPPlcG;fj7jf1wO2ItDlTjCciF@DS<}Y(YFGbTbD??Q> z&*CN4XF5CO6DtvfFEH%%AodFDTmYi4qG0m;J;shJ#p{fq^9`t`qQAw>%h=@fO!P|n zWVGys*{pyv%RdV6oTD?61j%fFCK}+^M{yPNqO-MGZX3n#$x^Op2K^=z2sUN zd9U%Hp&a*a(RfsVU};5bOm3P0O&X7i(I`M@KKuur$4uokR3X?8H<{$=H8p|3n7E`e zY`V+?Q(yCRKJnqRFO`1iTFf=v~;f=;yK3MR?6 z<%|>L3`$JU7~zciOyhvjW|VHv56t=AU7I0E4x~`CfjzW;4yp|Vp9R01gP{atSmpJW zb)L{j;_tDyPAD_Ht{&~c%K*3l@%45HMN0LZLSC2vDUiBZ8Ap>lRn63lF4$*|~z zUNfcwszAYG0NPP-I~dQBcrrs2==x0UU}GQL+!;eSx-P`WdHk}!feq}A!TkE;1r@lj zm>;7V_KQl9&)66y0&o`DLEQ@*LSo_&-m4=euQA_SnoNt&Ai#d$N^^)CWjsLTa};>k zkTZ0P@Lz-J1%`bY-G{M!qt7uGAvUtd;i<8(^ORf8+r*zV5ndrU{@FHMr80=V&CM@h zW7NWTdH6kUev_Nu<_RLRWQYi<93o|_vvUHd8;+n5|DD%xcu88}9$Jjl<@X3S3+ax_t%*p8L`h<0`}?`oM-J zdpEmeY>BBjq)oc0w1XXn5ZY(3H1vEk)l-Dq0ltAKi?V-AoqSRRj z@RP7!fWC$62FZi2WmJf*i#P9>VAHLt!*&E8^8OfRx*!xO0N~8D1F_%2UDCUhNaX+U zWH^Za0<);F>@ovbeK$SwUS%Np{PKGh|5|w9Yby99Jo`%UDDz6PqTR&B{-tI$V*gUy z{{QH`NYw5R;FTIsi(XG#v~1sHkJ6^=8sINuRh0~5SOtpsG+cRisu@(22{%*Z2Y7G! zMJkZk=0&isc-txB`-+w8INM&6xb+w;O;QaNT=kbc)VWdw6$1XYL%{p#WAwZ1ve>pF z%&NY9&-G0~hwtErPV&^5ANbBN0Qiu1=3lzbEHLq8#$*{AmvWd23{SG{i`+cN%|&jY zC~eAuN-=tan@@2Ac?^na1SEINuTqK?iYRxEyn8oR9GO)nN<0j}?HCCGwh4o;6Gw02 zR8XHpTC_3Ms6C8-4G!hjA8)whN96q-uFdXgOqeU!GE;kGqOpg^joJ~U*s*dI_8-;J zBa=KYmuCh~$7_ts^L^|fIAQ(M4rN()e)xDc$Eqy1)Jh53NPvKrFFt{Idarb%e?V;&v^+`~1D3TS$oFjeU@#~=H6 zf(NCzox#}3Fjdyt-D*JB6J3*@W>)>+py*kCySRe2WRmoxMTo~3ibwhwwdf~EZUa)` zE=+EscoD6dFmEH72jJa4(mBp!4E*ZJcLO5jZ+IfA~>?}8%0EgIvI zmpz4US})u4So9Cj7>O5uoqM0e#v~CK3-3H;CbJ^TBa1?GmeLMa_!RuiX4l3*%B4RP z;+vL9{tuairZk|sq zOE{Q`$zr^!7*Vbq)!NKgQKn&>!LQ<(W{*Nz1+0}!ExTcnb_59y^9@i#W|8?0l3j>- z5<3PlzC6m`Bp3RoeOR^`AsGF1#8 zAx?-0|4|9MMlKOnzJ?vES0v4M#&ROi4X$8}qVIDeh_|6ppgfR`8q0}b1Rm|kWWo<% z@7J088Y6o%QIi6WE?es=rQ_LprVa>&d)b&mi- zg}?k#-v)Mt7mBOslj4!w-Dh^sEurYqrqy3Vr+4s7S=g3oD6Q=m48`KPst(B3lTLS~ z3;&9qrwR&C1Q#zthJwK4rWNP7`X}RbK`w)c$)=0S=^J(Q5F0f%BVUOQf~K~P*0ERe zq!?YA(O+FBcZ&X#hHf={V_j*Jb~lAqu4xVza%h&e!h5jfibT}}#gMQAxcm^@xXqO) z!ccP+xSsNAx!xcjkd^rU8S*_PnFD##6UXb5jpyrAjUyQDeGsnNzHPGdPvT;0ThO(i;9M4~@&2j7RxoVObqh8nB~VGmq;^9PPQhG9Jx? z0ML6hC8hp48JQ=8sTu3eJU(IEnnxQQ4hXoP82bq{fU&Q^pFnh~Z$#~(#_(JCIM;oG zm)*g&pTC)>$g2qB%W1+~4{9SuJ_-dB^;f!A?J}>-_GFm10oj*)Jmq923L!_am>*t) zUHNr>d5HM{QE%GqcTvuRFs+{>c@r+JBUZb4QAty|6y{B;wb}s~^9kHDfZScMjj^Y* z(kebzH7*9xq&ONPi^c8M*Q=n%4gnNS*=;)BlGV(*UU%)8Z7eY3Qd%bPJ2*6xdz<7D zr8G0srT;9i{CRG^&dtwp^IdMf$IWkYL%nB4@|jzR{t-9-n45pX%|GSlpK=bq;m1HnU2c#Gp(|f0%o<2BpdU|g9$n*k! zho+xETMOHx(|ho5-}FbOC-Lv-#RW=DbQ~KwCZE6AN%ZlWa)4sY!SXd!Ge+bb^QooW zSw&3@MIx$~h}baUl(IKdJbaFuPjT}+H>bJL+n(Z{0aI?w{L_81%_}UUpc8wg01YTGh#KT_l;tv5+_98Zujk$@r`MK%2N&Gv4Uvusd lwzG5lu$@8s%-mrd?VtPT+=Fv_@vk{|5Le8iec#-H{|jXBb=Lp@ literal 0 HcmV?d00001 diff --git a/doc/breathe/renderer/rst/doxygen/index.py b/doc/breathe/renderer/rst/doxygen/index.py new file mode 100644 index 0000000..9ef04f0 --- /dev/null +++ b/doc/breathe/renderer/rst/doxygen/index.py @@ -0,0 +1,115 @@ + +from .base import Renderer + +class DoxygenTypeSubRenderer(Renderer): + + def render(self): + + nodelist = [] + + # Process all the compound children + for compound in self.data_object.get_compound(): + context = self.context.create_child_context(compound) + compound_renderer = self.renderer_factory.create_renderer(context) + nodelist.extend(compound_renderer.render()) + + return nodelist + + +class CompoundRenderer(Renderer): + """Base class for CompoundTypeSubRenderer and RefTypeSubRenderer.""" + + def __init__(self, compound_parser, render_empty_node, *args): + self.compound_parser = compound_parser + self.render_empty_node = render_empty_node + Renderer.__init__(self, *args) + + def create_doxygen_target(self): + """Can be overridden to create a target node which uses the doxygen refid information + which can be used for creating links between internal doxygen elements. + + The default implementation should suffice most of the time. + """ + + refid = "%s%s" % (self.project_info.name(), self.data_object.refid) + return self.target_handler.create_target(refid) + + def render_signature(self, file_data, doxygen_target): + # Defer to domains specific directive. + name, kind = self.get_node_info(file_data) + self.context.directive_args[1] = [self.get_fully_qualified_name()] + nodes = self.run_domain_directive(kind, self.context.directive_args[1]) + node = nodes[1] + signode, contentnode = node.children + + # The cpp domain in Sphinx doesn't support structs at the moment, so change the text from "class " + # to the correct kind which can be "class " or "struct ". + signode[0] = self.node_factory.desc_annotation(kind + ' ', kind + ' ') + + # Check if there is template information and format it as desired + template_signode = self.create_template_node(file_data.compounddef) + if template_signode: + node.insert(0, template_signode) + node.children[0].insert(0, doxygen_target) + return nodes, contentnode + + def render(self): + + # Read in the corresponding xml file and process + file_data = self.compound_parser.parse(self.data_object.refid) + + parent_context = self.context.create_child_context(file_data) + data_renderer = self.renderer_factory.create_renderer(parent_context) + rendered_data = data_renderer.render() + + if not rendered_data and not self.render_empty_node: + return [] + + file_data = parent_context.node_stack[0] + new_context = parent_context.create_child_context(file_data.compounddef) + + nodes, contentnode = self.render_signature(file_data, self.create_doxygen_target()) + + if file_data.compounddef.includes: + for include in file_data.compounddef.includes: + context = new_context.create_child_context(include) + renderer = self.renderer_factory.create_renderer(context) + contentnode.extend(renderer.render()) + + contentnode.extend(rendered_data) + return nodes + + +class CompoundTypeSubRenderer(CompoundRenderer): + + def __init__(self, compound_parser, *args): + CompoundRenderer.__init__(self, compound_parser, True, *args) + + def get_node_info(self, file_data): + return self.data_object.name, self.data_object.kind + + +class FileRenderer(CompoundTypeSubRenderer): + + def render_signature(self, file_data, doxygen_target): + # Build targets for linking + targets = [] + targets.extend(doxygen_target) + + title_signode = self.node_factory.desc_signature() + title_signode.extend(targets) + + # Set up the title + name, kind = self.get_node_info(file_data) + title_signode.append(self.node_factory.emphasis(text=kind)) + title_signode.append(self.node_factory.Text(" ")) + title_signode.append(self.node_factory.desc_name(text=name)) + + contentnode = self.node_factory.desc_content() + + node = self.node_factory.desc() + node.document = self.state.document + node['objtype'] = kind + node.append(title_signode) + node.append(contentnode) + return [node], contentnode diff --git a/doc/breathe/renderer/rst/doxygen/index.pyc b/doc/breathe/renderer/rst/doxygen/index.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2d8e49aafa1b651400886ea42db849469ca6ea14 GIT binary patch literal 5495 zcmd5=U60$w6`i3zR+4wKiCwSbG)NhsZq=e)0eR_H8U(SCJhWH@T&HQ>xCECRttd;R z%o)YIfc9zgm><%&KJ<_DrxZwkK+m~DQtJfCt1OA5nLA&1X3o9mays7}jAsA*^s`je zpAP;%#A6poGW@hcZmHE1t#lSBqt#TatfRhC>RPG4Jqc9SZKSlDp{Hr zW%bNXKD~6avN)bLlF468W%IJIllP8)Gg;(kla;h!$>z@ddX=Qll5=AxXI%2kOq$6i zm35QMpZg>S7A}rgm(dXOa(R|psDggyNZ-cyUNGjl%0l9}fI4yPMv%nuvdq>C6s7BS z1-o4a!6-)&Akz;VkM>~=hNwQ`6f*g==zb5y7Tq*HEf|Nr1(Jb@iETcCRdq$uC;WNv z_5&mzCDw%LBC$4{mQ~nH_${jnlOhWvGyRtMIOPsgY5sqL$NmfnpboQ$kr9iDwQ}BQ zAnB;D={Qtt3<51dY`xZal~fisPPqAlkIi!BE@MJ7g0MN#yvSV~k2yfZbB)*|y3GcZ zCDpmzp6$-ic?YV{U0Fg@=^?)2cX-O&wTF1@1PM;=rpIAkc5ND{BRHh3qk%)BFW~_8 zzZ@Yc!ZQ<=Uz)1Qv&>Jf9zX8xR>k_fVz26tQ6XEQ z_I{$p5NQP58-dh+knwneIRY?W1f;7g@KeKS=N?o7GJx-Wk1!AyGmZ5AHTr?w;6Ajv ze+6RelkGU#p1K-HTS)ducyKxQ>Ob__?9uhesAvXK911}W)n=%wf5|u_wm=cBbpdr{ zXo&95eGNz!HJE!dP%wj2vGo%P3LHIPm?KdVDacWhKM8b?gEvt}$#lI~T*lAW$s(WT zCKD>~j7CIcc?IO;Uz(T>LzuQ&7jafDlN^6dt>;5>FMN_Vacvf4BUOEE|g?7n>b5uJ)){TY~0V9vp6E>;D1^?m)e9_hpGyPey*ukYx4 z-kCC(YLVXqG(7SVyR}$`34GU!)*+n-a2wKf)O?_>5eC8(x@y0ADx(Y~hv@JWv_^o^ z9xwq404VT%OYn_6%xAwQ!TA9P0*YxcecFs~Ie$%6|5F!#+7=%@{k_;zPlm(%&=`Jvj3Y8}x`KmWJ-oaWYg&+kfLb2i>Bf2@UhKQar zqDzg49EpuQn-Y&iO>7+^v*@R+J!bM25;2UtNEd5>FB(81_UL^mqXEG#CIs}_u$6vS zf?t2wwI{9%nTI^jv@kE4KG82wj()`fsa`#!w`0!QjI?_c%g+54D%lW;>bw~+9NiDz z(B0rb-wxgh_JQ0($lgMEESpVF6fp{t#l>(xDZ*364zkI9yXg|P%ah#B!W!a<>RE!L zulvEUHyjP`IKt_Bg2)tA@@a!t;>W!FY6h$N3X%?kRPuM)#7RWwCwQ!YPB;w40c%2R z2^;*n^HNmVLCZ)mPbI}CKCaeA-Ux04i+r!z?&!`olRAEe$8xbs%bJ31p+s)5ORZ6~jRCqYn_FM@%fkPrDlKerf_ z#YmyRz=wJR(W53HU%(v**=V2`ZSLKO;>0F-xe+mt6}N|*5Qp2GG2i2bNuqaIMTAIf z)rJHSQ6gbevRd&;wgE6W4A9(CLNN_)*4}wE| z(7B6H3gJ|6h|(c~ssntzAK98DyKYyoTWkCSbom00c#nQ?;@|#w*k`!Ikc)wc&d|Gk g+HS-yuZa2rt@r)K(+70ac7Wvd;OOw^!=vH<0lH5ad;kCd literal 0 HcmV?d00001 diff --git a/doc/breathe/renderer/rst/doxygen/mask.py b/doc/breathe/renderer/rst/doxygen/mask.py new file mode 100644 index 0000000..49a2d4e --- /dev/null +++ b/doc/breathe/renderer/rst/doxygen/mask.py @@ -0,0 +1,62 @@ +""" +Masks +===== + +Masks are related to filters. Filters can block the processing of particular parts of the xml +hierarchy but they can only work on node level. If the part of the xml hierarchy that you want to +filter out is read in as an instance of one of the classes in parser/doxygen/*.py then you can use +the filters. However, if you want to filter out an attribute from one of the nodes (and some of the +xml child nodes are read in as attributes on their parents) then you can't use a filter. + +We introduce the Mask's to fulfil this need. The masks are designed to be applied to a particular +node type and to limit the access to particular attributes on the node. For example, then +NoParameterNamesMask wraps a node a returns all its standard attributes but returns None for the +'declname' and 'defname' attributes. + +Currently the Mask functionality is only used for the text signature rendering for doing function +matching. + +""" + +class NoParameterNamesMask(object): + + def __init__(self, data_object): + self.data_object = data_object + + def __getattr__(self, attr): + + if attr in ['declname', 'defname', 'defval']: + return None + + return getattr(self.data_object, attr) + +class MaskFactory(object): + + def __init__(self, lookup): + self.lookup = lookup + + def mask(self, data_object): + + try: + node_type = data_object.node_type + except AttributeError as e: + + # Horrible hack to silence errors on filtering unicode objects + # until we fix the parsing + if type(data_object) == unicode: + node_type = "unicode" + else: + raise e + + if node_type in self.lookup: + Mask = self.lookup[node_type] + return Mask(data_object) + + return data_object + + +class NullMaskFactory(object): + + def mask(self, data_object): + return data_object + diff --git a/doc/breathe/renderer/rst/doxygen/mask.pyc b/doc/breathe/renderer/rst/doxygen/mask.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b3852060382a48373cc4073fe258f9fbf7831de2 GIT binary patch literal 3385 zcmd5-U2h{b6!lE9T{^UM`6^nTjF4zROClj8q}76eLIu(it){@jzKon1Cz-~vgY9e^ zseNJjAH4Ga_ye4KCzEs~#2ad(*kj+hzH{!!x$gYEpH2UI@>40+zYd;XVuZ(-Dj}X> zPJ~XxI1yDU{t)7Y5WhZ4Mb&Ag-Ho&(synT8XCv*3>aIBLy+T(1g#GLX6=os(oPJre zk;-f7wNX)5GCDb~P1HX0)UrLuBlTsf0*s^!AFQio96iF9MRP(Ie>(kRc%Kr+(0 zn44@`Yp;AcUCGfhl61wUoHZ+X?)*$TE3K=vH2S$VeffQJluTYTBe!PaR7JUROL?v= z47#j=Djm$%0Y0co)>f(@fw;CIDqCtYGm zgovEgy6Vdx@qSL_!2p1?p4g@&MliZqn7Y}iYgx}YfpN8f2E0P~n0j7wwxuemP)K&I zN;bi1onfC*Y|cx4q2>#tAFxx|&^=LJ%{7W~h({pk^4zNh@HKU#kn*_n76M~r9fPEl zSISr090V@DR&Pj^Fvh14i|nY6kX-oD_Q)%@jOVgU9s<3||dSC{IM`FnF?xQ)m0*Rx|Nt zI6hQWd~l*8)prvsLYC9SIwZgO@KK73Vhyt>sD=XhBGSF2oA$`Tb%==xMG-Sdieioi zVzA9Q3?$pS!mAr9ha5=6+Zch6@1(mOE@J8wC#sCjuS(LO-~Y%P3ZQXrwp=h}IOq9m z5N?BXQ}LmEy^nF7CRD&Qj!AAYt@eo!XF^=1;;H>qbitEZCj7BTt~w%#4PO!wJ7Sg! z|B(6&RDb(MTz16oiLic^NiA)-@^p#=!>jOWpLvuU?kMNJ^-#j z?OmjuWIs9RzLD&vS$cqV)-W$8cIJCDQQmSY>@EHqe*nG7kAMIG literal 0 HcmV?d00001 diff --git a/doc/breathe/renderer/rst/doxygen/target.py b/doc/breathe/renderer/rst/doxygen/target.py new file mode 100644 index 0000000..c1ddd18 --- /dev/null +++ b/doc/breathe/renderer/rst/doxygen/target.py @@ -0,0 +1,40 @@ + +class TargetHandler(object): + + def __init__(self, project_info, node_factory, document): + + self.project_info = project_info + self.node_factory = node_factory + self.document = document + + def create_target(self, id_): + """Creates a target node and registers it with the document and returns it in a list""" + + target = self.node_factory.target(ids=[id_], names=[id_]) + + try: + self.document.note_explicit_target(target) + except Exception: + # TODO: We should really return a docutils warning node here + print("Warning: Duplicate target detected: %s" % id_) + + return [target] + +class NullTargetHandler(object): + + def create_target(self, refid): + return [] + +class TargetHandlerFactory(object): + + def __init__(self, node_factory): + + self.node_factory = node_factory + + def create_target_handler(self, options, project_info, document): + + if options.has_key("no-link"): + return NullTargetHandler() + + return TargetHandler(project_info, self.node_factory, document) + diff --git a/doc/breathe/renderer/rst/doxygen/target.pyc b/doc/breathe/renderer/rst/doxygen/target.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f0cf8fe69f95377d2c031523808fb014cfc4b1f4 GIT binary patch literal 2616 zcmd5;OK;Oa5T3Q$lvWgkREj_d3=$|Ds3k5)6+(zd;eaY|dG=zt_9k)TuA|+J+DLFJ zKZgIuAK;tWCQ&blTN8D+{iG*M4crRW#Y zDbe?RJVevgc(xi*wKQE_o~_1Ib!e}<0#kk+)2G7rwSQNbs?m1lQeo#MhP#Cc{@4Yv zjeS@Z$NMp5d))}zqnV-aA05CD7F?Q&}VGNzGj4|VDD z+VomkFm0vtUQzniPW&ZkRBbsv(#Ch$mFLOnrkAmuj6G*;tBVmP=OLx<>jPWZNxEZ; zBYoW3p-VqZ{Gc^kz3EE&MO#<5#-&fTo~BKGkd8!ypIq(r<55u#i@tX0fz^c{=+tUc zX{&8&olmRwWYX6r^@8IT-sNC(BvSi4moPgVRJ5vARmp*JoXZ#j)prQM=@5THDPZdh zok2LI=x0Qe4bh3{5D-Rmsz`k`w`d6{4A;nhB&Ae^Ek&De-x)>Upad&>0+sv7zBqL4 zk|GIlCJb)^(i5xuwex@=seN)>`$2*flPTC|Dt>H@DAWcf8ob~+i@I{2Gcf?yxrdOx z7S`0Jzn#1ukD9uK&#A*od+@8P?c{;$@=HRRXKX@9!k^z@bFJ68K4AmEFzotOY`i%s z^~i%Oshdm+A;ghqjQS$5&u6L>w9g`6!-C@yr}$nJs|~dttw*7VL!~f!dG1*+&yU(_ z+~6@2i1@X6QX*YgU1yvE*RNyTJJD*#UxTnaZkkX3?jfwE&-W0t4nDYY9@r*7yuuLM z{ds@D5=oN@WHTsM_v&g6%EjTqfg!PWA~|N~SlbDm zwuFxSn2?tk|8)T{0Mj8XG77T`pqkS;Yu0m4r41|som^XYIAftRn%!z#?UK}^kQ7=q zZb0;4yGb4bvh%p&+zI3<{SI^(13b