From 4759e1cf5407637a14df65dae72301289e8b3d67 Mon Sep 17 00:00:00 2001 From: Celine Mercier Date: Thu, 28 May 2015 16:34:24 +0200 Subject: [PATCH] deleting the Breathe sources --- doc/breathe/__init__.py | 16 - doc/breathe/__init__.pyc | Bin 491 -> 0 bytes doc/breathe/directive/__init__.py | 0 doc/breathe/directive/__init__.pyc | Bin 194 -> 0 bytes doc/breathe/directive/base.py | 88 - doc/breathe/directive/base.pyc | Bin 3943 -> 0 bytes doc/breathe/directive/file.py | 123 - doc/breathe/directive/file.pyc | Bin 4594 -> 0 bytes doc/breathe/directive/index.py | 115 - doc/breathe/directive/index.pyc | Bin 4470 -> 0 bytes doc/breathe/directives.py | 1050 --- doc/breathe/directives.pyc | Bin 35541 -> 0 bytes doc/breathe/exception.py | 3 - doc/breathe/exception.pyc | Bin 445 -> 0 bytes doc/breathe/finder/__init__.py | 0 doc/breathe/finder/__init__.pyc | Bin 191 -> 0 bytes doc/breathe/finder/core.py | 45 - doc/breathe/finder/core.pyc | Bin 2655 -> 0 bytes doc/breathe/finder/doxygen/__init__.py | 1 - doc/breathe/finder/doxygen/__init__.pyc | Bin 199 -> 0 bytes doc/breathe/finder/doxygen/base.py | 18 - doc/breathe/finder/doxygen/base.pyc | Bin 1124 -> 0 bytes doc/breathe/finder/doxygen/compound.py | 75 - doc/breathe/finder/doxygen/compound.pyc | Bin 3909 -> 0 bytes doc/breathe/finder/doxygen/core.py | 55 - doc/breathe/finder/doxygen/core.pyc | Bin 3200 -> 0 bytes doc/breathe/finder/doxygen/index.py | 79 - doc/breathe/finder/doxygen/index.pyc | Bin 3370 -> 0 bytes doc/breathe/parser/__init__.py | 118 - doc/breathe/parser/__init__.pyc | Bin 5579 -> 0 bytes doc/breathe/parser/doxygen/__init__.py | 0 doc/breathe/parser/doxygen/__init__.pyc | Bin 199 -> 0 bytes doc/breathe/parser/doxygen/compound.py | 964 --- doc/breathe/parser/doxygen/compound.pyc | Bin 47683 -> 0 bytes doc/breathe/parser/doxygen/compoundsuper.py | 5798 ----------------- doc/breathe/parser/doxygen/compoundsuper.pyc | Bin 398653 -> 0 bytes doc/breathe/parser/doxygen/index.py | 63 - doc/breathe/parser/doxygen/index.pyc | Bin 3240 -> 0 bytes doc/breathe/parser/doxygen/indexsuper.py | 362 - doc/breathe/parser/doxygen/indexsuper.pyc | Bin 21320 -> 0 bytes doc/breathe/process.py | 87 - doc/breathe/process.pyc | Bin 3344 -> 0 bytes doc/breathe/project.py | 306 - doc/breathe/project.pyc | Bin 10021 -> 0 bytes doc/breathe/renderer/__init__.py | 0 doc/breathe/renderer/__init__.pyc | Bin 193 -> 0 bytes doc/breathe/renderer/rst/__init__.py | 2 - doc/breathe/renderer/rst/__init__.pyc | Bin 197 -> 0 bytes doc/breathe/renderer/rst/doxygen/__init__.py | 383 -- doc/breathe/renderer/rst/doxygen/__init__.pyc | Bin 12815 -> 0 bytes doc/breathe/renderer/rst/doxygen/base.py | 127 - doc/breathe/renderer/rst/doxygen/base.pyc | Bin 5173 -> 0 bytes doc/breathe/renderer/rst/doxygen/compound.py | 1004 --- doc/breathe/renderer/rst/doxygen/compound.pyc | Bin 43542 -> 0 bytes doc/breathe/renderer/rst/doxygen/filter.py | 1138 ---- doc/breathe/renderer/rst/doxygen/filter.pyc | Bin 47842 -> 0 bytes doc/breathe/renderer/rst/doxygen/index.py | 115 - doc/breathe/renderer/rst/doxygen/index.pyc | Bin 5495 -> 0 bytes doc/breathe/renderer/rst/doxygen/mask.py | 62 - doc/breathe/renderer/rst/doxygen/mask.pyc | Bin 3385 -> 0 bytes doc/breathe/renderer/rst/doxygen/target.py | 40 - doc/breathe/renderer/rst/doxygen/target.pyc | Bin 2616 -> 0 bytes 62 files changed, 12237 deletions(-) delete mode 100644 doc/breathe/__init__.py delete mode 100644 doc/breathe/__init__.pyc delete mode 100644 doc/breathe/directive/__init__.py delete mode 100644 doc/breathe/directive/__init__.pyc delete mode 100644 doc/breathe/directive/base.py delete mode 100644 doc/breathe/directive/base.pyc delete mode 100644 doc/breathe/directive/file.py delete mode 100644 doc/breathe/directive/file.pyc delete mode 100644 doc/breathe/directive/index.py delete mode 100644 doc/breathe/directive/index.pyc delete mode 100644 doc/breathe/directives.py delete mode 100644 doc/breathe/directives.pyc delete mode 100644 doc/breathe/exception.py delete mode 100644 doc/breathe/exception.pyc delete mode 100644 doc/breathe/finder/__init__.py delete mode 100644 doc/breathe/finder/__init__.pyc delete mode 100644 doc/breathe/finder/core.py delete mode 100644 doc/breathe/finder/core.pyc delete mode 100644 doc/breathe/finder/doxygen/__init__.py delete mode 100644 doc/breathe/finder/doxygen/__init__.pyc delete mode 100644 doc/breathe/finder/doxygen/base.py delete mode 100644 doc/breathe/finder/doxygen/base.pyc delete mode 100644 doc/breathe/finder/doxygen/compound.py delete mode 100644 doc/breathe/finder/doxygen/compound.pyc delete mode 100644 doc/breathe/finder/doxygen/core.py delete mode 100644 doc/breathe/finder/doxygen/core.pyc delete mode 100644 doc/breathe/finder/doxygen/index.py delete mode 100644 doc/breathe/finder/doxygen/index.pyc delete mode 100644 doc/breathe/parser/__init__.py delete mode 100644 doc/breathe/parser/__init__.pyc delete mode 100644 doc/breathe/parser/doxygen/__init__.py delete mode 100644 doc/breathe/parser/doxygen/__init__.pyc delete mode 100644 doc/breathe/parser/doxygen/compound.py delete mode 100644 doc/breathe/parser/doxygen/compound.pyc delete mode 100644 doc/breathe/parser/doxygen/compoundsuper.py delete mode 100644 doc/breathe/parser/doxygen/compoundsuper.pyc delete mode 100644 doc/breathe/parser/doxygen/index.py delete mode 100644 doc/breathe/parser/doxygen/index.pyc delete mode 100644 doc/breathe/parser/doxygen/indexsuper.py delete mode 100644 doc/breathe/parser/doxygen/indexsuper.pyc delete mode 100644 doc/breathe/process.py delete mode 100644 doc/breathe/process.pyc delete mode 100644 doc/breathe/project.py delete mode 100644 doc/breathe/project.pyc delete mode 100644 doc/breathe/renderer/__init__.py delete mode 100644 doc/breathe/renderer/__init__.pyc delete mode 100644 doc/breathe/renderer/rst/__init__.py delete mode 100644 doc/breathe/renderer/rst/__init__.pyc delete mode 100644 doc/breathe/renderer/rst/doxygen/__init__.py delete mode 100644 doc/breathe/renderer/rst/doxygen/__init__.pyc delete mode 100644 doc/breathe/renderer/rst/doxygen/base.py delete mode 100644 doc/breathe/renderer/rst/doxygen/base.pyc delete mode 100644 doc/breathe/renderer/rst/doxygen/compound.py delete mode 100644 doc/breathe/renderer/rst/doxygen/compound.pyc delete mode 100644 doc/breathe/renderer/rst/doxygen/filter.py delete mode 100644 doc/breathe/renderer/rst/doxygen/filter.pyc delete mode 100644 doc/breathe/renderer/rst/doxygen/index.py delete mode 100644 doc/breathe/renderer/rst/doxygen/index.pyc delete mode 100644 doc/breathe/renderer/rst/doxygen/mask.py delete mode 100644 doc/breathe/renderer/rst/doxygen/mask.pyc delete mode 100644 doc/breathe/renderer/rst/doxygen/target.py delete mode 100644 doc/breathe/renderer/rst/doxygen/target.pyc diff --git a/doc/breathe/__init__.py b/doc/breathe/__init__.py deleted file mode 100644 index 0aaa564..0000000 --- a/doc/breathe/__init__.py +++ /dev/null @@ -1,16 +0,0 @@ - -__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 deleted file mode 100644 index 63dcadd294c0273faa9d2d4ed2264e2a9a1a1a2b..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 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 diff --git a/doc/breathe/directive/base.py b/doc/breathe/directive/base.py deleted file mode 100644 index 77f86f1..0000000 --- a/doc/breathe/directive/base.py +++ /dev/null @@ -1,88 +0,0 @@ - -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 deleted file mode 100644 index e80d74fb93bff685bddc0aacdf51013a28ece169..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 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 deleted file mode 100644 index 30c7a49429b59719fec60ebeebfd3a1feb11ddf6..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 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 diff --git a/doc/breathe/directive/index.py b/doc/breathe/directive/index.py deleted file mode 100644 index a8faa7b..0000000 --- a/doc/breathe/directive/index.py +++ /dev/null @@ -1,115 +0,0 @@ - -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 deleted file mode 100644 index 71aacef9686a9b58f84a8d9cbbad41c7d0041d80..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 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 diff --git a/doc/breathe/directives.py b/doc/breathe/directives.py deleted file mode 100644 index 99a8a77..0000000 --- a/doc/breathe/directives.py +++ /dev/null @@ -1,1050 +0,0 @@ - -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 deleted file mode 100644 index 562ebf4d712ecef09598dd46517c8129e7938dee..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 35541 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 diff --git a/doc/breathe/finder/__init__.py b/doc/breathe/finder/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/doc/breathe/finder/__init__.pyc b/doc/breathe/finder/__init__.pyc deleted file mode 100644 index af53154b0da2ccd8f2a922dcc6ee1dfbd83f2a83..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 191 zcmZSn%*&OrA|N!G0SXv_v;z`aYRSMTtd~`ff#u zxvAy(McKvr0hJ{g`FVP2FcJN*)S}|d{Jdg)BRzBdoXjNs0TZlX-=vg$VtUO%m4tpCNT>D diff --git a/doc/breathe/finder/core.py b/doc/breathe/finder/core.py deleted file mode 100644 index a519a11..0000000 --- a/doc/breathe/finder/core.py +++ /dev/null @@ -1,45 +0,0 @@ - -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 deleted file mode 100644 index d9ce31b6c27db9560c680003de5e1615e2494589..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 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? diff --git a/doc/breathe/finder/doxygen/__init__.py b/doc/breathe/finder/doxygen/__init__.py deleted file mode 100644 index 8b13789..0000000 --- a/doc/breathe/finder/doxygen/__init__.py +++ /dev/null @@ -1 +0,0 @@ - diff --git a/doc/breathe/finder/doxygen/__init__.pyc b/doc/breathe/finder/doxygen/__init__.pyc deleted file mode 100644 index 85d7ec67e81ca609e02bb7d11168feb4d4b583c6..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 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 diff --git a/doc/breathe/finder/doxygen/base.py b/doc/breathe/finder/doxygen/base.py deleted file mode 100644 index 0bccb75..0000000 --- a/doc/breathe/finder/doxygen/base.py +++ /dev/null @@ -1,18 +0,0 @@ - -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 deleted file mode 100644 index 39f32a8e84d26f210da3331df5f345db00cfc823..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 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 diff --git a/doc/breathe/finder/doxygen/compound.py b/doc/breathe/finder/doxygen/compound.py deleted file mode 100644 index 459190c..0000000 --- a/doc/breathe/finder/doxygen/compound.py +++ /dev/null @@ -1,75 +0,0 @@ - -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 deleted file mode 100644 index 3adaad45213569735b44711ae3680142974ad2bc..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 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 diff --git a/doc/breathe/finder/doxygen/index.py b/doc/breathe/finder/doxygen/index.py deleted file mode 100644 index f839953..0000000 --- a/doc/breathe/finder/doxygen/index.py +++ /dev/null @@ -1,79 +0,0 @@ - -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 deleted file mode 100644 index b1b87a24f844e93836910553002d0beed0299d73..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3370 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 diff --git a/doc/breathe/parser/doxygen/__init__.py b/doc/breathe/parser/doxygen/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/doc/breathe/parser/doxygen/__init__.pyc b/doc/breathe/parser/doxygen/__init__.pyc deleted file mode 100644 index 555c9d56fe9a74409242b4bbeae32016904c8e64..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 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 diff --git a/doc/breathe/parser/doxygen/compound.py b/doc/breathe/parser/doxygen/compound.py deleted file mode 100644 index c177ec1..0000000 --- a/doc/breathe/parser/doxygen/compound.py +++ /dev/null @@ -1,964 +0,0 @@ -#!/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 deleted file mode 100644 index bff7aaefb769a4adc3f1cad024bf70fa12ab5f36..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 47683 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 D*46dJ diff --git a/doc/breathe/parser/doxygen/compoundsuper.py b/doc/breathe/parser/doxygen/compoundsuper.py deleted file mode 100644 index 418a85d..0000000 --- a/doc/breathe/parser/doxygen/compoundsuper.py +++ /dev/null @@ -1,5798 +0,0 @@ -#!/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 deleted file mode 100644 index 5b3f94124ff34d5c0a23769154eb4b535ce15414..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 398653 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 ln{ diff --git a/doc/breathe/parser/doxygen/indexsuper.py b/doc/breathe/parser/doxygen/indexsuper.py deleted file mode 100644 index 5641e0b..0000000 --- a/doc/breathe/parser/doxygen/indexsuper.py +++ /dev/null @@ -1,362 +0,0 @@ -#!/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 deleted file mode 100644 index 8576b837b321cea4d8ab54abea24693b2ac5955e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 21320 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 diff --git a/doc/breathe/project.py b/doc/breathe/project.py deleted file mode 100644 index 6d2d37a..0000000 --- a/doc/breathe/project.py +++ /dev/null @@ -1,306 +0,0 @@ - -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 deleted file mode 100644 index 489ae42a90d87151d5210884249cb4031c61ca10..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 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& diff --git a/doc/breathe/renderer/rst/__init__.py b/doc/breathe/renderer/rst/__init__.py deleted file mode 100644 index 139597f..0000000 --- a/doc/breathe/renderer/rst/__init__.py +++ /dev/null @@ -1,2 +0,0 @@ - - diff --git a/doc/breathe/renderer/rst/__init__.pyc b/doc/breathe/renderer/rst/__init__.pyc deleted file mode 100644 index 434f51a23936bd15468d4b96d494cb968d2e46b1..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 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 diff --git a/doc/breathe/renderer/rst/doxygen/__init__.py b/doc/breathe/renderer/rst/doxygen/__init__.py deleted file mode 100644 index 0dcc0b8..0000000 --- a/doc/breathe/renderer/rst/doxygen/__init__.py +++ /dev/null @@ -1,383 +0,0 @@ - -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 deleted file mode 100644 index 8ae1c1796dc04aef4a46ef32f39f18f5ab21a15a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 12815 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 J-_wQ5{|Q<>{4D?g diff --git a/doc/breathe/renderer/rst/doxygen/base.py b/doc/breathe/renderer/rst/doxygen/base.py deleted file mode 100644 index 9506751..0000000 --- a/doc/breathe/renderer/rst/doxygen/base.py +++ /dev/null @@ -1,127 +0,0 @@ - -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 deleted file mode 100644 index cefbec028e6c239aa96dea93bc8279a31129da12..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 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_ diff --git a/doc/breathe/renderer/rst/doxygen/compound.py b/doc/breathe/renderer/rst/doxygen/compound.py deleted file mode 100644 index ec82e19..0000000 --- a/doc/breathe/renderer/rst/doxygen/compound.py +++ /dev/null @@ -1,1004 +0,0 @@ - -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 deleted file mode 100644 index 44fa4fe92f4e422203d31ab0582a7a19ef39ad60..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 43542 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 U&lcpqr@pEF-ulk^b@d(pAJ3m?1poj5 diff --git a/doc/breathe/renderer/rst/doxygen/filter.py b/doc/breathe/renderer/rst/doxygen/filter.py deleted file mode 100644 index 328bf89..0000000 --- a/doc/breathe/renderer/rst/doxygen/filter.py +++ /dev/null @@ -1,1138 +0,0 @@ -""" -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 deleted file mode 100644 index 13c5acb8f0647776b0746b1d033074d63c2d2c3b..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 47842 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 diff --git a/doc/breathe/renderer/rst/doxygen/index.py b/doc/breathe/renderer/rst/doxygen/index.py deleted file mode 100644 index 9ef04f0..0000000 --- a/doc/breathe/renderer/rst/doxygen/index.py +++ /dev/null @@ -1,115 +0,0 @@ - -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 deleted file mode 100644 index 2d8e49aafa1b651400886ea42db849469ca6ea14..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 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 diff --git a/doc/breathe/renderer/rst/doxygen/mask.py b/doc/breathe/renderer/rst/doxygen/mask.py deleted file mode 100644 index 49a2d4e..0000000 --- a/doc/breathe/renderer/rst/doxygen/mask.py +++ /dev/null @@ -1,62 +0,0 @@ -""" -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 deleted file mode 100644 index b3852060382a48373cc4073fe258f9fbf7831de2..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 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 diff --git a/doc/breathe/renderer/rst/doxygen/target.py b/doc/breathe/renderer/rst/doxygen/target.py deleted file mode 100644 index c1ddd18..0000000 --- a/doc/breathe/renderer/rst/doxygen/target.py +++ /dev/null @@ -1,40 +0,0 @@ - -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 deleted file mode 100644 index f0cf8fe69f95377d2c031523808fb014cfc4b1f4..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 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