diff --git a/.ci/pipeline/docs.yml b/.ci/pipeline/docs.yml index 08ddea7d8d7..d9fc18e004c 100644 --- a/.ci/pipeline/docs.yml +++ b/.ci/pipeline/docs.yml @@ -23,13 +23,15 @@ pr: - examples pool: - vmImage: 'ubuntu-latest' + vmImage: 'ubuntu-20.04' steps: - script: | cd docs sudo apt-get install python3-setuptools sudo pip3 install -r requirements.txt + sudo apt-get update + sudo apt-get install doxygen displayName: 'Install requirements' - script: | diff --git a/docs/.gitignore b/docs/.gitignore index 50264248282..6d2ef99a8c0 100644 --- a/docs/.gitignore +++ b/docs/.gitignore @@ -2,3 +2,5 @@ build/ source/examples/cpp/* source/examples/dpc/* docbuild-log.txt +__pycache__ +doxygen/oneapi/doxygen/xml diff --git a/docs/Makefile b/docs/Makefile index 1a5591aa62e..2342a5fc3a3 100644 --- a/docs/Makefile +++ b/docs/Makefile @@ -31,7 +31,14 @@ create_rst_examples: @echo "Creating rST files for oneAPI Examples..." python3 rst_examples.py -.PHONY: help Makefile create_rst_examples +doxygen: + doxygen doxygen/oneapi/Doxyfile + +parse-doxygen: doxygen + mkdir -p build + python3 -m dalapi.doxypy.cli doxygen/xml --compact > build/tree.yaml + +.PHONY: help Makefile create_rst_examples doxygen parse-doxygen # Catch-all target: route all unknown targets to Sphinx using the new # "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). diff --git a/docs/dalapi/__init__.py b/docs/dalapi/__init__.py new file mode 100644 index 00000000000..3f4c79c9672 --- /dev/null +++ b/docs/dalapi/__init__.py @@ -0,0 +1,27 @@ +# file: __init__.py +#=============================================================================== +# Copyright 2019-2020 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +#=============================================================================== + +__version__ = '0.0.1' + +def setup(app): + from . import extension + extension.setup(app) + return { + 'version': __version__, + 'parallel_read_safe': True, + 'parallel_write_safe': True + } diff --git a/docs/dalapi/directives.py b/docs/dalapi/directives.py new file mode 100644 index 00000000000..9f94c21a93d --- /dev/null +++ b/docs/dalapi/directives.py @@ -0,0 +1,271 @@ +# file: directives.py +#=============================================================================== +# Copyright 2019-2020 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +#=============================================================================== + +from docutils import nodes +from docutils.parsers.rst import Directive +from docutils.statemachine import ViewList +from .generator import RstBuilder + +def directive(cls): + class DirectiveFactory(cls): + def __init__(self, ctx): + self._ctx = ctx + def __call__(self, *args, **kwargs): + return cls(self._ctx, *args, **kwargs) + return DirectiveFactory + +class BaseDirective(Directive): + def __init__(self, ctx, *args, **kwargs): + super().__init__(*args, **kwargs) + self.ctx = ctx + +class MacroDirective(BaseDirective): + def init(self): ... + def rst(self, x: RstBuilder): ... + + def run(self): + self.init() + content = ViewList() + self._get_rst(content) + node = nodes.section() + node.document = self.state.document + self.state.nested_parse(content, 0, node) + return node.children + + def _get_rst(self, placeholder): + x = RstBuilder(placeholder, self.ctx.current_docname, self.lineno) + self.rst(x) + + +class DoxyDirective(MacroDirective): + def init(self): + self.ctx.watcher.link_docname(self.ctx.current_docname) + + def format_description(self, desc_def): + rst = '' + for run in desc_def.runs: + if run.kind == 'text': + rst += run.content + elif run.kind == 'math': + rst += f':math:`{run.content}`' + elif run.kind == 'code': + if hasattr(run, 'directive'): + rst += f'{run.directive}`{run.content}`' + else: + rst += f'`{run.content}`' + return rst.strip() + + def add_description(self, description, x: RstBuilder, level=0): + desc_str = self.format_description(description) + if desc_str: + x.add_doc(desc_str, level=level) + + def add_function_base(self, func, x: RstBuilder, is_free=True, level=0): + namespace = func.parent_fully_qualified_name if is_free else None + x.add_function(func.declaration, namespace, level=level) + if func.doc and func.doc.description: + self.add_description(func.doc.description, x, level=level + 1) + self.add_params('tparam', func.template_parameters, x, level=level + 1) + self.add_params('param', func.parameters, x, level=level + 1) + x.add_blank_line() + if func.doc: + self.add_preconditions(func.doc.preconditions, x, level=level + 1) + self.add_postconditions(func.doc.postconditions, x, level=level + 1) + + def add_params(self, tag, params, x: RstBuilder, level=0): + for param in params: + if param.description: + desc_str = self.format_description(param.description) + x.add_param(tag, param.name, desc_str, level=level) + + def add_listing(self, model_object, x: RstBuilder, remove_empty_lines=False): + listing = self.ctx.listing.read(model_object, remove_empty_lines) + x.add_code_block(listing) + + def add_invariants(self, invariants, x: RstBuilder, level=0): + if invariants: + x('Invariants', level=level) + for invariant in invariants: + x.add(f'| ' + self.format_description(invariant), level=level + 1) + x.add_blank_line() + + def add_preconditions(self, preconditions, x: RstBuilder, level=0): + if preconditions: + x('Preconditions', level=level) + for precondition in preconditions: + x.add(f'| ' + self.format_description(precondition), level=level + 1) + x.add_blank_line() + + def add_postconditions(self, postconditions, x: RstBuilder, level=0): + if postconditions: + x('Postconditions', level=level) + for postcondition in postconditions: + x.add(f'| ' + self.format_description(postcondition), level=level + 1) + x.add_blank_line() + + +@directive +class ClassDirective(DoxyDirective): + required_arguments = 1 + optional_arguments = 0 + has_content = False + + def rst(self, x: RstBuilder): + class_ = self.ctx.index.find(self.arguments[0]) + if self.ctx.listing_enabled: + self.add_listing(class_, x) + sphinx_class_decl = (f'{class_.template_declaration} {class_.name}' + if class_.template_declaration else class_.name) + x.add_class(class_.kind, sphinx_class_decl, + class_.parent_fully_qualified_name) + self.add_params('tparam', class_.template_parameters, x, level=1) + x.add_blank_line() + self.add_static_methods(class_, x) + self.add_constructors(class_, x) + self.add_methods(class_, x) + self.add_properties(class_, x) + + def add_static_methods(self, class_, x: RstBuilder): + static_methods = [func for func in class_.static_functions + if func.return_type.strip()] + if static_methods: + x.add('**Public Static Methods**', level=1) + x.add_blank_line() + for method in static_methods: + self.add_function_base(method, x, level=1) + + def add_constructors(self, class_, x: RstBuilder): + ctors = [func for func in class_.functions + if not func.return_type.strip()] + if ctors: + x.add('**Constructors**', level=1) + x.add_blank_line() + for ctor in ctors: + self.add_function_base(ctor, x, level=1) + + def add_methods(self, class_, x: RstBuilder): + methods = [func for func in class_.functions + if func.return_type.strip()] + if methods: + x.add('**Public Methods**', level=1) + x.add_blank_line() + for method in methods: + self.add_function_base(method, x, level=1) + + def add_properties(self, class_def, x: RstBuilder): + if class_def.properties: + x.add('**Properties**', level=1) + x.add_blank_line() + for property_def in class_def.properties: + self.add_property(property_def, x) + + def add_property(self, property_def, x: RstBuilder): + x.add_property_member(property_def.declaration, + property_def.parent_fully_qualified_name, + level=1) + if property_def.doc and property_def.doc.description: + desc = self.format_description(property_def.doc.description) + if desc: + x.add_doc(desc, level=2) + else: + print(f'WARNING: oneDAL property `{property_def.fully_qualified_name}` is not documented') + if property_def.getter or property_def.setter: + x('Getter & Setter', level=2) + if property_def.getter: + x(f'| ``{property_def.getter.declaration}``', level=3) + if property_def.setter: + x(f'| ``{property_def.setter.declaration}``', level=3) + x() + if property_def.doc: + invariants = property_def.doc.invariants + self.add_invariants(invariants, x, level=2) + + +@directive +class FunctionDirective(DoxyDirective): + required_arguments = 1 + optional_arguments = 0 + has_content = False + + def rst(self, x: RstBuilder): + func = self.ctx.index.find(self.arguments[0]) + if self.ctx.listing_enabled: + self.add_listing(func, x) + self.add_function_base(func, x, is_free=True) + +@directive +class EnumClassDirective(DoxyDirective): + required_arguments = 1 + optional_arguments = 0 + has_content = False + + def rst(self, x: RstBuilder): + enum = self.ctx.index.find(self.arguments[0]) + namespace = enum.parent_fully_qualified_name + + if self.ctx.listing_enabled: + self.add_listing(enum, x) + x.add_blank_line() + x.add_enumclass(enum.name, namespace) + + for value in enum.values: + x.add(f'{enum.name}::{value.name}', level=1) + + if value.doc and value.doc.description: + self.add_description(value.doc.description, x, level=2) + + +@directive +class ListingDirective(DoxyDirective): + required_arguments = 1 + optional_arguments = 0 + has_content = False + + def rst(self, x: RstBuilder): + model_object = self.ctx.index.find(self.arguments[0]) + listing = self.ctx.listing.read(model_object) + x.add_code_block(listing) + + +@directive +class TagsNamespaceDirective(DoxyDirective): + required_arguments = 1 + optional_arguments = 0 + has_content = False + + def rst(self, x: RstBuilder): + methods_namespace = self.arguments[0] + method_ns = self.ctx.index.find(methods_namespace) + if self.ctx.listing_enabled: + self.add_listing(method_ns, x, remove_empty_lines=True) + self._add_classes(method_ns, x) + self._add_typedefs(method_ns, x) + + def _add_classes(self, method_ns, x: RstBuilder): + for class_ref in method_ns.class_refs: + class_fqn = class_ref.fully_qualified_name + class_ = self.ctx.index.find(class_fqn) + x.add_class(class_.kind, class_.name, class_.parent_fully_qualified_name) + if class_.doc and class_.doc.description: + self.add_description(class_.doc.description, x, level=1) + + def _add_typedefs(self, method_ns, x: RstBuilder): + for typedef in method_ns.typedefs: + sphinx_decl = f'{typedef.name} = {typedef.type}' + x.add_typedef(sphinx_decl, typedef.parent_fully_qualified_name) + if typedef.doc and typedef.doc.description: + self.add_description(typedef.doc.description, x, level=1) diff --git a/docs/dalapi/doxypy/__init__.py b/docs/dalapi/doxypy/__init__.py new file mode 100644 index 00000000000..f328dafcda2 --- /dev/null +++ b/docs/dalapi/doxypy/__init__.py @@ -0,0 +1,21 @@ +# file: __init__.py +#=============================================================================== +# Copyright 2019-2020 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +#=============================================================================== + +from .index import Index, index, to_dict, to_json, to_yaml +from .loader import TransformerPass +from .listing import ListingReader +from . import model diff --git a/docs/dalapi/doxypy/builder.py b/docs/dalapi/doxypy/builder.py new file mode 100644 index 00000000000..4e96a04be1a --- /dev/null +++ b/docs/dalapi/doxypy/builder.py @@ -0,0 +1,484 @@ +# file: builder.py +#=============================================================================== +# Copyright 2019-2020 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +#=============================================================================== + +import os +import re +import sys + +from typing import ( + Any, + Dict, + List, + Text, + Union, +) + +from . import model +from . import utils +from .parser.compound import compounddefType as _CompoundDefType + +def build(BuilderType, *args, **kwargs): + return BuilderType(*args, **kwargs).build() + +class _BuilderMixins(object): + def __init__(self, src): + assert src + self.src = src + + def textify(self, text_like) -> Text: + return self._read_inner_text(text_like).strip() + + def split_compound_name(self, compoundname): + return utils.split_compound_name(compoundname) + + def find_parent(self, matcher): + current = self.src + while current: + current = current.parent_object_ + if matcher(current): + return current + + def build_doc(self): + brief = self.src.briefdescription + detailed = self.src.detaileddescription + description = detailed if len(detailed.para) > 0 else brief + return build(DocBuilder, description) + + def build_template(self): + template_params = self._build_template_parameters() + template_decl = self._build_template_declaration(template_params) + return template_decl, template_params + + def build_location(self): + if self.src.location: + return build(LocationBuilder, self.src.location) + + @utils.return_list + def _build_template_parameters(self): + if self.src.templateparamlist: + for param in self.src.templateparamlist.param: + yield build(ParameterBuilder, param, is_template=True) + + def _build_template_declaration(self, template_parameters): + template_entries = [] + for param in template_parameters: + template_entry = f'{param.type} {param.name}' + if param.default: + template_entry += f' = {param.default}' + template_entries.append(template_entry) + return (f'template <{", ".join(template_entries)}>' + if template_entries else None) + + def _read_inner_text(self, text_like) -> Text: + text = '' + if isinstance(text_like, str): + text = text_like + elif hasattr(text_like, 'content_'): + for content in text_like.content_: + text += self._read_inner_text(content.value) + elif hasattr(text_like, 'valueOf_'): + text = text_like.valueOf_ + return text + + +class DescriptionBuilder(_BuilderMixins): + def build(self): + return model.Description( + runs = self._remove_trailing_runs(self._build_runs()), + ) + + def _remove_trailing_runs(self, runs): + end_index = - 1 + for i in range(len(runs) - 1, -1, -1): + if runs[i].content.strip(): + end_index = i + break + return runs[:end_index + 1] + + @utils.return_list + def _build_runs(self): + content_ = (content for para in self.src.para + for content in para.content_) + for content in content_: + if content.name == 'computeroutput': + code = self.textify(content.value) + yield model.Run(code, 'code') + if content.name == 'formula': + formula = self.textify(content.value) + yield model.Run(formula.replace('$', ''), 'math') + elif not content.name: + if content.value.strip('\n\r\t'): + yield from self._split_math(content.value) + + def _split_math(self, text): + for i, chunk in enumerate(text.split('$')): + if i % 2 and chunk: + yield model.Run(chunk, 'math') + elif chunk: + yield model.Run(chunk, 'text') + + +class LocationBuilder(_BuilderMixins): + def build(self): + return model.Location( + file = self.src.file, + line = int(self.src.line) if self.src.line else None, + bodyfile = self.src.bodyfile if self.src.bodyfile else None, + bodystart = int(self.src.bodystart) if self.src.bodystart else None, + bodyend = int(self.src.bodyend) if self.src.bodyend else None, + ) + + +class DocBuilder(_BuilderMixins): + def build(self): + return model.Doc( + description = build(DescriptionBuilder, self.src), + invariants = self._build_simplesect('invariant'), + preconditions = self._build_simplesect('pre'), + postconditions = self._build_simplesect('post'), + remarks = self._build_simplesect('remark'), + ) + + @utils.return_list + def _build_simplesect(self, kind: str): + for simplesect in self._filter_simplesect(kind): + yield build(DescriptionBuilder, simplesect) + + def _filter_simplesect(self, kind: str): + return (simplesect + for para in self.src.para + for simplesect in para.simplesect + if simplesect.kind == kind + ) + + +class ParameterBuilder(_BuilderMixins): + def __init__(self, src, is_template=False): + super().__init__(src) + self.is_template = is_template + + def build(self): + name = self.textify(self.src.declname) + type_ = self.textify(self.src.type_) + default = self.textify(self.src.defval) + # Sometimes, Doxygen fuses the type with the name + # of template parameter and stores it in the `type` field. + if not name and self.is_template: + try: + type_, name = type_.rsplit(' ', 1) + except ValueError: + pass + return model.Parameter( + name = name if name else None, + type = type_ if type_ else None, + default = default if default else None, + description = self._build_description(name), + ) + + def _build_description(self, param_name): + try: + doc = self._find_parent_doc() + param_desc = self._find_param_description(doc, param_name) + if param_desc: + return build(DescriptionBuilder, param_desc) + except (AttributeError, IndexError): + pass + + def _find_param_description(self, doc, param_name): + param_kind = 'templateparam' if self.is_template else 'param' + param_list = self._find_parameter_list(doc, param_kind) + for parameteritem in param_list.parameteritem: + parametername = parameteritem.parameternamelist[0].parametername[0] + if self.textify(parametername) == param_name: + return parameteritem.parameterdescription + + def _find_parent_doc(self): + def has_detailed_description(node): + return hasattr(node, 'detaileddescription') + parent = self.find_parent(has_detailed_description) + return parent.detaileddescription + + def _find_parameter_list(self, doc, kind): + parameterlist_ = (parameterlist + for para in doc.para + for parameterlist in para.parameterlist + ) + for parameterlist in parameterlist_: + if parameterlist.kind == kind: + return parameterlist + + +class EnumClassValueBuilder(_BuilderMixins): + def build(self): + return model.EnumClassValue( + doc = self.build_doc(), + name = self._find_name(), + ) + + def _find_name(self): + for entry in self.src.content_: + if entry.name == 'name': + return entry.value + +class EnumClassBuilder(_BuilderMixins): + def build(self): + name = self.textify(self.src.name) + parent_fqn, fqn = self._build_fqn(name) + return model.EnumClass( + doc = self.build_doc(), + name = name, + values = self._build_values(), + location = self.build_location(), + fully_qualified_name = fqn, + parent_fully_qualified_name = parent_fqn, + ) + + @utils.return_list + def _build_values(self): + for enumvalue in self.src.enumvalue: + yield build(EnumClassValueBuilder, enumvalue) + + def _build_fqn(self, name): + compound = self._find_parent_compound() + parent_fqn = self.textify(compound.compoundname) + fqn = f'{parent_fqn}::{name}' if parent_fqn else name + return parent_fqn, fqn + + def _find_parent_compound(self): + def compound_matcher(node): + return isinstance(node, _CompoundDefType) + return self.find_parent(compound_matcher) + +class FunctionBuilder(_BuilderMixins): + def build(self): + name = self.textify(self.src.name) + argstring = self.textify(self.src.argsstring) + return_type = self.textify(self.src.type_) + template_decl, template_params = self.build_template() + qualifiers = self._build_qualifiers(self.src) + decl = self._build_declaration(template_decl, + qualifiers, return_type, + name, argstring) + parent_fqn, fqn = self._build_fqn(name) + return model.Function( + doc = self.build_doc(), + name = name, + location = self.build_location(), + argstring = argstring, + parameters = self._build_params(), + declaration = decl, + return_type = return_type, + template_parameters = template_params, + template_declaration = template_decl, + fully_qualified_name = fqn, + parent_fully_qualified_name = parent_fqn, + ) + + @utils.return_list + def _build_params(self): + for param in self.src.param: + yield build(ParameterBuilder, param) + + def _build_qualifiers(self, src): + qualifiers = [] + if src.static == 'yes': + qualifiers.append('static') + + return ' '.join(qualifiers) + + def _build_declaration(self, template_decl, qualifiers, return_type, name, argstring): + decl = '' + if template_decl: + decl += template_decl + ' ' + if qualifiers: + decl += qualifiers + ' ' + if return_type: + decl += return_type + ' ' + decl += name + argstring + return decl + + def _build_fqn(self, name): + compound = self._find_parent_compound() + parent_fqn = self.textify(compound.compoundname) + fqn = f'{parent_fqn}::{name}' if parent_fqn else name + return parent_fqn, fqn + + def _find_parent_compound(self): + def compound_matcher(node): + return isinstance(node, _CompoundDefType) + return self.find_parent(compound_matcher) + + +class ClassBuilder(_BuilderMixins): + def build(self): + fqn = self.textify(self.src.compoundname) + namespace, name = self.split_compound_name(fqn) + template_decl, template_params = self.build_template() + decl = self._build_declaration(template_decl, name) + return model.Class( + doc = self.build_doc(), + name = name, + kind = self.textify(self.src.kind), + location = self.build_location(), + functions = self._build_methods(), + static_functions = self._build_methods('static-func'), + declaration = decl, + template_parameters = template_params, + template_declaration = template_decl, + fully_qualified_name = fqn, + parent_fully_qualified_name = namespace, + ) + + @utils.return_list + def _build_methods(self, kind='func'): + public_func_memberdef = (memberdef + for sectiondef in self.src.sectiondef + if sectiondef.kind == f'public-{kind}' + for memberdef in sectiondef.memberdef + if memberdef.kind == 'function' + ) + for memberdef in public_func_memberdef: + yield build(FunctionBuilder, memberdef) + + def _build_declaration(self, template_decl, name): + decl = '' + if template_decl: + decl += template_decl + ' ' + decl += f'class {name}' + return decl + + +class ClassRefBuilder(_BuilderMixins): + def build(self): + fqn = self.textify(self.src) + parent_fqn, name = self.split_compound_name(fqn) + return model.ClassRef( + name = name, + fully_qualified_name = fqn, + parent_fully_qualified_name = parent_fqn, + ) + + +class TypedefBuilder(_BuilderMixins): + def build(self): + name = self.textify(self.src.name) + decl = self.textify(self.src.definition) + template_decl, template_params = self.build_template() + parent_fqn, fqn = self._build_fqn(name) + return model.Typedef( + doc = self.build_doc(), + name = name, + type = self.textify(self.src.type_), + location = self.build_location(), + declaration= self._build_declaration(template_decl, decl), + template_parameters = template_params, + template_declaration = template_decl, + fully_qualified_name = fqn, + parent_fully_qualified_name = parent_fqn, + ) + + def _build_fqn(self, name): + compound = self._find_parent_compound() + parent_fqn = self.textify(compound.compoundname) + fqn = f'{parent_fqn}::{name}' if parent_fqn else name + return parent_fqn, fqn + + def _find_parent_compound(self): + def compound_matcher(node): + return isinstance(node, _CompoundDefType) + return self.find_parent(compound_matcher) + + def _build_declaration(self, template_decl, nob_template_decl): + decl = '' + if template_decl: + decl += template_decl + ' ' + decl += nob_template_decl + return decl + + +class NamespaceBuilder(_BuilderMixins): + def build(self): + fqn = self.textify(self.src.compoundname) + parent_name, name = self.split_compound_name(fqn) + return model.Namespace( + doc = self.build_doc(), + name = name, + location = self.build_location(), + typedefs = self._build_typedefs(), + functions = self._build_functions(), + class_refs = self._build_class_refs(), + enum_classes = self._build_enums(), + fully_qualified_name = fqn, + parent_fully_qualified_name = parent_name, + ) + + @utils.return_list + def _build_functions(self): + func_memberdef = (memberdef + for sectiondef in self.src.sectiondef + if sectiondef.kind == 'func' + for memberdef in sectiondef.memberdef + if memberdef.kind == 'function' + ) + for memberdef in func_memberdef: + yield build(FunctionBuilder, memberdef) + + @utils.return_list + def _build_typedefs(self): + typedef_memberdef = (memberdef + for sectiondef in self.src.sectiondef + if sectiondef.kind == 'typedef' + for memberdef in sectiondef.memberdef + if memberdef.kind == 'typedef' + ) + for typedef in typedef_memberdef: + yield build(TypedefBuilder, typedef) + + @utils.return_list + def _build_enums(self): + enum_classes = (memberdef + for sectiondef in self.src.sectiondef + if sectiondef.kind == 'enum' + for memberdef in sectiondef.memberdef + if memberdef.kind == 'enum' + ) + for enumclass in enum_classes: + yield build(EnumClassBuilder, enumclass) + + @utils.return_list + def _build_class_refs(self): + for innerclass in self.src.innerclass: + yield build(ClassRefBuilder, innerclass) + + +class ModelBuilder(_BuilderMixins): + builder_map = { + 'class': ClassBuilder, + 'struct': ClassBuilder, + 'func': FunctionBuilder, + 'namespace': NamespaceBuilder, + 'typedef': TypedefBuilder, + 'enum' : EnumClassBuilder, + } + + def build(self): + allowed_kinds = ModelBuilder.builder_map.keys() + if self.src.kind not in allowed_kinds: + raise ValueError(f'Unexpected kind of Doxygen\'s compounddef "{self.src.kind}" ', + f'only {", ".join(sorted(allowed_kinds))} are supported') + BuilderType = ModelBuilder.builder_map[self.src.kind] + return build(BuilderType, self.src) diff --git a/docs/dalapi/doxypy/cli.py b/docs/dalapi/doxypy/cli.py new file mode 100644 index 00000000000..f8b6776a05c --- /dev/null +++ b/docs/dalapi/doxypy/cli.py @@ -0,0 +1,35 @@ +# file: cli.py +#=============================================================================== +# Copyright 2019-2020 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +#=============================================================================== + +from .index import index, to_yaml + +if __name__ == "__main__": + import argparse + args = argparse.ArgumentParser('doxypy: The Doxygen parser for Python') + args.add_argument('dir', type=str, + help='Path to the directory with Doxygen XML output') + args.add_argument('--compact', action='store_true', default=False, + help='Does not include empty fields into output') + # TODO + # args.add_argument('--only-functions', action='store_true', default=False, + # help='If provided, displays only functions') + # args.add_argument('--filter', type=str, default=None, + # help='Enables parsing only for the matched names') + config = args.parse_args() + + idx = index(config.dir) + print(to_yaml(idx, discard_empty=config.compact, indent=2)) diff --git a/docs/dalapi/doxypy/index.py b/docs/dalapi/doxypy/index.py new file mode 100644 index 00000000000..78cfdc88f5b --- /dev/null +++ b/docs/dalapi/doxypy/index.py @@ -0,0 +1,129 @@ +# file: index.py +#=============================================================================== +# Copyright 2019-2020 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +#=============================================================================== + +from typing import List, Text +from . import utils +from . import model +from .parser import Parser +from .loader import ModelLoader, Transformer, TransformerPass + +class _IndexEntry(object): + def __init__(self, loader: ModelLoader, refid: Text): + self._loader = loader + self._refid = refid + self._model = None + + @property + def model(self): + if not self._model: + self._model = self._loader.load(self._refid) + try: + self._on_content_loaded(self._model) + except AttributeError: + pass + return self._model + + +class Index(object): + def __init__(self, parser: Parser, loader: ModelLoader): + assert parser + assert loader + self._parser = parser + self._loader = loader + self._index = self._initialize() + + def find(self, query: str): + try: + model = self._index[query].model + except KeyError: + try: + model = self._find_inner(query) + except KeyError: + raise KeyError(f'Cannot find "{query}"') + return model + + @utils.return_dict + def _initialize(self): + index = self._parser.parse('index') + allowed_kinds = {'class', 'struct', 'namespace', 'typedef'} + for entry in index.compound: + if entry.kind in allowed_kinds: + model_object = _IndexEntry(self._loader, entry.refid) + yield entry.name, model_object + + def _find_inner(self, query): + parent_name, name = utils.split_compound_name(query) + model = self._index[parent_name].model + attrs_to_check = [ 'functions', 'typedefs', 'enum_classes' ] + try: + for attr in attrs_to_check: + for inner in getattr(model, attr): + if inner.name == name: + return inner + except AttributeError: + pass + raise KeyError(f'Cannot find {name} inside {parent_name}') + + +def index(doxygen_xml_dir: Text, + transformer_passes: List[TransformerPass] = []) -> Index: + parser = Parser(doxygen_xml_dir) + transformer = Transformer(transformer_passes) + loader = ModelLoader(parser, transformer) + return Index(parser, loader) + +def to_dict(index: Index, discard_empty=False): + index_dict = _to_dict(index) + if discard_empty: + index_dict = _discard_empty(index_dict) + return index_dict + +def to_json(index: Index, discard_empty=False, **kwargs): + import json + return json.dumps(to_dict(index, discard_empty), **kwargs) + +def to_yaml(index: Index, discard_empty=False, **kwargs): + import yaml + return yaml.dump(to_dict(index, discard_empty), **kwargs) + +@utils.return_dict +def _to_dict(index: Index): + for k, v in index._index.items(): + yield k, _index_to_dict(v.model) + +def _discard_empty(obj): + if isinstance(obj, list): + gen = (_discard_empty(x) for x in obj) + obj = [x for x in gen if x] + elif isinstance(obj, dict): + gen = ((k, _discard_empty(x)) for k, x in obj.items()) + obj = {k: x for k, x in gen if x} + if obj: + return obj + +def _index_to_dict(obj, discard_empty=False): + if isinstance(obj, list): + return [_index_to_dict(x) for x in obj] + elif isinstance(obj, dict): + return {k: _index_to_dict(x) for k, x in obj.items()} + elif model.has_fields(obj): + obj_dict = {} + for field in obj.iter(): + value = getattr(obj, field) + obj_dict[field] = _index_to_dict(value) + return obj_dict + return obj diff --git a/docs/dalapi/doxypy/listing.py b/docs/dalapi/doxypy/listing.py new file mode 100644 index 00000000000..b1d4a91c4e2 --- /dev/null +++ b/docs/dalapi/doxypy/listing.py @@ -0,0 +1,138 @@ +# file: listing.py +#=============================================================================== +# Copyright 2019-2020 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +#=============================================================================== + +import os +import re +from typing import ( + List, + Text, + Union, +) +from . import model +from . import utils + +class DeclarationError(Exception): + pass + + +# _getter_re = re.compile(r' get_\w+ *\(') +# _setter_re = re.compile(r' set_\w+ *\(') +# def _group_accessors(self, listing): +# getter_re = FileListingReader._getter_re +# setter_re = FileListingReader._setter_re +# getter_match = False +# setter_match = False +# line_stack = [] +# for line in listing: +# if line: +# local_getter_match = getter_re.search(line) +# local_setter_match = setter_re.search(line) +# if (getter_match and local_getter_match or +# setter_match and local_setter_match): +# if line_stack[-1] == '': +# line_stack.pop() +# getter_match = local_getter_match +# setter_match = local_setter_match +# line_stack.append(line) +# return line_stack + + +class _ListingEntry(object): + def __init__(self, base_dir, model_object): + self._base_dir = base_dir + self._filename = model_object.location.file + self._model_object = model_object + self._content = None + + @utils.return_list + def read(self, remove_empty_lines: bool): + if not self._content: + filename = os.path.join(self._base_dir, self._filename) + with open(filename, 'r') as f: + self._content = self._read(f.readlines()) + if remove_empty_lines: + for line in self._content: + if line.strip(): + yield line + else: + yield from self._content + + @utils.return_list + def _read(self, lines): + start_index = self._find_start_index(lines) + if start_index is None: + raise DeclarationError( + f'Cannot find the beginning of declaration for the' + f'{self._model_object.fully_qualified_name} in {self._filename}' + ) + end_index = self._find_end_index(lines, start_index) + if end_index is None: + raise DeclarationError( + f'Cannot find the end of declaration for the ' + f'{self._model_object.fully_qualified_name} in {self._filename}' + ) + for i in range(start_index, end_index + 1): + line = lines[i].strip() + if not line.startswith('/'): + yield lines[i].rstrip() + + def _find_start_index(self, lines): + assert self._model_object.location.line > 0 + line_index = self._model_object.location.line - 1 + if line_index == 0: + return 0 + # Note: Handles only the case if there is a blank + # line or comment before the declaration + for i in range(line_index, -1, -1): + line = lines[i].strip() + if not line or line.startswith('/'): + return i + 1 + + def _find_end_index(self, lines, start_index): + bodyend = self._model_object.location.bodyend + if bodyend is not None and bodyend > start_index: + return bodyend - 1 + if isinstance(self._model_object, model.Namespace): + return self._find_namespace_end(lines, start_index) + else: + return self._find_line_index(lines, start_index, ';') + + def _find_namespace_end(self, lines, start_index): + brace_counter = 0 + for i in range(start_index, len(lines)): + brace_counter += lines[i].count('{') + if brace_counter > 0: + brace_counter -= lines[i].count('}') + if brace_counter <= 0: + return i + + def _find_line_index(self, lines, start_index, trigger): + for i in range(start_index, len(lines)): + if trigger in lines[i]: + return i + + +class ListingReader(object): + def __init__(self, base_dir): + self._base_dir = base_dir + self._cache = {} + + def read(self, model_object, remove_empty_lines=False) -> List[Text]: + fqn = model_object.fully_qualified_name + if fqn not in self._cache: + self._cache[fqn] = _ListingEntry(self._base_dir, model_object) + return self._cache[fqn].read(remove_empty_lines) diff --git a/docs/dalapi/doxypy/loader.py b/docs/dalapi/doxypy/loader.py new file mode 100644 index 00000000000..313efcd390a --- /dev/null +++ b/docs/dalapi/doxypy/loader.py @@ -0,0 +1,72 @@ +# file: loader.py +#=============================================================================== +# Copyright 2019-2020 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +#=============================================================================== + +from typing import List +from . import model +from .parser import Parser +from .builder import build, ModelBuilder + +class TransformerPass(object): + def enter(self, node): ... + def transform(self, node): ... + +class Transformer(model.Visitor): + default_passes = [] + + def __init__(self, passes: List[TransformerPass] = []): + assert passes is not None + self._passes = Transformer.default_passes + passes + self._current_pass = None + + def transform(self, node): + for transformer_pass in self._passes: + self._current_pass = transformer_pass + model.visit(node, self) + + def enter(self, node): + return self._current_pass.enter(node) + + def leave(self, node): + self._current_pass.transform(node) + + +class ModelLoader(object): + def __init__(self, parser: Parser, transformer: Transformer): + assert parser + assert transformer + self._parser = parser + self._transformer = transformer + self._cache = {} + + def load(self, refid): + assert refid + if refid == 'index': + raise ValueError('Index cannot be loaded as a model') + model = self._cache.get(refid, None) + if not model: + model = self._load(refid) + self._cache[refid] = model + return model + + def _load(self, refid): + doxygen = self._parser.parse(refid) + if len(doxygen.compounddef) != 1: + raise ValueError(f'Cannot interpet Doxygen output, ' + f'unexpected content of the {refid} file') + node = build(ModelBuilder, doxygen.compounddef[0]) + self._transformer.transform(node) + return node diff --git a/docs/dalapi/doxypy/model.py b/docs/dalapi/doxypy/model.py new file mode 100644 index 00000000000..e97aa94a3be --- /dev/null +++ b/docs/dalapi/doxypy/model.py @@ -0,0 +1,209 @@ +# file: model.py +#=============================================================================== +# Copyright 2019-2020 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +#=============================================================================== + +from typing import ( + Any, + Dict, + List, + Text, + Union, +) + +from collections import namedtuple + +def has_fields(obj): + return hasattr(obj, '__fields__') + +def iter_fields(obj): + for attr in dir(obj): + is_public = not attr.startswith('_') + is_callable = callable(getattr(obj, attr)) + if is_public and not is_callable: + yield attr + +def _iter_model_object(obj, is_root=True): + if isinstance(obj, list): + for v in obj: + yield from _iter_model_object(v, is_root=False) + elif isinstance(obj, dict): + for k, v in obj.items(): + yield from _iter_model_object(v, is_root=False) + elif has_fields(obj): + if is_root: + for field in iter_fields(obj): + yield from _iter_model_object(getattr(obj, field), + is_root=False) + else: + yield obj + + +class _ModelProperty(object): + def __init__(self, var_name): + self._var_name = var_name + + def __get__(self, instance, owner): + if instance: + return getattr(instance, self._var_name) + return self + + def __set__(self, instance, value): + if instance: + return setattr(instance, self._var_name, value) + return self + + +def model_object(cls): + fields = tuple(iter_fields(cls)) + defaults = tuple(getattr(cls, f) for f in fields) + + for field, default in zip(fields, defaults): + setattr(cls, field, _ModelProperty(f'_{field}')) + + # __init__ + s = f'def __init__(self, {", ".join(fields)}): \n' + for field in fields: + s += f' self._{field} = {field}\n' + + # __repr__ + repr_str = ', '.join(f'{f}={{self._{f}}}' for f in fields) + s += f'def __repr__(self):\n' + s += f' return f"{{type(self).__name__}}({repr_str})"' + + namespace = {'__name__': f'__model_{cls.__name__}'} + exec(s, namespace) + + cls.__fields__ = fields + cls.__init__ = namespace['__init__'] + cls.__init__.__defaults__ = defaults + cls.__repr__ = namespace['__repr__'] + cls.iter = iter_fields + return cls + + +@model_object +class Run(object): + content: Text = None + kind: Text = 'unknown' + +@model_object +class Description(object): + runs: List[Run] = [] + +@model_object +class Doc(object): + invariants: List[Description] = [] + postconditions: List[Description] = [] + preconditions: List[Description] = [] + remarks: List[Description] = [] + description: Description = None + +@model_object +class Location(object): + file: Text = None + line: int = -1 + bodyfile: Text = None + bodyend: int = -1 + bodystart: int = -1 + +@model_object +class Parameter(object): + name: Text = None + type: Text = None + default: Text = None + description: Description = None + +@model_object +class Typedef(object): + doc: Doc = None + name: Text = None + type: Text = None + location: Location = None + declaration: Text = None + template_declaration: Text = None + template_parameters: List[Parameter] = [] + fully_qualified_name: Text = None + parent_fully_qualified_name: Text = None + +@model_object +class EnumClassValue(object): + doc: Doc = None + name: Text = None + +@model_object +class EnumClass(object): + doc: Doc = None + name: Text = None + values: List[EnumClassValue] = [] + location: Location = None + fully_qualified_name: Text = None + parent_fully_qualified_name: Text = None + +@model_object +class Function(object): + doc: Doc = None + name: Text = None + location: Location = None + argstring: Text = None + parameters: List[Parameter] = [] + declaration: Text = None + return_type: Text = None + template_parameters: List[Parameter] = [] + template_declaration: Text = None + fully_qualified_name: Text = None + parent_fully_qualified_name: Text = None + +@model_object +class Class(object): + doc: Doc = None + kind: Text = None + name: Text = None + location: Location = None + functions: List[Function] = [] + static_functions: List[Function] = [] + declaration: Text = None + template_parameters: List[Parameter] = [] + template_declaration: Text = None + fully_qualified_name: Text = None + parent_fully_qualified_name: Text = None + +@model_object +class ClassRef(object): + name: Text = None + fully_qualified_name: Text = None + parent_fully_qualified_name: Text = None + +@model_object +class Namespace(object): + doc: Doc = None + name: Text = None + typedefs: List[Typedef] = [] + location: Location = None + functions: List[Function] = [] + class_refs: List[ClassRef] = [] + enum_classes: List[EnumClass] = [] + fully_qualified_name: Text = None + parent_fully_qualified_name: Text = None + +class Visitor(object): + def enter(self, node): ... + def leave(self, node): ... + +def visit(node, visitor: Visitor): + if visitor.enter(node): + for child in _iter_model_object(node): + visit(child, visitor) + visitor.leave(node) diff --git a/docs/dalapi/doxypy/parser/__init__.py b/docs/dalapi/doxypy/parser/__init__.py new file mode 100644 index 00000000000..b0cd1c42548 --- /dev/null +++ b/docs/dalapi/doxypy/parser/__init__.py @@ -0,0 +1,40 @@ +# file: __init__.py +#=============================================================================== +# Copyright 2019-2020 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +#=============================================================================== + +import os +from typing import ( + Any, + Dict, + List, + Text, + Union, +) +from .index import parse as parse_index +from .compound import parse as parse_compound + +class Parser(object): + def __init__(self, xml_dir: Text): + self._dir = xml_dir + + def parse(self, refid): + xml_filename = self._resolve_path(refid) + parse = parse_index if refid == 'index' else parse_compound + return parse(xml_filename, silence=True) + + def _resolve_path(self, refid): + xml_name = os.path.join(self._dir, refid) + return f'{xml_name}.xml' diff --git a/docs/dalapi/doxypy/parser/compound.py b/docs/dalapi/doxypy/parser/compound.py new file mode 100644 index 00000000000..681471ed832 --- /dev/null +++ b/docs/dalapi/doxypy/parser/compound.py @@ -0,0 +1,44785 @@ +#!/usr/bin/env python + +# file: compound.py +#=============================================================================== +# Copyright 2019-2020 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +#=============================================================================== + +# -*- coding: utf-8 -*- + +# +# Generated Fri Apr 24 19:24:13 2020 by generateDS.py version 2.35.21. +# Python 3.6.10 |Anaconda, Inc.| (default, Mar 25 2020, 23:51:54) [GCC 7.3.0] +# +# Command line options: +# ('-o', './dalapi/compound_parser.py') +# +# Command line arguments: +# ./doxygen/xml/compound.xsd +# +# Command line: +# /root/miniconda3/envs/spec/bin/generateDS -o "./dalapi/compound_parser.py" ./doxygen/xml/compound.xsd +# +# Current working directory (os.getcwd()): +# oneDAL +# + +from six.moves import zip_longest +import os +import sys +import re as re_ +import base64 +import datetime as datetime_ +import decimal as decimal_ +from lxml import etree as etree_ + + +Validate_simpletypes_ = True +SaveElementTreeNode = True +if sys.version_info.major == 2: + BaseStrType_ = basestring +else: + BaseStrType_ = str + + +def parsexml_(infile, parser=None, **kwargs): + if parser is None: + # Use the lxml ElementTree compatible parser so that, e.g., + # we ignore comments. + try: + parser = etree_.ETCompatXMLParser() + except AttributeError: + # fallback to xml.etree + parser = etree_.XMLParser() + try: + if isinstance(infile, os.PathLike): + infile = os.path.join(infile) + except AttributeError: + pass + doc = etree_.parse(infile, parser=parser, **kwargs) + return doc + +def parsexmlstring_(instring, parser=None, **kwargs): + if parser is None: + # Use the lxml ElementTree compatible parser so that, e.g., + # we ignore comments. + try: + parser = etree_.ETCompatXMLParser() + except AttributeError: + # fallback to xml.etree + parser = etree_.XMLParser() + element = etree_.fromstring(instring, parser=parser, **kwargs) + return element + +# +# Namespace prefix definition table (and other attributes, too) +# +# The module generatedsnamespaces, if it is importable, must contain +# a dictionary named GeneratedsNamespaceDefs. This Python dictionary +# should map element type names (strings) to XML schema namespace prefix +# definitions. The export method for any class for which there is +# a namespace prefix definition, will export that definition in the +# XML representation of that element. See the export method of +# any generated element type class for an example of the use of this +# table. +# A sample table is: +# +# # File: generatedsnamespaces.py +# +# GenerateDSNamespaceDefs = { +# "ElementtypeA": "http://www.xxx.com/namespaceA", +# "ElementtypeB": "http://www.xxx.com/namespaceB", +# } +# +# Additionally, the generatedsnamespaces module can contain a python +# dictionary named GenerateDSNamespaceTypePrefixes that associates element +# types with the namespace prefixes that are to be added to the +# "xsi:type" attribute value. See the exportAttributes method of +# any generated element type and the generation of "xsi:type" for an +# example of the use of this table. +# An example table: +# +# # File: generatedsnamespaces.py +# +# GenerateDSNamespaceTypePrefixes = { +# "ElementtypeC": "aaa:", +# "ElementtypeD": "bbb:", +# } +# + +try: + from generatedsnamespaces import GenerateDSNamespaceDefs as GenerateDSNamespaceDefs_ +except ImportError: + GenerateDSNamespaceDefs_ = {} +try: + from generatedsnamespaces import GenerateDSNamespaceTypePrefixes as GenerateDSNamespaceTypePrefixes_ +except ImportError: + GenerateDSNamespaceTypePrefixes_ = {} + +# +# You can replace the following class definition by defining an +# importable module named "generatedscollector" containing a class +# named "GdsCollector". See the default class definition below for +# clues about the possible content of that class. +# +try: + from generatedscollector import GdsCollector as GdsCollector_ +except ImportError: + + class GdsCollector_(object): + + def __init__(self, messages=None): + if messages is None: + self.messages = [] + else: + self.messages = messages + + def add_message(self, msg): + self.messages.append(msg) + + def get_messages(self): + return self.messages + + def clear_messages(self): + self.messages = [] + + def print_messages(self): + for msg in self.messages: + print("Warning: {}".format(msg)) + + def write_messages(self, outstream): + for msg in self.messages: + outstream.write("Warning: {}\n".format(msg)) + + +# +# The super-class for enum types +# + +try: + from enum import Enum +except ImportError: + Enum = object + +# +# The root super-class for element type classes +# +# 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(object): + __hash__ = object.__hash__ + tzoff_pattern = re_.compile(r'(\+|-)((0\d|1[0-3]):[0-5]\d|14:00)$') + class _FixedOffsetTZ(datetime_.tzinfo): + def __init__(self, offset, name): + self.__offset = datetime_.timedelta(minutes=offset) + self.__name = name + def utcoffset(self, dt): + return self.__offset + def tzname(self, dt): + return self.__name + def dst(self, dt): + return None + def gds_format_string(self, input_data, input_name=''): + return input_data + def gds_parse_string(self, input_data, node=None, input_name=''): + return input_data + def gds_validate_string(self, input_data, node=None, input_name=''): + if not input_data: + return '' + return input_data + def gds_format_base64(self, input_data, input_name=''): + return base64.b64encode(input_data) + def gds_validate_base64(self, input_data, node=None, input_name=''): + return input_data + def gds_format_integer(self, input_data, input_name=''): + return '%d' % input_data + def gds_parse_integer(self, input_data, node=None, input_name=''): + try: + ival = int(input_data) + except (TypeError, ValueError) as exp: + raise_parse_error(node, 'Requires integer value: %s' % exp) + return ival + def gds_validate_integer(self, input_data, node=None, input_name=''): + try: + value = int(input_data) + except (TypeError, ValueError): + raise_parse_error(node, 'Requires integer value') + return value + def gds_format_integer_list(self, input_data, input_name=''): + return '%s' % ' '.join(input_data) + def gds_validate_integer_list( + self, input_data, node=None, input_name=''): + values = input_data.split() + for value in values: + try: + int(value) + except (TypeError, ValueError): + raise_parse_error(node, 'Requires sequence of integer valuess') + return values + def gds_format_float(self, input_data, input_name=''): + return ('%.15f' % input_data).rstrip('0') + def gds_parse_float(self, input_data, node=None, input_name=''): + try: + fval_ = float(input_data) + except (TypeError, ValueError) as exp: + raise_parse_error(node, 'Requires float or double value: %s' % exp) + return fval_ + def gds_validate_float(self, input_data, node=None, input_name=''): + try: + value = float(input_data) + except (TypeError, ValueError): + raise_parse_error(node, 'Requires float value') + return value + def gds_format_float_list(self, input_data, input_name=''): + return '%s' % ' '.join(input_data) + def gds_validate_float_list( + self, input_data, node=None, input_name=''): + values = input_data.split() + for value in values: + try: + float(value) + except (TypeError, ValueError): + raise_parse_error(node, 'Requires sequence of float values') + return values + def gds_format_decimal(self, input_data, input_name=''): + return_value = '%s' % input_data + if '.' in return_value: + return_value = return_value.rstrip('0') + if return_value.endswith('.'): + return_value = return_value.rstrip('.') + return return_value + def gds_parse_decimal(self, input_data, node=None, input_name=''): + try: + decimal_value = decimal_.Decimal(input_data) + except (TypeError, ValueError): + raise_parse_error(node, 'Requires decimal value') + return decimal_value + def gds_validate_decimal(self, input_data, node=None, input_name=''): + try: + value = decimal_.Decimal(input_data) + except (TypeError, ValueError): + raise_parse_error(node, 'Requires decimal value') + return value + def gds_format_decimal_list(self, input_data, input_name=''): + return ' '.join([self.gds_format_decimal(item) for item in input_data]) + def gds_validate_decimal_list( + self, input_data, node=None, input_name=''): + values = input_data.split() + for value in values: + try: + decimal_.Decimal(value) + except (TypeError, ValueError): + raise_parse_error(node, 'Requires sequence of decimal values') + return values + def gds_format_double(self, input_data, input_name=''): + return '%e' % input_data + def gds_parse_double(self, input_data, node=None, input_name=''): + try: + fval_ = float(input_data) + except (TypeError, ValueError) as exp: + raise_parse_error(node, 'Requires double or float value: %s' % exp) + return fval_ + def gds_validate_double(self, input_data, node=None, input_name=''): + try: + value = float(input_data) + except (TypeError, ValueError): + raise_parse_error(node, 'Requires double or float value') + return value + def gds_format_double_list(self, input_data, input_name=''): + return '%s' % ' '.join(input_data) + def gds_validate_double_list( + self, input_data, node=None, input_name=''): + values = input_data.split() + for value in values: + try: + float(value) + except (TypeError, ValueError): + raise_parse_error( + node, 'Requires sequence of double or float values') + return values + def gds_format_boolean(self, input_data, input_name=''): + return ('%s' % input_data).lower() + def gds_parse_boolean(self, input_data, node=None, input_name=''): + if input_data in ('true', '1'): + bval = True + elif input_data in ('false', '0'): + bval = False + else: + raise_parse_error(node, 'Requires boolean value') + return bval + def gds_validate_boolean(self, input_data, node=None, input_name=''): + if input_data not in (True, 1, False, 0, ): + raise_parse_error( + node, + 'Requires boolean value ' + '(one of True, 1, False, 0)') + return input_data + def gds_format_boolean_list(self, input_data, input_name=''): + return '%s' % ' '.join(input_data) + def gds_validate_boolean_list( + self, input_data, node=None, input_name=''): + values = input_data.split() + for value in values: + if value not in (True, 1, False, 0, ): + raise_parse_error( + node, + 'Requires sequence of boolean values ' + '(one of True, 1, False, 0)') + return values + def gds_validate_datetime(self, input_data, node=None, input_name=''): + return input_data + def gds_format_datetime(self, input_data, input_name=''): + if input_data.microsecond == 0: + _svalue = '%04d-%02d-%02dT%02d:%02d:%02d' % ( + input_data.year, + input_data.month, + input_data.day, + input_data.hour, + input_data.minute, + input_data.second, + ) + else: + _svalue = '%04d-%02d-%02dT%02d:%02d:%02d.%s' % ( + input_data.year, + input_data.month, + input_data.day, + input_data.hour, + input_data.minute, + input_data.second, + ('%f' % (float(input_data.microsecond) / 1000000))[2:], + ) + if input_data.tzinfo is not None: + tzoff = input_data.tzinfo.utcoffset(input_data) + if tzoff is not None: + total_seconds = tzoff.seconds + (86400 * tzoff.days) + if total_seconds == 0: + _svalue += 'Z' + else: + if total_seconds < 0: + _svalue += '-' + total_seconds *= -1 + else: + _svalue += '+' + hours = total_seconds // 3600 + minutes = (total_seconds - (hours * 3600)) // 60 + _svalue += '{0:02d}:{1:02d}'.format(hours, minutes) + return _svalue + @classmethod + def gds_parse_datetime(cls, input_data): + tz = None + if input_data[-1] == 'Z': + tz = GeneratedsSuper._FixedOffsetTZ(0, 'UTC') + input_data = input_data[:-1] + else: + results = GeneratedsSuper.tzoff_pattern.search(input_data) + if results is not None: + tzoff_parts = results.group(2).split(':') + tzoff = int(tzoff_parts[0]) * 60 + int(tzoff_parts[1]) + if results.group(1) == '-': + tzoff *= -1 + tz = GeneratedsSuper._FixedOffsetTZ( + tzoff, results.group(0)) + input_data = input_data[:-6] + time_parts = input_data.split('.') + if len(time_parts) > 1: + micro_seconds = int(float('0.' + time_parts[1]) * 1000000) + input_data = '%s.%s' % ( + time_parts[0], "{}".format(micro_seconds).rjust(6, "0"), ) + dt = datetime_.datetime.strptime( + input_data, '%Y-%m-%dT%H:%M:%S.%f') + else: + dt = datetime_.datetime.strptime( + input_data, '%Y-%m-%dT%H:%M:%S') + dt = dt.replace(tzinfo=tz) + return dt + def gds_validate_date(self, input_data, node=None, input_name=''): + return input_data + def gds_format_date(self, input_data, input_name=''): + _svalue = '%04d-%02d-%02d' % ( + input_data.year, + input_data.month, + input_data.day, + ) + try: + if input_data.tzinfo is not None: + tzoff = input_data.tzinfo.utcoffset(input_data) + if tzoff is not None: + total_seconds = tzoff.seconds + (86400 * tzoff.days) + if total_seconds == 0: + _svalue += 'Z' + else: + if total_seconds < 0: + _svalue += '-' + total_seconds *= -1 + else: + _svalue += '+' + hours = total_seconds // 3600 + minutes = (total_seconds - (hours * 3600)) // 60 + _svalue += '{0:02d}:{1:02d}'.format( + hours, minutes) + except AttributeError: + pass + return _svalue + @classmethod + def gds_parse_date(cls, input_data): + tz = None + if input_data[-1] == 'Z': + tz = GeneratedsSuper._FixedOffsetTZ(0, 'UTC') + input_data = input_data[:-1] + else: + results = GeneratedsSuper.tzoff_pattern.search(input_data) + if results is not None: + tzoff_parts = results.group(2).split(':') + tzoff = int(tzoff_parts[0]) * 60 + int(tzoff_parts[1]) + if results.group(1) == '-': + tzoff *= -1 + tz = GeneratedsSuper._FixedOffsetTZ( + tzoff, results.group(0)) + input_data = input_data[:-6] + dt = datetime_.datetime.strptime(input_data, '%Y-%m-%d') + dt = dt.replace(tzinfo=tz) + return dt.date() + def gds_validate_time(self, input_data, node=None, input_name=''): + return input_data + def gds_format_time(self, input_data, input_name=''): + if input_data.microsecond == 0: + _svalue = '%02d:%02d:%02d' % ( + input_data.hour, + input_data.minute, + input_data.second, + ) + else: + _svalue = '%02d:%02d:%02d.%s' % ( + input_data.hour, + input_data.minute, + input_data.second, + ('%f' % (float(input_data.microsecond) / 1000000))[2:], + ) + if input_data.tzinfo is not None: + tzoff = input_data.tzinfo.utcoffset(input_data) + if tzoff is not None: + total_seconds = tzoff.seconds + (86400 * tzoff.days) + if total_seconds == 0: + _svalue += 'Z' + else: + if total_seconds < 0: + _svalue += '-' + total_seconds *= -1 + else: + _svalue += '+' + hours = total_seconds // 3600 + minutes = (total_seconds - (hours * 3600)) // 60 + _svalue += '{0:02d}:{1:02d}'.format(hours, minutes) + return _svalue + def gds_validate_simple_patterns(self, patterns, target): + # pat is a list of lists of strings/patterns. + # The target value must match at least one of the patterns + # in order for the test to succeed. + found1 = True + for patterns1 in patterns: + found2 = False + for patterns2 in patterns1: + mo = re_.search(patterns2, target) + if mo is not None and len(mo.group(0)) == len(target): + found2 = True + break + if not found2: + found1 = False + break + return found1 + @classmethod + def gds_parse_time(cls, input_data): + tz = None + if input_data[-1] == 'Z': + tz = GeneratedsSuper._FixedOffsetTZ(0, 'UTC') + input_data = input_data[:-1] + else: + results = GeneratedsSuper.tzoff_pattern.search(input_data) + if results is not None: + tzoff_parts = results.group(2).split(':') + tzoff = int(tzoff_parts[0]) * 60 + int(tzoff_parts[1]) + if results.group(1) == '-': + tzoff *= -1 + tz = GeneratedsSuper._FixedOffsetTZ( + tzoff, results.group(0)) + input_data = input_data[:-6] + if len(input_data.split('.')) > 1: + dt = datetime_.datetime.strptime(input_data, '%H:%M:%S.%f') + else: + dt = datetime_.datetime.strptime(input_data, '%H:%M:%S') + dt = dt.replace(tzinfo=tz) + return dt.time() + def gds_check_cardinality_( + self, value, input_name, + min_occurs=0, max_occurs=1, required=None): + if value is None: + length = 0 + elif isinstance(value, list): + length = len(value) + else: + length = 1 + if required is not None : + if required and length < 1: + self.gds_collector_.add_message( + "Required value {}{} is missing".format( + input_name, self.gds_get_node_lineno_())) + if length < min_occurs: + self.gds_collector_.add_message( + "Number of values for {}{} is below " + "the minimum allowed, " + "expected at least {}, found {}".format( + input_name, self.gds_get_node_lineno_(), + min_occurs, length)) + elif length > max_occurs: + self.gds_collector_.add_message( + "Number of values for {}{} is above " + "the maximum allowed, " + "expected at most {}, found {}".format( + input_name, self.gds_get_node_lineno_(), + max_occurs, length)) + def gds_validate_builtin_ST_( + self, validator, value, input_name, + min_occurs=None, max_occurs=None, required=None): + if value is not None: + try: + validator(value, input_name=input_name) + except GDSParseError as parse_error: + self.gds_collector_.add_message(str(parse_error)) + def gds_validate_defined_ST_( + self, validator, value, input_name, + min_occurs=None, max_occurs=None, required=None): + if value is not None: + try: + validator(value) + except GDSParseError as parse_error: + self.gds_collector_.add_message(str(parse_error)) + def gds_str_lower(self, instring): + return instring.lower() + def get_path_(self, node): + path_list = [] + self.get_path_list_(node, path_list) + path_list.reverse() + path = '/'.join(path_list) + return path + Tag_strip_pattern_ = re_.compile(r'\{.*\}') + def get_path_list_(self, node, path_list): + if node is None: + return + tag = GeneratedsSuper.Tag_strip_pattern_.sub('', node.tag) + if tag: + path_list.append(tag) + self.get_path_list_(node.getparent(), path_list) + def get_class_obj_(self, node, default_class=None): + class_obj1 = default_class + if 'xsi' in node.nsmap: + classname = node.get('{%s}type' % node.nsmap['xsi']) + if classname is not None: + names = classname.split(':') + if len(names) == 2: + classname = names[1] + class_obj2 = globals().get(classname) + if class_obj2 is not None: + class_obj1 = class_obj2 + return class_obj1 + def gds_build_any(self, node, type_name=None): + # provide default value in case option --disable-xml is used. + content = "" + content = etree_.tostring(node, encoding="unicode") + return content + @classmethod + def gds_reverse_node_mapping(cls, mapping): + return dict(((v, k) for k, v in mapping.items())) + @staticmethod + def gds_encode(instring): + if sys.version_info.major == 2: + if ExternalEncoding: + encoding = ExternalEncoding + else: + encoding = 'utf-8' + return instring.encode(encoding) + return instring + @staticmethod + def convert_unicode(instring): + if isinstance(instring, str): + result = quote_xml(instring) + elif sys.version_info.major == 2 and isinstance(instring, unicode): + result = quote_xml(instring).encode('utf8') + else: + result = GeneratedsSuper.gds_encode(str(instring)) + return result + def __eq__(self, other): + def excl_select_objs_(obj): + return (obj[0] != 'parent_object_' and + obj[0] != 'gds_collector_') + if type(self) != type(other): + return False + return all(x == y for x, y in zip_longest( + filter(excl_select_objs_, self.__dict__.items()), + filter(excl_select_objs_, other.__dict__.items()))) + def __ne__(self, other): + return not self.__eq__(other) + # Django ETL transform hooks. + def gds_djo_etl_transform(self): + pass + def gds_djo_etl_transform_db_obj(self, dbobj): + pass + # SQLAlchemy ETL transform hooks. + def gds_sqa_etl_transform(self): + return 0, None + def gds_sqa_etl_transform_db_obj(self, dbobj): + pass + def gds_get_node_lineno_(self): + if (hasattr(self, "gds_elementtree_node_") and + self.gds_elementtree_node_ is not None): + return ' near line {}'.format( + self.gds_elementtree_node_.sourceline) + return "" + + + def getSubclassFromModule_(module, class_): + '''Get the subclass of a class from a specific module.''' + name = class_.__name__ + 'Sub' + if hasattr(module, name): + return getattr(module, name) + return None + + +# +# 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 = '' +# Set this to false in order to deactivate during export, the use of +# name space prefixes captured from the input document. +UseCapturedNS_ = True +CapturedNsmap_ = {} +Tag_pattern_ = re_.compile(r'({.*})?(.*)') +String_cleanup_pat_ = re_.compile(r"[\n\r\s]+") +Namespace_extract_pat_ = re_.compile(r'{(.*)}(.*)') +CDATA_pattern_ = re_.compile(r"", re_.DOTALL) + +# Change this to redirect the generated superclass module to use a +# specific subclass module. +CurrentSubclassModule_ = None + +# +# Support/utility functions. +# + + +def showIndent(outfile, level, pretty_print=True): + if pretty_print: + for idx in range(level): + outfile.write(' ') + + +def quote_xml(inStr): + "Escape markup chars, but do not modify CDATA sections." + if not inStr: + return '' + s1 = (isinstance(inStr, BaseStrType_) and inStr or '%s' % inStr) + s2 = '' + pos = 0 + matchobjects = CDATA_pattern_.finditer(s1) + for mo in matchobjects: + s3 = s1[pos:mo.start()] + s2 += quote_xml_aux(s3) + s2 += s1[mo.start():mo.end()] + pos = mo.end() + s3 = s1[pos:] + s2 += quote_xml_aux(s3) + return s2 + + +def quote_xml_aux(inStr): + s1 = inStr.replace('&', '&') + s1 = s1.replace('<', '<') + s1 = s1.replace('>', '>') + return s1 + + +def quote_attrib(inStr): + s1 = (isinstance(inStr, BaseStrType_) 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 + return "'''%s'''" % s1 + else: + if s1.find('"') != -1: + s1 = s1.replace('"', '\\"') + if s1.find('\n') == -1: + return '"%s"' % s1 + return '"""%s"""' % s1 + + +def get_all_text_(node): + if node.text is not None: + text = node.text + else: + text = '' + for child in node: + if child.tail is not None: + text += child.tail + return text + + +def find_attr_value_(attr_name, node): + attrs = node.attrib + attr_parts = attr_name.split(':') + value = None + if len(attr_parts) == 1: + value = attrs.get(attr_name) + elif len(attr_parts) == 2: + prefix, name = attr_parts + namespace = node.nsmap.get(prefix) + if namespace is not None: + value = attrs.get('{%s}%s' % (namespace, name, )) + return value + + +def encode_str_2_3(instr): + return instr + + +class GDSParseError(Exception): + pass + + +def raise_parse_error(node, msg): + if node is not None: + msg = '%s (element %s/line %d)' % (msg, node.tag, node.sourceline, ) + raise GDSParseError(msg) + + +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 + TypeBase64 = 8 + def __init__(self, category, content_type, name, value): + self.category = category + self.content_type = content_type + self.name = name + self.value = value + def getCategory(self): + return self.category + def getContenttype(self, content_type): + return self.content_type + def getValue(self): + return self.value + def getName(self): + return self.name + def export(self, outfile, level, name, namespace, + pretty_print=True): + if self.category == MixedContainer.CategoryText: + # Prevent exporting empty content as empty lines. + if self.value.strip(): + outfile.write(self.value) + elif self.category == MixedContainer.CategorySimple: + self.exportSimple(outfile, level, name) + else: # category == MixedContainer.CategoryComplex + self.value.export( + outfile, level, namespace, name_=name, + pretty_print=pretty_print) + def exportSimple(self, outfile, level, name): + if self.content_type == MixedContainer.TypeString: + outfile.write('<%s>%s' % ( + self.name, self.value, self.name)) + elif self.content_type == MixedContainer.TypeInteger or \ + self.content_type == MixedContainer.TypeBoolean: + outfile.write('<%s>%d' % ( + self.name, self.value, self.name)) + elif self.content_type == MixedContainer.TypeFloat or \ + self.content_type == MixedContainer.TypeDecimal: + outfile.write('<%s>%f' % ( + self.name, self.value, self.name)) + elif self.content_type == MixedContainer.TypeDouble: + outfile.write('<%s>%g' % ( + self.name, self.value, self.name)) + elif self.content_type == MixedContainer.TypeBase64: + outfile.write('<%s>%s' % ( + self.name, + base64.b64encode(self.value), + self.name)) + def to_etree(self, element, mapping_=None, nsmap_=None): + if self.category == MixedContainer.CategoryText: + # Prevent exporting empty content as empty lines. + if self.value.strip(): + if len(element) > 0: + if element[-1].tail is None: + element[-1].tail = self.value + else: + element[-1].tail += self.value + else: + if element.text is None: + element.text = self.value + else: + element.text += self.value + elif self.category == MixedContainer.CategorySimple: + subelement = etree_.SubElement( + element, '%s' % self.name) + subelement.text = self.to_etree_simple() + else: # category == MixedContainer.CategoryComplex + self.value.to_etree(element) + def to_etree_simple(self, mapping_=None, nsmap_=None): + if self.content_type == MixedContainer.TypeString: + text = self.value + elif (self.content_type == MixedContainer.TypeInteger or + self.content_type == MixedContainer.TypeBoolean): + text = '%d' % self.value + elif (self.content_type == MixedContainer.TypeFloat or + self.content_type == MixedContainer.TypeDecimal): + text = '%f' % self.value + elif self.content_type == MixedContainer.TypeDouble: + text = '%g' % self.value + elif self.content_type == MixedContainer.TypeBase64: + text = '%s' % base64.b64encode(self.value) + return text + def exportLiteral(self, outfile, level, name): + if self.category == MixedContainer.CategoryText: + showIndent(outfile, level) + outfile.write( + 'model_.MixedContainer(%d, %d, "%s", "%s"),\n' % ( + self.category, self.content_type, + self.name, self.value)) + elif self.category == MixedContainer.CategorySimple: + showIndent(outfile, level) + outfile.write( + 'model_.MixedContainer(%d, %d, "%s", "%s"),\n' % ( + self.category, self.content_type, + self.name, self.value)) + else: # category == MixedContainer.CategoryComplex + showIndent(outfile, level) + outfile.write( + 'model_.MixedContainer(%d, %d, "%s",\n' % ( + self.category, self.content_type, self.name,)) + self.value.exportLiteral(outfile, level + 1) + showIndent(outfile, level) + outfile.write(')\n') + + +class MemberSpec_(object): + def __init__(self, name='', data_type='', container=0, + optional=0, child_attrs=None, choice=None): + self.name = name + self.data_type = data_type + self.container = container + self.child_attrs = child_attrs + self.choice = choice + self.optional = optional + 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_chain(self): return self.data_type + def get_data_type(self): + if isinstance(self.data_type, list): + if len(self.data_type) > 0: + return self.data_type[-1] + return 'xs:string' + return self.data_type + def set_container(self, container): self.container = container + def get_container(self): return self.container + def set_child_attrs(self, child_attrs): self.child_attrs = child_attrs + def get_child_attrs(self): return self.child_attrs + def set_choice(self, choice): self.choice = choice + def get_choice(self): return self.choice + def set_optional(self, optional): self.optional = optional + def get_optional(self): return self.optional + + +def _cast(typ, value): + if typ is None or value is None: + return value + return typ(value) + +# +# Data representation classes. +# + + +class DoxAccessor(Enum): + RETAIN='retain' + COPY='copy' + ASSIGN='assign' + WEAK='weak' + STRONG='strong' + UNRETAINED='unretained' + + +class DoxBool(Enum): + YES='yes' + NO='no' + + +class DoxCompoundKind(Enum): + CLASS='class' + STRUCT='struct' + UNION='union' + INTERFACE='interface' + PROTOCOL='protocol' + CATEGORY='category' + EXCEPTION='exception' + SERVICE='service' + SINGLETON='singleton' + MODULE='module' + TYPE='type' + FILE='file' + NAMESPACE='namespace' + GROUP='group' + PAGE='page' + EXAMPLE='example' + DIR='dir' + + +class DoxGraphRelation(Enum): + INCLUDE='include' + USAGE='usage' + TEMPLATEINSTANCE='template-instance' + PUBLICINHERITANCE='public-inheritance' + PROTECTEDINHERITANCE='protected-inheritance' + PRIVATEINHERITANCE='private-inheritance' + + +class DoxHighlightClass(Enum): + COMMENT='comment' + NORMAL='normal' + PREPROCESSOR='preprocessor' + KEYWORD='keyword' + KEYWORDTYPE='keywordtype' + KEYWORDFLOW='keywordflow' + STRINGLITERAL='stringliteral' + CHARLITERAL='charliteral' + + +class DoxImageKind(Enum): + HTML='html' + LATEX='latex' + RTF='rtf' + + +class DoxMemberKind(Enum): + DEFINE='define' + PROPERTY='property' + EVENT='event' + VARIABLE='variable' + TYPEDEF='typedef' + ENUM='enum' + FUNCTION='function' + SIGNAL='signal' + PROTOTYPE='prototype' + FRIEND='friend' + DCOP='dcop' + SLOT='slot' + INTERFACE='interface' + SERVICE='service' + + +class DoxParamDir(Enum): + IN='in' + OUT='out' + INOUT='inout' + + +class DoxParamListKind(Enum): + PARAM='param' + RETVAL='retval' + EXCEPTION='exception' + TEMPLATEPARAM='templateparam' + + +class DoxProtectionKind(Enum): + PUBLIC='public' + PROTECTED='protected' + PRIVATE='private' + PACKAGE='package' + + +class DoxRefKind(Enum): + COMPOUND='compound' + MEMBER='member' + + +class DoxSectionKind(Enum): + USERDEFINED='user-defined' + PUBLICTYPE='public-type' + PUBLICFUNC='public-func' + PUBLICATTRIB='public-attrib' + PUBLICSLOT='public-slot' + SIGNAL='signal' + DCOPFUNC='dcop-func' + PROPERTY='property' + EVENT='event' + PUBLICSTATICFUNC='public-static-func' + PUBLICSTATICATTRIB='public-static-attrib' + PROTECTEDTYPE='protected-type' + PROTECTEDFUNC='protected-func' + PROTECTEDATTRIB='protected-attrib' + PROTECTEDSLOT='protected-slot' + PROTECTEDSTATICFUNC='protected-static-func' + PROTECTEDSTATICATTRIB='protected-static-attrib' + PACKAGETYPE='package-type' + PACKAGEFUNC='package-func' + PACKAGEATTRIB='package-attrib' + PACKAGESTATICFUNC='package-static-func' + PACKAGESTATICATTRIB='package-static-attrib' + PRIVATETYPE='private-type' + PRIVATEFUNC='private-func' + PRIVATEATTRIB='private-attrib' + PRIVATESLOT='private-slot' + PRIVATESTATICFUNC='private-static-func' + PRIVATESTATICATTRIB='private-static-attrib' + FRIEND='friend' + RELATED='related' + DEFINE='define' + PROTOTYPE='prototype' + TYPEDEF='typedef' + ENUM='enum' + FUNC='func' + VAR='var' + + +class DoxSimpleSectKind(Enum): + SEE='see' + RETURN='return' + AUTHOR='author' + AUTHORS='authors' + VERSION='version' + SINCE='since' + DATE='date' + NOTE='note' + WARNING='warning' + PRE='pre' + POST='post' + COPYRIGHT='copyright' + INVARIANT='invariant' + REMARK='remark' + ATTENTION='attention' + PAR='par' + RCS='rcs' + + +class DoxVirtualKind(Enum): + NONVIRTUAL='non-virtual' + VIRTUAL='virtual' + PUREVIRTUAL='pure-virtual' + + +class DoxygenType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, version=None, compounddef=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.version = _cast(None, version) + self.version_nsprefix_ = None + if compounddef is None: + self.compounddef = [] + else: + self.compounddef = compounddef + self.compounddef_nsprefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, DoxygenType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if DoxygenType.subclass: + return DoxygenType.subclass(*args_, **kwargs_) + return DoxygenType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + def get_compounddef(self): + return self.compounddef + def set_compounddef(self, compounddef): + self.compounddef = compounddef + def add_compounddef(self, value): + self.compounddef.append(value) + def insert_compounddef_at(self, index, value): + self.compounddef.insert(index, value) + def replace_compounddef_at(self, index, value): + self.compounddef[index] = value + def get_version(self): + return self.version + def set_version(self, version): + self.version = version + def validate_DoxVersionNumber(self, value): + # Validate type DoxVersionNumber, a restriction on xsd:string. + if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) + return False + if not self.gds_validate_simple_patterns( + self.validate_DoxVersionNumber_patterns_, value): + self.gds_collector_.add_message('Value "%s" does not match xsd pattern restrictions: %s' % (encode_str_2_3(value), self.validate_DoxVersionNumber_patterns_, )) + validate_DoxVersionNumber_patterns_ = [['^(\\d+\\.\\d+.*)$']] + def hasContent_(self): + if ( + self.compounddef + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DoxygenType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('DoxygenType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'DoxygenType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='DoxygenType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='DoxygenType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='DoxygenType'): + if self.version is not None and 'version' not in already_processed: + already_processed.add('version') + outfile.write(' version=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.version), input_name='version')), )) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DoxygenType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for compounddef_ in self.compounddef: + namespaceprefix_ = self.compounddef_nsprefix_ + ':' if (UseCapturedNS_ and self.compounddef_nsprefix_) else '' + compounddef_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='compounddef', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('version', node) + if value is not None and 'version' not in already_processed: + already_processed.add('version') + self.version = value + self.validate_DoxVersionNumber(self.version) # validate type DoxVersionNumber + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'compounddef': + obj_ = compounddefType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.compounddef.append(obj_) + obj_.original_tagname_ = 'compounddef' +# end class DoxygenType + + +class compounddefType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, id=None, kind=None, prot=None, final=None, sealed=None, abstract=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, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.id = _cast(None, id) + self.id_nsprefix_ = None + self.kind = _cast(None, kind) + self.kind_nsprefix_ = None + self.prot = _cast(None, prot) + self.prot_nsprefix_ = None + self.final = _cast(None, final) + self.final_nsprefix_ = None + self.sealed = _cast(None, sealed) + self.sealed_nsprefix_ = None + self.abstract = _cast(None, abstract) + self.abstract_nsprefix_ = None + self.compoundname = compoundname + self.compoundname_nsprefix_ = None + self.title = title + self.title_nsprefix_ = None + if basecompoundref is None: + self.basecompoundref = [] + else: + self.basecompoundref = basecompoundref + self.basecompoundref_nsprefix_ = None + if derivedcompoundref is None: + self.derivedcompoundref = [] + else: + self.derivedcompoundref = derivedcompoundref + self.derivedcompoundref_nsprefix_ = None + if includes is None: + self.includes = [] + else: + self.includes = includes + self.includes_nsprefix_ = None + if includedby is None: + self.includedby = [] + else: + self.includedby = includedby + self.includedby_nsprefix_ = None + self.incdepgraph = incdepgraph + self.incdepgraph_nsprefix_ = None + self.invincdepgraph = invincdepgraph + self.invincdepgraph_nsprefix_ = None + if innerdir is None: + self.innerdir = [] + else: + self.innerdir = innerdir + self.innerdir_nsprefix_ = None + if innerfile is None: + self.innerfile = [] + else: + self.innerfile = innerfile + self.innerfile_nsprefix_ = None + if innerclass is None: + self.innerclass = [] + else: + self.innerclass = innerclass + self.innerclass_nsprefix_ = None + if innernamespace is None: + self.innernamespace = [] + else: + self.innernamespace = innernamespace + self.innernamespace_nsprefix_ = None + if innerpage is None: + self.innerpage = [] + else: + self.innerpage = innerpage + self.innerpage_nsprefix_ = None + if innergroup is None: + self.innergroup = [] + else: + self.innergroup = innergroup + self.innergroup_nsprefix_ = None + self.templateparamlist = templateparamlist + self.templateparamlist_nsprefix_ = None + if sectiondef is None: + self.sectiondef = [] + else: + self.sectiondef = sectiondef + self.sectiondef_nsprefix_ = None + self.briefdescription = briefdescription + self.briefdescription_nsprefix_ = None + self.detaileddescription = detaileddescription + self.detaileddescription_nsprefix_ = None + self.inheritancegraph = inheritancegraph + self.inheritancegraph_nsprefix_ = None + self.collaborationgraph = collaborationgraph + self.collaborationgraph_nsprefix_ = None + self.programlisting = programlisting + self.programlisting_nsprefix_ = None + self.location = location + self.location_nsprefix_ = None + self.listofallmembers = listofallmembers + self.listofallmembers_nsprefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, compounddefType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if compounddefType.subclass: + return compounddefType.subclass(*args_, **kwargs_) + return compounddefType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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_at(self, index, value): + self.basecompoundref.insert(index, value) + def replace_basecompoundref_at(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_at(self, index, value): + self.derivedcompoundref.insert(index, value) + def replace_derivedcompoundref_at(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_at(self, index, value): + self.includes.insert(index, value) + def replace_includes_at(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_at(self, index, value): + self.includedby.insert(index, value) + def replace_includedby_at(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_at(self, index, value): + self.innerdir.insert(index, value) + def replace_innerdir_at(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_at(self, index, value): + self.innerfile.insert(index, value) + def replace_innerfile_at(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_at(self, index, value): + self.innerclass.insert(index, value) + def replace_innerclass_at(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_at(self, index, value): + self.innernamespace.insert(index, value) + def replace_innernamespace_at(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_at(self, index, value): + self.innerpage.insert(index, value) + def replace_innerpage_at(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_at(self, index, value): + self.innergroup.insert(index, value) + def replace_innergroup_at(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_at(self, index, value): + self.sectiondef.insert(index, value) + def replace_sectiondef_at(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_id(self): + return self.id + def set_id(self, id): + self.id = id + 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_final(self): + return self.final + def set_final(self, final): + self.final = final + def get_sealed(self): + return self.sealed + def set_sealed(self, sealed): + self.sealed = sealed + def get_abstract(self): + return self.abstract + def set_abstract(self, abstract): + self.abstract = abstract + def validate_DoxCompoundKind(self, value): + # Validate type DoxCompoundKind, a restriction on xsd:string. + if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) + return False + value = value + enumerations = ['class', 'struct', 'union', 'interface', 'protocol', 'category', 'exception', 'service', 'singleton', 'module', 'type', 'file', 'namespace', 'group', 'page', 'example', 'dir'] + if value not in enumerations: + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on DoxCompoundKind' % {"value" : encode_str_2_3(value), "lineno": lineno} ) + result = False + def validate_DoxProtectionKind(self, value): + # Validate type DoxProtectionKind, a restriction on xsd:string. + if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) + return False + value = value + enumerations = ['public', 'protected', 'private', 'package'] + if value not in enumerations: + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on DoxProtectionKind' % {"value" : encode_str_2_3(value), "lineno": lineno} ) + result = False + def validate_DoxBool(self, value): + # Validate type DoxBool, a restriction on xsd:string. + if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) + return False + value = value + enumerations = ['yes', 'no'] + if value not in enumerations: + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on DoxBool' % {"value" : encode_str_2_3(value), "lineno": lineno} ) + result = False + def hasContent_(self): + if ( + self.compoundname is not None or + self.title is not None or + self.basecompoundref or + self.derivedcompoundref or + self.includes or + self.includedby or + self.incdepgraph is not None or + self.invincdepgraph is not None or + self.innerdir or + self.innerfile or + self.innerclass or + self.innernamespace or + self.innerpage or + self.innergroup or + self.templateparamlist is not None or + self.sectiondef 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 + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='compounddefType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('compounddefType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'compounddefType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='compounddefType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='compounddefType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='compounddefType'): + if self.id is not None and 'id' not in already_processed: + already_processed.add('id') + outfile.write(' id=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.id), input_name='id')), )) + if self.kind is not None and 'kind' not in already_processed: + already_processed.add('kind') + outfile.write(' kind=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.kind), input_name='kind')), )) + if self.prot is not None and 'prot' not in already_processed: + already_processed.add('prot') + outfile.write(' prot=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.prot), input_name='prot')), )) + if self.final is not None and 'final' not in already_processed: + already_processed.add('final') + outfile.write(' final=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.final), input_name='final')), )) + if self.sealed is not None and 'sealed' not in already_processed: + already_processed.add('sealed') + outfile.write(' sealed=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.sealed), input_name='sealed')), )) + if self.abstract is not None and 'abstract' not in already_processed: + already_processed.add('abstract') + outfile.write(' abstract=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.abstract), input_name='abstract')), )) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='compounddefType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.compoundname is not None: + namespaceprefix_ = self.compoundname_nsprefix_ + ':' if (UseCapturedNS_ and self.compoundname_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%scompoundname>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.compoundname), input_name='compoundname')), namespaceprefix_ , eol_)) + if self.title is not None: + namespaceprefix_ = self.title_nsprefix_ + ':' if (UseCapturedNS_ and self.title_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%stitle>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.title), input_name='title')), namespaceprefix_ , eol_)) + for basecompoundref_ in self.basecompoundref: + namespaceprefix_ = self.basecompoundref_nsprefix_ + ':' if (UseCapturedNS_ and self.basecompoundref_nsprefix_) else '' + basecompoundref_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='basecompoundref', pretty_print=pretty_print) + for derivedcompoundref_ in self.derivedcompoundref: + namespaceprefix_ = self.derivedcompoundref_nsprefix_ + ':' if (UseCapturedNS_ and self.derivedcompoundref_nsprefix_) else '' + derivedcompoundref_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='derivedcompoundref', pretty_print=pretty_print) + for includes_ in self.includes: + namespaceprefix_ = self.includes_nsprefix_ + ':' if (UseCapturedNS_ and self.includes_nsprefix_) else '' + includes_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='includes', pretty_print=pretty_print) + for includedby_ in self.includedby: + namespaceprefix_ = self.includedby_nsprefix_ + ':' if (UseCapturedNS_ and self.includedby_nsprefix_) else '' + includedby_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='includedby', pretty_print=pretty_print) + if self.incdepgraph is not None: + namespaceprefix_ = self.incdepgraph_nsprefix_ + ':' if (UseCapturedNS_ and self.incdepgraph_nsprefix_) else '' + self.incdepgraph.export(outfile, level, namespaceprefix_, namespacedef_='', name_='incdepgraph', pretty_print=pretty_print) + if self.invincdepgraph is not None: + namespaceprefix_ = self.invincdepgraph_nsprefix_ + ':' if (UseCapturedNS_ and self.invincdepgraph_nsprefix_) else '' + self.invincdepgraph.export(outfile, level, namespaceprefix_, namespacedef_='', name_='invincdepgraph', pretty_print=pretty_print) + for innerdir_ in self.innerdir: + namespaceprefix_ = self.innerdir_nsprefix_ + ':' if (UseCapturedNS_ and self.innerdir_nsprefix_) else '' + innerdir_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='innerdir', pretty_print=pretty_print) + for innerfile_ in self.innerfile: + namespaceprefix_ = self.innerfile_nsprefix_ + ':' if (UseCapturedNS_ and self.innerfile_nsprefix_) else '' + innerfile_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='innerfile', pretty_print=pretty_print) + for innerclass_ in self.innerclass: + namespaceprefix_ = self.innerclass_nsprefix_ + ':' if (UseCapturedNS_ and self.innerclass_nsprefix_) else '' + innerclass_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='innerclass', pretty_print=pretty_print) + for innernamespace_ in self.innernamespace: + namespaceprefix_ = self.innernamespace_nsprefix_ + ':' if (UseCapturedNS_ and self.innernamespace_nsprefix_) else '' + innernamespace_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='innernamespace', pretty_print=pretty_print) + for innerpage_ in self.innerpage: + namespaceprefix_ = self.innerpage_nsprefix_ + ':' if (UseCapturedNS_ and self.innerpage_nsprefix_) else '' + innerpage_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='innerpage', pretty_print=pretty_print) + for innergroup_ in self.innergroup: + namespaceprefix_ = self.innergroup_nsprefix_ + ':' if (UseCapturedNS_ and self.innergroup_nsprefix_) else '' + innergroup_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='innergroup', pretty_print=pretty_print) + if self.templateparamlist is not None: + namespaceprefix_ = self.templateparamlist_nsprefix_ + ':' if (UseCapturedNS_ and self.templateparamlist_nsprefix_) else '' + self.templateparamlist.export(outfile, level, namespaceprefix_, namespacedef_='', name_='templateparamlist', pretty_print=pretty_print) + for sectiondef_ in self.sectiondef: + namespaceprefix_ = self.sectiondef_nsprefix_ + ':' if (UseCapturedNS_ and self.sectiondef_nsprefix_) else '' + sectiondef_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sectiondef', pretty_print=pretty_print) + if self.briefdescription is not None: + namespaceprefix_ = self.briefdescription_nsprefix_ + ':' if (UseCapturedNS_ and self.briefdescription_nsprefix_) else '' + self.briefdescription.export(outfile, level, namespaceprefix_, namespacedef_='', name_='briefdescription', pretty_print=pretty_print) + if self.detaileddescription is not None: + namespaceprefix_ = self.detaileddescription_nsprefix_ + ':' if (UseCapturedNS_ and self.detaileddescription_nsprefix_) else '' + self.detaileddescription.export(outfile, level, namespaceprefix_, namespacedef_='', name_='detaileddescription', pretty_print=pretty_print) + if self.inheritancegraph is not None: + namespaceprefix_ = self.inheritancegraph_nsprefix_ + ':' if (UseCapturedNS_ and self.inheritancegraph_nsprefix_) else '' + self.inheritancegraph.export(outfile, level, namespaceprefix_, namespacedef_='', name_='inheritancegraph', pretty_print=pretty_print) + if self.collaborationgraph is not None: + namespaceprefix_ = self.collaborationgraph_nsprefix_ + ':' if (UseCapturedNS_ and self.collaborationgraph_nsprefix_) else '' + self.collaborationgraph.export(outfile, level, namespaceprefix_, namespacedef_='', name_='collaborationgraph', pretty_print=pretty_print) + if self.programlisting is not None: + namespaceprefix_ = self.programlisting_nsprefix_ + ':' if (UseCapturedNS_ and self.programlisting_nsprefix_) else '' + self.programlisting.export(outfile, level, namespaceprefix_, namespacedef_='', name_='programlisting', pretty_print=pretty_print) + if self.location is not None: + namespaceprefix_ = self.location_nsprefix_ + ':' if (UseCapturedNS_ and self.location_nsprefix_) else '' + self.location.export(outfile, level, namespaceprefix_, namespacedef_='', name_='location', pretty_print=pretty_print) + if self.listofallmembers is not None: + namespaceprefix_ = self.listofallmembers_nsprefix_ + ':' if (UseCapturedNS_ and self.listofallmembers_nsprefix_) else '' + self.listofallmembers.export(outfile, level, namespaceprefix_, namespacedef_='', name_='listofallmembers', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('id', node) + if value is not None and 'id' not in already_processed: + already_processed.add('id') + self.id = value + value = find_attr_value_('kind', node) + if value is not None and 'kind' not in already_processed: + already_processed.add('kind') + self.kind = value + self.validate_DoxCompoundKind(self.kind) # validate type DoxCompoundKind + value = find_attr_value_('prot', node) + if value is not None and 'prot' not in already_processed: + already_processed.add('prot') + self.prot = value + self.validate_DoxProtectionKind(self.prot) # validate type DoxProtectionKind + value = find_attr_value_('final', node) + if value is not None and 'final' not in already_processed: + already_processed.add('final') + self.final = value + self.validate_DoxBool(self.final) # validate type DoxBool + value = find_attr_value_('sealed', node) + if value is not None and 'sealed' not in already_processed: + already_processed.add('sealed') + self.sealed = value + self.validate_DoxBool(self.sealed) # validate type DoxBool + value = find_attr_value_('abstract', node) + if value is not None and 'abstract' not in already_processed: + already_processed.add('abstract') + self.abstract = value + self.validate_DoxBool(self.abstract) # validate type DoxBool + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'compoundname': + value_ = child_.text + value_ = self.gds_parse_string(value_, node, 'compoundname') + value_ = self.gds_validate_string(value_, node, 'compoundname') + self.compoundname = value_ + self.compoundname_nsprefix_ = child_.prefix + elif nodeName_ == 'title': + value_ = child_.text + value_ = self.gds_parse_string(value_, node, 'title') + value_ = self.gds_validate_string(value_, node, 'title') + self.title = value_ + self.title_nsprefix_ = child_.prefix + elif nodeName_ == 'basecompoundref': + obj_ = compoundRefType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.basecompoundref.append(obj_) + obj_.original_tagname_ = 'basecompoundref' + elif nodeName_ == 'derivedcompoundref': + obj_ = compoundRefType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.derivedcompoundref.append(obj_) + obj_.original_tagname_ = 'derivedcompoundref' + elif nodeName_ == 'includes': + obj_ = incType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.includes.append(obj_) + obj_.original_tagname_ = 'includes' + elif nodeName_ == 'includedby': + obj_ = incType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.includedby.append(obj_) + obj_.original_tagname_ = 'includedby' + elif nodeName_ == 'incdepgraph': + obj_ = graphType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.incdepgraph = obj_ + obj_.original_tagname_ = 'incdepgraph' + elif nodeName_ == 'invincdepgraph': + obj_ = graphType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.invincdepgraph = obj_ + obj_.original_tagname_ = 'invincdepgraph' + elif nodeName_ == 'innerdir': + obj_ = refType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.innerdir.append(obj_) + obj_.original_tagname_ = 'innerdir' + elif nodeName_ == 'innerfile': + obj_ = refType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.innerfile.append(obj_) + obj_.original_tagname_ = 'innerfile' + elif nodeName_ == 'innerclass': + obj_ = refType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.innerclass.append(obj_) + obj_.original_tagname_ = 'innerclass' + elif nodeName_ == 'innernamespace': + obj_ = refType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.innernamespace.append(obj_) + obj_.original_tagname_ = 'innernamespace' + elif nodeName_ == 'innerpage': + obj_ = refType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.innerpage.append(obj_) + obj_.original_tagname_ = 'innerpage' + elif nodeName_ == 'innergroup': + obj_ = refType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.innergroup.append(obj_) + obj_.original_tagname_ = 'innergroup' + elif nodeName_ == 'templateparamlist': + obj_ = templateparamlistType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.templateparamlist = obj_ + obj_.original_tagname_ = 'templateparamlist' + elif nodeName_ == 'sectiondef': + obj_ = sectiondefType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.sectiondef.append(obj_) + obj_.original_tagname_ = 'sectiondef' + elif nodeName_ == 'briefdescription': + obj_ = descriptionType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.briefdescription = obj_ + obj_.original_tagname_ = 'briefdescription' + elif nodeName_ == 'detaileddescription': + obj_ = descriptionType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.detaileddescription = obj_ + obj_.original_tagname_ = 'detaileddescription' + elif nodeName_ == 'inheritancegraph': + obj_ = graphType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.inheritancegraph = obj_ + obj_.original_tagname_ = 'inheritancegraph' + elif nodeName_ == 'collaborationgraph': + obj_ = graphType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.collaborationgraph = obj_ + obj_.original_tagname_ = 'collaborationgraph' + elif nodeName_ == 'programlisting': + obj_ = listingType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.programlisting = obj_ + obj_.original_tagname_ = 'programlisting' + elif nodeName_ == 'location': + obj_ = locationType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.location = obj_ + obj_.original_tagname_ = 'location' + elif nodeName_ == 'listofallmembers': + obj_ = listofallmembersType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.listofallmembers = obj_ + obj_.original_tagname_ = 'listofallmembers' +# end class compounddefType + + +class listofallmembersType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, member=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + if member is None: + self.member = [] + else: + self.member = member + self.member_nsprefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, listofallmembersType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if listofallmembersType.subclass: + return listofallmembersType.subclass(*args_, **kwargs_) + return listofallmembersType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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_at(self, index, value): + self.member.insert(index, value) + def replace_member_at(self, index, value): + self.member[index] = value + def hasContent_(self): + if ( + self.member + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='listofallmembersType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('listofallmembersType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'listofallmembersType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='listofallmembersType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='listofallmembersType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='listofallmembersType'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='listofallmembersType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for member_ in self.member: + namespaceprefix_ = self.member_nsprefix_ + ':' if (UseCapturedNS_ and self.member_nsprefix_) else '' + member_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='member', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'member': + obj_ = memberRefType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.member.append(obj_) + obj_.original_tagname_ = 'member' +# end class listofallmembersType + + +class memberRefType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, refid=None, prot=None, virt=None, ambiguityscope=None, scope=None, name=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.refid = _cast(None, refid) + self.refid_nsprefix_ = None + self.prot = _cast(None, prot) + self.prot_nsprefix_ = None + self.virt = _cast(None, virt) + self.virt_nsprefix_ = None + self.ambiguityscope = _cast(None, ambiguityscope) + self.ambiguityscope_nsprefix_ = None + self.scope = scope + self.scope_nsprefix_ = None + self.name = name + self.name_nsprefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, memberRefType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if memberRefType.subclass: + return memberRefType.subclass(*args_, **kwargs_) + return memberRefType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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_refid(self): + return self.refid + def set_refid(self, refid): + self.refid = refid + def get_prot(self): + return self.prot + def set_prot(self, prot): + self.prot = prot + def get_virt(self): + return self.virt + def set_virt(self, virt): + self.virt = virt + def get_ambiguityscope(self): + return self.ambiguityscope + def set_ambiguityscope(self, ambiguityscope): + self.ambiguityscope = ambiguityscope + def validate_DoxProtectionKind(self, value): + # Validate type DoxProtectionKind, a restriction on xsd:string. + if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) + return False + value = value + enumerations = ['public', 'protected', 'private', 'package'] + if value not in enumerations: + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on DoxProtectionKind' % {"value" : encode_str_2_3(value), "lineno": lineno} ) + result = False + def validate_DoxVirtualKind(self, value): + # Validate type DoxVirtualKind, a restriction on xsd:string. + if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) + return False + value = value + enumerations = ['non-virtual', 'virtual', 'pure-virtual'] + if value not in enumerations: + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on DoxVirtualKind' % {"value" : encode_str_2_3(value), "lineno": lineno} ) + result = False + def hasContent_(self): + if ( + self.scope is not None or + self.name is not None + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='memberRefType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('memberRefType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'memberRefType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='memberRefType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='memberRefType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='memberRefType'): + if self.refid is not None and 'refid' not in already_processed: + already_processed.add('refid') + outfile.write(' refid=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.refid), input_name='refid')), )) + if self.prot is not None and 'prot' not in already_processed: + already_processed.add('prot') + outfile.write(' prot=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.prot), input_name='prot')), )) + if self.virt is not None and 'virt' not in already_processed: + already_processed.add('virt') + outfile.write(' virt=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.virt), input_name='virt')), )) + if self.ambiguityscope is not None and 'ambiguityscope' not in already_processed: + already_processed.add('ambiguityscope') + outfile.write(' ambiguityscope=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.ambiguityscope), input_name='ambiguityscope')), )) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='memberRefType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.scope is not None: + namespaceprefix_ = self.scope_nsprefix_ + ':' if (UseCapturedNS_ and self.scope_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%sscope>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.scope), input_name='scope')), namespaceprefix_ , eol_)) + if self.name is not None: + namespaceprefix_ = self.name_nsprefix_ + ':' if (UseCapturedNS_ and self.name_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%sname>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.name), input_name='name')), namespaceprefix_ , eol_)) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('refid', node) + if value is not None and 'refid' not in already_processed: + already_processed.add('refid') + self.refid = value + value = find_attr_value_('prot', node) + if value is not None and 'prot' not in already_processed: + already_processed.add('prot') + self.prot = value + self.validate_DoxProtectionKind(self.prot) # validate type DoxProtectionKind + value = find_attr_value_('virt', node) + if value is not None and 'virt' not in already_processed: + already_processed.add('virt') + self.virt = value + self.validate_DoxVirtualKind(self.virt) # validate type DoxVirtualKind + value = find_attr_value_('ambiguityscope', node) + if value is not None and 'ambiguityscope' not in already_processed: + already_processed.add('ambiguityscope') + self.ambiguityscope = value + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'scope': + value_ = child_.text + value_ = self.gds_parse_string(value_, node, 'scope') + value_ = self.gds_validate_string(value_, node, 'scope') + self.scope = value_ + self.scope_nsprefix_ = child_.prefix + elif nodeName_ == 'name': + value_ = child_.text + value_ = self.gds_parse_string(value_, node, 'name') + value_ = self.gds_validate_string(value_, node, 'name') + self.name = value_ + self.name_nsprefix_ = child_.prefix +# end class memberRefType + + +class scope(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, scope) + if subclass is not None: + return subclass(*args_, **kwargs_) + if scope.subclass: + return scope.subclass(*args_, **kwargs_) + return scope(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + def hasContent_(self): + if ( + + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='scope', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('scope') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'scope': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='scope') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='scope', pretty_print=pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='scope'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='scope', fromsubclass_=False, pretty_print=True): + pass + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + pass +# end class scope + + +class name(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, name) + if subclass is not None: + return subclass(*args_, **kwargs_) + if name.subclass: + return name.subclass(*args_, **kwargs_) + return name(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + def hasContent_(self): + if ( + + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='name', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('name') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'name': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='name') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='name', pretty_print=pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='name'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='name', fromsubclass_=False, pretty_print=True): + pass + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + pass +# end class name + + +class compoundRefType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, refid=None, prot=None, virt=None, valueOf_=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.refid = _cast(None, refid) + self.refid_nsprefix_ = None + self.prot = _cast(None, prot) + self.prot_nsprefix_ = None + self.virt = _cast(None, virt) + self.virt_nsprefix_ = None + self.valueOf_ = valueOf_ + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, compoundRefType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if compoundRefType.subclass: + return compoundRefType.subclass(*args_, **kwargs_) + return compoundRefType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + def get_refid(self): + return self.refid + def set_refid(self, refid): + self.refid = refid + def get_prot(self): + return self.prot + def set_prot(self, prot): + self.prot = prot + def get_virt(self): + return self.virt + def set_virt(self, virt): + self.virt = virt + def get_valueOf_(self): return self.valueOf_ + def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def validate_DoxProtectionKind(self, value): + # Validate type DoxProtectionKind, a restriction on xsd:string. + if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) + return False + value = value + enumerations = ['public', 'protected', 'private', 'package'] + if value not in enumerations: + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on DoxProtectionKind' % {"value" : encode_str_2_3(value), "lineno": lineno} ) + result = False + def validate_DoxVirtualKind(self, value): + # Validate type DoxVirtualKind, a restriction on xsd:string. + if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) + return False + value = value + enumerations = ['non-virtual', 'virtual', 'pure-virtual'] + if value not in enumerations: + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on DoxVirtualKind' % {"value" : encode_str_2_3(value), "lineno": lineno} ) + result = False + def hasContent_(self): + if ( + (1 if type(self.valueOf_) in [int,float] else self.valueOf_) + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='compoundRefType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('compoundRefType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'compoundRefType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='compoundRefType') + if self.hasContent_(): + outfile.write('>') + outfile.write(self.convert_unicode(self.valueOf_)) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='compoundRefType', pretty_print=pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='compoundRefType'): + if self.refid is not None and 'refid' not in already_processed: + already_processed.add('refid') + outfile.write(' refid=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.refid), input_name='refid')), )) + if self.prot is not None and 'prot' not in already_processed: + already_processed.add('prot') + outfile.write(' prot=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.prot), input_name='prot')), )) + if self.virt is not None and 'virt' not in already_processed: + already_processed.add('virt') + outfile.write(' virt=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.virt), input_name='virt')), )) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='compoundRefType', fromsubclass_=False, pretty_print=True): + pass + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + self.valueOf_ = get_all_text_(node) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('refid', node) + if value is not None and 'refid' not in already_processed: + already_processed.add('refid') + self.refid = value + value = find_attr_value_('prot', node) + if value is not None and 'prot' not in already_processed: + already_processed.add('prot') + self.prot = value + self.validate_DoxProtectionKind(self.prot) # validate type DoxProtectionKind + value = find_attr_value_('virt', node) + if value is not None and 'virt' not in already_processed: + already_processed.add('virt') + self.virt = value + self.validate_DoxVirtualKind(self.virt) # validate type DoxVirtualKind + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + pass +# end class compoundRefType + + +class reimplementType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, refid=None, valueOf_=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.refid = _cast(None, refid) + self.refid_nsprefix_ = None + self.valueOf_ = valueOf_ + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, reimplementType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if reimplementType.subclass: + return reimplementType.subclass(*args_, **kwargs_) + return reimplementType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + def get_refid(self): + return self.refid + def set_refid(self, refid): + self.refid = refid + def get_valueOf_(self): return self.valueOf_ + def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def hasContent_(self): + if ( + (1 if type(self.valueOf_) in [int,float] else self.valueOf_) + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='reimplementType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('reimplementType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'reimplementType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='reimplementType') + if self.hasContent_(): + outfile.write('>') + outfile.write(self.convert_unicode(self.valueOf_)) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='reimplementType', pretty_print=pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='reimplementType'): + if self.refid is not None and 'refid' not in already_processed: + already_processed.add('refid') + outfile.write(' refid=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.refid), input_name='refid')), )) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='reimplementType', fromsubclass_=False, pretty_print=True): + pass + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + self.valueOf_ = get_all_text_(node) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('refid', node) + if value is not None and 'refid' not in already_processed: + already_processed.add('refid') + self.refid = value + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + pass +# end class reimplementType + + +class incType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, refid=None, local=None, valueOf_=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.refid = _cast(None, refid) + self.refid_nsprefix_ = None + self.local = _cast(None, local) + self.local_nsprefix_ = None + self.valueOf_ = valueOf_ + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, incType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if incType.subclass: + return incType.subclass(*args_, **kwargs_) + return incType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + def get_refid(self): + return self.refid + def set_refid(self, refid): + self.refid = refid + def get_local(self): + return self.local + def set_local(self, local): + self.local = local + def get_valueOf_(self): return self.valueOf_ + def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def validate_DoxBool(self, value): + # Validate type DoxBool, a restriction on xsd:string. + if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) + return False + value = value + enumerations = ['yes', 'no'] + if value not in enumerations: + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on DoxBool' % {"value" : encode_str_2_3(value), "lineno": lineno} ) + result = False + def hasContent_(self): + if ( + (1 if type(self.valueOf_) in [int,float] else self.valueOf_) + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='incType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('incType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'incType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='incType') + if self.hasContent_(): + outfile.write('>') + outfile.write(self.convert_unicode(self.valueOf_)) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='incType', pretty_print=pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='incType'): + if self.refid is not None and 'refid' not in already_processed: + already_processed.add('refid') + outfile.write(' refid=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.refid), input_name='refid')), )) + if self.local is not None and 'local' not in already_processed: + already_processed.add('local') + outfile.write(' local=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.local), input_name='local')), )) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='incType', fromsubclass_=False, pretty_print=True): + pass + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + self.valueOf_ = get_all_text_(node) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('refid', node) + if value is not None and 'refid' not in already_processed: + already_processed.add('refid') + self.refid = value + value = find_attr_value_('local', node) + if value is not None and 'local' not in already_processed: + already_processed.add('local') + self.local = value + self.validate_DoxBool(self.local) # validate type DoxBool + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + pass +# end class incType + + +class refType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, refid=None, prot=None, valueOf_=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.refid = _cast(None, refid) + self.refid_nsprefix_ = None + self.prot = _cast(None, prot) + self.prot_nsprefix_ = None + self.valueOf_ = valueOf_ + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, refType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if refType.subclass: + return refType.subclass(*args_, **kwargs_) + return refType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + def get_refid(self): + return self.refid + def set_refid(self, refid): + self.refid = refid + def get_prot(self): + return self.prot + def set_prot(self, prot): + self.prot = prot + def get_valueOf_(self): return self.valueOf_ + def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def validate_DoxProtectionKind(self, value): + # Validate type DoxProtectionKind, a restriction on xsd:string. + if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) + return False + value = value + enumerations = ['public', 'protected', 'private', 'package'] + if value not in enumerations: + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on DoxProtectionKind' % {"value" : encode_str_2_3(value), "lineno": lineno} ) + result = False + def hasContent_(self): + if ( + (1 if type(self.valueOf_) in [int,float] else self.valueOf_) + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='refType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('refType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'refType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='refType') + if self.hasContent_(): + outfile.write('>') + outfile.write(self.convert_unicode(self.valueOf_)) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='refType', pretty_print=pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='refType'): + if self.refid is not None and 'refid' not in already_processed: + already_processed.add('refid') + outfile.write(' refid=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.refid), input_name='refid')), )) + if self.prot is not None and 'prot' not in already_processed: + already_processed.add('prot') + outfile.write(' prot=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.prot), input_name='prot')), )) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='refType', fromsubclass_=False, pretty_print=True): + pass + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + self.valueOf_ = get_all_text_(node) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('refid', node) + if value is not None and 'refid' not in already_processed: + already_processed.add('refid') + self.refid = value + value = find_attr_value_('prot', node) + if value is not None and 'prot' not in already_processed: + already_processed.add('prot') + self.prot = value + self.validate_DoxProtectionKind(self.prot) # validate type DoxProtectionKind + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + pass +# end class refType + + +class refTextType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, refid=None, kindref=None, external=None, tooltip=None, valueOf_=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.refid = _cast(None, refid) + self.refid_nsprefix_ = None + self.kindref = _cast(None, kindref) + self.kindref_nsprefix_ = None + self.external = _cast(None, external) + self.external_nsprefix_ = None + self.tooltip = _cast(None, tooltip) + self.tooltip_nsprefix_ = None + self.valueOf_ = valueOf_ + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, refTextType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if refTextType.subclass: + return refTextType.subclass(*args_, **kwargs_) + return refTextType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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 get_tooltip(self): + return self.tooltip + def set_tooltip(self, tooltip): + self.tooltip = tooltip + def get_valueOf_(self): return self.valueOf_ + def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def validate_DoxRefKind(self, value): + # Validate type DoxRefKind, a restriction on xsd:string. + if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) + return False + value = value + enumerations = ['compound', 'member'] + if value not in enumerations: + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on DoxRefKind' % {"value" : encode_str_2_3(value), "lineno": lineno} ) + result = False + def hasContent_(self): + if ( + (1 if type(self.valueOf_) in [int,float] else self.valueOf_) + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='refTextType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('refTextType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'refTextType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='refTextType') + if self.hasContent_(): + outfile.write('>') + outfile.write(self.convert_unicode(self.valueOf_)) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='refTextType', pretty_print=pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='refTextType'): + if self.refid is not None and 'refid' not in already_processed: + already_processed.add('refid') + outfile.write(' refid=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.refid), input_name='refid')), )) + if self.kindref is not None and 'kindref' not in already_processed: + already_processed.add('kindref') + outfile.write(' kindref=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.kindref), input_name='kindref')), )) + if self.external is not None and 'external' not in already_processed: + already_processed.add('external') + outfile.write(' external=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.external), input_name='external')), )) + if self.tooltip is not None and 'tooltip' not in already_processed: + already_processed.add('tooltip') + outfile.write(' tooltip=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.tooltip), input_name='tooltip')), )) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='refTextType', fromsubclass_=False, pretty_print=True): + pass + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + self.valueOf_ = get_all_text_(node) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('refid', node) + if value is not None and 'refid' not in already_processed: + already_processed.add('refid') + self.refid = value + value = find_attr_value_('kindref', node) + if value is not None and 'kindref' not in already_processed: + already_processed.add('kindref') + self.kindref = value + self.validate_DoxRefKind(self.kindref) # validate type DoxRefKind + value = find_attr_value_('external', node) + if value is not None and 'external' not in already_processed: + already_processed.add('external') + self.external = value + value = find_attr_value_('tooltip', node) + if value is not None and 'tooltip' not in already_processed: + already_processed.add('tooltip') + self.tooltip = value + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + pass +# end class refTextType + + +class sectiondefType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, kind=None, header=None, description=None, memberdef=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.kind = _cast(None, kind) + self.kind_nsprefix_ = None + self.header = header + self.header_nsprefix_ = None + self.description = description + self.description_nsprefix_ = None + if memberdef is None: + self.memberdef = [] + else: + self.memberdef = memberdef + self.memberdef_nsprefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, sectiondefType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if sectiondefType.subclass: + return sectiondefType.subclass(*args_, **kwargs_) + return sectiondefType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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_at(self, index, value): + self.memberdef.insert(index, value) + def replace_memberdef_at(self, index, value): + self.memberdef[index] = value + def get_kind(self): + return self.kind + def set_kind(self, kind): + self.kind = kind + def validate_DoxSectionKind(self, value): + # Validate type DoxSectionKind, a restriction on xsd:string. + if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) + return False + value = value + enumerations = ['user-defined', 'public-type', 'public-func', 'public-attrib', 'public-slot', 'signal', 'dcop-func', 'property', 'event', 'public-static-func', 'public-static-attrib', 'protected-type', 'protected-func', 'protected-attrib', 'protected-slot', 'protected-static-func', 'protected-static-attrib', 'package-type', 'package-func', 'package-attrib', 'package-static-func', 'package-static-attrib', 'private-type', 'private-func', 'private-attrib', 'private-slot', 'private-static-func', 'private-static-attrib', 'friend', 'related', 'define', 'prototype', 'typedef', 'enum', 'func', 'var'] + if value not in enumerations: + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on DoxSectionKind' % {"value" : encode_str_2_3(value), "lineno": lineno} ) + result = False + def hasContent_(self): + if ( + self.header is not None or + self.description is not None or + self.memberdef + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='sectiondefType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('sectiondefType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'sectiondefType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='sectiondefType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='sectiondefType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='sectiondefType'): + if self.kind is not None and 'kind' not in already_processed: + already_processed.add('kind') + outfile.write(' kind=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.kind), input_name='kind')), )) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='sectiondefType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.header is not None: + namespaceprefix_ = self.header_nsprefix_ + ':' if (UseCapturedNS_ and self.header_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%sheader>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.header), input_name='header')), namespaceprefix_ , eol_)) + if self.description is not None: + namespaceprefix_ = self.description_nsprefix_ + ':' if (UseCapturedNS_ and self.description_nsprefix_) else '' + self.description.export(outfile, level, namespaceprefix_, namespacedef_='', name_='description', pretty_print=pretty_print) + for memberdef_ in self.memberdef: + namespaceprefix_ = self.memberdef_nsprefix_ + ':' if (UseCapturedNS_ and self.memberdef_nsprefix_) else '' + memberdef_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='memberdef', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('kind', node) + if value is not None and 'kind' not in already_processed: + already_processed.add('kind') + self.kind = value + self.validate_DoxSectionKind(self.kind) # validate type DoxSectionKind + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'header': + value_ = child_.text + value_ = self.gds_parse_string(value_, node, 'header') + value_ = self.gds_validate_string(value_, node, 'header') + self.header = value_ + self.header_nsprefix_ = child_.prefix + elif nodeName_ == 'description': + obj_ = descriptionType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.description = obj_ + obj_.original_tagname_ = 'description' + elif nodeName_ == 'memberdef': + obj_ = memberdefType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.memberdef.append(obj_) + obj_.original_tagname_ = 'memberdef' +# end class sectiondefType + + +class memberdefType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, kind=None, id=None, prot=None, static=None, const=None, explicit=None, inline=None, virt=None, volatile=None, mutable=None, readable=None, writable=None, initonly=None, settable=None, gettable=None, final=None, sealed=None, new=None, add=None, remove=None, raise_=None, optional=None, required=None, accessor=None, attribute=None, property=None, readonly=None, bound=None, removable=None, contrained=None, transient=None, maybevoid=None, maybedefault=None, maybeambiguous=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, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.kind = _cast(None, kind) + self.kind_nsprefix_ = None + self.id = _cast(None, id) + self.id_nsprefix_ = None + self.prot = _cast(None, prot) + self.prot_nsprefix_ = None + self.static = _cast(None, static) + self.static_nsprefix_ = None + self.const = _cast(None, const) + self.const_nsprefix_ = None + self.explicit = _cast(None, explicit) + self.explicit_nsprefix_ = None + self.inline = _cast(None, inline) + self.inline_nsprefix_ = None + self.virt = _cast(None, virt) + self.virt_nsprefix_ = None + self.volatile = _cast(None, volatile) + self.volatile_nsprefix_ = None + self.mutable = _cast(None, mutable) + self.mutable_nsprefix_ = None + self.readable = _cast(None, readable) + self.readable_nsprefix_ = None + self.writable = _cast(None, writable) + self.writable_nsprefix_ = None + self.initonly = _cast(None, initonly) + self.initonly_nsprefix_ = None + self.settable = _cast(None, settable) + self.settable_nsprefix_ = None + self.gettable = _cast(None, gettable) + self.gettable_nsprefix_ = None + self.final = _cast(None, final) + self.final_nsprefix_ = None + self.sealed = _cast(None, sealed) + self.sealed_nsprefix_ = None + self.new = _cast(None, new) + self.new_nsprefix_ = None + self.add = _cast(None, add) + self.add_nsprefix_ = None + self.remove = _cast(None, remove) + self.remove_nsprefix_ = None + self.raise_ = _cast(None, raise_) + self.raise__nsprefix_ = None + self.optional = _cast(None, optional) + self.optional_nsprefix_ = None + self.required = _cast(None, required) + self.required_nsprefix_ = None + self.accessor = _cast(None, accessor) + self.accessor_nsprefix_ = None + self.attribute = _cast(None, attribute) + self.attribute_nsprefix_ = None + self.property = _cast(None, property) + self.property_nsprefix_ = None + self.readonly = _cast(None, readonly) + self.readonly_nsprefix_ = None + self.bound = _cast(None, bound) + self.bound_nsprefix_ = None + self.removable = _cast(None, removable) + self.removable_nsprefix_ = None + self.contrained = _cast(None, contrained) + self.contrained_nsprefix_ = None + self.transient = _cast(None, transient) + self.transient_nsprefix_ = None + self.maybevoid = _cast(None, maybevoid) + self.maybevoid_nsprefix_ = None + self.maybedefault = _cast(None, maybedefault) + self.maybedefault_nsprefix_ = None + self.maybeambiguous = _cast(None, maybeambiguous) + self.maybeambiguous_nsprefix_ = None + self.templateparamlist = templateparamlist + self.templateparamlist_nsprefix_ = None + self.type_ = type_ + self.type__nsprefix_ = None + self.definition = definition + self.definition_nsprefix_ = None + self.argsstring = argsstring + self.argsstring_nsprefix_ = None + self.name = name + self.name_nsprefix_ = None + self.read = read + self.read_nsprefix_ = None + self.write = write + self.write_nsprefix_ = None + self.bitfield = bitfield + self.bitfield_nsprefix_ = None + if reimplements is None: + self.reimplements = [] + else: + self.reimplements = reimplements + self.reimplements_nsprefix_ = None + if reimplementedby is None: + self.reimplementedby = [] + else: + self.reimplementedby = reimplementedby + self.reimplementedby_nsprefix_ = None + if param is None: + self.param = [] + else: + self.param = param + self.param_nsprefix_ = None + if enumvalue is None: + self.enumvalue = [] + else: + self.enumvalue = enumvalue + self.enumvalue_nsprefix_ = None + self.initializer = initializer + self.initializer_nsprefix_ = None + self.exceptions = exceptions + self.exceptions_nsprefix_ = None + self.briefdescription = briefdescription + self.briefdescription_nsprefix_ = None + self.detaileddescription = detaileddescription + self.detaileddescription_nsprefix_ = None + self.inbodydescription = inbodydescription + self.inbodydescription_nsprefix_ = None + self.location = location + self.location_nsprefix_ = None + if references is None: + self.references = [] + else: + self.references = references + self.references_nsprefix_ = None + if referencedby is None: + self.referencedby = [] + else: + self.referencedby = referencedby + self.referencedby_nsprefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, memberdefType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if memberdefType.subclass: + return memberdefType.subclass(*args_, **kwargs_) + return memberdefType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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_at(self, index, value): + self.reimplements.insert(index, value) + def replace_reimplements_at(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_at(self, index, value): + self.reimplementedby.insert(index, value) + def replace_reimplementedby_at(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_at(self, index, value): + self.param.insert(index, value) + def replace_param_at(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_at(self, index, value): + self.enumvalue.insert(index, value) + def replace_enumvalue_at(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_at(self, index, value): + self.references.insert(index, value) + def replace_references_at(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_at(self, index, value): + self.referencedby.insert(index, value) + def replace_referencedby_at(self, index, value): + self.referencedby[index] = value + def get_kind(self): + return self.kind + def set_kind(self, kind): + self.kind = kind + def get_id(self): + return self.id + def set_id(self, id): + self.id = id + def get_prot(self): + return self.prot + def set_prot(self, prot): + self.prot = prot + def get_static(self): + return self.static + def set_static(self, static): + self.static = static + def get_const(self): + return self.const + def set_const(self, const): + self.const = const + def get_explicit(self): + return self.explicit + def set_explicit(self, explicit): + self.explicit = explicit + def get_inline(self): + return self.inline + def set_inline(self, inline): + self.inline = inline + def get_virt(self): + return self.virt + def set_virt(self, virt): + self.virt = virt + def get_volatile(self): + return self.volatile + def set_volatile(self, volatile): + self.volatile = volatile + def get_mutable(self): + return self.mutable + def set_mutable(self, mutable): + self.mutable = mutable + def get_readable(self): + return self.readable + def set_readable(self, readable): + self.readable = readable + def get_writable(self): + return self.writable + def set_writable(self, writable): + self.writable = writable + def get_initonly(self): + return self.initonly + def set_initonly(self, initonly): + self.initonly = initonly + def get_settable(self): + return self.settable + def set_settable(self, settable): + self.settable = settable + def get_gettable(self): + return self.gettable + def set_gettable(self, gettable): + self.gettable = gettable + def get_final(self): + return self.final + def set_final(self, final): + self.final = final + def get_sealed(self): + return self.sealed + def set_sealed(self, sealed): + self.sealed = sealed + def get_new(self): + return self.new + def set_new(self, new): + self.new = new + def get_add(self): + return self.add + def set_add(self, add): + self.add = add + def get_remove(self): + return self.remove + def set_remove(self, remove): + self.remove = remove + def get_raise(self): + return self.raise_ + def set_raise(self, raise_): + self.raise_ = raise_ + def get_optional(self): + return self.optional + def set_optional(self, optional): + self.optional = optional + def get_required(self): + return self.required + def set_required(self, required): + self.required = required + def get_accessor(self): + return self.accessor + def set_accessor(self, accessor): + self.accessor = accessor + def get_attribute(self): + return self.attribute + def set_attribute(self, attribute): + self.attribute = attribute + def get_property(self): + return self.property + def set_property(self, property): + self.property = property + def get_readonly(self): + return self.readonly + def set_readonly(self, readonly): + self.readonly = readonly + def get_bound(self): + return self.bound + def set_bound(self, bound): + self.bound = bound + def get_removable(self): + return self.removable + def set_removable(self, removable): + self.removable = removable + def get_contrained(self): + return self.contrained + def set_contrained(self, contrained): + self.contrained = contrained + def get_transient(self): + return self.transient + def set_transient(self, transient): + self.transient = transient + def get_maybevoid(self): + return self.maybevoid + def set_maybevoid(self, maybevoid): + self.maybevoid = maybevoid + def get_maybedefault(self): + return self.maybedefault + def set_maybedefault(self, maybedefault): + self.maybedefault = maybedefault + def get_maybeambiguous(self): + return self.maybeambiguous + def set_maybeambiguous(self, maybeambiguous): + self.maybeambiguous = maybeambiguous + def validate_DoxMemberKind(self, value): + # Validate type DoxMemberKind, a restriction on xsd:string. + if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) + return False + value = value + enumerations = ['define', 'property', 'event', 'variable', 'typedef', 'enum', 'function', 'signal', 'prototype', 'friend', 'dcop', 'slot', 'interface', 'service'] + if value not in enumerations: + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on DoxMemberKind' % {"value" : encode_str_2_3(value), "lineno": lineno} ) + result = False + def validate_DoxProtectionKind(self, value): + # Validate type DoxProtectionKind, a restriction on xsd:string. + if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) + return False + value = value + enumerations = ['public', 'protected', 'private', 'package'] + if value not in enumerations: + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on DoxProtectionKind' % {"value" : encode_str_2_3(value), "lineno": lineno} ) + result = False + def validate_DoxBool(self, value): + # Validate type DoxBool, a restriction on xsd:string. + if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) + return False + value = value + enumerations = ['yes', 'no'] + if value not in enumerations: + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on DoxBool' % {"value" : encode_str_2_3(value), "lineno": lineno} ) + result = False + def validate_DoxVirtualKind(self, value): + # Validate type DoxVirtualKind, a restriction on xsd:string. + if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) + return False + value = value + enumerations = ['non-virtual', 'virtual', 'pure-virtual'] + if value not in enumerations: + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on DoxVirtualKind' % {"value" : encode_str_2_3(value), "lineno": lineno} ) + result = False + def validate_DoxAccessor(self, value): + # Validate type DoxAccessor, a restriction on xsd:string. + if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) + return False + value = value + enumerations = ['retain', 'copy', 'assign', 'weak', 'strong', 'unretained'] + if value not in enumerations: + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on DoxAccessor' % {"value" : encode_str_2_3(value), "lineno": lineno} ) + result = False + 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 or + self.reimplementedby or + self.param or + self.enumvalue 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 or + self.referencedby + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='memberdefType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('memberdefType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'memberdefType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='memberdefType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='memberdefType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='memberdefType'): + if self.kind is not None and 'kind' not in already_processed: + already_processed.add('kind') + outfile.write(' kind=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.kind), input_name='kind')), )) + if self.id is not None and 'id' not in already_processed: + already_processed.add('id') + outfile.write(' id=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.id), input_name='id')), )) + if self.prot is not None and 'prot' not in already_processed: + already_processed.add('prot') + outfile.write(' prot=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.prot), input_name='prot')), )) + if self.static is not None and 'static' not in already_processed: + already_processed.add('static') + outfile.write(' static=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.static), input_name='static')), )) + if self.const is not None and 'const' not in already_processed: + already_processed.add('const') + outfile.write(' const=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.const), input_name='const')), )) + if self.explicit is not None and 'explicit' not in already_processed: + already_processed.add('explicit') + outfile.write(' explicit=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.explicit), input_name='explicit')), )) + if self.inline is not None and 'inline' not in already_processed: + already_processed.add('inline') + outfile.write(' inline=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.inline), input_name='inline')), )) + if self.virt is not None and 'virt' not in already_processed: + already_processed.add('virt') + outfile.write(' virt=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.virt), input_name='virt')), )) + if self.volatile is not None and 'volatile' not in already_processed: + already_processed.add('volatile') + outfile.write(' volatile=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.volatile), input_name='volatile')), )) + if self.mutable is not None and 'mutable' not in already_processed: + already_processed.add('mutable') + outfile.write(' mutable=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mutable), input_name='mutable')), )) + if self.readable is not None and 'readable' not in already_processed: + already_processed.add('readable') + outfile.write(' readable=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.readable), input_name='readable')), )) + if self.writable is not None and 'writable' not in already_processed: + already_processed.add('writable') + outfile.write(' writable=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.writable), input_name='writable')), )) + if self.initonly is not None and 'initonly' not in already_processed: + already_processed.add('initonly') + outfile.write(' initonly=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.initonly), input_name='initonly')), )) + if self.settable is not None and 'settable' not in already_processed: + already_processed.add('settable') + outfile.write(' settable=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.settable), input_name='settable')), )) + if self.gettable is not None and 'gettable' not in already_processed: + already_processed.add('gettable') + outfile.write(' gettable=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.gettable), input_name='gettable')), )) + if self.final is not None and 'final' not in already_processed: + already_processed.add('final') + outfile.write(' final=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.final), input_name='final')), )) + if self.sealed is not None and 'sealed' not in already_processed: + already_processed.add('sealed') + outfile.write(' sealed=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.sealed), input_name='sealed')), )) + if self.new is not None and 'new' not in already_processed: + already_processed.add('new') + outfile.write(' new=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.new), input_name='new')), )) + if self.add is not None and 'add' not in already_processed: + already_processed.add('add') + outfile.write(' add=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.add), input_name='add')), )) + if self.remove is not None and 'remove' not in already_processed: + already_processed.add('remove') + outfile.write(' remove=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.remove), input_name='remove')), )) + if self.raise_ is not None and 'raise_' not in already_processed: + already_processed.add('raise_') + outfile.write(' raise=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.raise_), input_name='raise')), )) + if self.optional is not None and 'optional' not in already_processed: + already_processed.add('optional') + outfile.write(' optional=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.optional), input_name='optional')), )) + if self.required is not None and 'required' not in already_processed: + already_processed.add('required') + outfile.write(' required=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.required), input_name='required')), )) + if self.accessor is not None and 'accessor' not in already_processed: + already_processed.add('accessor') + outfile.write(' accessor=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.accessor), input_name='accessor')), )) + if self.attribute is not None and 'attribute' not in already_processed: + already_processed.add('attribute') + outfile.write(' attribute=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.attribute), input_name='attribute')), )) + if self.property is not None and 'property' not in already_processed: + already_processed.add('property') + outfile.write(' property=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.property), input_name='property')), )) + if self.readonly is not None and 'readonly' not in already_processed: + already_processed.add('readonly') + outfile.write(' readonly=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.readonly), input_name='readonly')), )) + if self.bound is not None and 'bound' not in already_processed: + already_processed.add('bound') + outfile.write(' bound=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.bound), input_name='bound')), )) + if self.removable is not None and 'removable' not in already_processed: + already_processed.add('removable') + outfile.write(' removable=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.removable), input_name='removable')), )) + if self.contrained is not None and 'contrained' not in already_processed: + already_processed.add('contrained') + outfile.write(' contrained=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.contrained), input_name='contrained')), )) + if self.transient is not None and 'transient' not in already_processed: + already_processed.add('transient') + outfile.write(' transient=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.transient), input_name='transient')), )) + if self.maybevoid is not None and 'maybevoid' not in already_processed: + already_processed.add('maybevoid') + outfile.write(' maybevoid=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.maybevoid), input_name='maybevoid')), )) + if self.maybedefault is not None and 'maybedefault' not in already_processed: + already_processed.add('maybedefault') + outfile.write(' maybedefault=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.maybedefault), input_name='maybedefault')), )) + if self.maybeambiguous is not None and 'maybeambiguous' not in already_processed: + already_processed.add('maybeambiguous') + outfile.write(' maybeambiguous=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.maybeambiguous), input_name='maybeambiguous')), )) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='memberdefType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.templateparamlist is not None: + namespaceprefix_ = self.templateparamlist_nsprefix_ + ':' if (UseCapturedNS_ and self.templateparamlist_nsprefix_) else '' + self.templateparamlist.export(outfile, level, namespaceprefix_, namespacedef_='', name_='templateparamlist', pretty_print=pretty_print) + if self.type_ is not None: + namespaceprefix_ = self.type__nsprefix_ + ':' if (UseCapturedNS_ and self.type__nsprefix_) else '' + self.type_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='type', pretty_print=pretty_print) + if self.definition is not None: + namespaceprefix_ = self.definition_nsprefix_ + ':' if (UseCapturedNS_ and self.definition_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%sdefinition>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.definition), input_name='definition')), namespaceprefix_ , eol_)) + if self.argsstring is not None: + namespaceprefix_ = self.argsstring_nsprefix_ + ':' if (UseCapturedNS_ and self.argsstring_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%sargsstring>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.argsstring), input_name='argsstring')), namespaceprefix_ , eol_)) + if self.name is not None: + namespaceprefix_ = self.name_nsprefix_ + ':' if (UseCapturedNS_ and self.name_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%sname>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.name), input_name='name')), namespaceprefix_ , eol_)) + if self.read is not None: + namespaceprefix_ = self.read_nsprefix_ + ':' if (UseCapturedNS_ and self.read_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%sread>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.read), input_name='read')), namespaceprefix_ , eol_)) + if self.write is not None: + namespaceprefix_ = self.write_nsprefix_ + ':' if (UseCapturedNS_ and self.write_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%swrite>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.write), input_name='write')), namespaceprefix_ , eol_)) + if self.bitfield is not None: + namespaceprefix_ = self.bitfield_nsprefix_ + ':' if (UseCapturedNS_ and self.bitfield_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%sbitfield>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.bitfield), input_name='bitfield')), namespaceprefix_ , eol_)) + for reimplements_ in self.reimplements: + namespaceprefix_ = self.reimplements_nsprefix_ + ':' if (UseCapturedNS_ and self.reimplements_nsprefix_) else '' + reimplements_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='reimplements', pretty_print=pretty_print) + for reimplementedby_ in self.reimplementedby: + namespaceprefix_ = self.reimplementedby_nsprefix_ + ':' if (UseCapturedNS_ and self.reimplementedby_nsprefix_) else '' + reimplementedby_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='reimplementedby', pretty_print=pretty_print) + for param_ in self.param: + namespaceprefix_ = self.param_nsprefix_ + ':' if (UseCapturedNS_ and self.param_nsprefix_) else '' + param_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='param', pretty_print=pretty_print) + for enumvalue_ in self.enumvalue: + namespaceprefix_ = self.enumvalue_nsprefix_ + ':' if (UseCapturedNS_ and self.enumvalue_nsprefix_) else '' + enumvalue_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='enumvalue', pretty_print=pretty_print) + if self.initializer is not None: + namespaceprefix_ = self.initializer_nsprefix_ + ':' if (UseCapturedNS_ and self.initializer_nsprefix_) else '' + self.initializer.export(outfile, level, namespaceprefix_, namespacedef_='', name_='initializer', pretty_print=pretty_print) + if self.exceptions is not None: + namespaceprefix_ = self.exceptions_nsprefix_ + ':' if (UseCapturedNS_ and self.exceptions_nsprefix_) else '' + self.exceptions.export(outfile, level, namespaceprefix_, namespacedef_='', name_='exceptions', pretty_print=pretty_print) + if self.briefdescription is not None: + namespaceprefix_ = self.briefdescription_nsprefix_ + ':' if (UseCapturedNS_ and self.briefdescription_nsprefix_) else '' + self.briefdescription.export(outfile, level, namespaceprefix_, namespacedef_='', name_='briefdescription', pretty_print=pretty_print) + if self.detaileddescription is not None: + namespaceprefix_ = self.detaileddescription_nsprefix_ + ':' if (UseCapturedNS_ and self.detaileddescription_nsprefix_) else '' + self.detaileddescription.export(outfile, level, namespaceprefix_, namespacedef_='', name_='detaileddescription', pretty_print=pretty_print) + if self.inbodydescription is not None: + namespaceprefix_ = self.inbodydescription_nsprefix_ + ':' if (UseCapturedNS_ and self.inbodydescription_nsprefix_) else '' + self.inbodydescription.export(outfile, level, namespaceprefix_, namespacedef_='', name_='inbodydescription', pretty_print=pretty_print) + if self.location is not None: + namespaceprefix_ = self.location_nsprefix_ + ':' if (UseCapturedNS_ and self.location_nsprefix_) else '' + self.location.export(outfile, level, namespaceprefix_, namespacedef_='', name_='location', pretty_print=pretty_print) + for references_ in self.references: + namespaceprefix_ = self.references_nsprefix_ + ':' if (UseCapturedNS_ and self.references_nsprefix_) else '' + references_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='references', pretty_print=pretty_print) + for referencedby_ in self.referencedby: + namespaceprefix_ = self.referencedby_nsprefix_ + ':' if (UseCapturedNS_ and self.referencedby_nsprefix_) else '' + referencedby_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='referencedby', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('kind', node) + if value is not None and 'kind' not in already_processed: + already_processed.add('kind') + self.kind = value + self.validate_DoxMemberKind(self.kind) # validate type DoxMemberKind + value = find_attr_value_('id', node) + if value is not None and 'id' not in already_processed: + already_processed.add('id') + self.id = value + value = find_attr_value_('prot', node) + if value is not None and 'prot' not in already_processed: + already_processed.add('prot') + self.prot = value + self.validate_DoxProtectionKind(self.prot) # validate type DoxProtectionKind + value = find_attr_value_('static', node) + if value is not None and 'static' not in already_processed: + already_processed.add('static') + self.static = value + self.validate_DoxBool(self.static) # validate type DoxBool + value = find_attr_value_('const', node) + if value is not None and 'const' not in already_processed: + already_processed.add('const') + self.const = value + self.validate_DoxBool(self.const) # validate type DoxBool + value = find_attr_value_('explicit', node) + if value is not None and 'explicit' not in already_processed: + already_processed.add('explicit') + self.explicit = value + self.validate_DoxBool(self.explicit) # validate type DoxBool + value = find_attr_value_('inline', node) + if value is not None and 'inline' not in already_processed: + already_processed.add('inline') + self.inline = value + self.validate_DoxBool(self.inline) # validate type DoxBool + value = find_attr_value_('virt', node) + if value is not None and 'virt' not in already_processed: + already_processed.add('virt') + self.virt = value + self.validate_DoxVirtualKind(self.virt) # validate type DoxVirtualKind + value = find_attr_value_('volatile', node) + if value is not None and 'volatile' not in already_processed: + already_processed.add('volatile') + self.volatile = value + self.validate_DoxBool(self.volatile) # validate type DoxBool + value = find_attr_value_('mutable', node) + if value is not None and 'mutable' not in already_processed: + already_processed.add('mutable') + self.mutable = value + self.validate_DoxBool(self.mutable) # validate type DoxBool + value = find_attr_value_('readable', node) + if value is not None and 'readable' not in already_processed: + already_processed.add('readable') + self.readable = value + self.validate_DoxBool(self.readable) # validate type DoxBool + value = find_attr_value_('writable', node) + if value is not None and 'writable' not in already_processed: + already_processed.add('writable') + self.writable = value + self.validate_DoxBool(self.writable) # validate type DoxBool + value = find_attr_value_('initonly', node) + if value is not None and 'initonly' not in already_processed: + already_processed.add('initonly') + self.initonly = value + self.validate_DoxBool(self.initonly) # validate type DoxBool + value = find_attr_value_('settable', node) + if value is not None and 'settable' not in already_processed: + already_processed.add('settable') + self.settable = value + self.validate_DoxBool(self.settable) # validate type DoxBool + value = find_attr_value_('gettable', node) + if value is not None and 'gettable' not in already_processed: + already_processed.add('gettable') + self.gettable = value + self.validate_DoxBool(self.gettable) # validate type DoxBool + value = find_attr_value_('final', node) + if value is not None and 'final' not in already_processed: + already_processed.add('final') + self.final = value + self.validate_DoxBool(self.final) # validate type DoxBool + value = find_attr_value_('sealed', node) + if value is not None and 'sealed' not in already_processed: + already_processed.add('sealed') + self.sealed = value + self.validate_DoxBool(self.sealed) # validate type DoxBool + value = find_attr_value_('new', node) + if value is not None and 'new' not in already_processed: + already_processed.add('new') + self.new = value + self.validate_DoxBool(self.new) # validate type DoxBool + value = find_attr_value_('add', node) + if value is not None and 'add' not in already_processed: + already_processed.add('add') + self.add = value + self.validate_DoxBool(self.add) # validate type DoxBool + value = find_attr_value_('remove', node) + if value is not None and 'remove' not in already_processed: + already_processed.add('remove') + self.remove = value + self.validate_DoxBool(self.remove) # validate type DoxBool + value = find_attr_value_('raise', node) + if value is not None and 'raise' not in already_processed: + already_processed.add('raise') + self.raise_ = value + self.validate_DoxBool(self.raise_) # validate type DoxBool + value = find_attr_value_('optional', node) + if value is not None and 'optional' not in already_processed: + already_processed.add('optional') + self.optional = value + self.validate_DoxBool(self.optional) # validate type DoxBool + value = find_attr_value_('required', node) + if value is not None and 'required' not in already_processed: + already_processed.add('required') + self.required = value + self.validate_DoxBool(self.required) # validate type DoxBool + value = find_attr_value_('accessor', node) + if value is not None and 'accessor' not in already_processed: + already_processed.add('accessor') + self.accessor = value + self.validate_DoxAccessor(self.accessor) # validate type DoxAccessor + value = find_attr_value_('attribute', node) + if value is not None and 'attribute' not in already_processed: + already_processed.add('attribute') + self.attribute = value + self.validate_DoxBool(self.attribute) # validate type DoxBool + value = find_attr_value_('property', node) + if value is not None and 'property' not in already_processed: + already_processed.add('property') + self.property = value + self.validate_DoxBool(self.property) # validate type DoxBool + value = find_attr_value_('readonly', node) + if value is not None and 'readonly' not in already_processed: + already_processed.add('readonly') + self.readonly = value + self.validate_DoxBool(self.readonly) # validate type DoxBool + value = find_attr_value_('bound', node) + if value is not None and 'bound' not in already_processed: + already_processed.add('bound') + self.bound = value + self.validate_DoxBool(self.bound) # validate type DoxBool + value = find_attr_value_('removable', node) + if value is not None and 'removable' not in already_processed: + already_processed.add('removable') + self.removable = value + self.validate_DoxBool(self.removable) # validate type DoxBool + value = find_attr_value_('contrained', node) + if value is not None and 'contrained' not in already_processed: + already_processed.add('contrained') + self.contrained = value + self.validate_DoxBool(self.contrained) # validate type DoxBool + value = find_attr_value_('transient', node) + if value is not None and 'transient' not in already_processed: + already_processed.add('transient') + self.transient = value + self.validate_DoxBool(self.transient) # validate type DoxBool + value = find_attr_value_('maybevoid', node) + if value is not None and 'maybevoid' not in already_processed: + already_processed.add('maybevoid') + self.maybevoid = value + self.validate_DoxBool(self.maybevoid) # validate type DoxBool + value = find_attr_value_('maybedefault', node) + if value is not None and 'maybedefault' not in already_processed: + already_processed.add('maybedefault') + self.maybedefault = value + self.validate_DoxBool(self.maybedefault) # validate type DoxBool + value = find_attr_value_('maybeambiguous', node) + if value is not None and 'maybeambiguous' not in already_processed: + already_processed.add('maybeambiguous') + self.maybeambiguous = value + self.validate_DoxBool(self.maybeambiguous) # validate type DoxBool + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'templateparamlist': + obj_ = templateparamlistType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.templateparamlist = obj_ + obj_.original_tagname_ = 'templateparamlist' + elif nodeName_ == 'type': + obj_ = linkedTextType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.type_ = obj_ + obj_.original_tagname_ = 'type' + elif nodeName_ == 'definition': + value_ = child_.text + value_ = self.gds_parse_string(value_, node, 'definition') + value_ = self.gds_validate_string(value_, node, 'definition') + self.definition = value_ + self.definition_nsprefix_ = child_.prefix + elif nodeName_ == 'argsstring': + value_ = child_.text + value_ = self.gds_parse_string(value_, node, 'argsstring') + value_ = self.gds_validate_string(value_, node, 'argsstring') + self.argsstring = value_ + self.argsstring_nsprefix_ = child_.prefix + elif nodeName_ == 'name': + value_ = child_.text + value_ = self.gds_parse_string(value_, node, 'name') + value_ = self.gds_validate_string(value_, node, 'name') + self.name = value_ + self.name_nsprefix_ = child_.prefix + elif nodeName_ == 'read': + value_ = child_.text + value_ = self.gds_parse_string(value_, node, 'read') + value_ = self.gds_validate_string(value_, node, 'read') + self.read = value_ + self.read_nsprefix_ = child_.prefix + elif nodeName_ == 'write': + value_ = child_.text + value_ = self.gds_parse_string(value_, node, 'write') + value_ = self.gds_validate_string(value_, node, 'write') + self.write = value_ + self.write_nsprefix_ = child_.prefix + elif nodeName_ == 'bitfield': + value_ = child_.text + value_ = self.gds_parse_string(value_, node, 'bitfield') + value_ = self.gds_validate_string(value_, node, 'bitfield') + self.bitfield = value_ + self.bitfield_nsprefix_ = child_.prefix + elif nodeName_ == 'reimplements': + obj_ = reimplementType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.reimplements.append(obj_) + obj_.original_tagname_ = 'reimplements' + elif nodeName_ == 'reimplementedby': + obj_ = reimplementType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.reimplementedby.append(obj_) + obj_.original_tagname_ = 'reimplementedby' + elif nodeName_ == 'param': + obj_ = paramType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.param.append(obj_) + obj_.original_tagname_ = 'param' + elif nodeName_ == 'enumvalue': + obj_ = enumvalueType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.enumvalue.append(obj_) + obj_.original_tagname_ = 'enumvalue' + elif nodeName_ == 'initializer': + obj_ = linkedTextType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.initializer = obj_ + obj_.original_tagname_ = 'initializer' + elif nodeName_ == 'exceptions': + obj_ = linkedTextType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.exceptions = obj_ + obj_.original_tagname_ = 'exceptions' + elif nodeName_ == 'briefdescription': + obj_ = descriptionType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.briefdescription = obj_ + obj_.original_tagname_ = 'briefdescription' + elif nodeName_ == 'detaileddescription': + obj_ = descriptionType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.detaileddescription = obj_ + obj_.original_tagname_ = 'detaileddescription' + elif nodeName_ == 'inbodydescription': + obj_ = descriptionType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.inbodydescription = obj_ + obj_.original_tagname_ = 'inbodydescription' + elif nodeName_ == 'location': + obj_ = locationType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.location = obj_ + obj_.original_tagname_ = 'location' + elif nodeName_ == 'references': + obj_ = referenceType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.references.append(obj_) + obj_.original_tagname_ = 'references' + elif nodeName_ == 'referencedby': + obj_ = referenceType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.referencedby.append(obj_) + obj_.original_tagname_ = 'referencedby' +# end class memberdefType + + +class definition(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, definition) + if subclass is not None: + return subclass(*args_, **kwargs_) + if definition.subclass: + return definition.subclass(*args_, **kwargs_) + return definition(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + def hasContent_(self): + if ( + + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='definition', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('definition') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'definition': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='definition') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='definition', pretty_print=pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='definition'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='definition', fromsubclass_=False, pretty_print=True): + pass + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + pass +# end class definition + + +class argsstring(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, argsstring) + if subclass is not None: + return subclass(*args_, **kwargs_) + if argsstring.subclass: + return argsstring.subclass(*args_, **kwargs_) + return argsstring(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + def hasContent_(self): + if ( + + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='argsstring', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('argsstring') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'argsstring': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='argsstring') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='argsstring', pretty_print=pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='argsstring'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='argsstring', fromsubclass_=False, pretty_print=True): + pass + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + pass +# end class argsstring + + +class read(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, read) + if subclass is not None: + return subclass(*args_, **kwargs_) + if read.subclass: + return read.subclass(*args_, **kwargs_) + return read(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + def hasContent_(self): + if ( + + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='read', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('read') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'read': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='read') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='read', pretty_print=pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='read'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='read', fromsubclass_=False, pretty_print=True): + pass + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + pass +# end class read + + +class write(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, write) + if subclass is not None: + return subclass(*args_, **kwargs_) + if write.subclass: + return write.subclass(*args_, **kwargs_) + return write(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + def hasContent_(self): + if ( + + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='write', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('write') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'write': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='write') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='write', pretty_print=pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='write'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='write', fromsubclass_=False, pretty_print=True): + pass + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + pass +# end class write + + +class bitfield(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, bitfield) + if subclass is not None: + return subclass(*args_, **kwargs_) + if bitfield.subclass: + return bitfield.subclass(*args_, **kwargs_) + return bitfield(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + def hasContent_(self): + if ( + + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='bitfield', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('bitfield') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'bitfield': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='bitfield') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='bitfield', pretty_print=pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='bitfield'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='bitfield', fromsubclass_=False, pretty_print=True): + pass + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + pass +# end class bitfield + + +class descriptionType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, title=None, para=None, sect1=None, internal=None, valueOf_=None, mixedclass_=None, content_=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.title = title + self.title_nsprefix_ = None + if para is None: + self.para = [] + else: + self.para = para + self.para_nsprefix_ = None + if sect1 is None: + self.sect1 = [] + else: + self.sect1 = sect1 + self.sect1_nsprefix_ = None + self.internal = internal + self.internal_nsprefix_ = None + self.valueOf_ = valueOf_ + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + self.valueOf_ = valueOf_ + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, descriptionType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if descriptionType.subclass: + return descriptionType.subclass(*args_, **kwargs_) + return descriptionType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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_at(self, index, value): + self.para.insert(index, value) + def replace_para_at(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_at(self, index, value): + self.sect1.insert(index, value) + def replace_sect1_at(self, index, value): + self.sect1[index] = value + def get_internal(self): + return self.internal + def set_internal(self, internal): + self.internal = internal + def get_valueOf_(self): return self.valueOf_ + def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def hasContent_(self): + if ( + self.title is not None or + self.para or + self.sect1 or + self.internal is not None or + (1 if type(self.valueOf_) in [int,float] else self.valueOf_) or + self.content_ + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='descriptionType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('descriptionType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'descriptionType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='descriptionType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='descriptionType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='descriptionType'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='descriptionType', fromsubclass_=False, pretty_print=True): + if not fromsubclass_: + for item_ in self.content_: + item_.export(outfile, level, item_.name, namespaceprefix_, pretty_print=pretty_print) + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.title is not None: + namespaceprefix_ = self.title_nsprefix_ + ':' if (UseCapturedNS_ and self.title_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%stitle>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.title), input_name='title')), namespaceprefix_ , eol_)) + for para_ in self.para: + namespaceprefix_ = self.para_nsprefix_ + ':' if (UseCapturedNS_ and self.para_nsprefix_) else '' + para_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='para', pretty_print=pretty_print) + for sect1_ in self.sect1: + namespaceprefix_ = self.sect1_nsprefix_ + ':' if (UseCapturedNS_ and self.sect1_nsprefix_) else '' + sect1_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sect1', pretty_print=pretty_print) + if self.internal is not None: + namespaceprefix_ = self.internal_nsprefix_ + ':' if (UseCapturedNS_ and self.internal_nsprefix_) else '' + self.internal.export(outfile, level, namespaceprefix_, namespacedef_='', name_='internal', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + self.valueOf_ = get_all_text_(node) + if node.text is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', node.text) + self.content_.append(obj_) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'title' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'title') + valuestr_ = self.gds_validate_string(valuestr_, node, 'title') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'title', valuestr_) + self.content_.append(obj_) + self.title_nsprefix_ = child_.prefix + elif nodeName_ == 'para': + obj_ = docParaType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'para', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_para'): + self.add_para(obj_.value) + elif hasattr(self, 'set_para'): + self.set_para(obj_.value) + elif nodeName_ == 'sect1': + obj_ = docSect1Type.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sect1', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sect1'): + self.add_sect1(obj_.value) + elif hasattr(self, 'set_sect1'): + self.set_sect1(obj_.value) + elif nodeName_ == 'internal': + obj_ = docInternalType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'internal', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_internal'): + self.add_internal(obj_.value) + elif hasattr(self, 'set_internal'): + self.set_internal(obj_.value) + if not fromsubclass_ and child_.tail is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.tail) + self.content_.append(obj_) +# end class descriptionType + + +class enumvalueType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, id=None, prot=None, name=None, initializer=None, briefdescription=None, detaileddescription=None, valueOf_=None, mixedclass_=None, content_=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.id = _cast(None, id) + self.id_nsprefix_ = None + self.prot = _cast(None, prot) + self.prot_nsprefix_ = None + self.name = name + self.name_nsprefix_ = None + self.initializer = initializer + self.initializer_nsprefix_ = None + self.briefdescription = briefdescription + self.briefdescription_nsprefix_ = None + self.detaileddescription = detaileddescription + self.detaileddescription_nsprefix_ = None + self.valueOf_ = valueOf_ + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + self.valueOf_ = valueOf_ + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, enumvalueType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if enumvalueType.subclass: + return enumvalueType.subclass(*args_, **kwargs_) + return enumvalueType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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_id(self): + return self.id + def set_id(self, id): + self.id = id + def get_prot(self): + return self.prot + def set_prot(self, prot): + self.prot = prot + def get_valueOf_(self): return self.valueOf_ + def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def validate_DoxProtectionKind(self, value): + # Validate type DoxProtectionKind, a restriction on xsd:string. + if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) + return False + value = value + enumerations = ['public', 'protected', 'private', 'package'] + if value not in enumerations: + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on DoxProtectionKind' % {"value" : encode_str_2_3(value), "lineno": lineno} ) + result = False + 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 or + (1 if type(self.valueOf_) in [int,float] else self.valueOf_) or + self.content_ + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='enumvalueType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('enumvalueType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'enumvalueType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='enumvalueType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='enumvalueType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='enumvalueType'): + if self.id is not None and 'id' not in already_processed: + already_processed.add('id') + outfile.write(' id=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.id), input_name='id')), )) + if self.prot is not None and 'prot' not in already_processed: + already_processed.add('prot') + outfile.write(' prot=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.prot), input_name='prot')), )) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='enumvalueType', fromsubclass_=False, pretty_print=True): + if not fromsubclass_: + for item_ in self.content_: + item_.export(outfile, level, item_.name, namespaceprefix_, pretty_print=pretty_print) + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.name is not None: + namespaceprefix_ = self.name_nsprefix_ + ':' if (UseCapturedNS_ and self.name_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%sname>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.name), input_name='name')), namespaceprefix_ , eol_)) + if self.initializer is not None: + namespaceprefix_ = self.initializer_nsprefix_ + ':' if (UseCapturedNS_ and self.initializer_nsprefix_) else '' + self.initializer.export(outfile, level, namespaceprefix_, namespacedef_='', name_='initializer', pretty_print=pretty_print) + if self.briefdescription is not None: + namespaceprefix_ = self.briefdescription_nsprefix_ + ':' if (UseCapturedNS_ and self.briefdescription_nsprefix_) else '' + self.briefdescription.export(outfile, level, namespaceprefix_, namespacedef_='', name_='briefdescription', pretty_print=pretty_print) + if self.detaileddescription is not None: + namespaceprefix_ = self.detaileddescription_nsprefix_ + ':' if (UseCapturedNS_ and self.detaileddescription_nsprefix_) else '' + self.detaileddescription.export(outfile, level, namespaceprefix_, namespacedef_='', name_='detaileddescription', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + self.valueOf_ = get_all_text_(node) + if node.text is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', node.text) + self.content_.append(obj_) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('id', node) + if value is not None and 'id' not in already_processed: + already_processed.add('id') + self.id = value + value = find_attr_value_('prot', node) + if value is not None and 'prot' not in already_processed: + already_processed.add('prot') + self.prot = value + self.validate_DoxProtectionKind(self.prot) # validate type DoxProtectionKind + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'name' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'name') + valuestr_ = self.gds_validate_string(valuestr_, node, 'name') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'name', valuestr_) + self.content_.append(obj_) + self.name_nsprefix_ = child_.prefix + elif nodeName_ == 'initializer': + obj_ = linkedTextType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'initializer', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_initializer'): + self.add_initializer(obj_.value) + elif hasattr(self, 'set_initializer'): + self.set_initializer(obj_.value) + elif nodeName_ == 'briefdescription': + obj_ = descriptionType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'briefdescription', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_briefdescription'): + self.add_briefdescription(obj_.value) + elif hasattr(self, 'set_briefdescription'): + self.set_briefdescription(obj_.value) + elif nodeName_ == 'detaileddescription': + obj_ = descriptionType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'detaileddescription', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_detaileddescription'): + self.add_detaileddescription(obj_.value) + elif hasattr(self, 'set_detaileddescription'): + self.set_detaileddescription(obj_.value) + if not fromsubclass_ and child_.tail is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.tail) + self.content_.append(obj_) +# end class enumvalueType + + +class templateparamlistType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, param=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + if param is None: + self.param = [] + else: + self.param = param + self.param_nsprefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, templateparamlistType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if templateparamlistType.subclass: + return templateparamlistType.subclass(*args_, **kwargs_) + return templateparamlistType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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_at(self, index, value): + self.param.insert(index, value) + def replace_param_at(self, index, value): + self.param[index] = value + def hasContent_(self): + if ( + self.param + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='templateparamlistType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('templateparamlistType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'templateparamlistType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='templateparamlistType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='templateparamlistType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='templateparamlistType'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='templateparamlistType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for param_ in self.param: + namespaceprefix_ = self.param_nsprefix_ + ':' if (UseCapturedNS_ and self.param_nsprefix_) else '' + param_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='param', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'param': + obj_ = paramType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.param.append(obj_) + obj_.original_tagname_ = 'param' +# end class templateparamlistType + + +class paramType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, type_=None, declname=None, defname=None, array=None, defval=None, briefdescription=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.type_ = type_ + self.type__nsprefix_ = None + self.declname = declname + self.declname_nsprefix_ = None + self.defname = defname + self.defname_nsprefix_ = None + self.array = array + self.array_nsprefix_ = None + self.defval = defval + self.defval_nsprefix_ = None + self.briefdescription = briefdescription + self.briefdescription_nsprefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, paramType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if paramType.subclass: + return paramType.subclass(*args_, **kwargs_) + return paramType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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 + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='paramType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('paramType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'paramType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='paramType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='paramType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='paramType'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='paramType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.type_ is not None: + namespaceprefix_ = self.type__nsprefix_ + ':' if (UseCapturedNS_ and self.type__nsprefix_) else '' + self.type_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='type', pretty_print=pretty_print) + if self.declname is not None: + namespaceprefix_ = self.declname_nsprefix_ + ':' if (UseCapturedNS_ and self.declname_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%sdeclname>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.declname), input_name='declname')), namespaceprefix_ , eol_)) + if self.defname is not None: + namespaceprefix_ = self.defname_nsprefix_ + ':' if (UseCapturedNS_ and self.defname_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%sdefname>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.defname), input_name='defname')), namespaceprefix_ , eol_)) + if self.array is not None: + namespaceprefix_ = self.array_nsprefix_ + ':' if (UseCapturedNS_ and self.array_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%sarray>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.array), input_name='array')), namespaceprefix_ , eol_)) + if self.defval is not None: + namespaceprefix_ = self.defval_nsprefix_ + ':' if (UseCapturedNS_ and self.defval_nsprefix_) else '' + self.defval.export(outfile, level, namespaceprefix_, namespacedef_='', name_='defval', pretty_print=pretty_print) + if self.briefdescription is not None: + namespaceprefix_ = self.briefdescription_nsprefix_ + ':' if (UseCapturedNS_ and self.briefdescription_nsprefix_) else '' + self.briefdescription.export(outfile, level, namespaceprefix_, namespacedef_='', name_='briefdescription', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'type': + obj_ = linkedTextType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.type_ = obj_ + obj_.original_tagname_ = 'type' + elif nodeName_ == 'declname': + value_ = child_.text + value_ = self.gds_parse_string(value_, node, 'declname') + value_ = self.gds_validate_string(value_, node, 'declname') + self.declname = value_ + self.declname_nsprefix_ = child_.prefix + elif nodeName_ == 'defname': + value_ = child_.text + value_ = self.gds_parse_string(value_, node, 'defname') + value_ = self.gds_validate_string(value_, node, 'defname') + self.defname = value_ + self.defname_nsprefix_ = child_.prefix + elif nodeName_ == 'array': + value_ = child_.text + value_ = self.gds_parse_string(value_, node, 'array') + value_ = self.gds_validate_string(value_, node, 'array') + self.array = value_ + self.array_nsprefix_ = child_.prefix + elif nodeName_ == 'defval': + obj_ = linkedTextType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.defval = obj_ + obj_.original_tagname_ = 'defval' + elif nodeName_ == 'briefdescription': + obj_ = descriptionType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.briefdescription = obj_ + obj_.original_tagname_ = 'briefdescription' +# end class paramType + + +class declname(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, declname) + if subclass is not None: + return subclass(*args_, **kwargs_) + if declname.subclass: + return declname.subclass(*args_, **kwargs_) + return declname(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + def hasContent_(self): + if ( + + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='declname', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('declname') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'declname': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='declname') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='declname', pretty_print=pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='declname'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='declname', fromsubclass_=False, pretty_print=True): + pass + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + pass +# end class declname + + +class defname(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, defname) + if subclass is not None: + return subclass(*args_, **kwargs_) + if defname.subclass: + return defname.subclass(*args_, **kwargs_) + return defname(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + def hasContent_(self): + if ( + + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='defname', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('defname') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'defname': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='defname') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='defname', pretty_print=pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='defname'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='defname', fromsubclass_=False, pretty_print=True): + pass + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + pass +# end class defname + + +class array(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, array) + if subclass is not None: + return subclass(*args_, **kwargs_) + if array.subclass: + return array.subclass(*args_, **kwargs_) + return array(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + def hasContent_(self): + if ( + + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='array', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('array') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'array': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='array') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='array', pretty_print=pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='array'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='array', fromsubclass_=False, pretty_print=True): + pass + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + pass +# end class array + + +class linkedTextType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, ref=None, valueOf_=None, mixedclass_=None, content_=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + if ref is None: + self.ref = [] + else: + self.ref = ref + self.ref_nsprefix_ = None + self.valueOf_ = valueOf_ + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + self.valueOf_ = valueOf_ + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, linkedTextType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if linkedTextType.subclass: + return linkedTextType.subclass(*args_, **kwargs_) + return linkedTextType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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_at(self, index, value): + self.ref.insert(index, value) + def replace_ref_at(self, index, value): + self.ref[index] = value + def get_valueOf_(self): return self.valueOf_ + def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def hasContent_(self): + if ( + self.ref or + (1 if type(self.valueOf_) in [int,float] else self.valueOf_) or + self.content_ + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='linkedTextType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('linkedTextType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'linkedTextType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='linkedTextType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='linkedTextType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='linkedTextType'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='linkedTextType', fromsubclass_=False, pretty_print=True): + if not fromsubclass_: + for item_ in self.content_: + item_.export(outfile, level, item_.name, namespaceprefix_, pretty_print=pretty_print) + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for ref_ in self.ref: + namespaceprefix_ = self.ref_nsprefix_ + ':' if (UseCapturedNS_ and self.ref_nsprefix_) else '' + ref_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ref', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + self.valueOf_ = get_all_text_(node) + if node.text is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', node.text) + self.content_.append(obj_) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'ref': + obj_ = refTextType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ref', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ref'): + self.add_ref(obj_.value) + elif hasattr(self, 'set_ref'): + self.set_ref(obj_.value) + if not fromsubclass_ and child_.tail is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.tail) + self.content_.append(obj_) +# end class linkedTextType + + +class graphType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, node=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + if node is None: + self.node = [] + else: + self.node = node + self.node_nsprefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, graphType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if graphType.subclass: + return graphType.subclass(*args_, **kwargs_) + return graphType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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_at(self, index, value): + self.node.insert(index, value) + def replace_node_at(self, index, value): + self.node[index] = value + def hasContent_(self): + if ( + self.node + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='graphType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('graphType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'graphType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='graphType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='graphType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='graphType'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='graphType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for node_ in self.node: + namespaceprefix_ = self.node_nsprefix_ + ':' if (UseCapturedNS_ and self.node_nsprefix_) else '' + node_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='node', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'node': + obj_ = nodeType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.node.append(obj_) + obj_.original_tagname_ = 'node' +# end class graphType + + +class nodeType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, id=None, label=None, link=None, childnode=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.id = _cast(None, id) + self.id_nsprefix_ = None + self.label = label + self.label_nsprefix_ = None + self.link = link + self.link_nsprefix_ = None + if childnode is None: + self.childnode = [] + else: + self.childnode = childnode + self.childnode_nsprefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, nodeType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if nodeType.subclass: + return nodeType.subclass(*args_, **kwargs_) + return nodeType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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_at(self, index, value): + self.childnode.insert(index, value) + def replace_childnode_at(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 + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='nodeType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('nodeType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'nodeType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='nodeType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='nodeType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='nodeType'): + if self.id is not None and 'id' not in already_processed: + already_processed.add('id') + outfile.write(' id=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.id), input_name='id')), )) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='nodeType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.label is not None: + namespaceprefix_ = self.label_nsprefix_ + ':' if (UseCapturedNS_ and self.label_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%slabel>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.label), input_name='label')), namespaceprefix_ , eol_)) + if self.link is not None: + namespaceprefix_ = self.link_nsprefix_ + ':' if (UseCapturedNS_ and self.link_nsprefix_) else '' + self.link.export(outfile, level, namespaceprefix_, namespacedef_='', name_='link', pretty_print=pretty_print) + for childnode_ in self.childnode: + namespaceprefix_ = self.childnode_nsprefix_ + ':' if (UseCapturedNS_ and self.childnode_nsprefix_) else '' + childnode_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='childnode', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('id', node) + if value is not None and 'id' not in already_processed: + already_processed.add('id') + self.id = value + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'label': + value_ = child_.text + value_ = self.gds_parse_string(value_, node, 'label') + value_ = self.gds_validate_string(value_, node, 'label') + self.label = value_ + self.label_nsprefix_ = child_.prefix + elif nodeName_ == 'link': + obj_ = linkType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.link = obj_ + obj_.original_tagname_ = 'link' + elif nodeName_ == 'childnode': + obj_ = childnodeType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.childnode.append(obj_) + obj_.original_tagname_ = 'childnode' +# end class nodeType + + +class label(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, label) + if subclass is not None: + return subclass(*args_, **kwargs_) + if label.subclass: + return label.subclass(*args_, **kwargs_) + return label(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + def hasContent_(self): + if ( + + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='label', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('label') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'label': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='label') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='label', pretty_print=pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='label'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='label', fromsubclass_=False, pretty_print=True): + pass + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + pass +# end class label + + +class childnodeType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, refid=None, relation=None, edgelabel=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.refid = _cast(None, refid) + self.refid_nsprefix_ = None + self.relation = _cast(None, relation) + self.relation_nsprefix_ = None + if edgelabel is None: + self.edgelabel = [] + else: + self.edgelabel = edgelabel + self.edgelabel_nsprefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, childnodeType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if childnodeType.subclass: + return childnodeType.subclass(*args_, **kwargs_) + return childnodeType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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_at(self, index, value): + self.edgelabel.insert(index, value) + def replace_edgelabel_at(self, index, value): + self.edgelabel[index] = value + def get_refid(self): + return self.refid + def set_refid(self, refid): + self.refid = refid + def get_relation(self): + return self.relation + def set_relation(self, relation): + self.relation = relation + def validate_DoxGraphRelation(self, value): + # Validate type DoxGraphRelation, a restriction on xsd:string. + if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) + return False + value = value + enumerations = ['include', 'usage', 'template-instance', 'public-inheritance', 'protected-inheritance', 'private-inheritance'] + if value not in enumerations: + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on DoxGraphRelation' % {"value" : encode_str_2_3(value), "lineno": lineno} ) + result = False + def hasContent_(self): + if ( + self.edgelabel + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='childnodeType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('childnodeType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'childnodeType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='childnodeType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='childnodeType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='childnodeType'): + if self.refid is not None and 'refid' not in already_processed: + already_processed.add('refid') + outfile.write(' refid=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.refid), input_name='refid')), )) + if self.relation is not None and 'relation' not in already_processed: + already_processed.add('relation') + outfile.write(' relation=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.relation), input_name='relation')), )) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='childnodeType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for edgelabel_ in self.edgelabel: + namespaceprefix_ = self.edgelabel_nsprefix_ + ':' if (UseCapturedNS_ and self.edgelabel_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%sedgelabel>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(edgelabel_), input_name='edgelabel')), namespaceprefix_ , eol_)) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('refid', node) + if value is not None and 'refid' not in already_processed: + already_processed.add('refid') + self.refid = value + value = find_attr_value_('relation', node) + if value is not None and 'relation' not in already_processed: + already_processed.add('relation') + self.relation = value + self.validate_DoxGraphRelation(self.relation) # validate type DoxGraphRelation + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'edgelabel': + value_ = child_.text + value_ = self.gds_parse_string(value_, node, 'edgelabel') + value_ = self.gds_validate_string(value_, node, 'edgelabel') + self.edgelabel.append(value_) + self.edgelabel_nsprefix_ = child_.prefix +# end class childnodeType + + +class edgelabel(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, edgelabel) + if subclass is not None: + return subclass(*args_, **kwargs_) + if edgelabel.subclass: + return edgelabel.subclass(*args_, **kwargs_) + return edgelabel(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + def hasContent_(self): + if ( + + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='edgelabel', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('edgelabel') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'edgelabel': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='edgelabel') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='edgelabel', pretty_print=pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='edgelabel'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='edgelabel', fromsubclass_=False, pretty_print=True): + pass + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + pass +# end class edgelabel + + +class linkType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, refid=None, external=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.refid = _cast(None, refid) + self.refid_nsprefix_ = None + self.external = _cast(None, external) + self.external_nsprefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, linkType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if linkType.subclass: + return linkType.subclass(*args_, **kwargs_) + return linkType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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 hasContent_(self): + if ( + + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='linkType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('linkType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'linkType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='linkType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='linkType', pretty_print=pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='linkType'): + if self.refid is not None and 'refid' not in already_processed: + already_processed.add('refid') + outfile.write(' refid=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.refid), input_name='refid')), )) + if self.external is not None and 'external' not in already_processed: + already_processed.add('external') + outfile.write(' external=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.external), input_name='external')), )) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='linkType', fromsubclass_=False, pretty_print=True): + pass + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('refid', node) + if value is not None and 'refid' not in already_processed: + already_processed.add('refid') + self.refid = value + value = find_attr_value_('external', node) + if value is not None and 'external' not in already_processed: + already_processed.add('external') + self.external = value + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + pass +# end class linkType + + +class listingType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, codeline=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + if codeline is None: + self.codeline = [] + else: + self.codeline = codeline + self.codeline_nsprefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, listingType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if listingType.subclass: + return listingType.subclass(*args_, **kwargs_) + return listingType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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_at(self, index, value): + self.codeline.insert(index, value) + def replace_codeline_at(self, index, value): + self.codeline[index] = value + def hasContent_(self): + if ( + self.codeline + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='listingType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('listingType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'listingType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='listingType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='listingType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='listingType'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='listingType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for codeline_ in self.codeline: + namespaceprefix_ = self.codeline_nsprefix_ + ':' if (UseCapturedNS_ and self.codeline_nsprefix_) else '' + codeline_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='codeline', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'codeline': + obj_ = codelineType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.codeline.append(obj_) + obj_.original_tagname_ = 'codeline' +# end class listingType + + +class codelineType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, lineno=None, refid=None, refkind=None, external=None, highlight=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.lineno = _cast(int, lineno) + self.lineno_nsprefix_ = None + self.refid = _cast(None, refid) + self.refid_nsprefix_ = None + self.refkind = _cast(None, refkind) + self.refkind_nsprefix_ = None + self.external = _cast(None, external) + self.external_nsprefix_ = None + if highlight is None: + self.highlight = [] + else: + self.highlight = highlight + self.highlight_nsprefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, codelineType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if codelineType.subclass: + return codelineType.subclass(*args_, **kwargs_) + return codelineType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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_at(self, index, value): + self.highlight.insert(index, value) + def replace_highlight_at(self, index, value): + self.highlight[index] = value + def get_lineno(self): + return self.lineno + def set_lineno(self, lineno): + self.lineno = lineno + def get_refid(self): + return self.refid + def set_refid(self, refid): + self.refid = refid + def get_refkind(self): + return self.refkind + def set_refkind(self, refkind): + self.refkind = refkind + def get_external(self): + return self.external + def set_external(self, external): + self.external = external + def validate_DoxRefKind(self, value): + # Validate type DoxRefKind, a restriction on xsd:string. + if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) + return False + value = value + enumerations = ['compound', 'member'] + if value not in enumerations: + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on DoxRefKind' % {"value" : encode_str_2_3(value), "lineno": lineno} ) + result = False + def validate_DoxBool(self, value): + # Validate type DoxBool, a restriction on xsd:string. + if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) + return False + value = value + enumerations = ['yes', 'no'] + if value not in enumerations: + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on DoxBool' % {"value" : encode_str_2_3(value), "lineno": lineno} ) + result = False + def hasContent_(self): + if ( + self.highlight + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='codelineType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('codelineType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'codelineType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='codelineType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='codelineType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='codelineType'): + if self.lineno is not None and 'lineno' not in already_processed: + already_processed.add('lineno') + outfile.write(' lineno="%s"' % self.gds_format_integer(self.lineno, input_name='lineno')) + if self.refid is not None and 'refid' not in already_processed: + already_processed.add('refid') + outfile.write(' refid=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.refid), input_name='refid')), )) + if self.refkind is not None and 'refkind' not in already_processed: + already_processed.add('refkind') + outfile.write(' refkind=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.refkind), input_name='refkind')), )) + if self.external is not None and 'external' not in already_processed: + already_processed.add('external') + outfile.write(' external=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.external), input_name='external')), )) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='codelineType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for highlight_ in self.highlight: + namespaceprefix_ = self.highlight_nsprefix_ + ':' if (UseCapturedNS_ and self.highlight_nsprefix_) else '' + highlight_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='highlight', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('lineno', node) + if value is not None and 'lineno' not in already_processed: + already_processed.add('lineno') + self.lineno = self.gds_parse_integer(value, node, 'lineno') + value = find_attr_value_('refid', node) + if value is not None and 'refid' not in already_processed: + already_processed.add('refid') + self.refid = value + value = find_attr_value_('refkind', node) + if value is not None and 'refkind' not in already_processed: + already_processed.add('refkind') + self.refkind = value + self.validate_DoxRefKind(self.refkind) # validate type DoxRefKind + value = find_attr_value_('external', node) + if value is not None and 'external' not in already_processed: + already_processed.add('external') + self.external = value + self.validate_DoxBool(self.external) # validate type DoxBool + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'highlight': + obj_ = highlightType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.highlight.append(obj_) + obj_.original_tagname_ = 'highlight' +# end class codelineType + + +class highlightType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, class_=None, sp=None, ref=None, valueOf_=None, mixedclass_=None, content_=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.class_ = _cast(None, class_) + self.class__nsprefix_ = None + if sp is None: + self.sp = [] + else: + self.sp = sp + self.sp_nsprefix_ = None + if ref is None: + self.ref = [] + else: + self.ref = ref + self.ref_nsprefix_ = None + self.valueOf_ = valueOf_ + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + self.valueOf_ = valueOf_ + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, highlightType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if highlightType.subclass: + return highlightType.subclass(*args_, **kwargs_) + return highlightType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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_at(self, index, value): + self.sp.insert(index, value) + def replace_sp_at(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_at(self, index, value): + self.ref.insert(index, value) + def replace_ref_at(self, index, value): + self.ref[index] = value + def get_class(self): + return self.class_ + def set_class(self, class_): + self.class_ = class_ + def get_valueOf_(self): return self.valueOf_ + def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def validate_DoxHighlightClass(self, value): + # Validate type DoxHighlightClass, a restriction on xsd:string. + if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) + return False + value = value + enumerations = ['comment', 'normal', 'preprocessor', 'keyword', 'keywordtype', 'keywordflow', 'stringliteral', 'charliteral'] + if value not in enumerations: + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on DoxHighlightClass' % {"value" : encode_str_2_3(value), "lineno": lineno} ) + result = False + def hasContent_(self): + if ( + self.sp or + self.ref or + (1 if type(self.valueOf_) in [int,float] else self.valueOf_) or + self.content_ + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='highlightType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('highlightType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'highlightType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='highlightType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='highlightType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='highlightType'): + if self.class_ is not None and 'class_' not in already_processed: + already_processed.add('class_') + outfile.write(' class=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.class_), input_name='class')), )) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='highlightType', fromsubclass_=False, pretty_print=True): + if not fromsubclass_: + for item_ in self.content_: + item_.export(outfile, level, item_.name, namespaceprefix_, pretty_print=pretty_print) + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for sp_ in self.sp: + namespaceprefix_ = self.sp_nsprefix_ + ':' if (UseCapturedNS_ and self.sp_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%ssp>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(sp_), input_name='sp')), namespaceprefix_ , eol_)) + for ref_ in self.ref: + namespaceprefix_ = self.ref_nsprefix_ + ':' if (UseCapturedNS_ and self.ref_nsprefix_) else '' + ref_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ref', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + self.valueOf_ = get_all_text_(node) + if node.text is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', node.text) + self.content_.append(obj_) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('class', node) + if value is not None and 'class' not in already_processed: + already_processed.add('class') + self.class_ = value + self.validate_DoxHighlightClass(self.class_) # validate type DoxHighlightClass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'sp' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'sp') + valuestr_ = self.gds_validate_string(valuestr_, node, 'sp') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'sp', valuestr_) + self.content_.append(obj_) + self.sp_nsprefix_ = child_.prefix + elif nodeName_ == 'ref': + obj_ = refTextType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ref', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ref'): + self.add_ref(obj_.value) + elif hasattr(self, 'set_ref'): + self.set_ref(obj_.value) + if not fromsubclass_ and child_.tail is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.tail) + self.content_.append(obj_) +# end class highlightType + + +class sp(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, sp) + if subclass is not None: + return subclass(*args_, **kwargs_) + if sp.subclass: + return sp.subclass(*args_, **kwargs_) + return sp(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + def hasContent_(self): + if ( + + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='sp', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('sp') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'sp': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='sp') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='sp', pretty_print=pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='sp'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='sp', fromsubclass_=False, pretty_print=True): + pass + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + pass +# end class sp + + +class referenceType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, refid=None, compoundref=None, startline=None, endline=None, valueOf_=None, mixedclass_=None, content_=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.refid = _cast(None, refid) + self.refid_nsprefix_ = None + self.compoundref = _cast(None, compoundref) + self.compoundref_nsprefix_ = None + self.startline = _cast(int, startline) + self.startline_nsprefix_ = None + self.endline = _cast(int, endline) + self.endline_nsprefix_ = None + self.valueOf_ = valueOf_ + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + self.valueOf_ = valueOf_ + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, referenceType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if referenceType.subclass: + return referenceType.subclass(*args_, **kwargs_) + return referenceType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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 get_startline(self): + return self.startline + def set_startline(self, startline): + self.startline = startline + def get_endline(self): + return self.endline + def set_endline(self, endline): + self.endline = endline + def get_valueOf_(self): return self.valueOf_ + def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def hasContent_(self): + if ( + (1 if type(self.valueOf_) in [int,float] else self.valueOf_) or + self.content_ + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='referenceType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('referenceType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'referenceType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='referenceType') + outfile.write('>') + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_, pretty_print=pretty_print) + outfile.write(self.convert_unicode(self.valueOf_)) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='referenceType'): + if self.refid is not None and 'refid' not in already_processed: + already_processed.add('refid') + outfile.write(' refid=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.refid), input_name='refid')), )) + if self.compoundref is not None and 'compoundref' not in already_processed: + already_processed.add('compoundref') + outfile.write(' compoundref=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.compoundref), input_name='compoundref')), )) + if self.startline is not None and 'startline' not in already_processed: + already_processed.add('startline') + outfile.write(' startline="%s"' % self.gds_format_integer(self.startline, input_name='startline')) + if self.endline is not None and 'endline' not in already_processed: + already_processed.add('endline') + outfile.write(' endline="%s"' % self.gds_format_integer(self.endline, input_name='endline')) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='referenceType', fromsubclass_=False, pretty_print=True): + pass + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + self.valueOf_ = get_all_text_(node) + if node.text is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', node.text) + self.content_.append(obj_) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('refid', node) + if value is not None and 'refid' not in already_processed: + already_processed.add('refid') + self.refid = value + value = find_attr_value_('compoundref', node) + if value is not None and 'compoundref' not in already_processed: + already_processed.add('compoundref') + self.compoundref = value + value = find_attr_value_('startline', node) + if value is not None and 'startline' not in already_processed: + already_processed.add('startline') + self.startline = self.gds_parse_integer(value, node, 'startline') + value = find_attr_value_('endline', node) + if value is not None and 'endline' not in already_processed: + already_processed.add('endline') + self.endline = self.gds_parse_integer(value, node, 'endline') + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if not fromsubclass_ and child_.tail is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.tail) + self.content_.append(obj_) + pass +# end class referenceType + + +class locationType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, file=None, line=None, column=None, bodyfile=None, bodystart=None, bodyend=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.file = _cast(None, file) + self.file_nsprefix_ = None + self.line = _cast(int, line) + self.line_nsprefix_ = None + self.column = _cast(int, column) + self.column_nsprefix_ = None + self.bodyfile = _cast(None, bodyfile) + self.bodyfile_nsprefix_ = None + self.bodystart = _cast(int, bodystart) + self.bodystart_nsprefix_ = None + self.bodyend = _cast(int, bodyend) + self.bodyend_nsprefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, locationType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if locationType.subclass: + return locationType.subclass(*args_, **kwargs_) + return locationType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + def get_file(self): + return self.file + def set_file(self, file): + self.file = file + def get_line(self): + return self.line + def set_line(self, line): + self.line = line + def get_column(self): + return self.column + def set_column(self, column): + self.column = column + def get_bodyfile(self): + return self.bodyfile + def set_bodyfile(self, bodyfile): + self.bodyfile = bodyfile + def get_bodystart(self): + return self.bodystart + def set_bodystart(self, bodystart): + self.bodystart = bodystart + def get_bodyend(self): + return self.bodyend + def set_bodyend(self, bodyend): + self.bodyend = bodyend + def hasContent_(self): + if ( + + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='locationType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('locationType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'locationType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='locationType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='locationType', pretty_print=pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='locationType'): + if self.file is not None and 'file' not in already_processed: + already_processed.add('file') + outfile.write(' file=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.file), input_name='file')), )) + if self.line is not None and 'line' not in already_processed: + already_processed.add('line') + outfile.write(' line="%s"' % self.gds_format_integer(self.line, input_name='line')) + if self.column is not None and 'column' not in already_processed: + already_processed.add('column') + outfile.write(' column="%s"' % self.gds_format_integer(self.column, input_name='column')) + if self.bodyfile is not None and 'bodyfile' not in already_processed: + already_processed.add('bodyfile') + outfile.write(' bodyfile=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.bodyfile), input_name='bodyfile')), )) + if self.bodystart is not None and 'bodystart' not in already_processed: + already_processed.add('bodystart') + outfile.write(' bodystart="%s"' % self.gds_format_integer(self.bodystart, input_name='bodystart')) + if self.bodyend is not None and 'bodyend' not in already_processed: + already_processed.add('bodyend') + outfile.write(' bodyend="%s"' % self.gds_format_integer(self.bodyend, input_name='bodyend')) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='locationType', fromsubclass_=False, pretty_print=True): + pass + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('file', node) + if value is not None and 'file' not in already_processed: + already_processed.add('file') + self.file = value + value = find_attr_value_('line', node) + if value is not None and 'line' not in already_processed: + already_processed.add('line') + self.line = self.gds_parse_integer(value, node, 'line') + value = find_attr_value_('column', node) + if value is not None and 'column' not in already_processed: + already_processed.add('column') + self.column = self.gds_parse_integer(value, node, 'column') + value = find_attr_value_('bodyfile', node) + if value is not None and 'bodyfile' not in already_processed: + already_processed.add('bodyfile') + self.bodyfile = value + value = find_attr_value_('bodystart', node) + if value is not None and 'bodystart' not in already_processed: + already_processed.add('bodystart') + self.bodystart = self.gds_parse_integer(value, node, 'bodystart') + value = find_attr_value_('bodyend', node) + if value is not None and 'bodyend' not in already_processed: + already_processed.add('bodyend') + self.bodyend = self.gds_parse_integer(value, node, 'bodyend') + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + pass +# end class locationType + + +class docSect1Type(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, id=None, title=None, para=None, sect2=None, internal=None, valueOf_=None, mixedclass_=None, content_=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.id = _cast(None, id) + self.id_nsprefix_ = None + self.title = title + self.title_nsprefix_ = None + if para is None: + self.para = [] + else: + self.para = para + self.para_nsprefix_ = None + if sect2 is None: + self.sect2 = [] + else: + self.sect2 = sect2 + self.sect2_nsprefix_ = None + self.internal = internal + self.internal_nsprefix_ = None + self.valueOf_ = valueOf_ + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + self.valueOf_ = valueOf_ + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docSect1Type) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docSect1Type.subclass: + return docSect1Type.subclass(*args_, **kwargs_) + return docSect1Type(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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_at(self, index, value): + self.para.insert(index, value) + def replace_para_at(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_at(self, index, value): + self.sect2.insert(index, value) + def replace_sect2_at(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 get_valueOf_(self): return self.valueOf_ + def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def hasContent_(self): + if ( + self.title is not None or + self.para or + self.sect2 or + self.internal is not None or + (1 if type(self.valueOf_) in [int,float] else self.valueOf_) or + self.content_ + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docSect1Type', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docSect1Type') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docSect1Type': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docSect1Type') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docSect1Type', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docSect1Type'): + if self.id is not None and 'id' not in already_processed: + already_processed.add('id') + outfile.write(' id=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.id), input_name='id')), )) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docSect1Type', fromsubclass_=False, pretty_print=True): + if not fromsubclass_: + for item_ in self.content_: + item_.export(outfile, level, item_.name, namespaceprefix_, pretty_print=pretty_print) + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.title is not None: + namespaceprefix_ = self.title_nsprefix_ + ':' if (UseCapturedNS_ and self.title_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%stitle>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.title), input_name='title')), namespaceprefix_ , eol_)) + for para_ in self.para: + namespaceprefix_ = self.para_nsprefix_ + ':' if (UseCapturedNS_ and self.para_nsprefix_) else '' + para_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='para', pretty_print=pretty_print) + for sect2_ in self.sect2: + namespaceprefix_ = self.sect2_nsprefix_ + ':' if (UseCapturedNS_ and self.sect2_nsprefix_) else '' + sect2_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sect2', pretty_print=pretty_print) + if self.internal is not None: + namespaceprefix_ = self.internal_nsprefix_ + ':' if (UseCapturedNS_ and self.internal_nsprefix_) else '' + self.internal.export(outfile, level, namespaceprefix_, namespacedef_='', name_='internal', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + self.valueOf_ = get_all_text_(node) + if node.text is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', node.text) + self.content_.append(obj_) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('id', node) + if value is not None and 'id' not in already_processed: + already_processed.add('id') + self.id = value + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'title' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'title') + valuestr_ = self.gds_validate_string(valuestr_, node, 'title') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'title', valuestr_) + self.content_.append(obj_) + self.title_nsprefix_ = child_.prefix + elif nodeName_ == 'para': + obj_ = docParaType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'para', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_para'): + self.add_para(obj_.value) + elif hasattr(self, 'set_para'): + self.set_para(obj_.value) + elif nodeName_ == 'sect2': + obj_ = docSect2Type.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sect2', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sect2'): + self.add_sect2(obj_.value) + elif hasattr(self, 'set_sect2'): + self.set_sect2(obj_.value) + elif nodeName_ == 'internal': + obj_ = docInternalS1Type.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'internal', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_internal'): + self.add_internal(obj_.value) + elif hasattr(self, 'set_internal'): + self.set_internal(obj_.value) + if not fromsubclass_ and child_.tail is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.tail) + self.content_.append(obj_) +# end class docSect1Type + + +class docSect2Type(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, id=None, title=None, para=None, sect3=None, internal=None, valueOf_=None, mixedclass_=None, content_=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.id = _cast(None, id) + self.id_nsprefix_ = None + self.title = title + self.title_nsprefix_ = None + if para is None: + self.para = [] + else: + self.para = para + self.para_nsprefix_ = None + if sect3 is None: + self.sect3 = [] + else: + self.sect3 = sect3 + self.sect3_nsprefix_ = None + self.internal = internal + self.internal_nsprefix_ = None + self.valueOf_ = valueOf_ + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + self.valueOf_ = valueOf_ + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docSect2Type) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docSect2Type.subclass: + return docSect2Type.subclass(*args_, **kwargs_) + return docSect2Type(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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_at(self, index, value): + self.para.insert(index, value) + def replace_para_at(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_at(self, index, value): + self.sect3.insert(index, value) + def replace_sect3_at(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 get_valueOf_(self): return self.valueOf_ + def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def hasContent_(self): + if ( + self.title is not None or + self.para or + self.sect3 or + self.internal is not None or + (1 if type(self.valueOf_) in [int,float] else self.valueOf_) or + self.content_ + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docSect2Type', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docSect2Type') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docSect2Type': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docSect2Type') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docSect2Type', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docSect2Type'): + if self.id is not None and 'id' not in already_processed: + already_processed.add('id') + outfile.write(' id=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.id), input_name='id')), )) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docSect2Type', fromsubclass_=False, pretty_print=True): + if not fromsubclass_: + for item_ in self.content_: + item_.export(outfile, level, item_.name, namespaceprefix_, pretty_print=pretty_print) + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.title is not None: + namespaceprefix_ = self.title_nsprefix_ + ':' if (UseCapturedNS_ and self.title_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%stitle>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.title), input_name='title')), namespaceprefix_ , eol_)) + for para_ in self.para: + namespaceprefix_ = self.para_nsprefix_ + ':' if (UseCapturedNS_ and self.para_nsprefix_) else '' + para_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='para', pretty_print=pretty_print) + for sect3_ in self.sect3: + namespaceprefix_ = self.sect3_nsprefix_ + ':' if (UseCapturedNS_ and self.sect3_nsprefix_) else '' + sect3_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sect3', pretty_print=pretty_print) + if self.internal is not None: + namespaceprefix_ = self.internal_nsprefix_ + ':' if (UseCapturedNS_ and self.internal_nsprefix_) else '' + self.internal.export(outfile, level, namespaceprefix_, namespacedef_='', name_='internal', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + self.valueOf_ = get_all_text_(node) + if node.text is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', node.text) + self.content_.append(obj_) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('id', node) + if value is not None and 'id' not in already_processed: + already_processed.add('id') + self.id = value + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'title' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'title') + valuestr_ = self.gds_validate_string(valuestr_, node, 'title') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'title', valuestr_) + self.content_.append(obj_) + self.title_nsprefix_ = child_.prefix + elif nodeName_ == 'para': + obj_ = docParaType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'para', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_para'): + self.add_para(obj_.value) + elif hasattr(self, 'set_para'): + self.set_para(obj_.value) + elif nodeName_ == 'sect3': + obj_ = docSect3Type.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sect3', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sect3'): + self.add_sect3(obj_.value) + elif hasattr(self, 'set_sect3'): + self.set_sect3(obj_.value) + elif nodeName_ == 'internal': + obj_ = docInternalS2Type.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'internal', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_internal'): + self.add_internal(obj_.value) + elif hasattr(self, 'set_internal'): + self.set_internal(obj_.value) + if not fromsubclass_ and child_.tail is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.tail) + self.content_.append(obj_) +# end class docSect2Type + + +class docSect3Type(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, id=None, title=None, para=None, sect4=None, internal=None, valueOf_=None, mixedclass_=None, content_=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.id = _cast(None, id) + self.id_nsprefix_ = None + self.title = title + self.title_nsprefix_ = None + if para is None: + self.para = [] + else: + self.para = para + self.para_nsprefix_ = None + if sect4 is None: + self.sect4 = [] + else: + self.sect4 = sect4 + self.sect4_nsprefix_ = None + self.internal = internal + self.internal_nsprefix_ = None + self.valueOf_ = valueOf_ + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + self.valueOf_ = valueOf_ + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docSect3Type) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docSect3Type.subclass: + return docSect3Type.subclass(*args_, **kwargs_) + return docSect3Type(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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_at(self, index, value): + self.para.insert(index, value) + def replace_para_at(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_at(self, index, value): + self.sect4.insert(index, value) + def replace_sect4_at(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 get_valueOf_(self): return self.valueOf_ + def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def hasContent_(self): + if ( + self.title is not None or + self.para or + self.sect4 or + self.internal is not None or + (1 if type(self.valueOf_) in [int,float] else self.valueOf_) or + self.content_ + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docSect3Type', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docSect3Type') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docSect3Type': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docSect3Type') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docSect3Type', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docSect3Type'): + if self.id is not None and 'id' not in already_processed: + already_processed.add('id') + outfile.write(' id=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.id), input_name='id')), )) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docSect3Type', fromsubclass_=False, pretty_print=True): + if not fromsubclass_: + for item_ in self.content_: + item_.export(outfile, level, item_.name, namespaceprefix_, pretty_print=pretty_print) + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.title is not None: + namespaceprefix_ = self.title_nsprefix_ + ':' if (UseCapturedNS_ and self.title_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%stitle>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.title), input_name='title')), namespaceprefix_ , eol_)) + for para_ in self.para: + namespaceprefix_ = self.para_nsprefix_ + ':' if (UseCapturedNS_ and self.para_nsprefix_) else '' + para_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='para', pretty_print=pretty_print) + for sect4_ in self.sect4: + namespaceprefix_ = self.sect4_nsprefix_ + ':' if (UseCapturedNS_ and self.sect4_nsprefix_) else '' + sect4_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sect4', pretty_print=pretty_print) + if self.internal is not None: + namespaceprefix_ = self.internal_nsprefix_ + ':' if (UseCapturedNS_ and self.internal_nsprefix_) else '' + self.internal.export(outfile, level, namespaceprefix_, namespacedef_='', name_='internal', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + self.valueOf_ = get_all_text_(node) + if node.text is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', node.text) + self.content_.append(obj_) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('id', node) + if value is not None and 'id' not in already_processed: + already_processed.add('id') + self.id = value + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'title' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'title') + valuestr_ = self.gds_validate_string(valuestr_, node, 'title') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'title', valuestr_) + self.content_.append(obj_) + self.title_nsprefix_ = child_.prefix + elif nodeName_ == 'para': + obj_ = docParaType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'para', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_para'): + self.add_para(obj_.value) + elif hasattr(self, 'set_para'): + self.set_para(obj_.value) + elif nodeName_ == 'sect4': + obj_ = docSect4Type.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sect4', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sect4'): + self.add_sect4(obj_.value) + elif hasattr(self, 'set_sect4'): + self.set_sect4(obj_.value) + elif nodeName_ == 'internal': + obj_ = docInternalS3Type.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'internal', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_internal'): + self.add_internal(obj_.value) + elif hasattr(self, 'set_internal'): + self.set_internal(obj_.value) + if not fromsubclass_ and child_.tail is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.tail) + self.content_.append(obj_) +# end class docSect3Type + + +class docSect4Type(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, id=None, title=None, para=None, internal=None, valueOf_=None, mixedclass_=None, content_=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.id = _cast(None, id) + self.id_nsprefix_ = None + self.title = title + self.title_nsprefix_ = None + if para is None: + self.para = [] + else: + self.para = para + self.para_nsprefix_ = None + self.internal = internal + self.internal_nsprefix_ = None + self.valueOf_ = valueOf_ + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + self.valueOf_ = valueOf_ + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docSect4Type) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docSect4Type.subclass: + return docSect4Type.subclass(*args_, **kwargs_) + return docSect4Type(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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_at(self, index, value): + self.para.insert(index, value) + def replace_para_at(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 get_valueOf_(self): return self.valueOf_ + def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def hasContent_(self): + if ( + self.title is not None or + self.para or + self.internal is not None or + (1 if type(self.valueOf_) in [int,float] else self.valueOf_) or + self.content_ + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docSect4Type', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docSect4Type') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docSect4Type': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docSect4Type') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docSect4Type', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docSect4Type'): + if self.id is not None and 'id' not in already_processed: + already_processed.add('id') + outfile.write(' id=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.id), input_name='id')), )) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docSect4Type', fromsubclass_=False, pretty_print=True): + if not fromsubclass_: + for item_ in self.content_: + item_.export(outfile, level, item_.name, namespaceprefix_, pretty_print=pretty_print) + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.title is not None: + namespaceprefix_ = self.title_nsprefix_ + ':' if (UseCapturedNS_ and self.title_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%stitle>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.title), input_name='title')), namespaceprefix_ , eol_)) + for para_ in self.para: + namespaceprefix_ = self.para_nsprefix_ + ':' if (UseCapturedNS_ and self.para_nsprefix_) else '' + para_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='para', pretty_print=pretty_print) + if self.internal is not None: + namespaceprefix_ = self.internal_nsprefix_ + ':' if (UseCapturedNS_ and self.internal_nsprefix_) else '' + self.internal.export(outfile, level, namespaceprefix_, namespacedef_='', name_='internal', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + self.valueOf_ = get_all_text_(node) + if node.text is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', node.text) + self.content_.append(obj_) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('id', node) + if value is not None and 'id' not in already_processed: + already_processed.add('id') + self.id = value + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'title' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'title') + valuestr_ = self.gds_validate_string(valuestr_, node, 'title') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'title', valuestr_) + self.content_.append(obj_) + self.title_nsprefix_ = child_.prefix + elif nodeName_ == 'para': + obj_ = docParaType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'para', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_para'): + self.add_para(obj_.value) + elif hasattr(self, 'set_para'): + self.set_para(obj_.value) + elif nodeName_ == 'internal': + obj_ = docInternalS4Type.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'internal', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_internal'): + self.add_internal(obj_.value) + elif hasattr(self, 'set_internal'): + self.set_internal(obj_.value) + if not fromsubclass_ and child_.tail is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.tail) + self.content_.append(obj_) +# end class docSect4Type + + +class docInternalType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, para=None, sect1=None, valueOf_=None, mixedclass_=None, content_=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + if para is None: + self.para = [] + else: + self.para = para + self.para_nsprefix_ = None + if sect1 is None: + self.sect1 = [] + else: + self.sect1 = sect1 + self.sect1_nsprefix_ = None + self.valueOf_ = valueOf_ + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + self.valueOf_ = valueOf_ + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docInternalType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docInternalType.subclass: + return docInternalType.subclass(*args_, **kwargs_) + return docInternalType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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_at(self, index, value): + self.para.insert(index, value) + def replace_para_at(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_at(self, index, value): + self.sect1.insert(index, value) + def replace_sect1_at(self, index, value): + self.sect1[index] = value + def get_valueOf_(self): return self.valueOf_ + def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def hasContent_(self): + if ( + self.para or + self.sect1 or + (1 if type(self.valueOf_) in [int,float] else self.valueOf_) or + self.content_ + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docInternalType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docInternalType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docInternalType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docInternalType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docInternalType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docInternalType'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docInternalType', fromsubclass_=False, pretty_print=True): + if not fromsubclass_: + for item_ in self.content_: + item_.export(outfile, level, item_.name, namespaceprefix_, pretty_print=pretty_print) + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for para_ in self.para: + namespaceprefix_ = self.para_nsprefix_ + ':' if (UseCapturedNS_ and self.para_nsprefix_) else '' + para_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='para', pretty_print=pretty_print) + for sect1_ in self.sect1: + namespaceprefix_ = self.sect1_nsprefix_ + ':' if (UseCapturedNS_ and self.sect1_nsprefix_) else '' + sect1_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sect1', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + self.valueOf_ = get_all_text_(node) + if node.text is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', node.text) + self.content_.append(obj_) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'para': + obj_ = docParaType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'para', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_para'): + self.add_para(obj_.value) + elif hasattr(self, 'set_para'): + self.set_para(obj_.value) + elif nodeName_ == 'sect1': + obj_ = docSect1Type.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sect1', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sect1'): + self.add_sect1(obj_.value) + elif hasattr(self, 'set_sect1'): + self.set_sect1(obj_.value) + if not fromsubclass_ and child_.tail is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.tail) + self.content_.append(obj_) +# end class docInternalType + + +class docInternalS1Type(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, para=None, sect2=None, valueOf_=None, mixedclass_=None, content_=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + if para is None: + self.para = [] + else: + self.para = para + self.para_nsprefix_ = None + if sect2 is None: + self.sect2 = [] + else: + self.sect2 = sect2 + self.sect2_nsprefix_ = None + self.valueOf_ = valueOf_ + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + self.valueOf_ = valueOf_ + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docInternalS1Type) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docInternalS1Type.subclass: + return docInternalS1Type.subclass(*args_, **kwargs_) + return docInternalS1Type(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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_at(self, index, value): + self.para.insert(index, value) + def replace_para_at(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_at(self, index, value): + self.sect2.insert(index, value) + def replace_sect2_at(self, index, value): + self.sect2[index] = value + def get_valueOf_(self): return self.valueOf_ + def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def hasContent_(self): + if ( + self.para or + self.sect2 or + (1 if type(self.valueOf_) in [int,float] else self.valueOf_) or + self.content_ + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docInternalS1Type', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docInternalS1Type') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docInternalS1Type': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docInternalS1Type') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docInternalS1Type', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docInternalS1Type'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docInternalS1Type', fromsubclass_=False, pretty_print=True): + if not fromsubclass_: + for item_ in self.content_: + item_.export(outfile, level, item_.name, namespaceprefix_, pretty_print=pretty_print) + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for para_ in self.para: + namespaceprefix_ = self.para_nsprefix_ + ':' if (UseCapturedNS_ and self.para_nsprefix_) else '' + para_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='para', pretty_print=pretty_print) + for sect2_ in self.sect2: + namespaceprefix_ = self.sect2_nsprefix_ + ':' if (UseCapturedNS_ and self.sect2_nsprefix_) else '' + sect2_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sect2', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + self.valueOf_ = get_all_text_(node) + if node.text is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', node.text) + self.content_.append(obj_) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'para': + obj_ = docParaType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'para', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_para'): + self.add_para(obj_.value) + elif hasattr(self, 'set_para'): + self.set_para(obj_.value) + elif nodeName_ == 'sect2': + obj_ = docSect2Type.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sect2', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sect2'): + self.add_sect2(obj_.value) + elif hasattr(self, 'set_sect2'): + self.set_sect2(obj_.value) + if not fromsubclass_ and child_.tail is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.tail) + self.content_.append(obj_) +# end class docInternalS1Type + + +class docInternalS2Type(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, para=None, sect3=None, valueOf_=None, mixedclass_=None, content_=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + if para is None: + self.para = [] + else: + self.para = para + self.para_nsprefix_ = None + if sect3 is None: + self.sect3 = [] + else: + self.sect3 = sect3 + self.sect3_nsprefix_ = None + self.valueOf_ = valueOf_ + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + self.valueOf_ = valueOf_ + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docInternalS2Type) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docInternalS2Type.subclass: + return docInternalS2Type.subclass(*args_, **kwargs_) + return docInternalS2Type(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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_at(self, index, value): + self.para.insert(index, value) + def replace_para_at(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_at(self, index, value): + self.sect3.insert(index, value) + def replace_sect3_at(self, index, value): + self.sect3[index] = value + def get_valueOf_(self): return self.valueOf_ + def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def hasContent_(self): + if ( + self.para or + self.sect3 or + (1 if type(self.valueOf_) in [int,float] else self.valueOf_) or + self.content_ + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docInternalS2Type', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docInternalS2Type') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docInternalS2Type': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docInternalS2Type') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docInternalS2Type', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docInternalS2Type'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docInternalS2Type', fromsubclass_=False, pretty_print=True): + if not fromsubclass_: + for item_ in self.content_: + item_.export(outfile, level, item_.name, namespaceprefix_, pretty_print=pretty_print) + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for para_ in self.para: + namespaceprefix_ = self.para_nsprefix_ + ':' if (UseCapturedNS_ and self.para_nsprefix_) else '' + para_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='para', pretty_print=pretty_print) + for sect3_ in self.sect3: + namespaceprefix_ = self.sect3_nsprefix_ + ':' if (UseCapturedNS_ and self.sect3_nsprefix_) else '' + sect3_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sect3', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + self.valueOf_ = get_all_text_(node) + if node.text is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', node.text) + self.content_.append(obj_) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'para': + obj_ = docParaType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'para', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_para'): + self.add_para(obj_.value) + elif hasattr(self, 'set_para'): + self.set_para(obj_.value) + elif nodeName_ == 'sect3': + obj_ = docSect3Type.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sect3', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sect3'): + self.add_sect3(obj_.value) + elif hasattr(self, 'set_sect3'): + self.set_sect3(obj_.value) + if not fromsubclass_ and child_.tail is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.tail) + self.content_.append(obj_) +# end class docInternalS2Type + + +class docInternalS3Type(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, para=None, sect3=None, valueOf_=None, mixedclass_=None, content_=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + if para is None: + self.para = [] + else: + self.para = para + self.para_nsprefix_ = None + if sect3 is None: + self.sect3 = [] + else: + self.sect3 = sect3 + self.sect3_nsprefix_ = None + self.valueOf_ = valueOf_ + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + self.valueOf_ = valueOf_ + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docInternalS3Type) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docInternalS3Type.subclass: + return docInternalS3Type.subclass(*args_, **kwargs_) + return docInternalS3Type(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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_at(self, index, value): + self.para.insert(index, value) + def replace_para_at(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_at(self, index, value): + self.sect3.insert(index, value) + def replace_sect3_at(self, index, value): + self.sect3[index] = value + def get_valueOf_(self): return self.valueOf_ + def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def hasContent_(self): + if ( + self.para or + self.sect3 or + (1 if type(self.valueOf_) in [int,float] else self.valueOf_) or + self.content_ + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docInternalS3Type', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docInternalS3Type') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docInternalS3Type': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docInternalS3Type') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docInternalS3Type', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docInternalS3Type'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docInternalS3Type', fromsubclass_=False, pretty_print=True): + if not fromsubclass_: + for item_ in self.content_: + item_.export(outfile, level, item_.name, namespaceprefix_, pretty_print=pretty_print) + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for para_ in self.para: + namespaceprefix_ = self.para_nsprefix_ + ':' if (UseCapturedNS_ and self.para_nsprefix_) else '' + para_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='para', pretty_print=pretty_print) + for sect3_ in self.sect3: + namespaceprefix_ = self.sect3_nsprefix_ + ':' if (UseCapturedNS_ and self.sect3_nsprefix_) else '' + sect3_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sect3', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + self.valueOf_ = get_all_text_(node) + if node.text is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', node.text) + self.content_.append(obj_) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'para': + obj_ = docParaType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'para', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_para'): + self.add_para(obj_.value) + elif hasattr(self, 'set_para'): + self.set_para(obj_.value) + elif nodeName_ == 'sect3': + obj_ = docSect4Type.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sect3', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sect3'): + self.add_sect3(obj_.value) + elif hasattr(self, 'set_sect3'): + self.set_sect3(obj_.value) + if not fromsubclass_ and child_.tail is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.tail) + self.content_.append(obj_) +# end class docInternalS3Type + + +class docInternalS4Type(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, para=None, valueOf_=None, mixedclass_=None, content_=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + if para is None: + self.para = [] + else: + self.para = para + self.para_nsprefix_ = None + self.valueOf_ = valueOf_ + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + self.valueOf_ = valueOf_ + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docInternalS4Type) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docInternalS4Type.subclass: + return docInternalS4Type.subclass(*args_, **kwargs_) + return docInternalS4Type(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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_at(self, index, value): + self.para.insert(index, value) + def replace_para_at(self, index, value): + self.para[index] = value + def get_valueOf_(self): return self.valueOf_ + def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def hasContent_(self): + if ( + self.para or + (1 if type(self.valueOf_) in [int,float] else self.valueOf_) or + self.content_ + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docInternalS4Type', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docInternalS4Type') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docInternalS4Type': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docInternalS4Type') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docInternalS4Type', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docInternalS4Type'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docInternalS4Type', fromsubclass_=False, pretty_print=True): + if not fromsubclass_: + for item_ in self.content_: + item_.export(outfile, level, item_.name, namespaceprefix_, pretty_print=pretty_print) + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for para_ in self.para: + namespaceprefix_ = self.para_nsprefix_ + ':' if (UseCapturedNS_ and self.para_nsprefix_) else '' + para_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='para', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + self.valueOf_ = get_all_text_(node) + if node.text is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', node.text) + self.content_.append(obj_) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'para': + obj_ = docParaType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'para', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_para'): + self.add_para(obj_.value) + elif hasattr(self, 'set_para'): + self.set_para(obj_.value) + if not fromsubclass_ and child_.tail is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.tail) + self.content_.append(obj_) +# end class docInternalS4Type + + +class docTitleType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, ulink=None, bold=None, emphasis=None, computeroutput=None, subscript=None, superscript=None, center=None, small=None, htmlonly=None, manonly=None, xmlonly=None, rtfonly=None, latexonly=None, dot=None, msc=None, anchor=None, formula=None, ref=None, copy=None, trademark=None, registered=None, lsquo=None, rsquo=None, ldquo=None, rdquo=None, ndash=None, mdash=None, umlaut=None, acute=None, grave=None, circ=None, slash=None, tilde=None, cedil=None, ring=None, szlig=None, nonbreakablespace=None, aelig=None, AElig=None, Gamma=None, Delta=None, Theta=None, Lambda=None, Xi=None, Pi=None, Sigma=None, Upsilon=None, Phi=None, Psi=None, Omega=None, alpha=None, beta=None, gamma=None, delta=None, epsilon=None, zeta=None, eta=None, theta=None, iota=None, kappa=None, lambda_=None, mu=None, nu=None, xi=None, pi=None, rho=None, sigma=None, tau=None, upsilon=None, phi=None, chi=None, psi=None, omega=None, sigmaf=None, sect=None, deg=None, prime=None, Prime=None, infin=None, empty=None, plusmn=None, times=None, minus=None, sdot=None, part=None, nabla=None, radic=None, perp=None, sum=None, int=None, prod=None, sim=None, asymp=None, ne=None, equiv=None, prop=None, le=None, ge=None, larr=None, rarr=None, isin=None, notin=None, lceil=None, rceil=None, lfloor=None, rfloor=None, valueOf_=None, mixedclass_=None, content_=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + if ulink is None: + self.ulink = [] + else: + self.ulink = ulink + self.ulink_nsprefix_ = None + if bold is None: + self.bold = [] + else: + self.bold = bold + self.bold_nsprefix_ = None + if emphasis is None: + self.emphasis = [] + else: + self.emphasis = emphasis + self.emphasis_nsprefix_ = None + if computeroutput is None: + self.computeroutput = [] + else: + self.computeroutput = computeroutput + self.computeroutput_nsprefix_ = None + if subscript is None: + self.subscript = [] + else: + self.subscript = subscript + self.subscript_nsprefix_ = None + if superscript is None: + self.superscript = [] + else: + self.superscript = superscript + self.superscript_nsprefix_ = None + if center is None: + self.center = [] + else: + self.center = center + self.center_nsprefix_ = None + if small is None: + self.small = [] + else: + self.small = small + self.small_nsprefix_ = None + if htmlonly is None: + self.htmlonly = [] + else: + self.htmlonly = htmlonly + self.htmlonly_nsprefix_ = None + if manonly is None: + self.manonly = [] + else: + self.manonly = manonly + self.manonly_nsprefix_ = None + if xmlonly is None: + self.xmlonly = [] + else: + self.xmlonly = xmlonly + self.xmlonly_nsprefix_ = None + if rtfonly is None: + self.rtfonly = [] + else: + self.rtfonly = rtfonly + self.rtfonly_nsprefix_ = None + if latexonly is None: + self.latexonly = [] + else: + self.latexonly = latexonly + self.latexonly_nsprefix_ = None + if dot is None: + self.dot = [] + else: + self.dot = dot + self.dot_nsprefix_ = None + if msc is None: + self.msc = [] + else: + self.msc = msc + self.msc_nsprefix_ = None + if anchor is None: + self.anchor = [] + else: + self.anchor = anchor + self.anchor_nsprefix_ = None + if formula is None: + self.formula = [] + else: + self.formula = formula + self.formula_nsprefix_ = None + if ref is None: + self.ref = [] + else: + self.ref = ref + self.ref_nsprefix_ = None + if copy is None: + self.copy = [] + else: + self.copy = copy + self.copy_nsprefix_ = None + if trademark is None: + self.trademark = [] + else: + self.trademark = trademark + self.trademark_nsprefix_ = None + if registered is None: + self.registered = [] + else: + self.registered = registered + self.registered_nsprefix_ = None + if lsquo is None: + self.lsquo = [] + else: + self.lsquo = lsquo + self.lsquo_nsprefix_ = None + if rsquo is None: + self.rsquo = [] + else: + self.rsquo = rsquo + self.rsquo_nsprefix_ = None + if ldquo is None: + self.ldquo = [] + else: + self.ldquo = ldquo + self.ldquo_nsprefix_ = None + if rdquo is None: + self.rdquo = [] + else: + self.rdquo = rdquo + self.rdquo_nsprefix_ = None + if ndash is None: + self.ndash = [] + else: + self.ndash = ndash + self.ndash_nsprefix_ = None + if mdash is None: + self.mdash = [] + else: + self.mdash = mdash + self.mdash_nsprefix_ = None + if umlaut is None: + self.umlaut = [] + else: + self.umlaut = umlaut + self.umlaut_nsprefix_ = None + if acute is None: + self.acute = [] + else: + self.acute = acute + self.acute_nsprefix_ = None + if grave is None: + self.grave = [] + else: + self.grave = grave + self.grave_nsprefix_ = None + if circ is None: + self.circ = [] + else: + self.circ = circ + self.circ_nsprefix_ = None + if slash is None: + self.slash = [] + else: + self.slash = slash + self.slash_nsprefix_ = None + if tilde is None: + self.tilde = [] + else: + self.tilde = tilde + self.tilde_nsprefix_ = None + if cedil is None: + self.cedil = [] + else: + self.cedil = cedil + self.cedil_nsprefix_ = None + if ring is None: + self.ring = [] + else: + self.ring = ring + self.ring_nsprefix_ = None + if szlig is None: + self.szlig = [] + else: + self.szlig = szlig + self.szlig_nsprefix_ = None + if nonbreakablespace is None: + self.nonbreakablespace = [] + else: + self.nonbreakablespace = nonbreakablespace + self.nonbreakablespace_nsprefix_ = None + if aelig is None: + self.aelig = [] + else: + self.aelig = aelig + self.aelig_nsprefix_ = None + if AElig is None: + self.AElig = [] + else: + self.AElig = AElig + self.AElig_nsprefix_ = None + if Gamma is None: + self.Gamma = [] + else: + self.Gamma = Gamma + self.Gamma_nsprefix_ = None + if Delta is None: + self.Delta = [] + else: + self.Delta = Delta + self.Delta_nsprefix_ = None + if Theta is None: + self.Theta = [] + else: + self.Theta = Theta + self.Theta_nsprefix_ = None + if Lambda is None: + self.Lambda = [] + else: + self.Lambda = Lambda + self.Lambda_nsprefix_ = None + if Xi is None: + self.Xi = [] + else: + self.Xi = Xi + self.Xi_nsprefix_ = None + if Pi is None: + self.Pi = [] + else: + self.Pi = Pi + self.Pi_nsprefix_ = None + if Sigma is None: + self.Sigma = [] + else: + self.Sigma = Sigma + self.Sigma_nsprefix_ = None + if Upsilon is None: + self.Upsilon = [] + else: + self.Upsilon = Upsilon + self.Upsilon_nsprefix_ = None + if Phi is None: + self.Phi = [] + else: + self.Phi = Phi + self.Phi_nsprefix_ = None + if Psi is None: + self.Psi = [] + else: + self.Psi = Psi + self.Psi_nsprefix_ = None + if Omega is None: + self.Omega = [] + else: + self.Omega = Omega + self.Omega_nsprefix_ = None + if alpha is None: + self.alpha = [] + else: + self.alpha = alpha + self.alpha_nsprefix_ = None + if beta is None: + self.beta = [] + else: + self.beta = beta + self.beta_nsprefix_ = None + if gamma is None: + self.gamma = [] + else: + self.gamma = gamma + self.gamma_nsprefix_ = None + if delta is None: + self.delta = [] + else: + self.delta = delta + self.delta_nsprefix_ = None + if epsilon is None: + self.epsilon = [] + else: + self.epsilon = epsilon + self.epsilon_nsprefix_ = None + if zeta is None: + self.zeta = [] + else: + self.zeta = zeta + self.zeta_nsprefix_ = None + if eta is None: + self.eta = [] + else: + self.eta = eta + self.eta_nsprefix_ = None + if theta is None: + self.theta = [] + else: + self.theta = theta + self.theta_nsprefix_ = None + if iota is None: + self.iota = [] + else: + self.iota = iota + self.iota_nsprefix_ = None + if kappa is None: + self.kappa = [] + else: + self.kappa = kappa + self.kappa_nsprefix_ = None + if lambda_ is None: + self.lambda_ = [] + else: + self.lambda_ = lambda_ + self.lambda__nsprefix_ = None + if mu is None: + self.mu = [] + else: + self.mu = mu + self.mu_nsprefix_ = None + if nu is None: + self.nu = [] + else: + self.nu = nu + self.nu_nsprefix_ = None + if xi is None: + self.xi = [] + else: + self.xi = xi + self.xi_nsprefix_ = None + if pi is None: + self.pi = [] + else: + self.pi = pi + self.pi_nsprefix_ = None + if rho is None: + self.rho = [] + else: + self.rho = rho + self.rho_nsprefix_ = None + if sigma is None: + self.sigma = [] + else: + self.sigma = sigma + self.sigma_nsprefix_ = None + if tau is None: + self.tau = [] + else: + self.tau = tau + self.tau_nsprefix_ = None + if upsilon is None: + self.upsilon = [] + else: + self.upsilon = upsilon + self.upsilon_nsprefix_ = None + if phi is None: + self.phi = [] + else: + self.phi = phi + self.phi_nsprefix_ = None + if chi is None: + self.chi = [] + else: + self.chi = chi + self.chi_nsprefix_ = None + if psi is None: + self.psi = [] + else: + self.psi = psi + self.psi_nsprefix_ = None + if omega is None: + self.omega = [] + else: + self.omega = omega + self.omega_nsprefix_ = None + if sigmaf is None: + self.sigmaf = [] + else: + self.sigmaf = sigmaf + self.sigmaf_nsprefix_ = None + if sect is None: + self.sect = [] + else: + self.sect = sect + self.sect_nsprefix_ = None + if deg is None: + self.deg = [] + else: + self.deg = deg + self.deg_nsprefix_ = None + if prime is None: + self.prime = [] + else: + self.prime = prime + self.prime_nsprefix_ = None + if Prime is None: + self.Prime = [] + else: + self.Prime = Prime + self.Prime_nsprefix_ = None + if infin is None: + self.infin = [] + else: + self.infin = infin + self.infin_nsprefix_ = None + if empty is None: + self.empty = [] + else: + self.empty = empty + self.empty_nsprefix_ = None + if plusmn is None: + self.plusmn = [] + else: + self.plusmn = plusmn + self.plusmn_nsprefix_ = None + if times is None: + self.times = [] + else: + self.times = times + self.times_nsprefix_ = None + if minus is None: + self.minus = [] + else: + self.minus = minus + self.minus_nsprefix_ = None + if sdot is None: + self.sdot = [] + else: + self.sdot = sdot + self.sdot_nsprefix_ = None + if part is None: + self.part = [] + else: + self.part = part + self.part_nsprefix_ = None + if nabla is None: + self.nabla = [] + else: + self.nabla = nabla + self.nabla_nsprefix_ = None + if radic is None: + self.radic = [] + else: + self.radic = radic + self.radic_nsprefix_ = None + if perp is None: + self.perp = [] + else: + self.perp = perp + self.perp_nsprefix_ = None + if sum is None: + self.sum = [] + else: + self.sum = sum + self.sum_nsprefix_ = None + if int is None: + self.int = [] + else: + self.int = int + self.int_nsprefix_ = None + if prod is None: + self.prod = [] + else: + self.prod = prod + self.prod_nsprefix_ = None + if sim is None: + self.sim = [] + else: + self.sim = sim + self.sim_nsprefix_ = None + if asymp is None: + self.asymp = [] + else: + self.asymp = asymp + self.asymp_nsprefix_ = None + if ne is None: + self.ne = [] + else: + self.ne = ne + self.ne_nsprefix_ = None + if equiv is None: + self.equiv = [] + else: + self.equiv = equiv + self.equiv_nsprefix_ = None + if prop is None: + self.prop = [] + else: + self.prop = prop + self.prop_nsprefix_ = None + if le is None: + self.le = [] + else: + self.le = le + self.le_nsprefix_ = None + if ge is None: + self.ge = [] + else: + self.ge = ge + self.ge_nsprefix_ = None + if larr is None: + self.larr = [] + else: + self.larr = larr + self.larr_nsprefix_ = None + if rarr is None: + self.rarr = [] + else: + self.rarr = rarr + self.rarr_nsprefix_ = None + if isin is None: + self.isin = [] + else: + self.isin = isin + self.isin_nsprefix_ = None + if notin is None: + self.notin = [] + else: + self.notin = notin + self.notin_nsprefix_ = None + if lceil is None: + self.lceil = [] + else: + self.lceil = lceil + self.lceil_nsprefix_ = None + if rceil is None: + self.rceil = [] + else: + self.rceil = rceil + self.rceil_nsprefix_ = None + if lfloor is None: + self.lfloor = [] + else: + self.lfloor = lfloor + self.lfloor_nsprefix_ = None + if rfloor is None: + self.rfloor = [] + else: + self.rfloor = rfloor + self.rfloor_nsprefix_ = None + self.valueOf_ = valueOf_ + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + self.valueOf_ = valueOf_ + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docTitleType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docTitleType.subclass: + return docTitleType.subclass(*args_, **kwargs_) + return docTitleType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + def get_ulink(self): + return self.ulink + def set_ulink(self, ulink): + self.ulink = ulink + def add_ulink(self, value): + self.ulink.append(value) + def insert_ulink_at(self, index, value): + self.ulink.insert(index, value) + def replace_ulink_at(self, index, value): + self.ulink[index] = value + def get_bold(self): + return self.bold + def set_bold(self, bold): + self.bold = bold + def add_bold(self, value): + self.bold.append(value) + def insert_bold_at(self, index, value): + self.bold.insert(index, value) + def replace_bold_at(self, index, value): + self.bold[index] = value + def get_emphasis(self): + return self.emphasis + def set_emphasis(self, emphasis): + self.emphasis = emphasis + def add_emphasis(self, value): + self.emphasis.append(value) + def insert_emphasis_at(self, index, value): + self.emphasis.insert(index, value) + def replace_emphasis_at(self, index, value): + self.emphasis[index] = value + def get_computeroutput(self): + return self.computeroutput + def set_computeroutput(self, computeroutput): + self.computeroutput = computeroutput + def add_computeroutput(self, value): + self.computeroutput.append(value) + def insert_computeroutput_at(self, index, value): + self.computeroutput.insert(index, value) + def replace_computeroutput_at(self, index, value): + self.computeroutput[index] = value + def get_subscript(self): + return self.subscript + def set_subscript(self, subscript): + self.subscript = subscript + def add_subscript(self, value): + self.subscript.append(value) + def insert_subscript_at(self, index, value): + self.subscript.insert(index, value) + def replace_subscript_at(self, index, value): + self.subscript[index] = value + def get_superscript(self): + return self.superscript + def set_superscript(self, superscript): + self.superscript = superscript + def add_superscript(self, value): + self.superscript.append(value) + def insert_superscript_at(self, index, value): + self.superscript.insert(index, value) + def replace_superscript_at(self, index, value): + self.superscript[index] = value + def get_center(self): + return self.center + def set_center(self, center): + self.center = center + def add_center(self, value): + self.center.append(value) + def insert_center_at(self, index, value): + self.center.insert(index, value) + def replace_center_at(self, index, value): + self.center[index] = value + def get_small(self): + return self.small + def set_small(self, small): + self.small = small + def add_small(self, value): + self.small.append(value) + def insert_small_at(self, index, value): + self.small.insert(index, value) + def replace_small_at(self, index, value): + self.small[index] = value + def get_htmlonly(self): + return self.htmlonly + def set_htmlonly(self, htmlonly): + self.htmlonly = htmlonly + def add_htmlonly(self, value): + self.htmlonly.append(value) + def insert_htmlonly_at(self, index, value): + self.htmlonly.insert(index, value) + def replace_htmlonly_at(self, index, value): + self.htmlonly[index] = value + def get_manonly(self): + return self.manonly + def set_manonly(self, manonly): + self.manonly = manonly + def add_manonly(self, value): + self.manonly.append(value) + def insert_manonly_at(self, index, value): + self.manonly.insert(index, value) + def replace_manonly_at(self, index, value): + self.manonly[index] = value + def get_xmlonly(self): + return self.xmlonly + def set_xmlonly(self, xmlonly): + self.xmlonly = xmlonly + def add_xmlonly(self, value): + self.xmlonly.append(value) + def insert_xmlonly_at(self, index, value): + self.xmlonly.insert(index, value) + def replace_xmlonly_at(self, index, value): + self.xmlonly[index] = value + def get_rtfonly(self): + return self.rtfonly + def set_rtfonly(self, rtfonly): + self.rtfonly = rtfonly + def add_rtfonly(self, value): + self.rtfonly.append(value) + def insert_rtfonly_at(self, index, value): + self.rtfonly.insert(index, value) + def replace_rtfonly_at(self, index, value): + self.rtfonly[index] = value + def get_latexonly(self): + return self.latexonly + def set_latexonly(self, latexonly): + self.latexonly = latexonly + def add_latexonly(self, value): + self.latexonly.append(value) + def insert_latexonly_at(self, index, value): + self.latexonly.insert(index, value) + def replace_latexonly_at(self, index, value): + self.latexonly[index] = value + def get_dot(self): + return self.dot + def set_dot(self, dot): + self.dot = dot + def add_dot(self, value): + self.dot.append(value) + def insert_dot_at(self, index, value): + self.dot.insert(index, value) + def replace_dot_at(self, index, value): + self.dot[index] = value + def get_msc(self): + return self.msc + def set_msc(self, msc): + self.msc = msc + def add_msc(self, value): + self.msc.append(value) + def insert_msc_at(self, index, value): + self.msc.insert(index, value) + def replace_msc_at(self, index, value): + self.msc[index] = value + def get_anchor(self): + return self.anchor + def set_anchor(self, anchor): + self.anchor = anchor + def add_anchor(self, value): + self.anchor.append(value) + def insert_anchor_at(self, index, value): + self.anchor.insert(index, value) + def replace_anchor_at(self, index, value): + self.anchor[index] = value + def get_formula(self): + return self.formula + def set_formula(self, formula): + self.formula = formula + def add_formula(self, value): + self.formula.append(value) + def insert_formula_at(self, index, value): + self.formula.insert(index, value) + def replace_formula_at(self, index, value): + self.formula[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_at(self, index, value): + self.ref.insert(index, value) + def replace_ref_at(self, index, value): + self.ref[index] = value + def get_copy(self): + return self.copy + def set_copy(self, copy): + self.copy = copy + def add_copy(self, value): + self.copy.append(value) + def insert_copy_at(self, index, value): + self.copy.insert(index, value) + def replace_copy_at(self, index, value): + self.copy[index] = value + def get_trademark(self): + return self.trademark + def set_trademark(self, trademark): + self.trademark = trademark + def add_trademark(self, value): + self.trademark.append(value) + def insert_trademark_at(self, index, value): + self.trademark.insert(index, value) + def replace_trademark_at(self, index, value): + self.trademark[index] = value + def get_registered(self): + return self.registered + def set_registered(self, registered): + self.registered = registered + def add_registered(self, value): + self.registered.append(value) + def insert_registered_at(self, index, value): + self.registered.insert(index, value) + def replace_registered_at(self, index, value): + self.registered[index] = value + def get_lsquo(self): + return self.lsquo + def set_lsquo(self, lsquo): + self.lsquo = lsquo + def add_lsquo(self, value): + self.lsquo.append(value) + def insert_lsquo_at(self, index, value): + self.lsquo.insert(index, value) + def replace_lsquo_at(self, index, value): + self.lsquo[index] = value + def get_rsquo(self): + return self.rsquo + def set_rsquo(self, rsquo): + self.rsquo = rsquo + def add_rsquo(self, value): + self.rsquo.append(value) + def insert_rsquo_at(self, index, value): + self.rsquo.insert(index, value) + def replace_rsquo_at(self, index, value): + self.rsquo[index] = value + def get_ldquo(self): + return self.ldquo + def set_ldquo(self, ldquo): + self.ldquo = ldquo + def add_ldquo(self, value): + self.ldquo.append(value) + def insert_ldquo_at(self, index, value): + self.ldquo.insert(index, value) + def replace_ldquo_at(self, index, value): + self.ldquo[index] = value + def get_rdquo(self): + return self.rdquo + def set_rdquo(self, rdquo): + self.rdquo = rdquo + def add_rdquo(self, value): + self.rdquo.append(value) + def insert_rdquo_at(self, index, value): + self.rdquo.insert(index, value) + def replace_rdquo_at(self, index, value): + self.rdquo[index] = value + def get_ndash(self): + return self.ndash + def set_ndash(self, ndash): + self.ndash = ndash + def add_ndash(self, value): + self.ndash.append(value) + def insert_ndash_at(self, index, value): + self.ndash.insert(index, value) + def replace_ndash_at(self, index, value): + self.ndash[index] = value + def get_mdash(self): + return self.mdash + def set_mdash(self, mdash): + self.mdash = mdash + def add_mdash(self, value): + self.mdash.append(value) + def insert_mdash_at(self, index, value): + self.mdash.insert(index, value) + def replace_mdash_at(self, index, value): + self.mdash[index] = value + def get_umlaut(self): + return self.umlaut + def set_umlaut(self, umlaut): + self.umlaut = umlaut + def add_umlaut(self, value): + self.umlaut.append(value) + def insert_umlaut_at(self, index, value): + self.umlaut.insert(index, value) + def replace_umlaut_at(self, index, value): + self.umlaut[index] = value + def get_acute(self): + return self.acute + def set_acute(self, acute): + self.acute = acute + def add_acute(self, value): + self.acute.append(value) + def insert_acute_at(self, index, value): + self.acute.insert(index, value) + def replace_acute_at(self, index, value): + self.acute[index] = value + def get_grave(self): + return self.grave + def set_grave(self, grave): + self.grave = grave + def add_grave(self, value): + self.grave.append(value) + def insert_grave_at(self, index, value): + self.grave.insert(index, value) + def replace_grave_at(self, index, value): + self.grave[index] = value + def get_circ(self): + return self.circ + def set_circ(self, circ): + self.circ = circ + def add_circ(self, value): + self.circ.append(value) + def insert_circ_at(self, index, value): + self.circ.insert(index, value) + def replace_circ_at(self, index, value): + self.circ[index] = value + def get_slash(self): + return self.slash + def set_slash(self, slash): + self.slash = slash + def add_slash(self, value): + self.slash.append(value) + def insert_slash_at(self, index, value): + self.slash.insert(index, value) + def replace_slash_at(self, index, value): + self.slash[index] = value + def get_tilde(self): + return self.tilde + def set_tilde(self, tilde): + self.tilde = tilde + def add_tilde(self, value): + self.tilde.append(value) + def insert_tilde_at(self, index, value): + self.tilde.insert(index, value) + def replace_tilde_at(self, index, value): + self.tilde[index] = value + def get_cedil(self): + return self.cedil + def set_cedil(self, cedil): + self.cedil = cedil + def add_cedil(self, value): + self.cedil.append(value) + def insert_cedil_at(self, index, value): + self.cedil.insert(index, value) + def replace_cedil_at(self, index, value): + self.cedil[index] = value + def get_ring(self): + return self.ring + def set_ring(self, ring): + self.ring = ring + def add_ring(self, value): + self.ring.append(value) + def insert_ring_at(self, index, value): + self.ring.insert(index, value) + def replace_ring_at(self, index, value): + self.ring[index] = value + def get_szlig(self): + return self.szlig + def set_szlig(self, szlig): + self.szlig = szlig + def add_szlig(self, value): + self.szlig.append(value) + def insert_szlig_at(self, index, value): + self.szlig.insert(index, value) + def replace_szlig_at(self, index, value): + self.szlig[index] = value + def get_nonbreakablespace(self): + return self.nonbreakablespace + def set_nonbreakablespace(self, nonbreakablespace): + self.nonbreakablespace = nonbreakablespace + def add_nonbreakablespace(self, value): + self.nonbreakablespace.append(value) + def insert_nonbreakablespace_at(self, index, value): + self.nonbreakablespace.insert(index, value) + def replace_nonbreakablespace_at(self, index, value): + self.nonbreakablespace[index] = value + def get_aelig(self): + return self.aelig + def set_aelig(self, aelig): + self.aelig = aelig + def add_aelig(self, value): + self.aelig.append(value) + def insert_aelig_at(self, index, value): + self.aelig.insert(index, value) + def replace_aelig_at(self, index, value): + self.aelig[index] = value + def get_AElig(self): + return self.AElig + def set_AElig(self, AElig): + self.AElig = AElig + def add_AElig(self, value): + self.AElig.append(value) + def insert_AElig_at(self, index, value): + self.AElig.insert(index, value) + def replace_AElig_at(self, index, value): + self.AElig[index] = value + def get_Gamma(self): + return self.Gamma + def set_Gamma(self, Gamma): + self.Gamma = Gamma + def add_Gamma(self, value): + self.Gamma.append(value) + def insert_Gamma_at(self, index, value): + self.Gamma.insert(index, value) + def replace_Gamma_at(self, index, value): + self.Gamma[index] = value + def get_Delta(self): + return self.Delta + def set_Delta(self, Delta): + self.Delta = Delta + def add_Delta(self, value): + self.Delta.append(value) + def insert_Delta_at(self, index, value): + self.Delta.insert(index, value) + def replace_Delta_at(self, index, value): + self.Delta[index] = value + def get_Theta(self): + return self.Theta + def set_Theta(self, Theta): + self.Theta = Theta + def add_Theta(self, value): + self.Theta.append(value) + def insert_Theta_at(self, index, value): + self.Theta.insert(index, value) + def replace_Theta_at(self, index, value): + self.Theta[index] = value + def get_Lambda(self): + return self.Lambda + def set_Lambda(self, Lambda): + self.Lambda = Lambda + def add_Lambda(self, value): + self.Lambda.append(value) + def insert_Lambda_at(self, index, value): + self.Lambda.insert(index, value) + def replace_Lambda_at(self, index, value): + self.Lambda[index] = value + def get_Xi(self): + return self.Xi + def set_Xi(self, Xi): + self.Xi = Xi + def add_Xi(self, value): + self.Xi.append(value) + def insert_Xi_at(self, index, value): + self.Xi.insert(index, value) + def replace_Xi_at(self, index, value): + self.Xi[index] = value + def get_Pi(self): + return self.Pi + def set_Pi(self, Pi): + self.Pi = Pi + def add_Pi(self, value): + self.Pi.append(value) + def insert_Pi_at(self, index, value): + self.Pi.insert(index, value) + def replace_Pi_at(self, index, value): + self.Pi[index] = value + def get_Sigma(self): + return self.Sigma + def set_Sigma(self, Sigma): + self.Sigma = Sigma + def add_Sigma(self, value): + self.Sigma.append(value) + def insert_Sigma_at(self, index, value): + self.Sigma.insert(index, value) + def replace_Sigma_at(self, index, value): + self.Sigma[index] = value + def get_Upsilon(self): + return self.Upsilon + def set_Upsilon(self, Upsilon): + self.Upsilon = Upsilon + def add_Upsilon(self, value): + self.Upsilon.append(value) + def insert_Upsilon_at(self, index, value): + self.Upsilon.insert(index, value) + def replace_Upsilon_at(self, index, value): + self.Upsilon[index] = value + def get_Phi(self): + return self.Phi + def set_Phi(self, Phi): + self.Phi = Phi + def add_Phi(self, value): + self.Phi.append(value) + def insert_Phi_at(self, index, value): + self.Phi.insert(index, value) + def replace_Phi_at(self, index, value): + self.Phi[index] = value + def get_Psi(self): + return self.Psi + def set_Psi(self, Psi): + self.Psi = Psi + def add_Psi(self, value): + self.Psi.append(value) + def insert_Psi_at(self, index, value): + self.Psi.insert(index, value) + def replace_Psi_at(self, index, value): + self.Psi[index] = value + def get_Omega(self): + return self.Omega + def set_Omega(self, Omega): + self.Omega = Omega + def add_Omega(self, value): + self.Omega.append(value) + def insert_Omega_at(self, index, value): + self.Omega.insert(index, value) + def replace_Omega_at(self, index, value): + self.Omega[index] = value + def get_alpha(self): + return self.alpha + def set_alpha(self, alpha): + self.alpha = alpha + def add_alpha(self, value): + self.alpha.append(value) + def insert_alpha_at(self, index, value): + self.alpha.insert(index, value) + def replace_alpha_at(self, index, value): + self.alpha[index] = value + def get_beta(self): + return self.beta + def set_beta(self, beta): + self.beta = beta + def add_beta(self, value): + self.beta.append(value) + def insert_beta_at(self, index, value): + self.beta.insert(index, value) + def replace_beta_at(self, index, value): + self.beta[index] = value + def get_gamma(self): + return self.gamma + def set_gamma(self, gamma): + self.gamma = gamma + def add_gamma(self, value): + self.gamma.append(value) + def insert_gamma_at(self, index, value): + self.gamma.insert(index, value) + def replace_gamma_at(self, index, value): + self.gamma[index] = value + def get_delta(self): + return self.delta + def set_delta(self, delta): + self.delta = delta + def add_delta(self, value): + self.delta.append(value) + def insert_delta_at(self, index, value): + self.delta.insert(index, value) + def replace_delta_at(self, index, value): + self.delta[index] = value + def get_epsilon(self): + return self.epsilon + def set_epsilon(self, epsilon): + self.epsilon = epsilon + def add_epsilon(self, value): + self.epsilon.append(value) + def insert_epsilon_at(self, index, value): + self.epsilon.insert(index, value) + def replace_epsilon_at(self, index, value): + self.epsilon[index] = value + def get_zeta(self): + return self.zeta + def set_zeta(self, zeta): + self.zeta = zeta + def add_zeta(self, value): + self.zeta.append(value) + def insert_zeta_at(self, index, value): + self.zeta.insert(index, value) + def replace_zeta_at(self, index, value): + self.zeta[index] = value + def get_eta(self): + return self.eta + def set_eta(self, eta): + self.eta = eta + def add_eta(self, value): + self.eta.append(value) + def insert_eta_at(self, index, value): + self.eta.insert(index, value) + def replace_eta_at(self, index, value): + self.eta[index] = value + def get_theta(self): + return self.theta + def set_theta(self, theta): + self.theta = theta + def add_theta(self, value): + self.theta.append(value) + def insert_theta_at(self, index, value): + self.theta.insert(index, value) + def replace_theta_at(self, index, value): + self.theta[index] = value + def get_iota(self): + return self.iota + def set_iota(self, iota): + self.iota = iota + def add_iota(self, value): + self.iota.append(value) + def insert_iota_at(self, index, value): + self.iota.insert(index, value) + def replace_iota_at(self, index, value): + self.iota[index] = value + def get_kappa(self): + return self.kappa + def set_kappa(self, kappa): + self.kappa = kappa + def add_kappa(self, value): + self.kappa.append(value) + def insert_kappa_at(self, index, value): + self.kappa.insert(index, value) + def replace_kappa_at(self, index, value): + self.kappa[index] = value + def get_lambda(self): + return self.lambda_ + def set_lambda(self, lambda_): + self.lambda_ = lambda_ + def add_lambda(self, value): + self.lambda_.append(value) + def insert_lambda_at(self, index, value): + self.lambda_.insert(index, value) + def replace_lambda_at(self, index, value): + self.lambda_[index] = value + def get_mu(self): + return self.mu + def set_mu(self, mu): + self.mu = mu + def add_mu(self, value): + self.mu.append(value) + def insert_mu_at(self, index, value): + self.mu.insert(index, value) + def replace_mu_at(self, index, value): + self.mu[index] = value + def get_nu(self): + return self.nu + def set_nu(self, nu): + self.nu = nu + def add_nu(self, value): + self.nu.append(value) + def insert_nu_at(self, index, value): + self.nu.insert(index, value) + def replace_nu_at(self, index, value): + self.nu[index] = value + def get_xi(self): + return self.xi + def set_xi(self, xi): + self.xi = xi + def add_xi(self, value): + self.xi.append(value) + def insert_xi_at(self, index, value): + self.xi.insert(index, value) + def replace_xi_at(self, index, value): + self.xi[index] = value + def get_pi(self): + return self.pi + def set_pi(self, pi): + self.pi = pi + def add_pi(self, value): + self.pi.append(value) + def insert_pi_at(self, index, value): + self.pi.insert(index, value) + def replace_pi_at(self, index, value): + self.pi[index] = value + def get_rho(self): + return self.rho + def set_rho(self, rho): + self.rho = rho + def add_rho(self, value): + self.rho.append(value) + def insert_rho_at(self, index, value): + self.rho.insert(index, value) + def replace_rho_at(self, index, value): + self.rho[index] = value + def get_sigma(self): + return self.sigma + def set_sigma(self, sigma): + self.sigma = sigma + def add_sigma(self, value): + self.sigma.append(value) + def insert_sigma_at(self, index, value): + self.sigma.insert(index, value) + def replace_sigma_at(self, index, value): + self.sigma[index] = value + def get_tau(self): + return self.tau + def set_tau(self, tau): + self.tau = tau + def add_tau(self, value): + self.tau.append(value) + def insert_tau_at(self, index, value): + self.tau.insert(index, value) + def replace_tau_at(self, index, value): + self.tau[index] = value + def get_upsilon(self): + return self.upsilon + def set_upsilon(self, upsilon): + self.upsilon = upsilon + def add_upsilon(self, value): + self.upsilon.append(value) + def insert_upsilon_at(self, index, value): + self.upsilon.insert(index, value) + def replace_upsilon_at(self, index, value): + self.upsilon[index] = value + def get_phi(self): + return self.phi + def set_phi(self, phi): + self.phi = phi + def add_phi(self, value): + self.phi.append(value) + def insert_phi_at(self, index, value): + self.phi.insert(index, value) + def replace_phi_at(self, index, value): + self.phi[index] = value + def get_chi(self): + return self.chi + def set_chi(self, chi): + self.chi = chi + def add_chi(self, value): + self.chi.append(value) + def insert_chi_at(self, index, value): + self.chi.insert(index, value) + def replace_chi_at(self, index, value): + self.chi[index] = value + def get_psi(self): + return self.psi + def set_psi(self, psi): + self.psi = psi + def add_psi(self, value): + self.psi.append(value) + def insert_psi_at(self, index, value): + self.psi.insert(index, value) + def replace_psi_at(self, index, value): + self.psi[index] = value + def get_omega(self): + return self.omega + def set_omega(self, omega): + self.omega = omega + def add_omega(self, value): + self.omega.append(value) + def insert_omega_at(self, index, value): + self.omega.insert(index, value) + def replace_omega_at(self, index, value): + self.omega[index] = value + def get_sigmaf(self): + return self.sigmaf + def set_sigmaf(self, sigmaf): + self.sigmaf = sigmaf + def add_sigmaf(self, value): + self.sigmaf.append(value) + def insert_sigmaf_at(self, index, value): + self.sigmaf.insert(index, value) + def replace_sigmaf_at(self, index, value): + self.sigmaf[index] = value + def get_sect(self): + return self.sect + def set_sect(self, sect): + self.sect = sect + def add_sect(self, value): + self.sect.append(value) + def insert_sect_at(self, index, value): + self.sect.insert(index, value) + def replace_sect_at(self, index, value): + self.sect[index] = value + def get_deg(self): + return self.deg + def set_deg(self, deg): + self.deg = deg + def add_deg(self, value): + self.deg.append(value) + def insert_deg_at(self, index, value): + self.deg.insert(index, value) + def replace_deg_at(self, index, value): + self.deg[index] = value + def get_prime(self): + return self.prime + def set_prime(self, prime): + self.prime = prime + def add_prime(self, value): + self.prime.append(value) + def insert_prime_at(self, index, value): + self.prime.insert(index, value) + def replace_prime_at(self, index, value): + self.prime[index] = value + def get_Prime(self): + return self.Prime + def set_Prime(self, Prime): + self.Prime = Prime + def add_Prime(self, value): + self.Prime.append(value) + def insert_Prime_at(self, index, value): + self.Prime.insert(index, value) + def replace_Prime_at(self, index, value): + self.Prime[index] = value + def get_infin(self): + return self.infin + def set_infin(self, infin): + self.infin = infin + def add_infin(self, value): + self.infin.append(value) + def insert_infin_at(self, index, value): + self.infin.insert(index, value) + def replace_infin_at(self, index, value): + self.infin[index] = value + def get_empty(self): + return self.empty + def set_empty(self, empty): + self.empty = empty + def add_empty(self, value): + self.empty.append(value) + def insert_empty_at(self, index, value): + self.empty.insert(index, value) + def replace_empty_at(self, index, value): + self.empty[index] = value + def get_plusmn(self): + return self.plusmn + def set_plusmn(self, plusmn): + self.plusmn = plusmn + def add_plusmn(self, value): + self.plusmn.append(value) + def insert_plusmn_at(self, index, value): + self.plusmn.insert(index, value) + def replace_plusmn_at(self, index, value): + self.plusmn[index] = value + def get_times(self): + return self.times + def set_times(self, times): + self.times = times + def add_times(self, value): + self.times.append(value) + def insert_times_at(self, index, value): + self.times.insert(index, value) + def replace_times_at(self, index, value): + self.times[index] = value + def get_minus(self): + return self.minus + def set_minus(self, minus): + self.minus = minus + def add_minus(self, value): + self.minus.append(value) + def insert_minus_at(self, index, value): + self.minus.insert(index, value) + def replace_minus_at(self, index, value): + self.minus[index] = value + def get_sdot(self): + return self.sdot + def set_sdot(self, sdot): + self.sdot = sdot + def add_sdot(self, value): + self.sdot.append(value) + def insert_sdot_at(self, index, value): + self.sdot.insert(index, value) + def replace_sdot_at(self, index, value): + self.sdot[index] = value + def get_part(self): + return self.part + def set_part(self, part): + self.part = part + def add_part(self, value): + self.part.append(value) + def insert_part_at(self, index, value): + self.part.insert(index, value) + def replace_part_at(self, index, value): + self.part[index] = value + def get_nabla(self): + return self.nabla + def set_nabla(self, nabla): + self.nabla = nabla + def add_nabla(self, value): + self.nabla.append(value) + def insert_nabla_at(self, index, value): + self.nabla.insert(index, value) + def replace_nabla_at(self, index, value): + self.nabla[index] = value + def get_radic(self): + return self.radic + def set_radic(self, radic): + self.radic = radic + def add_radic(self, value): + self.radic.append(value) + def insert_radic_at(self, index, value): + self.radic.insert(index, value) + def replace_radic_at(self, index, value): + self.radic[index] = value + def get_perp(self): + return self.perp + def set_perp(self, perp): + self.perp = perp + def add_perp(self, value): + self.perp.append(value) + def insert_perp_at(self, index, value): + self.perp.insert(index, value) + def replace_perp_at(self, index, value): + self.perp[index] = value + def get_sum(self): + return self.sum + def set_sum(self, sum): + self.sum = sum + def add_sum(self, value): + self.sum.append(value) + def insert_sum_at(self, index, value): + self.sum.insert(index, value) + def replace_sum_at(self, index, value): + self.sum[index] = value + def get_int(self): + return self.int + def set_int(self, int): + self.int = int + def add_int(self, value): + self.int.append(value) + def insert_int_at(self, index, value): + self.int.insert(index, value) + def replace_int_at(self, index, value): + self.int[index] = value + def get_prod(self): + return self.prod + def set_prod(self, prod): + self.prod = prod + def add_prod(self, value): + self.prod.append(value) + def insert_prod_at(self, index, value): + self.prod.insert(index, value) + def replace_prod_at(self, index, value): + self.prod[index] = value + def get_sim(self): + return self.sim + def set_sim(self, sim): + self.sim = sim + def add_sim(self, value): + self.sim.append(value) + def insert_sim_at(self, index, value): + self.sim.insert(index, value) + def replace_sim_at(self, index, value): + self.sim[index] = value + def get_asymp(self): + return self.asymp + def set_asymp(self, asymp): + self.asymp = asymp + def add_asymp(self, value): + self.asymp.append(value) + def insert_asymp_at(self, index, value): + self.asymp.insert(index, value) + def replace_asymp_at(self, index, value): + self.asymp[index] = value + def get_ne(self): + return self.ne + def set_ne(self, ne): + self.ne = ne + def add_ne(self, value): + self.ne.append(value) + def insert_ne_at(self, index, value): + self.ne.insert(index, value) + def replace_ne_at(self, index, value): + self.ne[index] = value + def get_equiv(self): + return self.equiv + def set_equiv(self, equiv): + self.equiv = equiv + def add_equiv(self, value): + self.equiv.append(value) + def insert_equiv_at(self, index, value): + self.equiv.insert(index, value) + def replace_equiv_at(self, index, value): + self.equiv[index] = value + def get_prop(self): + return self.prop + def set_prop(self, prop): + self.prop = prop + def add_prop(self, value): + self.prop.append(value) + def insert_prop_at(self, index, value): + self.prop.insert(index, value) + def replace_prop_at(self, index, value): + self.prop[index] = value + def get_le(self): + return self.le + def set_le(self, le): + self.le = le + def add_le(self, value): + self.le.append(value) + def insert_le_at(self, index, value): + self.le.insert(index, value) + def replace_le_at(self, index, value): + self.le[index] = value + def get_ge(self): + return self.ge + def set_ge(self, ge): + self.ge = ge + def add_ge(self, value): + self.ge.append(value) + def insert_ge_at(self, index, value): + self.ge.insert(index, value) + def replace_ge_at(self, index, value): + self.ge[index] = value + def get_larr(self): + return self.larr + def set_larr(self, larr): + self.larr = larr + def add_larr(self, value): + self.larr.append(value) + def insert_larr_at(self, index, value): + self.larr.insert(index, value) + def replace_larr_at(self, index, value): + self.larr[index] = value + def get_rarr(self): + return self.rarr + def set_rarr(self, rarr): + self.rarr = rarr + def add_rarr(self, value): + self.rarr.append(value) + def insert_rarr_at(self, index, value): + self.rarr.insert(index, value) + def replace_rarr_at(self, index, value): + self.rarr[index] = value + def get_isin(self): + return self.isin + def set_isin(self, isin): + self.isin = isin + def add_isin(self, value): + self.isin.append(value) + def insert_isin_at(self, index, value): + self.isin.insert(index, value) + def replace_isin_at(self, index, value): + self.isin[index] = value + def get_notin(self): + return self.notin + def set_notin(self, notin): + self.notin = notin + def add_notin(self, value): + self.notin.append(value) + def insert_notin_at(self, index, value): + self.notin.insert(index, value) + def replace_notin_at(self, index, value): + self.notin[index] = value + def get_lceil(self): + return self.lceil + def set_lceil(self, lceil): + self.lceil = lceil + def add_lceil(self, value): + self.lceil.append(value) + def insert_lceil_at(self, index, value): + self.lceil.insert(index, value) + def replace_lceil_at(self, index, value): + self.lceil[index] = value + def get_rceil(self): + return self.rceil + def set_rceil(self, rceil): + self.rceil = rceil + def add_rceil(self, value): + self.rceil.append(value) + def insert_rceil_at(self, index, value): + self.rceil.insert(index, value) + def replace_rceil_at(self, index, value): + self.rceil[index] = value + def get_lfloor(self): + return self.lfloor + def set_lfloor(self, lfloor): + self.lfloor = lfloor + def add_lfloor(self, value): + self.lfloor.append(value) + def insert_lfloor_at(self, index, value): + self.lfloor.insert(index, value) + def replace_lfloor_at(self, index, value): + self.lfloor[index] = value + def get_rfloor(self): + return self.rfloor + def set_rfloor(self, rfloor): + self.rfloor = rfloor + def add_rfloor(self, value): + self.rfloor.append(value) + def insert_rfloor_at(self, index, value): + self.rfloor.insert(index, value) + def replace_rfloor_at(self, index, value): + self.rfloor[index] = value + def get_valueOf_(self): return self.valueOf_ + def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def hasContent_(self): + if ( + self.ulink or + self.bold or + self.emphasis or + self.computeroutput or + self.subscript or + self.superscript or + self.center or + self.small or + self.htmlonly or + self.manonly or + self.xmlonly or + self.rtfonly or + self.latexonly or + self.dot or + self.msc or + self.anchor or + self.formula or + self.ref or + self.copy or + self.trademark or + self.registered or + self.lsquo or + self.rsquo or + self.ldquo or + self.rdquo or + self.ndash or + self.mdash or + self.umlaut or + self.acute or + self.grave or + self.circ or + self.slash or + self.tilde or + self.cedil or + self.ring or + self.szlig or + self.nonbreakablespace or + self.aelig or + self.AElig or + self.Gamma or + self.Delta or + self.Theta or + self.Lambda or + self.Xi or + self.Pi or + self.Sigma or + self.Upsilon or + self.Phi or + self.Psi or + self.Omega or + self.alpha or + self.beta or + self.gamma or + self.delta or + self.epsilon or + self.zeta or + self.eta or + self.theta or + self.iota or + self.kappa or + self.lambda_ or + self.mu or + self.nu or + self.xi or + self.pi or + self.rho or + self.sigma or + self.tau or + self.upsilon or + self.phi or + self.chi or + self.psi or + self.omega or + self.sigmaf or + self.sect or + self.deg or + self.prime or + self.Prime or + self.infin or + self.empty or + self.plusmn or + self.times or + self.minus or + self.sdot or + self.part or + self.nabla or + self.radic or + self.perp or + self.sum or + self.int or + self.prod or + self.sim or + self.asymp or + self.ne or + self.equiv or + self.prop or + self.le or + self.ge or + self.larr or + self.rarr or + self.isin or + self.notin or + self.lceil or + self.rceil or + self.lfloor or + self.rfloor or + (1 if type(self.valueOf_) in [int,float] else self.valueOf_) or + self.content_ + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docTitleType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docTitleType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docTitleType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docTitleType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docTitleType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docTitleType'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docTitleType', fromsubclass_=False, pretty_print=True): + if not fromsubclass_: + for item_ in self.content_: + item_.export(outfile, level, item_.name, namespaceprefix_, pretty_print=pretty_print) + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for ulink_ in self.ulink: + namespaceprefix_ = self.ulink_nsprefix_ + ':' if (UseCapturedNS_ and self.ulink_nsprefix_) else '' + ulink_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ulink', pretty_print=pretty_print) + for bold_ in self.bold: + namespaceprefix_ = self.bold_nsprefix_ + ':' if (UseCapturedNS_ and self.bold_nsprefix_) else '' + bold_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='bold', pretty_print=pretty_print) + for emphasis_ in self.emphasis: + namespaceprefix_ = self.emphasis_nsprefix_ + ':' if (UseCapturedNS_ and self.emphasis_nsprefix_) else '' + emphasis_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='emphasis', pretty_print=pretty_print) + for computeroutput_ in self.computeroutput: + namespaceprefix_ = self.computeroutput_nsprefix_ + ':' if (UseCapturedNS_ and self.computeroutput_nsprefix_) else '' + computeroutput_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='computeroutput', pretty_print=pretty_print) + for subscript_ in self.subscript: + namespaceprefix_ = self.subscript_nsprefix_ + ':' if (UseCapturedNS_ and self.subscript_nsprefix_) else '' + subscript_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='subscript', pretty_print=pretty_print) + for superscript_ in self.superscript: + namespaceprefix_ = self.superscript_nsprefix_ + ':' if (UseCapturedNS_ and self.superscript_nsprefix_) else '' + superscript_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='superscript', pretty_print=pretty_print) + for center_ in self.center: + namespaceprefix_ = self.center_nsprefix_ + ':' if (UseCapturedNS_ and self.center_nsprefix_) else '' + center_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='center', pretty_print=pretty_print) + for small_ in self.small: + namespaceprefix_ = self.small_nsprefix_ + ':' if (UseCapturedNS_ and self.small_nsprefix_) else '' + small_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='small', pretty_print=pretty_print) + for htmlonly_ in self.htmlonly: + namespaceprefix_ = self.htmlonly_nsprefix_ + ':' if (UseCapturedNS_ and self.htmlonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%shtmlonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(htmlonly_), input_name='htmlonly')), namespaceprefix_ , eol_)) + for manonly_ in self.manonly: + namespaceprefix_ = self.manonly_nsprefix_ + ':' if (UseCapturedNS_ and self.manonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%smanonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(manonly_), input_name='manonly')), namespaceprefix_ , eol_)) + for xmlonly_ in self.xmlonly: + namespaceprefix_ = self.xmlonly_nsprefix_ + ':' if (UseCapturedNS_ and self.xmlonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%sxmlonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(xmlonly_), input_name='xmlonly')), namespaceprefix_ , eol_)) + for rtfonly_ in self.rtfonly: + namespaceprefix_ = self.rtfonly_nsprefix_ + ':' if (UseCapturedNS_ and self.rtfonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%srtfonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(rtfonly_), input_name='rtfonly')), namespaceprefix_ , eol_)) + for latexonly_ in self.latexonly: + namespaceprefix_ = self.latexonly_nsprefix_ + ':' if (UseCapturedNS_ and self.latexonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%slatexonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(latexonly_), input_name='latexonly')), namespaceprefix_ , eol_)) + for dot_ in self.dot: + namespaceprefix_ = self.dot_nsprefix_ + ':' if (UseCapturedNS_ and self.dot_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%sdot>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(dot_), input_name='dot')), namespaceprefix_ , eol_)) + for msc_ in self.msc: + namespaceprefix_ = self.msc_nsprefix_ + ':' if (UseCapturedNS_ and self.msc_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%smsc>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(msc_), input_name='msc')), namespaceprefix_ , eol_)) + for anchor_ in self.anchor: + namespaceprefix_ = self.anchor_nsprefix_ + ':' if (UseCapturedNS_ and self.anchor_nsprefix_) else '' + anchor_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='anchor', pretty_print=pretty_print) + for formula_ in self.formula: + namespaceprefix_ = self.formula_nsprefix_ + ':' if (UseCapturedNS_ and self.formula_nsprefix_) else '' + formula_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='formula', pretty_print=pretty_print) + for ref_ in self.ref: + namespaceprefix_ = self.ref_nsprefix_ + ':' if (UseCapturedNS_ and self.ref_nsprefix_) else '' + ref_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ref', pretty_print=pretty_print) + for copy_ in self.copy: + namespaceprefix_ = self.copy_nsprefix_ + ':' if (UseCapturedNS_ and self.copy_nsprefix_) else '' + copy_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='copy', pretty_print=pretty_print) + for trademark_ in self.trademark: + namespaceprefix_ = self.trademark_nsprefix_ + ':' if (UseCapturedNS_ and self.trademark_nsprefix_) else '' + trademark_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='trademark', pretty_print=pretty_print) + for registered_ in self.registered: + namespaceprefix_ = self.registered_nsprefix_ + ':' if (UseCapturedNS_ and self.registered_nsprefix_) else '' + registered_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='registered', pretty_print=pretty_print) + for lsquo_ in self.lsquo: + namespaceprefix_ = self.lsquo_nsprefix_ + ':' if (UseCapturedNS_ and self.lsquo_nsprefix_) else '' + lsquo_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='lsquo', pretty_print=pretty_print) + for rsquo_ in self.rsquo: + namespaceprefix_ = self.rsquo_nsprefix_ + ':' if (UseCapturedNS_ and self.rsquo_nsprefix_) else '' + rsquo_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rsquo', pretty_print=pretty_print) + for ldquo_ in self.ldquo: + namespaceprefix_ = self.ldquo_nsprefix_ + ':' if (UseCapturedNS_ and self.ldquo_nsprefix_) else '' + ldquo_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ldquo', pretty_print=pretty_print) + for rdquo_ in self.rdquo: + namespaceprefix_ = self.rdquo_nsprefix_ + ':' if (UseCapturedNS_ and self.rdquo_nsprefix_) else '' + rdquo_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rdquo', pretty_print=pretty_print) + for ndash_ in self.ndash: + namespaceprefix_ = self.ndash_nsprefix_ + ':' if (UseCapturedNS_ and self.ndash_nsprefix_) else '' + ndash_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ndash', pretty_print=pretty_print) + for mdash_ in self.mdash: + namespaceprefix_ = self.mdash_nsprefix_ + ':' if (UseCapturedNS_ and self.mdash_nsprefix_) else '' + mdash_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='mdash', pretty_print=pretty_print) + for umlaut_ in self.umlaut: + namespaceprefix_ = self.umlaut_nsprefix_ + ':' if (UseCapturedNS_ and self.umlaut_nsprefix_) else '' + umlaut_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='umlaut', pretty_print=pretty_print) + for acute_ in self.acute: + namespaceprefix_ = self.acute_nsprefix_ + ':' if (UseCapturedNS_ and self.acute_nsprefix_) else '' + acute_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='acute', pretty_print=pretty_print) + for grave_ in self.grave: + namespaceprefix_ = self.grave_nsprefix_ + ':' if (UseCapturedNS_ and self.grave_nsprefix_) else '' + grave_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='grave', pretty_print=pretty_print) + for circ_ in self.circ: + namespaceprefix_ = self.circ_nsprefix_ + ':' if (UseCapturedNS_ and self.circ_nsprefix_) else '' + circ_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='circ', pretty_print=pretty_print) + for slash_ in self.slash: + namespaceprefix_ = self.slash_nsprefix_ + ':' if (UseCapturedNS_ and self.slash_nsprefix_) else '' + slash_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='slash', pretty_print=pretty_print) + for tilde_ in self.tilde: + namespaceprefix_ = self.tilde_nsprefix_ + ':' if (UseCapturedNS_ and self.tilde_nsprefix_) else '' + tilde_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='tilde', pretty_print=pretty_print) + for cedil_ in self.cedil: + namespaceprefix_ = self.cedil_nsprefix_ + ':' if (UseCapturedNS_ and self.cedil_nsprefix_) else '' + cedil_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='cedil', pretty_print=pretty_print) + for ring_ in self.ring: + namespaceprefix_ = self.ring_nsprefix_ + ':' if (UseCapturedNS_ and self.ring_nsprefix_) else '' + ring_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ring', pretty_print=pretty_print) + for szlig_ in self.szlig: + namespaceprefix_ = self.szlig_nsprefix_ + ':' if (UseCapturedNS_ and self.szlig_nsprefix_) else '' + szlig_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='szlig', pretty_print=pretty_print) + for nonbreakablespace_ in self.nonbreakablespace: + namespaceprefix_ = self.nonbreakablespace_nsprefix_ + ':' if (UseCapturedNS_ and self.nonbreakablespace_nsprefix_) else '' + nonbreakablespace_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='nonbreakablespace', pretty_print=pretty_print) + for aelig_ in self.aelig: + namespaceprefix_ = self.aelig_nsprefix_ + ':' if (UseCapturedNS_ and self.aelig_nsprefix_) else '' + aelig_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='aelig', pretty_print=pretty_print) + for AElig_ in self.AElig: + namespaceprefix_ = self.AElig_nsprefix_ + ':' if (UseCapturedNS_ and self.AElig_nsprefix_) else '' + AElig_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='AElig', pretty_print=pretty_print) + for Gamma_ in self.Gamma: + namespaceprefix_ = self.Gamma_nsprefix_ + ':' if (UseCapturedNS_ and self.Gamma_nsprefix_) else '' + Gamma_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Gamma', pretty_print=pretty_print) + for Delta_ in self.Delta: + namespaceprefix_ = self.Delta_nsprefix_ + ':' if (UseCapturedNS_ and self.Delta_nsprefix_) else '' + Delta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Delta', pretty_print=pretty_print) + for Theta_ in self.Theta: + namespaceprefix_ = self.Theta_nsprefix_ + ':' if (UseCapturedNS_ and self.Theta_nsprefix_) else '' + Theta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Theta', pretty_print=pretty_print) + for Lambda_ in self.Lambda: + namespaceprefix_ = self.Lambda_nsprefix_ + ':' if (UseCapturedNS_ and self.Lambda_nsprefix_) else '' + Lambda_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Lambda', pretty_print=pretty_print) + for Xi_ in self.Xi: + namespaceprefix_ = self.Xi_nsprefix_ + ':' if (UseCapturedNS_ and self.Xi_nsprefix_) else '' + Xi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Xi', pretty_print=pretty_print) + for Pi_ in self.Pi: + namespaceprefix_ = self.Pi_nsprefix_ + ':' if (UseCapturedNS_ and self.Pi_nsprefix_) else '' + Pi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Pi', pretty_print=pretty_print) + for Sigma_ in self.Sigma: + namespaceprefix_ = self.Sigma_nsprefix_ + ':' if (UseCapturedNS_ and self.Sigma_nsprefix_) else '' + Sigma_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Sigma', pretty_print=pretty_print) + for Upsilon_ in self.Upsilon: + namespaceprefix_ = self.Upsilon_nsprefix_ + ':' if (UseCapturedNS_ and self.Upsilon_nsprefix_) else '' + Upsilon_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Upsilon', pretty_print=pretty_print) + for Phi_ in self.Phi: + namespaceprefix_ = self.Phi_nsprefix_ + ':' if (UseCapturedNS_ and self.Phi_nsprefix_) else '' + Phi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Phi', pretty_print=pretty_print) + for Psi_ in self.Psi: + namespaceprefix_ = self.Psi_nsprefix_ + ':' if (UseCapturedNS_ and self.Psi_nsprefix_) else '' + Psi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Psi', pretty_print=pretty_print) + for Omega_ in self.Omega: + namespaceprefix_ = self.Omega_nsprefix_ + ':' if (UseCapturedNS_ and self.Omega_nsprefix_) else '' + Omega_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Omega', pretty_print=pretty_print) + for alpha_ in self.alpha: + namespaceprefix_ = self.alpha_nsprefix_ + ':' if (UseCapturedNS_ and self.alpha_nsprefix_) else '' + alpha_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='alpha', pretty_print=pretty_print) + for beta_ in self.beta: + namespaceprefix_ = self.beta_nsprefix_ + ':' if (UseCapturedNS_ and self.beta_nsprefix_) else '' + beta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='beta', pretty_print=pretty_print) + for gamma_ in self.gamma: + namespaceprefix_ = self.gamma_nsprefix_ + ':' if (UseCapturedNS_ and self.gamma_nsprefix_) else '' + gamma_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='gamma', pretty_print=pretty_print) + for delta_ in self.delta: + namespaceprefix_ = self.delta_nsprefix_ + ':' if (UseCapturedNS_ and self.delta_nsprefix_) else '' + delta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='delta', pretty_print=pretty_print) + for epsilon_ in self.epsilon: + namespaceprefix_ = self.epsilon_nsprefix_ + ':' if (UseCapturedNS_ and self.epsilon_nsprefix_) else '' + epsilon_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='epsilon', pretty_print=pretty_print) + for zeta_ in self.zeta: + namespaceprefix_ = self.zeta_nsprefix_ + ':' if (UseCapturedNS_ and self.zeta_nsprefix_) else '' + zeta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='zeta', pretty_print=pretty_print) + for eta_ in self.eta: + namespaceprefix_ = self.eta_nsprefix_ + ':' if (UseCapturedNS_ and self.eta_nsprefix_) else '' + eta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='eta', pretty_print=pretty_print) + for theta_ in self.theta: + namespaceprefix_ = self.theta_nsprefix_ + ':' if (UseCapturedNS_ and self.theta_nsprefix_) else '' + theta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='theta', pretty_print=pretty_print) + for iota_ in self.iota: + namespaceprefix_ = self.iota_nsprefix_ + ':' if (UseCapturedNS_ and self.iota_nsprefix_) else '' + iota_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='iota', pretty_print=pretty_print) + for kappa_ in self.kappa: + namespaceprefix_ = self.kappa_nsprefix_ + ':' if (UseCapturedNS_ and self.kappa_nsprefix_) else '' + kappa_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='kappa', pretty_print=pretty_print) + for lambda_ in self.lambda_: + namespaceprefix_ = self.lambda__nsprefix_ + ':' if (UseCapturedNS_ and self.lambda__nsprefix_) else '' + lambda_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='lambda', pretty_print=pretty_print) + for mu_ in self.mu: + namespaceprefix_ = self.mu_nsprefix_ + ':' if (UseCapturedNS_ and self.mu_nsprefix_) else '' + mu_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='mu', pretty_print=pretty_print) + for nu_ in self.nu: + namespaceprefix_ = self.nu_nsprefix_ + ':' if (UseCapturedNS_ and self.nu_nsprefix_) else '' + nu_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='nu', pretty_print=pretty_print) + for xi_ in self.xi: + namespaceprefix_ = self.xi_nsprefix_ + ':' if (UseCapturedNS_ and self.xi_nsprefix_) else '' + xi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='xi', pretty_print=pretty_print) + for pi_ in self.pi: + namespaceprefix_ = self.pi_nsprefix_ + ':' if (UseCapturedNS_ and self.pi_nsprefix_) else '' + pi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='pi', pretty_print=pretty_print) + for rho_ in self.rho: + namespaceprefix_ = self.rho_nsprefix_ + ':' if (UseCapturedNS_ and self.rho_nsprefix_) else '' + rho_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rho', pretty_print=pretty_print) + for sigma_ in self.sigma: + namespaceprefix_ = self.sigma_nsprefix_ + ':' if (UseCapturedNS_ and self.sigma_nsprefix_) else '' + sigma_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sigma', pretty_print=pretty_print) + for tau_ in self.tau: + namespaceprefix_ = self.tau_nsprefix_ + ':' if (UseCapturedNS_ and self.tau_nsprefix_) else '' + tau_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='tau', pretty_print=pretty_print) + for upsilon_ in self.upsilon: + namespaceprefix_ = self.upsilon_nsprefix_ + ':' if (UseCapturedNS_ and self.upsilon_nsprefix_) else '' + upsilon_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='upsilon', pretty_print=pretty_print) + for phi_ in self.phi: + namespaceprefix_ = self.phi_nsprefix_ + ':' if (UseCapturedNS_ and self.phi_nsprefix_) else '' + phi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='phi', pretty_print=pretty_print) + for chi_ in self.chi: + namespaceprefix_ = self.chi_nsprefix_ + ':' if (UseCapturedNS_ and self.chi_nsprefix_) else '' + chi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='chi', pretty_print=pretty_print) + for psi_ in self.psi: + namespaceprefix_ = self.psi_nsprefix_ + ':' if (UseCapturedNS_ and self.psi_nsprefix_) else '' + psi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='psi', pretty_print=pretty_print) + for omega_ in self.omega: + namespaceprefix_ = self.omega_nsprefix_ + ':' if (UseCapturedNS_ and self.omega_nsprefix_) else '' + omega_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='omega', pretty_print=pretty_print) + for sigmaf_ in self.sigmaf: + namespaceprefix_ = self.sigmaf_nsprefix_ + ':' if (UseCapturedNS_ and self.sigmaf_nsprefix_) else '' + sigmaf_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sigmaf', pretty_print=pretty_print) + for sect_ in self.sect: + namespaceprefix_ = self.sect_nsprefix_ + ':' if (UseCapturedNS_ and self.sect_nsprefix_) else '' + sect_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sect', pretty_print=pretty_print) + for deg_ in self.deg: + namespaceprefix_ = self.deg_nsprefix_ + ':' if (UseCapturedNS_ and self.deg_nsprefix_) else '' + deg_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='deg', pretty_print=pretty_print) + for prime_ in self.prime: + namespaceprefix_ = self.prime_nsprefix_ + ':' if (UseCapturedNS_ and self.prime_nsprefix_) else '' + prime_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='prime', pretty_print=pretty_print) + for Prime_ in self.Prime: + namespaceprefix_ = self.Prime_nsprefix_ + ':' if (UseCapturedNS_ and self.Prime_nsprefix_) else '' + Prime_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Prime', pretty_print=pretty_print) + for infin_ in self.infin: + namespaceprefix_ = self.infin_nsprefix_ + ':' if (UseCapturedNS_ and self.infin_nsprefix_) else '' + infin_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='infin', pretty_print=pretty_print) + for empty_ in self.empty: + namespaceprefix_ = self.empty_nsprefix_ + ':' if (UseCapturedNS_ and self.empty_nsprefix_) else '' + empty_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='empty', pretty_print=pretty_print) + for plusmn_ in self.plusmn: + namespaceprefix_ = self.plusmn_nsprefix_ + ':' if (UseCapturedNS_ and self.plusmn_nsprefix_) else '' + plusmn_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='plusmn', pretty_print=pretty_print) + for times_ in self.times: + namespaceprefix_ = self.times_nsprefix_ + ':' if (UseCapturedNS_ and self.times_nsprefix_) else '' + times_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='times', pretty_print=pretty_print) + for minus_ in self.minus: + namespaceprefix_ = self.minus_nsprefix_ + ':' if (UseCapturedNS_ and self.minus_nsprefix_) else '' + minus_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='minus', pretty_print=pretty_print) + for sdot_ in self.sdot: + namespaceprefix_ = self.sdot_nsprefix_ + ':' if (UseCapturedNS_ and self.sdot_nsprefix_) else '' + sdot_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sdot', pretty_print=pretty_print) + for part_ in self.part: + namespaceprefix_ = self.part_nsprefix_ + ':' if (UseCapturedNS_ and self.part_nsprefix_) else '' + part_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='part', pretty_print=pretty_print) + for nabla_ in self.nabla: + namespaceprefix_ = self.nabla_nsprefix_ + ':' if (UseCapturedNS_ and self.nabla_nsprefix_) else '' + nabla_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='nabla', pretty_print=pretty_print) + for radic_ in self.radic: + namespaceprefix_ = self.radic_nsprefix_ + ':' if (UseCapturedNS_ and self.radic_nsprefix_) else '' + radic_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='radic', pretty_print=pretty_print) + for perp_ in self.perp: + namespaceprefix_ = self.perp_nsprefix_ + ':' if (UseCapturedNS_ and self.perp_nsprefix_) else '' + perp_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='perp', pretty_print=pretty_print) + for sum_ in self.sum: + namespaceprefix_ = self.sum_nsprefix_ + ':' if (UseCapturedNS_ and self.sum_nsprefix_) else '' + sum_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sum', pretty_print=pretty_print) + for int_ in self.int: + namespaceprefix_ = self.int_nsprefix_ + ':' if (UseCapturedNS_ and self.int_nsprefix_) else '' + int_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='int', pretty_print=pretty_print) + for prod_ in self.prod: + namespaceprefix_ = self.prod_nsprefix_ + ':' if (UseCapturedNS_ and self.prod_nsprefix_) else '' + prod_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='prod', pretty_print=pretty_print) + for sim_ in self.sim: + namespaceprefix_ = self.sim_nsprefix_ + ':' if (UseCapturedNS_ and self.sim_nsprefix_) else '' + sim_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sim', pretty_print=pretty_print) + for asymp_ in self.asymp: + namespaceprefix_ = self.asymp_nsprefix_ + ':' if (UseCapturedNS_ and self.asymp_nsprefix_) else '' + asymp_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='asymp', pretty_print=pretty_print) + for ne_ in self.ne: + namespaceprefix_ = self.ne_nsprefix_ + ':' if (UseCapturedNS_ and self.ne_nsprefix_) else '' + ne_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ne', pretty_print=pretty_print) + for equiv_ in self.equiv: + namespaceprefix_ = self.equiv_nsprefix_ + ':' if (UseCapturedNS_ and self.equiv_nsprefix_) else '' + equiv_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='equiv', pretty_print=pretty_print) + for prop_ in self.prop: + namespaceprefix_ = self.prop_nsprefix_ + ':' if (UseCapturedNS_ and self.prop_nsprefix_) else '' + prop_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='prop', pretty_print=pretty_print) + for le_ in self.le: + namespaceprefix_ = self.le_nsprefix_ + ':' if (UseCapturedNS_ and self.le_nsprefix_) else '' + le_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='le', pretty_print=pretty_print) + for ge_ in self.ge: + namespaceprefix_ = self.ge_nsprefix_ + ':' if (UseCapturedNS_ and self.ge_nsprefix_) else '' + ge_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ge', pretty_print=pretty_print) + for larr_ in self.larr: + namespaceprefix_ = self.larr_nsprefix_ + ':' if (UseCapturedNS_ and self.larr_nsprefix_) else '' + larr_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='larr', pretty_print=pretty_print) + for rarr_ in self.rarr: + namespaceprefix_ = self.rarr_nsprefix_ + ':' if (UseCapturedNS_ and self.rarr_nsprefix_) else '' + rarr_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rarr', pretty_print=pretty_print) + for isin_ in self.isin: + namespaceprefix_ = self.isin_nsprefix_ + ':' if (UseCapturedNS_ and self.isin_nsprefix_) else '' + isin_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='isin', pretty_print=pretty_print) + for notin_ in self.notin: + namespaceprefix_ = self.notin_nsprefix_ + ':' if (UseCapturedNS_ and self.notin_nsprefix_) else '' + notin_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='notin', pretty_print=pretty_print) + for lceil_ in self.lceil: + namespaceprefix_ = self.lceil_nsprefix_ + ':' if (UseCapturedNS_ and self.lceil_nsprefix_) else '' + lceil_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='lceil', pretty_print=pretty_print) + for rceil_ in self.rceil: + namespaceprefix_ = self.rceil_nsprefix_ + ':' if (UseCapturedNS_ and self.rceil_nsprefix_) else '' + rceil_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rceil', pretty_print=pretty_print) + for lfloor_ in self.lfloor: + namespaceprefix_ = self.lfloor_nsprefix_ + ':' if (UseCapturedNS_ and self.lfloor_nsprefix_) else '' + lfloor_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='lfloor', pretty_print=pretty_print) + for rfloor_ in self.rfloor: + namespaceprefix_ = self.rfloor_nsprefix_ + ':' if (UseCapturedNS_ and self.rfloor_nsprefix_) else '' + rfloor_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rfloor', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + self.valueOf_ = get_all_text_(node) + if node.text is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', node.text) + self.content_.append(obj_) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'ulink': + obj_ = docURLLink.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ulink', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ulink'): + self.add_ulink(obj_.value) + elif hasattr(self, 'set_ulink'): + self.set_ulink(obj_.value) + elif nodeName_ == 'bold': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'bold', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_bold'): + self.add_bold(obj_.value) + elif hasattr(self, 'set_bold'): + self.set_bold(obj_.value) + elif nodeName_ == 'emphasis': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'emphasis', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_emphasis'): + self.add_emphasis(obj_.value) + elif hasattr(self, 'set_emphasis'): + self.set_emphasis(obj_.value) + elif nodeName_ == 'computeroutput': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'computeroutput', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_computeroutput'): + self.add_computeroutput(obj_.value) + elif hasattr(self, 'set_computeroutput'): + self.set_computeroutput(obj_.value) + elif nodeName_ == 'subscript': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'subscript', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_subscript'): + self.add_subscript(obj_.value) + elif hasattr(self, 'set_subscript'): + self.set_subscript(obj_.value) + elif nodeName_ == 'superscript': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'superscript', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_superscript'): + self.add_superscript(obj_.value) + elif hasattr(self, 'set_superscript'): + self.set_superscript(obj_.value) + elif nodeName_ == 'center': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'center', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_center'): + self.add_center(obj_.value) + elif hasattr(self, 'set_center'): + self.set_center(obj_.value) + elif nodeName_ == 'small': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'small', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_small'): + self.add_small(obj_.value) + elif hasattr(self, 'set_small'): + self.set_small(obj_.value) + elif nodeName_ == 'htmlonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'htmlonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'htmlonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'htmlonly', valuestr_) + self.content_.append(obj_) + self.htmlonly_nsprefix_ = child_.prefix + elif nodeName_ == 'manonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'manonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'manonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'manonly', valuestr_) + self.content_.append(obj_) + self.manonly_nsprefix_ = child_.prefix + elif nodeName_ == 'xmlonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'xmlonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'xmlonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'xmlonly', valuestr_) + self.content_.append(obj_) + self.xmlonly_nsprefix_ = child_.prefix + elif nodeName_ == 'rtfonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'rtfonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'rtfonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'rtfonly', valuestr_) + self.content_.append(obj_) + self.rtfonly_nsprefix_ = child_.prefix + elif nodeName_ == 'latexonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'latexonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'latexonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'latexonly', valuestr_) + self.content_.append(obj_) + self.latexonly_nsprefix_ = child_.prefix + elif nodeName_ == 'dot' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'dot') + valuestr_ = self.gds_validate_string(valuestr_, node, 'dot') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'dot', valuestr_) + self.content_.append(obj_) + self.dot_nsprefix_ = child_.prefix + elif nodeName_ == 'msc' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'msc') + valuestr_ = self.gds_validate_string(valuestr_, node, 'msc') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'msc', valuestr_) + self.content_.append(obj_) + self.msc_nsprefix_ = child_.prefix + elif nodeName_ == 'anchor': + obj_ = docAnchorType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'anchor', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_anchor'): + self.add_anchor(obj_.value) + elif hasattr(self, 'set_anchor'): + self.set_anchor(obj_.value) + elif nodeName_ == 'formula': + obj_ = docFormulaType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'formula', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_formula'): + self.add_formula(obj_.value) + elif hasattr(self, 'set_formula'): + self.set_formula(obj_.value) + elif nodeName_ == 'ref': + obj_ = docRefTextType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ref', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ref'): + self.add_ref(obj_.value) + elif hasattr(self, 'set_ref'): + self.set_ref(obj_.value) + elif nodeName_ == 'copy': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'copy', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_copy'): + self.add_copy(obj_.value) + elif hasattr(self, 'set_copy'): + self.set_copy(obj_.value) + elif nodeName_ == 'trademark': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'trademark', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_trademark'): + self.add_trademark(obj_.value) + elif hasattr(self, 'set_trademark'): + self.set_trademark(obj_.value) + elif nodeName_ == 'registered': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'registered', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_registered'): + self.add_registered(obj_.value) + elif hasattr(self, 'set_registered'): + self.set_registered(obj_.value) + elif nodeName_ == 'lsquo': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'lsquo', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_lsquo'): + self.add_lsquo(obj_.value) + elif hasattr(self, 'set_lsquo'): + self.set_lsquo(obj_.value) + elif nodeName_ == 'rsquo': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rsquo', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rsquo'): + self.add_rsquo(obj_.value) + elif hasattr(self, 'set_rsquo'): + self.set_rsquo(obj_.value) + elif nodeName_ == 'ldquo': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ldquo', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ldquo'): + self.add_ldquo(obj_.value) + elif hasattr(self, 'set_ldquo'): + self.set_ldquo(obj_.value) + elif nodeName_ == 'rdquo': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rdquo', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rdquo'): + self.add_rdquo(obj_.value) + elif hasattr(self, 'set_rdquo'): + self.set_rdquo(obj_.value) + elif nodeName_ == 'ndash': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ndash', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ndash'): + self.add_ndash(obj_.value) + elif hasattr(self, 'set_ndash'): + self.set_ndash(obj_.value) + elif nodeName_ == 'mdash': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'mdash', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_mdash'): + self.add_mdash(obj_.value) + elif hasattr(self, 'set_mdash'): + self.set_mdash(obj_.value) + elif nodeName_ == 'umlaut': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'umlaut', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_umlaut'): + self.add_umlaut(obj_.value) + elif hasattr(self, 'set_umlaut'): + self.set_umlaut(obj_.value) + elif nodeName_ == 'acute': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'acute', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_acute'): + self.add_acute(obj_.value) + elif hasattr(self, 'set_acute'): + self.set_acute(obj_.value) + elif nodeName_ == 'grave': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'grave', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_grave'): + self.add_grave(obj_.value) + elif hasattr(self, 'set_grave'): + self.set_grave(obj_.value) + elif nodeName_ == 'circ': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'circ', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_circ'): + self.add_circ(obj_.value) + elif hasattr(self, 'set_circ'): + self.set_circ(obj_.value) + elif nodeName_ == 'slash': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'slash', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_slash'): + self.add_slash(obj_.value) + elif hasattr(self, 'set_slash'): + self.set_slash(obj_.value) + elif nodeName_ == 'tilde': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'tilde', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_tilde'): + self.add_tilde(obj_.value) + elif hasattr(self, 'set_tilde'): + self.set_tilde(obj_.value) + elif nodeName_ == 'cedil': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'cedil', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_cedil'): + self.add_cedil(obj_.value) + elif hasattr(self, 'set_cedil'): + self.set_cedil(obj_.value) + elif nodeName_ == 'ring': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ring', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ring'): + self.add_ring(obj_.value) + elif hasattr(self, 'set_ring'): + self.set_ring(obj_.value) + elif nodeName_ == 'szlig': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'szlig', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_szlig'): + self.add_szlig(obj_.value) + elif hasattr(self, 'set_szlig'): + self.set_szlig(obj_.value) + elif nodeName_ == 'nonbreakablespace': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'nonbreakablespace', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_nonbreakablespace'): + self.add_nonbreakablespace(obj_.value) + elif hasattr(self, 'set_nonbreakablespace'): + self.set_nonbreakablespace(obj_.value) + elif nodeName_ == 'aelig': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'aelig', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_aelig'): + self.add_aelig(obj_.value) + elif hasattr(self, 'set_aelig'): + self.set_aelig(obj_.value) + elif nodeName_ == 'AElig': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'AElig', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_AElig'): + self.add_AElig(obj_.value) + elif hasattr(self, 'set_AElig'): + self.set_AElig(obj_.value) + elif nodeName_ == 'Gamma': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Gamma', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Gamma'): + self.add_Gamma(obj_.value) + elif hasattr(self, 'set_Gamma'): + self.set_Gamma(obj_.value) + elif nodeName_ == 'Delta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Delta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Delta'): + self.add_Delta(obj_.value) + elif hasattr(self, 'set_Delta'): + self.set_Delta(obj_.value) + elif nodeName_ == 'Theta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Theta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Theta'): + self.add_Theta(obj_.value) + elif hasattr(self, 'set_Theta'): + self.set_Theta(obj_.value) + elif nodeName_ == 'Lambda': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Lambda', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Lambda'): + self.add_Lambda(obj_.value) + elif hasattr(self, 'set_Lambda'): + self.set_Lambda(obj_.value) + elif nodeName_ == 'Xi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Xi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Xi'): + self.add_Xi(obj_.value) + elif hasattr(self, 'set_Xi'): + self.set_Xi(obj_.value) + elif nodeName_ == 'Pi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Pi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Pi'): + self.add_Pi(obj_.value) + elif hasattr(self, 'set_Pi'): + self.set_Pi(obj_.value) + elif nodeName_ == 'Sigma': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Sigma', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Sigma'): + self.add_Sigma(obj_.value) + elif hasattr(self, 'set_Sigma'): + self.set_Sigma(obj_.value) + elif nodeName_ == 'Upsilon': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Upsilon', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Upsilon'): + self.add_Upsilon(obj_.value) + elif hasattr(self, 'set_Upsilon'): + self.set_Upsilon(obj_.value) + elif nodeName_ == 'Phi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Phi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Phi'): + self.add_Phi(obj_.value) + elif hasattr(self, 'set_Phi'): + self.set_Phi(obj_.value) + elif nodeName_ == 'Psi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Psi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Psi'): + self.add_Psi(obj_.value) + elif hasattr(self, 'set_Psi'): + self.set_Psi(obj_.value) + elif nodeName_ == 'Omega': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Omega', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Omega'): + self.add_Omega(obj_.value) + elif hasattr(self, 'set_Omega'): + self.set_Omega(obj_.value) + elif nodeName_ == 'alpha': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'alpha', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_alpha'): + self.add_alpha(obj_.value) + elif hasattr(self, 'set_alpha'): + self.set_alpha(obj_.value) + elif nodeName_ == 'beta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'beta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_beta'): + self.add_beta(obj_.value) + elif hasattr(self, 'set_beta'): + self.set_beta(obj_.value) + elif nodeName_ == 'gamma': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'gamma', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_gamma'): + self.add_gamma(obj_.value) + elif hasattr(self, 'set_gamma'): + self.set_gamma(obj_.value) + elif nodeName_ == 'delta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'delta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_delta'): + self.add_delta(obj_.value) + elif hasattr(self, 'set_delta'): + self.set_delta(obj_.value) + elif nodeName_ == 'epsilon': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'epsilon', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_epsilon'): + self.add_epsilon(obj_.value) + elif hasattr(self, 'set_epsilon'): + self.set_epsilon(obj_.value) + elif nodeName_ == 'zeta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'zeta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_zeta'): + self.add_zeta(obj_.value) + elif hasattr(self, 'set_zeta'): + self.set_zeta(obj_.value) + elif nodeName_ == 'eta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'eta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_eta'): + self.add_eta(obj_.value) + elif hasattr(self, 'set_eta'): + self.set_eta(obj_.value) + elif nodeName_ == 'theta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'theta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_theta'): + self.add_theta(obj_.value) + elif hasattr(self, 'set_theta'): + self.set_theta(obj_.value) + elif nodeName_ == 'iota': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'iota', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_iota'): + self.add_iota(obj_.value) + elif hasattr(self, 'set_iota'): + self.set_iota(obj_.value) + elif nodeName_ == 'kappa': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'kappa', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_kappa'): + self.add_kappa(obj_.value) + elif hasattr(self, 'set_kappa'): + self.set_kappa(obj_.value) + elif nodeName_ == 'lambda': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'lambda', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_lambda'): + self.add_lambda(obj_.value) + elif hasattr(self, 'set_lambda'): + self.set_lambda(obj_.value) + elif nodeName_ == 'mu': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'mu', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_mu'): + self.add_mu(obj_.value) + elif hasattr(self, 'set_mu'): + self.set_mu(obj_.value) + elif nodeName_ == 'nu': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'nu', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_nu'): + self.add_nu(obj_.value) + elif hasattr(self, 'set_nu'): + self.set_nu(obj_.value) + elif nodeName_ == 'xi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'xi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_xi'): + self.add_xi(obj_.value) + elif hasattr(self, 'set_xi'): + self.set_xi(obj_.value) + elif nodeName_ == 'pi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'pi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_pi'): + self.add_pi(obj_.value) + elif hasattr(self, 'set_pi'): + self.set_pi(obj_.value) + elif nodeName_ == 'rho': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rho', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rho'): + self.add_rho(obj_.value) + elif hasattr(self, 'set_rho'): + self.set_rho(obj_.value) + elif nodeName_ == 'sigma': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sigma', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sigma'): + self.add_sigma(obj_.value) + elif hasattr(self, 'set_sigma'): + self.set_sigma(obj_.value) + elif nodeName_ == 'tau': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'tau', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_tau'): + self.add_tau(obj_.value) + elif hasattr(self, 'set_tau'): + self.set_tau(obj_.value) + elif nodeName_ == 'upsilon': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'upsilon', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_upsilon'): + self.add_upsilon(obj_.value) + elif hasattr(self, 'set_upsilon'): + self.set_upsilon(obj_.value) + elif nodeName_ == 'phi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'phi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_phi'): + self.add_phi(obj_.value) + elif hasattr(self, 'set_phi'): + self.set_phi(obj_.value) + elif nodeName_ == 'chi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'chi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_chi'): + self.add_chi(obj_.value) + elif hasattr(self, 'set_chi'): + self.set_chi(obj_.value) + elif nodeName_ == 'psi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'psi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_psi'): + self.add_psi(obj_.value) + elif hasattr(self, 'set_psi'): + self.set_psi(obj_.value) + elif nodeName_ == 'omega': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'omega', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_omega'): + self.add_omega(obj_.value) + elif hasattr(self, 'set_omega'): + self.set_omega(obj_.value) + elif nodeName_ == 'sigmaf': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sigmaf', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sigmaf'): + self.add_sigmaf(obj_.value) + elif hasattr(self, 'set_sigmaf'): + self.set_sigmaf(obj_.value) + elif nodeName_ == 'sect': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sect', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sect'): + self.add_sect(obj_.value) + elif hasattr(self, 'set_sect'): + self.set_sect(obj_.value) + elif nodeName_ == 'deg': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'deg', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_deg'): + self.add_deg(obj_.value) + elif hasattr(self, 'set_deg'): + self.set_deg(obj_.value) + elif nodeName_ == 'prime': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'prime', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_prime'): + self.add_prime(obj_.value) + elif hasattr(self, 'set_prime'): + self.set_prime(obj_.value) + elif nodeName_ == 'Prime': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Prime', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Prime'): + self.add_Prime(obj_.value) + elif hasattr(self, 'set_Prime'): + self.set_Prime(obj_.value) + elif nodeName_ == 'infin': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'infin', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_infin'): + self.add_infin(obj_.value) + elif hasattr(self, 'set_infin'): + self.set_infin(obj_.value) + elif nodeName_ == 'empty': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'empty', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_empty'): + self.add_empty(obj_.value) + elif hasattr(self, 'set_empty'): + self.set_empty(obj_.value) + elif nodeName_ == 'plusmn': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'plusmn', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_plusmn'): + self.add_plusmn(obj_.value) + elif hasattr(self, 'set_plusmn'): + self.set_plusmn(obj_.value) + elif nodeName_ == 'times': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'times', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_times'): + self.add_times(obj_.value) + elif hasattr(self, 'set_times'): + self.set_times(obj_.value) + elif nodeName_ == 'minus': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'minus', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_minus'): + self.add_minus(obj_.value) + elif hasattr(self, 'set_minus'): + self.set_minus(obj_.value) + elif nodeName_ == 'sdot': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sdot', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sdot'): + self.add_sdot(obj_.value) + elif hasattr(self, 'set_sdot'): + self.set_sdot(obj_.value) + elif nodeName_ == 'part': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'part', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_part'): + self.add_part(obj_.value) + elif hasattr(self, 'set_part'): + self.set_part(obj_.value) + elif nodeName_ == 'nabla': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'nabla', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_nabla'): + self.add_nabla(obj_.value) + elif hasattr(self, 'set_nabla'): + self.set_nabla(obj_.value) + elif nodeName_ == 'radic': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'radic', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_radic'): + self.add_radic(obj_.value) + elif hasattr(self, 'set_radic'): + self.set_radic(obj_.value) + elif nodeName_ == 'perp': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'perp', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_perp'): + self.add_perp(obj_.value) + elif hasattr(self, 'set_perp'): + self.set_perp(obj_.value) + elif nodeName_ == 'sum': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sum', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sum'): + self.add_sum(obj_.value) + elif hasattr(self, 'set_sum'): + self.set_sum(obj_.value) + elif nodeName_ == 'int': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'int', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_int'): + self.add_int(obj_.value) + elif hasattr(self, 'set_int'): + self.set_int(obj_.value) + elif nodeName_ == 'prod': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'prod', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_prod'): + self.add_prod(obj_.value) + elif hasattr(self, 'set_prod'): + self.set_prod(obj_.value) + elif nodeName_ == 'sim': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sim', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sim'): + self.add_sim(obj_.value) + elif hasattr(self, 'set_sim'): + self.set_sim(obj_.value) + elif nodeName_ == 'asymp': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'asymp', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_asymp'): + self.add_asymp(obj_.value) + elif hasattr(self, 'set_asymp'): + self.set_asymp(obj_.value) + elif nodeName_ == 'ne': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ne', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ne'): + self.add_ne(obj_.value) + elif hasattr(self, 'set_ne'): + self.set_ne(obj_.value) + elif nodeName_ == 'equiv': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'equiv', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_equiv'): + self.add_equiv(obj_.value) + elif hasattr(self, 'set_equiv'): + self.set_equiv(obj_.value) + elif nodeName_ == 'prop': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'prop', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_prop'): + self.add_prop(obj_.value) + elif hasattr(self, 'set_prop'): + self.set_prop(obj_.value) + elif nodeName_ == 'le': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'le', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_le'): + self.add_le(obj_.value) + elif hasattr(self, 'set_le'): + self.set_le(obj_.value) + elif nodeName_ == 'ge': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ge', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ge'): + self.add_ge(obj_.value) + elif hasattr(self, 'set_ge'): + self.set_ge(obj_.value) + elif nodeName_ == 'larr': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'larr', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_larr'): + self.add_larr(obj_.value) + elif hasattr(self, 'set_larr'): + self.set_larr(obj_.value) + elif nodeName_ == 'rarr': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rarr', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rarr'): + self.add_rarr(obj_.value) + elif hasattr(self, 'set_rarr'): + self.set_rarr(obj_.value) + elif nodeName_ == 'isin': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'isin', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_isin'): + self.add_isin(obj_.value) + elif hasattr(self, 'set_isin'): + self.set_isin(obj_.value) + elif nodeName_ == 'notin': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'notin', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_notin'): + self.add_notin(obj_.value) + elif hasattr(self, 'set_notin'): + self.set_notin(obj_.value) + elif nodeName_ == 'lceil': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'lceil', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_lceil'): + self.add_lceil(obj_.value) + elif hasattr(self, 'set_lceil'): + self.set_lceil(obj_.value) + elif nodeName_ == 'rceil': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rceil', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rceil'): + self.add_rceil(obj_.value) + elif hasattr(self, 'set_rceil'): + self.set_rceil(obj_.value) + elif nodeName_ == 'lfloor': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'lfloor', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_lfloor'): + self.add_lfloor(obj_.value) + elif hasattr(self, 'set_lfloor'): + self.set_lfloor(obj_.value) + elif nodeName_ == 'rfloor': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rfloor', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rfloor'): + self.add_rfloor(obj_.value) + elif hasattr(self, 'set_rfloor'): + self.set_rfloor(obj_.value) + if not fromsubclass_ and child_.tail is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.tail) + self.content_.append(obj_) +# end class docTitleType + + +class docParaType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, ulink=None, bold=None, emphasis=None, computeroutput=None, subscript=None, superscript=None, center=None, small=None, htmlonly=None, manonly=None, xmlonly=None, rtfonly=None, latexonly=None, dot=None, msc=None, anchor=None, formula=None, ref=None, copy=None, trademark=None, registered=None, lsquo=None, rsquo=None, ldquo=None, rdquo=None, ndash=None, mdash=None, umlaut=None, acute=None, grave=None, circ=None, slash=None, tilde=None, cedil=None, ring=None, szlig=None, nonbreakablespace=None, aelig=None, AElig=None, Gamma=None, Delta=None, Theta=None, Lambda=None, Xi=None, Pi=None, Sigma=None, Upsilon=None, Phi=None, Psi=None, Omega=None, alpha=None, beta=None, gamma=None, delta=None, epsilon=None, zeta=None, eta=None, theta=None, iota=None, kappa=None, lambda_=None, mu=None, nu=None, xi=None, pi=None, rho=None, sigma=None, tau=None, upsilon=None, phi=None, chi=None, psi=None, omega=None, sigmaf=None, sect=None, deg=None, prime=None, Prime=None, infin=None, empty=None, plusmn=None, times=None, minus=None, sdot=None, part=None, nabla=None, radic=None, perp=None, sum=None, int=None, prod=None, sim=None, asymp=None, ne=None, equiv=None, prop=None, le=None, ge=None, larr=None, rarr=None, isin=None, notin=None, lceil=None, rceil=None, lfloor=None, rfloor=None, linebreak=None, hruler=None, preformatted=None, programlisting=None, verbatim=None, indexentry=None, orderedlist=None, itemizedlist=None, simplesect=None, title=None, variablelist=None, table=None, heading=None, image=None, dotfile=None, mscfile=None, diafile=None, toclist=None, language=None, parameterlist=None, xrefsect=None, copydoc=None, blockquote=None, parblock=None, valueOf_=None, mixedclass_=None, content_=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + if ulink is None: + self.ulink = [] + else: + self.ulink = ulink + self.ulink_nsprefix_ = None + if bold is None: + self.bold = [] + else: + self.bold = bold + self.bold_nsprefix_ = None + if emphasis is None: + self.emphasis = [] + else: + self.emphasis = emphasis + self.emphasis_nsprefix_ = None + if computeroutput is None: + self.computeroutput = [] + else: + self.computeroutput = computeroutput + self.computeroutput_nsprefix_ = None + if subscript is None: + self.subscript = [] + else: + self.subscript = subscript + self.subscript_nsprefix_ = None + if superscript is None: + self.superscript = [] + else: + self.superscript = superscript + self.superscript_nsprefix_ = None + if center is None: + self.center = [] + else: + self.center = center + self.center_nsprefix_ = None + if small is None: + self.small = [] + else: + self.small = small + self.small_nsprefix_ = None + if htmlonly is None: + self.htmlonly = [] + else: + self.htmlonly = htmlonly + self.htmlonly_nsprefix_ = None + if manonly is None: + self.manonly = [] + else: + self.manonly = manonly + self.manonly_nsprefix_ = None + if xmlonly is None: + self.xmlonly = [] + else: + self.xmlonly = xmlonly + self.xmlonly_nsprefix_ = None + if rtfonly is None: + self.rtfonly = [] + else: + self.rtfonly = rtfonly + self.rtfonly_nsprefix_ = None + if latexonly is None: + self.latexonly = [] + else: + self.latexonly = latexonly + self.latexonly_nsprefix_ = None + if dot is None: + self.dot = [] + else: + self.dot = dot + self.dot_nsprefix_ = None + if msc is None: + self.msc = [] + else: + self.msc = msc + self.msc_nsprefix_ = None + if anchor is None: + self.anchor = [] + else: + self.anchor = anchor + self.anchor_nsprefix_ = None + if formula is None: + self.formula = [] + else: + self.formula = formula + self.formula_nsprefix_ = None + if ref is None: + self.ref = [] + else: + self.ref = ref + self.ref_nsprefix_ = None + if copy is None: + self.copy = [] + else: + self.copy = copy + self.copy_nsprefix_ = None + if trademark is None: + self.trademark = [] + else: + self.trademark = trademark + self.trademark_nsprefix_ = None + if registered is None: + self.registered = [] + else: + self.registered = registered + self.registered_nsprefix_ = None + if lsquo is None: + self.lsquo = [] + else: + self.lsquo = lsquo + self.lsquo_nsprefix_ = None + if rsquo is None: + self.rsquo = [] + else: + self.rsquo = rsquo + self.rsquo_nsprefix_ = None + if ldquo is None: + self.ldquo = [] + else: + self.ldquo = ldquo + self.ldquo_nsprefix_ = None + if rdquo is None: + self.rdquo = [] + else: + self.rdquo = rdquo + self.rdquo_nsprefix_ = None + if ndash is None: + self.ndash = [] + else: + self.ndash = ndash + self.ndash_nsprefix_ = None + if mdash is None: + self.mdash = [] + else: + self.mdash = mdash + self.mdash_nsprefix_ = None + if umlaut is None: + self.umlaut = [] + else: + self.umlaut = umlaut + self.umlaut_nsprefix_ = None + if acute is None: + self.acute = [] + else: + self.acute = acute + self.acute_nsprefix_ = None + if grave is None: + self.grave = [] + else: + self.grave = grave + self.grave_nsprefix_ = None + if circ is None: + self.circ = [] + else: + self.circ = circ + self.circ_nsprefix_ = None + if slash is None: + self.slash = [] + else: + self.slash = slash + self.slash_nsprefix_ = None + if tilde is None: + self.tilde = [] + else: + self.tilde = tilde + self.tilde_nsprefix_ = None + if cedil is None: + self.cedil = [] + else: + self.cedil = cedil + self.cedil_nsprefix_ = None + if ring is None: + self.ring = [] + else: + self.ring = ring + self.ring_nsprefix_ = None + if szlig is None: + self.szlig = [] + else: + self.szlig = szlig + self.szlig_nsprefix_ = None + if nonbreakablespace is None: + self.nonbreakablespace = [] + else: + self.nonbreakablespace = nonbreakablespace + self.nonbreakablespace_nsprefix_ = None + if aelig is None: + self.aelig = [] + else: + self.aelig = aelig + self.aelig_nsprefix_ = None + if AElig is None: + self.AElig = [] + else: + self.AElig = AElig + self.AElig_nsprefix_ = None + if Gamma is None: + self.Gamma = [] + else: + self.Gamma = Gamma + self.Gamma_nsprefix_ = None + if Delta is None: + self.Delta = [] + else: + self.Delta = Delta + self.Delta_nsprefix_ = None + if Theta is None: + self.Theta = [] + else: + self.Theta = Theta + self.Theta_nsprefix_ = None + if Lambda is None: + self.Lambda = [] + else: + self.Lambda = Lambda + self.Lambda_nsprefix_ = None + if Xi is None: + self.Xi = [] + else: + self.Xi = Xi + self.Xi_nsprefix_ = None + if Pi is None: + self.Pi = [] + else: + self.Pi = Pi + self.Pi_nsprefix_ = None + if Sigma is None: + self.Sigma = [] + else: + self.Sigma = Sigma + self.Sigma_nsprefix_ = None + if Upsilon is None: + self.Upsilon = [] + else: + self.Upsilon = Upsilon + self.Upsilon_nsprefix_ = None + if Phi is None: + self.Phi = [] + else: + self.Phi = Phi + self.Phi_nsprefix_ = None + if Psi is None: + self.Psi = [] + else: + self.Psi = Psi + self.Psi_nsprefix_ = None + if Omega is None: + self.Omega = [] + else: + self.Omega = Omega + self.Omega_nsprefix_ = None + if alpha is None: + self.alpha = [] + else: + self.alpha = alpha + self.alpha_nsprefix_ = None + if beta is None: + self.beta = [] + else: + self.beta = beta + self.beta_nsprefix_ = None + if gamma is None: + self.gamma = [] + else: + self.gamma = gamma + self.gamma_nsprefix_ = None + if delta is None: + self.delta = [] + else: + self.delta = delta + self.delta_nsprefix_ = None + if epsilon is None: + self.epsilon = [] + else: + self.epsilon = epsilon + self.epsilon_nsprefix_ = None + if zeta is None: + self.zeta = [] + else: + self.zeta = zeta + self.zeta_nsprefix_ = None + if eta is None: + self.eta = [] + else: + self.eta = eta + self.eta_nsprefix_ = None + if theta is None: + self.theta = [] + else: + self.theta = theta + self.theta_nsprefix_ = None + if iota is None: + self.iota = [] + else: + self.iota = iota + self.iota_nsprefix_ = None + if kappa is None: + self.kappa = [] + else: + self.kappa = kappa + self.kappa_nsprefix_ = None + if lambda_ is None: + self.lambda_ = [] + else: + self.lambda_ = lambda_ + self.lambda__nsprefix_ = None + if mu is None: + self.mu = [] + else: + self.mu = mu + self.mu_nsprefix_ = None + if nu is None: + self.nu = [] + else: + self.nu = nu + self.nu_nsprefix_ = None + if xi is None: + self.xi = [] + else: + self.xi = xi + self.xi_nsprefix_ = None + if pi is None: + self.pi = [] + else: + self.pi = pi + self.pi_nsprefix_ = None + if rho is None: + self.rho = [] + else: + self.rho = rho + self.rho_nsprefix_ = None + if sigma is None: + self.sigma = [] + else: + self.sigma = sigma + self.sigma_nsprefix_ = None + if tau is None: + self.tau = [] + else: + self.tau = tau + self.tau_nsprefix_ = None + if upsilon is None: + self.upsilon = [] + else: + self.upsilon = upsilon + self.upsilon_nsprefix_ = None + if phi is None: + self.phi = [] + else: + self.phi = phi + self.phi_nsprefix_ = None + if chi is None: + self.chi = [] + else: + self.chi = chi + self.chi_nsprefix_ = None + if psi is None: + self.psi = [] + else: + self.psi = psi + self.psi_nsprefix_ = None + if omega is None: + self.omega = [] + else: + self.omega = omega + self.omega_nsprefix_ = None + if sigmaf is None: + self.sigmaf = [] + else: + self.sigmaf = sigmaf + self.sigmaf_nsprefix_ = None + if sect is None: + self.sect = [] + else: + self.sect = sect + self.sect_nsprefix_ = None + if deg is None: + self.deg = [] + else: + self.deg = deg + self.deg_nsprefix_ = None + if prime is None: + self.prime = [] + else: + self.prime = prime + self.prime_nsprefix_ = None + if Prime is None: + self.Prime = [] + else: + self.Prime = Prime + self.Prime_nsprefix_ = None + if infin is None: + self.infin = [] + else: + self.infin = infin + self.infin_nsprefix_ = None + if empty is None: + self.empty = [] + else: + self.empty = empty + self.empty_nsprefix_ = None + if plusmn is None: + self.plusmn = [] + else: + self.plusmn = plusmn + self.plusmn_nsprefix_ = None + if times is None: + self.times = [] + else: + self.times = times + self.times_nsprefix_ = None + if minus is None: + self.minus = [] + else: + self.minus = minus + self.minus_nsprefix_ = None + if sdot is None: + self.sdot = [] + else: + self.sdot = sdot + self.sdot_nsprefix_ = None + if part is None: + self.part = [] + else: + self.part = part + self.part_nsprefix_ = None + if nabla is None: + self.nabla = [] + else: + self.nabla = nabla + self.nabla_nsprefix_ = None + if radic is None: + self.radic = [] + else: + self.radic = radic + self.radic_nsprefix_ = None + if perp is None: + self.perp = [] + else: + self.perp = perp + self.perp_nsprefix_ = None + if sum is None: + self.sum = [] + else: + self.sum = sum + self.sum_nsprefix_ = None + if int is None: + self.int = [] + else: + self.int = int + self.int_nsprefix_ = None + if prod is None: + self.prod = [] + else: + self.prod = prod + self.prod_nsprefix_ = None + if sim is None: + self.sim = [] + else: + self.sim = sim + self.sim_nsprefix_ = None + if asymp is None: + self.asymp = [] + else: + self.asymp = asymp + self.asymp_nsprefix_ = None + if ne is None: + self.ne = [] + else: + self.ne = ne + self.ne_nsprefix_ = None + if equiv is None: + self.equiv = [] + else: + self.equiv = equiv + self.equiv_nsprefix_ = None + if prop is None: + self.prop = [] + else: + self.prop = prop + self.prop_nsprefix_ = None + if le is None: + self.le = [] + else: + self.le = le + self.le_nsprefix_ = None + if ge is None: + self.ge = [] + else: + self.ge = ge + self.ge_nsprefix_ = None + if larr is None: + self.larr = [] + else: + self.larr = larr + self.larr_nsprefix_ = None + if rarr is None: + self.rarr = [] + else: + self.rarr = rarr + self.rarr_nsprefix_ = None + if isin is None: + self.isin = [] + else: + self.isin = isin + self.isin_nsprefix_ = None + if notin is None: + self.notin = [] + else: + self.notin = notin + self.notin_nsprefix_ = None + if lceil is None: + self.lceil = [] + else: + self.lceil = lceil + self.lceil_nsprefix_ = None + if rceil is None: + self.rceil = [] + else: + self.rceil = rceil + self.rceil_nsprefix_ = None + if lfloor is None: + self.lfloor = [] + else: + self.lfloor = lfloor + self.lfloor_nsprefix_ = None + if rfloor is None: + self.rfloor = [] + else: + self.rfloor = rfloor + self.rfloor_nsprefix_ = None + if linebreak is None: + self.linebreak = [] + else: + self.linebreak = linebreak + self.linebreak_nsprefix_ = None + if hruler is None: + self.hruler = [] + else: + self.hruler = hruler + self.hruler_nsprefix_ = None + if preformatted is None: + self.preformatted = [] + else: + self.preformatted = preformatted + self.preformatted_nsprefix_ = None + if programlisting is None: + self.programlisting = [] + else: + self.programlisting = programlisting + self.programlisting_nsprefix_ = None + if verbatim is None: + self.verbatim = [] + else: + self.verbatim = verbatim + self.verbatim_nsprefix_ = None + if indexentry is None: + self.indexentry = [] + else: + self.indexentry = indexentry + self.indexentry_nsprefix_ = None + if orderedlist is None: + self.orderedlist = [] + else: + self.orderedlist = orderedlist + self.orderedlist_nsprefix_ = None + if itemizedlist is None: + self.itemizedlist = [] + else: + self.itemizedlist = itemizedlist + self.itemizedlist_nsprefix_ = None + if simplesect is None: + self.simplesect = [] + else: + self.simplesect = simplesect + self.simplesect_nsprefix_ = None + if title is None: + self.title = [] + else: + self.title = title + self.title_nsprefix_ = None + if variablelist is None: + self.variablelist = [] + else: + self.variablelist = variablelist + self.variablelist_nsprefix_ = None + if table is None: + self.table = [] + else: + self.table = table + self.table_nsprefix_ = None + if heading is None: + self.heading = [] + else: + self.heading = heading + self.heading_nsprefix_ = None + if image is None: + self.image = [] + else: + self.image = image + self.image_nsprefix_ = None + if dotfile is None: + self.dotfile = [] + else: + self.dotfile = dotfile + self.dotfile_nsprefix_ = None + if mscfile is None: + self.mscfile = [] + else: + self.mscfile = mscfile + self.mscfile_nsprefix_ = None + if diafile is None: + self.diafile = [] + else: + self.diafile = diafile + self.diafile_nsprefix_ = None + if toclist is None: + self.toclist = [] + else: + self.toclist = toclist + self.toclist_nsprefix_ = None + if language is None: + self.language = [] + else: + self.language = language + self.language_nsprefix_ = None + if parameterlist is None: + self.parameterlist = [] + else: + self.parameterlist = parameterlist + self.parameterlist_nsprefix_ = None + if xrefsect is None: + self.xrefsect = [] + else: + self.xrefsect = xrefsect + self.xrefsect_nsprefix_ = None + if copydoc is None: + self.copydoc = [] + else: + self.copydoc = copydoc + self.copydoc_nsprefix_ = None + if blockquote is None: + self.blockquote = [] + else: + self.blockquote = blockquote + self.blockquote_nsprefix_ = None + if parblock is None: + self.parblock = [] + else: + self.parblock = parblock + self.parblock_nsprefix_ = None + self.valueOf_ = valueOf_ + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + self.valueOf_ = valueOf_ + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docParaType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docParaType.subclass: + return docParaType.subclass(*args_, **kwargs_) + return docParaType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + def get_ulink(self): + return self.ulink + def set_ulink(self, ulink): + self.ulink = ulink + def add_ulink(self, value): + self.ulink.append(value) + def insert_ulink_at(self, index, value): + self.ulink.insert(index, value) + def replace_ulink_at(self, index, value): + self.ulink[index] = value + def get_bold(self): + return self.bold + def set_bold(self, bold): + self.bold = bold + def add_bold(self, value): + self.bold.append(value) + def insert_bold_at(self, index, value): + self.bold.insert(index, value) + def replace_bold_at(self, index, value): + self.bold[index] = value + def get_emphasis(self): + return self.emphasis + def set_emphasis(self, emphasis): + self.emphasis = emphasis + def add_emphasis(self, value): + self.emphasis.append(value) + def insert_emphasis_at(self, index, value): + self.emphasis.insert(index, value) + def replace_emphasis_at(self, index, value): + self.emphasis[index] = value + def get_computeroutput(self): + return self.computeroutput + def set_computeroutput(self, computeroutput): + self.computeroutput = computeroutput + def add_computeroutput(self, value): + self.computeroutput.append(value) + def insert_computeroutput_at(self, index, value): + self.computeroutput.insert(index, value) + def replace_computeroutput_at(self, index, value): + self.computeroutput[index] = value + def get_subscript(self): + return self.subscript + def set_subscript(self, subscript): + self.subscript = subscript + def add_subscript(self, value): + self.subscript.append(value) + def insert_subscript_at(self, index, value): + self.subscript.insert(index, value) + def replace_subscript_at(self, index, value): + self.subscript[index] = value + def get_superscript(self): + return self.superscript + def set_superscript(self, superscript): + self.superscript = superscript + def add_superscript(self, value): + self.superscript.append(value) + def insert_superscript_at(self, index, value): + self.superscript.insert(index, value) + def replace_superscript_at(self, index, value): + self.superscript[index] = value + def get_center(self): + return self.center + def set_center(self, center): + self.center = center + def add_center(self, value): + self.center.append(value) + def insert_center_at(self, index, value): + self.center.insert(index, value) + def replace_center_at(self, index, value): + self.center[index] = value + def get_small(self): + return self.small + def set_small(self, small): + self.small = small + def add_small(self, value): + self.small.append(value) + def insert_small_at(self, index, value): + self.small.insert(index, value) + def replace_small_at(self, index, value): + self.small[index] = value + def get_htmlonly(self): + return self.htmlonly + def set_htmlonly(self, htmlonly): + self.htmlonly = htmlonly + def add_htmlonly(self, value): + self.htmlonly.append(value) + def insert_htmlonly_at(self, index, value): + self.htmlonly.insert(index, value) + def replace_htmlonly_at(self, index, value): + self.htmlonly[index] = value + def get_manonly(self): + return self.manonly + def set_manonly(self, manonly): + self.manonly = manonly + def add_manonly(self, value): + self.manonly.append(value) + def insert_manonly_at(self, index, value): + self.manonly.insert(index, value) + def replace_manonly_at(self, index, value): + self.manonly[index] = value + def get_xmlonly(self): + return self.xmlonly + def set_xmlonly(self, xmlonly): + self.xmlonly = xmlonly + def add_xmlonly(self, value): + self.xmlonly.append(value) + def insert_xmlonly_at(self, index, value): + self.xmlonly.insert(index, value) + def replace_xmlonly_at(self, index, value): + self.xmlonly[index] = value + def get_rtfonly(self): + return self.rtfonly + def set_rtfonly(self, rtfonly): + self.rtfonly = rtfonly + def add_rtfonly(self, value): + self.rtfonly.append(value) + def insert_rtfonly_at(self, index, value): + self.rtfonly.insert(index, value) + def replace_rtfonly_at(self, index, value): + self.rtfonly[index] = value + def get_latexonly(self): + return self.latexonly + def set_latexonly(self, latexonly): + self.latexonly = latexonly + def add_latexonly(self, value): + self.latexonly.append(value) + def insert_latexonly_at(self, index, value): + self.latexonly.insert(index, value) + def replace_latexonly_at(self, index, value): + self.latexonly[index] = value + def get_dot(self): + return self.dot + def set_dot(self, dot): + self.dot = dot + def add_dot(self, value): + self.dot.append(value) + def insert_dot_at(self, index, value): + self.dot.insert(index, value) + def replace_dot_at(self, index, value): + self.dot[index] = value + def get_msc(self): + return self.msc + def set_msc(self, msc): + self.msc = msc + def add_msc(self, value): + self.msc.append(value) + def insert_msc_at(self, index, value): + self.msc.insert(index, value) + def replace_msc_at(self, index, value): + self.msc[index] = value + def get_anchor(self): + return self.anchor + def set_anchor(self, anchor): + self.anchor = anchor + def add_anchor(self, value): + self.anchor.append(value) + def insert_anchor_at(self, index, value): + self.anchor.insert(index, value) + def replace_anchor_at(self, index, value): + self.anchor[index] = value + def get_formula(self): + return self.formula + def set_formula(self, formula): + self.formula = formula + def add_formula(self, value): + self.formula.append(value) + def insert_formula_at(self, index, value): + self.formula.insert(index, value) + def replace_formula_at(self, index, value): + self.formula[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_at(self, index, value): + self.ref.insert(index, value) + def replace_ref_at(self, index, value): + self.ref[index] = value + def get_copy(self): + return self.copy + def set_copy(self, copy): + self.copy = copy + def add_copy(self, value): + self.copy.append(value) + def insert_copy_at(self, index, value): + self.copy.insert(index, value) + def replace_copy_at(self, index, value): + self.copy[index] = value + def get_trademark(self): + return self.trademark + def set_trademark(self, trademark): + self.trademark = trademark + def add_trademark(self, value): + self.trademark.append(value) + def insert_trademark_at(self, index, value): + self.trademark.insert(index, value) + def replace_trademark_at(self, index, value): + self.trademark[index] = value + def get_registered(self): + return self.registered + def set_registered(self, registered): + self.registered = registered + def add_registered(self, value): + self.registered.append(value) + def insert_registered_at(self, index, value): + self.registered.insert(index, value) + def replace_registered_at(self, index, value): + self.registered[index] = value + def get_lsquo(self): + return self.lsquo + def set_lsquo(self, lsquo): + self.lsquo = lsquo + def add_lsquo(self, value): + self.lsquo.append(value) + def insert_lsquo_at(self, index, value): + self.lsquo.insert(index, value) + def replace_lsquo_at(self, index, value): + self.lsquo[index] = value + def get_rsquo(self): + return self.rsquo + def set_rsquo(self, rsquo): + self.rsquo = rsquo + def add_rsquo(self, value): + self.rsquo.append(value) + def insert_rsquo_at(self, index, value): + self.rsquo.insert(index, value) + def replace_rsquo_at(self, index, value): + self.rsquo[index] = value + def get_ldquo(self): + return self.ldquo + def set_ldquo(self, ldquo): + self.ldquo = ldquo + def add_ldquo(self, value): + self.ldquo.append(value) + def insert_ldquo_at(self, index, value): + self.ldquo.insert(index, value) + def replace_ldquo_at(self, index, value): + self.ldquo[index] = value + def get_rdquo(self): + return self.rdquo + def set_rdquo(self, rdquo): + self.rdquo = rdquo + def add_rdquo(self, value): + self.rdquo.append(value) + def insert_rdquo_at(self, index, value): + self.rdquo.insert(index, value) + def replace_rdquo_at(self, index, value): + self.rdquo[index] = value + def get_ndash(self): + return self.ndash + def set_ndash(self, ndash): + self.ndash = ndash + def add_ndash(self, value): + self.ndash.append(value) + def insert_ndash_at(self, index, value): + self.ndash.insert(index, value) + def replace_ndash_at(self, index, value): + self.ndash[index] = value + def get_mdash(self): + return self.mdash + def set_mdash(self, mdash): + self.mdash = mdash + def add_mdash(self, value): + self.mdash.append(value) + def insert_mdash_at(self, index, value): + self.mdash.insert(index, value) + def replace_mdash_at(self, index, value): + self.mdash[index] = value + def get_umlaut(self): + return self.umlaut + def set_umlaut(self, umlaut): + self.umlaut = umlaut + def add_umlaut(self, value): + self.umlaut.append(value) + def insert_umlaut_at(self, index, value): + self.umlaut.insert(index, value) + def replace_umlaut_at(self, index, value): + self.umlaut[index] = value + def get_acute(self): + return self.acute + def set_acute(self, acute): + self.acute = acute + def add_acute(self, value): + self.acute.append(value) + def insert_acute_at(self, index, value): + self.acute.insert(index, value) + def replace_acute_at(self, index, value): + self.acute[index] = value + def get_grave(self): + return self.grave + def set_grave(self, grave): + self.grave = grave + def add_grave(self, value): + self.grave.append(value) + def insert_grave_at(self, index, value): + self.grave.insert(index, value) + def replace_grave_at(self, index, value): + self.grave[index] = value + def get_circ(self): + return self.circ + def set_circ(self, circ): + self.circ = circ + def add_circ(self, value): + self.circ.append(value) + def insert_circ_at(self, index, value): + self.circ.insert(index, value) + def replace_circ_at(self, index, value): + self.circ[index] = value + def get_slash(self): + return self.slash + def set_slash(self, slash): + self.slash = slash + def add_slash(self, value): + self.slash.append(value) + def insert_slash_at(self, index, value): + self.slash.insert(index, value) + def replace_slash_at(self, index, value): + self.slash[index] = value + def get_tilde(self): + return self.tilde + def set_tilde(self, tilde): + self.tilde = tilde + def add_tilde(self, value): + self.tilde.append(value) + def insert_tilde_at(self, index, value): + self.tilde.insert(index, value) + def replace_tilde_at(self, index, value): + self.tilde[index] = value + def get_cedil(self): + return self.cedil + def set_cedil(self, cedil): + self.cedil = cedil + def add_cedil(self, value): + self.cedil.append(value) + def insert_cedil_at(self, index, value): + self.cedil.insert(index, value) + def replace_cedil_at(self, index, value): + self.cedil[index] = value + def get_ring(self): + return self.ring + def set_ring(self, ring): + self.ring = ring + def add_ring(self, value): + self.ring.append(value) + def insert_ring_at(self, index, value): + self.ring.insert(index, value) + def replace_ring_at(self, index, value): + self.ring[index] = value + def get_szlig(self): + return self.szlig + def set_szlig(self, szlig): + self.szlig = szlig + def add_szlig(self, value): + self.szlig.append(value) + def insert_szlig_at(self, index, value): + self.szlig.insert(index, value) + def replace_szlig_at(self, index, value): + self.szlig[index] = value + def get_nonbreakablespace(self): + return self.nonbreakablespace + def set_nonbreakablespace(self, nonbreakablespace): + self.nonbreakablespace = nonbreakablespace + def add_nonbreakablespace(self, value): + self.nonbreakablespace.append(value) + def insert_nonbreakablespace_at(self, index, value): + self.nonbreakablespace.insert(index, value) + def replace_nonbreakablespace_at(self, index, value): + self.nonbreakablespace[index] = value + def get_aelig(self): + return self.aelig + def set_aelig(self, aelig): + self.aelig = aelig + def add_aelig(self, value): + self.aelig.append(value) + def insert_aelig_at(self, index, value): + self.aelig.insert(index, value) + def replace_aelig_at(self, index, value): + self.aelig[index] = value + def get_AElig(self): + return self.AElig + def set_AElig(self, AElig): + self.AElig = AElig + def add_AElig(self, value): + self.AElig.append(value) + def insert_AElig_at(self, index, value): + self.AElig.insert(index, value) + def replace_AElig_at(self, index, value): + self.AElig[index] = value + def get_Gamma(self): + return self.Gamma + def set_Gamma(self, Gamma): + self.Gamma = Gamma + def add_Gamma(self, value): + self.Gamma.append(value) + def insert_Gamma_at(self, index, value): + self.Gamma.insert(index, value) + def replace_Gamma_at(self, index, value): + self.Gamma[index] = value + def get_Delta(self): + return self.Delta + def set_Delta(self, Delta): + self.Delta = Delta + def add_Delta(self, value): + self.Delta.append(value) + def insert_Delta_at(self, index, value): + self.Delta.insert(index, value) + def replace_Delta_at(self, index, value): + self.Delta[index] = value + def get_Theta(self): + return self.Theta + def set_Theta(self, Theta): + self.Theta = Theta + def add_Theta(self, value): + self.Theta.append(value) + def insert_Theta_at(self, index, value): + self.Theta.insert(index, value) + def replace_Theta_at(self, index, value): + self.Theta[index] = value + def get_Lambda(self): + return self.Lambda + def set_Lambda(self, Lambda): + self.Lambda = Lambda + def add_Lambda(self, value): + self.Lambda.append(value) + def insert_Lambda_at(self, index, value): + self.Lambda.insert(index, value) + def replace_Lambda_at(self, index, value): + self.Lambda[index] = value + def get_Xi(self): + return self.Xi + def set_Xi(self, Xi): + self.Xi = Xi + def add_Xi(self, value): + self.Xi.append(value) + def insert_Xi_at(self, index, value): + self.Xi.insert(index, value) + def replace_Xi_at(self, index, value): + self.Xi[index] = value + def get_Pi(self): + return self.Pi + def set_Pi(self, Pi): + self.Pi = Pi + def add_Pi(self, value): + self.Pi.append(value) + def insert_Pi_at(self, index, value): + self.Pi.insert(index, value) + def replace_Pi_at(self, index, value): + self.Pi[index] = value + def get_Sigma(self): + return self.Sigma + def set_Sigma(self, Sigma): + self.Sigma = Sigma + def add_Sigma(self, value): + self.Sigma.append(value) + def insert_Sigma_at(self, index, value): + self.Sigma.insert(index, value) + def replace_Sigma_at(self, index, value): + self.Sigma[index] = value + def get_Upsilon(self): + return self.Upsilon + def set_Upsilon(self, Upsilon): + self.Upsilon = Upsilon + def add_Upsilon(self, value): + self.Upsilon.append(value) + def insert_Upsilon_at(self, index, value): + self.Upsilon.insert(index, value) + def replace_Upsilon_at(self, index, value): + self.Upsilon[index] = value + def get_Phi(self): + return self.Phi + def set_Phi(self, Phi): + self.Phi = Phi + def add_Phi(self, value): + self.Phi.append(value) + def insert_Phi_at(self, index, value): + self.Phi.insert(index, value) + def replace_Phi_at(self, index, value): + self.Phi[index] = value + def get_Psi(self): + return self.Psi + def set_Psi(self, Psi): + self.Psi = Psi + def add_Psi(self, value): + self.Psi.append(value) + def insert_Psi_at(self, index, value): + self.Psi.insert(index, value) + def replace_Psi_at(self, index, value): + self.Psi[index] = value + def get_Omega(self): + return self.Omega + def set_Omega(self, Omega): + self.Omega = Omega + def add_Omega(self, value): + self.Omega.append(value) + def insert_Omega_at(self, index, value): + self.Omega.insert(index, value) + def replace_Omega_at(self, index, value): + self.Omega[index] = value + def get_alpha(self): + return self.alpha + def set_alpha(self, alpha): + self.alpha = alpha + def add_alpha(self, value): + self.alpha.append(value) + def insert_alpha_at(self, index, value): + self.alpha.insert(index, value) + def replace_alpha_at(self, index, value): + self.alpha[index] = value + def get_beta(self): + return self.beta + def set_beta(self, beta): + self.beta = beta + def add_beta(self, value): + self.beta.append(value) + def insert_beta_at(self, index, value): + self.beta.insert(index, value) + def replace_beta_at(self, index, value): + self.beta[index] = value + def get_gamma(self): + return self.gamma + def set_gamma(self, gamma): + self.gamma = gamma + def add_gamma(self, value): + self.gamma.append(value) + def insert_gamma_at(self, index, value): + self.gamma.insert(index, value) + def replace_gamma_at(self, index, value): + self.gamma[index] = value + def get_delta(self): + return self.delta + def set_delta(self, delta): + self.delta = delta + def add_delta(self, value): + self.delta.append(value) + def insert_delta_at(self, index, value): + self.delta.insert(index, value) + def replace_delta_at(self, index, value): + self.delta[index] = value + def get_epsilon(self): + return self.epsilon + def set_epsilon(self, epsilon): + self.epsilon = epsilon + def add_epsilon(self, value): + self.epsilon.append(value) + def insert_epsilon_at(self, index, value): + self.epsilon.insert(index, value) + def replace_epsilon_at(self, index, value): + self.epsilon[index] = value + def get_zeta(self): + return self.zeta + def set_zeta(self, zeta): + self.zeta = zeta + def add_zeta(self, value): + self.zeta.append(value) + def insert_zeta_at(self, index, value): + self.zeta.insert(index, value) + def replace_zeta_at(self, index, value): + self.zeta[index] = value + def get_eta(self): + return self.eta + def set_eta(self, eta): + self.eta = eta + def add_eta(self, value): + self.eta.append(value) + def insert_eta_at(self, index, value): + self.eta.insert(index, value) + def replace_eta_at(self, index, value): + self.eta[index] = value + def get_theta(self): + return self.theta + def set_theta(self, theta): + self.theta = theta + def add_theta(self, value): + self.theta.append(value) + def insert_theta_at(self, index, value): + self.theta.insert(index, value) + def replace_theta_at(self, index, value): + self.theta[index] = value + def get_iota(self): + return self.iota + def set_iota(self, iota): + self.iota = iota + def add_iota(self, value): + self.iota.append(value) + def insert_iota_at(self, index, value): + self.iota.insert(index, value) + def replace_iota_at(self, index, value): + self.iota[index] = value + def get_kappa(self): + return self.kappa + def set_kappa(self, kappa): + self.kappa = kappa + def add_kappa(self, value): + self.kappa.append(value) + def insert_kappa_at(self, index, value): + self.kappa.insert(index, value) + def replace_kappa_at(self, index, value): + self.kappa[index] = value + def get_lambda(self): + return self.lambda_ + def set_lambda(self, lambda_): + self.lambda_ = lambda_ + def add_lambda(self, value): + self.lambda_.append(value) + def insert_lambda_at(self, index, value): + self.lambda_.insert(index, value) + def replace_lambda_at(self, index, value): + self.lambda_[index] = value + def get_mu(self): + return self.mu + def set_mu(self, mu): + self.mu = mu + def add_mu(self, value): + self.mu.append(value) + def insert_mu_at(self, index, value): + self.mu.insert(index, value) + def replace_mu_at(self, index, value): + self.mu[index] = value + def get_nu(self): + return self.nu + def set_nu(self, nu): + self.nu = nu + def add_nu(self, value): + self.nu.append(value) + def insert_nu_at(self, index, value): + self.nu.insert(index, value) + def replace_nu_at(self, index, value): + self.nu[index] = value + def get_xi(self): + return self.xi + def set_xi(self, xi): + self.xi = xi + def add_xi(self, value): + self.xi.append(value) + def insert_xi_at(self, index, value): + self.xi.insert(index, value) + def replace_xi_at(self, index, value): + self.xi[index] = value + def get_pi(self): + return self.pi + def set_pi(self, pi): + self.pi = pi + def add_pi(self, value): + self.pi.append(value) + def insert_pi_at(self, index, value): + self.pi.insert(index, value) + def replace_pi_at(self, index, value): + self.pi[index] = value + def get_rho(self): + return self.rho + def set_rho(self, rho): + self.rho = rho + def add_rho(self, value): + self.rho.append(value) + def insert_rho_at(self, index, value): + self.rho.insert(index, value) + def replace_rho_at(self, index, value): + self.rho[index] = value + def get_sigma(self): + return self.sigma + def set_sigma(self, sigma): + self.sigma = sigma + def add_sigma(self, value): + self.sigma.append(value) + def insert_sigma_at(self, index, value): + self.sigma.insert(index, value) + def replace_sigma_at(self, index, value): + self.sigma[index] = value + def get_tau(self): + return self.tau + def set_tau(self, tau): + self.tau = tau + def add_tau(self, value): + self.tau.append(value) + def insert_tau_at(self, index, value): + self.tau.insert(index, value) + def replace_tau_at(self, index, value): + self.tau[index] = value + def get_upsilon(self): + return self.upsilon + def set_upsilon(self, upsilon): + self.upsilon = upsilon + def add_upsilon(self, value): + self.upsilon.append(value) + def insert_upsilon_at(self, index, value): + self.upsilon.insert(index, value) + def replace_upsilon_at(self, index, value): + self.upsilon[index] = value + def get_phi(self): + return self.phi + def set_phi(self, phi): + self.phi = phi + def add_phi(self, value): + self.phi.append(value) + def insert_phi_at(self, index, value): + self.phi.insert(index, value) + def replace_phi_at(self, index, value): + self.phi[index] = value + def get_chi(self): + return self.chi + def set_chi(self, chi): + self.chi = chi + def add_chi(self, value): + self.chi.append(value) + def insert_chi_at(self, index, value): + self.chi.insert(index, value) + def replace_chi_at(self, index, value): + self.chi[index] = value + def get_psi(self): + return self.psi + def set_psi(self, psi): + self.psi = psi + def add_psi(self, value): + self.psi.append(value) + def insert_psi_at(self, index, value): + self.psi.insert(index, value) + def replace_psi_at(self, index, value): + self.psi[index] = value + def get_omega(self): + return self.omega + def set_omega(self, omega): + self.omega = omega + def add_omega(self, value): + self.omega.append(value) + def insert_omega_at(self, index, value): + self.omega.insert(index, value) + def replace_omega_at(self, index, value): + self.omega[index] = value + def get_sigmaf(self): + return self.sigmaf + def set_sigmaf(self, sigmaf): + self.sigmaf = sigmaf + def add_sigmaf(self, value): + self.sigmaf.append(value) + def insert_sigmaf_at(self, index, value): + self.sigmaf.insert(index, value) + def replace_sigmaf_at(self, index, value): + self.sigmaf[index] = value + def get_sect(self): + return self.sect + def set_sect(self, sect): + self.sect = sect + def add_sect(self, value): + self.sect.append(value) + def insert_sect_at(self, index, value): + self.sect.insert(index, value) + def replace_sect_at(self, index, value): + self.sect[index] = value + def get_deg(self): + return self.deg + def set_deg(self, deg): + self.deg = deg + def add_deg(self, value): + self.deg.append(value) + def insert_deg_at(self, index, value): + self.deg.insert(index, value) + def replace_deg_at(self, index, value): + self.deg[index] = value + def get_prime(self): + return self.prime + def set_prime(self, prime): + self.prime = prime + def add_prime(self, value): + self.prime.append(value) + def insert_prime_at(self, index, value): + self.prime.insert(index, value) + def replace_prime_at(self, index, value): + self.prime[index] = value + def get_Prime(self): + return self.Prime + def set_Prime(self, Prime): + self.Prime = Prime + def add_Prime(self, value): + self.Prime.append(value) + def insert_Prime_at(self, index, value): + self.Prime.insert(index, value) + def replace_Prime_at(self, index, value): + self.Prime[index] = value + def get_infin(self): + return self.infin + def set_infin(self, infin): + self.infin = infin + def add_infin(self, value): + self.infin.append(value) + def insert_infin_at(self, index, value): + self.infin.insert(index, value) + def replace_infin_at(self, index, value): + self.infin[index] = value + def get_empty(self): + return self.empty + def set_empty(self, empty): + self.empty = empty + def add_empty(self, value): + self.empty.append(value) + def insert_empty_at(self, index, value): + self.empty.insert(index, value) + def replace_empty_at(self, index, value): + self.empty[index] = value + def get_plusmn(self): + return self.plusmn + def set_plusmn(self, plusmn): + self.plusmn = plusmn + def add_plusmn(self, value): + self.plusmn.append(value) + def insert_plusmn_at(self, index, value): + self.plusmn.insert(index, value) + def replace_plusmn_at(self, index, value): + self.plusmn[index] = value + def get_times(self): + return self.times + def set_times(self, times): + self.times = times + def add_times(self, value): + self.times.append(value) + def insert_times_at(self, index, value): + self.times.insert(index, value) + def replace_times_at(self, index, value): + self.times[index] = value + def get_minus(self): + return self.minus + def set_minus(self, minus): + self.minus = minus + def add_minus(self, value): + self.minus.append(value) + def insert_minus_at(self, index, value): + self.minus.insert(index, value) + def replace_minus_at(self, index, value): + self.minus[index] = value + def get_sdot(self): + return self.sdot + def set_sdot(self, sdot): + self.sdot = sdot + def add_sdot(self, value): + self.sdot.append(value) + def insert_sdot_at(self, index, value): + self.sdot.insert(index, value) + def replace_sdot_at(self, index, value): + self.sdot[index] = value + def get_part(self): + return self.part + def set_part(self, part): + self.part = part + def add_part(self, value): + self.part.append(value) + def insert_part_at(self, index, value): + self.part.insert(index, value) + def replace_part_at(self, index, value): + self.part[index] = value + def get_nabla(self): + return self.nabla + def set_nabla(self, nabla): + self.nabla = nabla + def add_nabla(self, value): + self.nabla.append(value) + def insert_nabla_at(self, index, value): + self.nabla.insert(index, value) + def replace_nabla_at(self, index, value): + self.nabla[index] = value + def get_radic(self): + return self.radic + def set_radic(self, radic): + self.radic = radic + def add_radic(self, value): + self.radic.append(value) + def insert_radic_at(self, index, value): + self.radic.insert(index, value) + def replace_radic_at(self, index, value): + self.radic[index] = value + def get_perp(self): + return self.perp + def set_perp(self, perp): + self.perp = perp + def add_perp(self, value): + self.perp.append(value) + def insert_perp_at(self, index, value): + self.perp.insert(index, value) + def replace_perp_at(self, index, value): + self.perp[index] = value + def get_sum(self): + return self.sum + def set_sum(self, sum): + self.sum = sum + def add_sum(self, value): + self.sum.append(value) + def insert_sum_at(self, index, value): + self.sum.insert(index, value) + def replace_sum_at(self, index, value): + self.sum[index] = value + def get_int(self): + return self.int + def set_int(self, int): + self.int = int + def add_int(self, value): + self.int.append(value) + def insert_int_at(self, index, value): + self.int.insert(index, value) + def replace_int_at(self, index, value): + self.int[index] = value + def get_prod(self): + return self.prod + def set_prod(self, prod): + self.prod = prod + def add_prod(self, value): + self.prod.append(value) + def insert_prod_at(self, index, value): + self.prod.insert(index, value) + def replace_prod_at(self, index, value): + self.prod[index] = value + def get_sim(self): + return self.sim + def set_sim(self, sim): + self.sim = sim + def add_sim(self, value): + self.sim.append(value) + def insert_sim_at(self, index, value): + self.sim.insert(index, value) + def replace_sim_at(self, index, value): + self.sim[index] = value + def get_asymp(self): + return self.asymp + def set_asymp(self, asymp): + self.asymp = asymp + def add_asymp(self, value): + self.asymp.append(value) + def insert_asymp_at(self, index, value): + self.asymp.insert(index, value) + def replace_asymp_at(self, index, value): + self.asymp[index] = value + def get_ne(self): + return self.ne + def set_ne(self, ne): + self.ne = ne + def add_ne(self, value): + self.ne.append(value) + def insert_ne_at(self, index, value): + self.ne.insert(index, value) + def replace_ne_at(self, index, value): + self.ne[index] = value + def get_equiv(self): + return self.equiv + def set_equiv(self, equiv): + self.equiv = equiv + def add_equiv(self, value): + self.equiv.append(value) + def insert_equiv_at(self, index, value): + self.equiv.insert(index, value) + def replace_equiv_at(self, index, value): + self.equiv[index] = value + def get_prop(self): + return self.prop + def set_prop(self, prop): + self.prop = prop + def add_prop(self, value): + self.prop.append(value) + def insert_prop_at(self, index, value): + self.prop.insert(index, value) + def replace_prop_at(self, index, value): + self.prop[index] = value + def get_le(self): + return self.le + def set_le(self, le): + self.le = le + def add_le(self, value): + self.le.append(value) + def insert_le_at(self, index, value): + self.le.insert(index, value) + def replace_le_at(self, index, value): + self.le[index] = value + def get_ge(self): + return self.ge + def set_ge(self, ge): + self.ge = ge + def add_ge(self, value): + self.ge.append(value) + def insert_ge_at(self, index, value): + self.ge.insert(index, value) + def replace_ge_at(self, index, value): + self.ge[index] = value + def get_larr(self): + return self.larr + def set_larr(self, larr): + self.larr = larr + def add_larr(self, value): + self.larr.append(value) + def insert_larr_at(self, index, value): + self.larr.insert(index, value) + def replace_larr_at(self, index, value): + self.larr[index] = value + def get_rarr(self): + return self.rarr + def set_rarr(self, rarr): + self.rarr = rarr + def add_rarr(self, value): + self.rarr.append(value) + def insert_rarr_at(self, index, value): + self.rarr.insert(index, value) + def replace_rarr_at(self, index, value): + self.rarr[index] = value + def get_isin(self): + return self.isin + def set_isin(self, isin): + self.isin = isin + def add_isin(self, value): + self.isin.append(value) + def insert_isin_at(self, index, value): + self.isin.insert(index, value) + def replace_isin_at(self, index, value): + self.isin[index] = value + def get_notin(self): + return self.notin + def set_notin(self, notin): + self.notin = notin + def add_notin(self, value): + self.notin.append(value) + def insert_notin_at(self, index, value): + self.notin.insert(index, value) + def replace_notin_at(self, index, value): + self.notin[index] = value + def get_lceil(self): + return self.lceil + def set_lceil(self, lceil): + self.lceil = lceil + def add_lceil(self, value): + self.lceil.append(value) + def insert_lceil_at(self, index, value): + self.lceil.insert(index, value) + def replace_lceil_at(self, index, value): + self.lceil[index] = value + def get_rceil(self): + return self.rceil + def set_rceil(self, rceil): + self.rceil = rceil + def add_rceil(self, value): + self.rceil.append(value) + def insert_rceil_at(self, index, value): + self.rceil.insert(index, value) + def replace_rceil_at(self, index, value): + self.rceil[index] = value + def get_lfloor(self): + return self.lfloor + def set_lfloor(self, lfloor): + self.lfloor = lfloor + def add_lfloor(self, value): + self.lfloor.append(value) + def insert_lfloor_at(self, index, value): + self.lfloor.insert(index, value) + def replace_lfloor_at(self, index, value): + self.lfloor[index] = value + def get_rfloor(self): + return self.rfloor + def set_rfloor(self, rfloor): + self.rfloor = rfloor + def add_rfloor(self, value): + self.rfloor.append(value) + def insert_rfloor_at(self, index, value): + self.rfloor.insert(index, value) + def replace_rfloor_at(self, index, value): + self.rfloor[index] = value + def get_linebreak(self): + return self.linebreak + def set_linebreak(self, linebreak): + self.linebreak = linebreak + def add_linebreak(self, value): + self.linebreak.append(value) + def insert_linebreak_at(self, index, value): + self.linebreak.insert(index, value) + def replace_linebreak_at(self, index, value): + self.linebreak[index] = value + def get_hruler(self): + return self.hruler + def set_hruler(self, hruler): + self.hruler = hruler + def add_hruler(self, value): + self.hruler.append(value) + def insert_hruler_at(self, index, value): + self.hruler.insert(index, value) + def replace_hruler_at(self, index, value): + self.hruler[index] = value + def get_preformatted(self): + return self.preformatted + def set_preformatted(self, preformatted): + self.preformatted = preformatted + def add_preformatted(self, value): + self.preformatted.append(value) + def insert_preformatted_at(self, index, value): + self.preformatted.insert(index, value) + def replace_preformatted_at(self, index, value): + self.preformatted[index] = value + def get_programlisting(self): + return self.programlisting + def set_programlisting(self, programlisting): + self.programlisting = programlisting + def add_programlisting(self, value): + self.programlisting.append(value) + def insert_programlisting_at(self, index, value): + self.programlisting.insert(index, value) + def replace_programlisting_at(self, index, value): + self.programlisting[index] = value + def get_verbatim(self): + return self.verbatim + def set_verbatim(self, verbatim): + self.verbatim = verbatim + def add_verbatim(self, value): + self.verbatim.append(value) + def insert_verbatim_at(self, index, value): + self.verbatim.insert(index, value) + def replace_verbatim_at(self, index, value): + self.verbatim[index] = value + def get_indexentry(self): + return self.indexentry + def set_indexentry(self, indexentry): + self.indexentry = indexentry + def add_indexentry(self, value): + self.indexentry.append(value) + def insert_indexentry_at(self, index, value): + self.indexentry.insert(index, value) + def replace_indexentry_at(self, index, value): + self.indexentry[index] = value + def get_orderedlist(self): + return self.orderedlist + def set_orderedlist(self, orderedlist): + self.orderedlist = orderedlist + def add_orderedlist(self, value): + self.orderedlist.append(value) + def insert_orderedlist_at(self, index, value): + self.orderedlist.insert(index, value) + def replace_orderedlist_at(self, index, value): + self.orderedlist[index] = value + def get_itemizedlist(self): + return self.itemizedlist + def set_itemizedlist(self, itemizedlist): + self.itemizedlist = itemizedlist + def add_itemizedlist(self, value): + self.itemizedlist.append(value) + def insert_itemizedlist_at(self, index, value): + self.itemizedlist.insert(index, value) + def replace_itemizedlist_at(self, index, value): + self.itemizedlist[index] = value + def get_simplesect(self): + return self.simplesect + def set_simplesect(self, simplesect): + self.simplesect = simplesect + def add_simplesect(self, value): + self.simplesect.append(value) + def insert_simplesect_at(self, index, value): + self.simplesect.insert(index, value) + def replace_simplesect_at(self, index, value): + self.simplesect[index] = value + def get_title(self): + return self.title + def set_title(self, title): + self.title = title + def add_title(self, value): + self.title.append(value) + def insert_title_at(self, index, value): + self.title.insert(index, value) + def replace_title_at(self, index, value): + self.title[index] = value + def get_variablelist(self): + return self.variablelist + def set_variablelist(self, variablelist): + self.variablelist = variablelist + def add_variablelist(self, value): + self.variablelist.append(value) + def insert_variablelist_at(self, index, value): + self.variablelist.insert(index, value) + def replace_variablelist_at(self, index, value): + self.variablelist[index] = value + def get_table(self): + return self.table + def set_table(self, table): + self.table = table + def add_table(self, value): + self.table.append(value) + def insert_table_at(self, index, value): + self.table.insert(index, value) + def replace_table_at(self, index, value): + self.table[index] = value + def get_heading(self): + return self.heading + def set_heading(self, heading): + self.heading = heading + def add_heading(self, value): + self.heading.append(value) + def insert_heading_at(self, index, value): + self.heading.insert(index, value) + def replace_heading_at(self, index, value): + self.heading[index] = value + def get_image(self): + return self.image + def set_image(self, image): + self.image = image + def add_image(self, value): + self.image.append(value) + def insert_image_at(self, index, value): + self.image.insert(index, value) + def replace_image_at(self, index, value): + self.image[index] = value + def get_dotfile(self): + return self.dotfile + def set_dotfile(self, dotfile): + self.dotfile = dotfile + def add_dotfile(self, value): + self.dotfile.append(value) + def insert_dotfile_at(self, index, value): + self.dotfile.insert(index, value) + def replace_dotfile_at(self, index, value): + self.dotfile[index] = value + def get_mscfile(self): + return self.mscfile + def set_mscfile(self, mscfile): + self.mscfile = mscfile + def add_mscfile(self, value): + self.mscfile.append(value) + def insert_mscfile_at(self, index, value): + self.mscfile.insert(index, value) + def replace_mscfile_at(self, index, value): + self.mscfile[index] = value + def get_diafile(self): + return self.diafile + def set_diafile(self, diafile): + self.diafile = diafile + def add_diafile(self, value): + self.diafile.append(value) + def insert_diafile_at(self, index, value): + self.diafile.insert(index, value) + def replace_diafile_at(self, index, value): + self.diafile[index] = value + def get_toclist(self): + return self.toclist + def set_toclist(self, toclist): + self.toclist = toclist + def add_toclist(self, value): + self.toclist.append(value) + def insert_toclist_at(self, index, value): + self.toclist.insert(index, value) + def replace_toclist_at(self, index, value): + self.toclist[index] = value + def get_language(self): + return self.language + def set_language(self, language): + self.language = language + def add_language(self, value): + self.language.append(value) + def insert_language_at(self, index, value): + self.language.insert(index, value) + def replace_language_at(self, index, value): + self.language[index] = value + def get_parameterlist(self): + return self.parameterlist + def set_parameterlist(self, parameterlist): + self.parameterlist = parameterlist + def add_parameterlist(self, value): + self.parameterlist.append(value) + def insert_parameterlist_at(self, index, value): + self.parameterlist.insert(index, value) + def replace_parameterlist_at(self, index, value): + self.parameterlist[index] = value + def get_xrefsect(self): + return self.xrefsect + def set_xrefsect(self, xrefsect): + self.xrefsect = xrefsect + def add_xrefsect(self, value): + self.xrefsect.append(value) + def insert_xrefsect_at(self, index, value): + self.xrefsect.insert(index, value) + def replace_xrefsect_at(self, index, value): + self.xrefsect[index] = value + def get_copydoc(self): + return self.copydoc + def set_copydoc(self, copydoc): + self.copydoc = copydoc + def add_copydoc(self, value): + self.copydoc.append(value) + def insert_copydoc_at(self, index, value): + self.copydoc.insert(index, value) + def replace_copydoc_at(self, index, value): + self.copydoc[index] = value + def get_blockquote(self): + return self.blockquote + def set_blockquote(self, blockquote): + self.blockquote = blockquote + def add_blockquote(self, value): + self.blockquote.append(value) + def insert_blockquote_at(self, index, value): + self.blockquote.insert(index, value) + def replace_blockquote_at(self, index, value): + self.blockquote[index] = value + def get_parblock(self): + return self.parblock + def set_parblock(self, parblock): + self.parblock = parblock + def add_parblock(self, value): + self.parblock.append(value) + def insert_parblock_at(self, index, value): + self.parblock.insert(index, value) + def replace_parblock_at(self, index, value): + self.parblock[index] = value + def get_valueOf_(self): return self.valueOf_ + def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def hasContent_(self): + if ( + self.ulink or + self.bold or + self.emphasis or + self.computeroutput or + self.subscript or + self.superscript or + self.center or + self.small or + self.htmlonly or + self.manonly or + self.xmlonly or + self.rtfonly or + self.latexonly or + self.dot or + self.msc or + self.anchor or + self.formula or + self.ref or + self.copy or + self.trademark or + self.registered or + self.lsquo or + self.rsquo or + self.ldquo or + self.rdquo or + self.ndash or + self.mdash or + self.umlaut or + self.acute or + self.grave or + self.circ or + self.slash or + self.tilde or + self.cedil or + self.ring or + self.szlig or + self.nonbreakablespace or + self.aelig or + self.AElig or + self.Gamma or + self.Delta or + self.Theta or + self.Lambda or + self.Xi or + self.Pi or + self.Sigma or + self.Upsilon or + self.Phi or + self.Psi or + self.Omega or + self.alpha or + self.beta or + self.gamma or + self.delta or + self.epsilon or + self.zeta or + self.eta or + self.theta or + self.iota or + self.kappa or + self.lambda_ or + self.mu or + self.nu or + self.xi or + self.pi or + self.rho or + self.sigma or + self.tau or + self.upsilon or + self.phi or + self.chi or + self.psi or + self.omega or + self.sigmaf or + self.sect or + self.deg or + self.prime or + self.Prime or + self.infin or + self.empty or + self.plusmn or + self.times or + self.minus or + self.sdot or + self.part or + self.nabla or + self.radic or + self.perp or + self.sum or + self.int or + self.prod or + self.sim or + self.asymp or + self.ne or + self.equiv or + self.prop or + self.le or + self.ge or + self.larr or + self.rarr or + self.isin or + self.notin or + self.lceil or + self.rceil or + self.lfloor or + self.rfloor or + self.linebreak or + self.hruler or + self.preformatted or + self.programlisting or + self.verbatim or + self.indexentry or + self.orderedlist or + self.itemizedlist or + self.simplesect or + self.title or + self.variablelist or + self.table or + self.heading or + self.image or + self.dotfile or + self.mscfile or + self.diafile or + self.toclist or + self.language or + self.parameterlist or + self.xrefsect or + self.copydoc or + self.blockquote or + self.parblock or + (1 if type(self.valueOf_) in [int,float] else self.valueOf_) or + self.content_ + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docParaType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docParaType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docParaType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docParaType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docParaType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docParaType'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docParaType', fromsubclass_=False, pretty_print=True): + if not fromsubclass_: + for item_ in self.content_: + item_.export(outfile, level, item_.name, namespaceprefix_, pretty_print=pretty_print) + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for ulink_ in self.ulink: + namespaceprefix_ = self.ulink_nsprefix_ + ':' if (UseCapturedNS_ and self.ulink_nsprefix_) else '' + ulink_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ulink', pretty_print=pretty_print) + for bold_ in self.bold: + namespaceprefix_ = self.bold_nsprefix_ + ':' if (UseCapturedNS_ and self.bold_nsprefix_) else '' + bold_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='bold', pretty_print=pretty_print) + for emphasis_ in self.emphasis: + namespaceprefix_ = self.emphasis_nsprefix_ + ':' if (UseCapturedNS_ and self.emphasis_nsprefix_) else '' + emphasis_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='emphasis', pretty_print=pretty_print) + for computeroutput_ in self.computeroutput: + namespaceprefix_ = self.computeroutput_nsprefix_ + ':' if (UseCapturedNS_ and self.computeroutput_nsprefix_) else '' + computeroutput_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='computeroutput', pretty_print=pretty_print) + for subscript_ in self.subscript: + namespaceprefix_ = self.subscript_nsprefix_ + ':' if (UseCapturedNS_ and self.subscript_nsprefix_) else '' + subscript_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='subscript', pretty_print=pretty_print) + for superscript_ in self.superscript: + namespaceprefix_ = self.superscript_nsprefix_ + ':' if (UseCapturedNS_ and self.superscript_nsprefix_) else '' + superscript_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='superscript', pretty_print=pretty_print) + for center_ in self.center: + namespaceprefix_ = self.center_nsprefix_ + ':' if (UseCapturedNS_ and self.center_nsprefix_) else '' + center_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='center', pretty_print=pretty_print) + for small_ in self.small: + namespaceprefix_ = self.small_nsprefix_ + ':' if (UseCapturedNS_ and self.small_nsprefix_) else '' + small_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='small', pretty_print=pretty_print) + for htmlonly_ in self.htmlonly: + namespaceprefix_ = self.htmlonly_nsprefix_ + ':' if (UseCapturedNS_ and self.htmlonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%shtmlonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(htmlonly_), input_name='htmlonly')), namespaceprefix_ , eol_)) + for manonly_ in self.manonly: + namespaceprefix_ = self.manonly_nsprefix_ + ':' if (UseCapturedNS_ and self.manonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%smanonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(manonly_), input_name='manonly')), namespaceprefix_ , eol_)) + for xmlonly_ in self.xmlonly: + namespaceprefix_ = self.xmlonly_nsprefix_ + ':' if (UseCapturedNS_ and self.xmlonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%sxmlonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(xmlonly_), input_name='xmlonly')), namespaceprefix_ , eol_)) + for rtfonly_ in self.rtfonly: + namespaceprefix_ = self.rtfonly_nsprefix_ + ':' if (UseCapturedNS_ and self.rtfonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%srtfonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(rtfonly_), input_name='rtfonly')), namespaceprefix_ , eol_)) + for latexonly_ in self.latexonly: + namespaceprefix_ = self.latexonly_nsprefix_ + ':' if (UseCapturedNS_ and self.latexonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%slatexonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(latexonly_), input_name='latexonly')), namespaceprefix_ , eol_)) + for dot_ in self.dot: + namespaceprefix_ = self.dot_nsprefix_ + ':' if (UseCapturedNS_ and self.dot_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%sdot>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(dot_), input_name='dot')), namespaceprefix_ , eol_)) + for msc_ in self.msc: + namespaceprefix_ = self.msc_nsprefix_ + ':' if (UseCapturedNS_ and self.msc_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%smsc>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(msc_), input_name='msc')), namespaceprefix_ , eol_)) + for anchor_ in self.anchor: + namespaceprefix_ = self.anchor_nsprefix_ + ':' if (UseCapturedNS_ and self.anchor_nsprefix_) else '' + anchor_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='anchor', pretty_print=pretty_print) + for formula_ in self.formula: + namespaceprefix_ = self.formula_nsprefix_ + ':' if (UseCapturedNS_ and self.formula_nsprefix_) else '' + formula_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='formula', pretty_print=pretty_print) + for ref_ in self.ref: + namespaceprefix_ = self.ref_nsprefix_ + ':' if (UseCapturedNS_ and self.ref_nsprefix_) else '' + ref_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ref', pretty_print=pretty_print) + for copy_ in self.copy: + namespaceprefix_ = self.copy_nsprefix_ + ':' if (UseCapturedNS_ and self.copy_nsprefix_) else '' + copy_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='copy', pretty_print=pretty_print) + for trademark_ in self.trademark: + namespaceprefix_ = self.trademark_nsprefix_ + ':' if (UseCapturedNS_ and self.trademark_nsprefix_) else '' + trademark_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='trademark', pretty_print=pretty_print) + for registered_ in self.registered: + namespaceprefix_ = self.registered_nsprefix_ + ':' if (UseCapturedNS_ and self.registered_nsprefix_) else '' + registered_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='registered', pretty_print=pretty_print) + for lsquo_ in self.lsquo: + namespaceprefix_ = self.lsquo_nsprefix_ + ':' if (UseCapturedNS_ and self.lsquo_nsprefix_) else '' + lsquo_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='lsquo', pretty_print=pretty_print) + for rsquo_ in self.rsquo: + namespaceprefix_ = self.rsquo_nsprefix_ + ':' if (UseCapturedNS_ and self.rsquo_nsprefix_) else '' + rsquo_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rsquo', pretty_print=pretty_print) + for ldquo_ in self.ldquo: + namespaceprefix_ = self.ldquo_nsprefix_ + ':' if (UseCapturedNS_ and self.ldquo_nsprefix_) else '' + ldquo_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ldquo', pretty_print=pretty_print) + for rdquo_ in self.rdquo: + namespaceprefix_ = self.rdquo_nsprefix_ + ':' if (UseCapturedNS_ and self.rdquo_nsprefix_) else '' + rdquo_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rdquo', pretty_print=pretty_print) + for ndash_ in self.ndash: + namespaceprefix_ = self.ndash_nsprefix_ + ':' if (UseCapturedNS_ and self.ndash_nsprefix_) else '' + ndash_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ndash', pretty_print=pretty_print) + for mdash_ in self.mdash: + namespaceprefix_ = self.mdash_nsprefix_ + ':' if (UseCapturedNS_ and self.mdash_nsprefix_) else '' + mdash_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='mdash', pretty_print=pretty_print) + for umlaut_ in self.umlaut: + namespaceprefix_ = self.umlaut_nsprefix_ + ':' if (UseCapturedNS_ and self.umlaut_nsprefix_) else '' + umlaut_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='umlaut', pretty_print=pretty_print) + for acute_ in self.acute: + namespaceprefix_ = self.acute_nsprefix_ + ':' if (UseCapturedNS_ and self.acute_nsprefix_) else '' + acute_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='acute', pretty_print=pretty_print) + for grave_ in self.grave: + namespaceprefix_ = self.grave_nsprefix_ + ':' if (UseCapturedNS_ and self.grave_nsprefix_) else '' + grave_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='grave', pretty_print=pretty_print) + for circ_ in self.circ: + namespaceprefix_ = self.circ_nsprefix_ + ':' if (UseCapturedNS_ and self.circ_nsprefix_) else '' + circ_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='circ', pretty_print=pretty_print) + for slash_ in self.slash: + namespaceprefix_ = self.slash_nsprefix_ + ':' if (UseCapturedNS_ and self.slash_nsprefix_) else '' + slash_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='slash', pretty_print=pretty_print) + for tilde_ in self.tilde: + namespaceprefix_ = self.tilde_nsprefix_ + ':' if (UseCapturedNS_ and self.tilde_nsprefix_) else '' + tilde_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='tilde', pretty_print=pretty_print) + for cedil_ in self.cedil: + namespaceprefix_ = self.cedil_nsprefix_ + ':' if (UseCapturedNS_ and self.cedil_nsprefix_) else '' + cedil_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='cedil', pretty_print=pretty_print) + for ring_ in self.ring: + namespaceprefix_ = self.ring_nsprefix_ + ':' if (UseCapturedNS_ and self.ring_nsprefix_) else '' + ring_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ring', pretty_print=pretty_print) + for szlig_ in self.szlig: + namespaceprefix_ = self.szlig_nsprefix_ + ':' if (UseCapturedNS_ and self.szlig_nsprefix_) else '' + szlig_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='szlig', pretty_print=pretty_print) + for nonbreakablespace_ in self.nonbreakablespace: + namespaceprefix_ = self.nonbreakablespace_nsprefix_ + ':' if (UseCapturedNS_ and self.nonbreakablespace_nsprefix_) else '' + nonbreakablespace_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='nonbreakablespace', pretty_print=pretty_print) + for aelig_ in self.aelig: + namespaceprefix_ = self.aelig_nsprefix_ + ':' if (UseCapturedNS_ and self.aelig_nsprefix_) else '' + aelig_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='aelig', pretty_print=pretty_print) + for AElig_ in self.AElig: + namespaceprefix_ = self.AElig_nsprefix_ + ':' if (UseCapturedNS_ and self.AElig_nsprefix_) else '' + AElig_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='AElig', pretty_print=pretty_print) + for Gamma_ in self.Gamma: + namespaceprefix_ = self.Gamma_nsprefix_ + ':' if (UseCapturedNS_ and self.Gamma_nsprefix_) else '' + Gamma_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Gamma', pretty_print=pretty_print) + for Delta_ in self.Delta: + namespaceprefix_ = self.Delta_nsprefix_ + ':' if (UseCapturedNS_ and self.Delta_nsprefix_) else '' + Delta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Delta', pretty_print=pretty_print) + for Theta_ in self.Theta: + namespaceprefix_ = self.Theta_nsprefix_ + ':' if (UseCapturedNS_ and self.Theta_nsprefix_) else '' + Theta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Theta', pretty_print=pretty_print) + for Lambda_ in self.Lambda: + namespaceprefix_ = self.Lambda_nsprefix_ + ':' if (UseCapturedNS_ and self.Lambda_nsprefix_) else '' + Lambda_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Lambda', pretty_print=pretty_print) + for Xi_ in self.Xi: + namespaceprefix_ = self.Xi_nsprefix_ + ':' if (UseCapturedNS_ and self.Xi_nsprefix_) else '' + Xi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Xi', pretty_print=pretty_print) + for Pi_ in self.Pi: + namespaceprefix_ = self.Pi_nsprefix_ + ':' if (UseCapturedNS_ and self.Pi_nsprefix_) else '' + Pi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Pi', pretty_print=pretty_print) + for Sigma_ in self.Sigma: + namespaceprefix_ = self.Sigma_nsprefix_ + ':' if (UseCapturedNS_ and self.Sigma_nsprefix_) else '' + Sigma_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Sigma', pretty_print=pretty_print) + for Upsilon_ in self.Upsilon: + namespaceprefix_ = self.Upsilon_nsprefix_ + ':' if (UseCapturedNS_ and self.Upsilon_nsprefix_) else '' + Upsilon_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Upsilon', pretty_print=pretty_print) + for Phi_ in self.Phi: + namespaceprefix_ = self.Phi_nsprefix_ + ':' if (UseCapturedNS_ and self.Phi_nsprefix_) else '' + Phi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Phi', pretty_print=pretty_print) + for Psi_ in self.Psi: + namespaceprefix_ = self.Psi_nsprefix_ + ':' if (UseCapturedNS_ and self.Psi_nsprefix_) else '' + Psi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Psi', pretty_print=pretty_print) + for Omega_ in self.Omega: + namespaceprefix_ = self.Omega_nsprefix_ + ':' if (UseCapturedNS_ and self.Omega_nsprefix_) else '' + Omega_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Omega', pretty_print=pretty_print) + for alpha_ in self.alpha: + namespaceprefix_ = self.alpha_nsprefix_ + ':' if (UseCapturedNS_ and self.alpha_nsprefix_) else '' + alpha_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='alpha', pretty_print=pretty_print) + for beta_ in self.beta: + namespaceprefix_ = self.beta_nsprefix_ + ':' if (UseCapturedNS_ and self.beta_nsprefix_) else '' + beta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='beta', pretty_print=pretty_print) + for gamma_ in self.gamma: + namespaceprefix_ = self.gamma_nsprefix_ + ':' if (UseCapturedNS_ and self.gamma_nsprefix_) else '' + gamma_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='gamma', pretty_print=pretty_print) + for delta_ in self.delta: + namespaceprefix_ = self.delta_nsprefix_ + ':' if (UseCapturedNS_ and self.delta_nsprefix_) else '' + delta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='delta', pretty_print=pretty_print) + for epsilon_ in self.epsilon: + namespaceprefix_ = self.epsilon_nsprefix_ + ':' if (UseCapturedNS_ and self.epsilon_nsprefix_) else '' + epsilon_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='epsilon', pretty_print=pretty_print) + for zeta_ in self.zeta: + namespaceprefix_ = self.zeta_nsprefix_ + ':' if (UseCapturedNS_ and self.zeta_nsprefix_) else '' + zeta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='zeta', pretty_print=pretty_print) + for eta_ in self.eta: + namespaceprefix_ = self.eta_nsprefix_ + ':' if (UseCapturedNS_ and self.eta_nsprefix_) else '' + eta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='eta', pretty_print=pretty_print) + for theta_ in self.theta: + namespaceprefix_ = self.theta_nsprefix_ + ':' if (UseCapturedNS_ and self.theta_nsprefix_) else '' + theta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='theta', pretty_print=pretty_print) + for iota_ in self.iota: + namespaceprefix_ = self.iota_nsprefix_ + ':' if (UseCapturedNS_ and self.iota_nsprefix_) else '' + iota_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='iota', pretty_print=pretty_print) + for kappa_ in self.kappa: + namespaceprefix_ = self.kappa_nsprefix_ + ':' if (UseCapturedNS_ and self.kappa_nsprefix_) else '' + kappa_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='kappa', pretty_print=pretty_print) + for lambda_ in self.lambda_: + namespaceprefix_ = self.lambda__nsprefix_ + ':' if (UseCapturedNS_ and self.lambda__nsprefix_) else '' + lambda_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='lambda', pretty_print=pretty_print) + for mu_ in self.mu: + namespaceprefix_ = self.mu_nsprefix_ + ':' if (UseCapturedNS_ and self.mu_nsprefix_) else '' + mu_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='mu', pretty_print=pretty_print) + for nu_ in self.nu: + namespaceprefix_ = self.nu_nsprefix_ + ':' if (UseCapturedNS_ and self.nu_nsprefix_) else '' + nu_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='nu', pretty_print=pretty_print) + for xi_ in self.xi: + namespaceprefix_ = self.xi_nsprefix_ + ':' if (UseCapturedNS_ and self.xi_nsprefix_) else '' + xi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='xi', pretty_print=pretty_print) + for pi_ in self.pi: + namespaceprefix_ = self.pi_nsprefix_ + ':' if (UseCapturedNS_ and self.pi_nsprefix_) else '' + pi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='pi', pretty_print=pretty_print) + for rho_ in self.rho: + namespaceprefix_ = self.rho_nsprefix_ + ':' if (UseCapturedNS_ and self.rho_nsprefix_) else '' + rho_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rho', pretty_print=pretty_print) + for sigma_ in self.sigma: + namespaceprefix_ = self.sigma_nsprefix_ + ':' if (UseCapturedNS_ and self.sigma_nsprefix_) else '' + sigma_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sigma', pretty_print=pretty_print) + for tau_ in self.tau: + namespaceprefix_ = self.tau_nsprefix_ + ':' if (UseCapturedNS_ and self.tau_nsprefix_) else '' + tau_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='tau', pretty_print=pretty_print) + for upsilon_ in self.upsilon: + namespaceprefix_ = self.upsilon_nsprefix_ + ':' if (UseCapturedNS_ and self.upsilon_nsprefix_) else '' + upsilon_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='upsilon', pretty_print=pretty_print) + for phi_ in self.phi: + namespaceprefix_ = self.phi_nsprefix_ + ':' if (UseCapturedNS_ and self.phi_nsprefix_) else '' + phi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='phi', pretty_print=pretty_print) + for chi_ in self.chi: + namespaceprefix_ = self.chi_nsprefix_ + ':' if (UseCapturedNS_ and self.chi_nsprefix_) else '' + chi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='chi', pretty_print=pretty_print) + for psi_ in self.psi: + namespaceprefix_ = self.psi_nsprefix_ + ':' if (UseCapturedNS_ and self.psi_nsprefix_) else '' + psi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='psi', pretty_print=pretty_print) + for omega_ in self.omega: + namespaceprefix_ = self.omega_nsprefix_ + ':' if (UseCapturedNS_ and self.omega_nsprefix_) else '' + omega_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='omega', pretty_print=pretty_print) + for sigmaf_ in self.sigmaf: + namespaceprefix_ = self.sigmaf_nsprefix_ + ':' if (UseCapturedNS_ and self.sigmaf_nsprefix_) else '' + sigmaf_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sigmaf', pretty_print=pretty_print) + for sect_ in self.sect: + namespaceprefix_ = self.sect_nsprefix_ + ':' if (UseCapturedNS_ and self.sect_nsprefix_) else '' + sect_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sect', pretty_print=pretty_print) + for deg_ in self.deg: + namespaceprefix_ = self.deg_nsprefix_ + ':' if (UseCapturedNS_ and self.deg_nsprefix_) else '' + deg_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='deg', pretty_print=pretty_print) + for prime_ in self.prime: + namespaceprefix_ = self.prime_nsprefix_ + ':' if (UseCapturedNS_ and self.prime_nsprefix_) else '' + prime_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='prime', pretty_print=pretty_print) + for Prime_ in self.Prime: + namespaceprefix_ = self.Prime_nsprefix_ + ':' if (UseCapturedNS_ and self.Prime_nsprefix_) else '' + Prime_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Prime', pretty_print=pretty_print) + for infin_ in self.infin: + namespaceprefix_ = self.infin_nsprefix_ + ':' if (UseCapturedNS_ and self.infin_nsprefix_) else '' + infin_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='infin', pretty_print=pretty_print) + for empty_ in self.empty: + namespaceprefix_ = self.empty_nsprefix_ + ':' if (UseCapturedNS_ and self.empty_nsprefix_) else '' + empty_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='empty', pretty_print=pretty_print) + for plusmn_ in self.plusmn: + namespaceprefix_ = self.plusmn_nsprefix_ + ':' if (UseCapturedNS_ and self.plusmn_nsprefix_) else '' + plusmn_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='plusmn', pretty_print=pretty_print) + for times_ in self.times: + namespaceprefix_ = self.times_nsprefix_ + ':' if (UseCapturedNS_ and self.times_nsprefix_) else '' + times_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='times', pretty_print=pretty_print) + for minus_ in self.minus: + namespaceprefix_ = self.minus_nsprefix_ + ':' if (UseCapturedNS_ and self.minus_nsprefix_) else '' + minus_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='minus', pretty_print=pretty_print) + for sdot_ in self.sdot: + namespaceprefix_ = self.sdot_nsprefix_ + ':' if (UseCapturedNS_ and self.sdot_nsprefix_) else '' + sdot_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sdot', pretty_print=pretty_print) + for part_ in self.part: + namespaceprefix_ = self.part_nsprefix_ + ':' if (UseCapturedNS_ and self.part_nsprefix_) else '' + part_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='part', pretty_print=pretty_print) + for nabla_ in self.nabla: + namespaceprefix_ = self.nabla_nsprefix_ + ':' if (UseCapturedNS_ and self.nabla_nsprefix_) else '' + nabla_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='nabla', pretty_print=pretty_print) + for radic_ in self.radic: + namespaceprefix_ = self.radic_nsprefix_ + ':' if (UseCapturedNS_ and self.radic_nsprefix_) else '' + radic_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='radic', pretty_print=pretty_print) + for perp_ in self.perp: + namespaceprefix_ = self.perp_nsprefix_ + ':' if (UseCapturedNS_ and self.perp_nsprefix_) else '' + perp_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='perp', pretty_print=pretty_print) + for sum_ in self.sum: + namespaceprefix_ = self.sum_nsprefix_ + ':' if (UseCapturedNS_ and self.sum_nsprefix_) else '' + sum_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sum', pretty_print=pretty_print) + for int_ in self.int: + namespaceprefix_ = self.int_nsprefix_ + ':' if (UseCapturedNS_ and self.int_nsprefix_) else '' + int_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='int', pretty_print=pretty_print) + for prod_ in self.prod: + namespaceprefix_ = self.prod_nsprefix_ + ':' if (UseCapturedNS_ and self.prod_nsprefix_) else '' + prod_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='prod', pretty_print=pretty_print) + for sim_ in self.sim: + namespaceprefix_ = self.sim_nsprefix_ + ':' if (UseCapturedNS_ and self.sim_nsprefix_) else '' + sim_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sim', pretty_print=pretty_print) + for asymp_ in self.asymp: + namespaceprefix_ = self.asymp_nsprefix_ + ':' if (UseCapturedNS_ and self.asymp_nsprefix_) else '' + asymp_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='asymp', pretty_print=pretty_print) + for ne_ in self.ne: + namespaceprefix_ = self.ne_nsprefix_ + ':' if (UseCapturedNS_ and self.ne_nsprefix_) else '' + ne_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ne', pretty_print=pretty_print) + for equiv_ in self.equiv: + namespaceprefix_ = self.equiv_nsprefix_ + ':' if (UseCapturedNS_ and self.equiv_nsprefix_) else '' + equiv_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='equiv', pretty_print=pretty_print) + for prop_ in self.prop: + namespaceprefix_ = self.prop_nsprefix_ + ':' if (UseCapturedNS_ and self.prop_nsprefix_) else '' + prop_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='prop', pretty_print=pretty_print) + for le_ in self.le: + namespaceprefix_ = self.le_nsprefix_ + ':' if (UseCapturedNS_ and self.le_nsprefix_) else '' + le_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='le', pretty_print=pretty_print) + for ge_ in self.ge: + namespaceprefix_ = self.ge_nsprefix_ + ':' if (UseCapturedNS_ and self.ge_nsprefix_) else '' + ge_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ge', pretty_print=pretty_print) + for larr_ in self.larr: + namespaceprefix_ = self.larr_nsprefix_ + ':' if (UseCapturedNS_ and self.larr_nsprefix_) else '' + larr_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='larr', pretty_print=pretty_print) + for rarr_ in self.rarr: + namespaceprefix_ = self.rarr_nsprefix_ + ':' if (UseCapturedNS_ and self.rarr_nsprefix_) else '' + rarr_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rarr', pretty_print=pretty_print) + for isin_ in self.isin: + namespaceprefix_ = self.isin_nsprefix_ + ':' if (UseCapturedNS_ and self.isin_nsprefix_) else '' + isin_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='isin', pretty_print=pretty_print) + for notin_ in self.notin: + namespaceprefix_ = self.notin_nsprefix_ + ':' if (UseCapturedNS_ and self.notin_nsprefix_) else '' + notin_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='notin', pretty_print=pretty_print) + for lceil_ in self.lceil: + namespaceprefix_ = self.lceil_nsprefix_ + ':' if (UseCapturedNS_ and self.lceil_nsprefix_) else '' + lceil_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='lceil', pretty_print=pretty_print) + for rceil_ in self.rceil: + namespaceprefix_ = self.rceil_nsprefix_ + ':' if (UseCapturedNS_ and self.rceil_nsprefix_) else '' + rceil_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rceil', pretty_print=pretty_print) + for lfloor_ in self.lfloor: + namespaceprefix_ = self.lfloor_nsprefix_ + ':' if (UseCapturedNS_ and self.lfloor_nsprefix_) else '' + lfloor_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='lfloor', pretty_print=pretty_print) + for rfloor_ in self.rfloor: + namespaceprefix_ = self.rfloor_nsprefix_ + ':' if (UseCapturedNS_ and self.rfloor_nsprefix_) else '' + rfloor_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rfloor', pretty_print=pretty_print) + for linebreak_ in self.linebreak: + namespaceprefix_ = self.linebreak_nsprefix_ + ':' if (UseCapturedNS_ and self.linebreak_nsprefix_) else '' + linebreak_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='linebreak', pretty_print=pretty_print) + for hruler_ in self.hruler: + namespaceprefix_ = self.hruler_nsprefix_ + ':' if (UseCapturedNS_ and self.hruler_nsprefix_) else '' + hruler_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='hruler', pretty_print=pretty_print) + for preformatted_ in self.preformatted: + namespaceprefix_ = self.preformatted_nsprefix_ + ':' if (UseCapturedNS_ and self.preformatted_nsprefix_) else '' + preformatted_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='preformatted', pretty_print=pretty_print) + for programlisting_ in self.programlisting: + namespaceprefix_ = self.programlisting_nsprefix_ + ':' if (UseCapturedNS_ and self.programlisting_nsprefix_) else '' + programlisting_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='programlisting', pretty_print=pretty_print) + for verbatim_ in self.verbatim: + namespaceprefix_ = self.verbatim_nsprefix_ + ':' if (UseCapturedNS_ and self.verbatim_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%sverbatim>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(verbatim_), input_name='verbatim')), namespaceprefix_ , eol_)) + for indexentry_ in self.indexentry: + namespaceprefix_ = self.indexentry_nsprefix_ + ':' if (UseCapturedNS_ and self.indexentry_nsprefix_) else '' + indexentry_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='indexentry', pretty_print=pretty_print) + for orderedlist_ in self.orderedlist: + namespaceprefix_ = self.orderedlist_nsprefix_ + ':' if (UseCapturedNS_ and self.orderedlist_nsprefix_) else '' + orderedlist_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='orderedlist', pretty_print=pretty_print) + for itemizedlist_ in self.itemizedlist: + namespaceprefix_ = self.itemizedlist_nsprefix_ + ':' if (UseCapturedNS_ and self.itemizedlist_nsprefix_) else '' + itemizedlist_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='itemizedlist', pretty_print=pretty_print) + for simplesect_ in self.simplesect: + namespaceprefix_ = self.simplesect_nsprefix_ + ':' if (UseCapturedNS_ and self.simplesect_nsprefix_) else '' + simplesect_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='simplesect', pretty_print=pretty_print) + for title_ in self.title: + namespaceprefix_ = self.title_nsprefix_ + ':' if (UseCapturedNS_ and self.title_nsprefix_) else '' + title_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='title', pretty_print=pretty_print) + for variablelist_ in self.variablelist: + namespaceprefix_ = self.variablelist_nsprefix_ + ':' if (UseCapturedNS_ and self.variablelist_nsprefix_) else '' + variablelist_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='variablelist', pretty_print=pretty_print) + for table_ in self.table: + namespaceprefix_ = self.table_nsprefix_ + ':' if (UseCapturedNS_ and self.table_nsprefix_) else '' + table_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='table', pretty_print=pretty_print) + for heading_ in self.heading: + namespaceprefix_ = self.heading_nsprefix_ + ':' if (UseCapturedNS_ and self.heading_nsprefix_) else '' + heading_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='heading', pretty_print=pretty_print) + for image_ in self.image: + namespaceprefix_ = self.image_nsprefix_ + ':' if (UseCapturedNS_ and self.image_nsprefix_) else '' + image_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='image', pretty_print=pretty_print) + for dotfile_ in self.dotfile: + namespaceprefix_ = self.dotfile_nsprefix_ + ':' if (UseCapturedNS_ and self.dotfile_nsprefix_) else '' + dotfile_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='dotfile', pretty_print=pretty_print) + for mscfile_ in self.mscfile: + namespaceprefix_ = self.mscfile_nsprefix_ + ':' if (UseCapturedNS_ and self.mscfile_nsprefix_) else '' + mscfile_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='mscfile', pretty_print=pretty_print) + for diafile_ in self.diafile: + namespaceprefix_ = self.diafile_nsprefix_ + ':' if (UseCapturedNS_ and self.diafile_nsprefix_) else '' + diafile_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='diafile', pretty_print=pretty_print) + for toclist_ in self.toclist: + namespaceprefix_ = self.toclist_nsprefix_ + ':' if (UseCapturedNS_ and self.toclist_nsprefix_) else '' + toclist_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='toclist', pretty_print=pretty_print) + for language_ in self.language: + namespaceprefix_ = self.language_nsprefix_ + ':' if (UseCapturedNS_ and self.language_nsprefix_) else '' + language_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='language', pretty_print=pretty_print) + for parameterlist_ in self.parameterlist: + namespaceprefix_ = self.parameterlist_nsprefix_ + ':' if (UseCapturedNS_ and self.parameterlist_nsprefix_) else '' + parameterlist_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='parameterlist', pretty_print=pretty_print) + for xrefsect_ in self.xrefsect: + namespaceprefix_ = self.xrefsect_nsprefix_ + ':' if (UseCapturedNS_ and self.xrefsect_nsprefix_) else '' + xrefsect_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='xrefsect', pretty_print=pretty_print) + for copydoc_ in self.copydoc: + namespaceprefix_ = self.copydoc_nsprefix_ + ':' if (UseCapturedNS_ and self.copydoc_nsprefix_) else '' + copydoc_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='copydoc', pretty_print=pretty_print) + for blockquote_ in self.blockquote: + namespaceprefix_ = self.blockquote_nsprefix_ + ':' if (UseCapturedNS_ and self.blockquote_nsprefix_) else '' + blockquote_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='blockquote', pretty_print=pretty_print) + for parblock_ in self.parblock: + namespaceprefix_ = self.parblock_nsprefix_ + ':' if (UseCapturedNS_ and self.parblock_nsprefix_) else '' + parblock_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='parblock', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + self.valueOf_ = get_all_text_(node) + if node.text is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', node.text) + self.content_.append(obj_) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'ulink': + obj_ = docURLLink.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ulink', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ulink'): + self.add_ulink(obj_.value) + elif hasattr(self, 'set_ulink'): + self.set_ulink(obj_.value) + elif nodeName_ == 'bold': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'bold', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_bold'): + self.add_bold(obj_.value) + elif hasattr(self, 'set_bold'): + self.set_bold(obj_.value) + elif nodeName_ == 'emphasis': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'emphasis', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_emphasis'): + self.add_emphasis(obj_.value) + elif hasattr(self, 'set_emphasis'): + self.set_emphasis(obj_.value) + elif nodeName_ == 'computeroutput': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'computeroutput', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_computeroutput'): + self.add_computeroutput(obj_.value) + elif hasattr(self, 'set_computeroutput'): + self.set_computeroutput(obj_.value) + elif nodeName_ == 'subscript': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'subscript', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_subscript'): + self.add_subscript(obj_.value) + elif hasattr(self, 'set_subscript'): + self.set_subscript(obj_.value) + elif nodeName_ == 'superscript': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'superscript', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_superscript'): + self.add_superscript(obj_.value) + elif hasattr(self, 'set_superscript'): + self.set_superscript(obj_.value) + elif nodeName_ == 'center': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'center', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_center'): + self.add_center(obj_.value) + elif hasattr(self, 'set_center'): + self.set_center(obj_.value) + elif nodeName_ == 'small': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'small', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_small'): + self.add_small(obj_.value) + elif hasattr(self, 'set_small'): + self.set_small(obj_.value) + elif nodeName_ == 'htmlonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'htmlonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'htmlonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'htmlonly', valuestr_) + self.content_.append(obj_) + self.htmlonly_nsprefix_ = child_.prefix + elif nodeName_ == 'manonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'manonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'manonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'manonly', valuestr_) + self.content_.append(obj_) + self.manonly_nsprefix_ = child_.prefix + elif nodeName_ == 'xmlonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'xmlonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'xmlonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'xmlonly', valuestr_) + self.content_.append(obj_) + self.xmlonly_nsprefix_ = child_.prefix + elif nodeName_ == 'rtfonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'rtfonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'rtfonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'rtfonly', valuestr_) + self.content_.append(obj_) + self.rtfonly_nsprefix_ = child_.prefix + elif nodeName_ == 'latexonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'latexonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'latexonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'latexonly', valuestr_) + self.content_.append(obj_) + self.latexonly_nsprefix_ = child_.prefix + elif nodeName_ == 'dot' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'dot') + valuestr_ = self.gds_validate_string(valuestr_, node, 'dot') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'dot', valuestr_) + self.content_.append(obj_) + self.dot_nsprefix_ = child_.prefix + elif nodeName_ == 'msc' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'msc') + valuestr_ = self.gds_validate_string(valuestr_, node, 'msc') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'msc', valuestr_) + self.content_.append(obj_) + self.msc_nsprefix_ = child_.prefix + elif nodeName_ == 'anchor': + obj_ = docAnchorType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'anchor', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_anchor'): + self.add_anchor(obj_.value) + elif hasattr(self, 'set_anchor'): + self.set_anchor(obj_.value) + elif nodeName_ == 'formula': + obj_ = docFormulaType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'formula', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_formula'): + self.add_formula(obj_.value) + elif hasattr(self, 'set_formula'): + self.set_formula(obj_.value) + elif nodeName_ == 'ref': + obj_ = docRefTextType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ref', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ref'): + self.add_ref(obj_.value) + elif hasattr(self, 'set_ref'): + self.set_ref(obj_.value) + elif nodeName_ == 'copy': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'copy', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_copy'): + self.add_copy(obj_.value) + elif hasattr(self, 'set_copy'): + self.set_copy(obj_.value) + elif nodeName_ == 'trademark': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'trademark', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_trademark'): + self.add_trademark(obj_.value) + elif hasattr(self, 'set_trademark'): + self.set_trademark(obj_.value) + elif nodeName_ == 'registered': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'registered', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_registered'): + self.add_registered(obj_.value) + elif hasattr(self, 'set_registered'): + self.set_registered(obj_.value) + elif nodeName_ == 'lsquo': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'lsquo', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_lsquo'): + self.add_lsquo(obj_.value) + elif hasattr(self, 'set_lsquo'): + self.set_lsquo(obj_.value) + elif nodeName_ == 'rsquo': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rsquo', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rsquo'): + self.add_rsquo(obj_.value) + elif hasattr(self, 'set_rsquo'): + self.set_rsquo(obj_.value) + elif nodeName_ == 'ldquo': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ldquo', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ldquo'): + self.add_ldquo(obj_.value) + elif hasattr(self, 'set_ldquo'): + self.set_ldquo(obj_.value) + elif nodeName_ == 'rdquo': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rdquo', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rdquo'): + self.add_rdquo(obj_.value) + elif hasattr(self, 'set_rdquo'): + self.set_rdquo(obj_.value) + elif nodeName_ == 'ndash': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ndash', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ndash'): + self.add_ndash(obj_.value) + elif hasattr(self, 'set_ndash'): + self.set_ndash(obj_.value) + elif nodeName_ == 'mdash': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'mdash', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_mdash'): + self.add_mdash(obj_.value) + elif hasattr(self, 'set_mdash'): + self.set_mdash(obj_.value) + elif nodeName_ == 'umlaut': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'umlaut', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_umlaut'): + self.add_umlaut(obj_.value) + elif hasattr(self, 'set_umlaut'): + self.set_umlaut(obj_.value) + elif nodeName_ == 'acute': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'acute', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_acute'): + self.add_acute(obj_.value) + elif hasattr(self, 'set_acute'): + self.set_acute(obj_.value) + elif nodeName_ == 'grave': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'grave', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_grave'): + self.add_grave(obj_.value) + elif hasattr(self, 'set_grave'): + self.set_grave(obj_.value) + elif nodeName_ == 'circ': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'circ', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_circ'): + self.add_circ(obj_.value) + elif hasattr(self, 'set_circ'): + self.set_circ(obj_.value) + elif nodeName_ == 'slash': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'slash', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_slash'): + self.add_slash(obj_.value) + elif hasattr(self, 'set_slash'): + self.set_slash(obj_.value) + elif nodeName_ == 'tilde': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'tilde', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_tilde'): + self.add_tilde(obj_.value) + elif hasattr(self, 'set_tilde'): + self.set_tilde(obj_.value) + elif nodeName_ == 'cedil': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'cedil', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_cedil'): + self.add_cedil(obj_.value) + elif hasattr(self, 'set_cedil'): + self.set_cedil(obj_.value) + elif nodeName_ == 'ring': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ring', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ring'): + self.add_ring(obj_.value) + elif hasattr(self, 'set_ring'): + self.set_ring(obj_.value) + elif nodeName_ == 'szlig': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'szlig', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_szlig'): + self.add_szlig(obj_.value) + elif hasattr(self, 'set_szlig'): + self.set_szlig(obj_.value) + elif nodeName_ == 'nonbreakablespace': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'nonbreakablespace', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_nonbreakablespace'): + self.add_nonbreakablespace(obj_.value) + elif hasattr(self, 'set_nonbreakablespace'): + self.set_nonbreakablespace(obj_.value) + elif nodeName_ == 'aelig': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'aelig', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_aelig'): + self.add_aelig(obj_.value) + elif hasattr(self, 'set_aelig'): + self.set_aelig(obj_.value) + elif nodeName_ == 'AElig': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'AElig', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_AElig'): + self.add_AElig(obj_.value) + elif hasattr(self, 'set_AElig'): + self.set_AElig(obj_.value) + elif nodeName_ == 'Gamma': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Gamma', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Gamma'): + self.add_Gamma(obj_.value) + elif hasattr(self, 'set_Gamma'): + self.set_Gamma(obj_.value) + elif nodeName_ == 'Delta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Delta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Delta'): + self.add_Delta(obj_.value) + elif hasattr(self, 'set_Delta'): + self.set_Delta(obj_.value) + elif nodeName_ == 'Theta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Theta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Theta'): + self.add_Theta(obj_.value) + elif hasattr(self, 'set_Theta'): + self.set_Theta(obj_.value) + elif nodeName_ == 'Lambda': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Lambda', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Lambda'): + self.add_Lambda(obj_.value) + elif hasattr(self, 'set_Lambda'): + self.set_Lambda(obj_.value) + elif nodeName_ == 'Xi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Xi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Xi'): + self.add_Xi(obj_.value) + elif hasattr(self, 'set_Xi'): + self.set_Xi(obj_.value) + elif nodeName_ == 'Pi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Pi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Pi'): + self.add_Pi(obj_.value) + elif hasattr(self, 'set_Pi'): + self.set_Pi(obj_.value) + elif nodeName_ == 'Sigma': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Sigma', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Sigma'): + self.add_Sigma(obj_.value) + elif hasattr(self, 'set_Sigma'): + self.set_Sigma(obj_.value) + elif nodeName_ == 'Upsilon': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Upsilon', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Upsilon'): + self.add_Upsilon(obj_.value) + elif hasattr(self, 'set_Upsilon'): + self.set_Upsilon(obj_.value) + elif nodeName_ == 'Phi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Phi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Phi'): + self.add_Phi(obj_.value) + elif hasattr(self, 'set_Phi'): + self.set_Phi(obj_.value) + elif nodeName_ == 'Psi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Psi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Psi'): + self.add_Psi(obj_.value) + elif hasattr(self, 'set_Psi'): + self.set_Psi(obj_.value) + elif nodeName_ == 'Omega': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Omega', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Omega'): + self.add_Omega(obj_.value) + elif hasattr(self, 'set_Omega'): + self.set_Omega(obj_.value) + elif nodeName_ == 'alpha': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'alpha', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_alpha'): + self.add_alpha(obj_.value) + elif hasattr(self, 'set_alpha'): + self.set_alpha(obj_.value) + elif nodeName_ == 'beta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'beta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_beta'): + self.add_beta(obj_.value) + elif hasattr(self, 'set_beta'): + self.set_beta(obj_.value) + elif nodeName_ == 'gamma': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'gamma', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_gamma'): + self.add_gamma(obj_.value) + elif hasattr(self, 'set_gamma'): + self.set_gamma(obj_.value) + elif nodeName_ == 'delta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'delta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_delta'): + self.add_delta(obj_.value) + elif hasattr(self, 'set_delta'): + self.set_delta(obj_.value) + elif nodeName_ == 'epsilon': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'epsilon', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_epsilon'): + self.add_epsilon(obj_.value) + elif hasattr(self, 'set_epsilon'): + self.set_epsilon(obj_.value) + elif nodeName_ == 'zeta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'zeta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_zeta'): + self.add_zeta(obj_.value) + elif hasattr(self, 'set_zeta'): + self.set_zeta(obj_.value) + elif nodeName_ == 'eta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'eta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_eta'): + self.add_eta(obj_.value) + elif hasattr(self, 'set_eta'): + self.set_eta(obj_.value) + elif nodeName_ == 'theta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'theta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_theta'): + self.add_theta(obj_.value) + elif hasattr(self, 'set_theta'): + self.set_theta(obj_.value) + elif nodeName_ == 'iota': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'iota', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_iota'): + self.add_iota(obj_.value) + elif hasattr(self, 'set_iota'): + self.set_iota(obj_.value) + elif nodeName_ == 'kappa': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'kappa', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_kappa'): + self.add_kappa(obj_.value) + elif hasattr(self, 'set_kappa'): + self.set_kappa(obj_.value) + elif nodeName_ == 'lambda': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'lambda', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_lambda'): + self.add_lambda(obj_.value) + elif hasattr(self, 'set_lambda'): + self.set_lambda(obj_.value) + elif nodeName_ == 'mu': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'mu', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_mu'): + self.add_mu(obj_.value) + elif hasattr(self, 'set_mu'): + self.set_mu(obj_.value) + elif nodeName_ == 'nu': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'nu', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_nu'): + self.add_nu(obj_.value) + elif hasattr(self, 'set_nu'): + self.set_nu(obj_.value) + elif nodeName_ == 'xi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'xi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_xi'): + self.add_xi(obj_.value) + elif hasattr(self, 'set_xi'): + self.set_xi(obj_.value) + elif nodeName_ == 'pi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'pi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_pi'): + self.add_pi(obj_.value) + elif hasattr(self, 'set_pi'): + self.set_pi(obj_.value) + elif nodeName_ == 'rho': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rho', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rho'): + self.add_rho(obj_.value) + elif hasattr(self, 'set_rho'): + self.set_rho(obj_.value) + elif nodeName_ == 'sigma': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sigma', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sigma'): + self.add_sigma(obj_.value) + elif hasattr(self, 'set_sigma'): + self.set_sigma(obj_.value) + elif nodeName_ == 'tau': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'tau', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_tau'): + self.add_tau(obj_.value) + elif hasattr(self, 'set_tau'): + self.set_tau(obj_.value) + elif nodeName_ == 'upsilon': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'upsilon', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_upsilon'): + self.add_upsilon(obj_.value) + elif hasattr(self, 'set_upsilon'): + self.set_upsilon(obj_.value) + elif nodeName_ == 'phi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'phi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_phi'): + self.add_phi(obj_.value) + elif hasattr(self, 'set_phi'): + self.set_phi(obj_.value) + elif nodeName_ == 'chi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'chi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_chi'): + self.add_chi(obj_.value) + elif hasattr(self, 'set_chi'): + self.set_chi(obj_.value) + elif nodeName_ == 'psi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'psi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_psi'): + self.add_psi(obj_.value) + elif hasattr(self, 'set_psi'): + self.set_psi(obj_.value) + elif nodeName_ == 'omega': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'omega', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_omega'): + self.add_omega(obj_.value) + elif hasattr(self, 'set_omega'): + self.set_omega(obj_.value) + elif nodeName_ == 'sigmaf': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sigmaf', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sigmaf'): + self.add_sigmaf(obj_.value) + elif hasattr(self, 'set_sigmaf'): + self.set_sigmaf(obj_.value) + elif nodeName_ == 'sect': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sect', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sect'): + self.add_sect(obj_.value) + elif hasattr(self, 'set_sect'): + self.set_sect(obj_.value) + elif nodeName_ == 'deg': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'deg', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_deg'): + self.add_deg(obj_.value) + elif hasattr(self, 'set_deg'): + self.set_deg(obj_.value) + elif nodeName_ == 'prime': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'prime', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_prime'): + self.add_prime(obj_.value) + elif hasattr(self, 'set_prime'): + self.set_prime(obj_.value) + elif nodeName_ == 'Prime': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Prime', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Prime'): + self.add_Prime(obj_.value) + elif hasattr(self, 'set_Prime'): + self.set_Prime(obj_.value) + elif nodeName_ == 'infin': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'infin', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_infin'): + self.add_infin(obj_.value) + elif hasattr(self, 'set_infin'): + self.set_infin(obj_.value) + elif nodeName_ == 'empty': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'empty', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_empty'): + self.add_empty(obj_.value) + elif hasattr(self, 'set_empty'): + self.set_empty(obj_.value) + elif nodeName_ == 'plusmn': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'plusmn', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_plusmn'): + self.add_plusmn(obj_.value) + elif hasattr(self, 'set_plusmn'): + self.set_plusmn(obj_.value) + elif nodeName_ == 'times': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'times', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_times'): + self.add_times(obj_.value) + elif hasattr(self, 'set_times'): + self.set_times(obj_.value) + elif nodeName_ == 'minus': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'minus', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_minus'): + self.add_minus(obj_.value) + elif hasattr(self, 'set_minus'): + self.set_minus(obj_.value) + elif nodeName_ == 'sdot': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sdot', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sdot'): + self.add_sdot(obj_.value) + elif hasattr(self, 'set_sdot'): + self.set_sdot(obj_.value) + elif nodeName_ == 'part': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'part', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_part'): + self.add_part(obj_.value) + elif hasattr(self, 'set_part'): + self.set_part(obj_.value) + elif nodeName_ == 'nabla': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'nabla', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_nabla'): + self.add_nabla(obj_.value) + elif hasattr(self, 'set_nabla'): + self.set_nabla(obj_.value) + elif nodeName_ == 'radic': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'radic', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_radic'): + self.add_radic(obj_.value) + elif hasattr(self, 'set_radic'): + self.set_radic(obj_.value) + elif nodeName_ == 'perp': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'perp', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_perp'): + self.add_perp(obj_.value) + elif hasattr(self, 'set_perp'): + self.set_perp(obj_.value) + elif nodeName_ == 'sum': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sum', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sum'): + self.add_sum(obj_.value) + elif hasattr(self, 'set_sum'): + self.set_sum(obj_.value) + elif nodeName_ == 'int': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'int', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_int'): + self.add_int(obj_.value) + elif hasattr(self, 'set_int'): + self.set_int(obj_.value) + elif nodeName_ == 'prod': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'prod', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_prod'): + self.add_prod(obj_.value) + elif hasattr(self, 'set_prod'): + self.set_prod(obj_.value) + elif nodeName_ == 'sim': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sim', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sim'): + self.add_sim(obj_.value) + elif hasattr(self, 'set_sim'): + self.set_sim(obj_.value) + elif nodeName_ == 'asymp': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'asymp', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_asymp'): + self.add_asymp(obj_.value) + elif hasattr(self, 'set_asymp'): + self.set_asymp(obj_.value) + elif nodeName_ == 'ne': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ne', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ne'): + self.add_ne(obj_.value) + elif hasattr(self, 'set_ne'): + self.set_ne(obj_.value) + elif nodeName_ == 'equiv': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'equiv', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_equiv'): + self.add_equiv(obj_.value) + elif hasattr(self, 'set_equiv'): + self.set_equiv(obj_.value) + elif nodeName_ == 'prop': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'prop', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_prop'): + self.add_prop(obj_.value) + elif hasattr(self, 'set_prop'): + self.set_prop(obj_.value) + elif nodeName_ == 'le': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'le', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_le'): + self.add_le(obj_.value) + elif hasattr(self, 'set_le'): + self.set_le(obj_.value) + elif nodeName_ == 'ge': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ge', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ge'): + self.add_ge(obj_.value) + elif hasattr(self, 'set_ge'): + self.set_ge(obj_.value) + elif nodeName_ == 'larr': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'larr', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_larr'): + self.add_larr(obj_.value) + elif hasattr(self, 'set_larr'): + self.set_larr(obj_.value) + elif nodeName_ == 'rarr': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rarr', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rarr'): + self.add_rarr(obj_.value) + elif hasattr(self, 'set_rarr'): + self.set_rarr(obj_.value) + elif nodeName_ == 'isin': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'isin', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_isin'): + self.add_isin(obj_.value) + elif hasattr(self, 'set_isin'): + self.set_isin(obj_.value) + elif nodeName_ == 'notin': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'notin', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_notin'): + self.add_notin(obj_.value) + elif hasattr(self, 'set_notin'): + self.set_notin(obj_.value) + elif nodeName_ == 'lceil': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'lceil', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_lceil'): + self.add_lceil(obj_.value) + elif hasattr(self, 'set_lceil'): + self.set_lceil(obj_.value) + elif nodeName_ == 'rceil': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rceil', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rceil'): + self.add_rceil(obj_.value) + elif hasattr(self, 'set_rceil'): + self.set_rceil(obj_.value) + elif nodeName_ == 'lfloor': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'lfloor', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_lfloor'): + self.add_lfloor(obj_.value) + elif hasattr(self, 'set_lfloor'): + self.set_lfloor(obj_.value) + elif nodeName_ == 'rfloor': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rfloor', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rfloor'): + self.add_rfloor(obj_.value) + elif hasattr(self, 'set_rfloor'): + self.set_rfloor(obj_.value) + elif nodeName_ == 'linebreak': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'linebreak', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_linebreak'): + self.add_linebreak(obj_.value) + elif hasattr(self, 'set_linebreak'): + self.set_linebreak(obj_.value) + elif nodeName_ == 'hruler': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'hruler', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_hruler'): + self.add_hruler(obj_.value) + elif hasattr(self, 'set_hruler'): + self.set_hruler(obj_.value) + elif nodeName_ == 'preformatted': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'preformatted', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_preformatted'): + self.add_preformatted(obj_.value) + elif hasattr(self, 'set_preformatted'): + self.set_preformatted(obj_.value) + elif nodeName_ == 'programlisting': + obj_ = listingType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'programlisting', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_programlisting'): + self.add_programlisting(obj_.value) + elif hasattr(self, 'set_programlisting'): + self.set_programlisting(obj_.value) + elif nodeName_ == 'verbatim' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'verbatim') + valuestr_ = self.gds_validate_string(valuestr_, node, 'verbatim') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'verbatim', valuestr_) + self.content_.append(obj_) + self.verbatim_nsprefix_ = child_.prefix + elif nodeName_ == 'indexentry': + obj_ = docIndexEntryType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'indexentry', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_indexentry'): + self.add_indexentry(obj_.value) + elif hasattr(self, 'set_indexentry'): + self.set_indexentry(obj_.value) + elif nodeName_ == 'orderedlist': + obj_ = docListType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'orderedlist', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_orderedlist'): + self.add_orderedlist(obj_.value) + elif hasattr(self, 'set_orderedlist'): + self.set_orderedlist(obj_.value) + elif nodeName_ == 'itemizedlist': + obj_ = docListType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'itemizedlist', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_itemizedlist'): + self.add_itemizedlist(obj_.value) + elif hasattr(self, 'set_itemizedlist'): + self.set_itemizedlist(obj_.value) + elif nodeName_ == 'simplesect': + obj_ = docSimpleSectType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'simplesect', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_simplesect'): + self.add_simplesect(obj_.value) + elif hasattr(self, 'set_simplesect'): + self.set_simplesect(obj_.value) + elif nodeName_ == 'title': + obj_ = docTitleType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'title', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_title'): + self.add_title(obj_.value) + elif hasattr(self, 'set_title'): + self.set_title(obj_.value) + elif nodeName_ == 'variablelist': + obj_ = docVariableListType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'variablelist', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_variablelist'): + self.add_variablelist(obj_.value) + elif hasattr(self, 'set_variablelist'): + self.set_variablelist(obj_.value) + elif nodeName_ == 'table': + obj_ = docTableType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'table', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_table'): + self.add_table(obj_.value) + elif hasattr(self, 'set_table'): + self.set_table(obj_.value) + elif nodeName_ == 'heading': + obj_ = docHeadingType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'heading', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_heading'): + self.add_heading(obj_.value) + elif hasattr(self, 'set_heading'): + self.set_heading(obj_.value) + elif nodeName_ == 'image': + obj_ = docImageType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'image', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_image'): + self.add_image(obj_.value) + elif hasattr(self, 'set_image'): + self.set_image(obj_.value) + elif nodeName_ == 'dotfile': + obj_ = docFileType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'dotfile', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_dotfile'): + self.add_dotfile(obj_.value) + elif hasattr(self, 'set_dotfile'): + self.set_dotfile(obj_.value) + elif nodeName_ == 'mscfile': + obj_ = docFileType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'mscfile', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_mscfile'): + self.add_mscfile(obj_.value) + elif hasattr(self, 'set_mscfile'): + self.set_mscfile(obj_.value) + elif nodeName_ == 'diafile': + obj_ = docFileType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'diafile', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_diafile'): + self.add_diafile(obj_.value) + elif hasattr(self, 'set_diafile'): + self.set_diafile(obj_.value) + elif nodeName_ == 'toclist': + obj_ = docTocListType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'toclist', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_toclist'): + self.add_toclist(obj_.value) + elif hasattr(self, 'set_toclist'): + self.set_toclist(obj_.value) + elif nodeName_ == 'language': + obj_ = docLanguageType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'language', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_language'): + self.add_language(obj_.value) + elif hasattr(self, 'set_language'): + self.set_language(obj_.value) + elif nodeName_ == 'parameterlist': + obj_ = docParamListType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'parameterlist', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_parameterlist'): + self.add_parameterlist(obj_.value) + elif hasattr(self, 'set_parameterlist'): + self.set_parameterlist(obj_.value) + elif nodeName_ == 'xrefsect': + obj_ = docXRefSectType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'xrefsect', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_xrefsect'): + self.add_xrefsect(obj_.value) + elif hasattr(self, 'set_xrefsect'): + self.set_xrefsect(obj_.value) + elif nodeName_ == 'copydoc': + obj_ = docCopyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'copydoc', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_copydoc'): + self.add_copydoc(obj_.value) + elif hasattr(self, 'set_copydoc'): + self.set_copydoc(obj_.value) + elif nodeName_ == 'blockquote': + obj_ = docBlockQuoteType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'blockquote', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_blockquote'): + self.add_blockquote(obj_.value) + elif hasattr(self, 'set_blockquote'): + self.set_blockquote(obj_.value) + elif nodeName_ == 'parblock': + obj_ = docParBlockType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'parblock', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_parblock'): + self.add_parblock(obj_.value) + elif hasattr(self, 'set_parblock'): + self.set_parblock(obj_.value) + if not fromsubclass_ and child_.tail is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.tail) + self.content_.append(obj_) +# end class docParaType + + +class docMarkupType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, ulink=None, bold=None, emphasis=None, computeroutput=None, subscript=None, superscript=None, center=None, small=None, htmlonly=None, manonly=None, xmlonly=None, rtfonly=None, latexonly=None, dot=None, msc=None, anchor=None, formula=None, ref=None, copy=None, trademark=None, registered=None, lsquo=None, rsquo=None, ldquo=None, rdquo=None, ndash=None, mdash=None, umlaut=None, acute=None, grave=None, circ=None, slash=None, tilde=None, cedil=None, ring=None, szlig=None, nonbreakablespace=None, aelig=None, AElig=None, Gamma=None, Delta=None, Theta=None, Lambda=None, Xi=None, Pi=None, Sigma=None, Upsilon=None, Phi=None, Psi=None, Omega=None, alpha=None, beta=None, gamma=None, delta=None, epsilon=None, zeta=None, eta=None, theta=None, iota=None, kappa=None, lambda_=None, mu=None, nu=None, xi=None, pi=None, rho=None, sigma=None, tau=None, upsilon=None, phi=None, chi=None, psi=None, omega=None, sigmaf=None, sect=None, deg=None, prime=None, Prime=None, infin=None, empty=None, plusmn=None, times=None, minus=None, sdot=None, part=None, nabla=None, radic=None, perp=None, sum=None, int=None, prod=None, sim=None, asymp=None, ne=None, equiv=None, prop=None, le=None, ge=None, larr=None, rarr=None, isin=None, notin=None, lceil=None, rceil=None, lfloor=None, rfloor=None, linebreak=None, hruler=None, preformatted=None, programlisting=None, verbatim=None, indexentry=None, orderedlist=None, itemizedlist=None, simplesect=None, title=None, variablelist=None, table=None, heading=None, image=None, dotfile=None, mscfile=None, diafile=None, toclist=None, language=None, parameterlist=None, xrefsect=None, copydoc=None, blockquote=None, parblock=None, valueOf_=None, mixedclass_=None, content_=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + if ulink is None: + self.ulink = [] + else: + self.ulink = ulink + self.ulink_nsprefix_ = None + if bold is None: + self.bold = [] + else: + self.bold = bold + self.bold_nsprefix_ = None + if emphasis is None: + self.emphasis = [] + else: + self.emphasis = emphasis + self.emphasis_nsprefix_ = None + if computeroutput is None: + self.computeroutput = [] + else: + self.computeroutput = computeroutput + self.computeroutput_nsprefix_ = None + if subscript is None: + self.subscript = [] + else: + self.subscript = subscript + self.subscript_nsprefix_ = None + if superscript is None: + self.superscript = [] + else: + self.superscript = superscript + self.superscript_nsprefix_ = None + if center is None: + self.center = [] + else: + self.center = center + self.center_nsprefix_ = None + if small is None: + self.small = [] + else: + self.small = small + self.small_nsprefix_ = None + if htmlonly is None: + self.htmlonly = [] + else: + self.htmlonly = htmlonly + self.htmlonly_nsprefix_ = None + if manonly is None: + self.manonly = [] + else: + self.manonly = manonly + self.manonly_nsprefix_ = None + if xmlonly is None: + self.xmlonly = [] + else: + self.xmlonly = xmlonly + self.xmlonly_nsprefix_ = None + if rtfonly is None: + self.rtfonly = [] + else: + self.rtfonly = rtfonly + self.rtfonly_nsprefix_ = None + if latexonly is None: + self.latexonly = [] + else: + self.latexonly = latexonly + self.latexonly_nsprefix_ = None + if dot is None: + self.dot = [] + else: + self.dot = dot + self.dot_nsprefix_ = None + if msc is None: + self.msc = [] + else: + self.msc = msc + self.msc_nsprefix_ = None + if anchor is None: + self.anchor = [] + else: + self.anchor = anchor + self.anchor_nsprefix_ = None + if formula is None: + self.formula = [] + else: + self.formula = formula + self.formula_nsprefix_ = None + if ref is None: + self.ref = [] + else: + self.ref = ref + self.ref_nsprefix_ = None + if copy is None: + self.copy = [] + else: + self.copy = copy + self.copy_nsprefix_ = None + if trademark is None: + self.trademark = [] + else: + self.trademark = trademark + self.trademark_nsprefix_ = None + if registered is None: + self.registered = [] + else: + self.registered = registered + self.registered_nsprefix_ = None + if lsquo is None: + self.lsquo = [] + else: + self.lsquo = lsquo + self.lsquo_nsprefix_ = None + if rsquo is None: + self.rsquo = [] + else: + self.rsquo = rsquo + self.rsquo_nsprefix_ = None + if ldquo is None: + self.ldquo = [] + else: + self.ldquo = ldquo + self.ldquo_nsprefix_ = None + if rdquo is None: + self.rdquo = [] + else: + self.rdquo = rdquo + self.rdquo_nsprefix_ = None + if ndash is None: + self.ndash = [] + else: + self.ndash = ndash + self.ndash_nsprefix_ = None + if mdash is None: + self.mdash = [] + else: + self.mdash = mdash + self.mdash_nsprefix_ = None + if umlaut is None: + self.umlaut = [] + else: + self.umlaut = umlaut + self.umlaut_nsprefix_ = None + if acute is None: + self.acute = [] + else: + self.acute = acute + self.acute_nsprefix_ = None + if grave is None: + self.grave = [] + else: + self.grave = grave + self.grave_nsprefix_ = None + if circ is None: + self.circ = [] + else: + self.circ = circ + self.circ_nsprefix_ = None + if slash is None: + self.slash = [] + else: + self.slash = slash + self.slash_nsprefix_ = None + if tilde is None: + self.tilde = [] + else: + self.tilde = tilde + self.tilde_nsprefix_ = None + if cedil is None: + self.cedil = [] + else: + self.cedil = cedil + self.cedil_nsprefix_ = None + if ring is None: + self.ring = [] + else: + self.ring = ring + self.ring_nsprefix_ = None + if szlig is None: + self.szlig = [] + else: + self.szlig = szlig + self.szlig_nsprefix_ = None + if nonbreakablespace is None: + self.nonbreakablespace = [] + else: + self.nonbreakablespace = nonbreakablespace + self.nonbreakablespace_nsprefix_ = None + if aelig is None: + self.aelig = [] + else: + self.aelig = aelig + self.aelig_nsprefix_ = None + if AElig is None: + self.AElig = [] + else: + self.AElig = AElig + self.AElig_nsprefix_ = None + if Gamma is None: + self.Gamma = [] + else: + self.Gamma = Gamma + self.Gamma_nsprefix_ = None + if Delta is None: + self.Delta = [] + else: + self.Delta = Delta + self.Delta_nsprefix_ = None + if Theta is None: + self.Theta = [] + else: + self.Theta = Theta + self.Theta_nsprefix_ = None + if Lambda is None: + self.Lambda = [] + else: + self.Lambda = Lambda + self.Lambda_nsprefix_ = None + if Xi is None: + self.Xi = [] + else: + self.Xi = Xi + self.Xi_nsprefix_ = None + if Pi is None: + self.Pi = [] + else: + self.Pi = Pi + self.Pi_nsprefix_ = None + if Sigma is None: + self.Sigma = [] + else: + self.Sigma = Sigma + self.Sigma_nsprefix_ = None + if Upsilon is None: + self.Upsilon = [] + else: + self.Upsilon = Upsilon + self.Upsilon_nsprefix_ = None + if Phi is None: + self.Phi = [] + else: + self.Phi = Phi + self.Phi_nsprefix_ = None + if Psi is None: + self.Psi = [] + else: + self.Psi = Psi + self.Psi_nsprefix_ = None + if Omega is None: + self.Omega = [] + else: + self.Omega = Omega + self.Omega_nsprefix_ = None + if alpha is None: + self.alpha = [] + else: + self.alpha = alpha + self.alpha_nsprefix_ = None + if beta is None: + self.beta = [] + else: + self.beta = beta + self.beta_nsprefix_ = None + if gamma is None: + self.gamma = [] + else: + self.gamma = gamma + self.gamma_nsprefix_ = None + if delta is None: + self.delta = [] + else: + self.delta = delta + self.delta_nsprefix_ = None + if epsilon is None: + self.epsilon = [] + else: + self.epsilon = epsilon + self.epsilon_nsprefix_ = None + if zeta is None: + self.zeta = [] + else: + self.zeta = zeta + self.zeta_nsprefix_ = None + if eta is None: + self.eta = [] + else: + self.eta = eta + self.eta_nsprefix_ = None + if theta is None: + self.theta = [] + else: + self.theta = theta + self.theta_nsprefix_ = None + if iota is None: + self.iota = [] + else: + self.iota = iota + self.iota_nsprefix_ = None + if kappa is None: + self.kappa = [] + else: + self.kappa = kappa + self.kappa_nsprefix_ = None + if lambda_ is None: + self.lambda_ = [] + else: + self.lambda_ = lambda_ + self.lambda__nsprefix_ = None + if mu is None: + self.mu = [] + else: + self.mu = mu + self.mu_nsprefix_ = None + if nu is None: + self.nu = [] + else: + self.nu = nu + self.nu_nsprefix_ = None + if xi is None: + self.xi = [] + else: + self.xi = xi + self.xi_nsprefix_ = None + if pi is None: + self.pi = [] + else: + self.pi = pi + self.pi_nsprefix_ = None + if rho is None: + self.rho = [] + else: + self.rho = rho + self.rho_nsprefix_ = None + if sigma is None: + self.sigma = [] + else: + self.sigma = sigma + self.sigma_nsprefix_ = None + if tau is None: + self.tau = [] + else: + self.tau = tau + self.tau_nsprefix_ = None + if upsilon is None: + self.upsilon = [] + else: + self.upsilon = upsilon + self.upsilon_nsprefix_ = None + if phi is None: + self.phi = [] + else: + self.phi = phi + self.phi_nsprefix_ = None + if chi is None: + self.chi = [] + else: + self.chi = chi + self.chi_nsprefix_ = None + if psi is None: + self.psi = [] + else: + self.psi = psi + self.psi_nsprefix_ = None + if omega is None: + self.omega = [] + else: + self.omega = omega + self.omega_nsprefix_ = None + if sigmaf is None: + self.sigmaf = [] + else: + self.sigmaf = sigmaf + self.sigmaf_nsprefix_ = None + if sect is None: + self.sect = [] + else: + self.sect = sect + self.sect_nsprefix_ = None + if deg is None: + self.deg = [] + else: + self.deg = deg + self.deg_nsprefix_ = None + if prime is None: + self.prime = [] + else: + self.prime = prime + self.prime_nsprefix_ = None + if Prime is None: + self.Prime = [] + else: + self.Prime = Prime + self.Prime_nsprefix_ = None + if infin is None: + self.infin = [] + else: + self.infin = infin + self.infin_nsprefix_ = None + if empty is None: + self.empty = [] + else: + self.empty = empty + self.empty_nsprefix_ = None + if plusmn is None: + self.plusmn = [] + else: + self.plusmn = plusmn + self.plusmn_nsprefix_ = None + if times is None: + self.times = [] + else: + self.times = times + self.times_nsprefix_ = None + if minus is None: + self.minus = [] + else: + self.minus = minus + self.minus_nsprefix_ = None + if sdot is None: + self.sdot = [] + else: + self.sdot = sdot + self.sdot_nsprefix_ = None + if part is None: + self.part = [] + else: + self.part = part + self.part_nsprefix_ = None + if nabla is None: + self.nabla = [] + else: + self.nabla = nabla + self.nabla_nsprefix_ = None + if radic is None: + self.radic = [] + else: + self.radic = radic + self.radic_nsprefix_ = None + if perp is None: + self.perp = [] + else: + self.perp = perp + self.perp_nsprefix_ = None + if sum is None: + self.sum = [] + else: + self.sum = sum + self.sum_nsprefix_ = None + if int is None: + self.int = [] + else: + self.int = int + self.int_nsprefix_ = None + if prod is None: + self.prod = [] + else: + self.prod = prod + self.prod_nsprefix_ = None + if sim is None: + self.sim = [] + else: + self.sim = sim + self.sim_nsprefix_ = None + if asymp is None: + self.asymp = [] + else: + self.asymp = asymp + self.asymp_nsprefix_ = None + if ne is None: + self.ne = [] + else: + self.ne = ne + self.ne_nsprefix_ = None + if equiv is None: + self.equiv = [] + else: + self.equiv = equiv + self.equiv_nsprefix_ = None + if prop is None: + self.prop = [] + else: + self.prop = prop + self.prop_nsprefix_ = None + if le is None: + self.le = [] + else: + self.le = le + self.le_nsprefix_ = None + if ge is None: + self.ge = [] + else: + self.ge = ge + self.ge_nsprefix_ = None + if larr is None: + self.larr = [] + else: + self.larr = larr + self.larr_nsprefix_ = None + if rarr is None: + self.rarr = [] + else: + self.rarr = rarr + self.rarr_nsprefix_ = None + if isin is None: + self.isin = [] + else: + self.isin = isin + self.isin_nsprefix_ = None + if notin is None: + self.notin = [] + else: + self.notin = notin + self.notin_nsprefix_ = None + if lceil is None: + self.lceil = [] + else: + self.lceil = lceil + self.lceil_nsprefix_ = None + if rceil is None: + self.rceil = [] + else: + self.rceil = rceil + self.rceil_nsprefix_ = None + if lfloor is None: + self.lfloor = [] + else: + self.lfloor = lfloor + self.lfloor_nsprefix_ = None + if rfloor is None: + self.rfloor = [] + else: + self.rfloor = rfloor + self.rfloor_nsprefix_ = None + if linebreak is None: + self.linebreak = [] + else: + self.linebreak = linebreak + self.linebreak_nsprefix_ = None + if hruler is None: + self.hruler = [] + else: + self.hruler = hruler + self.hruler_nsprefix_ = None + if preformatted is None: + self.preformatted = [] + else: + self.preformatted = preformatted + self.preformatted_nsprefix_ = None + if programlisting is None: + self.programlisting = [] + else: + self.programlisting = programlisting + self.programlisting_nsprefix_ = None + if verbatim is None: + self.verbatim = [] + else: + self.verbatim = verbatim + self.verbatim_nsprefix_ = None + if indexentry is None: + self.indexentry = [] + else: + self.indexentry = indexentry + self.indexentry_nsprefix_ = None + if orderedlist is None: + self.orderedlist = [] + else: + self.orderedlist = orderedlist + self.orderedlist_nsprefix_ = None + if itemizedlist is None: + self.itemizedlist = [] + else: + self.itemizedlist = itemizedlist + self.itemizedlist_nsprefix_ = None + if simplesect is None: + self.simplesect = [] + else: + self.simplesect = simplesect + self.simplesect_nsprefix_ = None + if title is None: + self.title = [] + else: + self.title = title + self.title_nsprefix_ = None + if variablelist is None: + self.variablelist = [] + else: + self.variablelist = variablelist + self.variablelist_nsprefix_ = None + if table is None: + self.table = [] + else: + self.table = table + self.table_nsprefix_ = None + if heading is None: + self.heading = [] + else: + self.heading = heading + self.heading_nsprefix_ = None + if image is None: + self.image = [] + else: + self.image = image + self.image_nsprefix_ = None + if dotfile is None: + self.dotfile = [] + else: + self.dotfile = dotfile + self.dotfile_nsprefix_ = None + if mscfile is None: + self.mscfile = [] + else: + self.mscfile = mscfile + self.mscfile_nsprefix_ = None + if diafile is None: + self.diafile = [] + else: + self.diafile = diafile + self.diafile_nsprefix_ = None + if toclist is None: + self.toclist = [] + else: + self.toclist = toclist + self.toclist_nsprefix_ = None + if language is None: + self.language = [] + else: + self.language = language + self.language_nsprefix_ = None + if parameterlist is None: + self.parameterlist = [] + else: + self.parameterlist = parameterlist + self.parameterlist_nsprefix_ = None + if xrefsect is None: + self.xrefsect = [] + else: + self.xrefsect = xrefsect + self.xrefsect_nsprefix_ = None + if copydoc is None: + self.copydoc = [] + else: + self.copydoc = copydoc + self.copydoc_nsprefix_ = None + if blockquote is None: + self.blockquote = [] + else: + self.blockquote = blockquote + self.blockquote_nsprefix_ = None + if parblock is None: + self.parblock = [] + else: + self.parblock = parblock + self.parblock_nsprefix_ = None + self.valueOf_ = valueOf_ + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + self.valueOf_ = valueOf_ + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docMarkupType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docMarkupType.subclass: + return docMarkupType.subclass(*args_, **kwargs_) + return docMarkupType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + def get_ulink(self): + return self.ulink + def set_ulink(self, ulink): + self.ulink = ulink + def add_ulink(self, value): + self.ulink.append(value) + def insert_ulink_at(self, index, value): + self.ulink.insert(index, value) + def replace_ulink_at(self, index, value): + self.ulink[index] = value + def get_bold(self): + return self.bold + def set_bold(self, bold): + self.bold = bold + def add_bold(self, value): + self.bold.append(value) + def insert_bold_at(self, index, value): + self.bold.insert(index, value) + def replace_bold_at(self, index, value): + self.bold[index] = value + def get_emphasis(self): + return self.emphasis + def set_emphasis(self, emphasis): + self.emphasis = emphasis + def add_emphasis(self, value): + self.emphasis.append(value) + def insert_emphasis_at(self, index, value): + self.emphasis.insert(index, value) + def replace_emphasis_at(self, index, value): + self.emphasis[index] = value + def get_computeroutput(self): + return self.computeroutput + def set_computeroutput(self, computeroutput): + self.computeroutput = computeroutput + def add_computeroutput(self, value): + self.computeroutput.append(value) + def insert_computeroutput_at(self, index, value): + self.computeroutput.insert(index, value) + def replace_computeroutput_at(self, index, value): + self.computeroutput[index] = value + def get_subscript(self): + return self.subscript + def set_subscript(self, subscript): + self.subscript = subscript + def add_subscript(self, value): + self.subscript.append(value) + def insert_subscript_at(self, index, value): + self.subscript.insert(index, value) + def replace_subscript_at(self, index, value): + self.subscript[index] = value + def get_superscript(self): + return self.superscript + def set_superscript(self, superscript): + self.superscript = superscript + def add_superscript(self, value): + self.superscript.append(value) + def insert_superscript_at(self, index, value): + self.superscript.insert(index, value) + def replace_superscript_at(self, index, value): + self.superscript[index] = value + def get_center(self): + return self.center + def set_center(self, center): + self.center = center + def add_center(self, value): + self.center.append(value) + def insert_center_at(self, index, value): + self.center.insert(index, value) + def replace_center_at(self, index, value): + self.center[index] = value + def get_small(self): + return self.small + def set_small(self, small): + self.small = small + def add_small(self, value): + self.small.append(value) + def insert_small_at(self, index, value): + self.small.insert(index, value) + def replace_small_at(self, index, value): + self.small[index] = value + def get_htmlonly(self): + return self.htmlonly + def set_htmlonly(self, htmlonly): + self.htmlonly = htmlonly + def add_htmlonly(self, value): + self.htmlonly.append(value) + def insert_htmlonly_at(self, index, value): + self.htmlonly.insert(index, value) + def replace_htmlonly_at(self, index, value): + self.htmlonly[index] = value + def get_manonly(self): + return self.manonly + def set_manonly(self, manonly): + self.manonly = manonly + def add_manonly(self, value): + self.manonly.append(value) + def insert_manonly_at(self, index, value): + self.manonly.insert(index, value) + def replace_manonly_at(self, index, value): + self.manonly[index] = value + def get_xmlonly(self): + return self.xmlonly + def set_xmlonly(self, xmlonly): + self.xmlonly = xmlonly + def add_xmlonly(self, value): + self.xmlonly.append(value) + def insert_xmlonly_at(self, index, value): + self.xmlonly.insert(index, value) + def replace_xmlonly_at(self, index, value): + self.xmlonly[index] = value + def get_rtfonly(self): + return self.rtfonly + def set_rtfonly(self, rtfonly): + self.rtfonly = rtfonly + def add_rtfonly(self, value): + self.rtfonly.append(value) + def insert_rtfonly_at(self, index, value): + self.rtfonly.insert(index, value) + def replace_rtfonly_at(self, index, value): + self.rtfonly[index] = value + def get_latexonly(self): + return self.latexonly + def set_latexonly(self, latexonly): + self.latexonly = latexonly + def add_latexonly(self, value): + self.latexonly.append(value) + def insert_latexonly_at(self, index, value): + self.latexonly.insert(index, value) + def replace_latexonly_at(self, index, value): + self.latexonly[index] = value + def get_dot(self): + return self.dot + def set_dot(self, dot): + self.dot = dot + def add_dot(self, value): + self.dot.append(value) + def insert_dot_at(self, index, value): + self.dot.insert(index, value) + def replace_dot_at(self, index, value): + self.dot[index] = value + def get_msc(self): + return self.msc + def set_msc(self, msc): + self.msc = msc + def add_msc(self, value): + self.msc.append(value) + def insert_msc_at(self, index, value): + self.msc.insert(index, value) + def replace_msc_at(self, index, value): + self.msc[index] = value + def get_anchor(self): + return self.anchor + def set_anchor(self, anchor): + self.anchor = anchor + def add_anchor(self, value): + self.anchor.append(value) + def insert_anchor_at(self, index, value): + self.anchor.insert(index, value) + def replace_anchor_at(self, index, value): + self.anchor[index] = value + def get_formula(self): + return self.formula + def set_formula(self, formula): + self.formula = formula + def add_formula(self, value): + self.formula.append(value) + def insert_formula_at(self, index, value): + self.formula.insert(index, value) + def replace_formula_at(self, index, value): + self.formula[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_at(self, index, value): + self.ref.insert(index, value) + def replace_ref_at(self, index, value): + self.ref[index] = value + def get_copy(self): + return self.copy + def set_copy(self, copy): + self.copy = copy + def add_copy(self, value): + self.copy.append(value) + def insert_copy_at(self, index, value): + self.copy.insert(index, value) + def replace_copy_at(self, index, value): + self.copy[index] = value + def get_trademark(self): + return self.trademark + def set_trademark(self, trademark): + self.trademark = trademark + def add_trademark(self, value): + self.trademark.append(value) + def insert_trademark_at(self, index, value): + self.trademark.insert(index, value) + def replace_trademark_at(self, index, value): + self.trademark[index] = value + def get_registered(self): + return self.registered + def set_registered(self, registered): + self.registered = registered + def add_registered(self, value): + self.registered.append(value) + def insert_registered_at(self, index, value): + self.registered.insert(index, value) + def replace_registered_at(self, index, value): + self.registered[index] = value + def get_lsquo(self): + return self.lsquo + def set_lsquo(self, lsquo): + self.lsquo = lsquo + def add_lsquo(self, value): + self.lsquo.append(value) + def insert_lsquo_at(self, index, value): + self.lsquo.insert(index, value) + def replace_lsquo_at(self, index, value): + self.lsquo[index] = value + def get_rsquo(self): + return self.rsquo + def set_rsquo(self, rsquo): + self.rsquo = rsquo + def add_rsquo(self, value): + self.rsquo.append(value) + def insert_rsquo_at(self, index, value): + self.rsquo.insert(index, value) + def replace_rsquo_at(self, index, value): + self.rsquo[index] = value + def get_ldquo(self): + return self.ldquo + def set_ldquo(self, ldquo): + self.ldquo = ldquo + def add_ldquo(self, value): + self.ldquo.append(value) + def insert_ldquo_at(self, index, value): + self.ldquo.insert(index, value) + def replace_ldquo_at(self, index, value): + self.ldquo[index] = value + def get_rdquo(self): + return self.rdquo + def set_rdquo(self, rdquo): + self.rdquo = rdquo + def add_rdquo(self, value): + self.rdquo.append(value) + def insert_rdquo_at(self, index, value): + self.rdquo.insert(index, value) + def replace_rdquo_at(self, index, value): + self.rdquo[index] = value + def get_ndash(self): + return self.ndash + def set_ndash(self, ndash): + self.ndash = ndash + def add_ndash(self, value): + self.ndash.append(value) + def insert_ndash_at(self, index, value): + self.ndash.insert(index, value) + def replace_ndash_at(self, index, value): + self.ndash[index] = value + def get_mdash(self): + return self.mdash + def set_mdash(self, mdash): + self.mdash = mdash + def add_mdash(self, value): + self.mdash.append(value) + def insert_mdash_at(self, index, value): + self.mdash.insert(index, value) + def replace_mdash_at(self, index, value): + self.mdash[index] = value + def get_umlaut(self): + return self.umlaut + def set_umlaut(self, umlaut): + self.umlaut = umlaut + def add_umlaut(self, value): + self.umlaut.append(value) + def insert_umlaut_at(self, index, value): + self.umlaut.insert(index, value) + def replace_umlaut_at(self, index, value): + self.umlaut[index] = value + def get_acute(self): + return self.acute + def set_acute(self, acute): + self.acute = acute + def add_acute(self, value): + self.acute.append(value) + def insert_acute_at(self, index, value): + self.acute.insert(index, value) + def replace_acute_at(self, index, value): + self.acute[index] = value + def get_grave(self): + return self.grave + def set_grave(self, grave): + self.grave = grave + def add_grave(self, value): + self.grave.append(value) + def insert_grave_at(self, index, value): + self.grave.insert(index, value) + def replace_grave_at(self, index, value): + self.grave[index] = value + def get_circ(self): + return self.circ + def set_circ(self, circ): + self.circ = circ + def add_circ(self, value): + self.circ.append(value) + def insert_circ_at(self, index, value): + self.circ.insert(index, value) + def replace_circ_at(self, index, value): + self.circ[index] = value + def get_slash(self): + return self.slash + def set_slash(self, slash): + self.slash = slash + def add_slash(self, value): + self.slash.append(value) + def insert_slash_at(self, index, value): + self.slash.insert(index, value) + def replace_slash_at(self, index, value): + self.slash[index] = value + def get_tilde(self): + return self.tilde + def set_tilde(self, tilde): + self.tilde = tilde + def add_tilde(self, value): + self.tilde.append(value) + def insert_tilde_at(self, index, value): + self.tilde.insert(index, value) + def replace_tilde_at(self, index, value): + self.tilde[index] = value + def get_cedil(self): + return self.cedil + def set_cedil(self, cedil): + self.cedil = cedil + def add_cedil(self, value): + self.cedil.append(value) + def insert_cedil_at(self, index, value): + self.cedil.insert(index, value) + def replace_cedil_at(self, index, value): + self.cedil[index] = value + def get_ring(self): + return self.ring + def set_ring(self, ring): + self.ring = ring + def add_ring(self, value): + self.ring.append(value) + def insert_ring_at(self, index, value): + self.ring.insert(index, value) + def replace_ring_at(self, index, value): + self.ring[index] = value + def get_szlig(self): + return self.szlig + def set_szlig(self, szlig): + self.szlig = szlig + def add_szlig(self, value): + self.szlig.append(value) + def insert_szlig_at(self, index, value): + self.szlig.insert(index, value) + def replace_szlig_at(self, index, value): + self.szlig[index] = value + def get_nonbreakablespace(self): + return self.nonbreakablespace + def set_nonbreakablespace(self, nonbreakablespace): + self.nonbreakablespace = nonbreakablespace + def add_nonbreakablespace(self, value): + self.nonbreakablespace.append(value) + def insert_nonbreakablespace_at(self, index, value): + self.nonbreakablespace.insert(index, value) + def replace_nonbreakablespace_at(self, index, value): + self.nonbreakablespace[index] = value + def get_aelig(self): + return self.aelig + def set_aelig(self, aelig): + self.aelig = aelig + def add_aelig(self, value): + self.aelig.append(value) + def insert_aelig_at(self, index, value): + self.aelig.insert(index, value) + def replace_aelig_at(self, index, value): + self.aelig[index] = value + def get_AElig(self): + return self.AElig + def set_AElig(self, AElig): + self.AElig = AElig + def add_AElig(self, value): + self.AElig.append(value) + def insert_AElig_at(self, index, value): + self.AElig.insert(index, value) + def replace_AElig_at(self, index, value): + self.AElig[index] = value + def get_Gamma(self): + return self.Gamma + def set_Gamma(self, Gamma): + self.Gamma = Gamma + def add_Gamma(self, value): + self.Gamma.append(value) + def insert_Gamma_at(self, index, value): + self.Gamma.insert(index, value) + def replace_Gamma_at(self, index, value): + self.Gamma[index] = value + def get_Delta(self): + return self.Delta + def set_Delta(self, Delta): + self.Delta = Delta + def add_Delta(self, value): + self.Delta.append(value) + def insert_Delta_at(self, index, value): + self.Delta.insert(index, value) + def replace_Delta_at(self, index, value): + self.Delta[index] = value + def get_Theta(self): + return self.Theta + def set_Theta(self, Theta): + self.Theta = Theta + def add_Theta(self, value): + self.Theta.append(value) + def insert_Theta_at(self, index, value): + self.Theta.insert(index, value) + def replace_Theta_at(self, index, value): + self.Theta[index] = value + def get_Lambda(self): + return self.Lambda + def set_Lambda(self, Lambda): + self.Lambda = Lambda + def add_Lambda(self, value): + self.Lambda.append(value) + def insert_Lambda_at(self, index, value): + self.Lambda.insert(index, value) + def replace_Lambda_at(self, index, value): + self.Lambda[index] = value + def get_Xi(self): + return self.Xi + def set_Xi(self, Xi): + self.Xi = Xi + def add_Xi(self, value): + self.Xi.append(value) + def insert_Xi_at(self, index, value): + self.Xi.insert(index, value) + def replace_Xi_at(self, index, value): + self.Xi[index] = value + def get_Pi(self): + return self.Pi + def set_Pi(self, Pi): + self.Pi = Pi + def add_Pi(self, value): + self.Pi.append(value) + def insert_Pi_at(self, index, value): + self.Pi.insert(index, value) + def replace_Pi_at(self, index, value): + self.Pi[index] = value + def get_Sigma(self): + return self.Sigma + def set_Sigma(self, Sigma): + self.Sigma = Sigma + def add_Sigma(self, value): + self.Sigma.append(value) + def insert_Sigma_at(self, index, value): + self.Sigma.insert(index, value) + def replace_Sigma_at(self, index, value): + self.Sigma[index] = value + def get_Upsilon(self): + return self.Upsilon + def set_Upsilon(self, Upsilon): + self.Upsilon = Upsilon + def add_Upsilon(self, value): + self.Upsilon.append(value) + def insert_Upsilon_at(self, index, value): + self.Upsilon.insert(index, value) + def replace_Upsilon_at(self, index, value): + self.Upsilon[index] = value + def get_Phi(self): + return self.Phi + def set_Phi(self, Phi): + self.Phi = Phi + def add_Phi(self, value): + self.Phi.append(value) + def insert_Phi_at(self, index, value): + self.Phi.insert(index, value) + def replace_Phi_at(self, index, value): + self.Phi[index] = value + def get_Psi(self): + return self.Psi + def set_Psi(self, Psi): + self.Psi = Psi + def add_Psi(self, value): + self.Psi.append(value) + def insert_Psi_at(self, index, value): + self.Psi.insert(index, value) + def replace_Psi_at(self, index, value): + self.Psi[index] = value + def get_Omega(self): + return self.Omega + def set_Omega(self, Omega): + self.Omega = Omega + def add_Omega(self, value): + self.Omega.append(value) + def insert_Omega_at(self, index, value): + self.Omega.insert(index, value) + def replace_Omega_at(self, index, value): + self.Omega[index] = value + def get_alpha(self): + return self.alpha + def set_alpha(self, alpha): + self.alpha = alpha + def add_alpha(self, value): + self.alpha.append(value) + def insert_alpha_at(self, index, value): + self.alpha.insert(index, value) + def replace_alpha_at(self, index, value): + self.alpha[index] = value + def get_beta(self): + return self.beta + def set_beta(self, beta): + self.beta = beta + def add_beta(self, value): + self.beta.append(value) + def insert_beta_at(self, index, value): + self.beta.insert(index, value) + def replace_beta_at(self, index, value): + self.beta[index] = value + def get_gamma(self): + return self.gamma + def set_gamma(self, gamma): + self.gamma = gamma + def add_gamma(self, value): + self.gamma.append(value) + def insert_gamma_at(self, index, value): + self.gamma.insert(index, value) + def replace_gamma_at(self, index, value): + self.gamma[index] = value + def get_delta(self): + return self.delta + def set_delta(self, delta): + self.delta = delta + def add_delta(self, value): + self.delta.append(value) + def insert_delta_at(self, index, value): + self.delta.insert(index, value) + def replace_delta_at(self, index, value): + self.delta[index] = value + def get_epsilon(self): + return self.epsilon + def set_epsilon(self, epsilon): + self.epsilon = epsilon + def add_epsilon(self, value): + self.epsilon.append(value) + def insert_epsilon_at(self, index, value): + self.epsilon.insert(index, value) + def replace_epsilon_at(self, index, value): + self.epsilon[index] = value + def get_zeta(self): + return self.zeta + def set_zeta(self, zeta): + self.zeta = zeta + def add_zeta(self, value): + self.zeta.append(value) + def insert_zeta_at(self, index, value): + self.zeta.insert(index, value) + def replace_zeta_at(self, index, value): + self.zeta[index] = value + def get_eta(self): + return self.eta + def set_eta(self, eta): + self.eta = eta + def add_eta(self, value): + self.eta.append(value) + def insert_eta_at(self, index, value): + self.eta.insert(index, value) + def replace_eta_at(self, index, value): + self.eta[index] = value + def get_theta(self): + return self.theta + def set_theta(self, theta): + self.theta = theta + def add_theta(self, value): + self.theta.append(value) + def insert_theta_at(self, index, value): + self.theta.insert(index, value) + def replace_theta_at(self, index, value): + self.theta[index] = value + def get_iota(self): + return self.iota + def set_iota(self, iota): + self.iota = iota + def add_iota(self, value): + self.iota.append(value) + def insert_iota_at(self, index, value): + self.iota.insert(index, value) + def replace_iota_at(self, index, value): + self.iota[index] = value + def get_kappa(self): + return self.kappa + def set_kappa(self, kappa): + self.kappa = kappa + def add_kappa(self, value): + self.kappa.append(value) + def insert_kappa_at(self, index, value): + self.kappa.insert(index, value) + def replace_kappa_at(self, index, value): + self.kappa[index] = value + def get_lambda(self): + return self.lambda_ + def set_lambda(self, lambda_): + self.lambda_ = lambda_ + def add_lambda(self, value): + self.lambda_.append(value) + def insert_lambda_at(self, index, value): + self.lambda_.insert(index, value) + def replace_lambda_at(self, index, value): + self.lambda_[index] = value + def get_mu(self): + return self.mu + def set_mu(self, mu): + self.mu = mu + def add_mu(self, value): + self.mu.append(value) + def insert_mu_at(self, index, value): + self.mu.insert(index, value) + def replace_mu_at(self, index, value): + self.mu[index] = value + def get_nu(self): + return self.nu + def set_nu(self, nu): + self.nu = nu + def add_nu(self, value): + self.nu.append(value) + def insert_nu_at(self, index, value): + self.nu.insert(index, value) + def replace_nu_at(self, index, value): + self.nu[index] = value + def get_xi(self): + return self.xi + def set_xi(self, xi): + self.xi = xi + def add_xi(self, value): + self.xi.append(value) + def insert_xi_at(self, index, value): + self.xi.insert(index, value) + def replace_xi_at(self, index, value): + self.xi[index] = value + def get_pi(self): + return self.pi + def set_pi(self, pi): + self.pi = pi + def add_pi(self, value): + self.pi.append(value) + def insert_pi_at(self, index, value): + self.pi.insert(index, value) + def replace_pi_at(self, index, value): + self.pi[index] = value + def get_rho(self): + return self.rho + def set_rho(self, rho): + self.rho = rho + def add_rho(self, value): + self.rho.append(value) + def insert_rho_at(self, index, value): + self.rho.insert(index, value) + def replace_rho_at(self, index, value): + self.rho[index] = value + def get_sigma(self): + return self.sigma + def set_sigma(self, sigma): + self.sigma = sigma + def add_sigma(self, value): + self.sigma.append(value) + def insert_sigma_at(self, index, value): + self.sigma.insert(index, value) + def replace_sigma_at(self, index, value): + self.sigma[index] = value + def get_tau(self): + return self.tau + def set_tau(self, tau): + self.tau = tau + def add_tau(self, value): + self.tau.append(value) + def insert_tau_at(self, index, value): + self.tau.insert(index, value) + def replace_tau_at(self, index, value): + self.tau[index] = value + def get_upsilon(self): + return self.upsilon + def set_upsilon(self, upsilon): + self.upsilon = upsilon + def add_upsilon(self, value): + self.upsilon.append(value) + def insert_upsilon_at(self, index, value): + self.upsilon.insert(index, value) + def replace_upsilon_at(self, index, value): + self.upsilon[index] = value + def get_phi(self): + return self.phi + def set_phi(self, phi): + self.phi = phi + def add_phi(self, value): + self.phi.append(value) + def insert_phi_at(self, index, value): + self.phi.insert(index, value) + def replace_phi_at(self, index, value): + self.phi[index] = value + def get_chi(self): + return self.chi + def set_chi(self, chi): + self.chi = chi + def add_chi(self, value): + self.chi.append(value) + def insert_chi_at(self, index, value): + self.chi.insert(index, value) + def replace_chi_at(self, index, value): + self.chi[index] = value + def get_psi(self): + return self.psi + def set_psi(self, psi): + self.psi = psi + def add_psi(self, value): + self.psi.append(value) + def insert_psi_at(self, index, value): + self.psi.insert(index, value) + def replace_psi_at(self, index, value): + self.psi[index] = value + def get_omega(self): + return self.omega + def set_omega(self, omega): + self.omega = omega + def add_omega(self, value): + self.omega.append(value) + def insert_omega_at(self, index, value): + self.omega.insert(index, value) + def replace_omega_at(self, index, value): + self.omega[index] = value + def get_sigmaf(self): + return self.sigmaf + def set_sigmaf(self, sigmaf): + self.sigmaf = sigmaf + def add_sigmaf(self, value): + self.sigmaf.append(value) + def insert_sigmaf_at(self, index, value): + self.sigmaf.insert(index, value) + def replace_sigmaf_at(self, index, value): + self.sigmaf[index] = value + def get_sect(self): + return self.sect + def set_sect(self, sect): + self.sect = sect + def add_sect(self, value): + self.sect.append(value) + def insert_sect_at(self, index, value): + self.sect.insert(index, value) + def replace_sect_at(self, index, value): + self.sect[index] = value + def get_deg(self): + return self.deg + def set_deg(self, deg): + self.deg = deg + def add_deg(self, value): + self.deg.append(value) + def insert_deg_at(self, index, value): + self.deg.insert(index, value) + def replace_deg_at(self, index, value): + self.deg[index] = value + def get_prime(self): + return self.prime + def set_prime(self, prime): + self.prime = prime + def add_prime(self, value): + self.prime.append(value) + def insert_prime_at(self, index, value): + self.prime.insert(index, value) + def replace_prime_at(self, index, value): + self.prime[index] = value + def get_Prime(self): + return self.Prime + def set_Prime(self, Prime): + self.Prime = Prime + def add_Prime(self, value): + self.Prime.append(value) + def insert_Prime_at(self, index, value): + self.Prime.insert(index, value) + def replace_Prime_at(self, index, value): + self.Prime[index] = value + def get_infin(self): + return self.infin + def set_infin(self, infin): + self.infin = infin + def add_infin(self, value): + self.infin.append(value) + def insert_infin_at(self, index, value): + self.infin.insert(index, value) + def replace_infin_at(self, index, value): + self.infin[index] = value + def get_empty(self): + return self.empty + def set_empty(self, empty): + self.empty = empty + def add_empty(self, value): + self.empty.append(value) + def insert_empty_at(self, index, value): + self.empty.insert(index, value) + def replace_empty_at(self, index, value): + self.empty[index] = value + def get_plusmn(self): + return self.plusmn + def set_plusmn(self, plusmn): + self.plusmn = plusmn + def add_plusmn(self, value): + self.plusmn.append(value) + def insert_plusmn_at(self, index, value): + self.plusmn.insert(index, value) + def replace_plusmn_at(self, index, value): + self.plusmn[index] = value + def get_times(self): + return self.times + def set_times(self, times): + self.times = times + def add_times(self, value): + self.times.append(value) + def insert_times_at(self, index, value): + self.times.insert(index, value) + def replace_times_at(self, index, value): + self.times[index] = value + def get_minus(self): + return self.minus + def set_minus(self, minus): + self.minus = minus + def add_minus(self, value): + self.minus.append(value) + def insert_minus_at(self, index, value): + self.minus.insert(index, value) + def replace_minus_at(self, index, value): + self.minus[index] = value + def get_sdot(self): + return self.sdot + def set_sdot(self, sdot): + self.sdot = sdot + def add_sdot(self, value): + self.sdot.append(value) + def insert_sdot_at(self, index, value): + self.sdot.insert(index, value) + def replace_sdot_at(self, index, value): + self.sdot[index] = value + def get_part(self): + return self.part + def set_part(self, part): + self.part = part + def add_part(self, value): + self.part.append(value) + def insert_part_at(self, index, value): + self.part.insert(index, value) + def replace_part_at(self, index, value): + self.part[index] = value + def get_nabla(self): + return self.nabla + def set_nabla(self, nabla): + self.nabla = nabla + def add_nabla(self, value): + self.nabla.append(value) + def insert_nabla_at(self, index, value): + self.nabla.insert(index, value) + def replace_nabla_at(self, index, value): + self.nabla[index] = value + def get_radic(self): + return self.radic + def set_radic(self, radic): + self.radic = radic + def add_radic(self, value): + self.radic.append(value) + def insert_radic_at(self, index, value): + self.radic.insert(index, value) + def replace_radic_at(self, index, value): + self.radic[index] = value + def get_perp(self): + return self.perp + def set_perp(self, perp): + self.perp = perp + def add_perp(self, value): + self.perp.append(value) + def insert_perp_at(self, index, value): + self.perp.insert(index, value) + def replace_perp_at(self, index, value): + self.perp[index] = value + def get_sum(self): + return self.sum + def set_sum(self, sum): + self.sum = sum + def add_sum(self, value): + self.sum.append(value) + def insert_sum_at(self, index, value): + self.sum.insert(index, value) + def replace_sum_at(self, index, value): + self.sum[index] = value + def get_int(self): + return self.int + def set_int(self, int): + self.int = int + def add_int(self, value): + self.int.append(value) + def insert_int_at(self, index, value): + self.int.insert(index, value) + def replace_int_at(self, index, value): + self.int[index] = value + def get_prod(self): + return self.prod + def set_prod(self, prod): + self.prod = prod + def add_prod(self, value): + self.prod.append(value) + def insert_prod_at(self, index, value): + self.prod.insert(index, value) + def replace_prod_at(self, index, value): + self.prod[index] = value + def get_sim(self): + return self.sim + def set_sim(self, sim): + self.sim = sim + def add_sim(self, value): + self.sim.append(value) + def insert_sim_at(self, index, value): + self.sim.insert(index, value) + def replace_sim_at(self, index, value): + self.sim[index] = value + def get_asymp(self): + return self.asymp + def set_asymp(self, asymp): + self.asymp = asymp + def add_asymp(self, value): + self.asymp.append(value) + def insert_asymp_at(self, index, value): + self.asymp.insert(index, value) + def replace_asymp_at(self, index, value): + self.asymp[index] = value + def get_ne(self): + return self.ne + def set_ne(self, ne): + self.ne = ne + def add_ne(self, value): + self.ne.append(value) + def insert_ne_at(self, index, value): + self.ne.insert(index, value) + def replace_ne_at(self, index, value): + self.ne[index] = value + def get_equiv(self): + return self.equiv + def set_equiv(self, equiv): + self.equiv = equiv + def add_equiv(self, value): + self.equiv.append(value) + def insert_equiv_at(self, index, value): + self.equiv.insert(index, value) + def replace_equiv_at(self, index, value): + self.equiv[index] = value + def get_prop(self): + return self.prop + def set_prop(self, prop): + self.prop = prop + def add_prop(self, value): + self.prop.append(value) + def insert_prop_at(self, index, value): + self.prop.insert(index, value) + def replace_prop_at(self, index, value): + self.prop[index] = value + def get_le(self): + return self.le + def set_le(self, le): + self.le = le + def add_le(self, value): + self.le.append(value) + def insert_le_at(self, index, value): + self.le.insert(index, value) + def replace_le_at(self, index, value): + self.le[index] = value + def get_ge(self): + return self.ge + def set_ge(self, ge): + self.ge = ge + def add_ge(self, value): + self.ge.append(value) + def insert_ge_at(self, index, value): + self.ge.insert(index, value) + def replace_ge_at(self, index, value): + self.ge[index] = value + def get_larr(self): + return self.larr + def set_larr(self, larr): + self.larr = larr + def add_larr(self, value): + self.larr.append(value) + def insert_larr_at(self, index, value): + self.larr.insert(index, value) + def replace_larr_at(self, index, value): + self.larr[index] = value + def get_rarr(self): + return self.rarr + def set_rarr(self, rarr): + self.rarr = rarr + def add_rarr(self, value): + self.rarr.append(value) + def insert_rarr_at(self, index, value): + self.rarr.insert(index, value) + def replace_rarr_at(self, index, value): + self.rarr[index] = value + def get_isin(self): + return self.isin + def set_isin(self, isin): + self.isin = isin + def add_isin(self, value): + self.isin.append(value) + def insert_isin_at(self, index, value): + self.isin.insert(index, value) + def replace_isin_at(self, index, value): + self.isin[index] = value + def get_notin(self): + return self.notin + def set_notin(self, notin): + self.notin = notin + def add_notin(self, value): + self.notin.append(value) + def insert_notin_at(self, index, value): + self.notin.insert(index, value) + def replace_notin_at(self, index, value): + self.notin[index] = value + def get_lceil(self): + return self.lceil + def set_lceil(self, lceil): + self.lceil = lceil + def add_lceil(self, value): + self.lceil.append(value) + def insert_lceil_at(self, index, value): + self.lceil.insert(index, value) + def replace_lceil_at(self, index, value): + self.lceil[index] = value + def get_rceil(self): + return self.rceil + def set_rceil(self, rceil): + self.rceil = rceil + def add_rceil(self, value): + self.rceil.append(value) + def insert_rceil_at(self, index, value): + self.rceil.insert(index, value) + def replace_rceil_at(self, index, value): + self.rceil[index] = value + def get_lfloor(self): + return self.lfloor + def set_lfloor(self, lfloor): + self.lfloor = lfloor + def add_lfloor(self, value): + self.lfloor.append(value) + def insert_lfloor_at(self, index, value): + self.lfloor.insert(index, value) + def replace_lfloor_at(self, index, value): + self.lfloor[index] = value + def get_rfloor(self): + return self.rfloor + def set_rfloor(self, rfloor): + self.rfloor = rfloor + def add_rfloor(self, value): + self.rfloor.append(value) + def insert_rfloor_at(self, index, value): + self.rfloor.insert(index, value) + def replace_rfloor_at(self, index, value): + self.rfloor[index] = value + def get_linebreak(self): + return self.linebreak + def set_linebreak(self, linebreak): + self.linebreak = linebreak + def add_linebreak(self, value): + self.linebreak.append(value) + def insert_linebreak_at(self, index, value): + self.linebreak.insert(index, value) + def replace_linebreak_at(self, index, value): + self.linebreak[index] = value + def get_hruler(self): + return self.hruler + def set_hruler(self, hruler): + self.hruler = hruler + def add_hruler(self, value): + self.hruler.append(value) + def insert_hruler_at(self, index, value): + self.hruler.insert(index, value) + def replace_hruler_at(self, index, value): + self.hruler[index] = value + def get_preformatted(self): + return self.preformatted + def set_preformatted(self, preformatted): + self.preformatted = preformatted + def add_preformatted(self, value): + self.preformatted.append(value) + def insert_preformatted_at(self, index, value): + self.preformatted.insert(index, value) + def replace_preformatted_at(self, index, value): + self.preformatted[index] = value + def get_programlisting(self): + return self.programlisting + def set_programlisting(self, programlisting): + self.programlisting = programlisting + def add_programlisting(self, value): + self.programlisting.append(value) + def insert_programlisting_at(self, index, value): + self.programlisting.insert(index, value) + def replace_programlisting_at(self, index, value): + self.programlisting[index] = value + def get_verbatim(self): + return self.verbatim + def set_verbatim(self, verbatim): + self.verbatim = verbatim + def add_verbatim(self, value): + self.verbatim.append(value) + def insert_verbatim_at(self, index, value): + self.verbatim.insert(index, value) + def replace_verbatim_at(self, index, value): + self.verbatim[index] = value + def get_indexentry(self): + return self.indexentry + def set_indexentry(self, indexentry): + self.indexentry = indexentry + def add_indexentry(self, value): + self.indexentry.append(value) + def insert_indexentry_at(self, index, value): + self.indexentry.insert(index, value) + def replace_indexentry_at(self, index, value): + self.indexentry[index] = value + def get_orderedlist(self): + return self.orderedlist + def set_orderedlist(self, orderedlist): + self.orderedlist = orderedlist + def add_orderedlist(self, value): + self.orderedlist.append(value) + def insert_orderedlist_at(self, index, value): + self.orderedlist.insert(index, value) + def replace_orderedlist_at(self, index, value): + self.orderedlist[index] = value + def get_itemizedlist(self): + return self.itemizedlist + def set_itemizedlist(self, itemizedlist): + self.itemizedlist = itemizedlist + def add_itemizedlist(self, value): + self.itemizedlist.append(value) + def insert_itemizedlist_at(self, index, value): + self.itemizedlist.insert(index, value) + def replace_itemizedlist_at(self, index, value): + self.itemizedlist[index] = value + def get_simplesect(self): + return self.simplesect + def set_simplesect(self, simplesect): + self.simplesect = simplesect + def add_simplesect(self, value): + self.simplesect.append(value) + def insert_simplesect_at(self, index, value): + self.simplesect.insert(index, value) + def replace_simplesect_at(self, index, value): + self.simplesect[index] = value + def get_title(self): + return self.title + def set_title(self, title): + self.title = title + def add_title(self, value): + self.title.append(value) + def insert_title_at(self, index, value): + self.title.insert(index, value) + def replace_title_at(self, index, value): + self.title[index] = value + def get_variablelist(self): + return self.variablelist + def set_variablelist(self, variablelist): + self.variablelist = variablelist + def add_variablelist(self, value): + self.variablelist.append(value) + def insert_variablelist_at(self, index, value): + self.variablelist.insert(index, value) + def replace_variablelist_at(self, index, value): + self.variablelist[index] = value + def get_table(self): + return self.table + def set_table(self, table): + self.table = table + def add_table(self, value): + self.table.append(value) + def insert_table_at(self, index, value): + self.table.insert(index, value) + def replace_table_at(self, index, value): + self.table[index] = value + def get_heading(self): + return self.heading + def set_heading(self, heading): + self.heading = heading + def add_heading(self, value): + self.heading.append(value) + def insert_heading_at(self, index, value): + self.heading.insert(index, value) + def replace_heading_at(self, index, value): + self.heading[index] = value + def get_image(self): + return self.image + def set_image(self, image): + self.image = image + def add_image(self, value): + self.image.append(value) + def insert_image_at(self, index, value): + self.image.insert(index, value) + def replace_image_at(self, index, value): + self.image[index] = value + def get_dotfile(self): + return self.dotfile + def set_dotfile(self, dotfile): + self.dotfile = dotfile + def add_dotfile(self, value): + self.dotfile.append(value) + def insert_dotfile_at(self, index, value): + self.dotfile.insert(index, value) + def replace_dotfile_at(self, index, value): + self.dotfile[index] = value + def get_mscfile(self): + return self.mscfile + def set_mscfile(self, mscfile): + self.mscfile = mscfile + def add_mscfile(self, value): + self.mscfile.append(value) + def insert_mscfile_at(self, index, value): + self.mscfile.insert(index, value) + def replace_mscfile_at(self, index, value): + self.mscfile[index] = value + def get_diafile(self): + return self.diafile + def set_diafile(self, diafile): + self.diafile = diafile + def add_diafile(self, value): + self.diafile.append(value) + def insert_diafile_at(self, index, value): + self.diafile.insert(index, value) + def replace_diafile_at(self, index, value): + self.diafile[index] = value + def get_toclist(self): + return self.toclist + def set_toclist(self, toclist): + self.toclist = toclist + def add_toclist(self, value): + self.toclist.append(value) + def insert_toclist_at(self, index, value): + self.toclist.insert(index, value) + def replace_toclist_at(self, index, value): + self.toclist[index] = value + def get_language(self): + return self.language + def set_language(self, language): + self.language = language + def add_language(self, value): + self.language.append(value) + def insert_language_at(self, index, value): + self.language.insert(index, value) + def replace_language_at(self, index, value): + self.language[index] = value + def get_parameterlist(self): + return self.parameterlist + def set_parameterlist(self, parameterlist): + self.parameterlist = parameterlist + def add_parameterlist(self, value): + self.parameterlist.append(value) + def insert_parameterlist_at(self, index, value): + self.parameterlist.insert(index, value) + def replace_parameterlist_at(self, index, value): + self.parameterlist[index] = value + def get_xrefsect(self): + return self.xrefsect + def set_xrefsect(self, xrefsect): + self.xrefsect = xrefsect + def add_xrefsect(self, value): + self.xrefsect.append(value) + def insert_xrefsect_at(self, index, value): + self.xrefsect.insert(index, value) + def replace_xrefsect_at(self, index, value): + self.xrefsect[index] = value + def get_copydoc(self): + return self.copydoc + def set_copydoc(self, copydoc): + self.copydoc = copydoc + def add_copydoc(self, value): + self.copydoc.append(value) + def insert_copydoc_at(self, index, value): + self.copydoc.insert(index, value) + def replace_copydoc_at(self, index, value): + self.copydoc[index] = value + def get_blockquote(self): + return self.blockquote + def set_blockquote(self, blockquote): + self.blockquote = blockquote + def add_blockquote(self, value): + self.blockquote.append(value) + def insert_blockquote_at(self, index, value): + self.blockquote.insert(index, value) + def replace_blockquote_at(self, index, value): + self.blockquote[index] = value + def get_parblock(self): + return self.parblock + def set_parblock(self, parblock): + self.parblock = parblock + def add_parblock(self, value): + self.parblock.append(value) + def insert_parblock_at(self, index, value): + self.parblock.insert(index, value) + def replace_parblock_at(self, index, value): + self.parblock[index] = value + def get_valueOf_(self): return self.valueOf_ + def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def hasContent_(self): + if ( + self.ulink or + self.bold or + self.emphasis or + self.computeroutput or + self.subscript or + self.superscript or + self.center or + self.small or + self.htmlonly or + self.manonly or + self.xmlonly or + self.rtfonly or + self.latexonly or + self.dot or + self.msc or + self.anchor or + self.formula or + self.ref or + self.copy or + self.trademark or + self.registered or + self.lsquo or + self.rsquo or + self.ldquo or + self.rdquo or + self.ndash or + self.mdash or + self.umlaut or + self.acute or + self.grave or + self.circ or + self.slash or + self.tilde or + self.cedil or + self.ring or + self.szlig or + self.nonbreakablespace or + self.aelig or + self.AElig or + self.Gamma or + self.Delta or + self.Theta or + self.Lambda or + self.Xi or + self.Pi or + self.Sigma or + self.Upsilon or + self.Phi or + self.Psi or + self.Omega or + self.alpha or + self.beta or + self.gamma or + self.delta or + self.epsilon or + self.zeta or + self.eta or + self.theta or + self.iota or + self.kappa or + self.lambda_ or + self.mu or + self.nu or + self.xi or + self.pi or + self.rho or + self.sigma or + self.tau or + self.upsilon or + self.phi or + self.chi or + self.psi or + self.omega or + self.sigmaf or + self.sect or + self.deg or + self.prime or + self.Prime or + self.infin or + self.empty or + self.plusmn or + self.times or + self.minus or + self.sdot or + self.part or + self.nabla or + self.radic or + self.perp or + self.sum or + self.int or + self.prod or + self.sim or + self.asymp or + self.ne or + self.equiv or + self.prop or + self.le or + self.ge or + self.larr or + self.rarr or + self.isin or + self.notin or + self.lceil or + self.rceil or + self.lfloor or + self.rfloor or + self.linebreak or + self.hruler or + self.preformatted or + self.programlisting or + self.verbatim or + self.indexentry or + self.orderedlist or + self.itemizedlist or + self.simplesect or + self.title or + self.variablelist or + self.table or + self.heading or + self.image or + self.dotfile or + self.mscfile or + self.diafile or + self.toclist or + self.language or + self.parameterlist or + self.xrefsect or + self.copydoc or + self.blockquote or + self.parblock or + (1 if type(self.valueOf_) in [int,float] else self.valueOf_) or + self.content_ + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docMarkupType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docMarkupType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docMarkupType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docMarkupType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docMarkupType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docMarkupType'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docMarkupType', fromsubclass_=False, pretty_print=True): + if not fromsubclass_: + for item_ in self.content_: + item_.export(outfile, level, item_.name, namespaceprefix_, pretty_print=pretty_print) + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for ulink_ in self.ulink: + namespaceprefix_ = self.ulink_nsprefix_ + ':' if (UseCapturedNS_ and self.ulink_nsprefix_) else '' + ulink_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ulink', pretty_print=pretty_print) + for bold_ in self.bold: + namespaceprefix_ = self.bold_nsprefix_ + ':' if (UseCapturedNS_ and self.bold_nsprefix_) else '' + bold_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='bold', pretty_print=pretty_print) + for emphasis_ in self.emphasis: + namespaceprefix_ = self.emphasis_nsprefix_ + ':' if (UseCapturedNS_ and self.emphasis_nsprefix_) else '' + emphasis_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='emphasis', pretty_print=pretty_print) + for computeroutput_ in self.computeroutput: + namespaceprefix_ = self.computeroutput_nsprefix_ + ':' if (UseCapturedNS_ and self.computeroutput_nsprefix_) else '' + computeroutput_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='computeroutput', pretty_print=pretty_print) + for subscript_ in self.subscript: + namespaceprefix_ = self.subscript_nsprefix_ + ':' if (UseCapturedNS_ and self.subscript_nsprefix_) else '' + subscript_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='subscript', pretty_print=pretty_print) + for superscript_ in self.superscript: + namespaceprefix_ = self.superscript_nsprefix_ + ':' if (UseCapturedNS_ and self.superscript_nsprefix_) else '' + superscript_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='superscript', pretty_print=pretty_print) + for center_ in self.center: + namespaceprefix_ = self.center_nsprefix_ + ':' if (UseCapturedNS_ and self.center_nsprefix_) else '' + center_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='center', pretty_print=pretty_print) + for small_ in self.small: + namespaceprefix_ = self.small_nsprefix_ + ':' if (UseCapturedNS_ and self.small_nsprefix_) else '' + small_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='small', pretty_print=pretty_print) + for htmlonly_ in self.htmlonly: + namespaceprefix_ = self.htmlonly_nsprefix_ + ':' if (UseCapturedNS_ and self.htmlonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%shtmlonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(htmlonly_), input_name='htmlonly')), namespaceprefix_ , eol_)) + for manonly_ in self.manonly: + namespaceprefix_ = self.manonly_nsprefix_ + ':' if (UseCapturedNS_ and self.manonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%smanonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(manonly_), input_name='manonly')), namespaceprefix_ , eol_)) + for xmlonly_ in self.xmlonly: + namespaceprefix_ = self.xmlonly_nsprefix_ + ':' if (UseCapturedNS_ and self.xmlonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%sxmlonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(xmlonly_), input_name='xmlonly')), namespaceprefix_ , eol_)) + for rtfonly_ in self.rtfonly: + namespaceprefix_ = self.rtfonly_nsprefix_ + ':' if (UseCapturedNS_ and self.rtfonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%srtfonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(rtfonly_), input_name='rtfonly')), namespaceprefix_ , eol_)) + for latexonly_ in self.latexonly: + namespaceprefix_ = self.latexonly_nsprefix_ + ':' if (UseCapturedNS_ and self.latexonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%slatexonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(latexonly_), input_name='latexonly')), namespaceprefix_ , eol_)) + for dot_ in self.dot: + namespaceprefix_ = self.dot_nsprefix_ + ':' if (UseCapturedNS_ and self.dot_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%sdot>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(dot_), input_name='dot')), namespaceprefix_ , eol_)) + for msc_ in self.msc: + namespaceprefix_ = self.msc_nsprefix_ + ':' if (UseCapturedNS_ and self.msc_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%smsc>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(msc_), input_name='msc')), namespaceprefix_ , eol_)) + for anchor_ in self.anchor: + namespaceprefix_ = self.anchor_nsprefix_ + ':' if (UseCapturedNS_ and self.anchor_nsprefix_) else '' + anchor_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='anchor', pretty_print=pretty_print) + for formula_ in self.formula: + namespaceprefix_ = self.formula_nsprefix_ + ':' if (UseCapturedNS_ and self.formula_nsprefix_) else '' + formula_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='formula', pretty_print=pretty_print) + for ref_ in self.ref: + namespaceprefix_ = self.ref_nsprefix_ + ':' if (UseCapturedNS_ and self.ref_nsprefix_) else '' + ref_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ref', pretty_print=pretty_print) + for copy_ in self.copy: + namespaceprefix_ = self.copy_nsprefix_ + ':' if (UseCapturedNS_ and self.copy_nsprefix_) else '' + copy_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='copy', pretty_print=pretty_print) + for trademark_ in self.trademark: + namespaceprefix_ = self.trademark_nsprefix_ + ':' if (UseCapturedNS_ and self.trademark_nsprefix_) else '' + trademark_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='trademark', pretty_print=pretty_print) + for registered_ in self.registered: + namespaceprefix_ = self.registered_nsprefix_ + ':' if (UseCapturedNS_ and self.registered_nsprefix_) else '' + registered_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='registered', pretty_print=pretty_print) + for lsquo_ in self.lsquo: + namespaceprefix_ = self.lsquo_nsprefix_ + ':' if (UseCapturedNS_ and self.lsquo_nsprefix_) else '' + lsquo_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='lsquo', pretty_print=pretty_print) + for rsquo_ in self.rsquo: + namespaceprefix_ = self.rsquo_nsprefix_ + ':' if (UseCapturedNS_ and self.rsquo_nsprefix_) else '' + rsquo_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rsquo', pretty_print=pretty_print) + for ldquo_ in self.ldquo: + namespaceprefix_ = self.ldquo_nsprefix_ + ':' if (UseCapturedNS_ and self.ldquo_nsprefix_) else '' + ldquo_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ldquo', pretty_print=pretty_print) + for rdquo_ in self.rdquo: + namespaceprefix_ = self.rdquo_nsprefix_ + ':' if (UseCapturedNS_ and self.rdquo_nsprefix_) else '' + rdquo_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rdquo', pretty_print=pretty_print) + for ndash_ in self.ndash: + namespaceprefix_ = self.ndash_nsprefix_ + ':' if (UseCapturedNS_ and self.ndash_nsprefix_) else '' + ndash_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ndash', pretty_print=pretty_print) + for mdash_ in self.mdash: + namespaceprefix_ = self.mdash_nsprefix_ + ':' if (UseCapturedNS_ and self.mdash_nsprefix_) else '' + mdash_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='mdash', pretty_print=pretty_print) + for umlaut_ in self.umlaut: + namespaceprefix_ = self.umlaut_nsprefix_ + ':' if (UseCapturedNS_ and self.umlaut_nsprefix_) else '' + umlaut_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='umlaut', pretty_print=pretty_print) + for acute_ in self.acute: + namespaceprefix_ = self.acute_nsprefix_ + ':' if (UseCapturedNS_ and self.acute_nsprefix_) else '' + acute_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='acute', pretty_print=pretty_print) + for grave_ in self.grave: + namespaceprefix_ = self.grave_nsprefix_ + ':' if (UseCapturedNS_ and self.grave_nsprefix_) else '' + grave_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='grave', pretty_print=pretty_print) + for circ_ in self.circ: + namespaceprefix_ = self.circ_nsprefix_ + ':' if (UseCapturedNS_ and self.circ_nsprefix_) else '' + circ_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='circ', pretty_print=pretty_print) + for slash_ in self.slash: + namespaceprefix_ = self.slash_nsprefix_ + ':' if (UseCapturedNS_ and self.slash_nsprefix_) else '' + slash_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='slash', pretty_print=pretty_print) + for tilde_ in self.tilde: + namespaceprefix_ = self.tilde_nsprefix_ + ':' if (UseCapturedNS_ and self.tilde_nsprefix_) else '' + tilde_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='tilde', pretty_print=pretty_print) + for cedil_ in self.cedil: + namespaceprefix_ = self.cedil_nsprefix_ + ':' if (UseCapturedNS_ and self.cedil_nsprefix_) else '' + cedil_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='cedil', pretty_print=pretty_print) + for ring_ in self.ring: + namespaceprefix_ = self.ring_nsprefix_ + ':' if (UseCapturedNS_ and self.ring_nsprefix_) else '' + ring_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ring', pretty_print=pretty_print) + for szlig_ in self.szlig: + namespaceprefix_ = self.szlig_nsprefix_ + ':' if (UseCapturedNS_ and self.szlig_nsprefix_) else '' + szlig_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='szlig', pretty_print=pretty_print) + for nonbreakablespace_ in self.nonbreakablespace: + namespaceprefix_ = self.nonbreakablespace_nsprefix_ + ':' if (UseCapturedNS_ and self.nonbreakablespace_nsprefix_) else '' + nonbreakablespace_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='nonbreakablespace', pretty_print=pretty_print) + for aelig_ in self.aelig: + namespaceprefix_ = self.aelig_nsprefix_ + ':' if (UseCapturedNS_ and self.aelig_nsprefix_) else '' + aelig_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='aelig', pretty_print=pretty_print) + for AElig_ in self.AElig: + namespaceprefix_ = self.AElig_nsprefix_ + ':' if (UseCapturedNS_ and self.AElig_nsprefix_) else '' + AElig_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='AElig', pretty_print=pretty_print) + for Gamma_ in self.Gamma: + namespaceprefix_ = self.Gamma_nsprefix_ + ':' if (UseCapturedNS_ and self.Gamma_nsprefix_) else '' + Gamma_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Gamma', pretty_print=pretty_print) + for Delta_ in self.Delta: + namespaceprefix_ = self.Delta_nsprefix_ + ':' if (UseCapturedNS_ and self.Delta_nsprefix_) else '' + Delta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Delta', pretty_print=pretty_print) + for Theta_ in self.Theta: + namespaceprefix_ = self.Theta_nsprefix_ + ':' if (UseCapturedNS_ and self.Theta_nsprefix_) else '' + Theta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Theta', pretty_print=pretty_print) + for Lambda_ in self.Lambda: + namespaceprefix_ = self.Lambda_nsprefix_ + ':' if (UseCapturedNS_ and self.Lambda_nsprefix_) else '' + Lambda_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Lambda', pretty_print=pretty_print) + for Xi_ in self.Xi: + namespaceprefix_ = self.Xi_nsprefix_ + ':' if (UseCapturedNS_ and self.Xi_nsprefix_) else '' + Xi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Xi', pretty_print=pretty_print) + for Pi_ in self.Pi: + namespaceprefix_ = self.Pi_nsprefix_ + ':' if (UseCapturedNS_ and self.Pi_nsprefix_) else '' + Pi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Pi', pretty_print=pretty_print) + for Sigma_ in self.Sigma: + namespaceprefix_ = self.Sigma_nsprefix_ + ':' if (UseCapturedNS_ and self.Sigma_nsprefix_) else '' + Sigma_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Sigma', pretty_print=pretty_print) + for Upsilon_ in self.Upsilon: + namespaceprefix_ = self.Upsilon_nsprefix_ + ':' if (UseCapturedNS_ and self.Upsilon_nsprefix_) else '' + Upsilon_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Upsilon', pretty_print=pretty_print) + for Phi_ in self.Phi: + namespaceprefix_ = self.Phi_nsprefix_ + ':' if (UseCapturedNS_ and self.Phi_nsprefix_) else '' + Phi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Phi', pretty_print=pretty_print) + for Psi_ in self.Psi: + namespaceprefix_ = self.Psi_nsprefix_ + ':' if (UseCapturedNS_ and self.Psi_nsprefix_) else '' + Psi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Psi', pretty_print=pretty_print) + for Omega_ in self.Omega: + namespaceprefix_ = self.Omega_nsprefix_ + ':' if (UseCapturedNS_ and self.Omega_nsprefix_) else '' + Omega_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Omega', pretty_print=pretty_print) + for alpha_ in self.alpha: + namespaceprefix_ = self.alpha_nsprefix_ + ':' if (UseCapturedNS_ and self.alpha_nsprefix_) else '' + alpha_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='alpha', pretty_print=pretty_print) + for beta_ in self.beta: + namespaceprefix_ = self.beta_nsprefix_ + ':' if (UseCapturedNS_ and self.beta_nsprefix_) else '' + beta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='beta', pretty_print=pretty_print) + for gamma_ in self.gamma: + namespaceprefix_ = self.gamma_nsprefix_ + ':' if (UseCapturedNS_ and self.gamma_nsprefix_) else '' + gamma_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='gamma', pretty_print=pretty_print) + for delta_ in self.delta: + namespaceprefix_ = self.delta_nsprefix_ + ':' if (UseCapturedNS_ and self.delta_nsprefix_) else '' + delta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='delta', pretty_print=pretty_print) + for epsilon_ in self.epsilon: + namespaceprefix_ = self.epsilon_nsprefix_ + ':' if (UseCapturedNS_ and self.epsilon_nsprefix_) else '' + epsilon_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='epsilon', pretty_print=pretty_print) + for zeta_ in self.zeta: + namespaceprefix_ = self.zeta_nsprefix_ + ':' if (UseCapturedNS_ and self.zeta_nsprefix_) else '' + zeta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='zeta', pretty_print=pretty_print) + for eta_ in self.eta: + namespaceprefix_ = self.eta_nsprefix_ + ':' if (UseCapturedNS_ and self.eta_nsprefix_) else '' + eta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='eta', pretty_print=pretty_print) + for theta_ in self.theta: + namespaceprefix_ = self.theta_nsprefix_ + ':' if (UseCapturedNS_ and self.theta_nsprefix_) else '' + theta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='theta', pretty_print=pretty_print) + for iota_ in self.iota: + namespaceprefix_ = self.iota_nsprefix_ + ':' if (UseCapturedNS_ and self.iota_nsprefix_) else '' + iota_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='iota', pretty_print=pretty_print) + for kappa_ in self.kappa: + namespaceprefix_ = self.kappa_nsprefix_ + ':' if (UseCapturedNS_ and self.kappa_nsprefix_) else '' + kappa_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='kappa', pretty_print=pretty_print) + for lambda_ in self.lambda_: + namespaceprefix_ = self.lambda__nsprefix_ + ':' if (UseCapturedNS_ and self.lambda__nsprefix_) else '' + lambda_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='lambda', pretty_print=pretty_print) + for mu_ in self.mu: + namespaceprefix_ = self.mu_nsprefix_ + ':' if (UseCapturedNS_ and self.mu_nsprefix_) else '' + mu_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='mu', pretty_print=pretty_print) + for nu_ in self.nu: + namespaceprefix_ = self.nu_nsprefix_ + ':' if (UseCapturedNS_ and self.nu_nsprefix_) else '' + nu_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='nu', pretty_print=pretty_print) + for xi_ in self.xi: + namespaceprefix_ = self.xi_nsprefix_ + ':' if (UseCapturedNS_ and self.xi_nsprefix_) else '' + xi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='xi', pretty_print=pretty_print) + for pi_ in self.pi: + namespaceprefix_ = self.pi_nsprefix_ + ':' if (UseCapturedNS_ and self.pi_nsprefix_) else '' + pi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='pi', pretty_print=pretty_print) + for rho_ in self.rho: + namespaceprefix_ = self.rho_nsprefix_ + ':' if (UseCapturedNS_ and self.rho_nsprefix_) else '' + rho_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rho', pretty_print=pretty_print) + for sigma_ in self.sigma: + namespaceprefix_ = self.sigma_nsprefix_ + ':' if (UseCapturedNS_ and self.sigma_nsprefix_) else '' + sigma_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sigma', pretty_print=pretty_print) + for tau_ in self.tau: + namespaceprefix_ = self.tau_nsprefix_ + ':' if (UseCapturedNS_ and self.tau_nsprefix_) else '' + tau_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='tau', pretty_print=pretty_print) + for upsilon_ in self.upsilon: + namespaceprefix_ = self.upsilon_nsprefix_ + ':' if (UseCapturedNS_ and self.upsilon_nsprefix_) else '' + upsilon_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='upsilon', pretty_print=pretty_print) + for phi_ in self.phi: + namespaceprefix_ = self.phi_nsprefix_ + ':' if (UseCapturedNS_ and self.phi_nsprefix_) else '' + phi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='phi', pretty_print=pretty_print) + for chi_ in self.chi: + namespaceprefix_ = self.chi_nsprefix_ + ':' if (UseCapturedNS_ and self.chi_nsprefix_) else '' + chi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='chi', pretty_print=pretty_print) + for psi_ in self.psi: + namespaceprefix_ = self.psi_nsprefix_ + ':' if (UseCapturedNS_ and self.psi_nsprefix_) else '' + psi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='psi', pretty_print=pretty_print) + for omega_ in self.omega: + namespaceprefix_ = self.omega_nsprefix_ + ':' if (UseCapturedNS_ and self.omega_nsprefix_) else '' + omega_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='omega', pretty_print=pretty_print) + for sigmaf_ in self.sigmaf: + namespaceprefix_ = self.sigmaf_nsprefix_ + ':' if (UseCapturedNS_ and self.sigmaf_nsprefix_) else '' + sigmaf_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sigmaf', pretty_print=pretty_print) + for sect_ in self.sect: + namespaceprefix_ = self.sect_nsprefix_ + ':' if (UseCapturedNS_ and self.sect_nsprefix_) else '' + sect_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sect', pretty_print=pretty_print) + for deg_ in self.deg: + namespaceprefix_ = self.deg_nsprefix_ + ':' if (UseCapturedNS_ and self.deg_nsprefix_) else '' + deg_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='deg', pretty_print=pretty_print) + for prime_ in self.prime: + namespaceprefix_ = self.prime_nsprefix_ + ':' if (UseCapturedNS_ and self.prime_nsprefix_) else '' + prime_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='prime', pretty_print=pretty_print) + for Prime_ in self.Prime: + namespaceprefix_ = self.Prime_nsprefix_ + ':' if (UseCapturedNS_ and self.Prime_nsprefix_) else '' + Prime_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Prime', pretty_print=pretty_print) + for infin_ in self.infin: + namespaceprefix_ = self.infin_nsprefix_ + ':' if (UseCapturedNS_ and self.infin_nsprefix_) else '' + infin_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='infin', pretty_print=pretty_print) + for empty_ in self.empty: + namespaceprefix_ = self.empty_nsprefix_ + ':' if (UseCapturedNS_ and self.empty_nsprefix_) else '' + empty_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='empty', pretty_print=pretty_print) + for plusmn_ in self.plusmn: + namespaceprefix_ = self.plusmn_nsprefix_ + ':' if (UseCapturedNS_ and self.plusmn_nsprefix_) else '' + plusmn_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='plusmn', pretty_print=pretty_print) + for times_ in self.times: + namespaceprefix_ = self.times_nsprefix_ + ':' if (UseCapturedNS_ and self.times_nsprefix_) else '' + times_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='times', pretty_print=pretty_print) + for minus_ in self.minus: + namespaceprefix_ = self.minus_nsprefix_ + ':' if (UseCapturedNS_ and self.minus_nsprefix_) else '' + minus_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='minus', pretty_print=pretty_print) + for sdot_ in self.sdot: + namespaceprefix_ = self.sdot_nsprefix_ + ':' if (UseCapturedNS_ and self.sdot_nsprefix_) else '' + sdot_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sdot', pretty_print=pretty_print) + for part_ in self.part: + namespaceprefix_ = self.part_nsprefix_ + ':' if (UseCapturedNS_ and self.part_nsprefix_) else '' + part_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='part', pretty_print=pretty_print) + for nabla_ in self.nabla: + namespaceprefix_ = self.nabla_nsprefix_ + ':' if (UseCapturedNS_ and self.nabla_nsprefix_) else '' + nabla_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='nabla', pretty_print=pretty_print) + for radic_ in self.radic: + namespaceprefix_ = self.radic_nsprefix_ + ':' if (UseCapturedNS_ and self.radic_nsprefix_) else '' + radic_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='radic', pretty_print=pretty_print) + for perp_ in self.perp: + namespaceprefix_ = self.perp_nsprefix_ + ':' if (UseCapturedNS_ and self.perp_nsprefix_) else '' + perp_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='perp', pretty_print=pretty_print) + for sum_ in self.sum: + namespaceprefix_ = self.sum_nsprefix_ + ':' if (UseCapturedNS_ and self.sum_nsprefix_) else '' + sum_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sum', pretty_print=pretty_print) + for int_ in self.int: + namespaceprefix_ = self.int_nsprefix_ + ':' if (UseCapturedNS_ and self.int_nsprefix_) else '' + int_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='int', pretty_print=pretty_print) + for prod_ in self.prod: + namespaceprefix_ = self.prod_nsprefix_ + ':' if (UseCapturedNS_ and self.prod_nsprefix_) else '' + prod_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='prod', pretty_print=pretty_print) + for sim_ in self.sim: + namespaceprefix_ = self.sim_nsprefix_ + ':' if (UseCapturedNS_ and self.sim_nsprefix_) else '' + sim_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sim', pretty_print=pretty_print) + for asymp_ in self.asymp: + namespaceprefix_ = self.asymp_nsprefix_ + ':' if (UseCapturedNS_ and self.asymp_nsprefix_) else '' + asymp_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='asymp', pretty_print=pretty_print) + for ne_ in self.ne: + namespaceprefix_ = self.ne_nsprefix_ + ':' if (UseCapturedNS_ and self.ne_nsprefix_) else '' + ne_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ne', pretty_print=pretty_print) + for equiv_ in self.equiv: + namespaceprefix_ = self.equiv_nsprefix_ + ':' if (UseCapturedNS_ and self.equiv_nsprefix_) else '' + equiv_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='equiv', pretty_print=pretty_print) + for prop_ in self.prop: + namespaceprefix_ = self.prop_nsprefix_ + ':' if (UseCapturedNS_ and self.prop_nsprefix_) else '' + prop_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='prop', pretty_print=pretty_print) + for le_ in self.le: + namespaceprefix_ = self.le_nsprefix_ + ':' if (UseCapturedNS_ and self.le_nsprefix_) else '' + le_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='le', pretty_print=pretty_print) + for ge_ in self.ge: + namespaceprefix_ = self.ge_nsprefix_ + ':' if (UseCapturedNS_ and self.ge_nsprefix_) else '' + ge_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ge', pretty_print=pretty_print) + for larr_ in self.larr: + namespaceprefix_ = self.larr_nsprefix_ + ':' if (UseCapturedNS_ and self.larr_nsprefix_) else '' + larr_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='larr', pretty_print=pretty_print) + for rarr_ in self.rarr: + namespaceprefix_ = self.rarr_nsprefix_ + ':' if (UseCapturedNS_ and self.rarr_nsprefix_) else '' + rarr_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rarr', pretty_print=pretty_print) + for isin_ in self.isin: + namespaceprefix_ = self.isin_nsprefix_ + ':' if (UseCapturedNS_ and self.isin_nsprefix_) else '' + isin_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='isin', pretty_print=pretty_print) + for notin_ in self.notin: + namespaceprefix_ = self.notin_nsprefix_ + ':' if (UseCapturedNS_ and self.notin_nsprefix_) else '' + notin_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='notin', pretty_print=pretty_print) + for lceil_ in self.lceil: + namespaceprefix_ = self.lceil_nsprefix_ + ':' if (UseCapturedNS_ and self.lceil_nsprefix_) else '' + lceil_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='lceil', pretty_print=pretty_print) + for rceil_ in self.rceil: + namespaceprefix_ = self.rceil_nsprefix_ + ':' if (UseCapturedNS_ and self.rceil_nsprefix_) else '' + rceil_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rceil', pretty_print=pretty_print) + for lfloor_ in self.lfloor: + namespaceprefix_ = self.lfloor_nsprefix_ + ':' if (UseCapturedNS_ and self.lfloor_nsprefix_) else '' + lfloor_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='lfloor', pretty_print=pretty_print) + for rfloor_ in self.rfloor: + namespaceprefix_ = self.rfloor_nsprefix_ + ':' if (UseCapturedNS_ and self.rfloor_nsprefix_) else '' + rfloor_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rfloor', pretty_print=pretty_print) + for linebreak_ in self.linebreak: + namespaceprefix_ = self.linebreak_nsprefix_ + ':' if (UseCapturedNS_ and self.linebreak_nsprefix_) else '' + linebreak_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='linebreak', pretty_print=pretty_print) + for hruler_ in self.hruler: + namespaceprefix_ = self.hruler_nsprefix_ + ':' if (UseCapturedNS_ and self.hruler_nsprefix_) else '' + hruler_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='hruler', pretty_print=pretty_print) + for preformatted_ in self.preformatted: + namespaceprefix_ = self.preformatted_nsprefix_ + ':' if (UseCapturedNS_ and self.preformatted_nsprefix_) else '' + preformatted_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='preformatted', pretty_print=pretty_print) + for programlisting_ in self.programlisting: + namespaceprefix_ = self.programlisting_nsprefix_ + ':' if (UseCapturedNS_ and self.programlisting_nsprefix_) else '' + programlisting_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='programlisting', pretty_print=pretty_print) + for verbatim_ in self.verbatim: + namespaceprefix_ = self.verbatim_nsprefix_ + ':' if (UseCapturedNS_ and self.verbatim_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%sverbatim>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(verbatim_), input_name='verbatim')), namespaceprefix_ , eol_)) + for indexentry_ in self.indexentry: + namespaceprefix_ = self.indexentry_nsprefix_ + ':' if (UseCapturedNS_ and self.indexentry_nsprefix_) else '' + indexentry_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='indexentry', pretty_print=pretty_print) + for orderedlist_ in self.orderedlist: + namespaceprefix_ = self.orderedlist_nsprefix_ + ':' if (UseCapturedNS_ and self.orderedlist_nsprefix_) else '' + orderedlist_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='orderedlist', pretty_print=pretty_print) + for itemizedlist_ in self.itemizedlist: + namespaceprefix_ = self.itemizedlist_nsprefix_ + ':' if (UseCapturedNS_ and self.itemizedlist_nsprefix_) else '' + itemizedlist_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='itemizedlist', pretty_print=pretty_print) + for simplesect_ in self.simplesect: + namespaceprefix_ = self.simplesect_nsprefix_ + ':' if (UseCapturedNS_ and self.simplesect_nsprefix_) else '' + simplesect_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='simplesect', pretty_print=pretty_print) + for title_ in self.title: + namespaceprefix_ = self.title_nsprefix_ + ':' if (UseCapturedNS_ and self.title_nsprefix_) else '' + title_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='title', pretty_print=pretty_print) + for variablelist_ in self.variablelist: + namespaceprefix_ = self.variablelist_nsprefix_ + ':' if (UseCapturedNS_ and self.variablelist_nsprefix_) else '' + variablelist_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='variablelist', pretty_print=pretty_print) + for table_ in self.table: + namespaceprefix_ = self.table_nsprefix_ + ':' if (UseCapturedNS_ and self.table_nsprefix_) else '' + table_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='table', pretty_print=pretty_print) + for heading_ in self.heading: + namespaceprefix_ = self.heading_nsprefix_ + ':' if (UseCapturedNS_ and self.heading_nsprefix_) else '' + heading_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='heading', pretty_print=pretty_print) + for image_ in self.image: + namespaceprefix_ = self.image_nsprefix_ + ':' if (UseCapturedNS_ and self.image_nsprefix_) else '' + image_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='image', pretty_print=pretty_print) + for dotfile_ in self.dotfile: + namespaceprefix_ = self.dotfile_nsprefix_ + ':' if (UseCapturedNS_ and self.dotfile_nsprefix_) else '' + dotfile_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='dotfile', pretty_print=pretty_print) + for mscfile_ in self.mscfile: + namespaceprefix_ = self.mscfile_nsprefix_ + ':' if (UseCapturedNS_ and self.mscfile_nsprefix_) else '' + mscfile_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='mscfile', pretty_print=pretty_print) + for diafile_ in self.diafile: + namespaceprefix_ = self.diafile_nsprefix_ + ':' if (UseCapturedNS_ and self.diafile_nsprefix_) else '' + diafile_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='diafile', pretty_print=pretty_print) + for toclist_ in self.toclist: + namespaceprefix_ = self.toclist_nsprefix_ + ':' if (UseCapturedNS_ and self.toclist_nsprefix_) else '' + toclist_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='toclist', pretty_print=pretty_print) + for language_ in self.language: + namespaceprefix_ = self.language_nsprefix_ + ':' if (UseCapturedNS_ and self.language_nsprefix_) else '' + language_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='language', pretty_print=pretty_print) + for parameterlist_ in self.parameterlist: + namespaceprefix_ = self.parameterlist_nsprefix_ + ':' if (UseCapturedNS_ and self.parameterlist_nsprefix_) else '' + parameterlist_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='parameterlist', pretty_print=pretty_print) + for xrefsect_ in self.xrefsect: + namespaceprefix_ = self.xrefsect_nsprefix_ + ':' if (UseCapturedNS_ and self.xrefsect_nsprefix_) else '' + xrefsect_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='xrefsect', pretty_print=pretty_print) + for copydoc_ in self.copydoc: + namespaceprefix_ = self.copydoc_nsprefix_ + ':' if (UseCapturedNS_ and self.copydoc_nsprefix_) else '' + copydoc_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='copydoc', pretty_print=pretty_print) + for blockquote_ in self.blockquote: + namespaceprefix_ = self.blockquote_nsprefix_ + ':' if (UseCapturedNS_ and self.blockquote_nsprefix_) else '' + blockquote_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='blockquote', pretty_print=pretty_print) + for parblock_ in self.parblock: + namespaceprefix_ = self.parblock_nsprefix_ + ':' if (UseCapturedNS_ and self.parblock_nsprefix_) else '' + parblock_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='parblock', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + self.valueOf_ = get_all_text_(node) + if node.text is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', node.text) + self.content_.append(obj_) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'ulink': + obj_ = docURLLink.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ulink', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ulink'): + self.add_ulink(obj_.value) + elif hasattr(self, 'set_ulink'): + self.set_ulink(obj_.value) + elif nodeName_ == 'bold': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'bold', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_bold'): + self.add_bold(obj_.value) + elif hasattr(self, 'set_bold'): + self.set_bold(obj_.value) + elif nodeName_ == 'emphasis': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'emphasis', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_emphasis'): + self.add_emphasis(obj_.value) + elif hasattr(self, 'set_emphasis'): + self.set_emphasis(obj_.value) + elif nodeName_ == 'computeroutput': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'computeroutput', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_computeroutput'): + self.add_computeroutput(obj_.value) + elif hasattr(self, 'set_computeroutput'): + self.set_computeroutput(obj_.value) + elif nodeName_ == 'subscript': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'subscript', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_subscript'): + self.add_subscript(obj_.value) + elif hasattr(self, 'set_subscript'): + self.set_subscript(obj_.value) + elif nodeName_ == 'superscript': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'superscript', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_superscript'): + self.add_superscript(obj_.value) + elif hasattr(self, 'set_superscript'): + self.set_superscript(obj_.value) + elif nodeName_ == 'center': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'center', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_center'): + self.add_center(obj_.value) + elif hasattr(self, 'set_center'): + self.set_center(obj_.value) + elif nodeName_ == 'small': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'small', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_small'): + self.add_small(obj_.value) + elif hasattr(self, 'set_small'): + self.set_small(obj_.value) + elif nodeName_ == 'htmlonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'htmlonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'htmlonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'htmlonly', valuestr_) + self.content_.append(obj_) + self.htmlonly_nsprefix_ = child_.prefix + elif nodeName_ == 'manonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'manonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'manonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'manonly', valuestr_) + self.content_.append(obj_) + self.manonly_nsprefix_ = child_.prefix + elif nodeName_ == 'xmlonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'xmlonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'xmlonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'xmlonly', valuestr_) + self.content_.append(obj_) + self.xmlonly_nsprefix_ = child_.prefix + elif nodeName_ == 'rtfonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'rtfonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'rtfonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'rtfonly', valuestr_) + self.content_.append(obj_) + self.rtfonly_nsprefix_ = child_.prefix + elif nodeName_ == 'latexonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'latexonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'latexonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'latexonly', valuestr_) + self.content_.append(obj_) + self.latexonly_nsprefix_ = child_.prefix + elif nodeName_ == 'dot' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'dot') + valuestr_ = self.gds_validate_string(valuestr_, node, 'dot') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'dot', valuestr_) + self.content_.append(obj_) + self.dot_nsprefix_ = child_.prefix + elif nodeName_ == 'msc' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'msc') + valuestr_ = self.gds_validate_string(valuestr_, node, 'msc') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'msc', valuestr_) + self.content_.append(obj_) + self.msc_nsprefix_ = child_.prefix + elif nodeName_ == 'anchor': + obj_ = docAnchorType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'anchor', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_anchor'): + self.add_anchor(obj_.value) + elif hasattr(self, 'set_anchor'): + self.set_anchor(obj_.value) + elif nodeName_ == 'formula': + obj_ = docFormulaType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'formula', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_formula'): + self.add_formula(obj_.value) + elif hasattr(self, 'set_formula'): + self.set_formula(obj_.value) + elif nodeName_ == 'ref': + obj_ = docRefTextType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ref', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ref'): + self.add_ref(obj_.value) + elif hasattr(self, 'set_ref'): + self.set_ref(obj_.value) + elif nodeName_ == 'copy': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'copy', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_copy'): + self.add_copy(obj_.value) + elif hasattr(self, 'set_copy'): + self.set_copy(obj_.value) + elif nodeName_ == 'trademark': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'trademark', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_trademark'): + self.add_trademark(obj_.value) + elif hasattr(self, 'set_trademark'): + self.set_trademark(obj_.value) + elif nodeName_ == 'registered': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'registered', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_registered'): + self.add_registered(obj_.value) + elif hasattr(self, 'set_registered'): + self.set_registered(obj_.value) + elif nodeName_ == 'lsquo': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'lsquo', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_lsquo'): + self.add_lsquo(obj_.value) + elif hasattr(self, 'set_lsquo'): + self.set_lsquo(obj_.value) + elif nodeName_ == 'rsquo': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rsquo', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rsquo'): + self.add_rsquo(obj_.value) + elif hasattr(self, 'set_rsquo'): + self.set_rsquo(obj_.value) + elif nodeName_ == 'ldquo': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ldquo', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ldquo'): + self.add_ldquo(obj_.value) + elif hasattr(self, 'set_ldquo'): + self.set_ldquo(obj_.value) + elif nodeName_ == 'rdquo': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rdquo', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rdquo'): + self.add_rdquo(obj_.value) + elif hasattr(self, 'set_rdquo'): + self.set_rdquo(obj_.value) + elif nodeName_ == 'ndash': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ndash', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ndash'): + self.add_ndash(obj_.value) + elif hasattr(self, 'set_ndash'): + self.set_ndash(obj_.value) + elif nodeName_ == 'mdash': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'mdash', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_mdash'): + self.add_mdash(obj_.value) + elif hasattr(self, 'set_mdash'): + self.set_mdash(obj_.value) + elif nodeName_ == 'umlaut': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'umlaut', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_umlaut'): + self.add_umlaut(obj_.value) + elif hasattr(self, 'set_umlaut'): + self.set_umlaut(obj_.value) + elif nodeName_ == 'acute': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'acute', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_acute'): + self.add_acute(obj_.value) + elif hasattr(self, 'set_acute'): + self.set_acute(obj_.value) + elif nodeName_ == 'grave': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'grave', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_grave'): + self.add_grave(obj_.value) + elif hasattr(self, 'set_grave'): + self.set_grave(obj_.value) + elif nodeName_ == 'circ': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'circ', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_circ'): + self.add_circ(obj_.value) + elif hasattr(self, 'set_circ'): + self.set_circ(obj_.value) + elif nodeName_ == 'slash': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'slash', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_slash'): + self.add_slash(obj_.value) + elif hasattr(self, 'set_slash'): + self.set_slash(obj_.value) + elif nodeName_ == 'tilde': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'tilde', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_tilde'): + self.add_tilde(obj_.value) + elif hasattr(self, 'set_tilde'): + self.set_tilde(obj_.value) + elif nodeName_ == 'cedil': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'cedil', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_cedil'): + self.add_cedil(obj_.value) + elif hasattr(self, 'set_cedil'): + self.set_cedil(obj_.value) + elif nodeName_ == 'ring': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ring', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ring'): + self.add_ring(obj_.value) + elif hasattr(self, 'set_ring'): + self.set_ring(obj_.value) + elif nodeName_ == 'szlig': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'szlig', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_szlig'): + self.add_szlig(obj_.value) + elif hasattr(self, 'set_szlig'): + self.set_szlig(obj_.value) + elif nodeName_ == 'nonbreakablespace': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'nonbreakablespace', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_nonbreakablespace'): + self.add_nonbreakablespace(obj_.value) + elif hasattr(self, 'set_nonbreakablespace'): + self.set_nonbreakablespace(obj_.value) + elif nodeName_ == 'aelig': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'aelig', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_aelig'): + self.add_aelig(obj_.value) + elif hasattr(self, 'set_aelig'): + self.set_aelig(obj_.value) + elif nodeName_ == 'AElig': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'AElig', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_AElig'): + self.add_AElig(obj_.value) + elif hasattr(self, 'set_AElig'): + self.set_AElig(obj_.value) + elif nodeName_ == 'Gamma': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Gamma', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Gamma'): + self.add_Gamma(obj_.value) + elif hasattr(self, 'set_Gamma'): + self.set_Gamma(obj_.value) + elif nodeName_ == 'Delta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Delta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Delta'): + self.add_Delta(obj_.value) + elif hasattr(self, 'set_Delta'): + self.set_Delta(obj_.value) + elif nodeName_ == 'Theta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Theta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Theta'): + self.add_Theta(obj_.value) + elif hasattr(self, 'set_Theta'): + self.set_Theta(obj_.value) + elif nodeName_ == 'Lambda': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Lambda', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Lambda'): + self.add_Lambda(obj_.value) + elif hasattr(self, 'set_Lambda'): + self.set_Lambda(obj_.value) + elif nodeName_ == 'Xi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Xi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Xi'): + self.add_Xi(obj_.value) + elif hasattr(self, 'set_Xi'): + self.set_Xi(obj_.value) + elif nodeName_ == 'Pi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Pi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Pi'): + self.add_Pi(obj_.value) + elif hasattr(self, 'set_Pi'): + self.set_Pi(obj_.value) + elif nodeName_ == 'Sigma': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Sigma', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Sigma'): + self.add_Sigma(obj_.value) + elif hasattr(self, 'set_Sigma'): + self.set_Sigma(obj_.value) + elif nodeName_ == 'Upsilon': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Upsilon', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Upsilon'): + self.add_Upsilon(obj_.value) + elif hasattr(self, 'set_Upsilon'): + self.set_Upsilon(obj_.value) + elif nodeName_ == 'Phi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Phi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Phi'): + self.add_Phi(obj_.value) + elif hasattr(self, 'set_Phi'): + self.set_Phi(obj_.value) + elif nodeName_ == 'Psi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Psi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Psi'): + self.add_Psi(obj_.value) + elif hasattr(self, 'set_Psi'): + self.set_Psi(obj_.value) + elif nodeName_ == 'Omega': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Omega', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Omega'): + self.add_Omega(obj_.value) + elif hasattr(self, 'set_Omega'): + self.set_Omega(obj_.value) + elif nodeName_ == 'alpha': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'alpha', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_alpha'): + self.add_alpha(obj_.value) + elif hasattr(self, 'set_alpha'): + self.set_alpha(obj_.value) + elif nodeName_ == 'beta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'beta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_beta'): + self.add_beta(obj_.value) + elif hasattr(self, 'set_beta'): + self.set_beta(obj_.value) + elif nodeName_ == 'gamma': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'gamma', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_gamma'): + self.add_gamma(obj_.value) + elif hasattr(self, 'set_gamma'): + self.set_gamma(obj_.value) + elif nodeName_ == 'delta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'delta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_delta'): + self.add_delta(obj_.value) + elif hasattr(self, 'set_delta'): + self.set_delta(obj_.value) + elif nodeName_ == 'epsilon': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'epsilon', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_epsilon'): + self.add_epsilon(obj_.value) + elif hasattr(self, 'set_epsilon'): + self.set_epsilon(obj_.value) + elif nodeName_ == 'zeta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'zeta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_zeta'): + self.add_zeta(obj_.value) + elif hasattr(self, 'set_zeta'): + self.set_zeta(obj_.value) + elif nodeName_ == 'eta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'eta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_eta'): + self.add_eta(obj_.value) + elif hasattr(self, 'set_eta'): + self.set_eta(obj_.value) + elif nodeName_ == 'theta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'theta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_theta'): + self.add_theta(obj_.value) + elif hasattr(self, 'set_theta'): + self.set_theta(obj_.value) + elif nodeName_ == 'iota': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'iota', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_iota'): + self.add_iota(obj_.value) + elif hasattr(self, 'set_iota'): + self.set_iota(obj_.value) + elif nodeName_ == 'kappa': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'kappa', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_kappa'): + self.add_kappa(obj_.value) + elif hasattr(self, 'set_kappa'): + self.set_kappa(obj_.value) + elif nodeName_ == 'lambda': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'lambda', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_lambda'): + self.add_lambda(obj_.value) + elif hasattr(self, 'set_lambda'): + self.set_lambda(obj_.value) + elif nodeName_ == 'mu': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'mu', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_mu'): + self.add_mu(obj_.value) + elif hasattr(self, 'set_mu'): + self.set_mu(obj_.value) + elif nodeName_ == 'nu': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'nu', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_nu'): + self.add_nu(obj_.value) + elif hasattr(self, 'set_nu'): + self.set_nu(obj_.value) + elif nodeName_ == 'xi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'xi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_xi'): + self.add_xi(obj_.value) + elif hasattr(self, 'set_xi'): + self.set_xi(obj_.value) + elif nodeName_ == 'pi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'pi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_pi'): + self.add_pi(obj_.value) + elif hasattr(self, 'set_pi'): + self.set_pi(obj_.value) + elif nodeName_ == 'rho': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rho', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rho'): + self.add_rho(obj_.value) + elif hasattr(self, 'set_rho'): + self.set_rho(obj_.value) + elif nodeName_ == 'sigma': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sigma', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sigma'): + self.add_sigma(obj_.value) + elif hasattr(self, 'set_sigma'): + self.set_sigma(obj_.value) + elif nodeName_ == 'tau': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'tau', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_tau'): + self.add_tau(obj_.value) + elif hasattr(self, 'set_tau'): + self.set_tau(obj_.value) + elif nodeName_ == 'upsilon': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'upsilon', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_upsilon'): + self.add_upsilon(obj_.value) + elif hasattr(self, 'set_upsilon'): + self.set_upsilon(obj_.value) + elif nodeName_ == 'phi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'phi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_phi'): + self.add_phi(obj_.value) + elif hasattr(self, 'set_phi'): + self.set_phi(obj_.value) + elif nodeName_ == 'chi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'chi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_chi'): + self.add_chi(obj_.value) + elif hasattr(self, 'set_chi'): + self.set_chi(obj_.value) + elif nodeName_ == 'psi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'psi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_psi'): + self.add_psi(obj_.value) + elif hasattr(self, 'set_psi'): + self.set_psi(obj_.value) + elif nodeName_ == 'omega': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'omega', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_omega'): + self.add_omega(obj_.value) + elif hasattr(self, 'set_omega'): + self.set_omega(obj_.value) + elif nodeName_ == 'sigmaf': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sigmaf', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sigmaf'): + self.add_sigmaf(obj_.value) + elif hasattr(self, 'set_sigmaf'): + self.set_sigmaf(obj_.value) + elif nodeName_ == 'sect': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sect', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sect'): + self.add_sect(obj_.value) + elif hasattr(self, 'set_sect'): + self.set_sect(obj_.value) + elif nodeName_ == 'deg': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'deg', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_deg'): + self.add_deg(obj_.value) + elif hasattr(self, 'set_deg'): + self.set_deg(obj_.value) + elif nodeName_ == 'prime': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'prime', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_prime'): + self.add_prime(obj_.value) + elif hasattr(self, 'set_prime'): + self.set_prime(obj_.value) + elif nodeName_ == 'Prime': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Prime', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Prime'): + self.add_Prime(obj_.value) + elif hasattr(self, 'set_Prime'): + self.set_Prime(obj_.value) + elif nodeName_ == 'infin': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'infin', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_infin'): + self.add_infin(obj_.value) + elif hasattr(self, 'set_infin'): + self.set_infin(obj_.value) + elif nodeName_ == 'empty': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'empty', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_empty'): + self.add_empty(obj_.value) + elif hasattr(self, 'set_empty'): + self.set_empty(obj_.value) + elif nodeName_ == 'plusmn': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'plusmn', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_plusmn'): + self.add_plusmn(obj_.value) + elif hasattr(self, 'set_plusmn'): + self.set_plusmn(obj_.value) + elif nodeName_ == 'times': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'times', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_times'): + self.add_times(obj_.value) + elif hasattr(self, 'set_times'): + self.set_times(obj_.value) + elif nodeName_ == 'minus': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'minus', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_minus'): + self.add_minus(obj_.value) + elif hasattr(self, 'set_minus'): + self.set_minus(obj_.value) + elif nodeName_ == 'sdot': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sdot', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sdot'): + self.add_sdot(obj_.value) + elif hasattr(self, 'set_sdot'): + self.set_sdot(obj_.value) + elif nodeName_ == 'part': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'part', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_part'): + self.add_part(obj_.value) + elif hasattr(self, 'set_part'): + self.set_part(obj_.value) + elif nodeName_ == 'nabla': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'nabla', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_nabla'): + self.add_nabla(obj_.value) + elif hasattr(self, 'set_nabla'): + self.set_nabla(obj_.value) + elif nodeName_ == 'radic': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'radic', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_radic'): + self.add_radic(obj_.value) + elif hasattr(self, 'set_radic'): + self.set_radic(obj_.value) + elif nodeName_ == 'perp': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'perp', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_perp'): + self.add_perp(obj_.value) + elif hasattr(self, 'set_perp'): + self.set_perp(obj_.value) + elif nodeName_ == 'sum': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sum', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sum'): + self.add_sum(obj_.value) + elif hasattr(self, 'set_sum'): + self.set_sum(obj_.value) + elif nodeName_ == 'int': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'int', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_int'): + self.add_int(obj_.value) + elif hasattr(self, 'set_int'): + self.set_int(obj_.value) + elif nodeName_ == 'prod': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'prod', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_prod'): + self.add_prod(obj_.value) + elif hasattr(self, 'set_prod'): + self.set_prod(obj_.value) + elif nodeName_ == 'sim': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sim', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sim'): + self.add_sim(obj_.value) + elif hasattr(self, 'set_sim'): + self.set_sim(obj_.value) + elif nodeName_ == 'asymp': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'asymp', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_asymp'): + self.add_asymp(obj_.value) + elif hasattr(self, 'set_asymp'): + self.set_asymp(obj_.value) + elif nodeName_ == 'ne': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ne', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ne'): + self.add_ne(obj_.value) + elif hasattr(self, 'set_ne'): + self.set_ne(obj_.value) + elif nodeName_ == 'equiv': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'equiv', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_equiv'): + self.add_equiv(obj_.value) + elif hasattr(self, 'set_equiv'): + self.set_equiv(obj_.value) + elif nodeName_ == 'prop': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'prop', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_prop'): + self.add_prop(obj_.value) + elif hasattr(self, 'set_prop'): + self.set_prop(obj_.value) + elif nodeName_ == 'le': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'le', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_le'): + self.add_le(obj_.value) + elif hasattr(self, 'set_le'): + self.set_le(obj_.value) + elif nodeName_ == 'ge': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ge', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ge'): + self.add_ge(obj_.value) + elif hasattr(self, 'set_ge'): + self.set_ge(obj_.value) + elif nodeName_ == 'larr': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'larr', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_larr'): + self.add_larr(obj_.value) + elif hasattr(self, 'set_larr'): + self.set_larr(obj_.value) + elif nodeName_ == 'rarr': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rarr', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rarr'): + self.add_rarr(obj_.value) + elif hasattr(self, 'set_rarr'): + self.set_rarr(obj_.value) + elif nodeName_ == 'isin': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'isin', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_isin'): + self.add_isin(obj_.value) + elif hasattr(self, 'set_isin'): + self.set_isin(obj_.value) + elif nodeName_ == 'notin': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'notin', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_notin'): + self.add_notin(obj_.value) + elif hasattr(self, 'set_notin'): + self.set_notin(obj_.value) + elif nodeName_ == 'lceil': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'lceil', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_lceil'): + self.add_lceil(obj_.value) + elif hasattr(self, 'set_lceil'): + self.set_lceil(obj_.value) + elif nodeName_ == 'rceil': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rceil', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rceil'): + self.add_rceil(obj_.value) + elif hasattr(self, 'set_rceil'): + self.set_rceil(obj_.value) + elif nodeName_ == 'lfloor': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'lfloor', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_lfloor'): + self.add_lfloor(obj_.value) + elif hasattr(self, 'set_lfloor'): + self.set_lfloor(obj_.value) + elif nodeName_ == 'rfloor': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rfloor', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rfloor'): + self.add_rfloor(obj_.value) + elif hasattr(self, 'set_rfloor'): + self.set_rfloor(obj_.value) + elif nodeName_ == 'linebreak': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'linebreak', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_linebreak'): + self.add_linebreak(obj_.value) + elif hasattr(self, 'set_linebreak'): + self.set_linebreak(obj_.value) + elif nodeName_ == 'hruler': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'hruler', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_hruler'): + self.add_hruler(obj_.value) + elif hasattr(self, 'set_hruler'): + self.set_hruler(obj_.value) + elif nodeName_ == 'preformatted': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'preformatted', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_preformatted'): + self.add_preformatted(obj_.value) + elif hasattr(self, 'set_preformatted'): + self.set_preformatted(obj_.value) + elif nodeName_ == 'programlisting': + obj_ = listingType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'programlisting', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_programlisting'): + self.add_programlisting(obj_.value) + elif hasattr(self, 'set_programlisting'): + self.set_programlisting(obj_.value) + elif nodeName_ == 'verbatim' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'verbatim') + valuestr_ = self.gds_validate_string(valuestr_, node, 'verbatim') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'verbatim', valuestr_) + self.content_.append(obj_) + self.verbatim_nsprefix_ = child_.prefix + elif nodeName_ == 'indexentry': + obj_ = docIndexEntryType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'indexentry', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_indexentry'): + self.add_indexentry(obj_.value) + elif hasattr(self, 'set_indexentry'): + self.set_indexentry(obj_.value) + elif nodeName_ == 'orderedlist': + obj_ = docListType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'orderedlist', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_orderedlist'): + self.add_orderedlist(obj_.value) + elif hasattr(self, 'set_orderedlist'): + self.set_orderedlist(obj_.value) + elif nodeName_ == 'itemizedlist': + obj_ = docListType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'itemizedlist', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_itemizedlist'): + self.add_itemizedlist(obj_.value) + elif hasattr(self, 'set_itemizedlist'): + self.set_itemizedlist(obj_.value) + elif nodeName_ == 'simplesect': + obj_ = docSimpleSectType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'simplesect', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_simplesect'): + self.add_simplesect(obj_.value) + elif hasattr(self, 'set_simplesect'): + self.set_simplesect(obj_.value) + elif nodeName_ == 'title': + obj_ = docTitleType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'title', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_title'): + self.add_title(obj_.value) + elif hasattr(self, 'set_title'): + self.set_title(obj_.value) + elif nodeName_ == 'variablelist': + obj_ = docVariableListType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'variablelist', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_variablelist'): + self.add_variablelist(obj_.value) + elif hasattr(self, 'set_variablelist'): + self.set_variablelist(obj_.value) + elif nodeName_ == 'table': + obj_ = docTableType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'table', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_table'): + self.add_table(obj_.value) + elif hasattr(self, 'set_table'): + self.set_table(obj_.value) + elif nodeName_ == 'heading': + obj_ = docHeadingType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'heading', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_heading'): + self.add_heading(obj_.value) + elif hasattr(self, 'set_heading'): + self.set_heading(obj_.value) + elif nodeName_ == 'image': + obj_ = docImageType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'image', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_image'): + self.add_image(obj_.value) + elif hasattr(self, 'set_image'): + self.set_image(obj_.value) + elif nodeName_ == 'dotfile': + obj_ = docFileType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'dotfile', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_dotfile'): + self.add_dotfile(obj_.value) + elif hasattr(self, 'set_dotfile'): + self.set_dotfile(obj_.value) + elif nodeName_ == 'mscfile': + obj_ = docFileType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'mscfile', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_mscfile'): + self.add_mscfile(obj_.value) + elif hasattr(self, 'set_mscfile'): + self.set_mscfile(obj_.value) + elif nodeName_ == 'diafile': + obj_ = docFileType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'diafile', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_diafile'): + self.add_diafile(obj_.value) + elif hasattr(self, 'set_diafile'): + self.set_diafile(obj_.value) + elif nodeName_ == 'toclist': + obj_ = docTocListType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'toclist', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_toclist'): + self.add_toclist(obj_.value) + elif hasattr(self, 'set_toclist'): + self.set_toclist(obj_.value) + elif nodeName_ == 'language': + obj_ = docLanguageType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'language', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_language'): + self.add_language(obj_.value) + elif hasattr(self, 'set_language'): + self.set_language(obj_.value) + elif nodeName_ == 'parameterlist': + obj_ = docParamListType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'parameterlist', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_parameterlist'): + self.add_parameterlist(obj_.value) + elif hasattr(self, 'set_parameterlist'): + self.set_parameterlist(obj_.value) + elif nodeName_ == 'xrefsect': + obj_ = docXRefSectType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'xrefsect', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_xrefsect'): + self.add_xrefsect(obj_.value) + elif hasattr(self, 'set_xrefsect'): + self.set_xrefsect(obj_.value) + elif nodeName_ == 'copydoc': + obj_ = docCopyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'copydoc', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_copydoc'): + self.add_copydoc(obj_.value) + elif hasattr(self, 'set_copydoc'): + self.set_copydoc(obj_.value) + elif nodeName_ == 'blockquote': + obj_ = docBlockQuoteType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'blockquote', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_blockquote'): + self.add_blockquote(obj_.value) + elif hasattr(self, 'set_blockquote'): + self.set_blockquote(obj_.value) + elif nodeName_ == 'parblock': + obj_ = docParBlockType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'parblock', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_parblock'): + self.add_parblock(obj_.value) + elif hasattr(self, 'set_parblock'): + self.set_parblock(obj_.value) + if not fromsubclass_ and child_.tail is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.tail) + self.content_.append(obj_) +# end class docMarkupType + + +class docURLLink(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, url=None, ulink=None, bold=None, emphasis=None, computeroutput=None, subscript=None, superscript=None, center=None, small=None, htmlonly=None, manonly=None, xmlonly=None, rtfonly=None, latexonly=None, dot=None, msc=None, anchor=None, formula=None, ref=None, copy=None, trademark=None, registered=None, lsquo=None, rsquo=None, ldquo=None, rdquo=None, ndash=None, mdash=None, umlaut=None, acute=None, grave=None, circ=None, slash=None, tilde=None, cedil=None, ring=None, szlig=None, nonbreakablespace=None, aelig=None, AElig=None, Gamma=None, Delta=None, Theta=None, Lambda=None, Xi=None, Pi=None, Sigma=None, Upsilon=None, Phi=None, Psi=None, Omega=None, alpha=None, beta=None, gamma=None, delta=None, epsilon=None, zeta=None, eta=None, theta=None, iota=None, kappa=None, lambda_=None, mu=None, nu=None, xi=None, pi=None, rho=None, sigma=None, tau=None, upsilon=None, phi=None, chi=None, psi=None, omega=None, sigmaf=None, sect=None, deg=None, prime=None, Prime=None, infin=None, empty=None, plusmn=None, times=None, minus=None, sdot=None, part=None, nabla=None, radic=None, perp=None, sum=None, int=None, prod=None, sim=None, asymp=None, ne=None, equiv=None, prop=None, le=None, ge=None, larr=None, rarr=None, isin=None, notin=None, lceil=None, rceil=None, lfloor=None, rfloor=None, valueOf_=None, mixedclass_=None, content_=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.url = _cast(None, url) + self.url_nsprefix_ = None + if ulink is None: + self.ulink = [] + else: + self.ulink = ulink + self.ulink_nsprefix_ = None + if bold is None: + self.bold = [] + else: + self.bold = bold + self.bold_nsprefix_ = None + if emphasis is None: + self.emphasis = [] + else: + self.emphasis = emphasis + self.emphasis_nsprefix_ = None + if computeroutput is None: + self.computeroutput = [] + else: + self.computeroutput = computeroutput + self.computeroutput_nsprefix_ = None + if subscript is None: + self.subscript = [] + else: + self.subscript = subscript + self.subscript_nsprefix_ = None + if superscript is None: + self.superscript = [] + else: + self.superscript = superscript + self.superscript_nsprefix_ = None + if center is None: + self.center = [] + else: + self.center = center + self.center_nsprefix_ = None + if small is None: + self.small = [] + else: + self.small = small + self.small_nsprefix_ = None + if htmlonly is None: + self.htmlonly = [] + else: + self.htmlonly = htmlonly + self.htmlonly_nsprefix_ = None + if manonly is None: + self.manonly = [] + else: + self.manonly = manonly + self.manonly_nsprefix_ = None + if xmlonly is None: + self.xmlonly = [] + else: + self.xmlonly = xmlonly + self.xmlonly_nsprefix_ = None + if rtfonly is None: + self.rtfonly = [] + else: + self.rtfonly = rtfonly + self.rtfonly_nsprefix_ = None + if latexonly is None: + self.latexonly = [] + else: + self.latexonly = latexonly + self.latexonly_nsprefix_ = None + if dot is None: + self.dot = [] + else: + self.dot = dot + self.dot_nsprefix_ = None + if msc is None: + self.msc = [] + else: + self.msc = msc + self.msc_nsprefix_ = None + if anchor is None: + self.anchor = [] + else: + self.anchor = anchor + self.anchor_nsprefix_ = None + if formula is None: + self.formula = [] + else: + self.formula = formula + self.formula_nsprefix_ = None + if ref is None: + self.ref = [] + else: + self.ref = ref + self.ref_nsprefix_ = None + if copy is None: + self.copy = [] + else: + self.copy = copy + self.copy_nsprefix_ = None + if trademark is None: + self.trademark = [] + else: + self.trademark = trademark + self.trademark_nsprefix_ = None + if registered is None: + self.registered = [] + else: + self.registered = registered + self.registered_nsprefix_ = None + if lsquo is None: + self.lsquo = [] + else: + self.lsquo = lsquo + self.lsquo_nsprefix_ = None + if rsquo is None: + self.rsquo = [] + else: + self.rsquo = rsquo + self.rsquo_nsprefix_ = None + if ldquo is None: + self.ldquo = [] + else: + self.ldquo = ldquo + self.ldquo_nsprefix_ = None + if rdquo is None: + self.rdquo = [] + else: + self.rdquo = rdquo + self.rdquo_nsprefix_ = None + if ndash is None: + self.ndash = [] + else: + self.ndash = ndash + self.ndash_nsprefix_ = None + if mdash is None: + self.mdash = [] + else: + self.mdash = mdash + self.mdash_nsprefix_ = None + if umlaut is None: + self.umlaut = [] + else: + self.umlaut = umlaut + self.umlaut_nsprefix_ = None + if acute is None: + self.acute = [] + else: + self.acute = acute + self.acute_nsprefix_ = None + if grave is None: + self.grave = [] + else: + self.grave = grave + self.grave_nsprefix_ = None + if circ is None: + self.circ = [] + else: + self.circ = circ + self.circ_nsprefix_ = None + if slash is None: + self.slash = [] + else: + self.slash = slash + self.slash_nsprefix_ = None + if tilde is None: + self.tilde = [] + else: + self.tilde = tilde + self.tilde_nsprefix_ = None + if cedil is None: + self.cedil = [] + else: + self.cedil = cedil + self.cedil_nsprefix_ = None + if ring is None: + self.ring = [] + else: + self.ring = ring + self.ring_nsprefix_ = None + if szlig is None: + self.szlig = [] + else: + self.szlig = szlig + self.szlig_nsprefix_ = None + if nonbreakablespace is None: + self.nonbreakablespace = [] + else: + self.nonbreakablespace = nonbreakablespace + self.nonbreakablespace_nsprefix_ = None + if aelig is None: + self.aelig = [] + else: + self.aelig = aelig + self.aelig_nsprefix_ = None + if AElig is None: + self.AElig = [] + else: + self.AElig = AElig + self.AElig_nsprefix_ = None + if Gamma is None: + self.Gamma = [] + else: + self.Gamma = Gamma + self.Gamma_nsprefix_ = None + if Delta is None: + self.Delta = [] + else: + self.Delta = Delta + self.Delta_nsprefix_ = None + if Theta is None: + self.Theta = [] + else: + self.Theta = Theta + self.Theta_nsprefix_ = None + if Lambda is None: + self.Lambda = [] + else: + self.Lambda = Lambda + self.Lambda_nsprefix_ = None + if Xi is None: + self.Xi = [] + else: + self.Xi = Xi + self.Xi_nsprefix_ = None + if Pi is None: + self.Pi = [] + else: + self.Pi = Pi + self.Pi_nsprefix_ = None + if Sigma is None: + self.Sigma = [] + else: + self.Sigma = Sigma + self.Sigma_nsprefix_ = None + if Upsilon is None: + self.Upsilon = [] + else: + self.Upsilon = Upsilon + self.Upsilon_nsprefix_ = None + if Phi is None: + self.Phi = [] + else: + self.Phi = Phi + self.Phi_nsprefix_ = None + if Psi is None: + self.Psi = [] + else: + self.Psi = Psi + self.Psi_nsprefix_ = None + if Omega is None: + self.Omega = [] + else: + self.Omega = Omega + self.Omega_nsprefix_ = None + if alpha is None: + self.alpha = [] + else: + self.alpha = alpha + self.alpha_nsprefix_ = None + if beta is None: + self.beta = [] + else: + self.beta = beta + self.beta_nsprefix_ = None + if gamma is None: + self.gamma = [] + else: + self.gamma = gamma + self.gamma_nsprefix_ = None + if delta is None: + self.delta = [] + else: + self.delta = delta + self.delta_nsprefix_ = None + if epsilon is None: + self.epsilon = [] + else: + self.epsilon = epsilon + self.epsilon_nsprefix_ = None + if zeta is None: + self.zeta = [] + else: + self.zeta = zeta + self.zeta_nsprefix_ = None + if eta is None: + self.eta = [] + else: + self.eta = eta + self.eta_nsprefix_ = None + if theta is None: + self.theta = [] + else: + self.theta = theta + self.theta_nsprefix_ = None + if iota is None: + self.iota = [] + else: + self.iota = iota + self.iota_nsprefix_ = None + if kappa is None: + self.kappa = [] + else: + self.kappa = kappa + self.kappa_nsprefix_ = None + if lambda_ is None: + self.lambda_ = [] + else: + self.lambda_ = lambda_ + self.lambda__nsprefix_ = None + if mu is None: + self.mu = [] + else: + self.mu = mu + self.mu_nsprefix_ = None + if nu is None: + self.nu = [] + else: + self.nu = nu + self.nu_nsprefix_ = None + if xi is None: + self.xi = [] + else: + self.xi = xi + self.xi_nsprefix_ = None + if pi is None: + self.pi = [] + else: + self.pi = pi + self.pi_nsprefix_ = None + if rho is None: + self.rho = [] + else: + self.rho = rho + self.rho_nsprefix_ = None + if sigma is None: + self.sigma = [] + else: + self.sigma = sigma + self.sigma_nsprefix_ = None + if tau is None: + self.tau = [] + else: + self.tau = tau + self.tau_nsprefix_ = None + if upsilon is None: + self.upsilon = [] + else: + self.upsilon = upsilon + self.upsilon_nsprefix_ = None + if phi is None: + self.phi = [] + else: + self.phi = phi + self.phi_nsprefix_ = None + if chi is None: + self.chi = [] + else: + self.chi = chi + self.chi_nsprefix_ = None + if psi is None: + self.psi = [] + else: + self.psi = psi + self.psi_nsprefix_ = None + if omega is None: + self.omega = [] + else: + self.omega = omega + self.omega_nsprefix_ = None + if sigmaf is None: + self.sigmaf = [] + else: + self.sigmaf = sigmaf + self.sigmaf_nsprefix_ = None + if sect is None: + self.sect = [] + else: + self.sect = sect + self.sect_nsprefix_ = None + if deg is None: + self.deg = [] + else: + self.deg = deg + self.deg_nsprefix_ = None + if prime is None: + self.prime = [] + else: + self.prime = prime + self.prime_nsprefix_ = None + if Prime is None: + self.Prime = [] + else: + self.Prime = Prime + self.Prime_nsprefix_ = None + if infin is None: + self.infin = [] + else: + self.infin = infin + self.infin_nsprefix_ = None + if empty is None: + self.empty = [] + else: + self.empty = empty + self.empty_nsprefix_ = None + if plusmn is None: + self.plusmn = [] + else: + self.plusmn = plusmn + self.plusmn_nsprefix_ = None + if times is None: + self.times = [] + else: + self.times = times + self.times_nsprefix_ = None + if minus is None: + self.minus = [] + else: + self.minus = minus + self.minus_nsprefix_ = None + if sdot is None: + self.sdot = [] + else: + self.sdot = sdot + self.sdot_nsprefix_ = None + if part is None: + self.part = [] + else: + self.part = part + self.part_nsprefix_ = None + if nabla is None: + self.nabla = [] + else: + self.nabla = nabla + self.nabla_nsprefix_ = None + if radic is None: + self.radic = [] + else: + self.radic = radic + self.radic_nsprefix_ = None + if perp is None: + self.perp = [] + else: + self.perp = perp + self.perp_nsprefix_ = None + if sum is None: + self.sum = [] + else: + self.sum = sum + self.sum_nsprefix_ = None + if int is None: + self.int = [] + else: + self.int = int + self.int_nsprefix_ = None + if prod is None: + self.prod = [] + else: + self.prod = prod + self.prod_nsprefix_ = None + if sim is None: + self.sim = [] + else: + self.sim = sim + self.sim_nsprefix_ = None + if asymp is None: + self.asymp = [] + else: + self.asymp = asymp + self.asymp_nsprefix_ = None + if ne is None: + self.ne = [] + else: + self.ne = ne + self.ne_nsprefix_ = None + if equiv is None: + self.equiv = [] + else: + self.equiv = equiv + self.equiv_nsprefix_ = None + if prop is None: + self.prop = [] + else: + self.prop = prop + self.prop_nsprefix_ = None + if le is None: + self.le = [] + else: + self.le = le + self.le_nsprefix_ = None + if ge is None: + self.ge = [] + else: + self.ge = ge + self.ge_nsprefix_ = None + if larr is None: + self.larr = [] + else: + self.larr = larr + self.larr_nsprefix_ = None + if rarr is None: + self.rarr = [] + else: + self.rarr = rarr + self.rarr_nsprefix_ = None + if isin is None: + self.isin = [] + else: + self.isin = isin + self.isin_nsprefix_ = None + if notin is None: + self.notin = [] + else: + self.notin = notin + self.notin_nsprefix_ = None + if lceil is None: + self.lceil = [] + else: + self.lceil = lceil + self.lceil_nsprefix_ = None + if rceil is None: + self.rceil = [] + else: + self.rceil = rceil + self.rceil_nsprefix_ = None + if lfloor is None: + self.lfloor = [] + else: + self.lfloor = lfloor + self.lfloor_nsprefix_ = None + if rfloor is None: + self.rfloor = [] + else: + self.rfloor = rfloor + self.rfloor_nsprefix_ = None + self.valueOf_ = valueOf_ + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + self.valueOf_ = valueOf_ + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docURLLink) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docURLLink.subclass: + return docURLLink.subclass(*args_, **kwargs_) + return docURLLink(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + def get_ulink(self): + return self.ulink + def set_ulink(self, ulink): + self.ulink = ulink + def add_ulink(self, value): + self.ulink.append(value) + def insert_ulink_at(self, index, value): + self.ulink.insert(index, value) + def replace_ulink_at(self, index, value): + self.ulink[index] = value + def get_bold(self): + return self.bold + def set_bold(self, bold): + self.bold = bold + def add_bold(self, value): + self.bold.append(value) + def insert_bold_at(self, index, value): + self.bold.insert(index, value) + def replace_bold_at(self, index, value): + self.bold[index] = value + def get_emphasis(self): + return self.emphasis + def set_emphasis(self, emphasis): + self.emphasis = emphasis + def add_emphasis(self, value): + self.emphasis.append(value) + def insert_emphasis_at(self, index, value): + self.emphasis.insert(index, value) + def replace_emphasis_at(self, index, value): + self.emphasis[index] = value + def get_computeroutput(self): + return self.computeroutput + def set_computeroutput(self, computeroutput): + self.computeroutput = computeroutput + def add_computeroutput(self, value): + self.computeroutput.append(value) + def insert_computeroutput_at(self, index, value): + self.computeroutput.insert(index, value) + def replace_computeroutput_at(self, index, value): + self.computeroutput[index] = value + def get_subscript(self): + return self.subscript + def set_subscript(self, subscript): + self.subscript = subscript + def add_subscript(self, value): + self.subscript.append(value) + def insert_subscript_at(self, index, value): + self.subscript.insert(index, value) + def replace_subscript_at(self, index, value): + self.subscript[index] = value + def get_superscript(self): + return self.superscript + def set_superscript(self, superscript): + self.superscript = superscript + def add_superscript(self, value): + self.superscript.append(value) + def insert_superscript_at(self, index, value): + self.superscript.insert(index, value) + def replace_superscript_at(self, index, value): + self.superscript[index] = value + def get_center(self): + return self.center + def set_center(self, center): + self.center = center + def add_center(self, value): + self.center.append(value) + def insert_center_at(self, index, value): + self.center.insert(index, value) + def replace_center_at(self, index, value): + self.center[index] = value + def get_small(self): + return self.small + def set_small(self, small): + self.small = small + def add_small(self, value): + self.small.append(value) + def insert_small_at(self, index, value): + self.small.insert(index, value) + def replace_small_at(self, index, value): + self.small[index] = value + def get_htmlonly(self): + return self.htmlonly + def set_htmlonly(self, htmlonly): + self.htmlonly = htmlonly + def add_htmlonly(self, value): + self.htmlonly.append(value) + def insert_htmlonly_at(self, index, value): + self.htmlonly.insert(index, value) + def replace_htmlonly_at(self, index, value): + self.htmlonly[index] = value + def get_manonly(self): + return self.manonly + def set_manonly(self, manonly): + self.manonly = manonly + def add_manonly(self, value): + self.manonly.append(value) + def insert_manonly_at(self, index, value): + self.manonly.insert(index, value) + def replace_manonly_at(self, index, value): + self.manonly[index] = value + def get_xmlonly(self): + return self.xmlonly + def set_xmlonly(self, xmlonly): + self.xmlonly = xmlonly + def add_xmlonly(self, value): + self.xmlonly.append(value) + def insert_xmlonly_at(self, index, value): + self.xmlonly.insert(index, value) + def replace_xmlonly_at(self, index, value): + self.xmlonly[index] = value + def get_rtfonly(self): + return self.rtfonly + def set_rtfonly(self, rtfonly): + self.rtfonly = rtfonly + def add_rtfonly(self, value): + self.rtfonly.append(value) + def insert_rtfonly_at(self, index, value): + self.rtfonly.insert(index, value) + def replace_rtfonly_at(self, index, value): + self.rtfonly[index] = value + def get_latexonly(self): + return self.latexonly + def set_latexonly(self, latexonly): + self.latexonly = latexonly + def add_latexonly(self, value): + self.latexonly.append(value) + def insert_latexonly_at(self, index, value): + self.latexonly.insert(index, value) + def replace_latexonly_at(self, index, value): + self.latexonly[index] = value + def get_dot(self): + return self.dot + def set_dot(self, dot): + self.dot = dot + def add_dot(self, value): + self.dot.append(value) + def insert_dot_at(self, index, value): + self.dot.insert(index, value) + def replace_dot_at(self, index, value): + self.dot[index] = value + def get_msc(self): + return self.msc + def set_msc(self, msc): + self.msc = msc + def add_msc(self, value): + self.msc.append(value) + def insert_msc_at(self, index, value): + self.msc.insert(index, value) + def replace_msc_at(self, index, value): + self.msc[index] = value + def get_anchor(self): + return self.anchor + def set_anchor(self, anchor): + self.anchor = anchor + def add_anchor(self, value): + self.anchor.append(value) + def insert_anchor_at(self, index, value): + self.anchor.insert(index, value) + def replace_anchor_at(self, index, value): + self.anchor[index] = value + def get_formula(self): + return self.formula + def set_formula(self, formula): + self.formula = formula + def add_formula(self, value): + self.formula.append(value) + def insert_formula_at(self, index, value): + self.formula.insert(index, value) + def replace_formula_at(self, index, value): + self.formula[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_at(self, index, value): + self.ref.insert(index, value) + def replace_ref_at(self, index, value): + self.ref[index] = value + def get_copy(self): + return self.copy + def set_copy(self, copy): + self.copy = copy + def add_copy(self, value): + self.copy.append(value) + def insert_copy_at(self, index, value): + self.copy.insert(index, value) + def replace_copy_at(self, index, value): + self.copy[index] = value + def get_trademark(self): + return self.trademark + def set_trademark(self, trademark): + self.trademark = trademark + def add_trademark(self, value): + self.trademark.append(value) + def insert_trademark_at(self, index, value): + self.trademark.insert(index, value) + def replace_trademark_at(self, index, value): + self.trademark[index] = value + def get_registered(self): + return self.registered + def set_registered(self, registered): + self.registered = registered + def add_registered(self, value): + self.registered.append(value) + def insert_registered_at(self, index, value): + self.registered.insert(index, value) + def replace_registered_at(self, index, value): + self.registered[index] = value + def get_lsquo(self): + return self.lsquo + def set_lsquo(self, lsquo): + self.lsquo = lsquo + def add_lsquo(self, value): + self.lsquo.append(value) + def insert_lsquo_at(self, index, value): + self.lsquo.insert(index, value) + def replace_lsquo_at(self, index, value): + self.lsquo[index] = value + def get_rsquo(self): + return self.rsquo + def set_rsquo(self, rsquo): + self.rsquo = rsquo + def add_rsquo(self, value): + self.rsquo.append(value) + def insert_rsquo_at(self, index, value): + self.rsquo.insert(index, value) + def replace_rsquo_at(self, index, value): + self.rsquo[index] = value + def get_ldquo(self): + return self.ldquo + def set_ldquo(self, ldquo): + self.ldquo = ldquo + def add_ldquo(self, value): + self.ldquo.append(value) + def insert_ldquo_at(self, index, value): + self.ldquo.insert(index, value) + def replace_ldquo_at(self, index, value): + self.ldquo[index] = value + def get_rdquo(self): + return self.rdquo + def set_rdquo(self, rdquo): + self.rdquo = rdquo + def add_rdquo(self, value): + self.rdquo.append(value) + def insert_rdquo_at(self, index, value): + self.rdquo.insert(index, value) + def replace_rdquo_at(self, index, value): + self.rdquo[index] = value + def get_ndash(self): + return self.ndash + def set_ndash(self, ndash): + self.ndash = ndash + def add_ndash(self, value): + self.ndash.append(value) + def insert_ndash_at(self, index, value): + self.ndash.insert(index, value) + def replace_ndash_at(self, index, value): + self.ndash[index] = value + def get_mdash(self): + return self.mdash + def set_mdash(self, mdash): + self.mdash = mdash + def add_mdash(self, value): + self.mdash.append(value) + def insert_mdash_at(self, index, value): + self.mdash.insert(index, value) + def replace_mdash_at(self, index, value): + self.mdash[index] = value + def get_umlaut(self): + return self.umlaut + def set_umlaut(self, umlaut): + self.umlaut = umlaut + def add_umlaut(self, value): + self.umlaut.append(value) + def insert_umlaut_at(self, index, value): + self.umlaut.insert(index, value) + def replace_umlaut_at(self, index, value): + self.umlaut[index] = value + def get_acute(self): + return self.acute + def set_acute(self, acute): + self.acute = acute + def add_acute(self, value): + self.acute.append(value) + def insert_acute_at(self, index, value): + self.acute.insert(index, value) + def replace_acute_at(self, index, value): + self.acute[index] = value + def get_grave(self): + return self.grave + def set_grave(self, grave): + self.grave = grave + def add_grave(self, value): + self.grave.append(value) + def insert_grave_at(self, index, value): + self.grave.insert(index, value) + def replace_grave_at(self, index, value): + self.grave[index] = value + def get_circ(self): + return self.circ + def set_circ(self, circ): + self.circ = circ + def add_circ(self, value): + self.circ.append(value) + def insert_circ_at(self, index, value): + self.circ.insert(index, value) + def replace_circ_at(self, index, value): + self.circ[index] = value + def get_slash(self): + return self.slash + def set_slash(self, slash): + self.slash = slash + def add_slash(self, value): + self.slash.append(value) + def insert_slash_at(self, index, value): + self.slash.insert(index, value) + def replace_slash_at(self, index, value): + self.slash[index] = value + def get_tilde(self): + return self.tilde + def set_tilde(self, tilde): + self.tilde = tilde + def add_tilde(self, value): + self.tilde.append(value) + def insert_tilde_at(self, index, value): + self.tilde.insert(index, value) + def replace_tilde_at(self, index, value): + self.tilde[index] = value + def get_cedil(self): + return self.cedil + def set_cedil(self, cedil): + self.cedil = cedil + def add_cedil(self, value): + self.cedil.append(value) + def insert_cedil_at(self, index, value): + self.cedil.insert(index, value) + def replace_cedil_at(self, index, value): + self.cedil[index] = value + def get_ring(self): + return self.ring + def set_ring(self, ring): + self.ring = ring + def add_ring(self, value): + self.ring.append(value) + def insert_ring_at(self, index, value): + self.ring.insert(index, value) + def replace_ring_at(self, index, value): + self.ring[index] = value + def get_szlig(self): + return self.szlig + def set_szlig(self, szlig): + self.szlig = szlig + def add_szlig(self, value): + self.szlig.append(value) + def insert_szlig_at(self, index, value): + self.szlig.insert(index, value) + def replace_szlig_at(self, index, value): + self.szlig[index] = value + def get_nonbreakablespace(self): + return self.nonbreakablespace + def set_nonbreakablespace(self, nonbreakablespace): + self.nonbreakablespace = nonbreakablespace + def add_nonbreakablespace(self, value): + self.nonbreakablespace.append(value) + def insert_nonbreakablespace_at(self, index, value): + self.nonbreakablespace.insert(index, value) + def replace_nonbreakablespace_at(self, index, value): + self.nonbreakablespace[index] = value + def get_aelig(self): + return self.aelig + def set_aelig(self, aelig): + self.aelig = aelig + def add_aelig(self, value): + self.aelig.append(value) + def insert_aelig_at(self, index, value): + self.aelig.insert(index, value) + def replace_aelig_at(self, index, value): + self.aelig[index] = value + def get_AElig(self): + return self.AElig + def set_AElig(self, AElig): + self.AElig = AElig + def add_AElig(self, value): + self.AElig.append(value) + def insert_AElig_at(self, index, value): + self.AElig.insert(index, value) + def replace_AElig_at(self, index, value): + self.AElig[index] = value + def get_Gamma(self): + return self.Gamma + def set_Gamma(self, Gamma): + self.Gamma = Gamma + def add_Gamma(self, value): + self.Gamma.append(value) + def insert_Gamma_at(self, index, value): + self.Gamma.insert(index, value) + def replace_Gamma_at(self, index, value): + self.Gamma[index] = value + def get_Delta(self): + return self.Delta + def set_Delta(self, Delta): + self.Delta = Delta + def add_Delta(self, value): + self.Delta.append(value) + def insert_Delta_at(self, index, value): + self.Delta.insert(index, value) + def replace_Delta_at(self, index, value): + self.Delta[index] = value + def get_Theta(self): + return self.Theta + def set_Theta(self, Theta): + self.Theta = Theta + def add_Theta(self, value): + self.Theta.append(value) + def insert_Theta_at(self, index, value): + self.Theta.insert(index, value) + def replace_Theta_at(self, index, value): + self.Theta[index] = value + def get_Lambda(self): + return self.Lambda + def set_Lambda(self, Lambda): + self.Lambda = Lambda + def add_Lambda(self, value): + self.Lambda.append(value) + def insert_Lambda_at(self, index, value): + self.Lambda.insert(index, value) + def replace_Lambda_at(self, index, value): + self.Lambda[index] = value + def get_Xi(self): + return self.Xi + def set_Xi(self, Xi): + self.Xi = Xi + def add_Xi(self, value): + self.Xi.append(value) + def insert_Xi_at(self, index, value): + self.Xi.insert(index, value) + def replace_Xi_at(self, index, value): + self.Xi[index] = value + def get_Pi(self): + return self.Pi + def set_Pi(self, Pi): + self.Pi = Pi + def add_Pi(self, value): + self.Pi.append(value) + def insert_Pi_at(self, index, value): + self.Pi.insert(index, value) + def replace_Pi_at(self, index, value): + self.Pi[index] = value + def get_Sigma(self): + return self.Sigma + def set_Sigma(self, Sigma): + self.Sigma = Sigma + def add_Sigma(self, value): + self.Sigma.append(value) + def insert_Sigma_at(self, index, value): + self.Sigma.insert(index, value) + def replace_Sigma_at(self, index, value): + self.Sigma[index] = value + def get_Upsilon(self): + return self.Upsilon + def set_Upsilon(self, Upsilon): + self.Upsilon = Upsilon + def add_Upsilon(self, value): + self.Upsilon.append(value) + def insert_Upsilon_at(self, index, value): + self.Upsilon.insert(index, value) + def replace_Upsilon_at(self, index, value): + self.Upsilon[index] = value + def get_Phi(self): + return self.Phi + def set_Phi(self, Phi): + self.Phi = Phi + def add_Phi(self, value): + self.Phi.append(value) + def insert_Phi_at(self, index, value): + self.Phi.insert(index, value) + def replace_Phi_at(self, index, value): + self.Phi[index] = value + def get_Psi(self): + return self.Psi + def set_Psi(self, Psi): + self.Psi = Psi + def add_Psi(self, value): + self.Psi.append(value) + def insert_Psi_at(self, index, value): + self.Psi.insert(index, value) + def replace_Psi_at(self, index, value): + self.Psi[index] = value + def get_Omega(self): + return self.Omega + def set_Omega(self, Omega): + self.Omega = Omega + def add_Omega(self, value): + self.Omega.append(value) + def insert_Omega_at(self, index, value): + self.Omega.insert(index, value) + def replace_Omega_at(self, index, value): + self.Omega[index] = value + def get_alpha(self): + return self.alpha + def set_alpha(self, alpha): + self.alpha = alpha + def add_alpha(self, value): + self.alpha.append(value) + def insert_alpha_at(self, index, value): + self.alpha.insert(index, value) + def replace_alpha_at(self, index, value): + self.alpha[index] = value + def get_beta(self): + return self.beta + def set_beta(self, beta): + self.beta = beta + def add_beta(self, value): + self.beta.append(value) + def insert_beta_at(self, index, value): + self.beta.insert(index, value) + def replace_beta_at(self, index, value): + self.beta[index] = value + def get_gamma(self): + return self.gamma + def set_gamma(self, gamma): + self.gamma = gamma + def add_gamma(self, value): + self.gamma.append(value) + def insert_gamma_at(self, index, value): + self.gamma.insert(index, value) + def replace_gamma_at(self, index, value): + self.gamma[index] = value + def get_delta(self): + return self.delta + def set_delta(self, delta): + self.delta = delta + def add_delta(self, value): + self.delta.append(value) + def insert_delta_at(self, index, value): + self.delta.insert(index, value) + def replace_delta_at(self, index, value): + self.delta[index] = value + def get_epsilon(self): + return self.epsilon + def set_epsilon(self, epsilon): + self.epsilon = epsilon + def add_epsilon(self, value): + self.epsilon.append(value) + def insert_epsilon_at(self, index, value): + self.epsilon.insert(index, value) + def replace_epsilon_at(self, index, value): + self.epsilon[index] = value + def get_zeta(self): + return self.zeta + def set_zeta(self, zeta): + self.zeta = zeta + def add_zeta(self, value): + self.zeta.append(value) + def insert_zeta_at(self, index, value): + self.zeta.insert(index, value) + def replace_zeta_at(self, index, value): + self.zeta[index] = value + def get_eta(self): + return self.eta + def set_eta(self, eta): + self.eta = eta + def add_eta(self, value): + self.eta.append(value) + def insert_eta_at(self, index, value): + self.eta.insert(index, value) + def replace_eta_at(self, index, value): + self.eta[index] = value + def get_theta(self): + return self.theta + def set_theta(self, theta): + self.theta = theta + def add_theta(self, value): + self.theta.append(value) + def insert_theta_at(self, index, value): + self.theta.insert(index, value) + def replace_theta_at(self, index, value): + self.theta[index] = value + def get_iota(self): + return self.iota + def set_iota(self, iota): + self.iota = iota + def add_iota(self, value): + self.iota.append(value) + def insert_iota_at(self, index, value): + self.iota.insert(index, value) + def replace_iota_at(self, index, value): + self.iota[index] = value + def get_kappa(self): + return self.kappa + def set_kappa(self, kappa): + self.kappa = kappa + def add_kappa(self, value): + self.kappa.append(value) + def insert_kappa_at(self, index, value): + self.kappa.insert(index, value) + def replace_kappa_at(self, index, value): + self.kappa[index] = value + def get_lambda(self): + return self.lambda_ + def set_lambda(self, lambda_): + self.lambda_ = lambda_ + def add_lambda(self, value): + self.lambda_.append(value) + def insert_lambda_at(self, index, value): + self.lambda_.insert(index, value) + def replace_lambda_at(self, index, value): + self.lambda_[index] = value + def get_mu(self): + return self.mu + def set_mu(self, mu): + self.mu = mu + def add_mu(self, value): + self.mu.append(value) + def insert_mu_at(self, index, value): + self.mu.insert(index, value) + def replace_mu_at(self, index, value): + self.mu[index] = value + def get_nu(self): + return self.nu + def set_nu(self, nu): + self.nu = nu + def add_nu(self, value): + self.nu.append(value) + def insert_nu_at(self, index, value): + self.nu.insert(index, value) + def replace_nu_at(self, index, value): + self.nu[index] = value + def get_xi(self): + return self.xi + def set_xi(self, xi): + self.xi = xi + def add_xi(self, value): + self.xi.append(value) + def insert_xi_at(self, index, value): + self.xi.insert(index, value) + def replace_xi_at(self, index, value): + self.xi[index] = value + def get_pi(self): + return self.pi + def set_pi(self, pi): + self.pi = pi + def add_pi(self, value): + self.pi.append(value) + def insert_pi_at(self, index, value): + self.pi.insert(index, value) + def replace_pi_at(self, index, value): + self.pi[index] = value + def get_rho(self): + return self.rho + def set_rho(self, rho): + self.rho = rho + def add_rho(self, value): + self.rho.append(value) + def insert_rho_at(self, index, value): + self.rho.insert(index, value) + def replace_rho_at(self, index, value): + self.rho[index] = value + def get_sigma(self): + return self.sigma + def set_sigma(self, sigma): + self.sigma = sigma + def add_sigma(self, value): + self.sigma.append(value) + def insert_sigma_at(self, index, value): + self.sigma.insert(index, value) + def replace_sigma_at(self, index, value): + self.sigma[index] = value + def get_tau(self): + return self.tau + def set_tau(self, tau): + self.tau = tau + def add_tau(self, value): + self.tau.append(value) + def insert_tau_at(self, index, value): + self.tau.insert(index, value) + def replace_tau_at(self, index, value): + self.tau[index] = value + def get_upsilon(self): + return self.upsilon + def set_upsilon(self, upsilon): + self.upsilon = upsilon + def add_upsilon(self, value): + self.upsilon.append(value) + def insert_upsilon_at(self, index, value): + self.upsilon.insert(index, value) + def replace_upsilon_at(self, index, value): + self.upsilon[index] = value + def get_phi(self): + return self.phi + def set_phi(self, phi): + self.phi = phi + def add_phi(self, value): + self.phi.append(value) + def insert_phi_at(self, index, value): + self.phi.insert(index, value) + def replace_phi_at(self, index, value): + self.phi[index] = value + def get_chi(self): + return self.chi + def set_chi(self, chi): + self.chi = chi + def add_chi(self, value): + self.chi.append(value) + def insert_chi_at(self, index, value): + self.chi.insert(index, value) + def replace_chi_at(self, index, value): + self.chi[index] = value + def get_psi(self): + return self.psi + def set_psi(self, psi): + self.psi = psi + def add_psi(self, value): + self.psi.append(value) + def insert_psi_at(self, index, value): + self.psi.insert(index, value) + def replace_psi_at(self, index, value): + self.psi[index] = value + def get_omega(self): + return self.omega + def set_omega(self, omega): + self.omega = omega + def add_omega(self, value): + self.omega.append(value) + def insert_omega_at(self, index, value): + self.omega.insert(index, value) + def replace_omega_at(self, index, value): + self.omega[index] = value + def get_sigmaf(self): + return self.sigmaf + def set_sigmaf(self, sigmaf): + self.sigmaf = sigmaf + def add_sigmaf(self, value): + self.sigmaf.append(value) + def insert_sigmaf_at(self, index, value): + self.sigmaf.insert(index, value) + def replace_sigmaf_at(self, index, value): + self.sigmaf[index] = value + def get_sect(self): + return self.sect + def set_sect(self, sect): + self.sect = sect + def add_sect(self, value): + self.sect.append(value) + def insert_sect_at(self, index, value): + self.sect.insert(index, value) + def replace_sect_at(self, index, value): + self.sect[index] = value + def get_deg(self): + return self.deg + def set_deg(self, deg): + self.deg = deg + def add_deg(self, value): + self.deg.append(value) + def insert_deg_at(self, index, value): + self.deg.insert(index, value) + def replace_deg_at(self, index, value): + self.deg[index] = value + def get_prime(self): + return self.prime + def set_prime(self, prime): + self.prime = prime + def add_prime(self, value): + self.prime.append(value) + def insert_prime_at(self, index, value): + self.prime.insert(index, value) + def replace_prime_at(self, index, value): + self.prime[index] = value + def get_Prime(self): + return self.Prime + def set_Prime(self, Prime): + self.Prime = Prime + def add_Prime(self, value): + self.Prime.append(value) + def insert_Prime_at(self, index, value): + self.Prime.insert(index, value) + def replace_Prime_at(self, index, value): + self.Prime[index] = value + def get_infin(self): + return self.infin + def set_infin(self, infin): + self.infin = infin + def add_infin(self, value): + self.infin.append(value) + def insert_infin_at(self, index, value): + self.infin.insert(index, value) + def replace_infin_at(self, index, value): + self.infin[index] = value + def get_empty(self): + return self.empty + def set_empty(self, empty): + self.empty = empty + def add_empty(self, value): + self.empty.append(value) + def insert_empty_at(self, index, value): + self.empty.insert(index, value) + def replace_empty_at(self, index, value): + self.empty[index] = value + def get_plusmn(self): + return self.plusmn + def set_plusmn(self, plusmn): + self.plusmn = plusmn + def add_plusmn(self, value): + self.plusmn.append(value) + def insert_plusmn_at(self, index, value): + self.plusmn.insert(index, value) + def replace_plusmn_at(self, index, value): + self.plusmn[index] = value + def get_times(self): + return self.times + def set_times(self, times): + self.times = times + def add_times(self, value): + self.times.append(value) + def insert_times_at(self, index, value): + self.times.insert(index, value) + def replace_times_at(self, index, value): + self.times[index] = value + def get_minus(self): + return self.minus + def set_minus(self, minus): + self.minus = minus + def add_minus(self, value): + self.minus.append(value) + def insert_minus_at(self, index, value): + self.minus.insert(index, value) + def replace_minus_at(self, index, value): + self.minus[index] = value + def get_sdot(self): + return self.sdot + def set_sdot(self, sdot): + self.sdot = sdot + def add_sdot(self, value): + self.sdot.append(value) + def insert_sdot_at(self, index, value): + self.sdot.insert(index, value) + def replace_sdot_at(self, index, value): + self.sdot[index] = value + def get_part(self): + return self.part + def set_part(self, part): + self.part = part + def add_part(self, value): + self.part.append(value) + def insert_part_at(self, index, value): + self.part.insert(index, value) + def replace_part_at(self, index, value): + self.part[index] = value + def get_nabla(self): + return self.nabla + def set_nabla(self, nabla): + self.nabla = nabla + def add_nabla(self, value): + self.nabla.append(value) + def insert_nabla_at(self, index, value): + self.nabla.insert(index, value) + def replace_nabla_at(self, index, value): + self.nabla[index] = value + def get_radic(self): + return self.radic + def set_radic(self, radic): + self.radic = radic + def add_radic(self, value): + self.radic.append(value) + def insert_radic_at(self, index, value): + self.radic.insert(index, value) + def replace_radic_at(self, index, value): + self.radic[index] = value + def get_perp(self): + return self.perp + def set_perp(self, perp): + self.perp = perp + def add_perp(self, value): + self.perp.append(value) + def insert_perp_at(self, index, value): + self.perp.insert(index, value) + def replace_perp_at(self, index, value): + self.perp[index] = value + def get_sum(self): + return self.sum + def set_sum(self, sum): + self.sum = sum + def add_sum(self, value): + self.sum.append(value) + def insert_sum_at(self, index, value): + self.sum.insert(index, value) + def replace_sum_at(self, index, value): + self.sum[index] = value + def get_int(self): + return self.int + def set_int(self, int): + self.int = int + def add_int(self, value): + self.int.append(value) + def insert_int_at(self, index, value): + self.int.insert(index, value) + def replace_int_at(self, index, value): + self.int[index] = value + def get_prod(self): + return self.prod + def set_prod(self, prod): + self.prod = prod + def add_prod(self, value): + self.prod.append(value) + def insert_prod_at(self, index, value): + self.prod.insert(index, value) + def replace_prod_at(self, index, value): + self.prod[index] = value + def get_sim(self): + return self.sim + def set_sim(self, sim): + self.sim = sim + def add_sim(self, value): + self.sim.append(value) + def insert_sim_at(self, index, value): + self.sim.insert(index, value) + def replace_sim_at(self, index, value): + self.sim[index] = value + def get_asymp(self): + return self.asymp + def set_asymp(self, asymp): + self.asymp = asymp + def add_asymp(self, value): + self.asymp.append(value) + def insert_asymp_at(self, index, value): + self.asymp.insert(index, value) + def replace_asymp_at(self, index, value): + self.asymp[index] = value + def get_ne(self): + return self.ne + def set_ne(self, ne): + self.ne = ne + def add_ne(self, value): + self.ne.append(value) + def insert_ne_at(self, index, value): + self.ne.insert(index, value) + def replace_ne_at(self, index, value): + self.ne[index] = value + def get_equiv(self): + return self.equiv + def set_equiv(self, equiv): + self.equiv = equiv + def add_equiv(self, value): + self.equiv.append(value) + def insert_equiv_at(self, index, value): + self.equiv.insert(index, value) + def replace_equiv_at(self, index, value): + self.equiv[index] = value + def get_prop(self): + return self.prop + def set_prop(self, prop): + self.prop = prop + def add_prop(self, value): + self.prop.append(value) + def insert_prop_at(self, index, value): + self.prop.insert(index, value) + def replace_prop_at(self, index, value): + self.prop[index] = value + def get_le(self): + return self.le + def set_le(self, le): + self.le = le + def add_le(self, value): + self.le.append(value) + def insert_le_at(self, index, value): + self.le.insert(index, value) + def replace_le_at(self, index, value): + self.le[index] = value + def get_ge(self): + return self.ge + def set_ge(self, ge): + self.ge = ge + def add_ge(self, value): + self.ge.append(value) + def insert_ge_at(self, index, value): + self.ge.insert(index, value) + def replace_ge_at(self, index, value): + self.ge[index] = value + def get_larr(self): + return self.larr + def set_larr(self, larr): + self.larr = larr + def add_larr(self, value): + self.larr.append(value) + def insert_larr_at(self, index, value): + self.larr.insert(index, value) + def replace_larr_at(self, index, value): + self.larr[index] = value + def get_rarr(self): + return self.rarr + def set_rarr(self, rarr): + self.rarr = rarr + def add_rarr(self, value): + self.rarr.append(value) + def insert_rarr_at(self, index, value): + self.rarr.insert(index, value) + def replace_rarr_at(self, index, value): + self.rarr[index] = value + def get_isin(self): + return self.isin + def set_isin(self, isin): + self.isin = isin + def add_isin(self, value): + self.isin.append(value) + def insert_isin_at(self, index, value): + self.isin.insert(index, value) + def replace_isin_at(self, index, value): + self.isin[index] = value + def get_notin(self): + return self.notin + def set_notin(self, notin): + self.notin = notin + def add_notin(self, value): + self.notin.append(value) + def insert_notin_at(self, index, value): + self.notin.insert(index, value) + def replace_notin_at(self, index, value): + self.notin[index] = value + def get_lceil(self): + return self.lceil + def set_lceil(self, lceil): + self.lceil = lceil + def add_lceil(self, value): + self.lceil.append(value) + def insert_lceil_at(self, index, value): + self.lceil.insert(index, value) + def replace_lceil_at(self, index, value): + self.lceil[index] = value + def get_rceil(self): + return self.rceil + def set_rceil(self, rceil): + self.rceil = rceil + def add_rceil(self, value): + self.rceil.append(value) + def insert_rceil_at(self, index, value): + self.rceil.insert(index, value) + def replace_rceil_at(self, index, value): + self.rceil[index] = value + def get_lfloor(self): + return self.lfloor + def set_lfloor(self, lfloor): + self.lfloor = lfloor + def add_lfloor(self, value): + self.lfloor.append(value) + def insert_lfloor_at(self, index, value): + self.lfloor.insert(index, value) + def replace_lfloor_at(self, index, value): + self.lfloor[index] = value + def get_rfloor(self): + return self.rfloor + def set_rfloor(self, rfloor): + self.rfloor = rfloor + def add_rfloor(self, value): + self.rfloor.append(value) + def insert_rfloor_at(self, index, value): + self.rfloor.insert(index, value) + def replace_rfloor_at(self, index, value): + self.rfloor[index] = value + def get_url(self): + return self.url + def set_url(self, url): + self.url = url + def get_valueOf_(self): return self.valueOf_ + def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def hasContent_(self): + if ( + self.ulink or + self.bold or + self.emphasis or + self.computeroutput or + self.subscript or + self.superscript or + self.center or + self.small or + self.htmlonly or + self.manonly or + self.xmlonly or + self.rtfonly or + self.latexonly or + self.dot or + self.msc or + self.anchor or + self.formula or + self.ref or + self.copy or + self.trademark or + self.registered or + self.lsquo or + self.rsquo or + self.ldquo or + self.rdquo or + self.ndash or + self.mdash or + self.umlaut or + self.acute or + self.grave or + self.circ or + self.slash or + self.tilde or + self.cedil or + self.ring or + self.szlig or + self.nonbreakablespace or + self.aelig or + self.AElig or + self.Gamma or + self.Delta or + self.Theta or + self.Lambda or + self.Xi or + self.Pi or + self.Sigma or + self.Upsilon or + self.Phi or + self.Psi or + self.Omega or + self.alpha or + self.beta or + self.gamma or + self.delta or + self.epsilon or + self.zeta or + self.eta or + self.theta or + self.iota or + self.kappa or + self.lambda_ or + self.mu or + self.nu or + self.xi or + self.pi or + self.rho or + self.sigma or + self.tau or + self.upsilon or + self.phi or + self.chi or + self.psi or + self.omega or + self.sigmaf or + self.sect or + self.deg or + self.prime or + self.Prime or + self.infin or + self.empty or + self.plusmn or + self.times or + self.minus or + self.sdot or + self.part or + self.nabla or + self.radic or + self.perp or + self.sum or + self.int or + self.prod or + self.sim or + self.asymp or + self.ne or + self.equiv or + self.prop or + self.le or + self.ge or + self.larr or + self.rarr or + self.isin or + self.notin or + self.lceil or + self.rceil or + self.lfloor or + self.rfloor or + (1 if type(self.valueOf_) in [int,float] else self.valueOf_) or + self.content_ + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docURLLink', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docURLLink') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docURLLink': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docURLLink') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docURLLink', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docURLLink'): + if self.url is not None and 'url' not in already_processed: + already_processed.add('url') + outfile.write(' url=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.url), input_name='url')), )) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docURLLink', fromsubclass_=False, pretty_print=True): + if not fromsubclass_: + for item_ in self.content_: + item_.export(outfile, level, item_.name, namespaceprefix_, pretty_print=pretty_print) + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for ulink_ in self.ulink: + namespaceprefix_ = self.ulink_nsprefix_ + ':' if (UseCapturedNS_ and self.ulink_nsprefix_) else '' + ulink_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ulink', pretty_print=pretty_print) + for bold_ in self.bold: + namespaceprefix_ = self.bold_nsprefix_ + ':' if (UseCapturedNS_ and self.bold_nsprefix_) else '' + bold_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='bold', pretty_print=pretty_print) + for emphasis_ in self.emphasis: + namespaceprefix_ = self.emphasis_nsprefix_ + ':' if (UseCapturedNS_ and self.emphasis_nsprefix_) else '' + emphasis_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='emphasis', pretty_print=pretty_print) + for computeroutput_ in self.computeroutput: + namespaceprefix_ = self.computeroutput_nsprefix_ + ':' if (UseCapturedNS_ and self.computeroutput_nsprefix_) else '' + computeroutput_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='computeroutput', pretty_print=pretty_print) + for subscript_ in self.subscript: + namespaceprefix_ = self.subscript_nsprefix_ + ':' if (UseCapturedNS_ and self.subscript_nsprefix_) else '' + subscript_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='subscript', pretty_print=pretty_print) + for superscript_ in self.superscript: + namespaceprefix_ = self.superscript_nsprefix_ + ':' if (UseCapturedNS_ and self.superscript_nsprefix_) else '' + superscript_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='superscript', pretty_print=pretty_print) + for center_ in self.center: + namespaceprefix_ = self.center_nsprefix_ + ':' if (UseCapturedNS_ and self.center_nsprefix_) else '' + center_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='center', pretty_print=pretty_print) + for small_ in self.small: + namespaceprefix_ = self.small_nsprefix_ + ':' if (UseCapturedNS_ and self.small_nsprefix_) else '' + small_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='small', pretty_print=pretty_print) + for htmlonly_ in self.htmlonly: + namespaceprefix_ = self.htmlonly_nsprefix_ + ':' if (UseCapturedNS_ and self.htmlonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%shtmlonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(htmlonly_), input_name='htmlonly')), namespaceprefix_ , eol_)) + for manonly_ in self.manonly: + namespaceprefix_ = self.manonly_nsprefix_ + ':' if (UseCapturedNS_ and self.manonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%smanonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(manonly_), input_name='manonly')), namespaceprefix_ , eol_)) + for xmlonly_ in self.xmlonly: + namespaceprefix_ = self.xmlonly_nsprefix_ + ':' if (UseCapturedNS_ and self.xmlonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%sxmlonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(xmlonly_), input_name='xmlonly')), namespaceprefix_ , eol_)) + for rtfonly_ in self.rtfonly: + namespaceprefix_ = self.rtfonly_nsprefix_ + ':' if (UseCapturedNS_ and self.rtfonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%srtfonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(rtfonly_), input_name='rtfonly')), namespaceprefix_ , eol_)) + for latexonly_ in self.latexonly: + namespaceprefix_ = self.latexonly_nsprefix_ + ':' if (UseCapturedNS_ and self.latexonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%slatexonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(latexonly_), input_name='latexonly')), namespaceprefix_ , eol_)) + for dot_ in self.dot: + namespaceprefix_ = self.dot_nsprefix_ + ':' if (UseCapturedNS_ and self.dot_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%sdot>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(dot_), input_name='dot')), namespaceprefix_ , eol_)) + for msc_ in self.msc: + namespaceprefix_ = self.msc_nsprefix_ + ':' if (UseCapturedNS_ and self.msc_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%smsc>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(msc_), input_name='msc')), namespaceprefix_ , eol_)) + for anchor_ in self.anchor: + namespaceprefix_ = self.anchor_nsprefix_ + ':' if (UseCapturedNS_ and self.anchor_nsprefix_) else '' + anchor_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='anchor', pretty_print=pretty_print) + for formula_ in self.formula: + namespaceprefix_ = self.formula_nsprefix_ + ':' if (UseCapturedNS_ and self.formula_nsprefix_) else '' + formula_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='formula', pretty_print=pretty_print) + for ref_ in self.ref: + namespaceprefix_ = self.ref_nsprefix_ + ':' if (UseCapturedNS_ and self.ref_nsprefix_) else '' + ref_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ref', pretty_print=pretty_print) + for copy_ in self.copy: + namespaceprefix_ = self.copy_nsprefix_ + ':' if (UseCapturedNS_ and self.copy_nsprefix_) else '' + copy_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='copy', pretty_print=pretty_print) + for trademark_ in self.trademark: + namespaceprefix_ = self.trademark_nsprefix_ + ':' if (UseCapturedNS_ and self.trademark_nsprefix_) else '' + trademark_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='trademark', pretty_print=pretty_print) + for registered_ in self.registered: + namespaceprefix_ = self.registered_nsprefix_ + ':' if (UseCapturedNS_ and self.registered_nsprefix_) else '' + registered_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='registered', pretty_print=pretty_print) + for lsquo_ in self.lsquo: + namespaceprefix_ = self.lsquo_nsprefix_ + ':' if (UseCapturedNS_ and self.lsquo_nsprefix_) else '' + lsquo_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='lsquo', pretty_print=pretty_print) + for rsquo_ in self.rsquo: + namespaceprefix_ = self.rsquo_nsprefix_ + ':' if (UseCapturedNS_ and self.rsquo_nsprefix_) else '' + rsquo_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rsquo', pretty_print=pretty_print) + for ldquo_ in self.ldquo: + namespaceprefix_ = self.ldquo_nsprefix_ + ':' if (UseCapturedNS_ and self.ldquo_nsprefix_) else '' + ldquo_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ldquo', pretty_print=pretty_print) + for rdquo_ in self.rdquo: + namespaceprefix_ = self.rdquo_nsprefix_ + ':' if (UseCapturedNS_ and self.rdquo_nsprefix_) else '' + rdquo_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rdquo', pretty_print=pretty_print) + for ndash_ in self.ndash: + namespaceprefix_ = self.ndash_nsprefix_ + ':' if (UseCapturedNS_ and self.ndash_nsprefix_) else '' + ndash_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ndash', pretty_print=pretty_print) + for mdash_ in self.mdash: + namespaceprefix_ = self.mdash_nsprefix_ + ':' if (UseCapturedNS_ and self.mdash_nsprefix_) else '' + mdash_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='mdash', pretty_print=pretty_print) + for umlaut_ in self.umlaut: + namespaceprefix_ = self.umlaut_nsprefix_ + ':' if (UseCapturedNS_ and self.umlaut_nsprefix_) else '' + umlaut_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='umlaut', pretty_print=pretty_print) + for acute_ in self.acute: + namespaceprefix_ = self.acute_nsprefix_ + ':' if (UseCapturedNS_ and self.acute_nsprefix_) else '' + acute_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='acute', pretty_print=pretty_print) + for grave_ in self.grave: + namespaceprefix_ = self.grave_nsprefix_ + ':' if (UseCapturedNS_ and self.grave_nsprefix_) else '' + grave_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='grave', pretty_print=pretty_print) + for circ_ in self.circ: + namespaceprefix_ = self.circ_nsprefix_ + ':' if (UseCapturedNS_ and self.circ_nsprefix_) else '' + circ_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='circ', pretty_print=pretty_print) + for slash_ in self.slash: + namespaceprefix_ = self.slash_nsprefix_ + ':' if (UseCapturedNS_ and self.slash_nsprefix_) else '' + slash_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='slash', pretty_print=pretty_print) + for tilde_ in self.tilde: + namespaceprefix_ = self.tilde_nsprefix_ + ':' if (UseCapturedNS_ and self.tilde_nsprefix_) else '' + tilde_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='tilde', pretty_print=pretty_print) + for cedil_ in self.cedil: + namespaceprefix_ = self.cedil_nsprefix_ + ':' if (UseCapturedNS_ and self.cedil_nsprefix_) else '' + cedil_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='cedil', pretty_print=pretty_print) + for ring_ in self.ring: + namespaceprefix_ = self.ring_nsprefix_ + ':' if (UseCapturedNS_ and self.ring_nsprefix_) else '' + ring_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ring', pretty_print=pretty_print) + for szlig_ in self.szlig: + namespaceprefix_ = self.szlig_nsprefix_ + ':' if (UseCapturedNS_ and self.szlig_nsprefix_) else '' + szlig_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='szlig', pretty_print=pretty_print) + for nonbreakablespace_ in self.nonbreakablespace: + namespaceprefix_ = self.nonbreakablespace_nsprefix_ + ':' if (UseCapturedNS_ and self.nonbreakablespace_nsprefix_) else '' + nonbreakablespace_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='nonbreakablespace', pretty_print=pretty_print) + for aelig_ in self.aelig: + namespaceprefix_ = self.aelig_nsprefix_ + ':' if (UseCapturedNS_ and self.aelig_nsprefix_) else '' + aelig_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='aelig', pretty_print=pretty_print) + for AElig_ in self.AElig: + namespaceprefix_ = self.AElig_nsprefix_ + ':' if (UseCapturedNS_ and self.AElig_nsprefix_) else '' + AElig_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='AElig', pretty_print=pretty_print) + for Gamma_ in self.Gamma: + namespaceprefix_ = self.Gamma_nsprefix_ + ':' if (UseCapturedNS_ and self.Gamma_nsprefix_) else '' + Gamma_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Gamma', pretty_print=pretty_print) + for Delta_ in self.Delta: + namespaceprefix_ = self.Delta_nsprefix_ + ':' if (UseCapturedNS_ and self.Delta_nsprefix_) else '' + Delta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Delta', pretty_print=pretty_print) + for Theta_ in self.Theta: + namespaceprefix_ = self.Theta_nsprefix_ + ':' if (UseCapturedNS_ and self.Theta_nsprefix_) else '' + Theta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Theta', pretty_print=pretty_print) + for Lambda_ in self.Lambda: + namespaceprefix_ = self.Lambda_nsprefix_ + ':' if (UseCapturedNS_ and self.Lambda_nsprefix_) else '' + Lambda_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Lambda', pretty_print=pretty_print) + for Xi_ in self.Xi: + namespaceprefix_ = self.Xi_nsprefix_ + ':' if (UseCapturedNS_ and self.Xi_nsprefix_) else '' + Xi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Xi', pretty_print=pretty_print) + for Pi_ in self.Pi: + namespaceprefix_ = self.Pi_nsprefix_ + ':' if (UseCapturedNS_ and self.Pi_nsprefix_) else '' + Pi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Pi', pretty_print=pretty_print) + for Sigma_ in self.Sigma: + namespaceprefix_ = self.Sigma_nsprefix_ + ':' if (UseCapturedNS_ and self.Sigma_nsprefix_) else '' + Sigma_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Sigma', pretty_print=pretty_print) + for Upsilon_ in self.Upsilon: + namespaceprefix_ = self.Upsilon_nsprefix_ + ':' if (UseCapturedNS_ and self.Upsilon_nsprefix_) else '' + Upsilon_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Upsilon', pretty_print=pretty_print) + for Phi_ in self.Phi: + namespaceprefix_ = self.Phi_nsprefix_ + ':' if (UseCapturedNS_ and self.Phi_nsprefix_) else '' + Phi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Phi', pretty_print=pretty_print) + for Psi_ in self.Psi: + namespaceprefix_ = self.Psi_nsprefix_ + ':' if (UseCapturedNS_ and self.Psi_nsprefix_) else '' + Psi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Psi', pretty_print=pretty_print) + for Omega_ in self.Omega: + namespaceprefix_ = self.Omega_nsprefix_ + ':' if (UseCapturedNS_ and self.Omega_nsprefix_) else '' + Omega_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Omega', pretty_print=pretty_print) + for alpha_ in self.alpha: + namespaceprefix_ = self.alpha_nsprefix_ + ':' if (UseCapturedNS_ and self.alpha_nsprefix_) else '' + alpha_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='alpha', pretty_print=pretty_print) + for beta_ in self.beta: + namespaceprefix_ = self.beta_nsprefix_ + ':' if (UseCapturedNS_ and self.beta_nsprefix_) else '' + beta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='beta', pretty_print=pretty_print) + for gamma_ in self.gamma: + namespaceprefix_ = self.gamma_nsprefix_ + ':' if (UseCapturedNS_ and self.gamma_nsprefix_) else '' + gamma_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='gamma', pretty_print=pretty_print) + for delta_ in self.delta: + namespaceprefix_ = self.delta_nsprefix_ + ':' if (UseCapturedNS_ and self.delta_nsprefix_) else '' + delta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='delta', pretty_print=pretty_print) + for epsilon_ in self.epsilon: + namespaceprefix_ = self.epsilon_nsprefix_ + ':' if (UseCapturedNS_ and self.epsilon_nsprefix_) else '' + epsilon_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='epsilon', pretty_print=pretty_print) + for zeta_ in self.zeta: + namespaceprefix_ = self.zeta_nsprefix_ + ':' if (UseCapturedNS_ and self.zeta_nsprefix_) else '' + zeta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='zeta', pretty_print=pretty_print) + for eta_ in self.eta: + namespaceprefix_ = self.eta_nsprefix_ + ':' if (UseCapturedNS_ and self.eta_nsprefix_) else '' + eta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='eta', pretty_print=pretty_print) + for theta_ in self.theta: + namespaceprefix_ = self.theta_nsprefix_ + ':' if (UseCapturedNS_ and self.theta_nsprefix_) else '' + theta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='theta', pretty_print=pretty_print) + for iota_ in self.iota: + namespaceprefix_ = self.iota_nsprefix_ + ':' if (UseCapturedNS_ and self.iota_nsprefix_) else '' + iota_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='iota', pretty_print=pretty_print) + for kappa_ in self.kappa: + namespaceprefix_ = self.kappa_nsprefix_ + ':' if (UseCapturedNS_ and self.kappa_nsprefix_) else '' + kappa_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='kappa', pretty_print=pretty_print) + for lambda_ in self.lambda_: + namespaceprefix_ = self.lambda__nsprefix_ + ':' if (UseCapturedNS_ and self.lambda__nsprefix_) else '' + lambda_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='lambda', pretty_print=pretty_print) + for mu_ in self.mu: + namespaceprefix_ = self.mu_nsprefix_ + ':' if (UseCapturedNS_ and self.mu_nsprefix_) else '' + mu_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='mu', pretty_print=pretty_print) + for nu_ in self.nu: + namespaceprefix_ = self.nu_nsprefix_ + ':' if (UseCapturedNS_ and self.nu_nsprefix_) else '' + nu_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='nu', pretty_print=pretty_print) + for xi_ in self.xi: + namespaceprefix_ = self.xi_nsprefix_ + ':' if (UseCapturedNS_ and self.xi_nsprefix_) else '' + xi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='xi', pretty_print=pretty_print) + for pi_ in self.pi: + namespaceprefix_ = self.pi_nsprefix_ + ':' if (UseCapturedNS_ and self.pi_nsprefix_) else '' + pi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='pi', pretty_print=pretty_print) + for rho_ in self.rho: + namespaceprefix_ = self.rho_nsprefix_ + ':' if (UseCapturedNS_ and self.rho_nsprefix_) else '' + rho_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rho', pretty_print=pretty_print) + for sigma_ in self.sigma: + namespaceprefix_ = self.sigma_nsprefix_ + ':' if (UseCapturedNS_ and self.sigma_nsprefix_) else '' + sigma_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sigma', pretty_print=pretty_print) + for tau_ in self.tau: + namespaceprefix_ = self.tau_nsprefix_ + ':' if (UseCapturedNS_ and self.tau_nsprefix_) else '' + tau_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='tau', pretty_print=pretty_print) + for upsilon_ in self.upsilon: + namespaceprefix_ = self.upsilon_nsprefix_ + ':' if (UseCapturedNS_ and self.upsilon_nsprefix_) else '' + upsilon_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='upsilon', pretty_print=pretty_print) + for phi_ in self.phi: + namespaceprefix_ = self.phi_nsprefix_ + ':' if (UseCapturedNS_ and self.phi_nsprefix_) else '' + phi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='phi', pretty_print=pretty_print) + for chi_ in self.chi: + namespaceprefix_ = self.chi_nsprefix_ + ':' if (UseCapturedNS_ and self.chi_nsprefix_) else '' + chi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='chi', pretty_print=pretty_print) + for psi_ in self.psi: + namespaceprefix_ = self.psi_nsprefix_ + ':' if (UseCapturedNS_ and self.psi_nsprefix_) else '' + psi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='psi', pretty_print=pretty_print) + for omega_ in self.omega: + namespaceprefix_ = self.omega_nsprefix_ + ':' if (UseCapturedNS_ and self.omega_nsprefix_) else '' + omega_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='omega', pretty_print=pretty_print) + for sigmaf_ in self.sigmaf: + namespaceprefix_ = self.sigmaf_nsprefix_ + ':' if (UseCapturedNS_ and self.sigmaf_nsprefix_) else '' + sigmaf_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sigmaf', pretty_print=pretty_print) + for sect_ in self.sect: + namespaceprefix_ = self.sect_nsprefix_ + ':' if (UseCapturedNS_ and self.sect_nsprefix_) else '' + sect_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sect', pretty_print=pretty_print) + for deg_ in self.deg: + namespaceprefix_ = self.deg_nsprefix_ + ':' if (UseCapturedNS_ and self.deg_nsprefix_) else '' + deg_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='deg', pretty_print=pretty_print) + for prime_ in self.prime: + namespaceprefix_ = self.prime_nsprefix_ + ':' if (UseCapturedNS_ and self.prime_nsprefix_) else '' + prime_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='prime', pretty_print=pretty_print) + for Prime_ in self.Prime: + namespaceprefix_ = self.Prime_nsprefix_ + ':' if (UseCapturedNS_ and self.Prime_nsprefix_) else '' + Prime_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Prime', pretty_print=pretty_print) + for infin_ in self.infin: + namespaceprefix_ = self.infin_nsprefix_ + ':' if (UseCapturedNS_ and self.infin_nsprefix_) else '' + infin_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='infin', pretty_print=pretty_print) + for empty_ in self.empty: + namespaceprefix_ = self.empty_nsprefix_ + ':' if (UseCapturedNS_ and self.empty_nsprefix_) else '' + empty_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='empty', pretty_print=pretty_print) + for plusmn_ in self.plusmn: + namespaceprefix_ = self.plusmn_nsprefix_ + ':' if (UseCapturedNS_ and self.plusmn_nsprefix_) else '' + plusmn_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='plusmn', pretty_print=pretty_print) + for times_ in self.times: + namespaceprefix_ = self.times_nsprefix_ + ':' if (UseCapturedNS_ and self.times_nsprefix_) else '' + times_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='times', pretty_print=pretty_print) + for minus_ in self.minus: + namespaceprefix_ = self.minus_nsprefix_ + ':' if (UseCapturedNS_ and self.minus_nsprefix_) else '' + minus_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='minus', pretty_print=pretty_print) + for sdot_ in self.sdot: + namespaceprefix_ = self.sdot_nsprefix_ + ':' if (UseCapturedNS_ and self.sdot_nsprefix_) else '' + sdot_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sdot', pretty_print=pretty_print) + for part_ in self.part: + namespaceprefix_ = self.part_nsprefix_ + ':' if (UseCapturedNS_ and self.part_nsprefix_) else '' + part_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='part', pretty_print=pretty_print) + for nabla_ in self.nabla: + namespaceprefix_ = self.nabla_nsprefix_ + ':' if (UseCapturedNS_ and self.nabla_nsprefix_) else '' + nabla_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='nabla', pretty_print=pretty_print) + for radic_ in self.radic: + namespaceprefix_ = self.radic_nsprefix_ + ':' if (UseCapturedNS_ and self.radic_nsprefix_) else '' + radic_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='radic', pretty_print=pretty_print) + for perp_ in self.perp: + namespaceprefix_ = self.perp_nsprefix_ + ':' if (UseCapturedNS_ and self.perp_nsprefix_) else '' + perp_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='perp', pretty_print=pretty_print) + for sum_ in self.sum: + namespaceprefix_ = self.sum_nsprefix_ + ':' if (UseCapturedNS_ and self.sum_nsprefix_) else '' + sum_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sum', pretty_print=pretty_print) + for int_ in self.int: + namespaceprefix_ = self.int_nsprefix_ + ':' if (UseCapturedNS_ and self.int_nsprefix_) else '' + int_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='int', pretty_print=pretty_print) + for prod_ in self.prod: + namespaceprefix_ = self.prod_nsprefix_ + ':' if (UseCapturedNS_ and self.prod_nsprefix_) else '' + prod_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='prod', pretty_print=pretty_print) + for sim_ in self.sim: + namespaceprefix_ = self.sim_nsprefix_ + ':' if (UseCapturedNS_ and self.sim_nsprefix_) else '' + sim_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sim', pretty_print=pretty_print) + for asymp_ in self.asymp: + namespaceprefix_ = self.asymp_nsprefix_ + ':' if (UseCapturedNS_ and self.asymp_nsprefix_) else '' + asymp_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='asymp', pretty_print=pretty_print) + for ne_ in self.ne: + namespaceprefix_ = self.ne_nsprefix_ + ':' if (UseCapturedNS_ and self.ne_nsprefix_) else '' + ne_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ne', pretty_print=pretty_print) + for equiv_ in self.equiv: + namespaceprefix_ = self.equiv_nsprefix_ + ':' if (UseCapturedNS_ and self.equiv_nsprefix_) else '' + equiv_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='equiv', pretty_print=pretty_print) + for prop_ in self.prop: + namespaceprefix_ = self.prop_nsprefix_ + ':' if (UseCapturedNS_ and self.prop_nsprefix_) else '' + prop_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='prop', pretty_print=pretty_print) + for le_ in self.le: + namespaceprefix_ = self.le_nsprefix_ + ':' if (UseCapturedNS_ and self.le_nsprefix_) else '' + le_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='le', pretty_print=pretty_print) + for ge_ in self.ge: + namespaceprefix_ = self.ge_nsprefix_ + ':' if (UseCapturedNS_ and self.ge_nsprefix_) else '' + ge_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ge', pretty_print=pretty_print) + for larr_ in self.larr: + namespaceprefix_ = self.larr_nsprefix_ + ':' if (UseCapturedNS_ and self.larr_nsprefix_) else '' + larr_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='larr', pretty_print=pretty_print) + for rarr_ in self.rarr: + namespaceprefix_ = self.rarr_nsprefix_ + ':' if (UseCapturedNS_ and self.rarr_nsprefix_) else '' + rarr_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rarr', pretty_print=pretty_print) + for isin_ in self.isin: + namespaceprefix_ = self.isin_nsprefix_ + ':' if (UseCapturedNS_ and self.isin_nsprefix_) else '' + isin_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='isin', pretty_print=pretty_print) + for notin_ in self.notin: + namespaceprefix_ = self.notin_nsprefix_ + ':' if (UseCapturedNS_ and self.notin_nsprefix_) else '' + notin_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='notin', pretty_print=pretty_print) + for lceil_ in self.lceil: + namespaceprefix_ = self.lceil_nsprefix_ + ':' if (UseCapturedNS_ and self.lceil_nsprefix_) else '' + lceil_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='lceil', pretty_print=pretty_print) + for rceil_ in self.rceil: + namespaceprefix_ = self.rceil_nsprefix_ + ':' if (UseCapturedNS_ and self.rceil_nsprefix_) else '' + rceil_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rceil', pretty_print=pretty_print) + for lfloor_ in self.lfloor: + namespaceprefix_ = self.lfloor_nsprefix_ + ':' if (UseCapturedNS_ and self.lfloor_nsprefix_) else '' + lfloor_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='lfloor', pretty_print=pretty_print) + for rfloor_ in self.rfloor: + namespaceprefix_ = self.rfloor_nsprefix_ + ':' if (UseCapturedNS_ and self.rfloor_nsprefix_) else '' + rfloor_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rfloor', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + self.valueOf_ = get_all_text_(node) + if node.text is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', node.text) + self.content_.append(obj_) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('url', node) + if value is not None and 'url' not in already_processed: + already_processed.add('url') + self.url = value + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'ulink': + obj_ = docURLLink.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ulink', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ulink'): + self.add_ulink(obj_.value) + elif hasattr(self, 'set_ulink'): + self.set_ulink(obj_.value) + elif nodeName_ == 'bold': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'bold', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_bold'): + self.add_bold(obj_.value) + elif hasattr(self, 'set_bold'): + self.set_bold(obj_.value) + elif nodeName_ == 'emphasis': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'emphasis', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_emphasis'): + self.add_emphasis(obj_.value) + elif hasattr(self, 'set_emphasis'): + self.set_emphasis(obj_.value) + elif nodeName_ == 'computeroutput': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'computeroutput', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_computeroutput'): + self.add_computeroutput(obj_.value) + elif hasattr(self, 'set_computeroutput'): + self.set_computeroutput(obj_.value) + elif nodeName_ == 'subscript': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'subscript', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_subscript'): + self.add_subscript(obj_.value) + elif hasattr(self, 'set_subscript'): + self.set_subscript(obj_.value) + elif nodeName_ == 'superscript': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'superscript', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_superscript'): + self.add_superscript(obj_.value) + elif hasattr(self, 'set_superscript'): + self.set_superscript(obj_.value) + elif nodeName_ == 'center': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'center', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_center'): + self.add_center(obj_.value) + elif hasattr(self, 'set_center'): + self.set_center(obj_.value) + elif nodeName_ == 'small': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'small', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_small'): + self.add_small(obj_.value) + elif hasattr(self, 'set_small'): + self.set_small(obj_.value) + elif nodeName_ == 'htmlonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'htmlonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'htmlonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'htmlonly', valuestr_) + self.content_.append(obj_) + self.htmlonly_nsprefix_ = child_.prefix + elif nodeName_ == 'manonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'manonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'manonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'manonly', valuestr_) + self.content_.append(obj_) + self.manonly_nsprefix_ = child_.prefix + elif nodeName_ == 'xmlonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'xmlonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'xmlonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'xmlonly', valuestr_) + self.content_.append(obj_) + self.xmlonly_nsprefix_ = child_.prefix + elif nodeName_ == 'rtfonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'rtfonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'rtfonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'rtfonly', valuestr_) + self.content_.append(obj_) + self.rtfonly_nsprefix_ = child_.prefix + elif nodeName_ == 'latexonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'latexonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'latexonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'latexonly', valuestr_) + self.content_.append(obj_) + self.latexonly_nsprefix_ = child_.prefix + elif nodeName_ == 'dot' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'dot') + valuestr_ = self.gds_validate_string(valuestr_, node, 'dot') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'dot', valuestr_) + self.content_.append(obj_) + self.dot_nsprefix_ = child_.prefix + elif nodeName_ == 'msc' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'msc') + valuestr_ = self.gds_validate_string(valuestr_, node, 'msc') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'msc', valuestr_) + self.content_.append(obj_) + self.msc_nsprefix_ = child_.prefix + elif nodeName_ == 'anchor': + obj_ = docAnchorType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'anchor', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_anchor'): + self.add_anchor(obj_.value) + elif hasattr(self, 'set_anchor'): + self.set_anchor(obj_.value) + elif nodeName_ == 'formula': + obj_ = docFormulaType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'formula', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_formula'): + self.add_formula(obj_.value) + elif hasattr(self, 'set_formula'): + self.set_formula(obj_.value) + elif nodeName_ == 'ref': + obj_ = docRefTextType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ref', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ref'): + self.add_ref(obj_.value) + elif hasattr(self, 'set_ref'): + self.set_ref(obj_.value) + elif nodeName_ == 'copy': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'copy', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_copy'): + self.add_copy(obj_.value) + elif hasattr(self, 'set_copy'): + self.set_copy(obj_.value) + elif nodeName_ == 'trademark': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'trademark', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_trademark'): + self.add_trademark(obj_.value) + elif hasattr(self, 'set_trademark'): + self.set_trademark(obj_.value) + elif nodeName_ == 'registered': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'registered', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_registered'): + self.add_registered(obj_.value) + elif hasattr(self, 'set_registered'): + self.set_registered(obj_.value) + elif nodeName_ == 'lsquo': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'lsquo', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_lsquo'): + self.add_lsquo(obj_.value) + elif hasattr(self, 'set_lsquo'): + self.set_lsquo(obj_.value) + elif nodeName_ == 'rsquo': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rsquo', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rsquo'): + self.add_rsquo(obj_.value) + elif hasattr(self, 'set_rsquo'): + self.set_rsquo(obj_.value) + elif nodeName_ == 'ldquo': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ldquo', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ldquo'): + self.add_ldquo(obj_.value) + elif hasattr(self, 'set_ldquo'): + self.set_ldquo(obj_.value) + elif nodeName_ == 'rdquo': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rdquo', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rdquo'): + self.add_rdquo(obj_.value) + elif hasattr(self, 'set_rdquo'): + self.set_rdquo(obj_.value) + elif nodeName_ == 'ndash': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ndash', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ndash'): + self.add_ndash(obj_.value) + elif hasattr(self, 'set_ndash'): + self.set_ndash(obj_.value) + elif nodeName_ == 'mdash': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'mdash', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_mdash'): + self.add_mdash(obj_.value) + elif hasattr(self, 'set_mdash'): + self.set_mdash(obj_.value) + elif nodeName_ == 'umlaut': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'umlaut', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_umlaut'): + self.add_umlaut(obj_.value) + elif hasattr(self, 'set_umlaut'): + self.set_umlaut(obj_.value) + elif nodeName_ == 'acute': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'acute', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_acute'): + self.add_acute(obj_.value) + elif hasattr(self, 'set_acute'): + self.set_acute(obj_.value) + elif nodeName_ == 'grave': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'grave', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_grave'): + self.add_grave(obj_.value) + elif hasattr(self, 'set_grave'): + self.set_grave(obj_.value) + elif nodeName_ == 'circ': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'circ', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_circ'): + self.add_circ(obj_.value) + elif hasattr(self, 'set_circ'): + self.set_circ(obj_.value) + elif nodeName_ == 'slash': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'slash', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_slash'): + self.add_slash(obj_.value) + elif hasattr(self, 'set_slash'): + self.set_slash(obj_.value) + elif nodeName_ == 'tilde': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'tilde', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_tilde'): + self.add_tilde(obj_.value) + elif hasattr(self, 'set_tilde'): + self.set_tilde(obj_.value) + elif nodeName_ == 'cedil': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'cedil', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_cedil'): + self.add_cedil(obj_.value) + elif hasattr(self, 'set_cedil'): + self.set_cedil(obj_.value) + elif nodeName_ == 'ring': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ring', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ring'): + self.add_ring(obj_.value) + elif hasattr(self, 'set_ring'): + self.set_ring(obj_.value) + elif nodeName_ == 'szlig': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'szlig', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_szlig'): + self.add_szlig(obj_.value) + elif hasattr(self, 'set_szlig'): + self.set_szlig(obj_.value) + elif nodeName_ == 'nonbreakablespace': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'nonbreakablespace', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_nonbreakablespace'): + self.add_nonbreakablespace(obj_.value) + elif hasattr(self, 'set_nonbreakablespace'): + self.set_nonbreakablespace(obj_.value) + elif nodeName_ == 'aelig': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'aelig', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_aelig'): + self.add_aelig(obj_.value) + elif hasattr(self, 'set_aelig'): + self.set_aelig(obj_.value) + elif nodeName_ == 'AElig': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'AElig', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_AElig'): + self.add_AElig(obj_.value) + elif hasattr(self, 'set_AElig'): + self.set_AElig(obj_.value) + elif nodeName_ == 'Gamma': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Gamma', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Gamma'): + self.add_Gamma(obj_.value) + elif hasattr(self, 'set_Gamma'): + self.set_Gamma(obj_.value) + elif nodeName_ == 'Delta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Delta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Delta'): + self.add_Delta(obj_.value) + elif hasattr(self, 'set_Delta'): + self.set_Delta(obj_.value) + elif nodeName_ == 'Theta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Theta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Theta'): + self.add_Theta(obj_.value) + elif hasattr(self, 'set_Theta'): + self.set_Theta(obj_.value) + elif nodeName_ == 'Lambda': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Lambda', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Lambda'): + self.add_Lambda(obj_.value) + elif hasattr(self, 'set_Lambda'): + self.set_Lambda(obj_.value) + elif nodeName_ == 'Xi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Xi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Xi'): + self.add_Xi(obj_.value) + elif hasattr(self, 'set_Xi'): + self.set_Xi(obj_.value) + elif nodeName_ == 'Pi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Pi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Pi'): + self.add_Pi(obj_.value) + elif hasattr(self, 'set_Pi'): + self.set_Pi(obj_.value) + elif nodeName_ == 'Sigma': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Sigma', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Sigma'): + self.add_Sigma(obj_.value) + elif hasattr(self, 'set_Sigma'): + self.set_Sigma(obj_.value) + elif nodeName_ == 'Upsilon': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Upsilon', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Upsilon'): + self.add_Upsilon(obj_.value) + elif hasattr(self, 'set_Upsilon'): + self.set_Upsilon(obj_.value) + elif nodeName_ == 'Phi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Phi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Phi'): + self.add_Phi(obj_.value) + elif hasattr(self, 'set_Phi'): + self.set_Phi(obj_.value) + elif nodeName_ == 'Psi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Psi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Psi'): + self.add_Psi(obj_.value) + elif hasattr(self, 'set_Psi'): + self.set_Psi(obj_.value) + elif nodeName_ == 'Omega': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Omega', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Omega'): + self.add_Omega(obj_.value) + elif hasattr(self, 'set_Omega'): + self.set_Omega(obj_.value) + elif nodeName_ == 'alpha': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'alpha', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_alpha'): + self.add_alpha(obj_.value) + elif hasattr(self, 'set_alpha'): + self.set_alpha(obj_.value) + elif nodeName_ == 'beta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'beta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_beta'): + self.add_beta(obj_.value) + elif hasattr(self, 'set_beta'): + self.set_beta(obj_.value) + elif nodeName_ == 'gamma': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'gamma', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_gamma'): + self.add_gamma(obj_.value) + elif hasattr(self, 'set_gamma'): + self.set_gamma(obj_.value) + elif nodeName_ == 'delta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'delta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_delta'): + self.add_delta(obj_.value) + elif hasattr(self, 'set_delta'): + self.set_delta(obj_.value) + elif nodeName_ == 'epsilon': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'epsilon', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_epsilon'): + self.add_epsilon(obj_.value) + elif hasattr(self, 'set_epsilon'): + self.set_epsilon(obj_.value) + elif nodeName_ == 'zeta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'zeta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_zeta'): + self.add_zeta(obj_.value) + elif hasattr(self, 'set_zeta'): + self.set_zeta(obj_.value) + elif nodeName_ == 'eta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'eta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_eta'): + self.add_eta(obj_.value) + elif hasattr(self, 'set_eta'): + self.set_eta(obj_.value) + elif nodeName_ == 'theta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'theta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_theta'): + self.add_theta(obj_.value) + elif hasattr(self, 'set_theta'): + self.set_theta(obj_.value) + elif nodeName_ == 'iota': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'iota', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_iota'): + self.add_iota(obj_.value) + elif hasattr(self, 'set_iota'): + self.set_iota(obj_.value) + elif nodeName_ == 'kappa': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'kappa', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_kappa'): + self.add_kappa(obj_.value) + elif hasattr(self, 'set_kappa'): + self.set_kappa(obj_.value) + elif nodeName_ == 'lambda': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'lambda', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_lambda'): + self.add_lambda(obj_.value) + elif hasattr(self, 'set_lambda'): + self.set_lambda(obj_.value) + elif nodeName_ == 'mu': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'mu', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_mu'): + self.add_mu(obj_.value) + elif hasattr(self, 'set_mu'): + self.set_mu(obj_.value) + elif nodeName_ == 'nu': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'nu', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_nu'): + self.add_nu(obj_.value) + elif hasattr(self, 'set_nu'): + self.set_nu(obj_.value) + elif nodeName_ == 'xi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'xi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_xi'): + self.add_xi(obj_.value) + elif hasattr(self, 'set_xi'): + self.set_xi(obj_.value) + elif nodeName_ == 'pi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'pi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_pi'): + self.add_pi(obj_.value) + elif hasattr(self, 'set_pi'): + self.set_pi(obj_.value) + elif nodeName_ == 'rho': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rho', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rho'): + self.add_rho(obj_.value) + elif hasattr(self, 'set_rho'): + self.set_rho(obj_.value) + elif nodeName_ == 'sigma': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sigma', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sigma'): + self.add_sigma(obj_.value) + elif hasattr(self, 'set_sigma'): + self.set_sigma(obj_.value) + elif nodeName_ == 'tau': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'tau', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_tau'): + self.add_tau(obj_.value) + elif hasattr(self, 'set_tau'): + self.set_tau(obj_.value) + elif nodeName_ == 'upsilon': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'upsilon', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_upsilon'): + self.add_upsilon(obj_.value) + elif hasattr(self, 'set_upsilon'): + self.set_upsilon(obj_.value) + elif nodeName_ == 'phi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'phi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_phi'): + self.add_phi(obj_.value) + elif hasattr(self, 'set_phi'): + self.set_phi(obj_.value) + elif nodeName_ == 'chi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'chi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_chi'): + self.add_chi(obj_.value) + elif hasattr(self, 'set_chi'): + self.set_chi(obj_.value) + elif nodeName_ == 'psi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'psi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_psi'): + self.add_psi(obj_.value) + elif hasattr(self, 'set_psi'): + self.set_psi(obj_.value) + elif nodeName_ == 'omega': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'omega', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_omega'): + self.add_omega(obj_.value) + elif hasattr(self, 'set_omega'): + self.set_omega(obj_.value) + elif nodeName_ == 'sigmaf': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sigmaf', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sigmaf'): + self.add_sigmaf(obj_.value) + elif hasattr(self, 'set_sigmaf'): + self.set_sigmaf(obj_.value) + elif nodeName_ == 'sect': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sect', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sect'): + self.add_sect(obj_.value) + elif hasattr(self, 'set_sect'): + self.set_sect(obj_.value) + elif nodeName_ == 'deg': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'deg', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_deg'): + self.add_deg(obj_.value) + elif hasattr(self, 'set_deg'): + self.set_deg(obj_.value) + elif nodeName_ == 'prime': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'prime', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_prime'): + self.add_prime(obj_.value) + elif hasattr(self, 'set_prime'): + self.set_prime(obj_.value) + elif nodeName_ == 'Prime': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Prime', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Prime'): + self.add_Prime(obj_.value) + elif hasattr(self, 'set_Prime'): + self.set_Prime(obj_.value) + elif nodeName_ == 'infin': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'infin', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_infin'): + self.add_infin(obj_.value) + elif hasattr(self, 'set_infin'): + self.set_infin(obj_.value) + elif nodeName_ == 'empty': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'empty', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_empty'): + self.add_empty(obj_.value) + elif hasattr(self, 'set_empty'): + self.set_empty(obj_.value) + elif nodeName_ == 'plusmn': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'plusmn', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_plusmn'): + self.add_plusmn(obj_.value) + elif hasattr(self, 'set_plusmn'): + self.set_plusmn(obj_.value) + elif nodeName_ == 'times': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'times', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_times'): + self.add_times(obj_.value) + elif hasattr(self, 'set_times'): + self.set_times(obj_.value) + elif nodeName_ == 'minus': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'minus', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_minus'): + self.add_minus(obj_.value) + elif hasattr(self, 'set_minus'): + self.set_minus(obj_.value) + elif nodeName_ == 'sdot': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sdot', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sdot'): + self.add_sdot(obj_.value) + elif hasattr(self, 'set_sdot'): + self.set_sdot(obj_.value) + elif nodeName_ == 'part': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'part', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_part'): + self.add_part(obj_.value) + elif hasattr(self, 'set_part'): + self.set_part(obj_.value) + elif nodeName_ == 'nabla': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'nabla', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_nabla'): + self.add_nabla(obj_.value) + elif hasattr(self, 'set_nabla'): + self.set_nabla(obj_.value) + elif nodeName_ == 'radic': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'radic', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_radic'): + self.add_radic(obj_.value) + elif hasattr(self, 'set_radic'): + self.set_radic(obj_.value) + elif nodeName_ == 'perp': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'perp', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_perp'): + self.add_perp(obj_.value) + elif hasattr(self, 'set_perp'): + self.set_perp(obj_.value) + elif nodeName_ == 'sum': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sum', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sum'): + self.add_sum(obj_.value) + elif hasattr(self, 'set_sum'): + self.set_sum(obj_.value) + elif nodeName_ == 'int': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'int', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_int'): + self.add_int(obj_.value) + elif hasattr(self, 'set_int'): + self.set_int(obj_.value) + elif nodeName_ == 'prod': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'prod', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_prod'): + self.add_prod(obj_.value) + elif hasattr(self, 'set_prod'): + self.set_prod(obj_.value) + elif nodeName_ == 'sim': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sim', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sim'): + self.add_sim(obj_.value) + elif hasattr(self, 'set_sim'): + self.set_sim(obj_.value) + elif nodeName_ == 'asymp': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'asymp', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_asymp'): + self.add_asymp(obj_.value) + elif hasattr(self, 'set_asymp'): + self.set_asymp(obj_.value) + elif nodeName_ == 'ne': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ne', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ne'): + self.add_ne(obj_.value) + elif hasattr(self, 'set_ne'): + self.set_ne(obj_.value) + elif nodeName_ == 'equiv': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'equiv', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_equiv'): + self.add_equiv(obj_.value) + elif hasattr(self, 'set_equiv'): + self.set_equiv(obj_.value) + elif nodeName_ == 'prop': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'prop', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_prop'): + self.add_prop(obj_.value) + elif hasattr(self, 'set_prop'): + self.set_prop(obj_.value) + elif nodeName_ == 'le': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'le', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_le'): + self.add_le(obj_.value) + elif hasattr(self, 'set_le'): + self.set_le(obj_.value) + elif nodeName_ == 'ge': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ge', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ge'): + self.add_ge(obj_.value) + elif hasattr(self, 'set_ge'): + self.set_ge(obj_.value) + elif nodeName_ == 'larr': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'larr', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_larr'): + self.add_larr(obj_.value) + elif hasattr(self, 'set_larr'): + self.set_larr(obj_.value) + elif nodeName_ == 'rarr': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rarr', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rarr'): + self.add_rarr(obj_.value) + elif hasattr(self, 'set_rarr'): + self.set_rarr(obj_.value) + elif nodeName_ == 'isin': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'isin', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_isin'): + self.add_isin(obj_.value) + elif hasattr(self, 'set_isin'): + self.set_isin(obj_.value) + elif nodeName_ == 'notin': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'notin', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_notin'): + self.add_notin(obj_.value) + elif hasattr(self, 'set_notin'): + self.set_notin(obj_.value) + elif nodeName_ == 'lceil': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'lceil', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_lceil'): + self.add_lceil(obj_.value) + elif hasattr(self, 'set_lceil'): + self.set_lceil(obj_.value) + elif nodeName_ == 'rceil': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rceil', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rceil'): + self.add_rceil(obj_.value) + elif hasattr(self, 'set_rceil'): + self.set_rceil(obj_.value) + elif nodeName_ == 'lfloor': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'lfloor', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_lfloor'): + self.add_lfloor(obj_.value) + elif hasattr(self, 'set_lfloor'): + self.set_lfloor(obj_.value) + elif nodeName_ == 'rfloor': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rfloor', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rfloor'): + self.add_rfloor(obj_.value) + elif hasattr(self, 'set_rfloor'): + self.set_rfloor(obj_.value) + if not fromsubclass_ and child_.tail is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.tail) + self.content_.append(obj_) +# end class docURLLink + + +class docAnchorType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, id=None, valueOf_=None, mixedclass_=None, content_=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.id = _cast(None, id) + self.id_nsprefix_ = None + self.valueOf_ = valueOf_ + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + self.valueOf_ = valueOf_ + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docAnchorType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docAnchorType.subclass: + return docAnchorType.subclass(*args_, **kwargs_) + return docAnchorType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + def get_id(self): + return self.id + def set_id(self, id): + self.id = id + def get_valueOf_(self): return self.valueOf_ + def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def hasContent_(self): + if ( + (1 if type(self.valueOf_) in [int,float] else self.valueOf_) or + self.content_ + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docAnchorType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docAnchorType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docAnchorType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docAnchorType') + outfile.write('>') + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_, pretty_print=pretty_print) + outfile.write(self.convert_unicode(self.valueOf_)) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docAnchorType'): + if self.id is not None and 'id' not in already_processed: + already_processed.add('id') + outfile.write(' id=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.id), input_name='id')), )) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docAnchorType', fromsubclass_=False, pretty_print=True): + pass + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + self.valueOf_ = get_all_text_(node) + if node.text is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', node.text) + self.content_.append(obj_) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('id', node) + if value is not None and 'id' not in already_processed: + already_processed.add('id') + self.id = value + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if not fromsubclass_ and child_.tail is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.tail) + self.content_.append(obj_) + pass +# end class docAnchorType + + +class docFormulaType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, id=None, valueOf_=None, mixedclass_=None, content_=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.id = _cast(None, id) + self.id_nsprefix_ = None + self.valueOf_ = valueOf_ + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + self.valueOf_ = valueOf_ + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docFormulaType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docFormulaType.subclass: + return docFormulaType.subclass(*args_, **kwargs_) + return docFormulaType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + def get_id(self): + return self.id + def set_id(self, id): + self.id = id + def get_valueOf_(self): return self.valueOf_ + def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def hasContent_(self): + if ( + (1 if type(self.valueOf_) in [int,float] else self.valueOf_) or + self.content_ + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docFormulaType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docFormulaType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docFormulaType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docFormulaType') + outfile.write('>') + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_, pretty_print=pretty_print) + outfile.write(self.convert_unicode(self.valueOf_)) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docFormulaType'): + if self.id is not None and 'id' not in already_processed: + already_processed.add('id') + outfile.write(' id=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.id), input_name='id')), )) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docFormulaType', fromsubclass_=False, pretty_print=True): + pass + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + self.valueOf_ = get_all_text_(node) + if node.text is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', node.text) + self.content_.append(obj_) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('id', node) + if value is not None and 'id' not in already_processed: + already_processed.add('id') + self.id = value + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if not fromsubclass_ and child_.tail is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.tail) + self.content_.append(obj_) + pass +# end class docFormulaType + + +class docIndexEntryType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, primaryie=None, secondaryie=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.primaryie = primaryie + self.primaryie_nsprefix_ = None + self.secondaryie = secondaryie + self.secondaryie_nsprefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docIndexEntryType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docIndexEntryType.subclass: + return docIndexEntryType.subclass(*args_, **kwargs_) + return docIndexEntryType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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 hasContent_(self): + if ( + self.primaryie is not None or + self.secondaryie is not None + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docIndexEntryType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docIndexEntryType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docIndexEntryType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docIndexEntryType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docIndexEntryType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docIndexEntryType'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docIndexEntryType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.primaryie is not None: + namespaceprefix_ = self.primaryie_nsprefix_ + ':' if (UseCapturedNS_ and self.primaryie_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%sprimaryie>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.primaryie), input_name='primaryie')), namespaceprefix_ , eol_)) + if self.secondaryie is not None: + namespaceprefix_ = self.secondaryie_nsprefix_ + ':' if (UseCapturedNS_ and self.secondaryie_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%ssecondaryie>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.secondaryie), input_name='secondaryie')), namespaceprefix_ , eol_)) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'primaryie': + value_ = child_.text + value_ = self.gds_parse_string(value_, node, 'primaryie') + value_ = self.gds_validate_string(value_, node, 'primaryie') + self.primaryie = value_ + self.primaryie_nsprefix_ = child_.prefix + elif nodeName_ == 'secondaryie': + value_ = child_.text + value_ = self.gds_parse_string(value_, node, 'secondaryie') + value_ = self.gds_validate_string(value_, node, 'secondaryie') + self.secondaryie = value_ + self.secondaryie_nsprefix_ = child_.prefix +# end class docIndexEntryType + + +class docListType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, listitem=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + if listitem is None: + self.listitem = [] + else: + self.listitem = listitem + self.listitem_nsprefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docListType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docListType.subclass: + return docListType.subclass(*args_, **kwargs_) + return docListType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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_at(self, index, value): + self.listitem.insert(index, value) + def replace_listitem_at(self, index, value): + self.listitem[index] = value + def hasContent_(self): + if ( + self.listitem + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docListType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docListType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docListType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docListType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docListType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docListType'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docListType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for listitem_ in self.listitem: + namespaceprefix_ = self.listitem_nsprefix_ + ':' if (UseCapturedNS_ and self.listitem_nsprefix_) else '' + listitem_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='listitem', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'listitem': + obj_ = docListItemType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.listitem.append(obj_) + obj_.original_tagname_ = 'listitem' +# end class docListType + + +class docListItemType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, para=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + if para is None: + self.para = [] + else: + self.para = para + self.para_nsprefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docListItemType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docListItemType.subclass: + return docListItemType.subclass(*args_, **kwargs_) + return docListItemType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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_at(self, index, value): + self.para.insert(index, value) + def replace_para_at(self, index, value): + self.para[index] = value + def hasContent_(self): + if ( + self.para + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docListItemType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docListItemType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docListItemType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docListItemType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docListItemType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docListItemType'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docListItemType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for para_ in self.para: + namespaceprefix_ = self.para_nsprefix_ + ':' if (UseCapturedNS_ and self.para_nsprefix_) else '' + para_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='para', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'para': + obj_ = docParaType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.para.append(obj_) + obj_.original_tagname_ = 'para' +# end class docListItemType + + +class docSimpleSectType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, kind=None, title=None, para=None, simplesectsep=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.kind = _cast(None, kind) + self.kind_nsprefix_ = None + self.title = title + self.title_nsprefix_ = None + if para is None: + self.para = [] + else: + self.para = para + self.para_nsprefix_ = None + if simplesectsep is None: + self.simplesectsep = [] + else: + self.simplesectsep = simplesectsep + self.simplesectsep_nsprefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docSimpleSectType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docSimpleSectType.subclass: + return docSimpleSectType.subclass(*args_, **kwargs_) + return docSimpleSectType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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_at(self, index, value): + self.para.insert(index, value) + def replace_para_at(self, index, value): + self.para[index] = value + def get_simplesectsep(self): + return self.simplesectsep + def set_simplesectsep(self, simplesectsep): + self.simplesectsep = simplesectsep + def add_simplesectsep(self, value): + self.simplesectsep.append(value) + def insert_simplesectsep_at(self, index, value): + self.simplesectsep.insert(index, value) + def replace_simplesectsep_at(self, index, value): + self.simplesectsep[index] = value + def get_kind(self): + return self.kind + def set_kind(self, kind): + self.kind = kind + def validate_DoxSimpleSectKind(self, value): + # Validate type DoxSimpleSectKind, a restriction on xsd:string. + if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) + return False + value = value + enumerations = ['see', 'return', 'author', 'authors', 'version', 'since', 'date', 'note', 'warning', 'pre', 'post', 'copyright', 'invariant', 'remark', 'attention', 'par', 'rcs'] + if value not in enumerations: + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on DoxSimpleSectKind' % {"value" : encode_str_2_3(value), "lineno": lineno} ) + result = False + def hasContent_(self): + if ( + self.title is not None or + self.para or + self.simplesectsep + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docSimpleSectType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docSimpleSectType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docSimpleSectType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docSimpleSectType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docSimpleSectType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docSimpleSectType'): + if self.kind is not None and 'kind' not in already_processed: + already_processed.add('kind') + outfile.write(' kind=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.kind), input_name='kind')), )) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docSimpleSectType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.title is not None: + namespaceprefix_ = self.title_nsprefix_ + ':' if (UseCapturedNS_ and self.title_nsprefix_) else '' + self.title.export(outfile, level, namespaceprefix_, namespacedef_='', name_='title', pretty_print=pretty_print) + for para_ in self.para: + namespaceprefix_ = self.para_nsprefix_ + ':' if (UseCapturedNS_ and self.para_nsprefix_) else '' + para_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='para', pretty_print=pretty_print) + for simplesectsep_ in self.simplesectsep: + namespaceprefix_ = self.simplesectsep_nsprefix_ + ':' if (UseCapturedNS_ and self.simplesectsep_nsprefix_) else '' + simplesectsep_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='simplesectsep', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('kind', node) + if value is not None and 'kind' not in already_processed: + already_processed.add('kind') + self.kind = value + self.validate_DoxSimpleSectKind(self.kind) # validate type DoxSimpleSectKind + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'title': + obj_ = docTitleType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.title = obj_ + obj_.original_tagname_ = 'title' + elif nodeName_ == 'para': + obj_ = docParaType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.para.append(obj_) + obj_.original_tagname_ = 'para' + elif nodeName_ == 'simplesectsep': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.simplesectsep.append(obj_) + obj_.original_tagname_ = 'simplesectsep' +# end class docSimpleSectType + + +class docVarListEntryType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, term=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.term = term + self.term_nsprefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docVarListEntryType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docVarListEntryType.subclass: + return docVarListEntryType.subclass(*args_, **kwargs_) + return docVarListEntryType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + def get_term(self): + return self.term + def set_term(self, term): + self.term = term + def hasContent_(self): + if ( + self.term is not None + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docVarListEntryType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docVarListEntryType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docVarListEntryType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docVarListEntryType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docVarListEntryType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docVarListEntryType'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docVarListEntryType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.term is not None: + namespaceprefix_ = self.term_nsprefix_ + ':' if (UseCapturedNS_ and self.term_nsprefix_) else '' + self.term.export(outfile, level, namespaceprefix_, namespacedef_='', name_='term', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'term': + obj_ = docTitleType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.term = obj_ + obj_.original_tagname_ = 'term' +# end class docVarListEntryType + + +class docVariableListType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, varlistentry=None, listitem=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + if varlistentry is None: + self.varlistentry = [] + else: + self.varlistentry = varlistentry + self.varlistentry_nsprefix_ = None + if listitem is None: + self.listitem = [] + else: + self.listitem = listitem + self.listitem_nsprefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docVariableListType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docVariableListType.subclass: + return docVariableListType.subclass(*args_, **kwargs_) + return docVariableListType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + def get_varlistentry(self): + return self.varlistentry + def set_varlistentry(self, varlistentry): + self.varlistentry = varlistentry + def add_varlistentry(self, value): + self.varlistentry.append(value) + def insert_varlistentry_at(self, index, value): + self.varlistentry.insert(index, value) + def replace_varlistentry_at(self, index, value): + self.varlistentry[index] = value + 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_at(self, index, value): + self.listitem.insert(index, value) + def replace_listitem_at(self, index, value): + self.listitem[index] = value + def hasContent_(self): + if ( + self.varlistentry or + self.listitem + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docVariableListType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docVariableListType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docVariableListType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docVariableListType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docVariableListType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docVariableListType'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docVariableListType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for varlistentry_ in self.varlistentry: + namespaceprefix_ = self.varlistentry_nsprefix_ + ':' if (UseCapturedNS_ and self.varlistentry_nsprefix_) else '' + varlistentry_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='varlistentry', pretty_print=pretty_print) + for listitem_ in self.listitem: + namespaceprefix_ = self.listitem_nsprefix_ + ':' if (UseCapturedNS_ and self.listitem_nsprefix_) else '' + listitem_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='listitem', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'varlistentry': + obj_ = docVarListEntryType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.varlistentry.append(obj_) + obj_.original_tagname_ = 'varlistentry' + elif nodeName_ == 'listitem': + obj_ = docListItemType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.listitem.append(obj_) + obj_.original_tagname_ = 'listitem' +# end class docVariableListType + + +class docRefTextType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, refid=None, kindref=None, external=None, ulink=None, bold=None, emphasis=None, computeroutput=None, subscript=None, superscript=None, center=None, small=None, htmlonly=None, manonly=None, xmlonly=None, rtfonly=None, latexonly=None, dot=None, msc=None, anchor=None, formula=None, ref=None, copy=None, trademark=None, registered=None, lsquo=None, rsquo=None, ldquo=None, rdquo=None, ndash=None, mdash=None, umlaut=None, acute=None, grave=None, circ=None, slash=None, tilde=None, cedil=None, ring=None, szlig=None, nonbreakablespace=None, aelig=None, AElig=None, Gamma=None, Delta=None, Theta=None, Lambda=None, Xi=None, Pi=None, Sigma=None, Upsilon=None, Phi=None, Psi=None, Omega=None, alpha=None, beta=None, gamma=None, delta=None, epsilon=None, zeta=None, eta=None, theta=None, iota=None, kappa=None, lambda_=None, mu=None, nu=None, xi=None, pi=None, rho=None, sigma=None, tau=None, upsilon=None, phi=None, chi=None, psi=None, omega=None, sigmaf=None, sect=None, deg=None, prime=None, Prime=None, infin=None, empty=None, plusmn=None, times=None, minus=None, sdot=None, part=None, nabla=None, radic=None, perp=None, sum=None, int=None, prod=None, sim=None, asymp=None, ne=None, equiv=None, prop=None, le=None, ge=None, larr=None, rarr=None, isin=None, notin=None, lceil=None, rceil=None, lfloor=None, rfloor=None, valueOf_=None, mixedclass_=None, content_=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.refid = _cast(None, refid) + self.refid_nsprefix_ = None + self.kindref = _cast(None, kindref) + self.kindref_nsprefix_ = None + self.external = _cast(None, external) + self.external_nsprefix_ = None + if ulink is None: + self.ulink = [] + else: + self.ulink = ulink + self.ulink_nsprefix_ = None + if bold is None: + self.bold = [] + else: + self.bold = bold + self.bold_nsprefix_ = None + if emphasis is None: + self.emphasis = [] + else: + self.emphasis = emphasis + self.emphasis_nsprefix_ = None + if computeroutput is None: + self.computeroutput = [] + else: + self.computeroutput = computeroutput + self.computeroutput_nsprefix_ = None + if subscript is None: + self.subscript = [] + else: + self.subscript = subscript + self.subscript_nsprefix_ = None + if superscript is None: + self.superscript = [] + else: + self.superscript = superscript + self.superscript_nsprefix_ = None + if center is None: + self.center = [] + else: + self.center = center + self.center_nsprefix_ = None + if small is None: + self.small = [] + else: + self.small = small + self.small_nsprefix_ = None + if htmlonly is None: + self.htmlonly = [] + else: + self.htmlonly = htmlonly + self.htmlonly_nsprefix_ = None + if manonly is None: + self.manonly = [] + else: + self.manonly = manonly + self.manonly_nsprefix_ = None + if xmlonly is None: + self.xmlonly = [] + else: + self.xmlonly = xmlonly + self.xmlonly_nsprefix_ = None + if rtfonly is None: + self.rtfonly = [] + else: + self.rtfonly = rtfonly + self.rtfonly_nsprefix_ = None + if latexonly is None: + self.latexonly = [] + else: + self.latexonly = latexonly + self.latexonly_nsprefix_ = None + if dot is None: + self.dot = [] + else: + self.dot = dot + self.dot_nsprefix_ = None + if msc is None: + self.msc = [] + else: + self.msc = msc + self.msc_nsprefix_ = None + if anchor is None: + self.anchor = [] + else: + self.anchor = anchor + self.anchor_nsprefix_ = None + if formula is None: + self.formula = [] + else: + self.formula = formula + self.formula_nsprefix_ = None + if ref is None: + self.ref = [] + else: + self.ref = ref + self.ref_nsprefix_ = None + if copy is None: + self.copy = [] + else: + self.copy = copy + self.copy_nsprefix_ = None + if trademark is None: + self.trademark = [] + else: + self.trademark = trademark + self.trademark_nsprefix_ = None + if registered is None: + self.registered = [] + else: + self.registered = registered + self.registered_nsprefix_ = None + if lsquo is None: + self.lsquo = [] + else: + self.lsquo = lsquo + self.lsquo_nsprefix_ = None + if rsquo is None: + self.rsquo = [] + else: + self.rsquo = rsquo + self.rsquo_nsprefix_ = None + if ldquo is None: + self.ldquo = [] + else: + self.ldquo = ldquo + self.ldquo_nsprefix_ = None + if rdquo is None: + self.rdquo = [] + else: + self.rdquo = rdquo + self.rdquo_nsprefix_ = None + if ndash is None: + self.ndash = [] + else: + self.ndash = ndash + self.ndash_nsprefix_ = None + if mdash is None: + self.mdash = [] + else: + self.mdash = mdash + self.mdash_nsprefix_ = None + if umlaut is None: + self.umlaut = [] + else: + self.umlaut = umlaut + self.umlaut_nsprefix_ = None + if acute is None: + self.acute = [] + else: + self.acute = acute + self.acute_nsprefix_ = None + if grave is None: + self.grave = [] + else: + self.grave = grave + self.grave_nsprefix_ = None + if circ is None: + self.circ = [] + else: + self.circ = circ + self.circ_nsprefix_ = None + if slash is None: + self.slash = [] + else: + self.slash = slash + self.slash_nsprefix_ = None + if tilde is None: + self.tilde = [] + else: + self.tilde = tilde + self.tilde_nsprefix_ = None + if cedil is None: + self.cedil = [] + else: + self.cedil = cedil + self.cedil_nsprefix_ = None + if ring is None: + self.ring = [] + else: + self.ring = ring + self.ring_nsprefix_ = None + if szlig is None: + self.szlig = [] + else: + self.szlig = szlig + self.szlig_nsprefix_ = None + if nonbreakablespace is None: + self.nonbreakablespace = [] + else: + self.nonbreakablespace = nonbreakablespace + self.nonbreakablespace_nsprefix_ = None + if aelig is None: + self.aelig = [] + else: + self.aelig = aelig + self.aelig_nsprefix_ = None + if AElig is None: + self.AElig = [] + else: + self.AElig = AElig + self.AElig_nsprefix_ = None + if Gamma is None: + self.Gamma = [] + else: + self.Gamma = Gamma + self.Gamma_nsprefix_ = None + if Delta is None: + self.Delta = [] + else: + self.Delta = Delta + self.Delta_nsprefix_ = None + if Theta is None: + self.Theta = [] + else: + self.Theta = Theta + self.Theta_nsprefix_ = None + if Lambda is None: + self.Lambda = [] + else: + self.Lambda = Lambda + self.Lambda_nsprefix_ = None + if Xi is None: + self.Xi = [] + else: + self.Xi = Xi + self.Xi_nsprefix_ = None + if Pi is None: + self.Pi = [] + else: + self.Pi = Pi + self.Pi_nsprefix_ = None + if Sigma is None: + self.Sigma = [] + else: + self.Sigma = Sigma + self.Sigma_nsprefix_ = None + if Upsilon is None: + self.Upsilon = [] + else: + self.Upsilon = Upsilon + self.Upsilon_nsprefix_ = None + if Phi is None: + self.Phi = [] + else: + self.Phi = Phi + self.Phi_nsprefix_ = None + if Psi is None: + self.Psi = [] + else: + self.Psi = Psi + self.Psi_nsprefix_ = None + if Omega is None: + self.Omega = [] + else: + self.Omega = Omega + self.Omega_nsprefix_ = None + if alpha is None: + self.alpha = [] + else: + self.alpha = alpha + self.alpha_nsprefix_ = None + if beta is None: + self.beta = [] + else: + self.beta = beta + self.beta_nsprefix_ = None + if gamma is None: + self.gamma = [] + else: + self.gamma = gamma + self.gamma_nsprefix_ = None + if delta is None: + self.delta = [] + else: + self.delta = delta + self.delta_nsprefix_ = None + if epsilon is None: + self.epsilon = [] + else: + self.epsilon = epsilon + self.epsilon_nsprefix_ = None + if zeta is None: + self.zeta = [] + else: + self.zeta = zeta + self.zeta_nsprefix_ = None + if eta is None: + self.eta = [] + else: + self.eta = eta + self.eta_nsprefix_ = None + if theta is None: + self.theta = [] + else: + self.theta = theta + self.theta_nsprefix_ = None + if iota is None: + self.iota = [] + else: + self.iota = iota + self.iota_nsprefix_ = None + if kappa is None: + self.kappa = [] + else: + self.kappa = kappa + self.kappa_nsprefix_ = None + if lambda_ is None: + self.lambda_ = [] + else: + self.lambda_ = lambda_ + self.lambda__nsprefix_ = None + if mu is None: + self.mu = [] + else: + self.mu = mu + self.mu_nsprefix_ = None + if nu is None: + self.nu = [] + else: + self.nu = nu + self.nu_nsprefix_ = None + if xi is None: + self.xi = [] + else: + self.xi = xi + self.xi_nsprefix_ = None + if pi is None: + self.pi = [] + else: + self.pi = pi + self.pi_nsprefix_ = None + if rho is None: + self.rho = [] + else: + self.rho = rho + self.rho_nsprefix_ = None + if sigma is None: + self.sigma = [] + else: + self.sigma = sigma + self.sigma_nsprefix_ = None + if tau is None: + self.tau = [] + else: + self.tau = tau + self.tau_nsprefix_ = None + if upsilon is None: + self.upsilon = [] + else: + self.upsilon = upsilon + self.upsilon_nsprefix_ = None + if phi is None: + self.phi = [] + else: + self.phi = phi + self.phi_nsprefix_ = None + if chi is None: + self.chi = [] + else: + self.chi = chi + self.chi_nsprefix_ = None + if psi is None: + self.psi = [] + else: + self.psi = psi + self.psi_nsprefix_ = None + if omega is None: + self.omega = [] + else: + self.omega = omega + self.omega_nsprefix_ = None + if sigmaf is None: + self.sigmaf = [] + else: + self.sigmaf = sigmaf + self.sigmaf_nsprefix_ = None + if sect is None: + self.sect = [] + else: + self.sect = sect + self.sect_nsprefix_ = None + if deg is None: + self.deg = [] + else: + self.deg = deg + self.deg_nsprefix_ = None + if prime is None: + self.prime = [] + else: + self.prime = prime + self.prime_nsprefix_ = None + if Prime is None: + self.Prime = [] + else: + self.Prime = Prime + self.Prime_nsprefix_ = None + if infin is None: + self.infin = [] + else: + self.infin = infin + self.infin_nsprefix_ = None + if empty is None: + self.empty = [] + else: + self.empty = empty + self.empty_nsprefix_ = None + if plusmn is None: + self.plusmn = [] + else: + self.plusmn = plusmn + self.plusmn_nsprefix_ = None + if times is None: + self.times = [] + else: + self.times = times + self.times_nsprefix_ = None + if minus is None: + self.minus = [] + else: + self.minus = minus + self.minus_nsprefix_ = None + if sdot is None: + self.sdot = [] + else: + self.sdot = sdot + self.sdot_nsprefix_ = None + if part is None: + self.part = [] + else: + self.part = part + self.part_nsprefix_ = None + if nabla is None: + self.nabla = [] + else: + self.nabla = nabla + self.nabla_nsprefix_ = None + if radic is None: + self.radic = [] + else: + self.radic = radic + self.radic_nsprefix_ = None + if perp is None: + self.perp = [] + else: + self.perp = perp + self.perp_nsprefix_ = None + if sum is None: + self.sum = [] + else: + self.sum = sum + self.sum_nsprefix_ = None + if int is None: + self.int = [] + else: + self.int = int + self.int_nsprefix_ = None + if prod is None: + self.prod = [] + else: + self.prod = prod + self.prod_nsprefix_ = None + if sim is None: + self.sim = [] + else: + self.sim = sim + self.sim_nsprefix_ = None + if asymp is None: + self.asymp = [] + else: + self.asymp = asymp + self.asymp_nsprefix_ = None + if ne is None: + self.ne = [] + else: + self.ne = ne + self.ne_nsprefix_ = None + if equiv is None: + self.equiv = [] + else: + self.equiv = equiv + self.equiv_nsprefix_ = None + if prop is None: + self.prop = [] + else: + self.prop = prop + self.prop_nsprefix_ = None + if le is None: + self.le = [] + else: + self.le = le + self.le_nsprefix_ = None + if ge is None: + self.ge = [] + else: + self.ge = ge + self.ge_nsprefix_ = None + if larr is None: + self.larr = [] + else: + self.larr = larr + self.larr_nsprefix_ = None + if rarr is None: + self.rarr = [] + else: + self.rarr = rarr + self.rarr_nsprefix_ = None + if isin is None: + self.isin = [] + else: + self.isin = isin + self.isin_nsprefix_ = None + if notin is None: + self.notin = [] + else: + self.notin = notin + self.notin_nsprefix_ = None + if lceil is None: + self.lceil = [] + else: + self.lceil = lceil + self.lceil_nsprefix_ = None + if rceil is None: + self.rceil = [] + else: + self.rceil = rceil + self.rceil_nsprefix_ = None + if lfloor is None: + self.lfloor = [] + else: + self.lfloor = lfloor + self.lfloor_nsprefix_ = None + if rfloor is None: + self.rfloor = [] + else: + self.rfloor = rfloor + self.rfloor_nsprefix_ = None + self.valueOf_ = valueOf_ + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + self.valueOf_ = valueOf_ + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docRefTextType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docRefTextType.subclass: + return docRefTextType.subclass(*args_, **kwargs_) + return docRefTextType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + def get_ulink(self): + return self.ulink + def set_ulink(self, ulink): + self.ulink = ulink + def add_ulink(self, value): + self.ulink.append(value) + def insert_ulink_at(self, index, value): + self.ulink.insert(index, value) + def replace_ulink_at(self, index, value): + self.ulink[index] = value + def get_bold(self): + return self.bold + def set_bold(self, bold): + self.bold = bold + def add_bold(self, value): + self.bold.append(value) + def insert_bold_at(self, index, value): + self.bold.insert(index, value) + def replace_bold_at(self, index, value): + self.bold[index] = value + def get_emphasis(self): + return self.emphasis + def set_emphasis(self, emphasis): + self.emphasis = emphasis + def add_emphasis(self, value): + self.emphasis.append(value) + def insert_emphasis_at(self, index, value): + self.emphasis.insert(index, value) + def replace_emphasis_at(self, index, value): + self.emphasis[index] = value + def get_computeroutput(self): + return self.computeroutput + def set_computeroutput(self, computeroutput): + self.computeroutput = computeroutput + def add_computeroutput(self, value): + self.computeroutput.append(value) + def insert_computeroutput_at(self, index, value): + self.computeroutput.insert(index, value) + def replace_computeroutput_at(self, index, value): + self.computeroutput[index] = value + def get_subscript(self): + return self.subscript + def set_subscript(self, subscript): + self.subscript = subscript + def add_subscript(self, value): + self.subscript.append(value) + def insert_subscript_at(self, index, value): + self.subscript.insert(index, value) + def replace_subscript_at(self, index, value): + self.subscript[index] = value + def get_superscript(self): + return self.superscript + def set_superscript(self, superscript): + self.superscript = superscript + def add_superscript(self, value): + self.superscript.append(value) + def insert_superscript_at(self, index, value): + self.superscript.insert(index, value) + def replace_superscript_at(self, index, value): + self.superscript[index] = value + def get_center(self): + return self.center + def set_center(self, center): + self.center = center + def add_center(self, value): + self.center.append(value) + def insert_center_at(self, index, value): + self.center.insert(index, value) + def replace_center_at(self, index, value): + self.center[index] = value + def get_small(self): + return self.small + def set_small(self, small): + self.small = small + def add_small(self, value): + self.small.append(value) + def insert_small_at(self, index, value): + self.small.insert(index, value) + def replace_small_at(self, index, value): + self.small[index] = value + def get_htmlonly(self): + return self.htmlonly + def set_htmlonly(self, htmlonly): + self.htmlonly = htmlonly + def add_htmlonly(self, value): + self.htmlonly.append(value) + def insert_htmlonly_at(self, index, value): + self.htmlonly.insert(index, value) + def replace_htmlonly_at(self, index, value): + self.htmlonly[index] = value + def get_manonly(self): + return self.manonly + def set_manonly(self, manonly): + self.manonly = manonly + def add_manonly(self, value): + self.manonly.append(value) + def insert_manonly_at(self, index, value): + self.manonly.insert(index, value) + def replace_manonly_at(self, index, value): + self.manonly[index] = value + def get_xmlonly(self): + return self.xmlonly + def set_xmlonly(self, xmlonly): + self.xmlonly = xmlonly + def add_xmlonly(self, value): + self.xmlonly.append(value) + def insert_xmlonly_at(self, index, value): + self.xmlonly.insert(index, value) + def replace_xmlonly_at(self, index, value): + self.xmlonly[index] = value + def get_rtfonly(self): + return self.rtfonly + def set_rtfonly(self, rtfonly): + self.rtfonly = rtfonly + def add_rtfonly(self, value): + self.rtfonly.append(value) + def insert_rtfonly_at(self, index, value): + self.rtfonly.insert(index, value) + def replace_rtfonly_at(self, index, value): + self.rtfonly[index] = value + def get_latexonly(self): + return self.latexonly + def set_latexonly(self, latexonly): + self.latexonly = latexonly + def add_latexonly(self, value): + self.latexonly.append(value) + def insert_latexonly_at(self, index, value): + self.latexonly.insert(index, value) + def replace_latexonly_at(self, index, value): + self.latexonly[index] = value + def get_dot(self): + return self.dot + def set_dot(self, dot): + self.dot = dot + def add_dot(self, value): + self.dot.append(value) + def insert_dot_at(self, index, value): + self.dot.insert(index, value) + def replace_dot_at(self, index, value): + self.dot[index] = value + def get_msc(self): + return self.msc + def set_msc(self, msc): + self.msc = msc + def add_msc(self, value): + self.msc.append(value) + def insert_msc_at(self, index, value): + self.msc.insert(index, value) + def replace_msc_at(self, index, value): + self.msc[index] = value + def get_anchor(self): + return self.anchor + def set_anchor(self, anchor): + self.anchor = anchor + def add_anchor(self, value): + self.anchor.append(value) + def insert_anchor_at(self, index, value): + self.anchor.insert(index, value) + def replace_anchor_at(self, index, value): + self.anchor[index] = value + def get_formula(self): + return self.formula + def set_formula(self, formula): + self.formula = formula + def add_formula(self, value): + self.formula.append(value) + def insert_formula_at(self, index, value): + self.formula.insert(index, value) + def replace_formula_at(self, index, value): + self.formula[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_at(self, index, value): + self.ref.insert(index, value) + def replace_ref_at(self, index, value): + self.ref[index] = value + def get_copy(self): + return self.copy + def set_copy(self, copy): + self.copy = copy + def add_copy(self, value): + self.copy.append(value) + def insert_copy_at(self, index, value): + self.copy.insert(index, value) + def replace_copy_at(self, index, value): + self.copy[index] = value + def get_trademark(self): + return self.trademark + def set_trademark(self, trademark): + self.trademark = trademark + def add_trademark(self, value): + self.trademark.append(value) + def insert_trademark_at(self, index, value): + self.trademark.insert(index, value) + def replace_trademark_at(self, index, value): + self.trademark[index] = value + def get_registered(self): + return self.registered + def set_registered(self, registered): + self.registered = registered + def add_registered(self, value): + self.registered.append(value) + def insert_registered_at(self, index, value): + self.registered.insert(index, value) + def replace_registered_at(self, index, value): + self.registered[index] = value + def get_lsquo(self): + return self.lsquo + def set_lsquo(self, lsquo): + self.lsquo = lsquo + def add_lsquo(self, value): + self.lsquo.append(value) + def insert_lsquo_at(self, index, value): + self.lsquo.insert(index, value) + def replace_lsquo_at(self, index, value): + self.lsquo[index] = value + def get_rsquo(self): + return self.rsquo + def set_rsquo(self, rsquo): + self.rsquo = rsquo + def add_rsquo(self, value): + self.rsquo.append(value) + def insert_rsquo_at(self, index, value): + self.rsquo.insert(index, value) + def replace_rsquo_at(self, index, value): + self.rsquo[index] = value + def get_ldquo(self): + return self.ldquo + def set_ldquo(self, ldquo): + self.ldquo = ldquo + def add_ldquo(self, value): + self.ldquo.append(value) + def insert_ldquo_at(self, index, value): + self.ldquo.insert(index, value) + def replace_ldquo_at(self, index, value): + self.ldquo[index] = value + def get_rdquo(self): + return self.rdquo + def set_rdquo(self, rdquo): + self.rdquo = rdquo + def add_rdquo(self, value): + self.rdquo.append(value) + def insert_rdquo_at(self, index, value): + self.rdquo.insert(index, value) + def replace_rdquo_at(self, index, value): + self.rdquo[index] = value + def get_ndash(self): + return self.ndash + def set_ndash(self, ndash): + self.ndash = ndash + def add_ndash(self, value): + self.ndash.append(value) + def insert_ndash_at(self, index, value): + self.ndash.insert(index, value) + def replace_ndash_at(self, index, value): + self.ndash[index] = value + def get_mdash(self): + return self.mdash + def set_mdash(self, mdash): + self.mdash = mdash + def add_mdash(self, value): + self.mdash.append(value) + def insert_mdash_at(self, index, value): + self.mdash.insert(index, value) + def replace_mdash_at(self, index, value): + self.mdash[index] = value + def get_umlaut(self): + return self.umlaut + def set_umlaut(self, umlaut): + self.umlaut = umlaut + def add_umlaut(self, value): + self.umlaut.append(value) + def insert_umlaut_at(self, index, value): + self.umlaut.insert(index, value) + def replace_umlaut_at(self, index, value): + self.umlaut[index] = value + def get_acute(self): + return self.acute + def set_acute(self, acute): + self.acute = acute + def add_acute(self, value): + self.acute.append(value) + def insert_acute_at(self, index, value): + self.acute.insert(index, value) + def replace_acute_at(self, index, value): + self.acute[index] = value + def get_grave(self): + return self.grave + def set_grave(self, grave): + self.grave = grave + def add_grave(self, value): + self.grave.append(value) + def insert_grave_at(self, index, value): + self.grave.insert(index, value) + def replace_grave_at(self, index, value): + self.grave[index] = value + def get_circ(self): + return self.circ + def set_circ(self, circ): + self.circ = circ + def add_circ(self, value): + self.circ.append(value) + def insert_circ_at(self, index, value): + self.circ.insert(index, value) + def replace_circ_at(self, index, value): + self.circ[index] = value + def get_slash(self): + return self.slash + def set_slash(self, slash): + self.slash = slash + def add_slash(self, value): + self.slash.append(value) + def insert_slash_at(self, index, value): + self.slash.insert(index, value) + def replace_slash_at(self, index, value): + self.slash[index] = value + def get_tilde(self): + return self.tilde + def set_tilde(self, tilde): + self.tilde = tilde + def add_tilde(self, value): + self.tilde.append(value) + def insert_tilde_at(self, index, value): + self.tilde.insert(index, value) + def replace_tilde_at(self, index, value): + self.tilde[index] = value + def get_cedil(self): + return self.cedil + def set_cedil(self, cedil): + self.cedil = cedil + def add_cedil(self, value): + self.cedil.append(value) + def insert_cedil_at(self, index, value): + self.cedil.insert(index, value) + def replace_cedil_at(self, index, value): + self.cedil[index] = value + def get_ring(self): + return self.ring + def set_ring(self, ring): + self.ring = ring + def add_ring(self, value): + self.ring.append(value) + def insert_ring_at(self, index, value): + self.ring.insert(index, value) + def replace_ring_at(self, index, value): + self.ring[index] = value + def get_szlig(self): + return self.szlig + def set_szlig(self, szlig): + self.szlig = szlig + def add_szlig(self, value): + self.szlig.append(value) + def insert_szlig_at(self, index, value): + self.szlig.insert(index, value) + def replace_szlig_at(self, index, value): + self.szlig[index] = value + def get_nonbreakablespace(self): + return self.nonbreakablespace + def set_nonbreakablespace(self, nonbreakablespace): + self.nonbreakablespace = nonbreakablespace + def add_nonbreakablespace(self, value): + self.nonbreakablespace.append(value) + def insert_nonbreakablespace_at(self, index, value): + self.nonbreakablespace.insert(index, value) + def replace_nonbreakablespace_at(self, index, value): + self.nonbreakablespace[index] = value + def get_aelig(self): + return self.aelig + def set_aelig(self, aelig): + self.aelig = aelig + def add_aelig(self, value): + self.aelig.append(value) + def insert_aelig_at(self, index, value): + self.aelig.insert(index, value) + def replace_aelig_at(self, index, value): + self.aelig[index] = value + def get_AElig(self): + return self.AElig + def set_AElig(self, AElig): + self.AElig = AElig + def add_AElig(self, value): + self.AElig.append(value) + def insert_AElig_at(self, index, value): + self.AElig.insert(index, value) + def replace_AElig_at(self, index, value): + self.AElig[index] = value + def get_Gamma(self): + return self.Gamma + def set_Gamma(self, Gamma): + self.Gamma = Gamma + def add_Gamma(self, value): + self.Gamma.append(value) + def insert_Gamma_at(self, index, value): + self.Gamma.insert(index, value) + def replace_Gamma_at(self, index, value): + self.Gamma[index] = value + def get_Delta(self): + return self.Delta + def set_Delta(self, Delta): + self.Delta = Delta + def add_Delta(self, value): + self.Delta.append(value) + def insert_Delta_at(self, index, value): + self.Delta.insert(index, value) + def replace_Delta_at(self, index, value): + self.Delta[index] = value + def get_Theta(self): + return self.Theta + def set_Theta(self, Theta): + self.Theta = Theta + def add_Theta(self, value): + self.Theta.append(value) + def insert_Theta_at(self, index, value): + self.Theta.insert(index, value) + def replace_Theta_at(self, index, value): + self.Theta[index] = value + def get_Lambda(self): + return self.Lambda + def set_Lambda(self, Lambda): + self.Lambda = Lambda + def add_Lambda(self, value): + self.Lambda.append(value) + def insert_Lambda_at(self, index, value): + self.Lambda.insert(index, value) + def replace_Lambda_at(self, index, value): + self.Lambda[index] = value + def get_Xi(self): + return self.Xi + def set_Xi(self, Xi): + self.Xi = Xi + def add_Xi(self, value): + self.Xi.append(value) + def insert_Xi_at(self, index, value): + self.Xi.insert(index, value) + def replace_Xi_at(self, index, value): + self.Xi[index] = value + def get_Pi(self): + return self.Pi + def set_Pi(self, Pi): + self.Pi = Pi + def add_Pi(self, value): + self.Pi.append(value) + def insert_Pi_at(self, index, value): + self.Pi.insert(index, value) + def replace_Pi_at(self, index, value): + self.Pi[index] = value + def get_Sigma(self): + return self.Sigma + def set_Sigma(self, Sigma): + self.Sigma = Sigma + def add_Sigma(self, value): + self.Sigma.append(value) + def insert_Sigma_at(self, index, value): + self.Sigma.insert(index, value) + def replace_Sigma_at(self, index, value): + self.Sigma[index] = value + def get_Upsilon(self): + return self.Upsilon + def set_Upsilon(self, Upsilon): + self.Upsilon = Upsilon + def add_Upsilon(self, value): + self.Upsilon.append(value) + def insert_Upsilon_at(self, index, value): + self.Upsilon.insert(index, value) + def replace_Upsilon_at(self, index, value): + self.Upsilon[index] = value + def get_Phi(self): + return self.Phi + def set_Phi(self, Phi): + self.Phi = Phi + def add_Phi(self, value): + self.Phi.append(value) + def insert_Phi_at(self, index, value): + self.Phi.insert(index, value) + def replace_Phi_at(self, index, value): + self.Phi[index] = value + def get_Psi(self): + return self.Psi + def set_Psi(self, Psi): + self.Psi = Psi + def add_Psi(self, value): + self.Psi.append(value) + def insert_Psi_at(self, index, value): + self.Psi.insert(index, value) + def replace_Psi_at(self, index, value): + self.Psi[index] = value + def get_Omega(self): + return self.Omega + def set_Omega(self, Omega): + self.Omega = Omega + def add_Omega(self, value): + self.Omega.append(value) + def insert_Omega_at(self, index, value): + self.Omega.insert(index, value) + def replace_Omega_at(self, index, value): + self.Omega[index] = value + def get_alpha(self): + return self.alpha + def set_alpha(self, alpha): + self.alpha = alpha + def add_alpha(self, value): + self.alpha.append(value) + def insert_alpha_at(self, index, value): + self.alpha.insert(index, value) + def replace_alpha_at(self, index, value): + self.alpha[index] = value + def get_beta(self): + return self.beta + def set_beta(self, beta): + self.beta = beta + def add_beta(self, value): + self.beta.append(value) + def insert_beta_at(self, index, value): + self.beta.insert(index, value) + def replace_beta_at(self, index, value): + self.beta[index] = value + def get_gamma(self): + return self.gamma + def set_gamma(self, gamma): + self.gamma = gamma + def add_gamma(self, value): + self.gamma.append(value) + def insert_gamma_at(self, index, value): + self.gamma.insert(index, value) + def replace_gamma_at(self, index, value): + self.gamma[index] = value + def get_delta(self): + return self.delta + def set_delta(self, delta): + self.delta = delta + def add_delta(self, value): + self.delta.append(value) + def insert_delta_at(self, index, value): + self.delta.insert(index, value) + def replace_delta_at(self, index, value): + self.delta[index] = value + def get_epsilon(self): + return self.epsilon + def set_epsilon(self, epsilon): + self.epsilon = epsilon + def add_epsilon(self, value): + self.epsilon.append(value) + def insert_epsilon_at(self, index, value): + self.epsilon.insert(index, value) + def replace_epsilon_at(self, index, value): + self.epsilon[index] = value + def get_zeta(self): + return self.zeta + def set_zeta(self, zeta): + self.zeta = zeta + def add_zeta(self, value): + self.zeta.append(value) + def insert_zeta_at(self, index, value): + self.zeta.insert(index, value) + def replace_zeta_at(self, index, value): + self.zeta[index] = value + def get_eta(self): + return self.eta + def set_eta(self, eta): + self.eta = eta + def add_eta(self, value): + self.eta.append(value) + def insert_eta_at(self, index, value): + self.eta.insert(index, value) + def replace_eta_at(self, index, value): + self.eta[index] = value + def get_theta(self): + return self.theta + def set_theta(self, theta): + self.theta = theta + def add_theta(self, value): + self.theta.append(value) + def insert_theta_at(self, index, value): + self.theta.insert(index, value) + def replace_theta_at(self, index, value): + self.theta[index] = value + def get_iota(self): + return self.iota + def set_iota(self, iota): + self.iota = iota + def add_iota(self, value): + self.iota.append(value) + def insert_iota_at(self, index, value): + self.iota.insert(index, value) + def replace_iota_at(self, index, value): + self.iota[index] = value + def get_kappa(self): + return self.kappa + def set_kappa(self, kappa): + self.kappa = kappa + def add_kappa(self, value): + self.kappa.append(value) + def insert_kappa_at(self, index, value): + self.kappa.insert(index, value) + def replace_kappa_at(self, index, value): + self.kappa[index] = value + def get_lambda(self): + return self.lambda_ + def set_lambda(self, lambda_): + self.lambda_ = lambda_ + def add_lambda(self, value): + self.lambda_.append(value) + def insert_lambda_at(self, index, value): + self.lambda_.insert(index, value) + def replace_lambda_at(self, index, value): + self.lambda_[index] = value + def get_mu(self): + return self.mu + def set_mu(self, mu): + self.mu = mu + def add_mu(self, value): + self.mu.append(value) + def insert_mu_at(self, index, value): + self.mu.insert(index, value) + def replace_mu_at(self, index, value): + self.mu[index] = value + def get_nu(self): + return self.nu + def set_nu(self, nu): + self.nu = nu + def add_nu(self, value): + self.nu.append(value) + def insert_nu_at(self, index, value): + self.nu.insert(index, value) + def replace_nu_at(self, index, value): + self.nu[index] = value + def get_xi(self): + return self.xi + def set_xi(self, xi): + self.xi = xi + def add_xi(self, value): + self.xi.append(value) + def insert_xi_at(self, index, value): + self.xi.insert(index, value) + def replace_xi_at(self, index, value): + self.xi[index] = value + def get_pi(self): + return self.pi + def set_pi(self, pi): + self.pi = pi + def add_pi(self, value): + self.pi.append(value) + def insert_pi_at(self, index, value): + self.pi.insert(index, value) + def replace_pi_at(self, index, value): + self.pi[index] = value + def get_rho(self): + return self.rho + def set_rho(self, rho): + self.rho = rho + def add_rho(self, value): + self.rho.append(value) + def insert_rho_at(self, index, value): + self.rho.insert(index, value) + def replace_rho_at(self, index, value): + self.rho[index] = value + def get_sigma(self): + return self.sigma + def set_sigma(self, sigma): + self.sigma = sigma + def add_sigma(self, value): + self.sigma.append(value) + def insert_sigma_at(self, index, value): + self.sigma.insert(index, value) + def replace_sigma_at(self, index, value): + self.sigma[index] = value + def get_tau(self): + return self.tau + def set_tau(self, tau): + self.tau = tau + def add_tau(self, value): + self.tau.append(value) + def insert_tau_at(self, index, value): + self.tau.insert(index, value) + def replace_tau_at(self, index, value): + self.tau[index] = value + def get_upsilon(self): + return self.upsilon + def set_upsilon(self, upsilon): + self.upsilon = upsilon + def add_upsilon(self, value): + self.upsilon.append(value) + def insert_upsilon_at(self, index, value): + self.upsilon.insert(index, value) + def replace_upsilon_at(self, index, value): + self.upsilon[index] = value + def get_phi(self): + return self.phi + def set_phi(self, phi): + self.phi = phi + def add_phi(self, value): + self.phi.append(value) + def insert_phi_at(self, index, value): + self.phi.insert(index, value) + def replace_phi_at(self, index, value): + self.phi[index] = value + def get_chi(self): + return self.chi + def set_chi(self, chi): + self.chi = chi + def add_chi(self, value): + self.chi.append(value) + def insert_chi_at(self, index, value): + self.chi.insert(index, value) + def replace_chi_at(self, index, value): + self.chi[index] = value + def get_psi(self): + return self.psi + def set_psi(self, psi): + self.psi = psi + def add_psi(self, value): + self.psi.append(value) + def insert_psi_at(self, index, value): + self.psi.insert(index, value) + def replace_psi_at(self, index, value): + self.psi[index] = value + def get_omega(self): + return self.omega + def set_omega(self, omega): + self.omega = omega + def add_omega(self, value): + self.omega.append(value) + def insert_omega_at(self, index, value): + self.omega.insert(index, value) + def replace_omega_at(self, index, value): + self.omega[index] = value + def get_sigmaf(self): + return self.sigmaf + def set_sigmaf(self, sigmaf): + self.sigmaf = sigmaf + def add_sigmaf(self, value): + self.sigmaf.append(value) + def insert_sigmaf_at(self, index, value): + self.sigmaf.insert(index, value) + def replace_sigmaf_at(self, index, value): + self.sigmaf[index] = value + def get_sect(self): + return self.sect + def set_sect(self, sect): + self.sect = sect + def add_sect(self, value): + self.sect.append(value) + def insert_sect_at(self, index, value): + self.sect.insert(index, value) + def replace_sect_at(self, index, value): + self.sect[index] = value + def get_deg(self): + return self.deg + def set_deg(self, deg): + self.deg = deg + def add_deg(self, value): + self.deg.append(value) + def insert_deg_at(self, index, value): + self.deg.insert(index, value) + def replace_deg_at(self, index, value): + self.deg[index] = value + def get_prime(self): + return self.prime + def set_prime(self, prime): + self.prime = prime + def add_prime(self, value): + self.prime.append(value) + def insert_prime_at(self, index, value): + self.prime.insert(index, value) + def replace_prime_at(self, index, value): + self.prime[index] = value + def get_Prime(self): + return self.Prime + def set_Prime(self, Prime): + self.Prime = Prime + def add_Prime(self, value): + self.Prime.append(value) + def insert_Prime_at(self, index, value): + self.Prime.insert(index, value) + def replace_Prime_at(self, index, value): + self.Prime[index] = value + def get_infin(self): + return self.infin + def set_infin(self, infin): + self.infin = infin + def add_infin(self, value): + self.infin.append(value) + def insert_infin_at(self, index, value): + self.infin.insert(index, value) + def replace_infin_at(self, index, value): + self.infin[index] = value + def get_empty(self): + return self.empty + def set_empty(self, empty): + self.empty = empty + def add_empty(self, value): + self.empty.append(value) + def insert_empty_at(self, index, value): + self.empty.insert(index, value) + def replace_empty_at(self, index, value): + self.empty[index] = value + def get_plusmn(self): + return self.plusmn + def set_plusmn(self, plusmn): + self.plusmn = plusmn + def add_plusmn(self, value): + self.plusmn.append(value) + def insert_plusmn_at(self, index, value): + self.plusmn.insert(index, value) + def replace_plusmn_at(self, index, value): + self.plusmn[index] = value + def get_times(self): + return self.times + def set_times(self, times): + self.times = times + def add_times(self, value): + self.times.append(value) + def insert_times_at(self, index, value): + self.times.insert(index, value) + def replace_times_at(self, index, value): + self.times[index] = value + def get_minus(self): + return self.minus + def set_minus(self, minus): + self.minus = minus + def add_minus(self, value): + self.minus.append(value) + def insert_minus_at(self, index, value): + self.minus.insert(index, value) + def replace_minus_at(self, index, value): + self.minus[index] = value + def get_sdot(self): + return self.sdot + def set_sdot(self, sdot): + self.sdot = sdot + def add_sdot(self, value): + self.sdot.append(value) + def insert_sdot_at(self, index, value): + self.sdot.insert(index, value) + def replace_sdot_at(self, index, value): + self.sdot[index] = value + def get_part(self): + return self.part + def set_part(self, part): + self.part = part + def add_part(self, value): + self.part.append(value) + def insert_part_at(self, index, value): + self.part.insert(index, value) + def replace_part_at(self, index, value): + self.part[index] = value + def get_nabla(self): + return self.nabla + def set_nabla(self, nabla): + self.nabla = nabla + def add_nabla(self, value): + self.nabla.append(value) + def insert_nabla_at(self, index, value): + self.nabla.insert(index, value) + def replace_nabla_at(self, index, value): + self.nabla[index] = value + def get_radic(self): + return self.radic + def set_radic(self, radic): + self.radic = radic + def add_radic(self, value): + self.radic.append(value) + def insert_radic_at(self, index, value): + self.radic.insert(index, value) + def replace_radic_at(self, index, value): + self.radic[index] = value + def get_perp(self): + return self.perp + def set_perp(self, perp): + self.perp = perp + def add_perp(self, value): + self.perp.append(value) + def insert_perp_at(self, index, value): + self.perp.insert(index, value) + def replace_perp_at(self, index, value): + self.perp[index] = value + def get_sum(self): + return self.sum + def set_sum(self, sum): + self.sum = sum + def add_sum(self, value): + self.sum.append(value) + def insert_sum_at(self, index, value): + self.sum.insert(index, value) + def replace_sum_at(self, index, value): + self.sum[index] = value + def get_int(self): + return self.int + def set_int(self, int): + self.int = int + def add_int(self, value): + self.int.append(value) + def insert_int_at(self, index, value): + self.int.insert(index, value) + def replace_int_at(self, index, value): + self.int[index] = value + def get_prod(self): + return self.prod + def set_prod(self, prod): + self.prod = prod + def add_prod(self, value): + self.prod.append(value) + def insert_prod_at(self, index, value): + self.prod.insert(index, value) + def replace_prod_at(self, index, value): + self.prod[index] = value + def get_sim(self): + return self.sim + def set_sim(self, sim): + self.sim = sim + def add_sim(self, value): + self.sim.append(value) + def insert_sim_at(self, index, value): + self.sim.insert(index, value) + def replace_sim_at(self, index, value): + self.sim[index] = value + def get_asymp(self): + return self.asymp + def set_asymp(self, asymp): + self.asymp = asymp + def add_asymp(self, value): + self.asymp.append(value) + def insert_asymp_at(self, index, value): + self.asymp.insert(index, value) + def replace_asymp_at(self, index, value): + self.asymp[index] = value + def get_ne(self): + return self.ne + def set_ne(self, ne): + self.ne = ne + def add_ne(self, value): + self.ne.append(value) + def insert_ne_at(self, index, value): + self.ne.insert(index, value) + def replace_ne_at(self, index, value): + self.ne[index] = value + def get_equiv(self): + return self.equiv + def set_equiv(self, equiv): + self.equiv = equiv + def add_equiv(self, value): + self.equiv.append(value) + def insert_equiv_at(self, index, value): + self.equiv.insert(index, value) + def replace_equiv_at(self, index, value): + self.equiv[index] = value + def get_prop(self): + return self.prop + def set_prop(self, prop): + self.prop = prop + def add_prop(self, value): + self.prop.append(value) + def insert_prop_at(self, index, value): + self.prop.insert(index, value) + def replace_prop_at(self, index, value): + self.prop[index] = value + def get_le(self): + return self.le + def set_le(self, le): + self.le = le + def add_le(self, value): + self.le.append(value) + def insert_le_at(self, index, value): + self.le.insert(index, value) + def replace_le_at(self, index, value): + self.le[index] = value + def get_ge(self): + return self.ge + def set_ge(self, ge): + self.ge = ge + def add_ge(self, value): + self.ge.append(value) + def insert_ge_at(self, index, value): + self.ge.insert(index, value) + def replace_ge_at(self, index, value): + self.ge[index] = value + def get_larr(self): + return self.larr + def set_larr(self, larr): + self.larr = larr + def add_larr(self, value): + self.larr.append(value) + def insert_larr_at(self, index, value): + self.larr.insert(index, value) + def replace_larr_at(self, index, value): + self.larr[index] = value + def get_rarr(self): + return self.rarr + def set_rarr(self, rarr): + self.rarr = rarr + def add_rarr(self, value): + self.rarr.append(value) + def insert_rarr_at(self, index, value): + self.rarr.insert(index, value) + def replace_rarr_at(self, index, value): + self.rarr[index] = value + def get_isin(self): + return self.isin + def set_isin(self, isin): + self.isin = isin + def add_isin(self, value): + self.isin.append(value) + def insert_isin_at(self, index, value): + self.isin.insert(index, value) + def replace_isin_at(self, index, value): + self.isin[index] = value + def get_notin(self): + return self.notin + def set_notin(self, notin): + self.notin = notin + def add_notin(self, value): + self.notin.append(value) + def insert_notin_at(self, index, value): + self.notin.insert(index, value) + def replace_notin_at(self, index, value): + self.notin[index] = value + def get_lceil(self): + return self.lceil + def set_lceil(self, lceil): + self.lceil = lceil + def add_lceil(self, value): + self.lceil.append(value) + def insert_lceil_at(self, index, value): + self.lceil.insert(index, value) + def replace_lceil_at(self, index, value): + self.lceil[index] = value + def get_rceil(self): + return self.rceil + def set_rceil(self, rceil): + self.rceil = rceil + def add_rceil(self, value): + self.rceil.append(value) + def insert_rceil_at(self, index, value): + self.rceil.insert(index, value) + def replace_rceil_at(self, index, value): + self.rceil[index] = value + def get_lfloor(self): + return self.lfloor + def set_lfloor(self, lfloor): + self.lfloor = lfloor + def add_lfloor(self, value): + self.lfloor.append(value) + def insert_lfloor_at(self, index, value): + self.lfloor.insert(index, value) + def replace_lfloor_at(self, index, value): + self.lfloor[index] = value + def get_rfloor(self): + return self.rfloor + def set_rfloor(self, rfloor): + self.rfloor = rfloor + def add_rfloor(self, value): + self.rfloor.append(value) + def insert_rfloor_at(self, index, value): + self.rfloor.insert(index, value) + def replace_rfloor_at(self, index, value): + self.rfloor[index] = value + 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 get_valueOf_(self): return self.valueOf_ + def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def validate_DoxRefKind(self, value): + # Validate type DoxRefKind, a restriction on xsd:string. + if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) + return False + value = value + enumerations = ['compound', 'member'] + if value not in enumerations: + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on DoxRefKind' % {"value" : encode_str_2_3(value), "lineno": lineno} ) + result = False + def hasContent_(self): + if ( + self.ulink or + self.bold or + self.emphasis or + self.computeroutput or + self.subscript or + self.superscript or + self.center or + self.small or + self.htmlonly or + self.manonly or + self.xmlonly or + self.rtfonly or + self.latexonly or + self.dot or + self.msc or + self.anchor or + self.formula or + self.ref or + self.copy or + self.trademark or + self.registered or + self.lsquo or + self.rsquo or + self.ldquo or + self.rdquo or + self.ndash or + self.mdash or + self.umlaut or + self.acute or + self.grave or + self.circ or + self.slash or + self.tilde or + self.cedil or + self.ring or + self.szlig or + self.nonbreakablespace or + self.aelig or + self.AElig or + self.Gamma or + self.Delta or + self.Theta or + self.Lambda or + self.Xi or + self.Pi or + self.Sigma or + self.Upsilon or + self.Phi or + self.Psi or + self.Omega or + self.alpha or + self.beta or + self.gamma or + self.delta or + self.epsilon or + self.zeta or + self.eta or + self.theta or + self.iota or + self.kappa or + self.lambda_ or + self.mu or + self.nu or + self.xi or + self.pi or + self.rho or + self.sigma or + self.tau or + self.upsilon or + self.phi or + self.chi or + self.psi or + self.omega or + self.sigmaf or + self.sect or + self.deg or + self.prime or + self.Prime or + self.infin or + self.empty or + self.plusmn or + self.times or + self.minus or + self.sdot or + self.part or + self.nabla or + self.radic or + self.perp or + self.sum or + self.int or + self.prod or + self.sim or + self.asymp or + self.ne or + self.equiv or + self.prop or + self.le or + self.ge or + self.larr or + self.rarr or + self.isin or + self.notin or + self.lceil or + self.rceil or + self.lfloor or + self.rfloor or + (1 if type(self.valueOf_) in [int,float] else self.valueOf_) or + self.content_ + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docRefTextType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docRefTextType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docRefTextType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docRefTextType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docRefTextType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docRefTextType'): + if self.refid is not None and 'refid' not in already_processed: + already_processed.add('refid') + outfile.write(' refid=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.refid), input_name='refid')), )) + if self.kindref is not None and 'kindref' not in already_processed: + already_processed.add('kindref') + outfile.write(' kindref=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.kindref), input_name='kindref')), )) + if self.external is not None and 'external' not in already_processed: + already_processed.add('external') + outfile.write(' external=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.external), input_name='external')), )) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docRefTextType', fromsubclass_=False, pretty_print=True): + if not fromsubclass_: + for item_ in self.content_: + item_.export(outfile, level, item_.name, namespaceprefix_, pretty_print=pretty_print) + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for ulink_ in self.ulink: + namespaceprefix_ = self.ulink_nsprefix_ + ':' if (UseCapturedNS_ and self.ulink_nsprefix_) else '' + ulink_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ulink', pretty_print=pretty_print) + for bold_ in self.bold: + namespaceprefix_ = self.bold_nsprefix_ + ':' if (UseCapturedNS_ and self.bold_nsprefix_) else '' + bold_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='bold', pretty_print=pretty_print) + for emphasis_ in self.emphasis: + namespaceprefix_ = self.emphasis_nsprefix_ + ':' if (UseCapturedNS_ and self.emphasis_nsprefix_) else '' + emphasis_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='emphasis', pretty_print=pretty_print) + for computeroutput_ in self.computeroutput: + namespaceprefix_ = self.computeroutput_nsprefix_ + ':' if (UseCapturedNS_ and self.computeroutput_nsprefix_) else '' + computeroutput_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='computeroutput', pretty_print=pretty_print) + for subscript_ in self.subscript: + namespaceprefix_ = self.subscript_nsprefix_ + ':' if (UseCapturedNS_ and self.subscript_nsprefix_) else '' + subscript_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='subscript', pretty_print=pretty_print) + for superscript_ in self.superscript: + namespaceprefix_ = self.superscript_nsprefix_ + ':' if (UseCapturedNS_ and self.superscript_nsprefix_) else '' + superscript_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='superscript', pretty_print=pretty_print) + for center_ in self.center: + namespaceprefix_ = self.center_nsprefix_ + ':' if (UseCapturedNS_ and self.center_nsprefix_) else '' + center_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='center', pretty_print=pretty_print) + for small_ in self.small: + namespaceprefix_ = self.small_nsprefix_ + ':' if (UseCapturedNS_ and self.small_nsprefix_) else '' + small_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='small', pretty_print=pretty_print) + for htmlonly_ in self.htmlonly: + namespaceprefix_ = self.htmlonly_nsprefix_ + ':' if (UseCapturedNS_ and self.htmlonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%shtmlonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(htmlonly_), input_name='htmlonly')), namespaceprefix_ , eol_)) + for manonly_ in self.manonly: + namespaceprefix_ = self.manonly_nsprefix_ + ':' if (UseCapturedNS_ and self.manonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%smanonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(manonly_), input_name='manonly')), namespaceprefix_ , eol_)) + for xmlonly_ in self.xmlonly: + namespaceprefix_ = self.xmlonly_nsprefix_ + ':' if (UseCapturedNS_ and self.xmlonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%sxmlonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(xmlonly_), input_name='xmlonly')), namespaceprefix_ , eol_)) + for rtfonly_ in self.rtfonly: + namespaceprefix_ = self.rtfonly_nsprefix_ + ':' if (UseCapturedNS_ and self.rtfonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%srtfonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(rtfonly_), input_name='rtfonly')), namespaceprefix_ , eol_)) + for latexonly_ in self.latexonly: + namespaceprefix_ = self.latexonly_nsprefix_ + ':' if (UseCapturedNS_ and self.latexonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%slatexonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(latexonly_), input_name='latexonly')), namespaceprefix_ , eol_)) + for dot_ in self.dot: + namespaceprefix_ = self.dot_nsprefix_ + ':' if (UseCapturedNS_ and self.dot_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%sdot>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(dot_), input_name='dot')), namespaceprefix_ , eol_)) + for msc_ in self.msc: + namespaceprefix_ = self.msc_nsprefix_ + ':' if (UseCapturedNS_ and self.msc_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%smsc>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(msc_), input_name='msc')), namespaceprefix_ , eol_)) + for anchor_ in self.anchor: + namespaceprefix_ = self.anchor_nsprefix_ + ':' if (UseCapturedNS_ and self.anchor_nsprefix_) else '' + anchor_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='anchor', pretty_print=pretty_print) + for formula_ in self.formula: + namespaceprefix_ = self.formula_nsprefix_ + ':' if (UseCapturedNS_ and self.formula_nsprefix_) else '' + formula_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='formula', pretty_print=pretty_print) + for ref_ in self.ref: + namespaceprefix_ = self.ref_nsprefix_ + ':' if (UseCapturedNS_ and self.ref_nsprefix_) else '' + ref_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ref', pretty_print=pretty_print) + for copy_ in self.copy: + namespaceprefix_ = self.copy_nsprefix_ + ':' if (UseCapturedNS_ and self.copy_nsprefix_) else '' + copy_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='copy', pretty_print=pretty_print) + for trademark_ in self.trademark: + namespaceprefix_ = self.trademark_nsprefix_ + ':' if (UseCapturedNS_ and self.trademark_nsprefix_) else '' + trademark_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='trademark', pretty_print=pretty_print) + for registered_ in self.registered: + namespaceprefix_ = self.registered_nsprefix_ + ':' if (UseCapturedNS_ and self.registered_nsprefix_) else '' + registered_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='registered', pretty_print=pretty_print) + for lsquo_ in self.lsquo: + namespaceprefix_ = self.lsquo_nsprefix_ + ':' if (UseCapturedNS_ and self.lsquo_nsprefix_) else '' + lsquo_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='lsquo', pretty_print=pretty_print) + for rsquo_ in self.rsquo: + namespaceprefix_ = self.rsquo_nsprefix_ + ':' if (UseCapturedNS_ and self.rsquo_nsprefix_) else '' + rsquo_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rsquo', pretty_print=pretty_print) + for ldquo_ in self.ldquo: + namespaceprefix_ = self.ldquo_nsprefix_ + ':' if (UseCapturedNS_ and self.ldquo_nsprefix_) else '' + ldquo_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ldquo', pretty_print=pretty_print) + for rdquo_ in self.rdquo: + namespaceprefix_ = self.rdquo_nsprefix_ + ':' if (UseCapturedNS_ and self.rdquo_nsprefix_) else '' + rdquo_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rdquo', pretty_print=pretty_print) + for ndash_ in self.ndash: + namespaceprefix_ = self.ndash_nsprefix_ + ':' if (UseCapturedNS_ and self.ndash_nsprefix_) else '' + ndash_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ndash', pretty_print=pretty_print) + for mdash_ in self.mdash: + namespaceprefix_ = self.mdash_nsprefix_ + ':' if (UseCapturedNS_ and self.mdash_nsprefix_) else '' + mdash_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='mdash', pretty_print=pretty_print) + for umlaut_ in self.umlaut: + namespaceprefix_ = self.umlaut_nsprefix_ + ':' if (UseCapturedNS_ and self.umlaut_nsprefix_) else '' + umlaut_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='umlaut', pretty_print=pretty_print) + for acute_ in self.acute: + namespaceprefix_ = self.acute_nsprefix_ + ':' if (UseCapturedNS_ and self.acute_nsprefix_) else '' + acute_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='acute', pretty_print=pretty_print) + for grave_ in self.grave: + namespaceprefix_ = self.grave_nsprefix_ + ':' if (UseCapturedNS_ and self.grave_nsprefix_) else '' + grave_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='grave', pretty_print=pretty_print) + for circ_ in self.circ: + namespaceprefix_ = self.circ_nsprefix_ + ':' if (UseCapturedNS_ and self.circ_nsprefix_) else '' + circ_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='circ', pretty_print=pretty_print) + for slash_ in self.slash: + namespaceprefix_ = self.slash_nsprefix_ + ':' if (UseCapturedNS_ and self.slash_nsprefix_) else '' + slash_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='slash', pretty_print=pretty_print) + for tilde_ in self.tilde: + namespaceprefix_ = self.tilde_nsprefix_ + ':' if (UseCapturedNS_ and self.tilde_nsprefix_) else '' + tilde_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='tilde', pretty_print=pretty_print) + for cedil_ in self.cedil: + namespaceprefix_ = self.cedil_nsprefix_ + ':' if (UseCapturedNS_ and self.cedil_nsprefix_) else '' + cedil_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='cedil', pretty_print=pretty_print) + for ring_ in self.ring: + namespaceprefix_ = self.ring_nsprefix_ + ':' if (UseCapturedNS_ and self.ring_nsprefix_) else '' + ring_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ring', pretty_print=pretty_print) + for szlig_ in self.szlig: + namespaceprefix_ = self.szlig_nsprefix_ + ':' if (UseCapturedNS_ and self.szlig_nsprefix_) else '' + szlig_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='szlig', pretty_print=pretty_print) + for nonbreakablespace_ in self.nonbreakablespace: + namespaceprefix_ = self.nonbreakablespace_nsprefix_ + ':' if (UseCapturedNS_ and self.nonbreakablespace_nsprefix_) else '' + nonbreakablespace_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='nonbreakablespace', pretty_print=pretty_print) + for aelig_ in self.aelig: + namespaceprefix_ = self.aelig_nsprefix_ + ':' if (UseCapturedNS_ and self.aelig_nsprefix_) else '' + aelig_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='aelig', pretty_print=pretty_print) + for AElig_ in self.AElig: + namespaceprefix_ = self.AElig_nsprefix_ + ':' if (UseCapturedNS_ and self.AElig_nsprefix_) else '' + AElig_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='AElig', pretty_print=pretty_print) + for Gamma_ in self.Gamma: + namespaceprefix_ = self.Gamma_nsprefix_ + ':' if (UseCapturedNS_ and self.Gamma_nsprefix_) else '' + Gamma_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Gamma', pretty_print=pretty_print) + for Delta_ in self.Delta: + namespaceprefix_ = self.Delta_nsprefix_ + ':' if (UseCapturedNS_ and self.Delta_nsprefix_) else '' + Delta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Delta', pretty_print=pretty_print) + for Theta_ in self.Theta: + namespaceprefix_ = self.Theta_nsprefix_ + ':' if (UseCapturedNS_ and self.Theta_nsprefix_) else '' + Theta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Theta', pretty_print=pretty_print) + for Lambda_ in self.Lambda: + namespaceprefix_ = self.Lambda_nsprefix_ + ':' if (UseCapturedNS_ and self.Lambda_nsprefix_) else '' + Lambda_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Lambda', pretty_print=pretty_print) + for Xi_ in self.Xi: + namespaceprefix_ = self.Xi_nsprefix_ + ':' if (UseCapturedNS_ and self.Xi_nsprefix_) else '' + Xi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Xi', pretty_print=pretty_print) + for Pi_ in self.Pi: + namespaceprefix_ = self.Pi_nsprefix_ + ':' if (UseCapturedNS_ and self.Pi_nsprefix_) else '' + Pi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Pi', pretty_print=pretty_print) + for Sigma_ in self.Sigma: + namespaceprefix_ = self.Sigma_nsprefix_ + ':' if (UseCapturedNS_ and self.Sigma_nsprefix_) else '' + Sigma_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Sigma', pretty_print=pretty_print) + for Upsilon_ in self.Upsilon: + namespaceprefix_ = self.Upsilon_nsprefix_ + ':' if (UseCapturedNS_ and self.Upsilon_nsprefix_) else '' + Upsilon_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Upsilon', pretty_print=pretty_print) + for Phi_ in self.Phi: + namespaceprefix_ = self.Phi_nsprefix_ + ':' if (UseCapturedNS_ and self.Phi_nsprefix_) else '' + Phi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Phi', pretty_print=pretty_print) + for Psi_ in self.Psi: + namespaceprefix_ = self.Psi_nsprefix_ + ':' if (UseCapturedNS_ and self.Psi_nsprefix_) else '' + Psi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Psi', pretty_print=pretty_print) + for Omega_ in self.Omega: + namespaceprefix_ = self.Omega_nsprefix_ + ':' if (UseCapturedNS_ and self.Omega_nsprefix_) else '' + Omega_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Omega', pretty_print=pretty_print) + for alpha_ in self.alpha: + namespaceprefix_ = self.alpha_nsprefix_ + ':' if (UseCapturedNS_ and self.alpha_nsprefix_) else '' + alpha_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='alpha', pretty_print=pretty_print) + for beta_ in self.beta: + namespaceprefix_ = self.beta_nsprefix_ + ':' if (UseCapturedNS_ and self.beta_nsprefix_) else '' + beta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='beta', pretty_print=pretty_print) + for gamma_ in self.gamma: + namespaceprefix_ = self.gamma_nsprefix_ + ':' if (UseCapturedNS_ and self.gamma_nsprefix_) else '' + gamma_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='gamma', pretty_print=pretty_print) + for delta_ in self.delta: + namespaceprefix_ = self.delta_nsprefix_ + ':' if (UseCapturedNS_ and self.delta_nsprefix_) else '' + delta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='delta', pretty_print=pretty_print) + for epsilon_ in self.epsilon: + namespaceprefix_ = self.epsilon_nsprefix_ + ':' if (UseCapturedNS_ and self.epsilon_nsprefix_) else '' + epsilon_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='epsilon', pretty_print=pretty_print) + for zeta_ in self.zeta: + namespaceprefix_ = self.zeta_nsprefix_ + ':' if (UseCapturedNS_ and self.zeta_nsprefix_) else '' + zeta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='zeta', pretty_print=pretty_print) + for eta_ in self.eta: + namespaceprefix_ = self.eta_nsprefix_ + ':' if (UseCapturedNS_ and self.eta_nsprefix_) else '' + eta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='eta', pretty_print=pretty_print) + for theta_ in self.theta: + namespaceprefix_ = self.theta_nsprefix_ + ':' if (UseCapturedNS_ and self.theta_nsprefix_) else '' + theta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='theta', pretty_print=pretty_print) + for iota_ in self.iota: + namespaceprefix_ = self.iota_nsprefix_ + ':' if (UseCapturedNS_ and self.iota_nsprefix_) else '' + iota_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='iota', pretty_print=pretty_print) + for kappa_ in self.kappa: + namespaceprefix_ = self.kappa_nsprefix_ + ':' if (UseCapturedNS_ and self.kappa_nsprefix_) else '' + kappa_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='kappa', pretty_print=pretty_print) + for lambda_ in self.lambda_: + namespaceprefix_ = self.lambda__nsprefix_ + ':' if (UseCapturedNS_ and self.lambda__nsprefix_) else '' + lambda_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='lambda', pretty_print=pretty_print) + for mu_ in self.mu: + namespaceprefix_ = self.mu_nsprefix_ + ':' if (UseCapturedNS_ and self.mu_nsprefix_) else '' + mu_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='mu', pretty_print=pretty_print) + for nu_ in self.nu: + namespaceprefix_ = self.nu_nsprefix_ + ':' if (UseCapturedNS_ and self.nu_nsprefix_) else '' + nu_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='nu', pretty_print=pretty_print) + for xi_ in self.xi: + namespaceprefix_ = self.xi_nsprefix_ + ':' if (UseCapturedNS_ and self.xi_nsprefix_) else '' + xi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='xi', pretty_print=pretty_print) + for pi_ in self.pi: + namespaceprefix_ = self.pi_nsprefix_ + ':' if (UseCapturedNS_ and self.pi_nsprefix_) else '' + pi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='pi', pretty_print=pretty_print) + for rho_ in self.rho: + namespaceprefix_ = self.rho_nsprefix_ + ':' if (UseCapturedNS_ and self.rho_nsprefix_) else '' + rho_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rho', pretty_print=pretty_print) + for sigma_ in self.sigma: + namespaceprefix_ = self.sigma_nsprefix_ + ':' if (UseCapturedNS_ and self.sigma_nsprefix_) else '' + sigma_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sigma', pretty_print=pretty_print) + for tau_ in self.tau: + namespaceprefix_ = self.tau_nsprefix_ + ':' if (UseCapturedNS_ and self.tau_nsprefix_) else '' + tau_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='tau', pretty_print=pretty_print) + for upsilon_ in self.upsilon: + namespaceprefix_ = self.upsilon_nsprefix_ + ':' if (UseCapturedNS_ and self.upsilon_nsprefix_) else '' + upsilon_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='upsilon', pretty_print=pretty_print) + for phi_ in self.phi: + namespaceprefix_ = self.phi_nsprefix_ + ':' if (UseCapturedNS_ and self.phi_nsprefix_) else '' + phi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='phi', pretty_print=pretty_print) + for chi_ in self.chi: + namespaceprefix_ = self.chi_nsprefix_ + ':' if (UseCapturedNS_ and self.chi_nsprefix_) else '' + chi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='chi', pretty_print=pretty_print) + for psi_ in self.psi: + namespaceprefix_ = self.psi_nsprefix_ + ':' if (UseCapturedNS_ and self.psi_nsprefix_) else '' + psi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='psi', pretty_print=pretty_print) + for omega_ in self.omega: + namespaceprefix_ = self.omega_nsprefix_ + ':' if (UseCapturedNS_ and self.omega_nsprefix_) else '' + omega_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='omega', pretty_print=pretty_print) + for sigmaf_ in self.sigmaf: + namespaceprefix_ = self.sigmaf_nsprefix_ + ':' if (UseCapturedNS_ and self.sigmaf_nsprefix_) else '' + sigmaf_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sigmaf', pretty_print=pretty_print) + for sect_ in self.sect: + namespaceprefix_ = self.sect_nsprefix_ + ':' if (UseCapturedNS_ and self.sect_nsprefix_) else '' + sect_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sect', pretty_print=pretty_print) + for deg_ in self.deg: + namespaceprefix_ = self.deg_nsprefix_ + ':' if (UseCapturedNS_ and self.deg_nsprefix_) else '' + deg_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='deg', pretty_print=pretty_print) + for prime_ in self.prime: + namespaceprefix_ = self.prime_nsprefix_ + ':' if (UseCapturedNS_ and self.prime_nsprefix_) else '' + prime_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='prime', pretty_print=pretty_print) + for Prime_ in self.Prime: + namespaceprefix_ = self.Prime_nsprefix_ + ':' if (UseCapturedNS_ and self.Prime_nsprefix_) else '' + Prime_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Prime', pretty_print=pretty_print) + for infin_ in self.infin: + namespaceprefix_ = self.infin_nsprefix_ + ':' if (UseCapturedNS_ and self.infin_nsprefix_) else '' + infin_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='infin', pretty_print=pretty_print) + for empty_ in self.empty: + namespaceprefix_ = self.empty_nsprefix_ + ':' if (UseCapturedNS_ and self.empty_nsprefix_) else '' + empty_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='empty', pretty_print=pretty_print) + for plusmn_ in self.plusmn: + namespaceprefix_ = self.plusmn_nsprefix_ + ':' if (UseCapturedNS_ and self.plusmn_nsprefix_) else '' + plusmn_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='plusmn', pretty_print=pretty_print) + for times_ in self.times: + namespaceprefix_ = self.times_nsprefix_ + ':' if (UseCapturedNS_ and self.times_nsprefix_) else '' + times_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='times', pretty_print=pretty_print) + for minus_ in self.minus: + namespaceprefix_ = self.minus_nsprefix_ + ':' if (UseCapturedNS_ and self.minus_nsprefix_) else '' + minus_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='minus', pretty_print=pretty_print) + for sdot_ in self.sdot: + namespaceprefix_ = self.sdot_nsprefix_ + ':' if (UseCapturedNS_ and self.sdot_nsprefix_) else '' + sdot_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sdot', pretty_print=pretty_print) + for part_ in self.part: + namespaceprefix_ = self.part_nsprefix_ + ':' if (UseCapturedNS_ and self.part_nsprefix_) else '' + part_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='part', pretty_print=pretty_print) + for nabla_ in self.nabla: + namespaceprefix_ = self.nabla_nsprefix_ + ':' if (UseCapturedNS_ and self.nabla_nsprefix_) else '' + nabla_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='nabla', pretty_print=pretty_print) + for radic_ in self.radic: + namespaceprefix_ = self.radic_nsprefix_ + ':' if (UseCapturedNS_ and self.radic_nsprefix_) else '' + radic_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='radic', pretty_print=pretty_print) + for perp_ in self.perp: + namespaceprefix_ = self.perp_nsprefix_ + ':' if (UseCapturedNS_ and self.perp_nsprefix_) else '' + perp_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='perp', pretty_print=pretty_print) + for sum_ in self.sum: + namespaceprefix_ = self.sum_nsprefix_ + ':' if (UseCapturedNS_ and self.sum_nsprefix_) else '' + sum_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sum', pretty_print=pretty_print) + for int_ in self.int: + namespaceprefix_ = self.int_nsprefix_ + ':' if (UseCapturedNS_ and self.int_nsprefix_) else '' + int_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='int', pretty_print=pretty_print) + for prod_ in self.prod: + namespaceprefix_ = self.prod_nsprefix_ + ':' if (UseCapturedNS_ and self.prod_nsprefix_) else '' + prod_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='prod', pretty_print=pretty_print) + for sim_ in self.sim: + namespaceprefix_ = self.sim_nsprefix_ + ':' if (UseCapturedNS_ and self.sim_nsprefix_) else '' + sim_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sim', pretty_print=pretty_print) + for asymp_ in self.asymp: + namespaceprefix_ = self.asymp_nsprefix_ + ':' if (UseCapturedNS_ and self.asymp_nsprefix_) else '' + asymp_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='asymp', pretty_print=pretty_print) + for ne_ in self.ne: + namespaceprefix_ = self.ne_nsprefix_ + ':' if (UseCapturedNS_ and self.ne_nsprefix_) else '' + ne_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ne', pretty_print=pretty_print) + for equiv_ in self.equiv: + namespaceprefix_ = self.equiv_nsprefix_ + ':' if (UseCapturedNS_ and self.equiv_nsprefix_) else '' + equiv_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='equiv', pretty_print=pretty_print) + for prop_ in self.prop: + namespaceprefix_ = self.prop_nsprefix_ + ':' if (UseCapturedNS_ and self.prop_nsprefix_) else '' + prop_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='prop', pretty_print=pretty_print) + for le_ in self.le: + namespaceprefix_ = self.le_nsprefix_ + ':' if (UseCapturedNS_ and self.le_nsprefix_) else '' + le_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='le', pretty_print=pretty_print) + for ge_ in self.ge: + namespaceprefix_ = self.ge_nsprefix_ + ':' if (UseCapturedNS_ and self.ge_nsprefix_) else '' + ge_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ge', pretty_print=pretty_print) + for larr_ in self.larr: + namespaceprefix_ = self.larr_nsprefix_ + ':' if (UseCapturedNS_ and self.larr_nsprefix_) else '' + larr_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='larr', pretty_print=pretty_print) + for rarr_ in self.rarr: + namespaceprefix_ = self.rarr_nsprefix_ + ':' if (UseCapturedNS_ and self.rarr_nsprefix_) else '' + rarr_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rarr', pretty_print=pretty_print) + for isin_ in self.isin: + namespaceprefix_ = self.isin_nsprefix_ + ':' if (UseCapturedNS_ and self.isin_nsprefix_) else '' + isin_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='isin', pretty_print=pretty_print) + for notin_ in self.notin: + namespaceprefix_ = self.notin_nsprefix_ + ':' if (UseCapturedNS_ and self.notin_nsprefix_) else '' + notin_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='notin', pretty_print=pretty_print) + for lceil_ in self.lceil: + namespaceprefix_ = self.lceil_nsprefix_ + ':' if (UseCapturedNS_ and self.lceil_nsprefix_) else '' + lceil_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='lceil', pretty_print=pretty_print) + for rceil_ in self.rceil: + namespaceprefix_ = self.rceil_nsprefix_ + ':' if (UseCapturedNS_ and self.rceil_nsprefix_) else '' + rceil_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rceil', pretty_print=pretty_print) + for lfloor_ in self.lfloor: + namespaceprefix_ = self.lfloor_nsprefix_ + ':' if (UseCapturedNS_ and self.lfloor_nsprefix_) else '' + lfloor_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='lfloor', pretty_print=pretty_print) + for rfloor_ in self.rfloor: + namespaceprefix_ = self.rfloor_nsprefix_ + ':' if (UseCapturedNS_ and self.rfloor_nsprefix_) else '' + rfloor_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rfloor', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + self.valueOf_ = get_all_text_(node) + if node.text is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', node.text) + self.content_.append(obj_) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('refid', node) + if value is not None and 'refid' not in already_processed: + already_processed.add('refid') + self.refid = value + value = find_attr_value_('kindref', node) + if value is not None and 'kindref' not in already_processed: + already_processed.add('kindref') + self.kindref = value + self.validate_DoxRefKind(self.kindref) # validate type DoxRefKind + value = find_attr_value_('external', node) + if value is not None and 'external' not in already_processed: + already_processed.add('external') + self.external = value + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'ulink': + obj_ = docURLLink.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ulink', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ulink'): + self.add_ulink(obj_.value) + elif hasattr(self, 'set_ulink'): + self.set_ulink(obj_.value) + elif nodeName_ == 'bold': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'bold', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_bold'): + self.add_bold(obj_.value) + elif hasattr(self, 'set_bold'): + self.set_bold(obj_.value) + elif nodeName_ == 'emphasis': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'emphasis', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_emphasis'): + self.add_emphasis(obj_.value) + elif hasattr(self, 'set_emphasis'): + self.set_emphasis(obj_.value) + elif nodeName_ == 'computeroutput': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'computeroutput', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_computeroutput'): + self.add_computeroutput(obj_.value) + elif hasattr(self, 'set_computeroutput'): + self.set_computeroutput(obj_.value) + elif nodeName_ == 'subscript': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'subscript', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_subscript'): + self.add_subscript(obj_.value) + elif hasattr(self, 'set_subscript'): + self.set_subscript(obj_.value) + elif nodeName_ == 'superscript': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'superscript', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_superscript'): + self.add_superscript(obj_.value) + elif hasattr(self, 'set_superscript'): + self.set_superscript(obj_.value) + elif nodeName_ == 'center': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'center', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_center'): + self.add_center(obj_.value) + elif hasattr(self, 'set_center'): + self.set_center(obj_.value) + elif nodeName_ == 'small': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'small', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_small'): + self.add_small(obj_.value) + elif hasattr(self, 'set_small'): + self.set_small(obj_.value) + elif nodeName_ == 'htmlonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'htmlonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'htmlonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'htmlonly', valuestr_) + self.content_.append(obj_) + self.htmlonly_nsprefix_ = child_.prefix + elif nodeName_ == 'manonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'manonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'manonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'manonly', valuestr_) + self.content_.append(obj_) + self.manonly_nsprefix_ = child_.prefix + elif nodeName_ == 'xmlonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'xmlonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'xmlonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'xmlonly', valuestr_) + self.content_.append(obj_) + self.xmlonly_nsprefix_ = child_.prefix + elif nodeName_ == 'rtfonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'rtfonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'rtfonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'rtfonly', valuestr_) + self.content_.append(obj_) + self.rtfonly_nsprefix_ = child_.prefix + elif nodeName_ == 'latexonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'latexonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'latexonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'latexonly', valuestr_) + self.content_.append(obj_) + self.latexonly_nsprefix_ = child_.prefix + elif nodeName_ == 'dot' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'dot') + valuestr_ = self.gds_validate_string(valuestr_, node, 'dot') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'dot', valuestr_) + self.content_.append(obj_) + self.dot_nsprefix_ = child_.prefix + elif nodeName_ == 'msc' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'msc') + valuestr_ = self.gds_validate_string(valuestr_, node, 'msc') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'msc', valuestr_) + self.content_.append(obj_) + self.msc_nsprefix_ = child_.prefix + elif nodeName_ == 'anchor': + obj_ = docAnchorType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'anchor', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_anchor'): + self.add_anchor(obj_.value) + elif hasattr(self, 'set_anchor'): + self.set_anchor(obj_.value) + elif nodeName_ == 'formula': + obj_ = docFormulaType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'formula', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_formula'): + self.add_formula(obj_.value) + elif hasattr(self, 'set_formula'): + self.set_formula(obj_.value) + elif nodeName_ == 'ref': + obj_ = docRefTextType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ref', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ref'): + self.add_ref(obj_.value) + elif hasattr(self, 'set_ref'): + self.set_ref(obj_.value) + elif nodeName_ == 'copy': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'copy', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_copy'): + self.add_copy(obj_.value) + elif hasattr(self, 'set_copy'): + self.set_copy(obj_.value) + elif nodeName_ == 'trademark': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'trademark', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_trademark'): + self.add_trademark(obj_.value) + elif hasattr(self, 'set_trademark'): + self.set_trademark(obj_.value) + elif nodeName_ == 'registered': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'registered', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_registered'): + self.add_registered(obj_.value) + elif hasattr(self, 'set_registered'): + self.set_registered(obj_.value) + elif nodeName_ == 'lsquo': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'lsquo', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_lsquo'): + self.add_lsquo(obj_.value) + elif hasattr(self, 'set_lsquo'): + self.set_lsquo(obj_.value) + elif nodeName_ == 'rsquo': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rsquo', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rsquo'): + self.add_rsquo(obj_.value) + elif hasattr(self, 'set_rsquo'): + self.set_rsquo(obj_.value) + elif nodeName_ == 'ldquo': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ldquo', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ldquo'): + self.add_ldquo(obj_.value) + elif hasattr(self, 'set_ldquo'): + self.set_ldquo(obj_.value) + elif nodeName_ == 'rdquo': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rdquo', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rdquo'): + self.add_rdquo(obj_.value) + elif hasattr(self, 'set_rdquo'): + self.set_rdquo(obj_.value) + elif nodeName_ == 'ndash': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ndash', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ndash'): + self.add_ndash(obj_.value) + elif hasattr(self, 'set_ndash'): + self.set_ndash(obj_.value) + elif nodeName_ == 'mdash': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'mdash', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_mdash'): + self.add_mdash(obj_.value) + elif hasattr(self, 'set_mdash'): + self.set_mdash(obj_.value) + elif nodeName_ == 'umlaut': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'umlaut', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_umlaut'): + self.add_umlaut(obj_.value) + elif hasattr(self, 'set_umlaut'): + self.set_umlaut(obj_.value) + elif nodeName_ == 'acute': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'acute', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_acute'): + self.add_acute(obj_.value) + elif hasattr(self, 'set_acute'): + self.set_acute(obj_.value) + elif nodeName_ == 'grave': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'grave', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_grave'): + self.add_grave(obj_.value) + elif hasattr(self, 'set_grave'): + self.set_grave(obj_.value) + elif nodeName_ == 'circ': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'circ', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_circ'): + self.add_circ(obj_.value) + elif hasattr(self, 'set_circ'): + self.set_circ(obj_.value) + elif nodeName_ == 'slash': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'slash', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_slash'): + self.add_slash(obj_.value) + elif hasattr(self, 'set_slash'): + self.set_slash(obj_.value) + elif nodeName_ == 'tilde': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'tilde', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_tilde'): + self.add_tilde(obj_.value) + elif hasattr(self, 'set_tilde'): + self.set_tilde(obj_.value) + elif nodeName_ == 'cedil': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'cedil', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_cedil'): + self.add_cedil(obj_.value) + elif hasattr(self, 'set_cedil'): + self.set_cedil(obj_.value) + elif nodeName_ == 'ring': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ring', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ring'): + self.add_ring(obj_.value) + elif hasattr(self, 'set_ring'): + self.set_ring(obj_.value) + elif nodeName_ == 'szlig': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'szlig', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_szlig'): + self.add_szlig(obj_.value) + elif hasattr(self, 'set_szlig'): + self.set_szlig(obj_.value) + elif nodeName_ == 'nonbreakablespace': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'nonbreakablespace', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_nonbreakablespace'): + self.add_nonbreakablespace(obj_.value) + elif hasattr(self, 'set_nonbreakablespace'): + self.set_nonbreakablespace(obj_.value) + elif nodeName_ == 'aelig': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'aelig', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_aelig'): + self.add_aelig(obj_.value) + elif hasattr(self, 'set_aelig'): + self.set_aelig(obj_.value) + elif nodeName_ == 'AElig': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'AElig', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_AElig'): + self.add_AElig(obj_.value) + elif hasattr(self, 'set_AElig'): + self.set_AElig(obj_.value) + elif nodeName_ == 'Gamma': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Gamma', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Gamma'): + self.add_Gamma(obj_.value) + elif hasattr(self, 'set_Gamma'): + self.set_Gamma(obj_.value) + elif nodeName_ == 'Delta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Delta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Delta'): + self.add_Delta(obj_.value) + elif hasattr(self, 'set_Delta'): + self.set_Delta(obj_.value) + elif nodeName_ == 'Theta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Theta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Theta'): + self.add_Theta(obj_.value) + elif hasattr(self, 'set_Theta'): + self.set_Theta(obj_.value) + elif nodeName_ == 'Lambda': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Lambda', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Lambda'): + self.add_Lambda(obj_.value) + elif hasattr(self, 'set_Lambda'): + self.set_Lambda(obj_.value) + elif nodeName_ == 'Xi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Xi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Xi'): + self.add_Xi(obj_.value) + elif hasattr(self, 'set_Xi'): + self.set_Xi(obj_.value) + elif nodeName_ == 'Pi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Pi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Pi'): + self.add_Pi(obj_.value) + elif hasattr(self, 'set_Pi'): + self.set_Pi(obj_.value) + elif nodeName_ == 'Sigma': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Sigma', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Sigma'): + self.add_Sigma(obj_.value) + elif hasattr(self, 'set_Sigma'): + self.set_Sigma(obj_.value) + elif nodeName_ == 'Upsilon': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Upsilon', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Upsilon'): + self.add_Upsilon(obj_.value) + elif hasattr(self, 'set_Upsilon'): + self.set_Upsilon(obj_.value) + elif nodeName_ == 'Phi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Phi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Phi'): + self.add_Phi(obj_.value) + elif hasattr(self, 'set_Phi'): + self.set_Phi(obj_.value) + elif nodeName_ == 'Psi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Psi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Psi'): + self.add_Psi(obj_.value) + elif hasattr(self, 'set_Psi'): + self.set_Psi(obj_.value) + elif nodeName_ == 'Omega': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Omega', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Omega'): + self.add_Omega(obj_.value) + elif hasattr(self, 'set_Omega'): + self.set_Omega(obj_.value) + elif nodeName_ == 'alpha': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'alpha', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_alpha'): + self.add_alpha(obj_.value) + elif hasattr(self, 'set_alpha'): + self.set_alpha(obj_.value) + elif nodeName_ == 'beta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'beta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_beta'): + self.add_beta(obj_.value) + elif hasattr(self, 'set_beta'): + self.set_beta(obj_.value) + elif nodeName_ == 'gamma': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'gamma', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_gamma'): + self.add_gamma(obj_.value) + elif hasattr(self, 'set_gamma'): + self.set_gamma(obj_.value) + elif nodeName_ == 'delta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'delta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_delta'): + self.add_delta(obj_.value) + elif hasattr(self, 'set_delta'): + self.set_delta(obj_.value) + elif nodeName_ == 'epsilon': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'epsilon', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_epsilon'): + self.add_epsilon(obj_.value) + elif hasattr(self, 'set_epsilon'): + self.set_epsilon(obj_.value) + elif nodeName_ == 'zeta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'zeta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_zeta'): + self.add_zeta(obj_.value) + elif hasattr(self, 'set_zeta'): + self.set_zeta(obj_.value) + elif nodeName_ == 'eta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'eta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_eta'): + self.add_eta(obj_.value) + elif hasattr(self, 'set_eta'): + self.set_eta(obj_.value) + elif nodeName_ == 'theta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'theta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_theta'): + self.add_theta(obj_.value) + elif hasattr(self, 'set_theta'): + self.set_theta(obj_.value) + elif nodeName_ == 'iota': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'iota', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_iota'): + self.add_iota(obj_.value) + elif hasattr(self, 'set_iota'): + self.set_iota(obj_.value) + elif nodeName_ == 'kappa': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'kappa', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_kappa'): + self.add_kappa(obj_.value) + elif hasattr(self, 'set_kappa'): + self.set_kappa(obj_.value) + elif nodeName_ == 'lambda': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'lambda', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_lambda'): + self.add_lambda(obj_.value) + elif hasattr(self, 'set_lambda'): + self.set_lambda(obj_.value) + elif nodeName_ == 'mu': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'mu', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_mu'): + self.add_mu(obj_.value) + elif hasattr(self, 'set_mu'): + self.set_mu(obj_.value) + elif nodeName_ == 'nu': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'nu', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_nu'): + self.add_nu(obj_.value) + elif hasattr(self, 'set_nu'): + self.set_nu(obj_.value) + elif nodeName_ == 'xi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'xi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_xi'): + self.add_xi(obj_.value) + elif hasattr(self, 'set_xi'): + self.set_xi(obj_.value) + elif nodeName_ == 'pi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'pi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_pi'): + self.add_pi(obj_.value) + elif hasattr(self, 'set_pi'): + self.set_pi(obj_.value) + elif nodeName_ == 'rho': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rho', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rho'): + self.add_rho(obj_.value) + elif hasattr(self, 'set_rho'): + self.set_rho(obj_.value) + elif nodeName_ == 'sigma': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sigma', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sigma'): + self.add_sigma(obj_.value) + elif hasattr(self, 'set_sigma'): + self.set_sigma(obj_.value) + elif nodeName_ == 'tau': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'tau', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_tau'): + self.add_tau(obj_.value) + elif hasattr(self, 'set_tau'): + self.set_tau(obj_.value) + elif nodeName_ == 'upsilon': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'upsilon', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_upsilon'): + self.add_upsilon(obj_.value) + elif hasattr(self, 'set_upsilon'): + self.set_upsilon(obj_.value) + elif nodeName_ == 'phi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'phi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_phi'): + self.add_phi(obj_.value) + elif hasattr(self, 'set_phi'): + self.set_phi(obj_.value) + elif nodeName_ == 'chi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'chi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_chi'): + self.add_chi(obj_.value) + elif hasattr(self, 'set_chi'): + self.set_chi(obj_.value) + elif nodeName_ == 'psi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'psi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_psi'): + self.add_psi(obj_.value) + elif hasattr(self, 'set_psi'): + self.set_psi(obj_.value) + elif nodeName_ == 'omega': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'omega', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_omega'): + self.add_omega(obj_.value) + elif hasattr(self, 'set_omega'): + self.set_omega(obj_.value) + elif nodeName_ == 'sigmaf': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sigmaf', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sigmaf'): + self.add_sigmaf(obj_.value) + elif hasattr(self, 'set_sigmaf'): + self.set_sigmaf(obj_.value) + elif nodeName_ == 'sect': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sect', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sect'): + self.add_sect(obj_.value) + elif hasattr(self, 'set_sect'): + self.set_sect(obj_.value) + elif nodeName_ == 'deg': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'deg', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_deg'): + self.add_deg(obj_.value) + elif hasattr(self, 'set_deg'): + self.set_deg(obj_.value) + elif nodeName_ == 'prime': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'prime', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_prime'): + self.add_prime(obj_.value) + elif hasattr(self, 'set_prime'): + self.set_prime(obj_.value) + elif nodeName_ == 'Prime': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Prime', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Prime'): + self.add_Prime(obj_.value) + elif hasattr(self, 'set_Prime'): + self.set_Prime(obj_.value) + elif nodeName_ == 'infin': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'infin', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_infin'): + self.add_infin(obj_.value) + elif hasattr(self, 'set_infin'): + self.set_infin(obj_.value) + elif nodeName_ == 'empty': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'empty', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_empty'): + self.add_empty(obj_.value) + elif hasattr(self, 'set_empty'): + self.set_empty(obj_.value) + elif nodeName_ == 'plusmn': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'plusmn', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_plusmn'): + self.add_plusmn(obj_.value) + elif hasattr(self, 'set_plusmn'): + self.set_plusmn(obj_.value) + elif nodeName_ == 'times': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'times', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_times'): + self.add_times(obj_.value) + elif hasattr(self, 'set_times'): + self.set_times(obj_.value) + elif nodeName_ == 'minus': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'minus', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_minus'): + self.add_minus(obj_.value) + elif hasattr(self, 'set_minus'): + self.set_minus(obj_.value) + elif nodeName_ == 'sdot': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sdot', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sdot'): + self.add_sdot(obj_.value) + elif hasattr(self, 'set_sdot'): + self.set_sdot(obj_.value) + elif nodeName_ == 'part': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'part', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_part'): + self.add_part(obj_.value) + elif hasattr(self, 'set_part'): + self.set_part(obj_.value) + elif nodeName_ == 'nabla': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'nabla', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_nabla'): + self.add_nabla(obj_.value) + elif hasattr(self, 'set_nabla'): + self.set_nabla(obj_.value) + elif nodeName_ == 'radic': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'radic', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_radic'): + self.add_radic(obj_.value) + elif hasattr(self, 'set_radic'): + self.set_radic(obj_.value) + elif nodeName_ == 'perp': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'perp', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_perp'): + self.add_perp(obj_.value) + elif hasattr(self, 'set_perp'): + self.set_perp(obj_.value) + elif nodeName_ == 'sum': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sum', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sum'): + self.add_sum(obj_.value) + elif hasattr(self, 'set_sum'): + self.set_sum(obj_.value) + elif nodeName_ == 'int': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'int', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_int'): + self.add_int(obj_.value) + elif hasattr(self, 'set_int'): + self.set_int(obj_.value) + elif nodeName_ == 'prod': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'prod', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_prod'): + self.add_prod(obj_.value) + elif hasattr(self, 'set_prod'): + self.set_prod(obj_.value) + elif nodeName_ == 'sim': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sim', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sim'): + self.add_sim(obj_.value) + elif hasattr(self, 'set_sim'): + self.set_sim(obj_.value) + elif nodeName_ == 'asymp': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'asymp', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_asymp'): + self.add_asymp(obj_.value) + elif hasattr(self, 'set_asymp'): + self.set_asymp(obj_.value) + elif nodeName_ == 'ne': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ne', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ne'): + self.add_ne(obj_.value) + elif hasattr(self, 'set_ne'): + self.set_ne(obj_.value) + elif nodeName_ == 'equiv': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'equiv', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_equiv'): + self.add_equiv(obj_.value) + elif hasattr(self, 'set_equiv'): + self.set_equiv(obj_.value) + elif nodeName_ == 'prop': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'prop', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_prop'): + self.add_prop(obj_.value) + elif hasattr(self, 'set_prop'): + self.set_prop(obj_.value) + elif nodeName_ == 'le': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'le', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_le'): + self.add_le(obj_.value) + elif hasattr(self, 'set_le'): + self.set_le(obj_.value) + elif nodeName_ == 'ge': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ge', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ge'): + self.add_ge(obj_.value) + elif hasattr(self, 'set_ge'): + self.set_ge(obj_.value) + elif nodeName_ == 'larr': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'larr', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_larr'): + self.add_larr(obj_.value) + elif hasattr(self, 'set_larr'): + self.set_larr(obj_.value) + elif nodeName_ == 'rarr': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rarr', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rarr'): + self.add_rarr(obj_.value) + elif hasattr(self, 'set_rarr'): + self.set_rarr(obj_.value) + elif nodeName_ == 'isin': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'isin', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_isin'): + self.add_isin(obj_.value) + elif hasattr(self, 'set_isin'): + self.set_isin(obj_.value) + elif nodeName_ == 'notin': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'notin', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_notin'): + self.add_notin(obj_.value) + elif hasattr(self, 'set_notin'): + self.set_notin(obj_.value) + elif nodeName_ == 'lceil': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'lceil', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_lceil'): + self.add_lceil(obj_.value) + elif hasattr(self, 'set_lceil'): + self.set_lceil(obj_.value) + elif nodeName_ == 'rceil': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rceil', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rceil'): + self.add_rceil(obj_.value) + elif hasattr(self, 'set_rceil'): + self.set_rceil(obj_.value) + elif nodeName_ == 'lfloor': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'lfloor', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_lfloor'): + self.add_lfloor(obj_.value) + elif hasattr(self, 'set_lfloor'): + self.set_lfloor(obj_.value) + elif nodeName_ == 'rfloor': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rfloor', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rfloor'): + self.add_rfloor(obj_.value) + elif hasattr(self, 'set_rfloor'): + self.set_rfloor(obj_.value) + if not fromsubclass_ and child_.tail is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.tail) + self.content_.append(obj_) +# end class docRefTextType + + +class docTableType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, rows=None, cols=None, row=None, caption=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.rows = _cast(int, rows) + self.rows_nsprefix_ = None + self.cols = _cast(int, cols) + self.cols_nsprefix_ = None + if row is None: + self.row = [] + else: + self.row = row + self.row_nsprefix_ = None + self.caption = caption + self.caption_nsprefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docTableType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docTableType.subclass: + return docTableType.subclass(*args_, **kwargs_) + return docTableType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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_at(self, index, value): + self.row.insert(index, value) + def replace_row_at(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 hasContent_(self): + if ( + self.row or + self.caption is not None + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docTableType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docTableType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docTableType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docTableType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docTableType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docTableType'): + if self.rows is not None and 'rows' not in already_processed: + already_processed.add('rows') + outfile.write(' rows="%s"' % self.gds_format_integer(self.rows, input_name='rows')) + if self.cols is not None and 'cols' not in already_processed: + already_processed.add('cols') + outfile.write(' cols="%s"' % self.gds_format_integer(self.cols, input_name='cols')) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docTableType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for row_ in self.row: + namespaceprefix_ = self.row_nsprefix_ + ':' if (UseCapturedNS_ and self.row_nsprefix_) else '' + row_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='row', pretty_print=pretty_print) + if self.caption is not None: + namespaceprefix_ = self.caption_nsprefix_ + ':' if (UseCapturedNS_ and self.caption_nsprefix_) else '' + self.caption.export(outfile, level, namespaceprefix_, namespacedef_='', name_='caption', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('rows', node) + if value is not None and 'rows' not in already_processed: + already_processed.add('rows') + self.rows = self.gds_parse_integer(value, node, 'rows') + value = find_attr_value_('cols', node) + if value is not None and 'cols' not in already_processed: + already_processed.add('cols') + self.cols = self.gds_parse_integer(value, node, 'cols') + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'row': + obj_ = docRowType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.row.append(obj_) + obj_.original_tagname_ = 'row' + elif nodeName_ == 'caption': + obj_ = docCaptionType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.caption = obj_ + obj_.original_tagname_ = 'caption' +# end class docTableType + + +class docRowType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, entry=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + if entry is None: + self.entry = [] + else: + self.entry = entry + self.entry_nsprefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docRowType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docRowType.subclass: + return docRowType.subclass(*args_, **kwargs_) + return docRowType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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_at(self, index, value): + self.entry.insert(index, value) + def replace_entry_at(self, index, value): + self.entry[index] = value + def hasContent_(self): + if ( + self.entry + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docRowType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docRowType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docRowType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docRowType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docRowType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docRowType'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docRowType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for entry_ in self.entry: + namespaceprefix_ = self.entry_nsprefix_ + ':' if (UseCapturedNS_ and self.entry_nsprefix_) else '' + entry_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='entry', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'entry': + obj_ = docEntryType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.entry.append(obj_) + obj_.original_tagname_ = 'entry' +# end class docRowType + + +class docEntryType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, thead=None, para=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.thead = _cast(None, thead) + self.thead_nsprefix_ = None + if para is None: + self.para = [] + else: + self.para = para + self.para_nsprefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docEntryType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docEntryType.subclass: + return docEntryType.subclass(*args_, **kwargs_) + return docEntryType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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_at(self, index, value): + self.para.insert(index, value) + def replace_para_at(self, index, value): + self.para[index] = value + def get_thead(self): + return self.thead + def set_thead(self, thead): + self.thead = thead + def validate_DoxBool(self, value): + # Validate type DoxBool, a restriction on xsd:string. + if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) + return False + value = value + enumerations = ['yes', 'no'] + if value not in enumerations: + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on DoxBool' % {"value" : encode_str_2_3(value), "lineno": lineno} ) + result = False + def hasContent_(self): + if ( + self.para + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docEntryType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docEntryType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docEntryType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docEntryType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docEntryType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docEntryType'): + if self.thead is not None and 'thead' not in already_processed: + already_processed.add('thead') + outfile.write(' thead=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.thead), input_name='thead')), )) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docEntryType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for para_ in self.para: + namespaceprefix_ = self.para_nsprefix_ + ':' if (UseCapturedNS_ and self.para_nsprefix_) else '' + para_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='para', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('thead', node) + if value is not None and 'thead' not in already_processed: + already_processed.add('thead') + self.thead = value + self.validate_DoxBool(self.thead) # validate type DoxBool + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'para': + obj_ = docParaType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.para.append(obj_) + obj_.original_tagname_ = 'para' +# end class docEntryType + + +class docCaptionType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, ulink=None, bold=None, emphasis=None, computeroutput=None, subscript=None, superscript=None, center=None, small=None, htmlonly=None, manonly=None, xmlonly=None, rtfonly=None, latexonly=None, dot=None, msc=None, anchor=None, formula=None, ref=None, copy=None, trademark=None, registered=None, lsquo=None, rsquo=None, ldquo=None, rdquo=None, ndash=None, mdash=None, umlaut=None, acute=None, grave=None, circ=None, slash=None, tilde=None, cedil=None, ring=None, szlig=None, nonbreakablespace=None, aelig=None, AElig=None, Gamma=None, Delta=None, Theta=None, Lambda=None, Xi=None, Pi=None, Sigma=None, Upsilon=None, Phi=None, Psi=None, Omega=None, alpha=None, beta=None, gamma=None, delta=None, epsilon=None, zeta=None, eta=None, theta=None, iota=None, kappa=None, lambda_=None, mu=None, nu=None, xi=None, pi=None, rho=None, sigma=None, tau=None, upsilon=None, phi=None, chi=None, psi=None, omega=None, sigmaf=None, sect=None, deg=None, prime=None, Prime=None, infin=None, empty=None, plusmn=None, times=None, minus=None, sdot=None, part=None, nabla=None, radic=None, perp=None, sum=None, int=None, prod=None, sim=None, asymp=None, ne=None, equiv=None, prop=None, le=None, ge=None, larr=None, rarr=None, isin=None, notin=None, lceil=None, rceil=None, lfloor=None, rfloor=None, valueOf_=None, mixedclass_=None, content_=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + if ulink is None: + self.ulink = [] + else: + self.ulink = ulink + self.ulink_nsprefix_ = None + if bold is None: + self.bold = [] + else: + self.bold = bold + self.bold_nsprefix_ = None + if emphasis is None: + self.emphasis = [] + else: + self.emphasis = emphasis + self.emphasis_nsprefix_ = None + if computeroutput is None: + self.computeroutput = [] + else: + self.computeroutput = computeroutput + self.computeroutput_nsprefix_ = None + if subscript is None: + self.subscript = [] + else: + self.subscript = subscript + self.subscript_nsprefix_ = None + if superscript is None: + self.superscript = [] + else: + self.superscript = superscript + self.superscript_nsprefix_ = None + if center is None: + self.center = [] + else: + self.center = center + self.center_nsprefix_ = None + if small is None: + self.small = [] + else: + self.small = small + self.small_nsprefix_ = None + if htmlonly is None: + self.htmlonly = [] + else: + self.htmlonly = htmlonly + self.htmlonly_nsprefix_ = None + if manonly is None: + self.manonly = [] + else: + self.manonly = manonly + self.manonly_nsprefix_ = None + if xmlonly is None: + self.xmlonly = [] + else: + self.xmlonly = xmlonly + self.xmlonly_nsprefix_ = None + if rtfonly is None: + self.rtfonly = [] + else: + self.rtfonly = rtfonly + self.rtfonly_nsprefix_ = None + if latexonly is None: + self.latexonly = [] + else: + self.latexonly = latexonly + self.latexonly_nsprefix_ = None + if dot is None: + self.dot = [] + else: + self.dot = dot + self.dot_nsprefix_ = None + if msc is None: + self.msc = [] + else: + self.msc = msc + self.msc_nsprefix_ = None + if anchor is None: + self.anchor = [] + else: + self.anchor = anchor + self.anchor_nsprefix_ = None + if formula is None: + self.formula = [] + else: + self.formula = formula + self.formula_nsprefix_ = None + if ref is None: + self.ref = [] + else: + self.ref = ref + self.ref_nsprefix_ = None + if copy is None: + self.copy = [] + else: + self.copy = copy + self.copy_nsprefix_ = None + if trademark is None: + self.trademark = [] + else: + self.trademark = trademark + self.trademark_nsprefix_ = None + if registered is None: + self.registered = [] + else: + self.registered = registered + self.registered_nsprefix_ = None + if lsquo is None: + self.lsquo = [] + else: + self.lsquo = lsquo + self.lsquo_nsprefix_ = None + if rsquo is None: + self.rsquo = [] + else: + self.rsquo = rsquo + self.rsquo_nsprefix_ = None + if ldquo is None: + self.ldquo = [] + else: + self.ldquo = ldquo + self.ldquo_nsprefix_ = None + if rdquo is None: + self.rdquo = [] + else: + self.rdquo = rdquo + self.rdquo_nsprefix_ = None + if ndash is None: + self.ndash = [] + else: + self.ndash = ndash + self.ndash_nsprefix_ = None + if mdash is None: + self.mdash = [] + else: + self.mdash = mdash + self.mdash_nsprefix_ = None + if umlaut is None: + self.umlaut = [] + else: + self.umlaut = umlaut + self.umlaut_nsprefix_ = None + if acute is None: + self.acute = [] + else: + self.acute = acute + self.acute_nsprefix_ = None + if grave is None: + self.grave = [] + else: + self.grave = grave + self.grave_nsprefix_ = None + if circ is None: + self.circ = [] + else: + self.circ = circ + self.circ_nsprefix_ = None + if slash is None: + self.slash = [] + else: + self.slash = slash + self.slash_nsprefix_ = None + if tilde is None: + self.tilde = [] + else: + self.tilde = tilde + self.tilde_nsprefix_ = None + if cedil is None: + self.cedil = [] + else: + self.cedil = cedil + self.cedil_nsprefix_ = None + if ring is None: + self.ring = [] + else: + self.ring = ring + self.ring_nsprefix_ = None + if szlig is None: + self.szlig = [] + else: + self.szlig = szlig + self.szlig_nsprefix_ = None + if nonbreakablespace is None: + self.nonbreakablespace = [] + else: + self.nonbreakablespace = nonbreakablespace + self.nonbreakablespace_nsprefix_ = None + if aelig is None: + self.aelig = [] + else: + self.aelig = aelig + self.aelig_nsprefix_ = None + if AElig is None: + self.AElig = [] + else: + self.AElig = AElig + self.AElig_nsprefix_ = None + if Gamma is None: + self.Gamma = [] + else: + self.Gamma = Gamma + self.Gamma_nsprefix_ = None + if Delta is None: + self.Delta = [] + else: + self.Delta = Delta + self.Delta_nsprefix_ = None + if Theta is None: + self.Theta = [] + else: + self.Theta = Theta + self.Theta_nsprefix_ = None + if Lambda is None: + self.Lambda = [] + else: + self.Lambda = Lambda + self.Lambda_nsprefix_ = None + if Xi is None: + self.Xi = [] + else: + self.Xi = Xi + self.Xi_nsprefix_ = None + if Pi is None: + self.Pi = [] + else: + self.Pi = Pi + self.Pi_nsprefix_ = None + if Sigma is None: + self.Sigma = [] + else: + self.Sigma = Sigma + self.Sigma_nsprefix_ = None + if Upsilon is None: + self.Upsilon = [] + else: + self.Upsilon = Upsilon + self.Upsilon_nsprefix_ = None + if Phi is None: + self.Phi = [] + else: + self.Phi = Phi + self.Phi_nsprefix_ = None + if Psi is None: + self.Psi = [] + else: + self.Psi = Psi + self.Psi_nsprefix_ = None + if Omega is None: + self.Omega = [] + else: + self.Omega = Omega + self.Omega_nsprefix_ = None + if alpha is None: + self.alpha = [] + else: + self.alpha = alpha + self.alpha_nsprefix_ = None + if beta is None: + self.beta = [] + else: + self.beta = beta + self.beta_nsprefix_ = None + if gamma is None: + self.gamma = [] + else: + self.gamma = gamma + self.gamma_nsprefix_ = None + if delta is None: + self.delta = [] + else: + self.delta = delta + self.delta_nsprefix_ = None + if epsilon is None: + self.epsilon = [] + else: + self.epsilon = epsilon + self.epsilon_nsprefix_ = None + if zeta is None: + self.zeta = [] + else: + self.zeta = zeta + self.zeta_nsprefix_ = None + if eta is None: + self.eta = [] + else: + self.eta = eta + self.eta_nsprefix_ = None + if theta is None: + self.theta = [] + else: + self.theta = theta + self.theta_nsprefix_ = None + if iota is None: + self.iota = [] + else: + self.iota = iota + self.iota_nsprefix_ = None + if kappa is None: + self.kappa = [] + else: + self.kappa = kappa + self.kappa_nsprefix_ = None + if lambda_ is None: + self.lambda_ = [] + else: + self.lambda_ = lambda_ + self.lambda__nsprefix_ = None + if mu is None: + self.mu = [] + else: + self.mu = mu + self.mu_nsprefix_ = None + if nu is None: + self.nu = [] + else: + self.nu = nu + self.nu_nsprefix_ = None + if xi is None: + self.xi = [] + else: + self.xi = xi + self.xi_nsprefix_ = None + if pi is None: + self.pi = [] + else: + self.pi = pi + self.pi_nsprefix_ = None + if rho is None: + self.rho = [] + else: + self.rho = rho + self.rho_nsprefix_ = None + if sigma is None: + self.sigma = [] + else: + self.sigma = sigma + self.sigma_nsprefix_ = None + if tau is None: + self.tau = [] + else: + self.tau = tau + self.tau_nsprefix_ = None + if upsilon is None: + self.upsilon = [] + else: + self.upsilon = upsilon + self.upsilon_nsprefix_ = None + if phi is None: + self.phi = [] + else: + self.phi = phi + self.phi_nsprefix_ = None + if chi is None: + self.chi = [] + else: + self.chi = chi + self.chi_nsprefix_ = None + if psi is None: + self.psi = [] + else: + self.psi = psi + self.psi_nsprefix_ = None + if omega is None: + self.omega = [] + else: + self.omega = omega + self.omega_nsprefix_ = None + if sigmaf is None: + self.sigmaf = [] + else: + self.sigmaf = sigmaf + self.sigmaf_nsprefix_ = None + if sect is None: + self.sect = [] + else: + self.sect = sect + self.sect_nsprefix_ = None + if deg is None: + self.deg = [] + else: + self.deg = deg + self.deg_nsprefix_ = None + if prime is None: + self.prime = [] + else: + self.prime = prime + self.prime_nsprefix_ = None + if Prime is None: + self.Prime = [] + else: + self.Prime = Prime + self.Prime_nsprefix_ = None + if infin is None: + self.infin = [] + else: + self.infin = infin + self.infin_nsprefix_ = None + if empty is None: + self.empty = [] + else: + self.empty = empty + self.empty_nsprefix_ = None + if plusmn is None: + self.plusmn = [] + else: + self.plusmn = plusmn + self.plusmn_nsprefix_ = None + if times is None: + self.times = [] + else: + self.times = times + self.times_nsprefix_ = None + if minus is None: + self.minus = [] + else: + self.minus = minus + self.minus_nsprefix_ = None + if sdot is None: + self.sdot = [] + else: + self.sdot = sdot + self.sdot_nsprefix_ = None + if part is None: + self.part = [] + else: + self.part = part + self.part_nsprefix_ = None + if nabla is None: + self.nabla = [] + else: + self.nabla = nabla + self.nabla_nsprefix_ = None + if radic is None: + self.radic = [] + else: + self.radic = radic + self.radic_nsprefix_ = None + if perp is None: + self.perp = [] + else: + self.perp = perp + self.perp_nsprefix_ = None + if sum is None: + self.sum = [] + else: + self.sum = sum + self.sum_nsprefix_ = None + if int is None: + self.int = [] + else: + self.int = int + self.int_nsprefix_ = None + if prod is None: + self.prod = [] + else: + self.prod = prod + self.prod_nsprefix_ = None + if sim is None: + self.sim = [] + else: + self.sim = sim + self.sim_nsprefix_ = None + if asymp is None: + self.asymp = [] + else: + self.asymp = asymp + self.asymp_nsprefix_ = None + if ne is None: + self.ne = [] + else: + self.ne = ne + self.ne_nsprefix_ = None + if equiv is None: + self.equiv = [] + else: + self.equiv = equiv + self.equiv_nsprefix_ = None + if prop is None: + self.prop = [] + else: + self.prop = prop + self.prop_nsprefix_ = None + if le is None: + self.le = [] + else: + self.le = le + self.le_nsprefix_ = None + if ge is None: + self.ge = [] + else: + self.ge = ge + self.ge_nsprefix_ = None + if larr is None: + self.larr = [] + else: + self.larr = larr + self.larr_nsprefix_ = None + if rarr is None: + self.rarr = [] + else: + self.rarr = rarr + self.rarr_nsprefix_ = None + if isin is None: + self.isin = [] + else: + self.isin = isin + self.isin_nsprefix_ = None + if notin is None: + self.notin = [] + else: + self.notin = notin + self.notin_nsprefix_ = None + if lceil is None: + self.lceil = [] + else: + self.lceil = lceil + self.lceil_nsprefix_ = None + if rceil is None: + self.rceil = [] + else: + self.rceil = rceil + self.rceil_nsprefix_ = None + if lfloor is None: + self.lfloor = [] + else: + self.lfloor = lfloor + self.lfloor_nsprefix_ = None + if rfloor is None: + self.rfloor = [] + else: + self.rfloor = rfloor + self.rfloor_nsprefix_ = None + self.valueOf_ = valueOf_ + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + self.valueOf_ = valueOf_ + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docCaptionType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docCaptionType.subclass: + return docCaptionType.subclass(*args_, **kwargs_) + return docCaptionType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + def get_ulink(self): + return self.ulink + def set_ulink(self, ulink): + self.ulink = ulink + def add_ulink(self, value): + self.ulink.append(value) + def insert_ulink_at(self, index, value): + self.ulink.insert(index, value) + def replace_ulink_at(self, index, value): + self.ulink[index] = value + def get_bold(self): + return self.bold + def set_bold(self, bold): + self.bold = bold + def add_bold(self, value): + self.bold.append(value) + def insert_bold_at(self, index, value): + self.bold.insert(index, value) + def replace_bold_at(self, index, value): + self.bold[index] = value + def get_emphasis(self): + return self.emphasis + def set_emphasis(self, emphasis): + self.emphasis = emphasis + def add_emphasis(self, value): + self.emphasis.append(value) + def insert_emphasis_at(self, index, value): + self.emphasis.insert(index, value) + def replace_emphasis_at(self, index, value): + self.emphasis[index] = value + def get_computeroutput(self): + return self.computeroutput + def set_computeroutput(self, computeroutput): + self.computeroutput = computeroutput + def add_computeroutput(self, value): + self.computeroutput.append(value) + def insert_computeroutput_at(self, index, value): + self.computeroutput.insert(index, value) + def replace_computeroutput_at(self, index, value): + self.computeroutput[index] = value + def get_subscript(self): + return self.subscript + def set_subscript(self, subscript): + self.subscript = subscript + def add_subscript(self, value): + self.subscript.append(value) + def insert_subscript_at(self, index, value): + self.subscript.insert(index, value) + def replace_subscript_at(self, index, value): + self.subscript[index] = value + def get_superscript(self): + return self.superscript + def set_superscript(self, superscript): + self.superscript = superscript + def add_superscript(self, value): + self.superscript.append(value) + def insert_superscript_at(self, index, value): + self.superscript.insert(index, value) + def replace_superscript_at(self, index, value): + self.superscript[index] = value + def get_center(self): + return self.center + def set_center(self, center): + self.center = center + def add_center(self, value): + self.center.append(value) + def insert_center_at(self, index, value): + self.center.insert(index, value) + def replace_center_at(self, index, value): + self.center[index] = value + def get_small(self): + return self.small + def set_small(self, small): + self.small = small + def add_small(self, value): + self.small.append(value) + def insert_small_at(self, index, value): + self.small.insert(index, value) + def replace_small_at(self, index, value): + self.small[index] = value + def get_htmlonly(self): + return self.htmlonly + def set_htmlonly(self, htmlonly): + self.htmlonly = htmlonly + def add_htmlonly(self, value): + self.htmlonly.append(value) + def insert_htmlonly_at(self, index, value): + self.htmlonly.insert(index, value) + def replace_htmlonly_at(self, index, value): + self.htmlonly[index] = value + def get_manonly(self): + return self.manonly + def set_manonly(self, manonly): + self.manonly = manonly + def add_manonly(self, value): + self.manonly.append(value) + def insert_manonly_at(self, index, value): + self.manonly.insert(index, value) + def replace_manonly_at(self, index, value): + self.manonly[index] = value + def get_xmlonly(self): + return self.xmlonly + def set_xmlonly(self, xmlonly): + self.xmlonly = xmlonly + def add_xmlonly(self, value): + self.xmlonly.append(value) + def insert_xmlonly_at(self, index, value): + self.xmlonly.insert(index, value) + def replace_xmlonly_at(self, index, value): + self.xmlonly[index] = value + def get_rtfonly(self): + return self.rtfonly + def set_rtfonly(self, rtfonly): + self.rtfonly = rtfonly + def add_rtfonly(self, value): + self.rtfonly.append(value) + def insert_rtfonly_at(self, index, value): + self.rtfonly.insert(index, value) + def replace_rtfonly_at(self, index, value): + self.rtfonly[index] = value + def get_latexonly(self): + return self.latexonly + def set_latexonly(self, latexonly): + self.latexonly = latexonly + def add_latexonly(self, value): + self.latexonly.append(value) + def insert_latexonly_at(self, index, value): + self.latexonly.insert(index, value) + def replace_latexonly_at(self, index, value): + self.latexonly[index] = value + def get_dot(self): + return self.dot + def set_dot(self, dot): + self.dot = dot + def add_dot(self, value): + self.dot.append(value) + def insert_dot_at(self, index, value): + self.dot.insert(index, value) + def replace_dot_at(self, index, value): + self.dot[index] = value + def get_msc(self): + return self.msc + def set_msc(self, msc): + self.msc = msc + def add_msc(self, value): + self.msc.append(value) + def insert_msc_at(self, index, value): + self.msc.insert(index, value) + def replace_msc_at(self, index, value): + self.msc[index] = value + def get_anchor(self): + return self.anchor + def set_anchor(self, anchor): + self.anchor = anchor + def add_anchor(self, value): + self.anchor.append(value) + def insert_anchor_at(self, index, value): + self.anchor.insert(index, value) + def replace_anchor_at(self, index, value): + self.anchor[index] = value + def get_formula(self): + return self.formula + def set_formula(self, formula): + self.formula = formula + def add_formula(self, value): + self.formula.append(value) + def insert_formula_at(self, index, value): + self.formula.insert(index, value) + def replace_formula_at(self, index, value): + self.formula[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_at(self, index, value): + self.ref.insert(index, value) + def replace_ref_at(self, index, value): + self.ref[index] = value + def get_copy(self): + return self.copy + def set_copy(self, copy): + self.copy = copy + def add_copy(self, value): + self.copy.append(value) + def insert_copy_at(self, index, value): + self.copy.insert(index, value) + def replace_copy_at(self, index, value): + self.copy[index] = value + def get_trademark(self): + return self.trademark + def set_trademark(self, trademark): + self.trademark = trademark + def add_trademark(self, value): + self.trademark.append(value) + def insert_trademark_at(self, index, value): + self.trademark.insert(index, value) + def replace_trademark_at(self, index, value): + self.trademark[index] = value + def get_registered(self): + return self.registered + def set_registered(self, registered): + self.registered = registered + def add_registered(self, value): + self.registered.append(value) + def insert_registered_at(self, index, value): + self.registered.insert(index, value) + def replace_registered_at(self, index, value): + self.registered[index] = value + def get_lsquo(self): + return self.lsquo + def set_lsquo(self, lsquo): + self.lsquo = lsquo + def add_lsquo(self, value): + self.lsquo.append(value) + def insert_lsquo_at(self, index, value): + self.lsquo.insert(index, value) + def replace_lsquo_at(self, index, value): + self.lsquo[index] = value + def get_rsquo(self): + return self.rsquo + def set_rsquo(self, rsquo): + self.rsquo = rsquo + def add_rsquo(self, value): + self.rsquo.append(value) + def insert_rsquo_at(self, index, value): + self.rsquo.insert(index, value) + def replace_rsquo_at(self, index, value): + self.rsquo[index] = value + def get_ldquo(self): + return self.ldquo + def set_ldquo(self, ldquo): + self.ldquo = ldquo + def add_ldquo(self, value): + self.ldquo.append(value) + def insert_ldquo_at(self, index, value): + self.ldquo.insert(index, value) + def replace_ldquo_at(self, index, value): + self.ldquo[index] = value + def get_rdquo(self): + return self.rdquo + def set_rdquo(self, rdquo): + self.rdquo = rdquo + def add_rdquo(self, value): + self.rdquo.append(value) + def insert_rdquo_at(self, index, value): + self.rdquo.insert(index, value) + def replace_rdquo_at(self, index, value): + self.rdquo[index] = value + def get_ndash(self): + return self.ndash + def set_ndash(self, ndash): + self.ndash = ndash + def add_ndash(self, value): + self.ndash.append(value) + def insert_ndash_at(self, index, value): + self.ndash.insert(index, value) + def replace_ndash_at(self, index, value): + self.ndash[index] = value + def get_mdash(self): + return self.mdash + def set_mdash(self, mdash): + self.mdash = mdash + def add_mdash(self, value): + self.mdash.append(value) + def insert_mdash_at(self, index, value): + self.mdash.insert(index, value) + def replace_mdash_at(self, index, value): + self.mdash[index] = value + def get_umlaut(self): + return self.umlaut + def set_umlaut(self, umlaut): + self.umlaut = umlaut + def add_umlaut(self, value): + self.umlaut.append(value) + def insert_umlaut_at(self, index, value): + self.umlaut.insert(index, value) + def replace_umlaut_at(self, index, value): + self.umlaut[index] = value + def get_acute(self): + return self.acute + def set_acute(self, acute): + self.acute = acute + def add_acute(self, value): + self.acute.append(value) + def insert_acute_at(self, index, value): + self.acute.insert(index, value) + def replace_acute_at(self, index, value): + self.acute[index] = value + def get_grave(self): + return self.grave + def set_grave(self, grave): + self.grave = grave + def add_grave(self, value): + self.grave.append(value) + def insert_grave_at(self, index, value): + self.grave.insert(index, value) + def replace_grave_at(self, index, value): + self.grave[index] = value + def get_circ(self): + return self.circ + def set_circ(self, circ): + self.circ = circ + def add_circ(self, value): + self.circ.append(value) + def insert_circ_at(self, index, value): + self.circ.insert(index, value) + def replace_circ_at(self, index, value): + self.circ[index] = value + def get_slash(self): + return self.slash + def set_slash(self, slash): + self.slash = slash + def add_slash(self, value): + self.slash.append(value) + def insert_slash_at(self, index, value): + self.slash.insert(index, value) + def replace_slash_at(self, index, value): + self.slash[index] = value + def get_tilde(self): + return self.tilde + def set_tilde(self, tilde): + self.tilde = tilde + def add_tilde(self, value): + self.tilde.append(value) + def insert_tilde_at(self, index, value): + self.tilde.insert(index, value) + def replace_tilde_at(self, index, value): + self.tilde[index] = value + def get_cedil(self): + return self.cedil + def set_cedil(self, cedil): + self.cedil = cedil + def add_cedil(self, value): + self.cedil.append(value) + def insert_cedil_at(self, index, value): + self.cedil.insert(index, value) + def replace_cedil_at(self, index, value): + self.cedil[index] = value + def get_ring(self): + return self.ring + def set_ring(self, ring): + self.ring = ring + def add_ring(self, value): + self.ring.append(value) + def insert_ring_at(self, index, value): + self.ring.insert(index, value) + def replace_ring_at(self, index, value): + self.ring[index] = value + def get_szlig(self): + return self.szlig + def set_szlig(self, szlig): + self.szlig = szlig + def add_szlig(self, value): + self.szlig.append(value) + def insert_szlig_at(self, index, value): + self.szlig.insert(index, value) + def replace_szlig_at(self, index, value): + self.szlig[index] = value + def get_nonbreakablespace(self): + return self.nonbreakablespace + def set_nonbreakablespace(self, nonbreakablespace): + self.nonbreakablespace = nonbreakablespace + def add_nonbreakablespace(self, value): + self.nonbreakablespace.append(value) + def insert_nonbreakablespace_at(self, index, value): + self.nonbreakablespace.insert(index, value) + def replace_nonbreakablespace_at(self, index, value): + self.nonbreakablespace[index] = value + def get_aelig(self): + return self.aelig + def set_aelig(self, aelig): + self.aelig = aelig + def add_aelig(self, value): + self.aelig.append(value) + def insert_aelig_at(self, index, value): + self.aelig.insert(index, value) + def replace_aelig_at(self, index, value): + self.aelig[index] = value + def get_AElig(self): + return self.AElig + def set_AElig(self, AElig): + self.AElig = AElig + def add_AElig(self, value): + self.AElig.append(value) + def insert_AElig_at(self, index, value): + self.AElig.insert(index, value) + def replace_AElig_at(self, index, value): + self.AElig[index] = value + def get_Gamma(self): + return self.Gamma + def set_Gamma(self, Gamma): + self.Gamma = Gamma + def add_Gamma(self, value): + self.Gamma.append(value) + def insert_Gamma_at(self, index, value): + self.Gamma.insert(index, value) + def replace_Gamma_at(self, index, value): + self.Gamma[index] = value + def get_Delta(self): + return self.Delta + def set_Delta(self, Delta): + self.Delta = Delta + def add_Delta(self, value): + self.Delta.append(value) + def insert_Delta_at(self, index, value): + self.Delta.insert(index, value) + def replace_Delta_at(self, index, value): + self.Delta[index] = value + def get_Theta(self): + return self.Theta + def set_Theta(self, Theta): + self.Theta = Theta + def add_Theta(self, value): + self.Theta.append(value) + def insert_Theta_at(self, index, value): + self.Theta.insert(index, value) + def replace_Theta_at(self, index, value): + self.Theta[index] = value + def get_Lambda(self): + return self.Lambda + def set_Lambda(self, Lambda): + self.Lambda = Lambda + def add_Lambda(self, value): + self.Lambda.append(value) + def insert_Lambda_at(self, index, value): + self.Lambda.insert(index, value) + def replace_Lambda_at(self, index, value): + self.Lambda[index] = value + def get_Xi(self): + return self.Xi + def set_Xi(self, Xi): + self.Xi = Xi + def add_Xi(self, value): + self.Xi.append(value) + def insert_Xi_at(self, index, value): + self.Xi.insert(index, value) + def replace_Xi_at(self, index, value): + self.Xi[index] = value + def get_Pi(self): + return self.Pi + def set_Pi(self, Pi): + self.Pi = Pi + def add_Pi(self, value): + self.Pi.append(value) + def insert_Pi_at(self, index, value): + self.Pi.insert(index, value) + def replace_Pi_at(self, index, value): + self.Pi[index] = value + def get_Sigma(self): + return self.Sigma + def set_Sigma(self, Sigma): + self.Sigma = Sigma + def add_Sigma(self, value): + self.Sigma.append(value) + def insert_Sigma_at(self, index, value): + self.Sigma.insert(index, value) + def replace_Sigma_at(self, index, value): + self.Sigma[index] = value + def get_Upsilon(self): + return self.Upsilon + def set_Upsilon(self, Upsilon): + self.Upsilon = Upsilon + def add_Upsilon(self, value): + self.Upsilon.append(value) + def insert_Upsilon_at(self, index, value): + self.Upsilon.insert(index, value) + def replace_Upsilon_at(self, index, value): + self.Upsilon[index] = value + def get_Phi(self): + return self.Phi + def set_Phi(self, Phi): + self.Phi = Phi + def add_Phi(self, value): + self.Phi.append(value) + def insert_Phi_at(self, index, value): + self.Phi.insert(index, value) + def replace_Phi_at(self, index, value): + self.Phi[index] = value + def get_Psi(self): + return self.Psi + def set_Psi(self, Psi): + self.Psi = Psi + def add_Psi(self, value): + self.Psi.append(value) + def insert_Psi_at(self, index, value): + self.Psi.insert(index, value) + def replace_Psi_at(self, index, value): + self.Psi[index] = value + def get_Omega(self): + return self.Omega + def set_Omega(self, Omega): + self.Omega = Omega + def add_Omega(self, value): + self.Omega.append(value) + def insert_Omega_at(self, index, value): + self.Omega.insert(index, value) + def replace_Omega_at(self, index, value): + self.Omega[index] = value + def get_alpha(self): + return self.alpha + def set_alpha(self, alpha): + self.alpha = alpha + def add_alpha(self, value): + self.alpha.append(value) + def insert_alpha_at(self, index, value): + self.alpha.insert(index, value) + def replace_alpha_at(self, index, value): + self.alpha[index] = value + def get_beta(self): + return self.beta + def set_beta(self, beta): + self.beta = beta + def add_beta(self, value): + self.beta.append(value) + def insert_beta_at(self, index, value): + self.beta.insert(index, value) + def replace_beta_at(self, index, value): + self.beta[index] = value + def get_gamma(self): + return self.gamma + def set_gamma(self, gamma): + self.gamma = gamma + def add_gamma(self, value): + self.gamma.append(value) + def insert_gamma_at(self, index, value): + self.gamma.insert(index, value) + def replace_gamma_at(self, index, value): + self.gamma[index] = value + def get_delta(self): + return self.delta + def set_delta(self, delta): + self.delta = delta + def add_delta(self, value): + self.delta.append(value) + def insert_delta_at(self, index, value): + self.delta.insert(index, value) + def replace_delta_at(self, index, value): + self.delta[index] = value + def get_epsilon(self): + return self.epsilon + def set_epsilon(self, epsilon): + self.epsilon = epsilon + def add_epsilon(self, value): + self.epsilon.append(value) + def insert_epsilon_at(self, index, value): + self.epsilon.insert(index, value) + def replace_epsilon_at(self, index, value): + self.epsilon[index] = value + def get_zeta(self): + return self.zeta + def set_zeta(self, zeta): + self.zeta = zeta + def add_zeta(self, value): + self.zeta.append(value) + def insert_zeta_at(self, index, value): + self.zeta.insert(index, value) + def replace_zeta_at(self, index, value): + self.zeta[index] = value + def get_eta(self): + return self.eta + def set_eta(self, eta): + self.eta = eta + def add_eta(self, value): + self.eta.append(value) + def insert_eta_at(self, index, value): + self.eta.insert(index, value) + def replace_eta_at(self, index, value): + self.eta[index] = value + def get_theta(self): + return self.theta + def set_theta(self, theta): + self.theta = theta + def add_theta(self, value): + self.theta.append(value) + def insert_theta_at(self, index, value): + self.theta.insert(index, value) + def replace_theta_at(self, index, value): + self.theta[index] = value + def get_iota(self): + return self.iota + def set_iota(self, iota): + self.iota = iota + def add_iota(self, value): + self.iota.append(value) + def insert_iota_at(self, index, value): + self.iota.insert(index, value) + def replace_iota_at(self, index, value): + self.iota[index] = value + def get_kappa(self): + return self.kappa + def set_kappa(self, kappa): + self.kappa = kappa + def add_kappa(self, value): + self.kappa.append(value) + def insert_kappa_at(self, index, value): + self.kappa.insert(index, value) + def replace_kappa_at(self, index, value): + self.kappa[index] = value + def get_lambda(self): + return self.lambda_ + def set_lambda(self, lambda_): + self.lambda_ = lambda_ + def add_lambda(self, value): + self.lambda_.append(value) + def insert_lambda_at(self, index, value): + self.lambda_.insert(index, value) + def replace_lambda_at(self, index, value): + self.lambda_[index] = value + def get_mu(self): + return self.mu + def set_mu(self, mu): + self.mu = mu + def add_mu(self, value): + self.mu.append(value) + def insert_mu_at(self, index, value): + self.mu.insert(index, value) + def replace_mu_at(self, index, value): + self.mu[index] = value + def get_nu(self): + return self.nu + def set_nu(self, nu): + self.nu = nu + def add_nu(self, value): + self.nu.append(value) + def insert_nu_at(self, index, value): + self.nu.insert(index, value) + def replace_nu_at(self, index, value): + self.nu[index] = value + def get_xi(self): + return self.xi + def set_xi(self, xi): + self.xi = xi + def add_xi(self, value): + self.xi.append(value) + def insert_xi_at(self, index, value): + self.xi.insert(index, value) + def replace_xi_at(self, index, value): + self.xi[index] = value + def get_pi(self): + return self.pi + def set_pi(self, pi): + self.pi = pi + def add_pi(self, value): + self.pi.append(value) + def insert_pi_at(self, index, value): + self.pi.insert(index, value) + def replace_pi_at(self, index, value): + self.pi[index] = value + def get_rho(self): + return self.rho + def set_rho(self, rho): + self.rho = rho + def add_rho(self, value): + self.rho.append(value) + def insert_rho_at(self, index, value): + self.rho.insert(index, value) + def replace_rho_at(self, index, value): + self.rho[index] = value + def get_sigma(self): + return self.sigma + def set_sigma(self, sigma): + self.sigma = sigma + def add_sigma(self, value): + self.sigma.append(value) + def insert_sigma_at(self, index, value): + self.sigma.insert(index, value) + def replace_sigma_at(self, index, value): + self.sigma[index] = value + def get_tau(self): + return self.tau + def set_tau(self, tau): + self.tau = tau + def add_tau(self, value): + self.tau.append(value) + def insert_tau_at(self, index, value): + self.tau.insert(index, value) + def replace_tau_at(self, index, value): + self.tau[index] = value + def get_upsilon(self): + return self.upsilon + def set_upsilon(self, upsilon): + self.upsilon = upsilon + def add_upsilon(self, value): + self.upsilon.append(value) + def insert_upsilon_at(self, index, value): + self.upsilon.insert(index, value) + def replace_upsilon_at(self, index, value): + self.upsilon[index] = value + def get_phi(self): + return self.phi + def set_phi(self, phi): + self.phi = phi + def add_phi(self, value): + self.phi.append(value) + def insert_phi_at(self, index, value): + self.phi.insert(index, value) + def replace_phi_at(self, index, value): + self.phi[index] = value + def get_chi(self): + return self.chi + def set_chi(self, chi): + self.chi = chi + def add_chi(self, value): + self.chi.append(value) + def insert_chi_at(self, index, value): + self.chi.insert(index, value) + def replace_chi_at(self, index, value): + self.chi[index] = value + def get_psi(self): + return self.psi + def set_psi(self, psi): + self.psi = psi + def add_psi(self, value): + self.psi.append(value) + def insert_psi_at(self, index, value): + self.psi.insert(index, value) + def replace_psi_at(self, index, value): + self.psi[index] = value + def get_omega(self): + return self.omega + def set_omega(self, omega): + self.omega = omega + def add_omega(self, value): + self.omega.append(value) + def insert_omega_at(self, index, value): + self.omega.insert(index, value) + def replace_omega_at(self, index, value): + self.omega[index] = value + def get_sigmaf(self): + return self.sigmaf + def set_sigmaf(self, sigmaf): + self.sigmaf = sigmaf + def add_sigmaf(self, value): + self.sigmaf.append(value) + def insert_sigmaf_at(self, index, value): + self.sigmaf.insert(index, value) + def replace_sigmaf_at(self, index, value): + self.sigmaf[index] = value + def get_sect(self): + return self.sect + def set_sect(self, sect): + self.sect = sect + def add_sect(self, value): + self.sect.append(value) + def insert_sect_at(self, index, value): + self.sect.insert(index, value) + def replace_sect_at(self, index, value): + self.sect[index] = value + def get_deg(self): + return self.deg + def set_deg(self, deg): + self.deg = deg + def add_deg(self, value): + self.deg.append(value) + def insert_deg_at(self, index, value): + self.deg.insert(index, value) + def replace_deg_at(self, index, value): + self.deg[index] = value + def get_prime(self): + return self.prime + def set_prime(self, prime): + self.prime = prime + def add_prime(self, value): + self.prime.append(value) + def insert_prime_at(self, index, value): + self.prime.insert(index, value) + def replace_prime_at(self, index, value): + self.prime[index] = value + def get_Prime(self): + return self.Prime + def set_Prime(self, Prime): + self.Prime = Prime + def add_Prime(self, value): + self.Prime.append(value) + def insert_Prime_at(self, index, value): + self.Prime.insert(index, value) + def replace_Prime_at(self, index, value): + self.Prime[index] = value + def get_infin(self): + return self.infin + def set_infin(self, infin): + self.infin = infin + def add_infin(self, value): + self.infin.append(value) + def insert_infin_at(self, index, value): + self.infin.insert(index, value) + def replace_infin_at(self, index, value): + self.infin[index] = value + def get_empty(self): + return self.empty + def set_empty(self, empty): + self.empty = empty + def add_empty(self, value): + self.empty.append(value) + def insert_empty_at(self, index, value): + self.empty.insert(index, value) + def replace_empty_at(self, index, value): + self.empty[index] = value + def get_plusmn(self): + return self.plusmn + def set_plusmn(self, plusmn): + self.plusmn = plusmn + def add_plusmn(self, value): + self.plusmn.append(value) + def insert_plusmn_at(self, index, value): + self.plusmn.insert(index, value) + def replace_plusmn_at(self, index, value): + self.plusmn[index] = value + def get_times(self): + return self.times + def set_times(self, times): + self.times = times + def add_times(self, value): + self.times.append(value) + def insert_times_at(self, index, value): + self.times.insert(index, value) + def replace_times_at(self, index, value): + self.times[index] = value + def get_minus(self): + return self.minus + def set_minus(self, minus): + self.minus = minus + def add_minus(self, value): + self.minus.append(value) + def insert_minus_at(self, index, value): + self.minus.insert(index, value) + def replace_minus_at(self, index, value): + self.minus[index] = value + def get_sdot(self): + return self.sdot + def set_sdot(self, sdot): + self.sdot = sdot + def add_sdot(self, value): + self.sdot.append(value) + def insert_sdot_at(self, index, value): + self.sdot.insert(index, value) + def replace_sdot_at(self, index, value): + self.sdot[index] = value + def get_part(self): + return self.part + def set_part(self, part): + self.part = part + def add_part(self, value): + self.part.append(value) + def insert_part_at(self, index, value): + self.part.insert(index, value) + def replace_part_at(self, index, value): + self.part[index] = value + def get_nabla(self): + return self.nabla + def set_nabla(self, nabla): + self.nabla = nabla + def add_nabla(self, value): + self.nabla.append(value) + def insert_nabla_at(self, index, value): + self.nabla.insert(index, value) + def replace_nabla_at(self, index, value): + self.nabla[index] = value + def get_radic(self): + return self.radic + def set_radic(self, radic): + self.radic = radic + def add_radic(self, value): + self.radic.append(value) + def insert_radic_at(self, index, value): + self.radic.insert(index, value) + def replace_radic_at(self, index, value): + self.radic[index] = value + def get_perp(self): + return self.perp + def set_perp(self, perp): + self.perp = perp + def add_perp(self, value): + self.perp.append(value) + def insert_perp_at(self, index, value): + self.perp.insert(index, value) + def replace_perp_at(self, index, value): + self.perp[index] = value + def get_sum(self): + return self.sum + def set_sum(self, sum): + self.sum = sum + def add_sum(self, value): + self.sum.append(value) + def insert_sum_at(self, index, value): + self.sum.insert(index, value) + def replace_sum_at(self, index, value): + self.sum[index] = value + def get_int(self): + return self.int + def set_int(self, int): + self.int = int + def add_int(self, value): + self.int.append(value) + def insert_int_at(self, index, value): + self.int.insert(index, value) + def replace_int_at(self, index, value): + self.int[index] = value + def get_prod(self): + return self.prod + def set_prod(self, prod): + self.prod = prod + def add_prod(self, value): + self.prod.append(value) + def insert_prod_at(self, index, value): + self.prod.insert(index, value) + def replace_prod_at(self, index, value): + self.prod[index] = value + def get_sim(self): + return self.sim + def set_sim(self, sim): + self.sim = sim + def add_sim(self, value): + self.sim.append(value) + def insert_sim_at(self, index, value): + self.sim.insert(index, value) + def replace_sim_at(self, index, value): + self.sim[index] = value + def get_asymp(self): + return self.asymp + def set_asymp(self, asymp): + self.asymp = asymp + def add_asymp(self, value): + self.asymp.append(value) + def insert_asymp_at(self, index, value): + self.asymp.insert(index, value) + def replace_asymp_at(self, index, value): + self.asymp[index] = value + def get_ne(self): + return self.ne + def set_ne(self, ne): + self.ne = ne + def add_ne(self, value): + self.ne.append(value) + def insert_ne_at(self, index, value): + self.ne.insert(index, value) + def replace_ne_at(self, index, value): + self.ne[index] = value + def get_equiv(self): + return self.equiv + def set_equiv(self, equiv): + self.equiv = equiv + def add_equiv(self, value): + self.equiv.append(value) + def insert_equiv_at(self, index, value): + self.equiv.insert(index, value) + def replace_equiv_at(self, index, value): + self.equiv[index] = value + def get_prop(self): + return self.prop + def set_prop(self, prop): + self.prop = prop + def add_prop(self, value): + self.prop.append(value) + def insert_prop_at(self, index, value): + self.prop.insert(index, value) + def replace_prop_at(self, index, value): + self.prop[index] = value + def get_le(self): + return self.le + def set_le(self, le): + self.le = le + def add_le(self, value): + self.le.append(value) + def insert_le_at(self, index, value): + self.le.insert(index, value) + def replace_le_at(self, index, value): + self.le[index] = value + def get_ge(self): + return self.ge + def set_ge(self, ge): + self.ge = ge + def add_ge(self, value): + self.ge.append(value) + def insert_ge_at(self, index, value): + self.ge.insert(index, value) + def replace_ge_at(self, index, value): + self.ge[index] = value + def get_larr(self): + return self.larr + def set_larr(self, larr): + self.larr = larr + def add_larr(self, value): + self.larr.append(value) + def insert_larr_at(self, index, value): + self.larr.insert(index, value) + def replace_larr_at(self, index, value): + self.larr[index] = value + def get_rarr(self): + return self.rarr + def set_rarr(self, rarr): + self.rarr = rarr + def add_rarr(self, value): + self.rarr.append(value) + def insert_rarr_at(self, index, value): + self.rarr.insert(index, value) + def replace_rarr_at(self, index, value): + self.rarr[index] = value + def get_isin(self): + return self.isin + def set_isin(self, isin): + self.isin = isin + def add_isin(self, value): + self.isin.append(value) + def insert_isin_at(self, index, value): + self.isin.insert(index, value) + def replace_isin_at(self, index, value): + self.isin[index] = value + def get_notin(self): + return self.notin + def set_notin(self, notin): + self.notin = notin + def add_notin(self, value): + self.notin.append(value) + def insert_notin_at(self, index, value): + self.notin.insert(index, value) + def replace_notin_at(self, index, value): + self.notin[index] = value + def get_lceil(self): + return self.lceil + def set_lceil(self, lceil): + self.lceil = lceil + def add_lceil(self, value): + self.lceil.append(value) + def insert_lceil_at(self, index, value): + self.lceil.insert(index, value) + def replace_lceil_at(self, index, value): + self.lceil[index] = value + def get_rceil(self): + return self.rceil + def set_rceil(self, rceil): + self.rceil = rceil + def add_rceil(self, value): + self.rceil.append(value) + def insert_rceil_at(self, index, value): + self.rceil.insert(index, value) + def replace_rceil_at(self, index, value): + self.rceil[index] = value + def get_lfloor(self): + return self.lfloor + def set_lfloor(self, lfloor): + self.lfloor = lfloor + def add_lfloor(self, value): + self.lfloor.append(value) + def insert_lfloor_at(self, index, value): + self.lfloor.insert(index, value) + def replace_lfloor_at(self, index, value): + self.lfloor[index] = value + def get_rfloor(self): + return self.rfloor + def set_rfloor(self, rfloor): + self.rfloor = rfloor + def add_rfloor(self, value): + self.rfloor.append(value) + def insert_rfloor_at(self, index, value): + self.rfloor.insert(index, value) + def replace_rfloor_at(self, index, value): + self.rfloor[index] = value + def get_valueOf_(self): return self.valueOf_ + def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def hasContent_(self): + if ( + self.ulink or + self.bold or + self.emphasis or + self.computeroutput or + self.subscript or + self.superscript or + self.center or + self.small or + self.htmlonly or + self.manonly or + self.xmlonly or + self.rtfonly or + self.latexonly or + self.dot or + self.msc or + self.anchor or + self.formula or + self.ref or + self.copy or + self.trademark or + self.registered or + self.lsquo or + self.rsquo or + self.ldquo or + self.rdquo or + self.ndash or + self.mdash or + self.umlaut or + self.acute or + self.grave or + self.circ or + self.slash or + self.tilde or + self.cedil or + self.ring or + self.szlig or + self.nonbreakablespace or + self.aelig or + self.AElig or + self.Gamma or + self.Delta or + self.Theta or + self.Lambda or + self.Xi or + self.Pi or + self.Sigma or + self.Upsilon or + self.Phi or + self.Psi or + self.Omega or + self.alpha or + self.beta or + self.gamma or + self.delta or + self.epsilon or + self.zeta or + self.eta or + self.theta or + self.iota or + self.kappa or + self.lambda_ or + self.mu or + self.nu or + self.xi or + self.pi or + self.rho or + self.sigma or + self.tau or + self.upsilon or + self.phi or + self.chi or + self.psi or + self.omega or + self.sigmaf or + self.sect or + self.deg or + self.prime or + self.Prime or + self.infin or + self.empty or + self.plusmn or + self.times or + self.minus or + self.sdot or + self.part or + self.nabla or + self.radic or + self.perp or + self.sum or + self.int or + self.prod or + self.sim or + self.asymp or + self.ne or + self.equiv or + self.prop or + self.le or + self.ge or + self.larr or + self.rarr or + self.isin or + self.notin or + self.lceil or + self.rceil or + self.lfloor or + self.rfloor or + (1 if type(self.valueOf_) in [int,float] else self.valueOf_) or + self.content_ + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docCaptionType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docCaptionType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docCaptionType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docCaptionType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docCaptionType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docCaptionType'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docCaptionType', fromsubclass_=False, pretty_print=True): + if not fromsubclass_: + for item_ in self.content_: + item_.export(outfile, level, item_.name, namespaceprefix_, pretty_print=pretty_print) + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for ulink_ in self.ulink: + namespaceprefix_ = self.ulink_nsprefix_ + ':' if (UseCapturedNS_ and self.ulink_nsprefix_) else '' + ulink_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ulink', pretty_print=pretty_print) + for bold_ in self.bold: + namespaceprefix_ = self.bold_nsprefix_ + ':' if (UseCapturedNS_ and self.bold_nsprefix_) else '' + bold_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='bold', pretty_print=pretty_print) + for emphasis_ in self.emphasis: + namespaceprefix_ = self.emphasis_nsprefix_ + ':' if (UseCapturedNS_ and self.emphasis_nsprefix_) else '' + emphasis_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='emphasis', pretty_print=pretty_print) + for computeroutput_ in self.computeroutput: + namespaceprefix_ = self.computeroutput_nsprefix_ + ':' if (UseCapturedNS_ and self.computeroutput_nsprefix_) else '' + computeroutput_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='computeroutput', pretty_print=pretty_print) + for subscript_ in self.subscript: + namespaceprefix_ = self.subscript_nsprefix_ + ':' if (UseCapturedNS_ and self.subscript_nsprefix_) else '' + subscript_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='subscript', pretty_print=pretty_print) + for superscript_ in self.superscript: + namespaceprefix_ = self.superscript_nsprefix_ + ':' if (UseCapturedNS_ and self.superscript_nsprefix_) else '' + superscript_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='superscript', pretty_print=pretty_print) + for center_ in self.center: + namespaceprefix_ = self.center_nsprefix_ + ':' if (UseCapturedNS_ and self.center_nsprefix_) else '' + center_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='center', pretty_print=pretty_print) + for small_ in self.small: + namespaceprefix_ = self.small_nsprefix_ + ':' if (UseCapturedNS_ and self.small_nsprefix_) else '' + small_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='small', pretty_print=pretty_print) + for htmlonly_ in self.htmlonly: + namespaceprefix_ = self.htmlonly_nsprefix_ + ':' if (UseCapturedNS_ and self.htmlonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%shtmlonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(htmlonly_), input_name='htmlonly')), namespaceprefix_ , eol_)) + for manonly_ in self.manonly: + namespaceprefix_ = self.manonly_nsprefix_ + ':' if (UseCapturedNS_ and self.manonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%smanonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(manonly_), input_name='manonly')), namespaceprefix_ , eol_)) + for xmlonly_ in self.xmlonly: + namespaceprefix_ = self.xmlonly_nsprefix_ + ':' if (UseCapturedNS_ and self.xmlonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%sxmlonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(xmlonly_), input_name='xmlonly')), namespaceprefix_ , eol_)) + for rtfonly_ in self.rtfonly: + namespaceprefix_ = self.rtfonly_nsprefix_ + ':' if (UseCapturedNS_ and self.rtfonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%srtfonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(rtfonly_), input_name='rtfonly')), namespaceprefix_ , eol_)) + for latexonly_ in self.latexonly: + namespaceprefix_ = self.latexonly_nsprefix_ + ':' if (UseCapturedNS_ and self.latexonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%slatexonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(latexonly_), input_name='latexonly')), namespaceprefix_ , eol_)) + for dot_ in self.dot: + namespaceprefix_ = self.dot_nsprefix_ + ':' if (UseCapturedNS_ and self.dot_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%sdot>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(dot_), input_name='dot')), namespaceprefix_ , eol_)) + for msc_ in self.msc: + namespaceprefix_ = self.msc_nsprefix_ + ':' if (UseCapturedNS_ and self.msc_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%smsc>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(msc_), input_name='msc')), namespaceprefix_ , eol_)) + for anchor_ in self.anchor: + namespaceprefix_ = self.anchor_nsprefix_ + ':' if (UseCapturedNS_ and self.anchor_nsprefix_) else '' + anchor_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='anchor', pretty_print=pretty_print) + for formula_ in self.formula: + namespaceprefix_ = self.formula_nsprefix_ + ':' if (UseCapturedNS_ and self.formula_nsprefix_) else '' + formula_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='formula', pretty_print=pretty_print) + for ref_ in self.ref: + namespaceprefix_ = self.ref_nsprefix_ + ':' if (UseCapturedNS_ and self.ref_nsprefix_) else '' + ref_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ref', pretty_print=pretty_print) + for copy_ in self.copy: + namespaceprefix_ = self.copy_nsprefix_ + ':' if (UseCapturedNS_ and self.copy_nsprefix_) else '' + copy_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='copy', pretty_print=pretty_print) + for trademark_ in self.trademark: + namespaceprefix_ = self.trademark_nsprefix_ + ':' if (UseCapturedNS_ and self.trademark_nsprefix_) else '' + trademark_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='trademark', pretty_print=pretty_print) + for registered_ in self.registered: + namespaceprefix_ = self.registered_nsprefix_ + ':' if (UseCapturedNS_ and self.registered_nsprefix_) else '' + registered_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='registered', pretty_print=pretty_print) + for lsquo_ in self.lsquo: + namespaceprefix_ = self.lsquo_nsprefix_ + ':' if (UseCapturedNS_ and self.lsquo_nsprefix_) else '' + lsquo_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='lsquo', pretty_print=pretty_print) + for rsquo_ in self.rsquo: + namespaceprefix_ = self.rsquo_nsprefix_ + ':' if (UseCapturedNS_ and self.rsquo_nsprefix_) else '' + rsquo_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rsquo', pretty_print=pretty_print) + for ldquo_ in self.ldquo: + namespaceprefix_ = self.ldquo_nsprefix_ + ':' if (UseCapturedNS_ and self.ldquo_nsprefix_) else '' + ldquo_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ldquo', pretty_print=pretty_print) + for rdquo_ in self.rdquo: + namespaceprefix_ = self.rdquo_nsprefix_ + ':' if (UseCapturedNS_ and self.rdquo_nsprefix_) else '' + rdquo_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rdquo', pretty_print=pretty_print) + for ndash_ in self.ndash: + namespaceprefix_ = self.ndash_nsprefix_ + ':' if (UseCapturedNS_ and self.ndash_nsprefix_) else '' + ndash_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ndash', pretty_print=pretty_print) + for mdash_ in self.mdash: + namespaceprefix_ = self.mdash_nsprefix_ + ':' if (UseCapturedNS_ and self.mdash_nsprefix_) else '' + mdash_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='mdash', pretty_print=pretty_print) + for umlaut_ in self.umlaut: + namespaceprefix_ = self.umlaut_nsprefix_ + ':' if (UseCapturedNS_ and self.umlaut_nsprefix_) else '' + umlaut_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='umlaut', pretty_print=pretty_print) + for acute_ in self.acute: + namespaceprefix_ = self.acute_nsprefix_ + ':' if (UseCapturedNS_ and self.acute_nsprefix_) else '' + acute_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='acute', pretty_print=pretty_print) + for grave_ in self.grave: + namespaceprefix_ = self.grave_nsprefix_ + ':' if (UseCapturedNS_ and self.grave_nsprefix_) else '' + grave_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='grave', pretty_print=pretty_print) + for circ_ in self.circ: + namespaceprefix_ = self.circ_nsprefix_ + ':' if (UseCapturedNS_ and self.circ_nsprefix_) else '' + circ_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='circ', pretty_print=pretty_print) + for slash_ in self.slash: + namespaceprefix_ = self.slash_nsprefix_ + ':' if (UseCapturedNS_ and self.slash_nsprefix_) else '' + slash_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='slash', pretty_print=pretty_print) + for tilde_ in self.tilde: + namespaceprefix_ = self.tilde_nsprefix_ + ':' if (UseCapturedNS_ and self.tilde_nsprefix_) else '' + tilde_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='tilde', pretty_print=pretty_print) + for cedil_ in self.cedil: + namespaceprefix_ = self.cedil_nsprefix_ + ':' if (UseCapturedNS_ and self.cedil_nsprefix_) else '' + cedil_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='cedil', pretty_print=pretty_print) + for ring_ in self.ring: + namespaceprefix_ = self.ring_nsprefix_ + ':' if (UseCapturedNS_ and self.ring_nsprefix_) else '' + ring_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ring', pretty_print=pretty_print) + for szlig_ in self.szlig: + namespaceprefix_ = self.szlig_nsprefix_ + ':' if (UseCapturedNS_ and self.szlig_nsprefix_) else '' + szlig_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='szlig', pretty_print=pretty_print) + for nonbreakablespace_ in self.nonbreakablespace: + namespaceprefix_ = self.nonbreakablespace_nsprefix_ + ':' if (UseCapturedNS_ and self.nonbreakablespace_nsprefix_) else '' + nonbreakablespace_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='nonbreakablespace', pretty_print=pretty_print) + for aelig_ in self.aelig: + namespaceprefix_ = self.aelig_nsprefix_ + ':' if (UseCapturedNS_ and self.aelig_nsprefix_) else '' + aelig_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='aelig', pretty_print=pretty_print) + for AElig_ in self.AElig: + namespaceprefix_ = self.AElig_nsprefix_ + ':' if (UseCapturedNS_ and self.AElig_nsprefix_) else '' + AElig_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='AElig', pretty_print=pretty_print) + for Gamma_ in self.Gamma: + namespaceprefix_ = self.Gamma_nsprefix_ + ':' if (UseCapturedNS_ and self.Gamma_nsprefix_) else '' + Gamma_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Gamma', pretty_print=pretty_print) + for Delta_ in self.Delta: + namespaceprefix_ = self.Delta_nsprefix_ + ':' if (UseCapturedNS_ and self.Delta_nsprefix_) else '' + Delta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Delta', pretty_print=pretty_print) + for Theta_ in self.Theta: + namespaceprefix_ = self.Theta_nsprefix_ + ':' if (UseCapturedNS_ and self.Theta_nsprefix_) else '' + Theta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Theta', pretty_print=pretty_print) + for Lambda_ in self.Lambda: + namespaceprefix_ = self.Lambda_nsprefix_ + ':' if (UseCapturedNS_ and self.Lambda_nsprefix_) else '' + Lambda_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Lambda', pretty_print=pretty_print) + for Xi_ in self.Xi: + namespaceprefix_ = self.Xi_nsprefix_ + ':' if (UseCapturedNS_ and self.Xi_nsprefix_) else '' + Xi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Xi', pretty_print=pretty_print) + for Pi_ in self.Pi: + namespaceprefix_ = self.Pi_nsprefix_ + ':' if (UseCapturedNS_ and self.Pi_nsprefix_) else '' + Pi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Pi', pretty_print=pretty_print) + for Sigma_ in self.Sigma: + namespaceprefix_ = self.Sigma_nsprefix_ + ':' if (UseCapturedNS_ and self.Sigma_nsprefix_) else '' + Sigma_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Sigma', pretty_print=pretty_print) + for Upsilon_ in self.Upsilon: + namespaceprefix_ = self.Upsilon_nsprefix_ + ':' if (UseCapturedNS_ and self.Upsilon_nsprefix_) else '' + Upsilon_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Upsilon', pretty_print=pretty_print) + for Phi_ in self.Phi: + namespaceprefix_ = self.Phi_nsprefix_ + ':' if (UseCapturedNS_ and self.Phi_nsprefix_) else '' + Phi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Phi', pretty_print=pretty_print) + for Psi_ in self.Psi: + namespaceprefix_ = self.Psi_nsprefix_ + ':' if (UseCapturedNS_ and self.Psi_nsprefix_) else '' + Psi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Psi', pretty_print=pretty_print) + for Omega_ in self.Omega: + namespaceprefix_ = self.Omega_nsprefix_ + ':' if (UseCapturedNS_ and self.Omega_nsprefix_) else '' + Omega_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Omega', pretty_print=pretty_print) + for alpha_ in self.alpha: + namespaceprefix_ = self.alpha_nsprefix_ + ':' if (UseCapturedNS_ and self.alpha_nsprefix_) else '' + alpha_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='alpha', pretty_print=pretty_print) + for beta_ in self.beta: + namespaceprefix_ = self.beta_nsprefix_ + ':' if (UseCapturedNS_ and self.beta_nsprefix_) else '' + beta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='beta', pretty_print=pretty_print) + for gamma_ in self.gamma: + namespaceprefix_ = self.gamma_nsprefix_ + ':' if (UseCapturedNS_ and self.gamma_nsprefix_) else '' + gamma_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='gamma', pretty_print=pretty_print) + for delta_ in self.delta: + namespaceprefix_ = self.delta_nsprefix_ + ':' if (UseCapturedNS_ and self.delta_nsprefix_) else '' + delta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='delta', pretty_print=pretty_print) + for epsilon_ in self.epsilon: + namespaceprefix_ = self.epsilon_nsprefix_ + ':' if (UseCapturedNS_ and self.epsilon_nsprefix_) else '' + epsilon_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='epsilon', pretty_print=pretty_print) + for zeta_ in self.zeta: + namespaceprefix_ = self.zeta_nsprefix_ + ':' if (UseCapturedNS_ and self.zeta_nsprefix_) else '' + zeta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='zeta', pretty_print=pretty_print) + for eta_ in self.eta: + namespaceprefix_ = self.eta_nsprefix_ + ':' if (UseCapturedNS_ and self.eta_nsprefix_) else '' + eta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='eta', pretty_print=pretty_print) + for theta_ in self.theta: + namespaceprefix_ = self.theta_nsprefix_ + ':' if (UseCapturedNS_ and self.theta_nsprefix_) else '' + theta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='theta', pretty_print=pretty_print) + for iota_ in self.iota: + namespaceprefix_ = self.iota_nsprefix_ + ':' if (UseCapturedNS_ and self.iota_nsprefix_) else '' + iota_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='iota', pretty_print=pretty_print) + for kappa_ in self.kappa: + namespaceprefix_ = self.kappa_nsprefix_ + ':' if (UseCapturedNS_ and self.kappa_nsprefix_) else '' + kappa_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='kappa', pretty_print=pretty_print) + for lambda_ in self.lambda_: + namespaceprefix_ = self.lambda__nsprefix_ + ':' if (UseCapturedNS_ and self.lambda__nsprefix_) else '' + lambda_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='lambda', pretty_print=pretty_print) + for mu_ in self.mu: + namespaceprefix_ = self.mu_nsprefix_ + ':' if (UseCapturedNS_ and self.mu_nsprefix_) else '' + mu_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='mu', pretty_print=pretty_print) + for nu_ in self.nu: + namespaceprefix_ = self.nu_nsprefix_ + ':' if (UseCapturedNS_ and self.nu_nsprefix_) else '' + nu_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='nu', pretty_print=pretty_print) + for xi_ in self.xi: + namespaceprefix_ = self.xi_nsprefix_ + ':' if (UseCapturedNS_ and self.xi_nsprefix_) else '' + xi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='xi', pretty_print=pretty_print) + for pi_ in self.pi: + namespaceprefix_ = self.pi_nsprefix_ + ':' if (UseCapturedNS_ and self.pi_nsprefix_) else '' + pi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='pi', pretty_print=pretty_print) + for rho_ in self.rho: + namespaceprefix_ = self.rho_nsprefix_ + ':' if (UseCapturedNS_ and self.rho_nsprefix_) else '' + rho_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rho', pretty_print=pretty_print) + for sigma_ in self.sigma: + namespaceprefix_ = self.sigma_nsprefix_ + ':' if (UseCapturedNS_ and self.sigma_nsprefix_) else '' + sigma_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sigma', pretty_print=pretty_print) + for tau_ in self.tau: + namespaceprefix_ = self.tau_nsprefix_ + ':' if (UseCapturedNS_ and self.tau_nsprefix_) else '' + tau_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='tau', pretty_print=pretty_print) + for upsilon_ in self.upsilon: + namespaceprefix_ = self.upsilon_nsprefix_ + ':' if (UseCapturedNS_ and self.upsilon_nsprefix_) else '' + upsilon_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='upsilon', pretty_print=pretty_print) + for phi_ in self.phi: + namespaceprefix_ = self.phi_nsprefix_ + ':' if (UseCapturedNS_ and self.phi_nsprefix_) else '' + phi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='phi', pretty_print=pretty_print) + for chi_ in self.chi: + namespaceprefix_ = self.chi_nsprefix_ + ':' if (UseCapturedNS_ and self.chi_nsprefix_) else '' + chi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='chi', pretty_print=pretty_print) + for psi_ in self.psi: + namespaceprefix_ = self.psi_nsprefix_ + ':' if (UseCapturedNS_ and self.psi_nsprefix_) else '' + psi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='psi', pretty_print=pretty_print) + for omega_ in self.omega: + namespaceprefix_ = self.omega_nsprefix_ + ':' if (UseCapturedNS_ and self.omega_nsprefix_) else '' + omega_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='omega', pretty_print=pretty_print) + for sigmaf_ in self.sigmaf: + namespaceprefix_ = self.sigmaf_nsprefix_ + ':' if (UseCapturedNS_ and self.sigmaf_nsprefix_) else '' + sigmaf_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sigmaf', pretty_print=pretty_print) + for sect_ in self.sect: + namespaceprefix_ = self.sect_nsprefix_ + ':' if (UseCapturedNS_ and self.sect_nsprefix_) else '' + sect_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sect', pretty_print=pretty_print) + for deg_ in self.deg: + namespaceprefix_ = self.deg_nsprefix_ + ':' if (UseCapturedNS_ and self.deg_nsprefix_) else '' + deg_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='deg', pretty_print=pretty_print) + for prime_ in self.prime: + namespaceprefix_ = self.prime_nsprefix_ + ':' if (UseCapturedNS_ and self.prime_nsprefix_) else '' + prime_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='prime', pretty_print=pretty_print) + for Prime_ in self.Prime: + namespaceprefix_ = self.Prime_nsprefix_ + ':' if (UseCapturedNS_ and self.Prime_nsprefix_) else '' + Prime_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Prime', pretty_print=pretty_print) + for infin_ in self.infin: + namespaceprefix_ = self.infin_nsprefix_ + ':' if (UseCapturedNS_ and self.infin_nsprefix_) else '' + infin_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='infin', pretty_print=pretty_print) + for empty_ in self.empty: + namespaceprefix_ = self.empty_nsprefix_ + ':' if (UseCapturedNS_ and self.empty_nsprefix_) else '' + empty_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='empty', pretty_print=pretty_print) + for plusmn_ in self.plusmn: + namespaceprefix_ = self.plusmn_nsprefix_ + ':' if (UseCapturedNS_ and self.plusmn_nsprefix_) else '' + plusmn_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='plusmn', pretty_print=pretty_print) + for times_ in self.times: + namespaceprefix_ = self.times_nsprefix_ + ':' if (UseCapturedNS_ and self.times_nsprefix_) else '' + times_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='times', pretty_print=pretty_print) + for minus_ in self.minus: + namespaceprefix_ = self.minus_nsprefix_ + ':' if (UseCapturedNS_ and self.minus_nsprefix_) else '' + minus_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='minus', pretty_print=pretty_print) + for sdot_ in self.sdot: + namespaceprefix_ = self.sdot_nsprefix_ + ':' if (UseCapturedNS_ and self.sdot_nsprefix_) else '' + sdot_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sdot', pretty_print=pretty_print) + for part_ in self.part: + namespaceprefix_ = self.part_nsprefix_ + ':' if (UseCapturedNS_ and self.part_nsprefix_) else '' + part_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='part', pretty_print=pretty_print) + for nabla_ in self.nabla: + namespaceprefix_ = self.nabla_nsprefix_ + ':' if (UseCapturedNS_ and self.nabla_nsprefix_) else '' + nabla_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='nabla', pretty_print=pretty_print) + for radic_ in self.radic: + namespaceprefix_ = self.radic_nsprefix_ + ':' if (UseCapturedNS_ and self.radic_nsprefix_) else '' + radic_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='radic', pretty_print=pretty_print) + for perp_ in self.perp: + namespaceprefix_ = self.perp_nsprefix_ + ':' if (UseCapturedNS_ and self.perp_nsprefix_) else '' + perp_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='perp', pretty_print=pretty_print) + for sum_ in self.sum: + namespaceprefix_ = self.sum_nsprefix_ + ':' if (UseCapturedNS_ and self.sum_nsprefix_) else '' + sum_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sum', pretty_print=pretty_print) + for int_ in self.int: + namespaceprefix_ = self.int_nsprefix_ + ':' if (UseCapturedNS_ and self.int_nsprefix_) else '' + int_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='int', pretty_print=pretty_print) + for prod_ in self.prod: + namespaceprefix_ = self.prod_nsprefix_ + ':' if (UseCapturedNS_ and self.prod_nsprefix_) else '' + prod_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='prod', pretty_print=pretty_print) + for sim_ in self.sim: + namespaceprefix_ = self.sim_nsprefix_ + ':' if (UseCapturedNS_ and self.sim_nsprefix_) else '' + sim_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sim', pretty_print=pretty_print) + for asymp_ in self.asymp: + namespaceprefix_ = self.asymp_nsprefix_ + ':' if (UseCapturedNS_ and self.asymp_nsprefix_) else '' + asymp_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='asymp', pretty_print=pretty_print) + for ne_ in self.ne: + namespaceprefix_ = self.ne_nsprefix_ + ':' if (UseCapturedNS_ and self.ne_nsprefix_) else '' + ne_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ne', pretty_print=pretty_print) + for equiv_ in self.equiv: + namespaceprefix_ = self.equiv_nsprefix_ + ':' if (UseCapturedNS_ and self.equiv_nsprefix_) else '' + equiv_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='equiv', pretty_print=pretty_print) + for prop_ in self.prop: + namespaceprefix_ = self.prop_nsprefix_ + ':' if (UseCapturedNS_ and self.prop_nsprefix_) else '' + prop_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='prop', pretty_print=pretty_print) + for le_ in self.le: + namespaceprefix_ = self.le_nsprefix_ + ':' if (UseCapturedNS_ and self.le_nsprefix_) else '' + le_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='le', pretty_print=pretty_print) + for ge_ in self.ge: + namespaceprefix_ = self.ge_nsprefix_ + ':' if (UseCapturedNS_ and self.ge_nsprefix_) else '' + ge_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ge', pretty_print=pretty_print) + for larr_ in self.larr: + namespaceprefix_ = self.larr_nsprefix_ + ':' if (UseCapturedNS_ and self.larr_nsprefix_) else '' + larr_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='larr', pretty_print=pretty_print) + for rarr_ in self.rarr: + namespaceprefix_ = self.rarr_nsprefix_ + ':' if (UseCapturedNS_ and self.rarr_nsprefix_) else '' + rarr_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rarr', pretty_print=pretty_print) + for isin_ in self.isin: + namespaceprefix_ = self.isin_nsprefix_ + ':' if (UseCapturedNS_ and self.isin_nsprefix_) else '' + isin_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='isin', pretty_print=pretty_print) + for notin_ in self.notin: + namespaceprefix_ = self.notin_nsprefix_ + ':' if (UseCapturedNS_ and self.notin_nsprefix_) else '' + notin_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='notin', pretty_print=pretty_print) + for lceil_ in self.lceil: + namespaceprefix_ = self.lceil_nsprefix_ + ':' if (UseCapturedNS_ and self.lceil_nsprefix_) else '' + lceil_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='lceil', pretty_print=pretty_print) + for rceil_ in self.rceil: + namespaceprefix_ = self.rceil_nsprefix_ + ':' if (UseCapturedNS_ and self.rceil_nsprefix_) else '' + rceil_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rceil', pretty_print=pretty_print) + for lfloor_ in self.lfloor: + namespaceprefix_ = self.lfloor_nsprefix_ + ':' if (UseCapturedNS_ and self.lfloor_nsprefix_) else '' + lfloor_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='lfloor', pretty_print=pretty_print) + for rfloor_ in self.rfloor: + namespaceprefix_ = self.rfloor_nsprefix_ + ':' if (UseCapturedNS_ and self.rfloor_nsprefix_) else '' + rfloor_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rfloor', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + self.valueOf_ = get_all_text_(node) + if node.text is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', node.text) + self.content_.append(obj_) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'ulink': + obj_ = docURLLink.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ulink', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ulink'): + self.add_ulink(obj_.value) + elif hasattr(self, 'set_ulink'): + self.set_ulink(obj_.value) + elif nodeName_ == 'bold': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'bold', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_bold'): + self.add_bold(obj_.value) + elif hasattr(self, 'set_bold'): + self.set_bold(obj_.value) + elif nodeName_ == 'emphasis': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'emphasis', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_emphasis'): + self.add_emphasis(obj_.value) + elif hasattr(self, 'set_emphasis'): + self.set_emphasis(obj_.value) + elif nodeName_ == 'computeroutput': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'computeroutput', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_computeroutput'): + self.add_computeroutput(obj_.value) + elif hasattr(self, 'set_computeroutput'): + self.set_computeroutput(obj_.value) + elif nodeName_ == 'subscript': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'subscript', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_subscript'): + self.add_subscript(obj_.value) + elif hasattr(self, 'set_subscript'): + self.set_subscript(obj_.value) + elif nodeName_ == 'superscript': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'superscript', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_superscript'): + self.add_superscript(obj_.value) + elif hasattr(self, 'set_superscript'): + self.set_superscript(obj_.value) + elif nodeName_ == 'center': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'center', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_center'): + self.add_center(obj_.value) + elif hasattr(self, 'set_center'): + self.set_center(obj_.value) + elif nodeName_ == 'small': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'small', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_small'): + self.add_small(obj_.value) + elif hasattr(self, 'set_small'): + self.set_small(obj_.value) + elif nodeName_ == 'htmlonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'htmlonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'htmlonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'htmlonly', valuestr_) + self.content_.append(obj_) + self.htmlonly_nsprefix_ = child_.prefix + elif nodeName_ == 'manonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'manonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'manonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'manonly', valuestr_) + self.content_.append(obj_) + self.manonly_nsprefix_ = child_.prefix + elif nodeName_ == 'xmlonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'xmlonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'xmlonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'xmlonly', valuestr_) + self.content_.append(obj_) + self.xmlonly_nsprefix_ = child_.prefix + elif nodeName_ == 'rtfonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'rtfonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'rtfonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'rtfonly', valuestr_) + self.content_.append(obj_) + self.rtfonly_nsprefix_ = child_.prefix + elif nodeName_ == 'latexonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'latexonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'latexonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'latexonly', valuestr_) + self.content_.append(obj_) + self.latexonly_nsprefix_ = child_.prefix + elif nodeName_ == 'dot' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'dot') + valuestr_ = self.gds_validate_string(valuestr_, node, 'dot') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'dot', valuestr_) + self.content_.append(obj_) + self.dot_nsprefix_ = child_.prefix + elif nodeName_ == 'msc' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'msc') + valuestr_ = self.gds_validate_string(valuestr_, node, 'msc') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'msc', valuestr_) + self.content_.append(obj_) + self.msc_nsprefix_ = child_.prefix + elif nodeName_ == 'anchor': + obj_ = docAnchorType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'anchor', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_anchor'): + self.add_anchor(obj_.value) + elif hasattr(self, 'set_anchor'): + self.set_anchor(obj_.value) + elif nodeName_ == 'formula': + obj_ = docFormulaType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'formula', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_formula'): + self.add_formula(obj_.value) + elif hasattr(self, 'set_formula'): + self.set_formula(obj_.value) + elif nodeName_ == 'ref': + obj_ = docRefTextType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ref', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ref'): + self.add_ref(obj_.value) + elif hasattr(self, 'set_ref'): + self.set_ref(obj_.value) + elif nodeName_ == 'copy': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'copy', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_copy'): + self.add_copy(obj_.value) + elif hasattr(self, 'set_copy'): + self.set_copy(obj_.value) + elif nodeName_ == 'trademark': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'trademark', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_trademark'): + self.add_trademark(obj_.value) + elif hasattr(self, 'set_trademark'): + self.set_trademark(obj_.value) + elif nodeName_ == 'registered': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'registered', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_registered'): + self.add_registered(obj_.value) + elif hasattr(self, 'set_registered'): + self.set_registered(obj_.value) + elif nodeName_ == 'lsquo': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'lsquo', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_lsquo'): + self.add_lsquo(obj_.value) + elif hasattr(self, 'set_lsquo'): + self.set_lsquo(obj_.value) + elif nodeName_ == 'rsquo': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rsquo', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rsquo'): + self.add_rsquo(obj_.value) + elif hasattr(self, 'set_rsquo'): + self.set_rsquo(obj_.value) + elif nodeName_ == 'ldquo': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ldquo', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ldquo'): + self.add_ldquo(obj_.value) + elif hasattr(self, 'set_ldquo'): + self.set_ldquo(obj_.value) + elif nodeName_ == 'rdquo': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rdquo', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rdquo'): + self.add_rdquo(obj_.value) + elif hasattr(self, 'set_rdquo'): + self.set_rdquo(obj_.value) + elif nodeName_ == 'ndash': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ndash', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ndash'): + self.add_ndash(obj_.value) + elif hasattr(self, 'set_ndash'): + self.set_ndash(obj_.value) + elif nodeName_ == 'mdash': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'mdash', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_mdash'): + self.add_mdash(obj_.value) + elif hasattr(self, 'set_mdash'): + self.set_mdash(obj_.value) + elif nodeName_ == 'umlaut': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'umlaut', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_umlaut'): + self.add_umlaut(obj_.value) + elif hasattr(self, 'set_umlaut'): + self.set_umlaut(obj_.value) + elif nodeName_ == 'acute': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'acute', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_acute'): + self.add_acute(obj_.value) + elif hasattr(self, 'set_acute'): + self.set_acute(obj_.value) + elif nodeName_ == 'grave': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'grave', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_grave'): + self.add_grave(obj_.value) + elif hasattr(self, 'set_grave'): + self.set_grave(obj_.value) + elif nodeName_ == 'circ': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'circ', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_circ'): + self.add_circ(obj_.value) + elif hasattr(self, 'set_circ'): + self.set_circ(obj_.value) + elif nodeName_ == 'slash': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'slash', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_slash'): + self.add_slash(obj_.value) + elif hasattr(self, 'set_slash'): + self.set_slash(obj_.value) + elif nodeName_ == 'tilde': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'tilde', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_tilde'): + self.add_tilde(obj_.value) + elif hasattr(self, 'set_tilde'): + self.set_tilde(obj_.value) + elif nodeName_ == 'cedil': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'cedil', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_cedil'): + self.add_cedil(obj_.value) + elif hasattr(self, 'set_cedil'): + self.set_cedil(obj_.value) + elif nodeName_ == 'ring': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ring', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ring'): + self.add_ring(obj_.value) + elif hasattr(self, 'set_ring'): + self.set_ring(obj_.value) + elif nodeName_ == 'szlig': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'szlig', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_szlig'): + self.add_szlig(obj_.value) + elif hasattr(self, 'set_szlig'): + self.set_szlig(obj_.value) + elif nodeName_ == 'nonbreakablespace': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'nonbreakablespace', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_nonbreakablespace'): + self.add_nonbreakablespace(obj_.value) + elif hasattr(self, 'set_nonbreakablespace'): + self.set_nonbreakablespace(obj_.value) + elif nodeName_ == 'aelig': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'aelig', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_aelig'): + self.add_aelig(obj_.value) + elif hasattr(self, 'set_aelig'): + self.set_aelig(obj_.value) + elif nodeName_ == 'AElig': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'AElig', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_AElig'): + self.add_AElig(obj_.value) + elif hasattr(self, 'set_AElig'): + self.set_AElig(obj_.value) + elif nodeName_ == 'Gamma': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Gamma', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Gamma'): + self.add_Gamma(obj_.value) + elif hasattr(self, 'set_Gamma'): + self.set_Gamma(obj_.value) + elif nodeName_ == 'Delta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Delta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Delta'): + self.add_Delta(obj_.value) + elif hasattr(self, 'set_Delta'): + self.set_Delta(obj_.value) + elif nodeName_ == 'Theta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Theta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Theta'): + self.add_Theta(obj_.value) + elif hasattr(self, 'set_Theta'): + self.set_Theta(obj_.value) + elif nodeName_ == 'Lambda': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Lambda', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Lambda'): + self.add_Lambda(obj_.value) + elif hasattr(self, 'set_Lambda'): + self.set_Lambda(obj_.value) + elif nodeName_ == 'Xi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Xi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Xi'): + self.add_Xi(obj_.value) + elif hasattr(self, 'set_Xi'): + self.set_Xi(obj_.value) + elif nodeName_ == 'Pi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Pi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Pi'): + self.add_Pi(obj_.value) + elif hasattr(self, 'set_Pi'): + self.set_Pi(obj_.value) + elif nodeName_ == 'Sigma': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Sigma', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Sigma'): + self.add_Sigma(obj_.value) + elif hasattr(self, 'set_Sigma'): + self.set_Sigma(obj_.value) + elif nodeName_ == 'Upsilon': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Upsilon', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Upsilon'): + self.add_Upsilon(obj_.value) + elif hasattr(self, 'set_Upsilon'): + self.set_Upsilon(obj_.value) + elif nodeName_ == 'Phi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Phi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Phi'): + self.add_Phi(obj_.value) + elif hasattr(self, 'set_Phi'): + self.set_Phi(obj_.value) + elif nodeName_ == 'Psi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Psi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Psi'): + self.add_Psi(obj_.value) + elif hasattr(self, 'set_Psi'): + self.set_Psi(obj_.value) + elif nodeName_ == 'Omega': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Omega', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Omega'): + self.add_Omega(obj_.value) + elif hasattr(self, 'set_Omega'): + self.set_Omega(obj_.value) + elif nodeName_ == 'alpha': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'alpha', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_alpha'): + self.add_alpha(obj_.value) + elif hasattr(self, 'set_alpha'): + self.set_alpha(obj_.value) + elif nodeName_ == 'beta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'beta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_beta'): + self.add_beta(obj_.value) + elif hasattr(self, 'set_beta'): + self.set_beta(obj_.value) + elif nodeName_ == 'gamma': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'gamma', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_gamma'): + self.add_gamma(obj_.value) + elif hasattr(self, 'set_gamma'): + self.set_gamma(obj_.value) + elif nodeName_ == 'delta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'delta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_delta'): + self.add_delta(obj_.value) + elif hasattr(self, 'set_delta'): + self.set_delta(obj_.value) + elif nodeName_ == 'epsilon': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'epsilon', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_epsilon'): + self.add_epsilon(obj_.value) + elif hasattr(self, 'set_epsilon'): + self.set_epsilon(obj_.value) + elif nodeName_ == 'zeta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'zeta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_zeta'): + self.add_zeta(obj_.value) + elif hasattr(self, 'set_zeta'): + self.set_zeta(obj_.value) + elif nodeName_ == 'eta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'eta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_eta'): + self.add_eta(obj_.value) + elif hasattr(self, 'set_eta'): + self.set_eta(obj_.value) + elif nodeName_ == 'theta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'theta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_theta'): + self.add_theta(obj_.value) + elif hasattr(self, 'set_theta'): + self.set_theta(obj_.value) + elif nodeName_ == 'iota': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'iota', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_iota'): + self.add_iota(obj_.value) + elif hasattr(self, 'set_iota'): + self.set_iota(obj_.value) + elif nodeName_ == 'kappa': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'kappa', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_kappa'): + self.add_kappa(obj_.value) + elif hasattr(self, 'set_kappa'): + self.set_kappa(obj_.value) + elif nodeName_ == 'lambda': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'lambda', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_lambda'): + self.add_lambda(obj_.value) + elif hasattr(self, 'set_lambda'): + self.set_lambda(obj_.value) + elif nodeName_ == 'mu': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'mu', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_mu'): + self.add_mu(obj_.value) + elif hasattr(self, 'set_mu'): + self.set_mu(obj_.value) + elif nodeName_ == 'nu': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'nu', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_nu'): + self.add_nu(obj_.value) + elif hasattr(self, 'set_nu'): + self.set_nu(obj_.value) + elif nodeName_ == 'xi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'xi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_xi'): + self.add_xi(obj_.value) + elif hasattr(self, 'set_xi'): + self.set_xi(obj_.value) + elif nodeName_ == 'pi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'pi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_pi'): + self.add_pi(obj_.value) + elif hasattr(self, 'set_pi'): + self.set_pi(obj_.value) + elif nodeName_ == 'rho': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rho', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rho'): + self.add_rho(obj_.value) + elif hasattr(self, 'set_rho'): + self.set_rho(obj_.value) + elif nodeName_ == 'sigma': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sigma', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sigma'): + self.add_sigma(obj_.value) + elif hasattr(self, 'set_sigma'): + self.set_sigma(obj_.value) + elif nodeName_ == 'tau': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'tau', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_tau'): + self.add_tau(obj_.value) + elif hasattr(self, 'set_tau'): + self.set_tau(obj_.value) + elif nodeName_ == 'upsilon': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'upsilon', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_upsilon'): + self.add_upsilon(obj_.value) + elif hasattr(self, 'set_upsilon'): + self.set_upsilon(obj_.value) + elif nodeName_ == 'phi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'phi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_phi'): + self.add_phi(obj_.value) + elif hasattr(self, 'set_phi'): + self.set_phi(obj_.value) + elif nodeName_ == 'chi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'chi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_chi'): + self.add_chi(obj_.value) + elif hasattr(self, 'set_chi'): + self.set_chi(obj_.value) + elif nodeName_ == 'psi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'psi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_psi'): + self.add_psi(obj_.value) + elif hasattr(self, 'set_psi'): + self.set_psi(obj_.value) + elif nodeName_ == 'omega': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'omega', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_omega'): + self.add_omega(obj_.value) + elif hasattr(self, 'set_omega'): + self.set_omega(obj_.value) + elif nodeName_ == 'sigmaf': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sigmaf', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sigmaf'): + self.add_sigmaf(obj_.value) + elif hasattr(self, 'set_sigmaf'): + self.set_sigmaf(obj_.value) + elif nodeName_ == 'sect': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sect', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sect'): + self.add_sect(obj_.value) + elif hasattr(self, 'set_sect'): + self.set_sect(obj_.value) + elif nodeName_ == 'deg': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'deg', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_deg'): + self.add_deg(obj_.value) + elif hasattr(self, 'set_deg'): + self.set_deg(obj_.value) + elif nodeName_ == 'prime': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'prime', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_prime'): + self.add_prime(obj_.value) + elif hasattr(self, 'set_prime'): + self.set_prime(obj_.value) + elif nodeName_ == 'Prime': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Prime', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Prime'): + self.add_Prime(obj_.value) + elif hasattr(self, 'set_Prime'): + self.set_Prime(obj_.value) + elif nodeName_ == 'infin': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'infin', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_infin'): + self.add_infin(obj_.value) + elif hasattr(self, 'set_infin'): + self.set_infin(obj_.value) + elif nodeName_ == 'empty': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'empty', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_empty'): + self.add_empty(obj_.value) + elif hasattr(self, 'set_empty'): + self.set_empty(obj_.value) + elif nodeName_ == 'plusmn': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'plusmn', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_plusmn'): + self.add_plusmn(obj_.value) + elif hasattr(self, 'set_plusmn'): + self.set_plusmn(obj_.value) + elif nodeName_ == 'times': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'times', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_times'): + self.add_times(obj_.value) + elif hasattr(self, 'set_times'): + self.set_times(obj_.value) + elif nodeName_ == 'minus': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'minus', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_minus'): + self.add_minus(obj_.value) + elif hasattr(self, 'set_minus'): + self.set_minus(obj_.value) + elif nodeName_ == 'sdot': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sdot', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sdot'): + self.add_sdot(obj_.value) + elif hasattr(self, 'set_sdot'): + self.set_sdot(obj_.value) + elif nodeName_ == 'part': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'part', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_part'): + self.add_part(obj_.value) + elif hasattr(self, 'set_part'): + self.set_part(obj_.value) + elif nodeName_ == 'nabla': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'nabla', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_nabla'): + self.add_nabla(obj_.value) + elif hasattr(self, 'set_nabla'): + self.set_nabla(obj_.value) + elif nodeName_ == 'radic': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'radic', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_radic'): + self.add_radic(obj_.value) + elif hasattr(self, 'set_radic'): + self.set_radic(obj_.value) + elif nodeName_ == 'perp': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'perp', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_perp'): + self.add_perp(obj_.value) + elif hasattr(self, 'set_perp'): + self.set_perp(obj_.value) + elif nodeName_ == 'sum': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sum', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sum'): + self.add_sum(obj_.value) + elif hasattr(self, 'set_sum'): + self.set_sum(obj_.value) + elif nodeName_ == 'int': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'int', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_int'): + self.add_int(obj_.value) + elif hasattr(self, 'set_int'): + self.set_int(obj_.value) + elif nodeName_ == 'prod': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'prod', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_prod'): + self.add_prod(obj_.value) + elif hasattr(self, 'set_prod'): + self.set_prod(obj_.value) + elif nodeName_ == 'sim': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sim', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sim'): + self.add_sim(obj_.value) + elif hasattr(self, 'set_sim'): + self.set_sim(obj_.value) + elif nodeName_ == 'asymp': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'asymp', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_asymp'): + self.add_asymp(obj_.value) + elif hasattr(self, 'set_asymp'): + self.set_asymp(obj_.value) + elif nodeName_ == 'ne': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ne', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ne'): + self.add_ne(obj_.value) + elif hasattr(self, 'set_ne'): + self.set_ne(obj_.value) + elif nodeName_ == 'equiv': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'equiv', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_equiv'): + self.add_equiv(obj_.value) + elif hasattr(self, 'set_equiv'): + self.set_equiv(obj_.value) + elif nodeName_ == 'prop': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'prop', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_prop'): + self.add_prop(obj_.value) + elif hasattr(self, 'set_prop'): + self.set_prop(obj_.value) + elif nodeName_ == 'le': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'le', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_le'): + self.add_le(obj_.value) + elif hasattr(self, 'set_le'): + self.set_le(obj_.value) + elif nodeName_ == 'ge': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ge', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ge'): + self.add_ge(obj_.value) + elif hasattr(self, 'set_ge'): + self.set_ge(obj_.value) + elif nodeName_ == 'larr': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'larr', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_larr'): + self.add_larr(obj_.value) + elif hasattr(self, 'set_larr'): + self.set_larr(obj_.value) + elif nodeName_ == 'rarr': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rarr', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rarr'): + self.add_rarr(obj_.value) + elif hasattr(self, 'set_rarr'): + self.set_rarr(obj_.value) + elif nodeName_ == 'isin': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'isin', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_isin'): + self.add_isin(obj_.value) + elif hasattr(self, 'set_isin'): + self.set_isin(obj_.value) + elif nodeName_ == 'notin': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'notin', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_notin'): + self.add_notin(obj_.value) + elif hasattr(self, 'set_notin'): + self.set_notin(obj_.value) + elif nodeName_ == 'lceil': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'lceil', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_lceil'): + self.add_lceil(obj_.value) + elif hasattr(self, 'set_lceil'): + self.set_lceil(obj_.value) + elif nodeName_ == 'rceil': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rceil', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rceil'): + self.add_rceil(obj_.value) + elif hasattr(self, 'set_rceil'): + self.set_rceil(obj_.value) + elif nodeName_ == 'lfloor': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'lfloor', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_lfloor'): + self.add_lfloor(obj_.value) + elif hasattr(self, 'set_lfloor'): + self.set_lfloor(obj_.value) + elif nodeName_ == 'rfloor': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rfloor', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rfloor'): + self.add_rfloor(obj_.value) + elif hasattr(self, 'set_rfloor'): + self.set_rfloor(obj_.value) + if not fromsubclass_ and child_.tail is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.tail) + self.content_.append(obj_) +# end class docCaptionType + + +class docHeadingType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, level=None, ulink=None, bold=None, emphasis=None, computeroutput=None, subscript=None, superscript=None, center=None, small=None, htmlonly=None, manonly=None, xmlonly=None, rtfonly=None, latexonly=None, dot=None, msc=None, anchor=None, formula=None, ref=None, copy=None, trademark=None, registered=None, lsquo=None, rsquo=None, ldquo=None, rdquo=None, ndash=None, mdash=None, umlaut=None, acute=None, grave=None, circ=None, slash=None, tilde=None, cedil=None, ring=None, szlig=None, nonbreakablespace=None, aelig=None, AElig=None, Gamma=None, Delta=None, Theta=None, Lambda=None, Xi=None, Pi=None, Sigma=None, Upsilon=None, Phi=None, Psi=None, Omega=None, alpha=None, beta=None, gamma=None, delta=None, epsilon=None, zeta=None, eta=None, theta=None, iota=None, kappa=None, lambda_=None, mu=None, nu=None, xi=None, pi=None, rho=None, sigma=None, tau=None, upsilon=None, phi=None, chi=None, psi=None, omega=None, sigmaf=None, sect=None, deg=None, prime=None, Prime=None, infin=None, empty=None, plusmn=None, times=None, minus=None, sdot=None, part=None, nabla=None, radic=None, perp=None, sum=None, int=None, prod=None, sim=None, asymp=None, ne=None, equiv=None, prop=None, le=None, ge=None, larr=None, rarr=None, isin=None, notin=None, lceil=None, rceil=None, lfloor=None, rfloor=None, valueOf_=None, mixedclass_=None, content_=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.level = _cast(int, level) + self.level_nsprefix_ = None + if ulink is None: + self.ulink = [] + else: + self.ulink = ulink + self.ulink_nsprefix_ = None + if bold is None: + self.bold = [] + else: + self.bold = bold + self.bold_nsprefix_ = None + if emphasis is None: + self.emphasis = [] + else: + self.emphasis = emphasis + self.emphasis_nsprefix_ = None + if computeroutput is None: + self.computeroutput = [] + else: + self.computeroutput = computeroutput + self.computeroutput_nsprefix_ = None + if subscript is None: + self.subscript = [] + else: + self.subscript = subscript + self.subscript_nsprefix_ = None + if superscript is None: + self.superscript = [] + else: + self.superscript = superscript + self.superscript_nsprefix_ = None + if center is None: + self.center = [] + else: + self.center = center + self.center_nsprefix_ = None + if small is None: + self.small = [] + else: + self.small = small + self.small_nsprefix_ = None + if htmlonly is None: + self.htmlonly = [] + else: + self.htmlonly = htmlonly + self.htmlonly_nsprefix_ = None + if manonly is None: + self.manonly = [] + else: + self.manonly = manonly + self.manonly_nsprefix_ = None + if xmlonly is None: + self.xmlonly = [] + else: + self.xmlonly = xmlonly + self.xmlonly_nsprefix_ = None + if rtfonly is None: + self.rtfonly = [] + else: + self.rtfonly = rtfonly + self.rtfonly_nsprefix_ = None + if latexonly is None: + self.latexonly = [] + else: + self.latexonly = latexonly + self.latexonly_nsprefix_ = None + if dot is None: + self.dot = [] + else: + self.dot = dot + self.dot_nsprefix_ = None + if msc is None: + self.msc = [] + else: + self.msc = msc + self.msc_nsprefix_ = None + if anchor is None: + self.anchor = [] + else: + self.anchor = anchor + self.anchor_nsprefix_ = None + if formula is None: + self.formula = [] + else: + self.formula = formula + self.formula_nsprefix_ = None + if ref is None: + self.ref = [] + else: + self.ref = ref + self.ref_nsprefix_ = None + if copy is None: + self.copy = [] + else: + self.copy = copy + self.copy_nsprefix_ = None + if trademark is None: + self.trademark = [] + else: + self.trademark = trademark + self.trademark_nsprefix_ = None + if registered is None: + self.registered = [] + else: + self.registered = registered + self.registered_nsprefix_ = None + if lsquo is None: + self.lsquo = [] + else: + self.lsquo = lsquo + self.lsquo_nsprefix_ = None + if rsquo is None: + self.rsquo = [] + else: + self.rsquo = rsquo + self.rsquo_nsprefix_ = None + if ldquo is None: + self.ldquo = [] + else: + self.ldquo = ldquo + self.ldquo_nsprefix_ = None + if rdquo is None: + self.rdquo = [] + else: + self.rdquo = rdquo + self.rdquo_nsprefix_ = None + if ndash is None: + self.ndash = [] + else: + self.ndash = ndash + self.ndash_nsprefix_ = None + if mdash is None: + self.mdash = [] + else: + self.mdash = mdash + self.mdash_nsprefix_ = None + if umlaut is None: + self.umlaut = [] + else: + self.umlaut = umlaut + self.umlaut_nsprefix_ = None + if acute is None: + self.acute = [] + else: + self.acute = acute + self.acute_nsprefix_ = None + if grave is None: + self.grave = [] + else: + self.grave = grave + self.grave_nsprefix_ = None + if circ is None: + self.circ = [] + else: + self.circ = circ + self.circ_nsprefix_ = None + if slash is None: + self.slash = [] + else: + self.slash = slash + self.slash_nsprefix_ = None + if tilde is None: + self.tilde = [] + else: + self.tilde = tilde + self.tilde_nsprefix_ = None + if cedil is None: + self.cedil = [] + else: + self.cedil = cedil + self.cedil_nsprefix_ = None + if ring is None: + self.ring = [] + else: + self.ring = ring + self.ring_nsprefix_ = None + if szlig is None: + self.szlig = [] + else: + self.szlig = szlig + self.szlig_nsprefix_ = None + if nonbreakablespace is None: + self.nonbreakablespace = [] + else: + self.nonbreakablespace = nonbreakablespace + self.nonbreakablespace_nsprefix_ = None + if aelig is None: + self.aelig = [] + else: + self.aelig = aelig + self.aelig_nsprefix_ = None + if AElig is None: + self.AElig = [] + else: + self.AElig = AElig + self.AElig_nsprefix_ = None + if Gamma is None: + self.Gamma = [] + else: + self.Gamma = Gamma + self.Gamma_nsprefix_ = None + if Delta is None: + self.Delta = [] + else: + self.Delta = Delta + self.Delta_nsprefix_ = None + if Theta is None: + self.Theta = [] + else: + self.Theta = Theta + self.Theta_nsprefix_ = None + if Lambda is None: + self.Lambda = [] + else: + self.Lambda = Lambda + self.Lambda_nsprefix_ = None + if Xi is None: + self.Xi = [] + else: + self.Xi = Xi + self.Xi_nsprefix_ = None + if Pi is None: + self.Pi = [] + else: + self.Pi = Pi + self.Pi_nsprefix_ = None + if Sigma is None: + self.Sigma = [] + else: + self.Sigma = Sigma + self.Sigma_nsprefix_ = None + if Upsilon is None: + self.Upsilon = [] + else: + self.Upsilon = Upsilon + self.Upsilon_nsprefix_ = None + if Phi is None: + self.Phi = [] + else: + self.Phi = Phi + self.Phi_nsprefix_ = None + if Psi is None: + self.Psi = [] + else: + self.Psi = Psi + self.Psi_nsprefix_ = None + if Omega is None: + self.Omega = [] + else: + self.Omega = Omega + self.Omega_nsprefix_ = None + if alpha is None: + self.alpha = [] + else: + self.alpha = alpha + self.alpha_nsprefix_ = None + if beta is None: + self.beta = [] + else: + self.beta = beta + self.beta_nsprefix_ = None + if gamma is None: + self.gamma = [] + else: + self.gamma = gamma + self.gamma_nsprefix_ = None + if delta is None: + self.delta = [] + else: + self.delta = delta + self.delta_nsprefix_ = None + if epsilon is None: + self.epsilon = [] + else: + self.epsilon = epsilon + self.epsilon_nsprefix_ = None + if zeta is None: + self.zeta = [] + else: + self.zeta = zeta + self.zeta_nsprefix_ = None + if eta is None: + self.eta = [] + else: + self.eta = eta + self.eta_nsprefix_ = None + if theta is None: + self.theta = [] + else: + self.theta = theta + self.theta_nsprefix_ = None + if iota is None: + self.iota = [] + else: + self.iota = iota + self.iota_nsprefix_ = None + if kappa is None: + self.kappa = [] + else: + self.kappa = kappa + self.kappa_nsprefix_ = None + if lambda_ is None: + self.lambda_ = [] + else: + self.lambda_ = lambda_ + self.lambda__nsprefix_ = None + if mu is None: + self.mu = [] + else: + self.mu = mu + self.mu_nsprefix_ = None + if nu is None: + self.nu = [] + else: + self.nu = nu + self.nu_nsprefix_ = None + if xi is None: + self.xi = [] + else: + self.xi = xi + self.xi_nsprefix_ = None + if pi is None: + self.pi = [] + else: + self.pi = pi + self.pi_nsprefix_ = None + if rho is None: + self.rho = [] + else: + self.rho = rho + self.rho_nsprefix_ = None + if sigma is None: + self.sigma = [] + else: + self.sigma = sigma + self.sigma_nsprefix_ = None + if tau is None: + self.tau = [] + else: + self.tau = tau + self.tau_nsprefix_ = None + if upsilon is None: + self.upsilon = [] + else: + self.upsilon = upsilon + self.upsilon_nsprefix_ = None + if phi is None: + self.phi = [] + else: + self.phi = phi + self.phi_nsprefix_ = None + if chi is None: + self.chi = [] + else: + self.chi = chi + self.chi_nsprefix_ = None + if psi is None: + self.psi = [] + else: + self.psi = psi + self.psi_nsprefix_ = None + if omega is None: + self.omega = [] + else: + self.omega = omega + self.omega_nsprefix_ = None + if sigmaf is None: + self.sigmaf = [] + else: + self.sigmaf = sigmaf + self.sigmaf_nsprefix_ = None + if sect is None: + self.sect = [] + else: + self.sect = sect + self.sect_nsprefix_ = None + if deg is None: + self.deg = [] + else: + self.deg = deg + self.deg_nsprefix_ = None + if prime is None: + self.prime = [] + else: + self.prime = prime + self.prime_nsprefix_ = None + if Prime is None: + self.Prime = [] + else: + self.Prime = Prime + self.Prime_nsprefix_ = None + if infin is None: + self.infin = [] + else: + self.infin = infin + self.infin_nsprefix_ = None + if empty is None: + self.empty = [] + else: + self.empty = empty + self.empty_nsprefix_ = None + if plusmn is None: + self.plusmn = [] + else: + self.plusmn = plusmn + self.plusmn_nsprefix_ = None + if times is None: + self.times = [] + else: + self.times = times + self.times_nsprefix_ = None + if minus is None: + self.minus = [] + else: + self.minus = minus + self.minus_nsprefix_ = None + if sdot is None: + self.sdot = [] + else: + self.sdot = sdot + self.sdot_nsprefix_ = None + if part is None: + self.part = [] + else: + self.part = part + self.part_nsprefix_ = None + if nabla is None: + self.nabla = [] + else: + self.nabla = nabla + self.nabla_nsprefix_ = None + if radic is None: + self.radic = [] + else: + self.radic = radic + self.radic_nsprefix_ = None + if perp is None: + self.perp = [] + else: + self.perp = perp + self.perp_nsprefix_ = None + if sum is None: + self.sum = [] + else: + self.sum = sum + self.sum_nsprefix_ = None + if int is None: + self.int = [] + else: + self.int = int + self.int_nsprefix_ = None + if prod is None: + self.prod = [] + else: + self.prod = prod + self.prod_nsprefix_ = None + if sim is None: + self.sim = [] + else: + self.sim = sim + self.sim_nsprefix_ = None + if asymp is None: + self.asymp = [] + else: + self.asymp = asymp + self.asymp_nsprefix_ = None + if ne is None: + self.ne = [] + else: + self.ne = ne + self.ne_nsprefix_ = None + if equiv is None: + self.equiv = [] + else: + self.equiv = equiv + self.equiv_nsprefix_ = None + if prop is None: + self.prop = [] + else: + self.prop = prop + self.prop_nsprefix_ = None + if le is None: + self.le = [] + else: + self.le = le + self.le_nsprefix_ = None + if ge is None: + self.ge = [] + else: + self.ge = ge + self.ge_nsprefix_ = None + if larr is None: + self.larr = [] + else: + self.larr = larr + self.larr_nsprefix_ = None + if rarr is None: + self.rarr = [] + else: + self.rarr = rarr + self.rarr_nsprefix_ = None + if isin is None: + self.isin = [] + else: + self.isin = isin + self.isin_nsprefix_ = None + if notin is None: + self.notin = [] + else: + self.notin = notin + self.notin_nsprefix_ = None + if lceil is None: + self.lceil = [] + else: + self.lceil = lceil + self.lceil_nsprefix_ = None + if rceil is None: + self.rceil = [] + else: + self.rceil = rceil + self.rceil_nsprefix_ = None + if lfloor is None: + self.lfloor = [] + else: + self.lfloor = lfloor + self.lfloor_nsprefix_ = None + if rfloor is None: + self.rfloor = [] + else: + self.rfloor = rfloor + self.rfloor_nsprefix_ = None + self.valueOf_ = valueOf_ + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + self.valueOf_ = valueOf_ + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docHeadingType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docHeadingType.subclass: + return docHeadingType.subclass(*args_, **kwargs_) + return docHeadingType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + def get_ulink(self): + return self.ulink + def set_ulink(self, ulink): + self.ulink = ulink + def add_ulink(self, value): + self.ulink.append(value) + def insert_ulink_at(self, index, value): + self.ulink.insert(index, value) + def replace_ulink_at(self, index, value): + self.ulink[index] = value + def get_bold(self): + return self.bold + def set_bold(self, bold): + self.bold = bold + def add_bold(self, value): + self.bold.append(value) + def insert_bold_at(self, index, value): + self.bold.insert(index, value) + def replace_bold_at(self, index, value): + self.bold[index] = value + def get_emphasis(self): + return self.emphasis + def set_emphasis(self, emphasis): + self.emphasis = emphasis + def add_emphasis(self, value): + self.emphasis.append(value) + def insert_emphasis_at(self, index, value): + self.emphasis.insert(index, value) + def replace_emphasis_at(self, index, value): + self.emphasis[index] = value + def get_computeroutput(self): + return self.computeroutput + def set_computeroutput(self, computeroutput): + self.computeroutput = computeroutput + def add_computeroutput(self, value): + self.computeroutput.append(value) + def insert_computeroutput_at(self, index, value): + self.computeroutput.insert(index, value) + def replace_computeroutput_at(self, index, value): + self.computeroutput[index] = value + def get_subscript(self): + return self.subscript + def set_subscript(self, subscript): + self.subscript = subscript + def add_subscript(self, value): + self.subscript.append(value) + def insert_subscript_at(self, index, value): + self.subscript.insert(index, value) + def replace_subscript_at(self, index, value): + self.subscript[index] = value + def get_superscript(self): + return self.superscript + def set_superscript(self, superscript): + self.superscript = superscript + def add_superscript(self, value): + self.superscript.append(value) + def insert_superscript_at(self, index, value): + self.superscript.insert(index, value) + def replace_superscript_at(self, index, value): + self.superscript[index] = value + def get_center(self): + return self.center + def set_center(self, center): + self.center = center + def add_center(self, value): + self.center.append(value) + def insert_center_at(self, index, value): + self.center.insert(index, value) + def replace_center_at(self, index, value): + self.center[index] = value + def get_small(self): + return self.small + def set_small(self, small): + self.small = small + def add_small(self, value): + self.small.append(value) + def insert_small_at(self, index, value): + self.small.insert(index, value) + def replace_small_at(self, index, value): + self.small[index] = value + def get_htmlonly(self): + return self.htmlonly + def set_htmlonly(self, htmlonly): + self.htmlonly = htmlonly + def add_htmlonly(self, value): + self.htmlonly.append(value) + def insert_htmlonly_at(self, index, value): + self.htmlonly.insert(index, value) + def replace_htmlonly_at(self, index, value): + self.htmlonly[index] = value + def get_manonly(self): + return self.manonly + def set_manonly(self, manonly): + self.manonly = manonly + def add_manonly(self, value): + self.manonly.append(value) + def insert_manonly_at(self, index, value): + self.manonly.insert(index, value) + def replace_manonly_at(self, index, value): + self.manonly[index] = value + def get_xmlonly(self): + return self.xmlonly + def set_xmlonly(self, xmlonly): + self.xmlonly = xmlonly + def add_xmlonly(self, value): + self.xmlonly.append(value) + def insert_xmlonly_at(self, index, value): + self.xmlonly.insert(index, value) + def replace_xmlonly_at(self, index, value): + self.xmlonly[index] = value + def get_rtfonly(self): + return self.rtfonly + def set_rtfonly(self, rtfonly): + self.rtfonly = rtfonly + def add_rtfonly(self, value): + self.rtfonly.append(value) + def insert_rtfonly_at(self, index, value): + self.rtfonly.insert(index, value) + def replace_rtfonly_at(self, index, value): + self.rtfonly[index] = value + def get_latexonly(self): + return self.latexonly + def set_latexonly(self, latexonly): + self.latexonly = latexonly + def add_latexonly(self, value): + self.latexonly.append(value) + def insert_latexonly_at(self, index, value): + self.latexonly.insert(index, value) + def replace_latexonly_at(self, index, value): + self.latexonly[index] = value + def get_dot(self): + return self.dot + def set_dot(self, dot): + self.dot = dot + def add_dot(self, value): + self.dot.append(value) + def insert_dot_at(self, index, value): + self.dot.insert(index, value) + def replace_dot_at(self, index, value): + self.dot[index] = value + def get_msc(self): + return self.msc + def set_msc(self, msc): + self.msc = msc + def add_msc(self, value): + self.msc.append(value) + def insert_msc_at(self, index, value): + self.msc.insert(index, value) + def replace_msc_at(self, index, value): + self.msc[index] = value + def get_anchor(self): + return self.anchor + def set_anchor(self, anchor): + self.anchor = anchor + def add_anchor(self, value): + self.anchor.append(value) + def insert_anchor_at(self, index, value): + self.anchor.insert(index, value) + def replace_anchor_at(self, index, value): + self.anchor[index] = value + def get_formula(self): + return self.formula + def set_formula(self, formula): + self.formula = formula + def add_formula(self, value): + self.formula.append(value) + def insert_formula_at(self, index, value): + self.formula.insert(index, value) + def replace_formula_at(self, index, value): + self.formula[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_at(self, index, value): + self.ref.insert(index, value) + def replace_ref_at(self, index, value): + self.ref[index] = value + def get_copy(self): + return self.copy + def set_copy(self, copy): + self.copy = copy + def add_copy(self, value): + self.copy.append(value) + def insert_copy_at(self, index, value): + self.copy.insert(index, value) + def replace_copy_at(self, index, value): + self.copy[index] = value + def get_trademark(self): + return self.trademark + def set_trademark(self, trademark): + self.trademark = trademark + def add_trademark(self, value): + self.trademark.append(value) + def insert_trademark_at(self, index, value): + self.trademark.insert(index, value) + def replace_trademark_at(self, index, value): + self.trademark[index] = value + def get_registered(self): + return self.registered + def set_registered(self, registered): + self.registered = registered + def add_registered(self, value): + self.registered.append(value) + def insert_registered_at(self, index, value): + self.registered.insert(index, value) + def replace_registered_at(self, index, value): + self.registered[index] = value + def get_lsquo(self): + return self.lsquo + def set_lsquo(self, lsquo): + self.lsquo = lsquo + def add_lsquo(self, value): + self.lsquo.append(value) + def insert_lsquo_at(self, index, value): + self.lsquo.insert(index, value) + def replace_lsquo_at(self, index, value): + self.lsquo[index] = value + def get_rsquo(self): + return self.rsquo + def set_rsquo(self, rsquo): + self.rsquo = rsquo + def add_rsquo(self, value): + self.rsquo.append(value) + def insert_rsquo_at(self, index, value): + self.rsquo.insert(index, value) + def replace_rsquo_at(self, index, value): + self.rsquo[index] = value + def get_ldquo(self): + return self.ldquo + def set_ldquo(self, ldquo): + self.ldquo = ldquo + def add_ldquo(self, value): + self.ldquo.append(value) + def insert_ldquo_at(self, index, value): + self.ldquo.insert(index, value) + def replace_ldquo_at(self, index, value): + self.ldquo[index] = value + def get_rdquo(self): + return self.rdquo + def set_rdquo(self, rdquo): + self.rdquo = rdquo + def add_rdquo(self, value): + self.rdquo.append(value) + def insert_rdquo_at(self, index, value): + self.rdquo.insert(index, value) + def replace_rdquo_at(self, index, value): + self.rdquo[index] = value + def get_ndash(self): + return self.ndash + def set_ndash(self, ndash): + self.ndash = ndash + def add_ndash(self, value): + self.ndash.append(value) + def insert_ndash_at(self, index, value): + self.ndash.insert(index, value) + def replace_ndash_at(self, index, value): + self.ndash[index] = value + def get_mdash(self): + return self.mdash + def set_mdash(self, mdash): + self.mdash = mdash + def add_mdash(self, value): + self.mdash.append(value) + def insert_mdash_at(self, index, value): + self.mdash.insert(index, value) + def replace_mdash_at(self, index, value): + self.mdash[index] = value + def get_umlaut(self): + return self.umlaut + def set_umlaut(self, umlaut): + self.umlaut = umlaut + def add_umlaut(self, value): + self.umlaut.append(value) + def insert_umlaut_at(self, index, value): + self.umlaut.insert(index, value) + def replace_umlaut_at(self, index, value): + self.umlaut[index] = value + def get_acute(self): + return self.acute + def set_acute(self, acute): + self.acute = acute + def add_acute(self, value): + self.acute.append(value) + def insert_acute_at(self, index, value): + self.acute.insert(index, value) + def replace_acute_at(self, index, value): + self.acute[index] = value + def get_grave(self): + return self.grave + def set_grave(self, grave): + self.grave = grave + def add_grave(self, value): + self.grave.append(value) + def insert_grave_at(self, index, value): + self.grave.insert(index, value) + def replace_grave_at(self, index, value): + self.grave[index] = value + def get_circ(self): + return self.circ + def set_circ(self, circ): + self.circ = circ + def add_circ(self, value): + self.circ.append(value) + def insert_circ_at(self, index, value): + self.circ.insert(index, value) + def replace_circ_at(self, index, value): + self.circ[index] = value + def get_slash(self): + return self.slash + def set_slash(self, slash): + self.slash = slash + def add_slash(self, value): + self.slash.append(value) + def insert_slash_at(self, index, value): + self.slash.insert(index, value) + def replace_slash_at(self, index, value): + self.slash[index] = value + def get_tilde(self): + return self.tilde + def set_tilde(self, tilde): + self.tilde = tilde + def add_tilde(self, value): + self.tilde.append(value) + def insert_tilde_at(self, index, value): + self.tilde.insert(index, value) + def replace_tilde_at(self, index, value): + self.tilde[index] = value + def get_cedil(self): + return self.cedil + def set_cedil(self, cedil): + self.cedil = cedil + def add_cedil(self, value): + self.cedil.append(value) + def insert_cedil_at(self, index, value): + self.cedil.insert(index, value) + def replace_cedil_at(self, index, value): + self.cedil[index] = value + def get_ring(self): + return self.ring + def set_ring(self, ring): + self.ring = ring + def add_ring(self, value): + self.ring.append(value) + def insert_ring_at(self, index, value): + self.ring.insert(index, value) + def replace_ring_at(self, index, value): + self.ring[index] = value + def get_szlig(self): + return self.szlig + def set_szlig(self, szlig): + self.szlig = szlig + def add_szlig(self, value): + self.szlig.append(value) + def insert_szlig_at(self, index, value): + self.szlig.insert(index, value) + def replace_szlig_at(self, index, value): + self.szlig[index] = value + def get_nonbreakablespace(self): + return self.nonbreakablespace + def set_nonbreakablespace(self, nonbreakablespace): + self.nonbreakablespace = nonbreakablespace + def add_nonbreakablespace(self, value): + self.nonbreakablespace.append(value) + def insert_nonbreakablespace_at(self, index, value): + self.nonbreakablespace.insert(index, value) + def replace_nonbreakablespace_at(self, index, value): + self.nonbreakablespace[index] = value + def get_aelig(self): + return self.aelig + def set_aelig(self, aelig): + self.aelig = aelig + def add_aelig(self, value): + self.aelig.append(value) + def insert_aelig_at(self, index, value): + self.aelig.insert(index, value) + def replace_aelig_at(self, index, value): + self.aelig[index] = value + def get_AElig(self): + return self.AElig + def set_AElig(self, AElig): + self.AElig = AElig + def add_AElig(self, value): + self.AElig.append(value) + def insert_AElig_at(self, index, value): + self.AElig.insert(index, value) + def replace_AElig_at(self, index, value): + self.AElig[index] = value + def get_Gamma(self): + return self.Gamma + def set_Gamma(self, Gamma): + self.Gamma = Gamma + def add_Gamma(self, value): + self.Gamma.append(value) + def insert_Gamma_at(self, index, value): + self.Gamma.insert(index, value) + def replace_Gamma_at(self, index, value): + self.Gamma[index] = value + def get_Delta(self): + return self.Delta + def set_Delta(self, Delta): + self.Delta = Delta + def add_Delta(self, value): + self.Delta.append(value) + def insert_Delta_at(self, index, value): + self.Delta.insert(index, value) + def replace_Delta_at(self, index, value): + self.Delta[index] = value + def get_Theta(self): + return self.Theta + def set_Theta(self, Theta): + self.Theta = Theta + def add_Theta(self, value): + self.Theta.append(value) + def insert_Theta_at(self, index, value): + self.Theta.insert(index, value) + def replace_Theta_at(self, index, value): + self.Theta[index] = value + def get_Lambda(self): + return self.Lambda + def set_Lambda(self, Lambda): + self.Lambda = Lambda + def add_Lambda(self, value): + self.Lambda.append(value) + def insert_Lambda_at(self, index, value): + self.Lambda.insert(index, value) + def replace_Lambda_at(self, index, value): + self.Lambda[index] = value + def get_Xi(self): + return self.Xi + def set_Xi(self, Xi): + self.Xi = Xi + def add_Xi(self, value): + self.Xi.append(value) + def insert_Xi_at(self, index, value): + self.Xi.insert(index, value) + def replace_Xi_at(self, index, value): + self.Xi[index] = value + def get_Pi(self): + return self.Pi + def set_Pi(self, Pi): + self.Pi = Pi + def add_Pi(self, value): + self.Pi.append(value) + def insert_Pi_at(self, index, value): + self.Pi.insert(index, value) + def replace_Pi_at(self, index, value): + self.Pi[index] = value + def get_Sigma(self): + return self.Sigma + def set_Sigma(self, Sigma): + self.Sigma = Sigma + def add_Sigma(self, value): + self.Sigma.append(value) + def insert_Sigma_at(self, index, value): + self.Sigma.insert(index, value) + def replace_Sigma_at(self, index, value): + self.Sigma[index] = value + def get_Upsilon(self): + return self.Upsilon + def set_Upsilon(self, Upsilon): + self.Upsilon = Upsilon + def add_Upsilon(self, value): + self.Upsilon.append(value) + def insert_Upsilon_at(self, index, value): + self.Upsilon.insert(index, value) + def replace_Upsilon_at(self, index, value): + self.Upsilon[index] = value + def get_Phi(self): + return self.Phi + def set_Phi(self, Phi): + self.Phi = Phi + def add_Phi(self, value): + self.Phi.append(value) + def insert_Phi_at(self, index, value): + self.Phi.insert(index, value) + def replace_Phi_at(self, index, value): + self.Phi[index] = value + def get_Psi(self): + return self.Psi + def set_Psi(self, Psi): + self.Psi = Psi + def add_Psi(self, value): + self.Psi.append(value) + def insert_Psi_at(self, index, value): + self.Psi.insert(index, value) + def replace_Psi_at(self, index, value): + self.Psi[index] = value + def get_Omega(self): + return self.Omega + def set_Omega(self, Omega): + self.Omega = Omega + def add_Omega(self, value): + self.Omega.append(value) + def insert_Omega_at(self, index, value): + self.Omega.insert(index, value) + def replace_Omega_at(self, index, value): + self.Omega[index] = value + def get_alpha(self): + return self.alpha + def set_alpha(self, alpha): + self.alpha = alpha + def add_alpha(self, value): + self.alpha.append(value) + def insert_alpha_at(self, index, value): + self.alpha.insert(index, value) + def replace_alpha_at(self, index, value): + self.alpha[index] = value + def get_beta(self): + return self.beta + def set_beta(self, beta): + self.beta = beta + def add_beta(self, value): + self.beta.append(value) + def insert_beta_at(self, index, value): + self.beta.insert(index, value) + def replace_beta_at(self, index, value): + self.beta[index] = value + def get_gamma(self): + return self.gamma + def set_gamma(self, gamma): + self.gamma = gamma + def add_gamma(self, value): + self.gamma.append(value) + def insert_gamma_at(self, index, value): + self.gamma.insert(index, value) + def replace_gamma_at(self, index, value): + self.gamma[index] = value + def get_delta(self): + return self.delta + def set_delta(self, delta): + self.delta = delta + def add_delta(self, value): + self.delta.append(value) + def insert_delta_at(self, index, value): + self.delta.insert(index, value) + def replace_delta_at(self, index, value): + self.delta[index] = value + def get_epsilon(self): + return self.epsilon + def set_epsilon(self, epsilon): + self.epsilon = epsilon + def add_epsilon(self, value): + self.epsilon.append(value) + def insert_epsilon_at(self, index, value): + self.epsilon.insert(index, value) + def replace_epsilon_at(self, index, value): + self.epsilon[index] = value + def get_zeta(self): + return self.zeta + def set_zeta(self, zeta): + self.zeta = zeta + def add_zeta(self, value): + self.zeta.append(value) + def insert_zeta_at(self, index, value): + self.zeta.insert(index, value) + def replace_zeta_at(self, index, value): + self.zeta[index] = value + def get_eta(self): + return self.eta + def set_eta(self, eta): + self.eta = eta + def add_eta(self, value): + self.eta.append(value) + def insert_eta_at(self, index, value): + self.eta.insert(index, value) + def replace_eta_at(self, index, value): + self.eta[index] = value + def get_theta(self): + return self.theta + def set_theta(self, theta): + self.theta = theta + def add_theta(self, value): + self.theta.append(value) + def insert_theta_at(self, index, value): + self.theta.insert(index, value) + def replace_theta_at(self, index, value): + self.theta[index] = value + def get_iota(self): + return self.iota + def set_iota(self, iota): + self.iota = iota + def add_iota(self, value): + self.iota.append(value) + def insert_iota_at(self, index, value): + self.iota.insert(index, value) + def replace_iota_at(self, index, value): + self.iota[index] = value + def get_kappa(self): + return self.kappa + def set_kappa(self, kappa): + self.kappa = kappa + def add_kappa(self, value): + self.kappa.append(value) + def insert_kappa_at(self, index, value): + self.kappa.insert(index, value) + def replace_kappa_at(self, index, value): + self.kappa[index] = value + def get_lambda(self): + return self.lambda_ + def set_lambda(self, lambda_): + self.lambda_ = lambda_ + def add_lambda(self, value): + self.lambda_.append(value) + def insert_lambda_at(self, index, value): + self.lambda_.insert(index, value) + def replace_lambda_at(self, index, value): + self.lambda_[index] = value + def get_mu(self): + return self.mu + def set_mu(self, mu): + self.mu = mu + def add_mu(self, value): + self.mu.append(value) + def insert_mu_at(self, index, value): + self.mu.insert(index, value) + def replace_mu_at(self, index, value): + self.mu[index] = value + def get_nu(self): + return self.nu + def set_nu(self, nu): + self.nu = nu + def add_nu(self, value): + self.nu.append(value) + def insert_nu_at(self, index, value): + self.nu.insert(index, value) + def replace_nu_at(self, index, value): + self.nu[index] = value + def get_xi(self): + return self.xi + def set_xi(self, xi): + self.xi = xi + def add_xi(self, value): + self.xi.append(value) + def insert_xi_at(self, index, value): + self.xi.insert(index, value) + def replace_xi_at(self, index, value): + self.xi[index] = value + def get_pi(self): + return self.pi + def set_pi(self, pi): + self.pi = pi + def add_pi(self, value): + self.pi.append(value) + def insert_pi_at(self, index, value): + self.pi.insert(index, value) + def replace_pi_at(self, index, value): + self.pi[index] = value + def get_rho(self): + return self.rho + def set_rho(self, rho): + self.rho = rho + def add_rho(self, value): + self.rho.append(value) + def insert_rho_at(self, index, value): + self.rho.insert(index, value) + def replace_rho_at(self, index, value): + self.rho[index] = value + def get_sigma(self): + return self.sigma + def set_sigma(self, sigma): + self.sigma = sigma + def add_sigma(self, value): + self.sigma.append(value) + def insert_sigma_at(self, index, value): + self.sigma.insert(index, value) + def replace_sigma_at(self, index, value): + self.sigma[index] = value + def get_tau(self): + return self.tau + def set_tau(self, tau): + self.tau = tau + def add_tau(self, value): + self.tau.append(value) + def insert_tau_at(self, index, value): + self.tau.insert(index, value) + def replace_tau_at(self, index, value): + self.tau[index] = value + def get_upsilon(self): + return self.upsilon + def set_upsilon(self, upsilon): + self.upsilon = upsilon + def add_upsilon(self, value): + self.upsilon.append(value) + def insert_upsilon_at(self, index, value): + self.upsilon.insert(index, value) + def replace_upsilon_at(self, index, value): + self.upsilon[index] = value + def get_phi(self): + return self.phi + def set_phi(self, phi): + self.phi = phi + def add_phi(self, value): + self.phi.append(value) + def insert_phi_at(self, index, value): + self.phi.insert(index, value) + def replace_phi_at(self, index, value): + self.phi[index] = value + def get_chi(self): + return self.chi + def set_chi(self, chi): + self.chi = chi + def add_chi(self, value): + self.chi.append(value) + def insert_chi_at(self, index, value): + self.chi.insert(index, value) + def replace_chi_at(self, index, value): + self.chi[index] = value + def get_psi(self): + return self.psi + def set_psi(self, psi): + self.psi = psi + def add_psi(self, value): + self.psi.append(value) + def insert_psi_at(self, index, value): + self.psi.insert(index, value) + def replace_psi_at(self, index, value): + self.psi[index] = value + def get_omega(self): + return self.omega + def set_omega(self, omega): + self.omega = omega + def add_omega(self, value): + self.omega.append(value) + def insert_omega_at(self, index, value): + self.omega.insert(index, value) + def replace_omega_at(self, index, value): + self.omega[index] = value + def get_sigmaf(self): + return self.sigmaf + def set_sigmaf(self, sigmaf): + self.sigmaf = sigmaf + def add_sigmaf(self, value): + self.sigmaf.append(value) + def insert_sigmaf_at(self, index, value): + self.sigmaf.insert(index, value) + def replace_sigmaf_at(self, index, value): + self.sigmaf[index] = value + def get_sect(self): + return self.sect + def set_sect(self, sect): + self.sect = sect + def add_sect(self, value): + self.sect.append(value) + def insert_sect_at(self, index, value): + self.sect.insert(index, value) + def replace_sect_at(self, index, value): + self.sect[index] = value + def get_deg(self): + return self.deg + def set_deg(self, deg): + self.deg = deg + def add_deg(self, value): + self.deg.append(value) + def insert_deg_at(self, index, value): + self.deg.insert(index, value) + def replace_deg_at(self, index, value): + self.deg[index] = value + def get_prime(self): + return self.prime + def set_prime(self, prime): + self.prime = prime + def add_prime(self, value): + self.prime.append(value) + def insert_prime_at(self, index, value): + self.prime.insert(index, value) + def replace_prime_at(self, index, value): + self.prime[index] = value + def get_Prime(self): + return self.Prime + def set_Prime(self, Prime): + self.Prime = Prime + def add_Prime(self, value): + self.Prime.append(value) + def insert_Prime_at(self, index, value): + self.Prime.insert(index, value) + def replace_Prime_at(self, index, value): + self.Prime[index] = value + def get_infin(self): + return self.infin + def set_infin(self, infin): + self.infin = infin + def add_infin(self, value): + self.infin.append(value) + def insert_infin_at(self, index, value): + self.infin.insert(index, value) + def replace_infin_at(self, index, value): + self.infin[index] = value + def get_empty(self): + return self.empty + def set_empty(self, empty): + self.empty = empty + def add_empty(self, value): + self.empty.append(value) + def insert_empty_at(self, index, value): + self.empty.insert(index, value) + def replace_empty_at(self, index, value): + self.empty[index] = value + def get_plusmn(self): + return self.plusmn + def set_plusmn(self, plusmn): + self.plusmn = plusmn + def add_plusmn(self, value): + self.plusmn.append(value) + def insert_plusmn_at(self, index, value): + self.plusmn.insert(index, value) + def replace_plusmn_at(self, index, value): + self.plusmn[index] = value + def get_times(self): + return self.times + def set_times(self, times): + self.times = times + def add_times(self, value): + self.times.append(value) + def insert_times_at(self, index, value): + self.times.insert(index, value) + def replace_times_at(self, index, value): + self.times[index] = value + def get_minus(self): + return self.minus + def set_minus(self, minus): + self.minus = minus + def add_minus(self, value): + self.minus.append(value) + def insert_minus_at(self, index, value): + self.minus.insert(index, value) + def replace_minus_at(self, index, value): + self.minus[index] = value + def get_sdot(self): + return self.sdot + def set_sdot(self, sdot): + self.sdot = sdot + def add_sdot(self, value): + self.sdot.append(value) + def insert_sdot_at(self, index, value): + self.sdot.insert(index, value) + def replace_sdot_at(self, index, value): + self.sdot[index] = value + def get_part(self): + return self.part + def set_part(self, part): + self.part = part + def add_part(self, value): + self.part.append(value) + def insert_part_at(self, index, value): + self.part.insert(index, value) + def replace_part_at(self, index, value): + self.part[index] = value + def get_nabla(self): + return self.nabla + def set_nabla(self, nabla): + self.nabla = nabla + def add_nabla(self, value): + self.nabla.append(value) + def insert_nabla_at(self, index, value): + self.nabla.insert(index, value) + def replace_nabla_at(self, index, value): + self.nabla[index] = value + def get_radic(self): + return self.radic + def set_radic(self, radic): + self.radic = radic + def add_radic(self, value): + self.radic.append(value) + def insert_radic_at(self, index, value): + self.radic.insert(index, value) + def replace_radic_at(self, index, value): + self.radic[index] = value + def get_perp(self): + return self.perp + def set_perp(self, perp): + self.perp = perp + def add_perp(self, value): + self.perp.append(value) + def insert_perp_at(self, index, value): + self.perp.insert(index, value) + def replace_perp_at(self, index, value): + self.perp[index] = value + def get_sum(self): + return self.sum + def set_sum(self, sum): + self.sum = sum + def add_sum(self, value): + self.sum.append(value) + def insert_sum_at(self, index, value): + self.sum.insert(index, value) + def replace_sum_at(self, index, value): + self.sum[index] = value + def get_int(self): + return self.int + def set_int(self, int): + self.int = int + def add_int(self, value): + self.int.append(value) + def insert_int_at(self, index, value): + self.int.insert(index, value) + def replace_int_at(self, index, value): + self.int[index] = value + def get_prod(self): + return self.prod + def set_prod(self, prod): + self.prod = prod + def add_prod(self, value): + self.prod.append(value) + def insert_prod_at(self, index, value): + self.prod.insert(index, value) + def replace_prod_at(self, index, value): + self.prod[index] = value + def get_sim(self): + return self.sim + def set_sim(self, sim): + self.sim = sim + def add_sim(self, value): + self.sim.append(value) + def insert_sim_at(self, index, value): + self.sim.insert(index, value) + def replace_sim_at(self, index, value): + self.sim[index] = value + def get_asymp(self): + return self.asymp + def set_asymp(self, asymp): + self.asymp = asymp + def add_asymp(self, value): + self.asymp.append(value) + def insert_asymp_at(self, index, value): + self.asymp.insert(index, value) + def replace_asymp_at(self, index, value): + self.asymp[index] = value + def get_ne(self): + return self.ne + def set_ne(self, ne): + self.ne = ne + def add_ne(self, value): + self.ne.append(value) + def insert_ne_at(self, index, value): + self.ne.insert(index, value) + def replace_ne_at(self, index, value): + self.ne[index] = value + def get_equiv(self): + return self.equiv + def set_equiv(self, equiv): + self.equiv = equiv + def add_equiv(self, value): + self.equiv.append(value) + def insert_equiv_at(self, index, value): + self.equiv.insert(index, value) + def replace_equiv_at(self, index, value): + self.equiv[index] = value + def get_prop(self): + return self.prop + def set_prop(self, prop): + self.prop = prop + def add_prop(self, value): + self.prop.append(value) + def insert_prop_at(self, index, value): + self.prop.insert(index, value) + def replace_prop_at(self, index, value): + self.prop[index] = value + def get_le(self): + return self.le + def set_le(self, le): + self.le = le + def add_le(self, value): + self.le.append(value) + def insert_le_at(self, index, value): + self.le.insert(index, value) + def replace_le_at(self, index, value): + self.le[index] = value + def get_ge(self): + return self.ge + def set_ge(self, ge): + self.ge = ge + def add_ge(self, value): + self.ge.append(value) + def insert_ge_at(self, index, value): + self.ge.insert(index, value) + def replace_ge_at(self, index, value): + self.ge[index] = value + def get_larr(self): + return self.larr + def set_larr(self, larr): + self.larr = larr + def add_larr(self, value): + self.larr.append(value) + def insert_larr_at(self, index, value): + self.larr.insert(index, value) + def replace_larr_at(self, index, value): + self.larr[index] = value + def get_rarr(self): + return self.rarr + def set_rarr(self, rarr): + self.rarr = rarr + def add_rarr(self, value): + self.rarr.append(value) + def insert_rarr_at(self, index, value): + self.rarr.insert(index, value) + def replace_rarr_at(self, index, value): + self.rarr[index] = value + def get_isin(self): + return self.isin + def set_isin(self, isin): + self.isin = isin + def add_isin(self, value): + self.isin.append(value) + def insert_isin_at(self, index, value): + self.isin.insert(index, value) + def replace_isin_at(self, index, value): + self.isin[index] = value + def get_notin(self): + return self.notin + def set_notin(self, notin): + self.notin = notin + def add_notin(self, value): + self.notin.append(value) + def insert_notin_at(self, index, value): + self.notin.insert(index, value) + def replace_notin_at(self, index, value): + self.notin[index] = value + def get_lceil(self): + return self.lceil + def set_lceil(self, lceil): + self.lceil = lceil + def add_lceil(self, value): + self.lceil.append(value) + def insert_lceil_at(self, index, value): + self.lceil.insert(index, value) + def replace_lceil_at(self, index, value): + self.lceil[index] = value + def get_rceil(self): + return self.rceil + def set_rceil(self, rceil): + self.rceil = rceil + def add_rceil(self, value): + self.rceil.append(value) + def insert_rceil_at(self, index, value): + self.rceil.insert(index, value) + def replace_rceil_at(self, index, value): + self.rceil[index] = value + def get_lfloor(self): + return self.lfloor + def set_lfloor(self, lfloor): + self.lfloor = lfloor + def add_lfloor(self, value): + self.lfloor.append(value) + def insert_lfloor_at(self, index, value): + self.lfloor.insert(index, value) + def replace_lfloor_at(self, index, value): + self.lfloor[index] = value + def get_rfloor(self): + return self.rfloor + def set_rfloor(self, rfloor): + self.rfloor = rfloor + def add_rfloor(self, value): + self.rfloor.append(value) + def insert_rfloor_at(self, index, value): + self.rfloor.insert(index, value) + def replace_rfloor_at(self, index, value): + self.rfloor[index] = value + def get_level(self): + return self.level + def set_level(self, level): + self.level = level + def get_valueOf_(self): return self.valueOf_ + def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def hasContent_(self): + if ( + self.ulink or + self.bold or + self.emphasis or + self.computeroutput or + self.subscript or + self.superscript or + self.center or + self.small or + self.htmlonly or + self.manonly or + self.xmlonly or + self.rtfonly or + self.latexonly or + self.dot or + self.msc or + self.anchor or + self.formula or + self.ref or + self.copy or + self.trademark or + self.registered or + self.lsquo or + self.rsquo or + self.ldquo or + self.rdquo or + self.ndash or + self.mdash or + self.umlaut or + self.acute or + self.grave or + self.circ or + self.slash or + self.tilde or + self.cedil or + self.ring or + self.szlig or + self.nonbreakablespace or + self.aelig or + self.AElig or + self.Gamma or + self.Delta or + self.Theta or + self.Lambda or + self.Xi or + self.Pi or + self.Sigma or + self.Upsilon or + self.Phi or + self.Psi or + self.Omega or + self.alpha or + self.beta or + self.gamma or + self.delta or + self.epsilon or + self.zeta or + self.eta or + self.theta or + self.iota or + self.kappa or + self.lambda_ or + self.mu or + self.nu or + self.xi or + self.pi or + self.rho or + self.sigma or + self.tau or + self.upsilon or + self.phi or + self.chi or + self.psi or + self.omega or + self.sigmaf or + self.sect or + self.deg or + self.prime or + self.Prime or + self.infin or + self.empty or + self.plusmn or + self.times or + self.minus or + self.sdot or + self.part or + self.nabla or + self.radic or + self.perp or + self.sum or + self.int or + self.prod or + self.sim or + self.asymp or + self.ne or + self.equiv or + self.prop or + self.le or + self.ge or + self.larr or + self.rarr or + self.isin or + self.notin or + self.lceil or + self.rceil or + self.lfloor or + self.rfloor or + (1 if type(self.valueOf_) in [int,float] else self.valueOf_) or + self.content_ + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docHeadingType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docHeadingType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docHeadingType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docHeadingType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docHeadingType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docHeadingType'): + if self.level is not None and 'level' not in already_processed: + already_processed.add('level') + outfile.write(' level="%s"' % self.gds_format_integer(self.level, input_name='level')) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docHeadingType', fromsubclass_=False, pretty_print=True): + if not fromsubclass_: + for item_ in self.content_: + item_.export(outfile, level, item_.name, namespaceprefix_, pretty_print=pretty_print) + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for ulink_ in self.ulink: + namespaceprefix_ = self.ulink_nsprefix_ + ':' if (UseCapturedNS_ and self.ulink_nsprefix_) else '' + ulink_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ulink', pretty_print=pretty_print) + for bold_ in self.bold: + namespaceprefix_ = self.bold_nsprefix_ + ':' if (UseCapturedNS_ and self.bold_nsprefix_) else '' + bold_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='bold', pretty_print=pretty_print) + for emphasis_ in self.emphasis: + namespaceprefix_ = self.emphasis_nsprefix_ + ':' if (UseCapturedNS_ and self.emphasis_nsprefix_) else '' + emphasis_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='emphasis', pretty_print=pretty_print) + for computeroutput_ in self.computeroutput: + namespaceprefix_ = self.computeroutput_nsprefix_ + ':' if (UseCapturedNS_ and self.computeroutput_nsprefix_) else '' + computeroutput_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='computeroutput', pretty_print=pretty_print) + for subscript_ in self.subscript: + namespaceprefix_ = self.subscript_nsprefix_ + ':' if (UseCapturedNS_ and self.subscript_nsprefix_) else '' + subscript_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='subscript', pretty_print=pretty_print) + for superscript_ in self.superscript: + namespaceprefix_ = self.superscript_nsprefix_ + ':' if (UseCapturedNS_ and self.superscript_nsprefix_) else '' + superscript_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='superscript', pretty_print=pretty_print) + for center_ in self.center: + namespaceprefix_ = self.center_nsprefix_ + ':' if (UseCapturedNS_ and self.center_nsprefix_) else '' + center_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='center', pretty_print=pretty_print) + for small_ in self.small: + namespaceprefix_ = self.small_nsprefix_ + ':' if (UseCapturedNS_ and self.small_nsprefix_) else '' + small_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='small', pretty_print=pretty_print) + for htmlonly_ in self.htmlonly: + namespaceprefix_ = self.htmlonly_nsprefix_ + ':' if (UseCapturedNS_ and self.htmlonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%shtmlonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(htmlonly_), input_name='htmlonly')), namespaceprefix_ , eol_)) + for manonly_ in self.manonly: + namespaceprefix_ = self.manonly_nsprefix_ + ':' if (UseCapturedNS_ and self.manonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%smanonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(manonly_), input_name='manonly')), namespaceprefix_ , eol_)) + for xmlonly_ in self.xmlonly: + namespaceprefix_ = self.xmlonly_nsprefix_ + ':' if (UseCapturedNS_ and self.xmlonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%sxmlonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(xmlonly_), input_name='xmlonly')), namespaceprefix_ , eol_)) + for rtfonly_ in self.rtfonly: + namespaceprefix_ = self.rtfonly_nsprefix_ + ':' if (UseCapturedNS_ and self.rtfonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%srtfonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(rtfonly_), input_name='rtfonly')), namespaceprefix_ , eol_)) + for latexonly_ in self.latexonly: + namespaceprefix_ = self.latexonly_nsprefix_ + ':' if (UseCapturedNS_ and self.latexonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%slatexonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(latexonly_), input_name='latexonly')), namespaceprefix_ , eol_)) + for dot_ in self.dot: + namespaceprefix_ = self.dot_nsprefix_ + ':' if (UseCapturedNS_ and self.dot_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%sdot>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(dot_), input_name='dot')), namespaceprefix_ , eol_)) + for msc_ in self.msc: + namespaceprefix_ = self.msc_nsprefix_ + ':' if (UseCapturedNS_ and self.msc_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%smsc>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(msc_), input_name='msc')), namespaceprefix_ , eol_)) + for anchor_ in self.anchor: + namespaceprefix_ = self.anchor_nsprefix_ + ':' if (UseCapturedNS_ and self.anchor_nsprefix_) else '' + anchor_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='anchor', pretty_print=pretty_print) + for formula_ in self.formula: + namespaceprefix_ = self.formula_nsprefix_ + ':' if (UseCapturedNS_ and self.formula_nsprefix_) else '' + formula_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='formula', pretty_print=pretty_print) + for ref_ in self.ref: + namespaceprefix_ = self.ref_nsprefix_ + ':' if (UseCapturedNS_ and self.ref_nsprefix_) else '' + ref_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ref', pretty_print=pretty_print) + for copy_ in self.copy: + namespaceprefix_ = self.copy_nsprefix_ + ':' if (UseCapturedNS_ and self.copy_nsprefix_) else '' + copy_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='copy', pretty_print=pretty_print) + for trademark_ in self.trademark: + namespaceprefix_ = self.trademark_nsprefix_ + ':' if (UseCapturedNS_ and self.trademark_nsprefix_) else '' + trademark_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='trademark', pretty_print=pretty_print) + for registered_ in self.registered: + namespaceprefix_ = self.registered_nsprefix_ + ':' if (UseCapturedNS_ and self.registered_nsprefix_) else '' + registered_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='registered', pretty_print=pretty_print) + for lsquo_ in self.lsquo: + namespaceprefix_ = self.lsquo_nsprefix_ + ':' if (UseCapturedNS_ and self.lsquo_nsprefix_) else '' + lsquo_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='lsquo', pretty_print=pretty_print) + for rsquo_ in self.rsquo: + namespaceprefix_ = self.rsquo_nsprefix_ + ':' if (UseCapturedNS_ and self.rsquo_nsprefix_) else '' + rsquo_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rsquo', pretty_print=pretty_print) + for ldquo_ in self.ldquo: + namespaceprefix_ = self.ldquo_nsprefix_ + ':' if (UseCapturedNS_ and self.ldquo_nsprefix_) else '' + ldquo_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ldquo', pretty_print=pretty_print) + for rdquo_ in self.rdquo: + namespaceprefix_ = self.rdquo_nsprefix_ + ':' if (UseCapturedNS_ and self.rdquo_nsprefix_) else '' + rdquo_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rdquo', pretty_print=pretty_print) + for ndash_ in self.ndash: + namespaceprefix_ = self.ndash_nsprefix_ + ':' if (UseCapturedNS_ and self.ndash_nsprefix_) else '' + ndash_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ndash', pretty_print=pretty_print) + for mdash_ in self.mdash: + namespaceprefix_ = self.mdash_nsprefix_ + ':' if (UseCapturedNS_ and self.mdash_nsprefix_) else '' + mdash_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='mdash', pretty_print=pretty_print) + for umlaut_ in self.umlaut: + namespaceprefix_ = self.umlaut_nsprefix_ + ':' if (UseCapturedNS_ and self.umlaut_nsprefix_) else '' + umlaut_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='umlaut', pretty_print=pretty_print) + for acute_ in self.acute: + namespaceprefix_ = self.acute_nsprefix_ + ':' if (UseCapturedNS_ and self.acute_nsprefix_) else '' + acute_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='acute', pretty_print=pretty_print) + for grave_ in self.grave: + namespaceprefix_ = self.grave_nsprefix_ + ':' if (UseCapturedNS_ and self.grave_nsprefix_) else '' + grave_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='grave', pretty_print=pretty_print) + for circ_ in self.circ: + namespaceprefix_ = self.circ_nsprefix_ + ':' if (UseCapturedNS_ and self.circ_nsprefix_) else '' + circ_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='circ', pretty_print=pretty_print) + for slash_ in self.slash: + namespaceprefix_ = self.slash_nsprefix_ + ':' if (UseCapturedNS_ and self.slash_nsprefix_) else '' + slash_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='slash', pretty_print=pretty_print) + for tilde_ in self.tilde: + namespaceprefix_ = self.tilde_nsprefix_ + ':' if (UseCapturedNS_ and self.tilde_nsprefix_) else '' + tilde_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='tilde', pretty_print=pretty_print) + for cedil_ in self.cedil: + namespaceprefix_ = self.cedil_nsprefix_ + ':' if (UseCapturedNS_ and self.cedil_nsprefix_) else '' + cedil_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='cedil', pretty_print=pretty_print) + for ring_ in self.ring: + namespaceprefix_ = self.ring_nsprefix_ + ':' if (UseCapturedNS_ and self.ring_nsprefix_) else '' + ring_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ring', pretty_print=pretty_print) + for szlig_ in self.szlig: + namespaceprefix_ = self.szlig_nsprefix_ + ':' if (UseCapturedNS_ and self.szlig_nsprefix_) else '' + szlig_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='szlig', pretty_print=pretty_print) + for nonbreakablespace_ in self.nonbreakablespace: + namespaceprefix_ = self.nonbreakablespace_nsprefix_ + ':' if (UseCapturedNS_ and self.nonbreakablespace_nsprefix_) else '' + nonbreakablespace_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='nonbreakablespace', pretty_print=pretty_print) + for aelig_ in self.aelig: + namespaceprefix_ = self.aelig_nsprefix_ + ':' if (UseCapturedNS_ and self.aelig_nsprefix_) else '' + aelig_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='aelig', pretty_print=pretty_print) + for AElig_ in self.AElig: + namespaceprefix_ = self.AElig_nsprefix_ + ':' if (UseCapturedNS_ and self.AElig_nsprefix_) else '' + AElig_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='AElig', pretty_print=pretty_print) + for Gamma_ in self.Gamma: + namespaceprefix_ = self.Gamma_nsprefix_ + ':' if (UseCapturedNS_ and self.Gamma_nsprefix_) else '' + Gamma_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Gamma', pretty_print=pretty_print) + for Delta_ in self.Delta: + namespaceprefix_ = self.Delta_nsprefix_ + ':' if (UseCapturedNS_ and self.Delta_nsprefix_) else '' + Delta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Delta', pretty_print=pretty_print) + for Theta_ in self.Theta: + namespaceprefix_ = self.Theta_nsprefix_ + ':' if (UseCapturedNS_ and self.Theta_nsprefix_) else '' + Theta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Theta', pretty_print=pretty_print) + for Lambda_ in self.Lambda: + namespaceprefix_ = self.Lambda_nsprefix_ + ':' if (UseCapturedNS_ and self.Lambda_nsprefix_) else '' + Lambda_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Lambda', pretty_print=pretty_print) + for Xi_ in self.Xi: + namespaceprefix_ = self.Xi_nsprefix_ + ':' if (UseCapturedNS_ and self.Xi_nsprefix_) else '' + Xi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Xi', pretty_print=pretty_print) + for Pi_ in self.Pi: + namespaceprefix_ = self.Pi_nsprefix_ + ':' if (UseCapturedNS_ and self.Pi_nsprefix_) else '' + Pi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Pi', pretty_print=pretty_print) + for Sigma_ in self.Sigma: + namespaceprefix_ = self.Sigma_nsprefix_ + ':' if (UseCapturedNS_ and self.Sigma_nsprefix_) else '' + Sigma_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Sigma', pretty_print=pretty_print) + for Upsilon_ in self.Upsilon: + namespaceprefix_ = self.Upsilon_nsprefix_ + ':' if (UseCapturedNS_ and self.Upsilon_nsprefix_) else '' + Upsilon_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Upsilon', pretty_print=pretty_print) + for Phi_ in self.Phi: + namespaceprefix_ = self.Phi_nsprefix_ + ':' if (UseCapturedNS_ and self.Phi_nsprefix_) else '' + Phi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Phi', pretty_print=pretty_print) + for Psi_ in self.Psi: + namespaceprefix_ = self.Psi_nsprefix_ + ':' if (UseCapturedNS_ and self.Psi_nsprefix_) else '' + Psi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Psi', pretty_print=pretty_print) + for Omega_ in self.Omega: + namespaceprefix_ = self.Omega_nsprefix_ + ':' if (UseCapturedNS_ and self.Omega_nsprefix_) else '' + Omega_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Omega', pretty_print=pretty_print) + for alpha_ in self.alpha: + namespaceprefix_ = self.alpha_nsprefix_ + ':' if (UseCapturedNS_ and self.alpha_nsprefix_) else '' + alpha_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='alpha', pretty_print=pretty_print) + for beta_ in self.beta: + namespaceprefix_ = self.beta_nsprefix_ + ':' if (UseCapturedNS_ and self.beta_nsprefix_) else '' + beta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='beta', pretty_print=pretty_print) + for gamma_ in self.gamma: + namespaceprefix_ = self.gamma_nsprefix_ + ':' if (UseCapturedNS_ and self.gamma_nsprefix_) else '' + gamma_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='gamma', pretty_print=pretty_print) + for delta_ in self.delta: + namespaceprefix_ = self.delta_nsprefix_ + ':' if (UseCapturedNS_ and self.delta_nsprefix_) else '' + delta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='delta', pretty_print=pretty_print) + for epsilon_ in self.epsilon: + namespaceprefix_ = self.epsilon_nsprefix_ + ':' if (UseCapturedNS_ and self.epsilon_nsprefix_) else '' + epsilon_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='epsilon', pretty_print=pretty_print) + for zeta_ in self.zeta: + namespaceprefix_ = self.zeta_nsprefix_ + ':' if (UseCapturedNS_ and self.zeta_nsprefix_) else '' + zeta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='zeta', pretty_print=pretty_print) + for eta_ in self.eta: + namespaceprefix_ = self.eta_nsprefix_ + ':' if (UseCapturedNS_ and self.eta_nsprefix_) else '' + eta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='eta', pretty_print=pretty_print) + for theta_ in self.theta: + namespaceprefix_ = self.theta_nsprefix_ + ':' if (UseCapturedNS_ and self.theta_nsprefix_) else '' + theta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='theta', pretty_print=pretty_print) + for iota_ in self.iota: + namespaceprefix_ = self.iota_nsprefix_ + ':' if (UseCapturedNS_ and self.iota_nsprefix_) else '' + iota_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='iota', pretty_print=pretty_print) + for kappa_ in self.kappa: + namespaceprefix_ = self.kappa_nsprefix_ + ':' if (UseCapturedNS_ and self.kappa_nsprefix_) else '' + kappa_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='kappa', pretty_print=pretty_print) + for lambda_ in self.lambda_: + namespaceprefix_ = self.lambda__nsprefix_ + ':' if (UseCapturedNS_ and self.lambda__nsprefix_) else '' + lambda_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='lambda', pretty_print=pretty_print) + for mu_ in self.mu: + namespaceprefix_ = self.mu_nsprefix_ + ':' if (UseCapturedNS_ and self.mu_nsprefix_) else '' + mu_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='mu', pretty_print=pretty_print) + for nu_ in self.nu: + namespaceprefix_ = self.nu_nsprefix_ + ':' if (UseCapturedNS_ and self.nu_nsprefix_) else '' + nu_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='nu', pretty_print=pretty_print) + for xi_ in self.xi: + namespaceprefix_ = self.xi_nsprefix_ + ':' if (UseCapturedNS_ and self.xi_nsprefix_) else '' + xi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='xi', pretty_print=pretty_print) + for pi_ in self.pi: + namespaceprefix_ = self.pi_nsprefix_ + ':' if (UseCapturedNS_ and self.pi_nsprefix_) else '' + pi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='pi', pretty_print=pretty_print) + for rho_ in self.rho: + namespaceprefix_ = self.rho_nsprefix_ + ':' if (UseCapturedNS_ and self.rho_nsprefix_) else '' + rho_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rho', pretty_print=pretty_print) + for sigma_ in self.sigma: + namespaceprefix_ = self.sigma_nsprefix_ + ':' if (UseCapturedNS_ and self.sigma_nsprefix_) else '' + sigma_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sigma', pretty_print=pretty_print) + for tau_ in self.tau: + namespaceprefix_ = self.tau_nsprefix_ + ':' if (UseCapturedNS_ and self.tau_nsprefix_) else '' + tau_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='tau', pretty_print=pretty_print) + for upsilon_ in self.upsilon: + namespaceprefix_ = self.upsilon_nsprefix_ + ':' if (UseCapturedNS_ and self.upsilon_nsprefix_) else '' + upsilon_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='upsilon', pretty_print=pretty_print) + for phi_ in self.phi: + namespaceprefix_ = self.phi_nsprefix_ + ':' if (UseCapturedNS_ and self.phi_nsprefix_) else '' + phi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='phi', pretty_print=pretty_print) + for chi_ in self.chi: + namespaceprefix_ = self.chi_nsprefix_ + ':' if (UseCapturedNS_ and self.chi_nsprefix_) else '' + chi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='chi', pretty_print=pretty_print) + for psi_ in self.psi: + namespaceprefix_ = self.psi_nsprefix_ + ':' if (UseCapturedNS_ and self.psi_nsprefix_) else '' + psi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='psi', pretty_print=pretty_print) + for omega_ in self.omega: + namespaceprefix_ = self.omega_nsprefix_ + ':' if (UseCapturedNS_ and self.omega_nsprefix_) else '' + omega_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='omega', pretty_print=pretty_print) + for sigmaf_ in self.sigmaf: + namespaceprefix_ = self.sigmaf_nsprefix_ + ':' if (UseCapturedNS_ and self.sigmaf_nsprefix_) else '' + sigmaf_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sigmaf', pretty_print=pretty_print) + for sect_ in self.sect: + namespaceprefix_ = self.sect_nsprefix_ + ':' if (UseCapturedNS_ and self.sect_nsprefix_) else '' + sect_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sect', pretty_print=pretty_print) + for deg_ in self.deg: + namespaceprefix_ = self.deg_nsprefix_ + ':' if (UseCapturedNS_ and self.deg_nsprefix_) else '' + deg_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='deg', pretty_print=pretty_print) + for prime_ in self.prime: + namespaceprefix_ = self.prime_nsprefix_ + ':' if (UseCapturedNS_ and self.prime_nsprefix_) else '' + prime_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='prime', pretty_print=pretty_print) + for Prime_ in self.Prime: + namespaceprefix_ = self.Prime_nsprefix_ + ':' if (UseCapturedNS_ and self.Prime_nsprefix_) else '' + Prime_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Prime', pretty_print=pretty_print) + for infin_ in self.infin: + namespaceprefix_ = self.infin_nsprefix_ + ':' if (UseCapturedNS_ and self.infin_nsprefix_) else '' + infin_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='infin', pretty_print=pretty_print) + for empty_ in self.empty: + namespaceprefix_ = self.empty_nsprefix_ + ':' if (UseCapturedNS_ and self.empty_nsprefix_) else '' + empty_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='empty', pretty_print=pretty_print) + for plusmn_ in self.plusmn: + namespaceprefix_ = self.plusmn_nsprefix_ + ':' if (UseCapturedNS_ and self.plusmn_nsprefix_) else '' + plusmn_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='plusmn', pretty_print=pretty_print) + for times_ in self.times: + namespaceprefix_ = self.times_nsprefix_ + ':' if (UseCapturedNS_ and self.times_nsprefix_) else '' + times_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='times', pretty_print=pretty_print) + for minus_ in self.minus: + namespaceprefix_ = self.minus_nsprefix_ + ':' if (UseCapturedNS_ and self.minus_nsprefix_) else '' + minus_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='minus', pretty_print=pretty_print) + for sdot_ in self.sdot: + namespaceprefix_ = self.sdot_nsprefix_ + ':' if (UseCapturedNS_ and self.sdot_nsprefix_) else '' + sdot_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sdot', pretty_print=pretty_print) + for part_ in self.part: + namespaceprefix_ = self.part_nsprefix_ + ':' if (UseCapturedNS_ and self.part_nsprefix_) else '' + part_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='part', pretty_print=pretty_print) + for nabla_ in self.nabla: + namespaceprefix_ = self.nabla_nsprefix_ + ':' if (UseCapturedNS_ and self.nabla_nsprefix_) else '' + nabla_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='nabla', pretty_print=pretty_print) + for radic_ in self.radic: + namespaceprefix_ = self.radic_nsprefix_ + ':' if (UseCapturedNS_ and self.radic_nsprefix_) else '' + radic_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='radic', pretty_print=pretty_print) + for perp_ in self.perp: + namespaceprefix_ = self.perp_nsprefix_ + ':' if (UseCapturedNS_ and self.perp_nsprefix_) else '' + perp_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='perp', pretty_print=pretty_print) + for sum_ in self.sum: + namespaceprefix_ = self.sum_nsprefix_ + ':' if (UseCapturedNS_ and self.sum_nsprefix_) else '' + sum_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sum', pretty_print=pretty_print) + for int_ in self.int: + namespaceprefix_ = self.int_nsprefix_ + ':' if (UseCapturedNS_ and self.int_nsprefix_) else '' + int_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='int', pretty_print=pretty_print) + for prod_ in self.prod: + namespaceprefix_ = self.prod_nsprefix_ + ':' if (UseCapturedNS_ and self.prod_nsprefix_) else '' + prod_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='prod', pretty_print=pretty_print) + for sim_ in self.sim: + namespaceprefix_ = self.sim_nsprefix_ + ':' if (UseCapturedNS_ and self.sim_nsprefix_) else '' + sim_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sim', pretty_print=pretty_print) + for asymp_ in self.asymp: + namespaceprefix_ = self.asymp_nsprefix_ + ':' if (UseCapturedNS_ and self.asymp_nsprefix_) else '' + asymp_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='asymp', pretty_print=pretty_print) + for ne_ in self.ne: + namespaceprefix_ = self.ne_nsprefix_ + ':' if (UseCapturedNS_ and self.ne_nsprefix_) else '' + ne_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ne', pretty_print=pretty_print) + for equiv_ in self.equiv: + namespaceprefix_ = self.equiv_nsprefix_ + ':' if (UseCapturedNS_ and self.equiv_nsprefix_) else '' + equiv_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='equiv', pretty_print=pretty_print) + for prop_ in self.prop: + namespaceprefix_ = self.prop_nsprefix_ + ':' if (UseCapturedNS_ and self.prop_nsprefix_) else '' + prop_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='prop', pretty_print=pretty_print) + for le_ in self.le: + namespaceprefix_ = self.le_nsprefix_ + ':' if (UseCapturedNS_ and self.le_nsprefix_) else '' + le_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='le', pretty_print=pretty_print) + for ge_ in self.ge: + namespaceprefix_ = self.ge_nsprefix_ + ':' if (UseCapturedNS_ and self.ge_nsprefix_) else '' + ge_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ge', pretty_print=pretty_print) + for larr_ in self.larr: + namespaceprefix_ = self.larr_nsprefix_ + ':' if (UseCapturedNS_ and self.larr_nsprefix_) else '' + larr_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='larr', pretty_print=pretty_print) + for rarr_ in self.rarr: + namespaceprefix_ = self.rarr_nsprefix_ + ':' if (UseCapturedNS_ and self.rarr_nsprefix_) else '' + rarr_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rarr', pretty_print=pretty_print) + for isin_ in self.isin: + namespaceprefix_ = self.isin_nsprefix_ + ':' if (UseCapturedNS_ and self.isin_nsprefix_) else '' + isin_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='isin', pretty_print=pretty_print) + for notin_ in self.notin: + namespaceprefix_ = self.notin_nsprefix_ + ':' if (UseCapturedNS_ and self.notin_nsprefix_) else '' + notin_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='notin', pretty_print=pretty_print) + for lceil_ in self.lceil: + namespaceprefix_ = self.lceil_nsprefix_ + ':' if (UseCapturedNS_ and self.lceil_nsprefix_) else '' + lceil_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='lceil', pretty_print=pretty_print) + for rceil_ in self.rceil: + namespaceprefix_ = self.rceil_nsprefix_ + ':' if (UseCapturedNS_ and self.rceil_nsprefix_) else '' + rceil_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rceil', pretty_print=pretty_print) + for lfloor_ in self.lfloor: + namespaceprefix_ = self.lfloor_nsprefix_ + ':' if (UseCapturedNS_ and self.lfloor_nsprefix_) else '' + lfloor_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='lfloor', pretty_print=pretty_print) + for rfloor_ in self.rfloor: + namespaceprefix_ = self.rfloor_nsprefix_ + ':' if (UseCapturedNS_ and self.rfloor_nsprefix_) else '' + rfloor_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rfloor', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + self.valueOf_ = get_all_text_(node) + if node.text is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', node.text) + self.content_.append(obj_) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('level', node) + if value is not None and 'level' not in already_processed: + already_processed.add('level') + self.level = self.gds_parse_integer(value, node, 'level') + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'ulink': + obj_ = docURLLink.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ulink', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ulink'): + self.add_ulink(obj_.value) + elif hasattr(self, 'set_ulink'): + self.set_ulink(obj_.value) + elif nodeName_ == 'bold': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'bold', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_bold'): + self.add_bold(obj_.value) + elif hasattr(self, 'set_bold'): + self.set_bold(obj_.value) + elif nodeName_ == 'emphasis': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'emphasis', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_emphasis'): + self.add_emphasis(obj_.value) + elif hasattr(self, 'set_emphasis'): + self.set_emphasis(obj_.value) + elif nodeName_ == 'computeroutput': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'computeroutput', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_computeroutput'): + self.add_computeroutput(obj_.value) + elif hasattr(self, 'set_computeroutput'): + self.set_computeroutput(obj_.value) + elif nodeName_ == 'subscript': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'subscript', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_subscript'): + self.add_subscript(obj_.value) + elif hasattr(self, 'set_subscript'): + self.set_subscript(obj_.value) + elif nodeName_ == 'superscript': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'superscript', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_superscript'): + self.add_superscript(obj_.value) + elif hasattr(self, 'set_superscript'): + self.set_superscript(obj_.value) + elif nodeName_ == 'center': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'center', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_center'): + self.add_center(obj_.value) + elif hasattr(self, 'set_center'): + self.set_center(obj_.value) + elif nodeName_ == 'small': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'small', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_small'): + self.add_small(obj_.value) + elif hasattr(self, 'set_small'): + self.set_small(obj_.value) + elif nodeName_ == 'htmlonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'htmlonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'htmlonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'htmlonly', valuestr_) + self.content_.append(obj_) + self.htmlonly_nsprefix_ = child_.prefix + elif nodeName_ == 'manonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'manonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'manonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'manonly', valuestr_) + self.content_.append(obj_) + self.manonly_nsprefix_ = child_.prefix + elif nodeName_ == 'xmlonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'xmlonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'xmlonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'xmlonly', valuestr_) + self.content_.append(obj_) + self.xmlonly_nsprefix_ = child_.prefix + elif nodeName_ == 'rtfonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'rtfonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'rtfonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'rtfonly', valuestr_) + self.content_.append(obj_) + self.rtfonly_nsprefix_ = child_.prefix + elif nodeName_ == 'latexonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'latexonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'latexonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'latexonly', valuestr_) + self.content_.append(obj_) + self.latexonly_nsprefix_ = child_.prefix + elif nodeName_ == 'dot' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'dot') + valuestr_ = self.gds_validate_string(valuestr_, node, 'dot') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'dot', valuestr_) + self.content_.append(obj_) + self.dot_nsprefix_ = child_.prefix + elif nodeName_ == 'msc' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'msc') + valuestr_ = self.gds_validate_string(valuestr_, node, 'msc') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'msc', valuestr_) + self.content_.append(obj_) + self.msc_nsprefix_ = child_.prefix + elif nodeName_ == 'anchor': + obj_ = docAnchorType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'anchor', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_anchor'): + self.add_anchor(obj_.value) + elif hasattr(self, 'set_anchor'): + self.set_anchor(obj_.value) + elif nodeName_ == 'formula': + obj_ = docFormulaType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'formula', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_formula'): + self.add_formula(obj_.value) + elif hasattr(self, 'set_formula'): + self.set_formula(obj_.value) + elif nodeName_ == 'ref': + obj_ = docRefTextType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ref', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ref'): + self.add_ref(obj_.value) + elif hasattr(self, 'set_ref'): + self.set_ref(obj_.value) + elif nodeName_ == 'copy': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'copy', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_copy'): + self.add_copy(obj_.value) + elif hasattr(self, 'set_copy'): + self.set_copy(obj_.value) + elif nodeName_ == 'trademark': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'trademark', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_trademark'): + self.add_trademark(obj_.value) + elif hasattr(self, 'set_trademark'): + self.set_trademark(obj_.value) + elif nodeName_ == 'registered': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'registered', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_registered'): + self.add_registered(obj_.value) + elif hasattr(self, 'set_registered'): + self.set_registered(obj_.value) + elif nodeName_ == 'lsquo': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'lsquo', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_lsquo'): + self.add_lsquo(obj_.value) + elif hasattr(self, 'set_lsquo'): + self.set_lsquo(obj_.value) + elif nodeName_ == 'rsquo': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rsquo', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rsquo'): + self.add_rsquo(obj_.value) + elif hasattr(self, 'set_rsquo'): + self.set_rsquo(obj_.value) + elif nodeName_ == 'ldquo': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ldquo', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ldquo'): + self.add_ldquo(obj_.value) + elif hasattr(self, 'set_ldquo'): + self.set_ldquo(obj_.value) + elif nodeName_ == 'rdquo': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rdquo', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rdquo'): + self.add_rdquo(obj_.value) + elif hasattr(self, 'set_rdquo'): + self.set_rdquo(obj_.value) + elif nodeName_ == 'ndash': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ndash', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ndash'): + self.add_ndash(obj_.value) + elif hasattr(self, 'set_ndash'): + self.set_ndash(obj_.value) + elif nodeName_ == 'mdash': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'mdash', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_mdash'): + self.add_mdash(obj_.value) + elif hasattr(self, 'set_mdash'): + self.set_mdash(obj_.value) + elif nodeName_ == 'umlaut': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'umlaut', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_umlaut'): + self.add_umlaut(obj_.value) + elif hasattr(self, 'set_umlaut'): + self.set_umlaut(obj_.value) + elif nodeName_ == 'acute': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'acute', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_acute'): + self.add_acute(obj_.value) + elif hasattr(self, 'set_acute'): + self.set_acute(obj_.value) + elif nodeName_ == 'grave': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'grave', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_grave'): + self.add_grave(obj_.value) + elif hasattr(self, 'set_grave'): + self.set_grave(obj_.value) + elif nodeName_ == 'circ': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'circ', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_circ'): + self.add_circ(obj_.value) + elif hasattr(self, 'set_circ'): + self.set_circ(obj_.value) + elif nodeName_ == 'slash': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'slash', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_slash'): + self.add_slash(obj_.value) + elif hasattr(self, 'set_slash'): + self.set_slash(obj_.value) + elif nodeName_ == 'tilde': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'tilde', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_tilde'): + self.add_tilde(obj_.value) + elif hasattr(self, 'set_tilde'): + self.set_tilde(obj_.value) + elif nodeName_ == 'cedil': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'cedil', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_cedil'): + self.add_cedil(obj_.value) + elif hasattr(self, 'set_cedil'): + self.set_cedil(obj_.value) + elif nodeName_ == 'ring': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ring', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ring'): + self.add_ring(obj_.value) + elif hasattr(self, 'set_ring'): + self.set_ring(obj_.value) + elif nodeName_ == 'szlig': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'szlig', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_szlig'): + self.add_szlig(obj_.value) + elif hasattr(self, 'set_szlig'): + self.set_szlig(obj_.value) + elif nodeName_ == 'nonbreakablespace': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'nonbreakablespace', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_nonbreakablespace'): + self.add_nonbreakablespace(obj_.value) + elif hasattr(self, 'set_nonbreakablespace'): + self.set_nonbreakablespace(obj_.value) + elif nodeName_ == 'aelig': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'aelig', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_aelig'): + self.add_aelig(obj_.value) + elif hasattr(self, 'set_aelig'): + self.set_aelig(obj_.value) + elif nodeName_ == 'AElig': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'AElig', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_AElig'): + self.add_AElig(obj_.value) + elif hasattr(self, 'set_AElig'): + self.set_AElig(obj_.value) + elif nodeName_ == 'Gamma': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Gamma', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Gamma'): + self.add_Gamma(obj_.value) + elif hasattr(self, 'set_Gamma'): + self.set_Gamma(obj_.value) + elif nodeName_ == 'Delta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Delta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Delta'): + self.add_Delta(obj_.value) + elif hasattr(self, 'set_Delta'): + self.set_Delta(obj_.value) + elif nodeName_ == 'Theta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Theta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Theta'): + self.add_Theta(obj_.value) + elif hasattr(self, 'set_Theta'): + self.set_Theta(obj_.value) + elif nodeName_ == 'Lambda': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Lambda', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Lambda'): + self.add_Lambda(obj_.value) + elif hasattr(self, 'set_Lambda'): + self.set_Lambda(obj_.value) + elif nodeName_ == 'Xi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Xi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Xi'): + self.add_Xi(obj_.value) + elif hasattr(self, 'set_Xi'): + self.set_Xi(obj_.value) + elif nodeName_ == 'Pi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Pi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Pi'): + self.add_Pi(obj_.value) + elif hasattr(self, 'set_Pi'): + self.set_Pi(obj_.value) + elif nodeName_ == 'Sigma': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Sigma', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Sigma'): + self.add_Sigma(obj_.value) + elif hasattr(self, 'set_Sigma'): + self.set_Sigma(obj_.value) + elif nodeName_ == 'Upsilon': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Upsilon', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Upsilon'): + self.add_Upsilon(obj_.value) + elif hasattr(self, 'set_Upsilon'): + self.set_Upsilon(obj_.value) + elif nodeName_ == 'Phi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Phi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Phi'): + self.add_Phi(obj_.value) + elif hasattr(self, 'set_Phi'): + self.set_Phi(obj_.value) + elif nodeName_ == 'Psi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Psi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Psi'): + self.add_Psi(obj_.value) + elif hasattr(self, 'set_Psi'): + self.set_Psi(obj_.value) + elif nodeName_ == 'Omega': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Omega', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Omega'): + self.add_Omega(obj_.value) + elif hasattr(self, 'set_Omega'): + self.set_Omega(obj_.value) + elif nodeName_ == 'alpha': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'alpha', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_alpha'): + self.add_alpha(obj_.value) + elif hasattr(self, 'set_alpha'): + self.set_alpha(obj_.value) + elif nodeName_ == 'beta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'beta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_beta'): + self.add_beta(obj_.value) + elif hasattr(self, 'set_beta'): + self.set_beta(obj_.value) + elif nodeName_ == 'gamma': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'gamma', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_gamma'): + self.add_gamma(obj_.value) + elif hasattr(self, 'set_gamma'): + self.set_gamma(obj_.value) + elif nodeName_ == 'delta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'delta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_delta'): + self.add_delta(obj_.value) + elif hasattr(self, 'set_delta'): + self.set_delta(obj_.value) + elif nodeName_ == 'epsilon': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'epsilon', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_epsilon'): + self.add_epsilon(obj_.value) + elif hasattr(self, 'set_epsilon'): + self.set_epsilon(obj_.value) + elif nodeName_ == 'zeta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'zeta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_zeta'): + self.add_zeta(obj_.value) + elif hasattr(self, 'set_zeta'): + self.set_zeta(obj_.value) + elif nodeName_ == 'eta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'eta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_eta'): + self.add_eta(obj_.value) + elif hasattr(self, 'set_eta'): + self.set_eta(obj_.value) + elif nodeName_ == 'theta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'theta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_theta'): + self.add_theta(obj_.value) + elif hasattr(self, 'set_theta'): + self.set_theta(obj_.value) + elif nodeName_ == 'iota': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'iota', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_iota'): + self.add_iota(obj_.value) + elif hasattr(self, 'set_iota'): + self.set_iota(obj_.value) + elif nodeName_ == 'kappa': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'kappa', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_kappa'): + self.add_kappa(obj_.value) + elif hasattr(self, 'set_kappa'): + self.set_kappa(obj_.value) + elif nodeName_ == 'lambda': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'lambda', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_lambda'): + self.add_lambda(obj_.value) + elif hasattr(self, 'set_lambda'): + self.set_lambda(obj_.value) + elif nodeName_ == 'mu': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'mu', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_mu'): + self.add_mu(obj_.value) + elif hasattr(self, 'set_mu'): + self.set_mu(obj_.value) + elif nodeName_ == 'nu': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'nu', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_nu'): + self.add_nu(obj_.value) + elif hasattr(self, 'set_nu'): + self.set_nu(obj_.value) + elif nodeName_ == 'xi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'xi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_xi'): + self.add_xi(obj_.value) + elif hasattr(self, 'set_xi'): + self.set_xi(obj_.value) + elif nodeName_ == 'pi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'pi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_pi'): + self.add_pi(obj_.value) + elif hasattr(self, 'set_pi'): + self.set_pi(obj_.value) + elif nodeName_ == 'rho': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rho', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rho'): + self.add_rho(obj_.value) + elif hasattr(self, 'set_rho'): + self.set_rho(obj_.value) + elif nodeName_ == 'sigma': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sigma', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sigma'): + self.add_sigma(obj_.value) + elif hasattr(self, 'set_sigma'): + self.set_sigma(obj_.value) + elif nodeName_ == 'tau': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'tau', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_tau'): + self.add_tau(obj_.value) + elif hasattr(self, 'set_tau'): + self.set_tau(obj_.value) + elif nodeName_ == 'upsilon': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'upsilon', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_upsilon'): + self.add_upsilon(obj_.value) + elif hasattr(self, 'set_upsilon'): + self.set_upsilon(obj_.value) + elif nodeName_ == 'phi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'phi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_phi'): + self.add_phi(obj_.value) + elif hasattr(self, 'set_phi'): + self.set_phi(obj_.value) + elif nodeName_ == 'chi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'chi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_chi'): + self.add_chi(obj_.value) + elif hasattr(self, 'set_chi'): + self.set_chi(obj_.value) + elif nodeName_ == 'psi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'psi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_psi'): + self.add_psi(obj_.value) + elif hasattr(self, 'set_psi'): + self.set_psi(obj_.value) + elif nodeName_ == 'omega': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'omega', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_omega'): + self.add_omega(obj_.value) + elif hasattr(self, 'set_omega'): + self.set_omega(obj_.value) + elif nodeName_ == 'sigmaf': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sigmaf', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sigmaf'): + self.add_sigmaf(obj_.value) + elif hasattr(self, 'set_sigmaf'): + self.set_sigmaf(obj_.value) + elif nodeName_ == 'sect': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sect', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sect'): + self.add_sect(obj_.value) + elif hasattr(self, 'set_sect'): + self.set_sect(obj_.value) + elif nodeName_ == 'deg': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'deg', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_deg'): + self.add_deg(obj_.value) + elif hasattr(self, 'set_deg'): + self.set_deg(obj_.value) + elif nodeName_ == 'prime': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'prime', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_prime'): + self.add_prime(obj_.value) + elif hasattr(self, 'set_prime'): + self.set_prime(obj_.value) + elif nodeName_ == 'Prime': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Prime', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Prime'): + self.add_Prime(obj_.value) + elif hasattr(self, 'set_Prime'): + self.set_Prime(obj_.value) + elif nodeName_ == 'infin': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'infin', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_infin'): + self.add_infin(obj_.value) + elif hasattr(self, 'set_infin'): + self.set_infin(obj_.value) + elif nodeName_ == 'empty': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'empty', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_empty'): + self.add_empty(obj_.value) + elif hasattr(self, 'set_empty'): + self.set_empty(obj_.value) + elif nodeName_ == 'plusmn': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'plusmn', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_plusmn'): + self.add_plusmn(obj_.value) + elif hasattr(self, 'set_plusmn'): + self.set_plusmn(obj_.value) + elif nodeName_ == 'times': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'times', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_times'): + self.add_times(obj_.value) + elif hasattr(self, 'set_times'): + self.set_times(obj_.value) + elif nodeName_ == 'minus': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'minus', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_minus'): + self.add_minus(obj_.value) + elif hasattr(self, 'set_minus'): + self.set_minus(obj_.value) + elif nodeName_ == 'sdot': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sdot', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sdot'): + self.add_sdot(obj_.value) + elif hasattr(self, 'set_sdot'): + self.set_sdot(obj_.value) + elif nodeName_ == 'part': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'part', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_part'): + self.add_part(obj_.value) + elif hasattr(self, 'set_part'): + self.set_part(obj_.value) + elif nodeName_ == 'nabla': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'nabla', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_nabla'): + self.add_nabla(obj_.value) + elif hasattr(self, 'set_nabla'): + self.set_nabla(obj_.value) + elif nodeName_ == 'radic': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'radic', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_radic'): + self.add_radic(obj_.value) + elif hasattr(self, 'set_radic'): + self.set_radic(obj_.value) + elif nodeName_ == 'perp': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'perp', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_perp'): + self.add_perp(obj_.value) + elif hasattr(self, 'set_perp'): + self.set_perp(obj_.value) + elif nodeName_ == 'sum': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sum', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sum'): + self.add_sum(obj_.value) + elif hasattr(self, 'set_sum'): + self.set_sum(obj_.value) + elif nodeName_ == 'int': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'int', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_int'): + self.add_int(obj_.value) + elif hasattr(self, 'set_int'): + self.set_int(obj_.value) + elif nodeName_ == 'prod': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'prod', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_prod'): + self.add_prod(obj_.value) + elif hasattr(self, 'set_prod'): + self.set_prod(obj_.value) + elif nodeName_ == 'sim': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sim', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sim'): + self.add_sim(obj_.value) + elif hasattr(self, 'set_sim'): + self.set_sim(obj_.value) + elif nodeName_ == 'asymp': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'asymp', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_asymp'): + self.add_asymp(obj_.value) + elif hasattr(self, 'set_asymp'): + self.set_asymp(obj_.value) + elif nodeName_ == 'ne': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ne', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ne'): + self.add_ne(obj_.value) + elif hasattr(self, 'set_ne'): + self.set_ne(obj_.value) + elif nodeName_ == 'equiv': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'equiv', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_equiv'): + self.add_equiv(obj_.value) + elif hasattr(self, 'set_equiv'): + self.set_equiv(obj_.value) + elif nodeName_ == 'prop': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'prop', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_prop'): + self.add_prop(obj_.value) + elif hasattr(self, 'set_prop'): + self.set_prop(obj_.value) + elif nodeName_ == 'le': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'le', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_le'): + self.add_le(obj_.value) + elif hasattr(self, 'set_le'): + self.set_le(obj_.value) + elif nodeName_ == 'ge': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ge', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ge'): + self.add_ge(obj_.value) + elif hasattr(self, 'set_ge'): + self.set_ge(obj_.value) + elif nodeName_ == 'larr': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'larr', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_larr'): + self.add_larr(obj_.value) + elif hasattr(self, 'set_larr'): + self.set_larr(obj_.value) + elif nodeName_ == 'rarr': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rarr', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rarr'): + self.add_rarr(obj_.value) + elif hasattr(self, 'set_rarr'): + self.set_rarr(obj_.value) + elif nodeName_ == 'isin': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'isin', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_isin'): + self.add_isin(obj_.value) + elif hasattr(self, 'set_isin'): + self.set_isin(obj_.value) + elif nodeName_ == 'notin': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'notin', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_notin'): + self.add_notin(obj_.value) + elif hasattr(self, 'set_notin'): + self.set_notin(obj_.value) + elif nodeName_ == 'lceil': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'lceil', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_lceil'): + self.add_lceil(obj_.value) + elif hasattr(self, 'set_lceil'): + self.set_lceil(obj_.value) + elif nodeName_ == 'rceil': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rceil', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rceil'): + self.add_rceil(obj_.value) + elif hasattr(self, 'set_rceil'): + self.set_rceil(obj_.value) + elif nodeName_ == 'lfloor': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'lfloor', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_lfloor'): + self.add_lfloor(obj_.value) + elif hasattr(self, 'set_lfloor'): + self.set_lfloor(obj_.value) + elif nodeName_ == 'rfloor': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rfloor', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rfloor'): + self.add_rfloor(obj_.value) + elif hasattr(self, 'set_rfloor'): + self.set_rfloor(obj_.value) + if not fromsubclass_ and child_.tail is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.tail) + self.content_.append(obj_) +# end class docHeadingType + + +class docImageType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, type_=None, name=None, width=None, height=None, ulink=None, bold=None, emphasis=None, computeroutput=None, subscript=None, superscript=None, center=None, small=None, htmlonly=None, manonly=None, xmlonly=None, rtfonly=None, latexonly=None, dot=None, msc=None, anchor=None, formula=None, ref=None, copy=None, trademark=None, registered=None, lsquo=None, rsquo=None, ldquo=None, rdquo=None, ndash=None, mdash=None, umlaut=None, acute=None, grave=None, circ=None, slash=None, tilde=None, cedil=None, ring=None, szlig=None, nonbreakablespace=None, aelig=None, AElig=None, Gamma=None, Delta=None, Theta=None, Lambda=None, Xi=None, Pi=None, Sigma=None, Upsilon=None, Phi=None, Psi=None, Omega=None, alpha=None, beta=None, gamma=None, delta=None, epsilon=None, zeta=None, eta=None, theta=None, iota=None, kappa=None, lambda_=None, mu=None, nu=None, xi=None, pi=None, rho=None, sigma=None, tau=None, upsilon=None, phi=None, chi=None, psi=None, omega=None, sigmaf=None, sect=None, deg=None, prime=None, Prime=None, infin=None, empty=None, plusmn=None, times=None, minus=None, sdot=None, part=None, nabla=None, radic=None, perp=None, sum=None, int=None, prod=None, sim=None, asymp=None, ne=None, equiv=None, prop=None, le=None, ge=None, larr=None, rarr=None, isin=None, notin=None, lceil=None, rceil=None, lfloor=None, rfloor=None, valueOf_=None, mixedclass_=None, content_=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.type_ = _cast(None, type_) + self.type__nsprefix_ = None + self.name = _cast(None, name) + self.name_nsprefix_ = None + self.width = _cast(None, width) + self.width_nsprefix_ = None + self.height = _cast(None, height) + self.height_nsprefix_ = None + if ulink is None: + self.ulink = [] + else: + self.ulink = ulink + self.ulink_nsprefix_ = None + if bold is None: + self.bold = [] + else: + self.bold = bold + self.bold_nsprefix_ = None + if emphasis is None: + self.emphasis = [] + else: + self.emphasis = emphasis + self.emphasis_nsprefix_ = None + if computeroutput is None: + self.computeroutput = [] + else: + self.computeroutput = computeroutput + self.computeroutput_nsprefix_ = None + if subscript is None: + self.subscript = [] + else: + self.subscript = subscript + self.subscript_nsprefix_ = None + if superscript is None: + self.superscript = [] + else: + self.superscript = superscript + self.superscript_nsprefix_ = None + if center is None: + self.center = [] + else: + self.center = center + self.center_nsprefix_ = None + if small is None: + self.small = [] + else: + self.small = small + self.small_nsprefix_ = None + if htmlonly is None: + self.htmlonly = [] + else: + self.htmlonly = htmlonly + self.htmlonly_nsprefix_ = None + if manonly is None: + self.manonly = [] + else: + self.manonly = manonly + self.manonly_nsprefix_ = None + if xmlonly is None: + self.xmlonly = [] + else: + self.xmlonly = xmlonly + self.xmlonly_nsprefix_ = None + if rtfonly is None: + self.rtfonly = [] + else: + self.rtfonly = rtfonly + self.rtfonly_nsprefix_ = None + if latexonly is None: + self.latexonly = [] + else: + self.latexonly = latexonly + self.latexonly_nsprefix_ = None + if dot is None: + self.dot = [] + else: + self.dot = dot + self.dot_nsprefix_ = None + if msc is None: + self.msc = [] + else: + self.msc = msc + self.msc_nsprefix_ = None + if anchor is None: + self.anchor = [] + else: + self.anchor = anchor + self.anchor_nsprefix_ = None + if formula is None: + self.formula = [] + else: + self.formula = formula + self.formula_nsprefix_ = None + if ref is None: + self.ref = [] + else: + self.ref = ref + self.ref_nsprefix_ = None + if copy is None: + self.copy = [] + else: + self.copy = copy + self.copy_nsprefix_ = None + if trademark is None: + self.trademark = [] + else: + self.trademark = trademark + self.trademark_nsprefix_ = None + if registered is None: + self.registered = [] + else: + self.registered = registered + self.registered_nsprefix_ = None + if lsquo is None: + self.lsquo = [] + else: + self.lsquo = lsquo + self.lsquo_nsprefix_ = None + if rsquo is None: + self.rsquo = [] + else: + self.rsquo = rsquo + self.rsquo_nsprefix_ = None + if ldquo is None: + self.ldquo = [] + else: + self.ldquo = ldquo + self.ldquo_nsprefix_ = None + if rdquo is None: + self.rdquo = [] + else: + self.rdquo = rdquo + self.rdquo_nsprefix_ = None + if ndash is None: + self.ndash = [] + else: + self.ndash = ndash + self.ndash_nsprefix_ = None + if mdash is None: + self.mdash = [] + else: + self.mdash = mdash + self.mdash_nsprefix_ = None + if umlaut is None: + self.umlaut = [] + else: + self.umlaut = umlaut + self.umlaut_nsprefix_ = None + if acute is None: + self.acute = [] + else: + self.acute = acute + self.acute_nsprefix_ = None + if grave is None: + self.grave = [] + else: + self.grave = grave + self.grave_nsprefix_ = None + if circ is None: + self.circ = [] + else: + self.circ = circ + self.circ_nsprefix_ = None + if slash is None: + self.slash = [] + else: + self.slash = slash + self.slash_nsprefix_ = None + if tilde is None: + self.tilde = [] + else: + self.tilde = tilde + self.tilde_nsprefix_ = None + if cedil is None: + self.cedil = [] + else: + self.cedil = cedil + self.cedil_nsprefix_ = None + if ring is None: + self.ring = [] + else: + self.ring = ring + self.ring_nsprefix_ = None + if szlig is None: + self.szlig = [] + else: + self.szlig = szlig + self.szlig_nsprefix_ = None + if nonbreakablespace is None: + self.nonbreakablespace = [] + else: + self.nonbreakablespace = nonbreakablespace + self.nonbreakablespace_nsprefix_ = None + if aelig is None: + self.aelig = [] + else: + self.aelig = aelig + self.aelig_nsprefix_ = None + if AElig is None: + self.AElig = [] + else: + self.AElig = AElig + self.AElig_nsprefix_ = None + if Gamma is None: + self.Gamma = [] + else: + self.Gamma = Gamma + self.Gamma_nsprefix_ = None + if Delta is None: + self.Delta = [] + else: + self.Delta = Delta + self.Delta_nsprefix_ = None + if Theta is None: + self.Theta = [] + else: + self.Theta = Theta + self.Theta_nsprefix_ = None + if Lambda is None: + self.Lambda = [] + else: + self.Lambda = Lambda + self.Lambda_nsprefix_ = None + if Xi is None: + self.Xi = [] + else: + self.Xi = Xi + self.Xi_nsprefix_ = None + if Pi is None: + self.Pi = [] + else: + self.Pi = Pi + self.Pi_nsprefix_ = None + if Sigma is None: + self.Sigma = [] + else: + self.Sigma = Sigma + self.Sigma_nsprefix_ = None + if Upsilon is None: + self.Upsilon = [] + else: + self.Upsilon = Upsilon + self.Upsilon_nsprefix_ = None + if Phi is None: + self.Phi = [] + else: + self.Phi = Phi + self.Phi_nsprefix_ = None + if Psi is None: + self.Psi = [] + else: + self.Psi = Psi + self.Psi_nsprefix_ = None + if Omega is None: + self.Omega = [] + else: + self.Omega = Omega + self.Omega_nsprefix_ = None + if alpha is None: + self.alpha = [] + else: + self.alpha = alpha + self.alpha_nsprefix_ = None + if beta is None: + self.beta = [] + else: + self.beta = beta + self.beta_nsprefix_ = None + if gamma is None: + self.gamma = [] + else: + self.gamma = gamma + self.gamma_nsprefix_ = None + if delta is None: + self.delta = [] + else: + self.delta = delta + self.delta_nsprefix_ = None + if epsilon is None: + self.epsilon = [] + else: + self.epsilon = epsilon + self.epsilon_nsprefix_ = None + if zeta is None: + self.zeta = [] + else: + self.zeta = zeta + self.zeta_nsprefix_ = None + if eta is None: + self.eta = [] + else: + self.eta = eta + self.eta_nsprefix_ = None + if theta is None: + self.theta = [] + else: + self.theta = theta + self.theta_nsprefix_ = None + if iota is None: + self.iota = [] + else: + self.iota = iota + self.iota_nsprefix_ = None + if kappa is None: + self.kappa = [] + else: + self.kappa = kappa + self.kappa_nsprefix_ = None + if lambda_ is None: + self.lambda_ = [] + else: + self.lambda_ = lambda_ + self.lambda__nsprefix_ = None + if mu is None: + self.mu = [] + else: + self.mu = mu + self.mu_nsprefix_ = None + if nu is None: + self.nu = [] + else: + self.nu = nu + self.nu_nsprefix_ = None + if xi is None: + self.xi = [] + else: + self.xi = xi + self.xi_nsprefix_ = None + if pi is None: + self.pi = [] + else: + self.pi = pi + self.pi_nsprefix_ = None + if rho is None: + self.rho = [] + else: + self.rho = rho + self.rho_nsprefix_ = None + if sigma is None: + self.sigma = [] + else: + self.sigma = sigma + self.sigma_nsprefix_ = None + if tau is None: + self.tau = [] + else: + self.tau = tau + self.tau_nsprefix_ = None + if upsilon is None: + self.upsilon = [] + else: + self.upsilon = upsilon + self.upsilon_nsprefix_ = None + if phi is None: + self.phi = [] + else: + self.phi = phi + self.phi_nsprefix_ = None + if chi is None: + self.chi = [] + else: + self.chi = chi + self.chi_nsprefix_ = None + if psi is None: + self.psi = [] + else: + self.psi = psi + self.psi_nsprefix_ = None + if omega is None: + self.omega = [] + else: + self.omega = omega + self.omega_nsprefix_ = None + if sigmaf is None: + self.sigmaf = [] + else: + self.sigmaf = sigmaf + self.sigmaf_nsprefix_ = None + if sect is None: + self.sect = [] + else: + self.sect = sect + self.sect_nsprefix_ = None + if deg is None: + self.deg = [] + else: + self.deg = deg + self.deg_nsprefix_ = None + if prime is None: + self.prime = [] + else: + self.prime = prime + self.prime_nsprefix_ = None + if Prime is None: + self.Prime = [] + else: + self.Prime = Prime + self.Prime_nsprefix_ = None + if infin is None: + self.infin = [] + else: + self.infin = infin + self.infin_nsprefix_ = None + if empty is None: + self.empty = [] + else: + self.empty = empty + self.empty_nsprefix_ = None + if plusmn is None: + self.plusmn = [] + else: + self.plusmn = plusmn + self.plusmn_nsprefix_ = None + if times is None: + self.times = [] + else: + self.times = times + self.times_nsprefix_ = None + if minus is None: + self.minus = [] + else: + self.minus = minus + self.minus_nsprefix_ = None + if sdot is None: + self.sdot = [] + else: + self.sdot = sdot + self.sdot_nsprefix_ = None + if part is None: + self.part = [] + else: + self.part = part + self.part_nsprefix_ = None + if nabla is None: + self.nabla = [] + else: + self.nabla = nabla + self.nabla_nsprefix_ = None + if radic is None: + self.radic = [] + else: + self.radic = radic + self.radic_nsprefix_ = None + if perp is None: + self.perp = [] + else: + self.perp = perp + self.perp_nsprefix_ = None + if sum is None: + self.sum = [] + else: + self.sum = sum + self.sum_nsprefix_ = None + if int is None: + self.int = [] + else: + self.int = int + self.int_nsprefix_ = None + if prod is None: + self.prod = [] + else: + self.prod = prod + self.prod_nsprefix_ = None + if sim is None: + self.sim = [] + else: + self.sim = sim + self.sim_nsprefix_ = None + if asymp is None: + self.asymp = [] + else: + self.asymp = asymp + self.asymp_nsprefix_ = None + if ne is None: + self.ne = [] + else: + self.ne = ne + self.ne_nsprefix_ = None + if equiv is None: + self.equiv = [] + else: + self.equiv = equiv + self.equiv_nsprefix_ = None + if prop is None: + self.prop = [] + else: + self.prop = prop + self.prop_nsprefix_ = None + if le is None: + self.le = [] + else: + self.le = le + self.le_nsprefix_ = None + if ge is None: + self.ge = [] + else: + self.ge = ge + self.ge_nsprefix_ = None + if larr is None: + self.larr = [] + else: + self.larr = larr + self.larr_nsprefix_ = None + if rarr is None: + self.rarr = [] + else: + self.rarr = rarr + self.rarr_nsprefix_ = None + if isin is None: + self.isin = [] + else: + self.isin = isin + self.isin_nsprefix_ = None + if notin is None: + self.notin = [] + else: + self.notin = notin + self.notin_nsprefix_ = None + if lceil is None: + self.lceil = [] + else: + self.lceil = lceil + self.lceil_nsprefix_ = None + if rceil is None: + self.rceil = [] + else: + self.rceil = rceil + self.rceil_nsprefix_ = None + if lfloor is None: + self.lfloor = [] + else: + self.lfloor = lfloor + self.lfloor_nsprefix_ = None + if rfloor is None: + self.rfloor = [] + else: + self.rfloor = rfloor + self.rfloor_nsprefix_ = None + self.valueOf_ = valueOf_ + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + self.valueOf_ = valueOf_ + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docImageType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docImageType.subclass: + return docImageType.subclass(*args_, **kwargs_) + return docImageType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + def get_ulink(self): + return self.ulink + def set_ulink(self, ulink): + self.ulink = ulink + def add_ulink(self, value): + self.ulink.append(value) + def insert_ulink_at(self, index, value): + self.ulink.insert(index, value) + def replace_ulink_at(self, index, value): + self.ulink[index] = value + def get_bold(self): + return self.bold + def set_bold(self, bold): + self.bold = bold + def add_bold(self, value): + self.bold.append(value) + def insert_bold_at(self, index, value): + self.bold.insert(index, value) + def replace_bold_at(self, index, value): + self.bold[index] = value + def get_emphasis(self): + return self.emphasis + def set_emphasis(self, emphasis): + self.emphasis = emphasis + def add_emphasis(self, value): + self.emphasis.append(value) + def insert_emphasis_at(self, index, value): + self.emphasis.insert(index, value) + def replace_emphasis_at(self, index, value): + self.emphasis[index] = value + def get_computeroutput(self): + return self.computeroutput + def set_computeroutput(self, computeroutput): + self.computeroutput = computeroutput + def add_computeroutput(self, value): + self.computeroutput.append(value) + def insert_computeroutput_at(self, index, value): + self.computeroutput.insert(index, value) + def replace_computeroutput_at(self, index, value): + self.computeroutput[index] = value + def get_subscript(self): + return self.subscript + def set_subscript(self, subscript): + self.subscript = subscript + def add_subscript(self, value): + self.subscript.append(value) + def insert_subscript_at(self, index, value): + self.subscript.insert(index, value) + def replace_subscript_at(self, index, value): + self.subscript[index] = value + def get_superscript(self): + return self.superscript + def set_superscript(self, superscript): + self.superscript = superscript + def add_superscript(self, value): + self.superscript.append(value) + def insert_superscript_at(self, index, value): + self.superscript.insert(index, value) + def replace_superscript_at(self, index, value): + self.superscript[index] = value + def get_center(self): + return self.center + def set_center(self, center): + self.center = center + def add_center(self, value): + self.center.append(value) + def insert_center_at(self, index, value): + self.center.insert(index, value) + def replace_center_at(self, index, value): + self.center[index] = value + def get_small(self): + return self.small + def set_small(self, small): + self.small = small + def add_small(self, value): + self.small.append(value) + def insert_small_at(self, index, value): + self.small.insert(index, value) + def replace_small_at(self, index, value): + self.small[index] = value + def get_htmlonly(self): + return self.htmlonly + def set_htmlonly(self, htmlonly): + self.htmlonly = htmlonly + def add_htmlonly(self, value): + self.htmlonly.append(value) + def insert_htmlonly_at(self, index, value): + self.htmlonly.insert(index, value) + def replace_htmlonly_at(self, index, value): + self.htmlonly[index] = value + def get_manonly(self): + return self.manonly + def set_manonly(self, manonly): + self.manonly = manonly + def add_manonly(self, value): + self.manonly.append(value) + def insert_manonly_at(self, index, value): + self.manonly.insert(index, value) + def replace_manonly_at(self, index, value): + self.manonly[index] = value + def get_xmlonly(self): + return self.xmlonly + def set_xmlonly(self, xmlonly): + self.xmlonly = xmlonly + def add_xmlonly(self, value): + self.xmlonly.append(value) + def insert_xmlonly_at(self, index, value): + self.xmlonly.insert(index, value) + def replace_xmlonly_at(self, index, value): + self.xmlonly[index] = value + def get_rtfonly(self): + return self.rtfonly + def set_rtfonly(self, rtfonly): + self.rtfonly = rtfonly + def add_rtfonly(self, value): + self.rtfonly.append(value) + def insert_rtfonly_at(self, index, value): + self.rtfonly.insert(index, value) + def replace_rtfonly_at(self, index, value): + self.rtfonly[index] = value + def get_latexonly(self): + return self.latexonly + def set_latexonly(self, latexonly): + self.latexonly = latexonly + def add_latexonly(self, value): + self.latexonly.append(value) + def insert_latexonly_at(self, index, value): + self.latexonly.insert(index, value) + def replace_latexonly_at(self, index, value): + self.latexonly[index] = value + def get_dot(self): + return self.dot + def set_dot(self, dot): + self.dot = dot + def add_dot(self, value): + self.dot.append(value) + def insert_dot_at(self, index, value): + self.dot.insert(index, value) + def replace_dot_at(self, index, value): + self.dot[index] = value + def get_msc(self): + return self.msc + def set_msc(self, msc): + self.msc = msc + def add_msc(self, value): + self.msc.append(value) + def insert_msc_at(self, index, value): + self.msc.insert(index, value) + def replace_msc_at(self, index, value): + self.msc[index] = value + def get_anchor(self): + return self.anchor + def set_anchor(self, anchor): + self.anchor = anchor + def add_anchor(self, value): + self.anchor.append(value) + def insert_anchor_at(self, index, value): + self.anchor.insert(index, value) + def replace_anchor_at(self, index, value): + self.anchor[index] = value + def get_formula(self): + return self.formula + def set_formula(self, formula): + self.formula = formula + def add_formula(self, value): + self.formula.append(value) + def insert_formula_at(self, index, value): + self.formula.insert(index, value) + def replace_formula_at(self, index, value): + self.formula[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_at(self, index, value): + self.ref.insert(index, value) + def replace_ref_at(self, index, value): + self.ref[index] = value + def get_copy(self): + return self.copy + def set_copy(self, copy): + self.copy = copy + def add_copy(self, value): + self.copy.append(value) + def insert_copy_at(self, index, value): + self.copy.insert(index, value) + def replace_copy_at(self, index, value): + self.copy[index] = value + def get_trademark(self): + return self.trademark + def set_trademark(self, trademark): + self.trademark = trademark + def add_trademark(self, value): + self.trademark.append(value) + def insert_trademark_at(self, index, value): + self.trademark.insert(index, value) + def replace_trademark_at(self, index, value): + self.trademark[index] = value + def get_registered(self): + return self.registered + def set_registered(self, registered): + self.registered = registered + def add_registered(self, value): + self.registered.append(value) + def insert_registered_at(self, index, value): + self.registered.insert(index, value) + def replace_registered_at(self, index, value): + self.registered[index] = value + def get_lsquo(self): + return self.lsquo + def set_lsquo(self, lsquo): + self.lsquo = lsquo + def add_lsquo(self, value): + self.lsquo.append(value) + def insert_lsquo_at(self, index, value): + self.lsquo.insert(index, value) + def replace_lsquo_at(self, index, value): + self.lsquo[index] = value + def get_rsquo(self): + return self.rsquo + def set_rsquo(self, rsquo): + self.rsquo = rsquo + def add_rsquo(self, value): + self.rsquo.append(value) + def insert_rsquo_at(self, index, value): + self.rsquo.insert(index, value) + def replace_rsquo_at(self, index, value): + self.rsquo[index] = value + def get_ldquo(self): + return self.ldquo + def set_ldquo(self, ldquo): + self.ldquo = ldquo + def add_ldquo(self, value): + self.ldquo.append(value) + def insert_ldquo_at(self, index, value): + self.ldquo.insert(index, value) + def replace_ldquo_at(self, index, value): + self.ldquo[index] = value + def get_rdquo(self): + return self.rdquo + def set_rdquo(self, rdquo): + self.rdquo = rdquo + def add_rdquo(self, value): + self.rdquo.append(value) + def insert_rdquo_at(self, index, value): + self.rdquo.insert(index, value) + def replace_rdquo_at(self, index, value): + self.rdquo[index] = value + def get_ndash(self): + return self.ndash + def set_ndash(self, ndash): + self.ndash = ndash + def add_ndash(self, value): + self.ndash.append(value) + def insert_ndash_at(self, index, value): + self.ndash.insert(index, value) + def replace_ndash_at(self, index, value): + self.ndash[index] = value + def get_mdash(self): + return self.mdash + def set_mdash(self, mdash): + self.mdash = mdash + def add_mdash(self, value): + self.mdash.append(value) + def insert_mdash_at(self, index, value): + self.mdash.insert(index, value) + def replace_mdash_at(self, index, value): + self.mdash[index] = value + def get_umlaut(self): + return self.umlaut + def set_umlaut(self, umlaut): + self.umlaut = umlaut + def add_umlaut(self, value): + self.umlaut.append(value) + def insert_umlaut_at(self, index, value): + self.umlaut.insert(index, value) + def replace_umlaut_at(self, index, value): + self.umlaut[index] = value + def get_acute(self): + return self.acute + def set_acute(self, acute): + self.acute = acute + def add_acute(self, value): + self.acute.append(value) + def insert_acute_at(self, index, value): + self.acute.insert(index, value) + def replace_acute_at(self, index, value): + self.acute[index] = value + def get_grave(self): + return self.grave + def set_grave(self, grave): + self.grave = grave + def add_grave(self, value): + self.grave.append(value) + def insert_grave_at(self, index, value): + self.grave.insert(index, value) + def replace_grave_at(self, index, value): + self.grave[index] = value + def get_circ(self): + return self.circ + def set_circ(self, circ): + self.circ = circ + def add_circ(self, value): + self.circ.append(value) + def insert_circ_at(self, index, value): + self.circ.insert(index, value) + def replace_circ_at(self, index, value): + self.circ[index] = value + def get_slash(self): + return self.slash + def set_slash(self, slash): + self.slash = slash + def add_slash(self, value): + self.slash.append(value) + def insert_slash_at(self, index, value): + self.slash.insert(index, value) + def replace_slash_at(self, index, value): + self.slash[index] = value + def get_tilde(self): + return self.tilde + def set_tilde(self, tilde): + self.tilde = tilde + def add_tilde(self, value): + self.tilde.append(value) + def insert_tilde_at(self, index, value): + self.tilde.insert(index, value) + def replace_tilde_at(self, index, value): + self.tilde[index] = value + def get_cedil(self): + return self.cedil + def set_cedil(self, cedil): + self.cedil = cedil + def add_cedil(self, value): + self.cedil.append(value) + def insert_cedil_at(self, index, value): + self.cedil.insert(index, value) + def replace_cedil_at(self, index, value): + self.cedil[index] = value + def get_ring(self): + return self.ring + def set_ring(self, ring): + self.ring = ring + def add_ring(self, value): + self.ring.append(value) + def insert_ring_at(self, index, value): + self.ring.insert(index, value) + def replace_ring_at(self, index, value): + self.ring[index] = value + def get_szlig(self): + return self.szlig + def set_szlig(self, szlig): + self.szlig = szlig + def add_szlig(self, value): + self.szlig.append(value) + def insert_szlig_at(self, index, value): + self.szlig.insert(index, value) + def replace_szlig_at(self, index, value): + self.szlig[index] = value + def get_nonbreakablespace(self): + return self.nonbreakablespace + def set_nonbreakablespace(self, nonbreakablespace): + self.nonbreakablespace = nonbreakablespace + def add_nonbreakablespace(self, value): + self.nonbreakablespace.append(value) + def insert_nonbreakablespace_at(self, index, value): + self.nonbreakablespace.insert(index, value) + def replace_nonbreakablespace_at(self, index, value): + self.nonbreakablespace[index] = value + def get_aelig(self): + return self.aelig + def set_aelig(self, aelig): + self.aelig = aelig + def add_aelig(self, value): + self.aelig.append(value) + def insert_aelig_at(self, index, value): + self.aelig.insert(index, value) + def replace_aelig_at(self, index, value): + self.aelig[index] = value + def get_AElig(self): + return self.AElig + def set_AElig(self, AElig): + self.AElig = AElig + def add_AElig(self, value): + self.AElig.append(value) + def insert_AElig_at(self, index, value): + self.AElig.insert(index, value) + def replace_AElig_at(self, index, value): + self.AElig[index] = value + def get_Gamma(self): + return self.Gamma + def set_Gamma(self, Gamma): + self.Gamma = Gamma + def add_Gamma(self, value): + self.Gamma.append(value) + def insert_Gamma_at(self, index, value): + self.Gamma.insert(index, value) + def replace_Gamma_at(self, index, value): + self.Gamma[index] = value + def get_Delta(self): + return self.Delta + def set_Delta(self, Delta): + self.Delta = Delta + def add_Delta(self, value): + self.Delta.append(value) + def insert_Delta_at(self, index, value): + self.Delta.insert(index, value) + def replace_Delta_at(self, index, value): + self.Delta[index] = value + def get_Theta(self): + return self.Theta + def set_Theta(self, Theta): + self.Theta = Theta + def add_Theta(self, value): + self.Theta.append(value) + def insert_Theta_at(self, index, value): + self.Theta.insert(index, value) + def replace_Theta_at(self, index, value): + self.Theta[index] = value + def get_Lambda(self): + return self.Lambda + def set_Lambda(self, Lambda): + self.Lambda = Lambda + def add_Lambda(self, value): + self.Lambda.append(value) + def insert_Lambda_at(self, index, value): + self.Lambda.insert(index, value) + def replace_Lambda_at(self, index, value): + self.Lambda[index] = value + def get_Xi(self): + return self.Xi + def set_Xi(self, Xi): + self.Xi = Xi + def add_Xi(self, value): + self.Xi.append(value) + def insert_Xi_at(self, index, value): + self.Xi.insert(index, value) + def replace_Xi_at(self, index, value): + self.Xi[index] = value + def get_Pi(self): + return self.Pi + def set_Pi(self, Pi): + self.Pi = Pi + def add_Pi(self, value): + self.Pi.append(value) + def insert_Pi_at(self, index, value): + self.Pi.insert(index, value) + def replace_Pi_at(self, index, value): + self.Pi[index] = value + def get_Sigma(self): + return self.Sigma + def set_Sigma(self, Sigma): + self.Sigma = Sigma + def add_Sigma(self, value): + self.Sigma.append(value) + def insert_Sigma_at(self, index, value): + self.Sigma.insert(index, value) + def replace_Sigma_at(self, index, value): + self.Sigma[index] = value + def get_Upsilon(self): + return self.Upsilon + def set_Upsilon(self, Upsilon): + self.Upsilon = Upsilon + def add_Upsilon(self, value): + self.Upsilon.append(value) + def insert_Upsilon_at(self, index, value): + self.Upsilon.insert(index, value) + def replace_Upsilon_at(self, index, value): + self.Upsilon[index] = value + def get_Phi(self): + return self.Phi + def set_Phi(self, Phi): + self.Phi = Phi + def add_Phi(self, value): + self.Phi.append(value) + def insert_Phi_at(self, index, value): + self.Phi.insert(index, value) + def replace_Phi_at(self, index, value): + self.Phi[index] = value + def get_Psi(self): + return self.Psi + def set_Psi(self, Psi): + self.Psi = Psi + def add_Psi(self, value): + self.Psi.append(value) + def insert_Psi_at(self, index, value): + self.Psi.insert(index, value) + def replace_Psi_at(self, index, value): + self.Psi[index] = value + def get_Omega(self): + return self.Omega + def set_Omega(self, Omega): + self.Omega = Omega + def add_Omega(self, value): + self.Omega.append(value) + def insert_Omega_at(self, index, value): + self.Omega.insert(index, value) + def replace_Omega_at(self, index, value): + self.Omega[index] = value + def get_alpha(self): + return self.alpha + def set_alpha(self, alpha): + self.alpha = alpha + def add_alpha(self, value): + self.alpha.append(value) + def insert_alpha_at(self, index, value): + self.alpha.insert(index, value) + def replace_alpha_at(self, index, value): + self.alpha[index] = value + def get_beta(self): + return self.beta + def set_beta(self, beta): + self.beta = beta + def add_beta(self, value): + self.beta.append(value) + def insert_beta_at(self, index, value): + self.beta.insert(index, value) + def replace_beta_at(self, index, value): + self.beta[index] = value + def get_gamma(self): + return self.gamma + def set_gamma(self, gamma): + self.gamma = gamma + def add_gamma(self, value): + self.gamma.append(value) + def insert_gamma_at(self, index, value): + self.gamma.insert(index, value) + def replace_gamma_at(self, index, value): + self.gamma[index] = value + def get_delta(self): + return self.delta + def set_delta(self, delta): + self.delta = delta + def add_delta(self, value): + self.delta.append(value) + def insert_delta_at(self, index, value): + self.delta.insert(index, value) + def replace_delta_at(self, index, value): + self.delta[index] = value + def get_epsilon(self): + return self.epsilon + def set_epsilon(self, epsilon): + self.epsilon = epsilon + def add_epsilon(self, value): + self.epsilon.append(value) + def insert_epsilon_at(self, index, value): + self.epsilon.insert(index, value) + def replace_epsilon_at(self, index, value): + self.epsilon[index] = value + def get_zeta(self): + return self.zeta + def set_zeta(self, zeta): + self.zeta = zeta + def add_zeta(self, value): + self.zeta.append(value) + def insert_zeta_at(self, index, value): + self.zeta.insert(index, value) + def replace_zeta_at(self, index, value): + self.zeta[index] = value + def get_eta(self): + return self.eta + def set_eta(self, eta): + self.eta = eta + def add_eta(self, value): + self.eta.append(value) + def insert_eta_at(self, index, value): + self.eta.insert(index, value) + def replace_eta_at(self, index, value): + self.eta[index] = value + def get_theta(self): + return self.theta + def set_theta(self, theta): + self.theta = theta + def add_theta(self, value): + self.theta.append(value) + def insert_theta_at(self, index, value): + self.theta.insert(index, value) + def replace_theta_at(self, index, value): + self.theta[index] = value + def get_iota(self): + return self.iota + def set_iota(self, iota): + self.iota = iota + def add_iota(self, value): + self.iota.append(value) + def insert_iota_at(self, index, value): + self.iota.insert(index, value) + def replace_iota_at(self, index, value): + self.iota[index] = value + def get_kappa(self): + return self.kappa + def set_kappa(self, kappa): + self.kappa = kappa + def add_kappa(self, value): + self.kappa.append(value) + def insert_kappa_at(self, index, value): + self.kappa.insert(index, value) + def replace_kappa_at(self, index, value): + self.kappa[index] = value + def get_lambda(self): + return self.lambda_ + def set_lambda(self, lambda_): + self.lambda_ = lambda_ + def add_lambda(self, value): + self.lambda_.append(value) + def insert_lambda_at(self, index, value): + self.lambda_.insert(index, value) + def replace_lambda_at(self, index, value): + self.lambda_[index] = value + def get_mu(self): + return self.mu + def set_mu(self, mu): + self.mu = mu + def add_mu(self, value): + self.mu.append(value) + def insert_mu_at(self, index, value): + self.mu.insert(index, value) + def replace_mu_at(self, index, value): + self.mu[index] = value + def get_nu(self): + return self.nu + def set_nu(self, nu): + self.nu = nu + def add_nu(self, value): + self.nu.append(value) + def insert_nu_at(self, index, value): + self.nu.insert(index, value) + def replace_nu_at(self, index, value): + self.nu[index] = value + def get_xi(self): + return self.xi + def set_xi(self, xi): + self.xi = xi + def add_xi(self, value): + self.xi.append(value) + def insert_xi_at(self, index, value): + self.xi.insert(index, value) + def replace_xi_at(self, index, value): + self.xi[index] = value + def get_pi(self): + return self.pi + def set_pi(self, pi): + self.pi = pi + def add_pi(self, value): + self.pi.append(value) + def insert_pi_at(self, index, value): + self.pi.insert(index, value) + def replace_pi_at(self, index, value): + self.pi[index] = value + def get_rho(self): + return self.rho + def set_rho(self, rho): + self.rho = rho + def add_rho(self, value): + self.rho.append(value) + def insert_rho_at(self, index, value): + self.rho.insert(index, value) + def replace_rho_at(self, index, value): + self.rho[index] = value + def get_sigma(self): + return self.sigma + def set_sigma(self, sigma): + self.sigma = sigma + def add_sigma(self, value): + self.sigma.append(value) + def insert_sigma_at(self, index, value): + self.sigma.insert(index, value) + def replace_sigma_at(self, index, value): + self.sigma[index] = value + def get_tau(self): + return self.tau + def set_tau(self, tau): + self.tau = tau + def add_tau(self, value): + self.tau.append(value) + def insert_tau_at(self, index, value): + self.tau.insert(index, value) + def replace_tau_at(self, index, value): + self.tau[index] = value + def get_upsilon(self): + return self.upsilon + def set_upsilon(self, upsilon): + self.upsilon = upsilon + def add_upsilon(self, value): + self.upsilon.append(value) + def insert_upsilon_at(self, index, value): + self.upsilon.insert(index, value) + def replace_upsilon_at(self, index, value): + self.upsilon[index] = value + def get_phi(self): + return self.phi + def set_phi(self, phi): + self.phi = phi + def add_phi(self, value): + self.phi.append(value) + def insert_phi_at(self, index, value): + self.phi.insert(index, value) + def replace_phi_at(self, index, value): + self.phi[index] = value + def get_chi(self): + return self.chi + def set_chi(self, chi): + self.chi = chi + def add_chi(self, value): + self.chi.append(value) + def insert_chi_at(self, index, value): + self.chi.insert(index, value) + def replace_chi_at(self, index, value): + self.chi[index] = value + def get_psi(self): + return self.psi + def set_psi(self, psi): + self.psi = psi + def add_psi(self, value): + self.psi.append(value) + def insert_psi_at(self, index, value): + self.psi.insert(index, value) + def replace_psi_at(self, index, value): + self.psi[index] = value + def get_omega(self): + return self.omega + def set_omega(self, omega): + self.omega = omega + def add_omega(self, value): + self.omega.append(value) + def insert_omega_at(self, index, value): + self.omega.insert(index, value) + def replace_omega_at(self, index, value): + self.omega[index] = value + def get_sigmaf(self): + return self.sigmaf + def set_sigmaf(self, sigmaf): + self.sigmaf = sigmaf + def add_sigmaf(self, value): + self.sigmaf.append(value) + def insert_sigmaf_at(self, index, value): + self.sigmaf.insert(index, value) + def replace_sigmaf_at(self, index, value): + self.sigmaf[index] = value + def get_sect(self): + return self.sect + def set_sect(self, sect): + self.sect = sect + def add_sect(self, value): + self.sect.append(value) + def insert_sect_at(self, index, value): + self.sect.insert(index, value) + def replace_sect_at(self, index, value): + self.sect[index] = value + def get_deg(self): + return self.deg + def set_deg(self, deg): + self.deg = deg + def add_deg(self, value): + self.deg.append(value) + def insert_deg_at(self, index, value): + self.deg.insert(index, value) + def replace_deg_at(self, index, value): + self.deg[index] = value + def get_prime(self): + return self.prime + def set_prime(self, prime): + self.prime = prime + def add_prime(self, value): + self.prime.append(value) + def insert_prime_at(self, index, value): + self.prime.insert(index, value) + def replace_prime_at(self, index, value): + self.prime[index] = value + def get_Prime(self): + return self.Prime + def set_Prime(self, Prime): + self.Prime = Prime + def add_Prime(self, value): + self.Prime.append(value) + def insert_Prime_at(self, index, value): + self.Prime.insert(index, value) + def replace_Prime_at(self, index, value): + self.Prime[index] = value + def get_infin(self): + return self.infin + def set_infin(self, infin): + self.infin = infin + def add_infin(self, value): + self.infin.append(value) + def insert_infin_at(self, index, value): + self.infin.insert(index, value) + def replace_infin_at(self, index, value): + self.infin[index] = value + def get_empty(self): + return self.empty + def set_empty(self, empty): + self.empty = empty + def add_empty(self, value): + self.empty.append(value) + def insert_empty_at(self, index, value): + self.empty.insert(index, value) + def replace_empty_at(self, index, value): + self.empty[index] = value + def get_plusmn(self): + return self.plusmn + def set_plusmn(self, plusmn): + self.plusmn = plusmn + def add_plusmn(self, value): + self.plusmn.append(value) + def insert_plusmn_at(self, index, value): + self.plusmn.insert(index, value) + def replace_plusmn_at(self, index, value): + self.plusmn[index] = value + def get_times(self): + return self.times + def set_times(self, times): + self.times = times + def add_times(self, value): + self.times.append(value) + def insert_times_at(self, index, value): + self.times.insert(index, value) + def replace_times_at(self, index, value): + self.times[index] = value + def get_minus(self): + return self.minus + def set_minus(self, minus): + self.minus = minus + def add_minus(self, value): + self.minus.append(value) + def insert_minus_at(self, index, value): + self.minus.insert(index, value) + def replace_minus_at(self, index, value): + self.minus[index] = value + def get_sdot(self): + return self.sdot + def set_sdot(self, sdot): + self.sdot = sdot + def add_sdot(self, value): + self.sdot.append(value) + def insert_sdot_at(self, index, value): + self.sdot.insert(index, value) + def replace_sdot_at(self, index, value): + self.sdot[index] = value + def get_part(self): + return self.part + def set_part(self, part): + self.part = part + def add_part(self, value): + self.part.append(value) + def insert_part_at(self, index, value): + self.part.insert(index, value) + def replace_part_at(self, index, value): + self.part[index] = value + def get_nabla(self): + return self.nabla + def set_nabla(self, nabla): + self.nabla = nabla + def add_nabla(self, value): + self.nabla.append(value) + def insert_nabla_at(self, index, value): + self.nabla.insert(index, value) + def replace_nabla_at(self, index, value): + self.nabla[index] = value + def get_radic(self): + return self.radic + def set_radic(self, radic): + self.radic = radic + def add_radic(self, value): + self.radic.append(value) + def insert_radic_at(self, index, value): + self.radic.insert(index, value) + def replace_radic_at(self, index, value): + self.radic[index] = value + def get_perp(self): + return self.perp + def set_perp(self, perp): + self.perp = perp + def add_perp(self, value): + self.perp.append(value) + def insert_perp_at(self, index, value): + self.perp.insert(index, value) + def replace_perp_at(self, index, value): + self.perp[index] = value + def get_sum(self): + return self.sum + def set_sum(self, sum): + self.sum = sum + def add_sum(self, value): + self.sum.append(value) + def insert_sum_at(self, index, value): + self.sum.insert(index, value) + def replace_sum_at(self, index, value): + self.sum[index] = value + def get_int(self): + return self.int + def set_int(self, int): + self.int = int + def add_int(self, value): + self.int.append(value) + def insert_int_at(self, index, value): + self.int.insert(index, value) + def replace_int_at(self, index, value): + self.int[index] = value + def get_prod(self): + return self.prod + def set_prod(self, prod): + self.prod = prod + def add_prod(self, value): + self.prod.append(value) + def insert_prod_at(self, index, value): + self.prod.insert(index, value) + def replace_prod_at(self, index, value): + self.prod[index] = value + def get_sim(self): + return self.sim + def set_sim(self, sim): + self.sim = sim + def add_sim(self, value): + self.sim.append(value) + def insert_sim_at(self, index, value): + self.sim.insert(index, value) + def replace_sim_at(self, index, value): + self.sim[index] = value + def get_asymp(self): + return self.asymp + def set_asymp(self, asymp): + self.asymp = asymp + def add_asymp(self, value): + self.asymp.append(value) + def insert_asymp_at(self, index, value): + self.asymp.insert(index, value) + def replace_asymp_at(self, index, value): + self.asymp[index] = value + def get_ne(self): + return self.ne + def set_ne(self, ne): + self.ne = ne + def add_ne(self, value): + self.ne.append(value) + def insert_ne_at(self, index, value): + self.ne.insert(index, value) + def replace_ne_at(self, index, value): + self.ne[index] = value + def get_equiv(self): + return self.equiv + def set_equiv(self, equiv): + self.equiv = equiv + def add_equiv(self, value): + self.equiv.append(value) + def insert_equiv_at(self, index, value): + self.equiv.insert(index, value) + def replace_equiv_at(self, index, value): + self.equiv[index] = value + def get_prop(self): + return self.prop + def set_prop(self, prop): + self.prop = prop + def add_prop(self, value): + self.prop.append(value) + def insert_prop_at(self, index, value): + self.prop.insert(index, value) + def replace_prop_at(self, index, value): + self.prop[index] = value + def get_le(self): + return self.le + def set_le(self, le): + self.le = le + def add_le(self, value): + self.le.append(value) + def insert_le_at(self, index, value): + self.le.insert(index, value) + def replace_le_at(self, index, value): + self.le[index] = value + def get_ge(self): + return self.ge + def set_ge(self, ge): + self.ge = ge + def add_ge(self, value): + self.ge.append(value) + def insert_ge_at(self, index, value): + self.ge.insert(index, value) + def replace_ge_at(self, index, value): + self.ge[index] = value + def get_larr(self): + return self.larr + def set_larr(self, larr): + self.larr = larr + def add_larr(self, value): + self.larr.append(value) + def insert_larr_at(self, index, value): + self.larr.insert(index, value) + def replace_larr_at(self, index, value): + self.larr[index] = value + def get_rarr(self): + return self.rarr + def set_rarr(self, rarr): + self.rarr = rarr + def add_rarr(self, value): + self.rarr.append(value) + def insert_rarr_at(self, index, value): + self.rarr.insert(index, value) + def replace_rarr_at(self, index, value): + self.rarr[index] = value + def get_isin(self): + return self.isin + def set_isin(self, isin): + self.isin = isin + def add_isin(self, value): + self.isin.append(value) + def insert_isin_at(self, index, value): + self.isin.insert(index, value) + def replace_isin_at(self, index, value): + self.isin[index] = value + def get_notin(self): + return self.notin + def set_notin(self, notin): + self.notin = notin + def add_notin(self, value): + self.notin.append(value) + def insert_notin_at(self, index, value): + self.notin.insert(index, value) + def replace_notin_at(self, index, value): + self.notin[index] = value + def get_lceil(self): + return self.lceil + def set_lceil(self, lceil): + self.lceil = lceil + def add_lceil(self, value): + self.lceil.append(value) + def insert_lceil_at(self, index, value): + self.lceil.insert(index, value) + def replace_lceil_at(self, index, value): + self.lceil[index] = value + def get_rceil(self): + return self.rceil + def set_rceil(self, rceil): + self.rceil = rceil + def add_rceil(self, value): + self.rceil.append(value) + def insert_rceil_at(self, index, value): + self.rceil.insert(index, value) + def replace_rceil_at(self, index, value): + self.rceil[index] = value + def get_lfloor(self): + return self.lfloor + def set_lfloor(self, lfloor): + self.lfloor = lfloor + def add_lfloor(self, value): + self.lfloor.append(value) + def insert_lfloor_at(self, index, value): + self.lfloor.insert(index, value) + def replace_lfloor_at(self, index, value): + self.lfloor[index] = value + def get_rfloor(self): + return self.rfloor + def set_rfloor(self, rfloor): + self.rfloor = rfloor + def add_rfloor(self, value): + self.rfloor.append(value) + def insert_rfloor_at(self, index, value): + self.rfloor.insert(index, value) + def replace_rfloor_at(self, index, value): + self.rfloor[index] = value + 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_width(self): + return self.width + def set_width(self, width): + self.width = width + def get_height(self): + return self.height + def set_height(self, height): + self.height = height + def get_valueOf_(self): return self.valueOf_ + def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def validate_DoxImageKind(self, value): + # Validate type DoxImageKind, a restriction on xsd:string. + if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) + return False + value = value + enumerations = ['html', 'latex', 'rtf'] + if value not in enumerations: + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on DoxImageKind' % {"value" : encode_str_2_3(value), "lineno": lineno} ) + result = False + def hasContent_(self): + if ( + self.ulink or + self.bold or + self.emphasis or + self.computeroutput or + self.subscript or + self.superscript or + self.center or + self.small or + self.htmlonly or + self.manonly or + self.xmlonly or + self.rtfonly or + self.latexonly or + self.dot or + self.msc or + self.anchor or + self.formula or + self.ref or + self.copy or + self.trademark or + self.registered or + self.lsquo or + self.rsquo or + self.ldquo or + self.rdquo or + self.ndash or + self.mdash or + self.umlaut or + self.acute or + self.grave or + self.circ or + self.slash or + self.tilde or + self.cedil or + self.ring or + self.szlig or + self.nonbreakablespace or + self.aelig or + self.AElig or + self.Gamma or + self.Delta or + self.Theta or + self.Lambda or + self.Xi or + self.Pi or + self.Sigma or + self.Upsilon or + self.Phi or + self.Psi or + self.Omega or + self.alpha or + self.beta or + self.gamma or + self.delta or + self.epsilon or + self.zeta or + self.eta or + self.theta or + self.iota or + self.kappa or + self.lambda_ or + self.mu or + self.nu or + self.xi or + self.pi or + self.rho or + self.sigma or + self.tau or + self.upsilon or + self.phi or + self.chi or + self.psi or + self.omega or + self.sigmaf or + self.sect or + self.deg or + self.prime or + self.Prime or + self.infin or + self.empty or + self.plusmn or + self.times or + self.minus or + self.sdot or + self.part or + self.nabla or + self.radic or + self.perp or + self.sum or + self.int or + self.prod or + self.sim or + self.asymp or + self.ne or + self.equiv or + self.prop or + self.le or + self.ge or + self.larr or + self.rarr or + self.isin or + self.notin or + self.lceil or + self.rceil or + self.lfloor or + self.rfloor or + (1 if type(self.valueOf_) in [int,float] else self.valueOf_) or + self.content_ + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docImageType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docImageType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docImageType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docImageType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docImageType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docImageType'): + if self.type_ is not None and 'type_' not in already_processed: + already_processed.add('type_') + outfile.write(' type=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.type_), input_name='type')), )) + if self.name is not None and 'name' not in already_processed: + already_processed.add('name') + outfile.write(' name=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.name), input_name='name')), )) + if self.width is not None and 'width' not in already_processed: + already_processed.add('width') + outfile.write(' width=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.width), input_name='width')), )) + if self.height is not None and 'height' not in already_processed: + already_processed.add('height') + outfile.write(' height=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.height), input_name='height')), )) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docImageType', fromsubclass_=False, pretty_print=True): + if not fromsubclass_: + for item_ in self.content_: + item_.export(outfile, level, item_.name, namespaceprefix_, pretty_print=pretty_print) + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for ulink_ in self.ulink: + namespaceprefix_ = self.ulink_nsprefix_ + ':' if (UseCapturedNS_ and self.ulink_nsprefix_) else '' + ulink_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ulink', pretty_print=pretty_print) + for bold_ in self.bold: + namespaceprefix_ = self.bold_nsprefix_ + ':' if (UseCapturedNS_ and self.bold_nsprefix_) else '' + bold_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='bold', pretty_print=pretty_print) + for emphasis_ in self.emphasis: + namespaceprefix_ = self.emphasis_nsprefix_ + ':' if (UseCapturedNS_ and self.emphasis_nsprefix_) else '' + emphasis_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='emphasis', pretty_print=pretty_print) + for computeroutput_ in self.computeroutput: + namespaceprefix_ = self.computeroutput_nsprefix_ + ':' if (UseCapturedNS_ and self.computeroutput_nsprefix_) else '' + computeroutput_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='computeroutput', pretty_print=pretty_print) + for subscript_ in self.subscript: + namespaceprefix_ = self.subscript_nsprefix_ + ':' if (UseCapturedNS_ and self.subscript_nsprefix_) else '' + subscript_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='subscript', pretty_print=pretty_print) + for superscript_ in self.superscript: + namespaceprefix_ = self.superscript_nsprefix_ + ':' if (UseCapturedNS_ and self.superscript_nsprefix_) else '' + superscript_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='superscript', pretty_print=pretty_print) + for center_ in self.center: + namespaceprefix_ = self.center_nsprefix_ + ':' if (UseCapturedNS_ and self.center_nsprefix_) else '' + center_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='center', pretty_print=pretty_print) + for small_ in self.small: + namespaceprefix_ = self.small_nsprefix_ + ':' if (UseCapturedNS_ and self.small_nsprefix_) else '' + small_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='small', pretty_print=pretty_print) + for htmlonly_ in self.htmlonly: + namespaceprefix_ = self.htmlonly_nsprefix_ + ':' if (UseCapturedNS_ and self.htmlonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%shtmlonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(htmlonly_), input_name='htmlonly')), namespaceprefix_ , eol_)) + for manonly_ in self.manonly: + namespaceprefix_ = self.manonly_nsprefix_ + ':' if (UseCapturedNS_ and self.manonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%smanonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(manonly_), input_name='manonly')), namespaceprefix_ , eol_)) + for xmlonly_ in self.xmlonly: + namespaceprefix_ = self.xmlonly_nsprefix_ + ':' if (UseCapturedNS_ and self.xmlonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%sxmlonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(xmlonly_), input_name='xmlonly')), namespaceprefix_ , eol_)) + for rtfonly_ in self.rtfonly: + namespaceprefix_ = self.rtfonly_nsprefix_ + ':' if (UseCapturedNS_ and self.rtfonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%srtfonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(rtfonly_), input_name='rtfonly')), namespaceprefix_ , eol_)) + for latexonly_ in self.latexonly: + namespaceprefix_ = self.latexonly_nsprefix_ + ':' if (UseCapturedNS_ and self.latexonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%slatexonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(latexonly_), input_name='latexonly')), namespaceprefix_ , eol_)) + for dot_ in self.dot: + namespaceprefix_ = self.dot_nsprefix_ + ':' if (UseCapturedNS_ and self.dot_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%sdot>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(dot_), input_name='dot')), namespaceprefix_ , eol_)) + for msc_ in self.msc: + namespaceprefix_ = self.msc_nsprefix_ + ':' if (UseCapturedNS_ and self.msc_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%smsc>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(msc_), input_name='msc')), namespaceprefix_ , eol_)) + for anchor_ in self.anchor: + namespaceprefix_ = self.anchor_nsprefix_ + ':' if (UseCapturedNS_ and self.anchor_nsprefix_) else '' + anchor_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='anchor', pretty_print=pretty_print) + for formula_ in self.formula: + namespaceprefix_ = self.formula_nsprefix_ + ':' if (UseCapturedNS_ and self.formula_nsprefix_) else '' + formula_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='formula', pretty_print=pretty_print) + for ref_ in self.ref: + namespaceprefix_ = self.ref_nsprefix_ + ':' if (UseCapturedNS_ and self.ref_nsprefix_) else '' + ref_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ref', pretty_print=pretty_print) + for copy_ in self.copy: + namespaceprefix_ = self.copy_nsprefix_ + ':' if (UseCapturedNS_ and self.copy_nsprefix_) else '' + copy_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='copy', pretty_print=pretty_print) + for trademark_ in self.trademark: + namespaceprefix_ = self.trademark_nsprefix_ + ':' if (UseCapturedNS_ and self.trademark_nsprefix_) else '' + trademark_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='trademark', pretty_print=pretty_print) + for registered_ in self.registered: + namespaceprefix_ = self.registered_nsprefix_ + ':' if (UseCapturedNS_ and self.registered_nsprefix_) else '' + registered_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='registered', pretty_print=pretty_print) + for lsquo_ in self.lsquo: + namespaceprefix_ = self.lsquo_nsprefix_ + ':' if (UseCapturedNS_ and self.lsquo_nsprefix_) else '' + lsquo_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='lsquo', pretty_print=pretty_print) + for rsquo_ in self.rsquo: + namespaceprefix_ = self.rsquo_nsprefix_ + ':' if (UseCapturedNS_ and self.rsquo_nsprefix_) else '' + rsquo_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rsquo', pretty_print=pretty_print) + for ldquo_ in self.ldquo: + namespaceprefix_ = self.ldquo_nsprefix_ + ':' if (UseCapturedNS_ and self.ldquo_nsprefix_) else '' + ldquo_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ldquo', pretty_print=pretty_print) + for rdquo_ in self.rdquo: + namespaceprefix_ = self.rdquo_nsprefix_ + ':' if (UseCapturedNS_ and self.rdquo_nsprefix_) else '' + rdquo_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rdquo', pretty_print=pretty_print) + for ndash_ in self.ndash: + namespaceprefix_ = self.ndash_nsprefix_ + ':' if (UseCapturedNS_ and self.ndash_nsprefix_) else '' + ndash_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ndash', pretty_print=pretty_print) + for mdash_ in self.mdash: + namespaceprefix_ = self.mdash_nsprefix_ + ':' if (UseCapturedNS_ and self.mdash_nsprefix_) else '' + mdash_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='mdash', pretty_print=pretty_print) + for umlaut_ in self.umlaut: + namespaceprefix_ = self.umlaut_nsprefix_ + ':' if (UseCapturedNS_ and self.umlaut_nsprefix_) else '' + umlaut_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='umlaut', pretty_print=pretty_print) + for acute_ in self.acute: + namespaceprefix_ = self.acute_nsprefix_ + ':' if (UseCapturedNS_ and self.acute_nsprefix_) else '' + acute_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='acute', pretty_print=pretty_print) + for grave_ in self.grave: + namespaceprefix_ = self.grave_nsprefix_ + ':' if (UseCapturedNS_ and self.grave_nsprefix_) else '' + grave_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='grave', pretty_print=pretty_print) + for circ_ in self.circ: + namespaceprefix_ = self.circ_nsprefix_ + ':' if (UseCapturedNS_ and self.circ_nsprefix_) else '' + circ_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='circ', pretty_print=pretty_print) + for slash_ in self.slash: + namespaceprefix_ = self.slash_nsprefix_ + ':' if (UseCapturedNS_ and self.slash_nsprefix_) else '' + slash_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='slash', pretty_print=pretty_print) + for tilde_ in self.tilde: + namespaceprefix_ = self.tilde_nsprefix_ + ':' if (UseCapturedNS_ and self.tilde_nsprefix_) else '' + tilde_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='tilde', pretty_print=pretty_print) + for cedil_ in self.cedil: + namespaceprefix_ = self.cedil_nsprefix_ + ':' if (UseCapturedNS_ and self.cedil_nsprefix_) else '' + cedil_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='cedil', pretty_print=pretty_print) + for ring_ in self.ring: + namespaceprefix_ = self.ring_nsprefix_ + ':' if (UseCapturedNS_ and self.ring_nsprefix_) else '' + ring_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ring', pretty_print=pretty_print) + for szlig_ in self.szlig: + namespaceprefix_ = self.szlig_nsprefix_ + ':' if (UseCapturedNS_ and self.szlig_nsprefix_) else '' + szlig_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='szlig', pretty_print=pretty_print) + for nonbreakablespace_ in self.nonbreakablespace: + namespaceprefix_ = self.nonbreakablespace_nsprefix_ + ':' if (UseCapturedNS_ and self.nonbreakablespace_nsprefix_) else '' + nonbreakablespace_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='nonbreakablespace', pretty_print=pretty_print) + for aelig_ in self.aelig: + namespaceprefix_ = self.aelig_nsprefix_ + ':' if (UseCapturedNS_ and self.aelig_nsprefix_) else '' + aelig_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='aelig', pretty_print=pretty_print) + for AElig_ in self.AElig: + namespaceprefix_ = self.AElig_nsprefix_ + ':' if (UseCapturedNS_ and self.AElig_nsprefix_) else '' + AElig_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='AElig', pretty_print=pretty_print) + for Gamma_ in self.Gamma: + namespaceprefix_ = self.Gamma_nsprefix_ + ':' if (UseCapturedNS_ and self.Gamma_nsprefix_) else '' + Gamma_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Gamma', pretty_print=pretty_print) + for Delta_ in self.Delta: + namespaceprefix_ = self.Delta_nsprefix_ + ':' if (UseCapturedNS_ and self.Delta_nsprefix_) else '' + Delta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Delta', pretty_print=pretty_print) + for Theta_ in self.Theta: + namespaceprefix_ = self.Theta_nsprefix_ + ':' if (UseCapturedNS_ and self.Theta_nsprefix_) else '' + Theta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Theta', pretty_print=pretty_print) + for Lambda_ in self.Lambda: + namespaceprefix_ = self.Lambda_nsprefix_ + ':' if (UseCapturedNS_ and self.Lambda_nsprefix_) else '' + Lambda_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Lambda', pretty_print=pretty_print) + for Xi_ in self.Xi: + namespaceprefix_ = self.Xi_nsprefix_ + ':' if (UseCapturedNS_ and self.Xi_nsprefix_) else '' + Xi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Xi', pretty_print=pretty_print) + for Pi_ in self.Pi: + namespaceprefix_ = self.Pi_nsprefix_ + ':' if (UseCapturedNS_ and self.Pi_nsprefix_) else '' + Pi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Pi', pretty_print=pretty_print) + for Sigma_ in self.Sigma: + namespaceprefix_ = self.Sigma_nsprefix_ + ':' if (UseCapturedNS_ and self.Sigma_nsprefix_) else '' + Sigma_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Sigma', pretty_print=pretty_print) + for Upsilon_ in self.Upsilon: + namespaceprefix_ = self.Upsilon_nsprefix_ + ':' if (UseCapturedNS_ and self.Upsilon_nsprefix_) else '' + Upsilon_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Upsilon', pretty_print=pretty_print) + for Phi_ in self.Phi: + namespaceprefix_ = self.Phi_nsprefix_ + ':' if (UseCapturedNS_ and self.Phi_nsprefix_) else '' + Phi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Phi', pretty_print=pretty_print) + for Psi_ in self.Psi: + namespaceprefix_ = self.Psi_nsprefix_ + ':' if (UseCapturedNS_ and self.Psi_nsprefix_) else '' + Psi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Psi', pretty_print=pretty_print) + for Omega_ in self.Omega: + namespaceprefix_ = self.Omega_nsprefix_ + ':' if (UseCapturedNS_ and self.Omega_nsprefix_) else '' + Omega_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Omega', pretty_print=pretty_print) + for alpha_ in self.alpha: + namespaceprefix_ = self.alpha_nsprefix_ + ':' if (UseCapturedNS_ and self.alpha_nsprefix_) else '' + alpha_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='alpha', pretty_print=pretty_print) + for beta_ in self.beta: + namespaceprefix_ = self.beta_nsprefix_ + ':' if (UseCapturedNS_ and self.beta_nsprefix_) else '' + beta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='beta', pretty_print=pretty_print) + for gamma_ in self.gamma: + namespaceprefix_ = self.gamma_nsprefix_ + ':' if (UseCapturedNS_ and self.gamma_nsprefix_) else '' + gamma_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='gamma', pretty_print=pretty_print) + for delta_ in self.delta: + namespaceprefix_ = self.delta_nsprefix_ + ':' if (UseCapturedNS_ and self.delta_nsprefix_) else '' + delta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='delta', pretty_print=pretty_print) + for epsilon_ in self.epsilon: + namespaceprefix_ = self.epsilon_nsprefix_ + ':' if (UseCapturedNS_ and self.epsilon_nsprefix_) else '' + epsilon_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='epsilon', pretty_print=pretty_print) + for zeta_ in self.zeta: + namespaceprefix_ = self.zeta_nsprefix_ + ':' if (UseCapturedNS_ and self.zeta_nsprefix_) else '' + zeta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='zeta', pretty_print=pretty_print) + for eta_ in self.eta: + namespaceprefix_ = self.eta_nsprefix_ + ':' if (UseCapturedNS_ and self.eta_nsprefix_) else '' + eta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='eta', pretty_print=pretty_print) + for theta_ in self.theta: + namespaceprefix_ = self.theta_nsprefix_ + ':' if (UseCapturedNS_ and self.theta_nsprefix_) else '' + theta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='theta', pretty_print=pretty_print) + for iota_ in self.iota: + namespaceprefix_ = self.iota_nsprefix_ + ':' if (UseCapturedNS_ and self.iota_nsprefix_) else '' + iota_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='iota', pretty_print=pretty_print) + for kappa_ in self.kappa: + namespaceprefix_ = self.kappa_nsprefix_ + ':' if (UseCapturedNS_ and self.kappa_nsprefix_) else '' + kappa_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='kappa', pretty_print=pretty_print) + for lambda_ in self.lambda_: + namespaceprefix_ = self.lambda__nsprefix_ + ':' if (UseCapturedNS_ and self.lambda__nsprefix_) else '' + lambda_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='lambda', pretty_print=pretty_print) + for mu_ in self.mu: + namespaceprefix_ = self.mu_nsprefix_ + ':' if (UseCapturedNS_ and self.mu_nsprefix_) else '' + mu_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='mu', pretty_print=pretty_print) + for nu_ in self.nu: + namespaceprefix_ = self.nu_nsprefix_ + ':' if (UseCapturedNS_ and self.nu_nsprefix_) else '' + nu_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='nu', pretty_print=pretty_print) + for xi_ in self.xi: + namespaceprefix_ = self.xi_nsprefix_ + ':' if (UseCapturedNS_ and self.xi_nsprefix_) else '' + xi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='xi', pretty_print=pretty_print) + for pi_ in self.pi: + namespaceprefix_ = self.pi_nsprefix_ + ':' if (UseCapturedNS_ and self.pi_nsprefix_) else '' + pi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='pi', pretty_print=pretty_print) + for rho_ in self.rho: + namespaceprefix_ = self.rho_nsprefix_ + ':' if (UseCapturedNS_ and self.rho_nsprefix_) else '' + rho_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rho', pretty_print=pretty_print) + for sigma_ in self.sigma: + namespaceprefix_ = self.sigma_nsprefix_ + ':' if (UseCapturedNS_ and self.sigma_nsprefix_) else '' + sigma_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sigma', pretty_print=pretty_print) + for tau_ in self.tau: + namespaceprefix_ = self.tau_nsprefix_ + ':' if (UseCapturedNS_ and self.tau_nsprefix_) else '' + tau_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='tau', pretty_print=pretty_print) + for upsilon_ in self.upsilon: + namespaceprefix_ = self.upsilon_nsprefix_ + ':' if (UseCapturedNS_ and self.upsilon_nsprefix_) else '' + upsilon_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='upsilon', pretty_print=pretty_print) + for phi_ in self.phi: + namespaceprefix_ = self.phi_nsprefix_ + ':' if (UseCapturedNS_ and self.phi_nsprefix_) else '' + phi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='phi', pretty_print=pretty_print) + for chi_ in self.chi: + namespaceprefix_ = self.chi_nsprefix_ + ':' if (UseCapturedNS_ and self.chi_nsprefix_) else '' + chi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='chi', pretty_print=pretty_print) + for psi_ in self.psi: + namespaceprefix_ = self.psi_nsprefix_ + ':' if (UseCapturedNS_ and self.psi_nsprefix_) else '' + psi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='psi', pretty_print=pretty_print) + for omega_ in self.omega: + namespaceprefix_ = self.omega_nsprefix_ + ':' if (UseCapturedNS_ and self.omega_nsprefix_) else '' + omega_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='omega', pretty_print=pretty_print) + for sigmaf_ in self.sigmaf: + namespaceprefix_ = self.sigmaf_nsprefix_ + ':' if (UseCapturedNS_ and self.sigmaf_nsprefix_) else '' + sigmaf_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sigmaf', pretty_print=pretty_print) + for sect_ in self.sect: + namespaceprefix_ = self.sect_nsprefix_ + ':' if (UseCapturedNS_ and self.sect_nsprefix_) else '' + sect_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sect', pretty_print=pretty_print) + for deg_ in self.deg: + namespaceprefix_ = self.deg_nsprefix_ + ':' if (UseCapturedNS_ and self.deg_nsprefix_) else '' + deg_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='deg', pretty_print=pretty_print) + for prime_ in self.prime: + namespaceprefix_ = self.prime_nsprefix_ + ':' if (UseCapturedNS_ and self.prime_nsprefix_) else '' + prime_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='prime', pretty_print=pretty_print) + for Prime_ in self.Prime: + namespaceprefix_ = self.Prime_nsprefix_ + ':' if (UseCapturedNS_ and self.Prime_nsprefix_) else '' + Prime_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Prime', pretty_print=pretty_print) + for infin_ in self.infin: + namespaceprefix_ = self.infin_nsprefix_ + ':' if (UseCapturedNS_ and self.infin_nsprefix_) else '' + infin_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='infin', pretty_print=pretty_print) + for empty_ in self.empty: + namespaceprefix_ = self.empty_nsprefix_ + ':' if (UseCapturedNS_ and self.empty_nsprefix_) else '' + empty_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='empty', pretty_print=pretty_print) + for plusmn_ in self.plusmn: + namespaceprefix_ = self.plusmn_nsprefix_ + ':' if (UseCapturedNS_ and self.plusmn_nsprefix_) else '' + plusmn_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='plusmn', pretty_print=pretty_print) + for times_ in self.times: + namespaceprefix_ = self.times_nsprefix_ + ':' if (UseCapturedNS_ and self.times_nsprefix_) else '' + times_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='times', pretty_print=pretty_print) + for minus_ in self.minus: + namespaceprefix_ = self.minus_nsprefix_ + ':' if (UseCapturedNS_ and self.minus_nsprefix_) else '' + minus_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='minus', pretty_print=pretty_print) + for sdot_ in self.sdot: + namespaceprefix_ = self.sdot_nsprefix_ + ':' if (UseCapturedNS_ and self.sdot_nsprefix_) else '' + sdot_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sdot', pretty_print=pretty_print) + for part_ in self.part: + namespaceprefix_ = self.part_nsprefix_ + ':' if (UseCapturedNS_ and self.part_nsprefix_) else '' + part_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='part', pretty_print=pretty_print) + for nabla_ in self.nabla: + namespaceprefix_ = self.nabla_nsprefix_ + ':' if (UseCapturedNS_ and self.nabla_nsprefix_) else '' + nabla_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='nabla', pretty_print=pretty_print) + for radic_ in self.radic: + namespaceprefix_ = self.radic_nsprefix_ + ':' if (UseCapturedNS_ and self.radic_nsprefix_) else '' + radic_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='radic', pretty_print=pretty_print) + for perp_ in self.perp: + namespaceprefix_ = self.perp_nsprefix_ + ':' if (UseCapturedNS_ and self.perp_nsprefix_) else '' + perp_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='perp', pretty_print=pretty_print) + for sum_ in self.sum: + namespaceprefix_ = self.sum_nsprefix_ + ':' if (UseCapturedNS_ and self.sum_nsprefix_) else '' + sum_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sum', pretty_print=pretty_print) + for int_ in self.int: + namespaceprefix_ = self.int_nsprefix_ + ':' if (UseCapturedNS_ and self.int_nsprefix_) else '' + int_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='int', pretty_print=pretty_print) + for prod_ in self.prod: + namespaceprefix_ = self.prod_nsprefix_ + ':' if (UseCapturedNS_ and self.prod_nsprefix_) else '' + prod_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='prod', pretty_print=pretty_print) + for sim_ in self.sim: + namespaceprefix_ = self.sim_nsprefix_ + ':' if (UseCapturedNS_ and self.sim_nsprefix_) else '' + sim_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sim', pretty_print=pretty_print) + for asymp_ in self.asymp: + namespaceprefix_ = self.asymp_nsprefix_ + ':' if (UseCapturedNS_ and self.asymp_nsprefix_) else '' + asymp_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='asymp', pretty_print=pretty_print) + for ne_ in self.ne: + namespaceprefix_ = self.ne_nsprefix_ + ':' if (UseCapturedNS_ and self.ne_nsprefix_) else '' + ne_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ne', pretty_print=pretty_print) + for equiv_ in self.equiv: + namespaceprefix_ = self.equiv_nsprefix_ + ':' if (UseCapturedNS_ and self.equiv_nsprefix_) else '' + equiv_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='equiv', pretty_print=pretty_print) + for prop_ in self.prop: + namespaceprefix_ = self.prop_nsprefix_ + ':' if (UseCapturedNS_ and self.prop_nsprefix_) else '' + prop_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='prop', pretty_print=pretty_print) + for le_ in self.le: + namespaceprefix_ = self.le_nsprefix_ + ':' if (UseCapturedNS_ and self.le_nsprefix_) else '' + le_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='le', pretty_print=pretty_print) + for ge_ in self.ge: + namespaceprefix_ = self.ge_nsprefix_ + ':' if (UseCapturedNS_ and self.ge_nsprefix_) else '' + ge_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ge', pretty_print=pretty_print) + for larr_ in self.larr: + namespaceprefix_ = self.larr_nsprefix_ + ':' if (UseCapturedNS_ and self.larr_nsprefix_) else '' + larr_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='larr', pretty_print=pretty_print) + for rarr_ in self.rarr: + namespaceprefix_ = self.rarr_nsprefix_ + ':' if (UseCapturedNS_ and self.rarr_nsprefix_) else '' + rarr_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rarr', pretty_print=pretty_print) + for isin_ in self.isin: + namespaceprefix_ = self.isin_nsprefix_ + ':' if (UseCapturedNS_ and self.isin_nsprefix_) else '' + isin_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='isin', pretty_print=pretty_print) + for notin_ in self.notin: + namespaceprefix_ = self.notin_nsprefix_ + ':' if (UseCapturedNS_ and self.notin_nsprefix_) else '' + notin_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='notin', pretty_print=pretty_print) + for lceil_ in self.lceil: + namespaceprefix_ = self.lceil_nsprefix_ + ':' if (UseCapturedNS_ and self.lceil_nsprefix_) else '' + lceil_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='lceil', pretty_print=pretty_print) + for rceil_ in self.rceil: + namespaceprefix_ = self.rceil_nsprefix_ + ':' if (UseCapturedNS_ and self.rceil_nsprefix_) else '' + rceil_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rceil', pretty_print=pretty_print) + for lfloor_ in self.lfloor: + namespaceprefix_ = self.lfloor_nsprefix_ + ':' if (UseCapturedNS_ and self.lfloor_nsprefix_) else '' + lfloor_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='lfloor', pretty_print=pretty_print) + for rfloor_ in self.rfloor: + namespaceprefix_ = self.rfloor_nsprefix_ + ':' if (UseCapturedNS_ and self.rfloor_nsprefix_) else '' + rfloor_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rfloor', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + self.valueOf_ = get_all_text_(node) + if node.text is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', node.text) + self.content_.append(obj_) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('type', node) + if value is not None and 'type' not in already_processed: + already_processed.add('type') + self.type_ = value + self.validate_DoxImageKind(self.type_) # validate type DoxImageKind + value = find_attr_value_('name', node) + if value is not None and 'name' not in already_processed: + already_processed.add('name') + self.name = value + value = find_attr_value_('width', node) + if value is not None and 'width' not in already_processed: + already_processed.add('width') + self.width = value + value = find_attr_value_('height', node) + if value is not None and 'height' not in already_processed: + already_processed.add('height') + self.height = value + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'ulink': + obj_ = docURLLink.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ulink', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ulink'): + self.add_ulink(obj_.value) + elif hasattr(self, 'set_ulink'): + self.set_ulink(obj_.value) + elif nodeName_ == 'bold': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'bold', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_bold'): + self.add_bold(obj_.value) + elif hasattr(self, 'set_bold'): + self.set_bold(obj_.value) + elif nodeName_ == 'emphasis': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'emphasis', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_emphasis'): + self.add_emphasis(obj_.value) + elif hasattr(self, 'set_emphasis'): + self.set_emphasis(obj_.value) + elif nodeName_ == 'computeroutput': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'computeroutput', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_computeroutput'): + self.add_computeroutput(obj_.value) + elif hasattr(self, 'set_computeroutput'): + self.set_computeroutput(obj_.value) + elif nodeName_ == 'subscript': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'subscript', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_subscript'): + self.add_subscript(obj_.value) + elif hasattr(self, 'set_subscript'): + self.set_subscript(obj_.value) + elif nodeName_ == 'superscript': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'superscript', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_superscript'): + self.add_superscript(obj_.value) + elif hasattr(self, 'set_superscript'): + self.set_superscript(obj_.value) + elif nodeName_ == 'center': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'center', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_center'): + self.add_center(obj_.value) + elif hasattr(self, 'set_center'): + self.set_center(obj_.value) + elif nodeName_ == 'small': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'small', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_small'): + self.add_small(obj_.value) + elif hasattr(self, 'set_small'): + self.set_small(obj_.value) + elif nodeName_ == 'htmlonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'htmlonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'htmlonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'htmlonly', valuestr_) + self.content_.append(obj_) + self.htmlonly_nsprefix_ = child_.prefix + elif nodeName_ == 'manonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'manonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'manonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'manonly', valuestr_) + self.content_.append(obj_) + self.manonly_nsprefix_ = child_.prefix + elif nodeName_ == 'xmlonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'xmlonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'xmlonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'xmlonly', valuestr_) + self.content_.append(obj_) + self.xmlonly_nsprefix_ = child_.prefix + elif nodeName_ == 'rtfonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'rtfonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'rtfonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'rtfonly', valuestr_) + self.content_.append(obj_) + self.rtfonly_nsprefix_ = child_.prefix + elif nodeName_ == 'latexonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'latexonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'latexonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'latexonly', valuestr_) + self.content_.append(obj_) + self.latexonly_nsprefix_ = child_.prefix + elif nodeName_ == 'dot' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'dot') + valuestr_ = self.gds_validate_string(valuestr_, node, 'dot') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'dot', valuestr_) + self.content_.append(obj_) + self.dot_nsprefix_ = child_.prefix + elif nodeName_ == 'msc' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'msc') + valuestr_ = self.gds_validate_string(valuestr_, node, 'msc') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'msc', valuestr_) + self.content_.append(obj_) + self.msc_nsprefix_ = child_.prefix + elif nodeName_ == 'anchor': + obj_ = docAnchorType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'anchor', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_anchor'): + self.add_anchor(obj_.value) + elif hasattr(self, 'set_anchor'): + self.set_anchor(obj_.value) + elif nodeName_ == 'formula': + obj_ = docFormulaType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'formula', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_formula'): + self.add_formula(obj_.value) + elif hasattr(self, 'set_formula'): + self.set_formula(obj_.value) + elif nodeName_ == 'ref': + obj_ = docRefTextType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ref', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ref'): + self.add_ref(obj_.value) + elif hasattr(self, 'set_ref'): + self.set_ref(obj_.value) + elif nodeName_ == 'copy': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'copy', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_copy'): + self.add_copy(obj_.value) + elif hasattr(self, 'set_copy'): + self.set_copy(obj_.value) + elif nodeName_ == 'trademark': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'trademark', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_trademark'): + self.add_trademark(obj_.value) + elif hasattr(self, 'set_trademark'): + self.set_trademark(obj_.value) + elif nodeName_ == 'registered': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'registered', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_registered'): + self.add_registered(obj_.value) + elif hasattr(self, 'set_registered'): + self.set_registered(obj_.value) + elif nodeName_ == 'lsquo': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'lsquo', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_lsquo'): + self.add_lsquo(obj_.value) + elif hasattr(self, 'set_lsquo'): + self.set_lsquo(obj_.value) + elif nodeName_ == 'rsquo': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rsquo', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rsquo'): + self.add_rsquo(obj_.value) + elif hasattr(self, 'set_rsquo'): + self.set_rsquo(obj_.value) + elif nodeName_ == 'ldquo': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ldquo', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ldquo'): + self.add_ldquo(obj_.value) + elif hasattr(self, 'set_ldquo'): + self.set_ldquo(obj_.value) + elif nodeName_ == 'rdquo': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rdquo', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rdquo'): + self.add_rdquo(obj_.value) + elif hasattr(self, 'set_rdquo'): + self.set_rdquo(obj_.value) + elif nodeName_ == 'ndash': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ndash', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ndash'): + self.add_ndash(obj_.value) + elif hasattr(self, 'set_ndash'): + self.set_ndash(obj_.value) + elif nodeName_ == 'mdash': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'mdash', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_mdash'): + self.add_mdash(obj_.value) + elif hasattr(self, 'set_mdash'): + self.set_mdash(obj_.value) + elif nodeName_ == 'umlaut': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'umlaut', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_umlaut'): + self.add_umlaut(obj_.value) + elif hasattr(self, 'set_umlaut'): + self.set_umlaut(obj_.value) + elif nodeName_ == 'acute': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'acute', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_acute'): + self.add_acute(obj_.value) + elif hasattr(self, 'set_acute'): + self.set_acute(obj_.value) + elif nodeName_ == 'grave': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'grave', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_grave'): + self.add_grave(obj_.value) + elif hasattr(self, 'set_grave'): + self.set_grave(obj_.value) + elif nodeName_ == 'circ': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'circ', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_circ'): + self.add_circ(obj_.value) + elif hasattr(self, 'set_circ'): + self.set_circ(obj_.value) + elif nodeName_ == 'slash': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'slash', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_slash'): + self.add_slash(obj_.value) + elif hasattr(self, 'set_slash'): + self.set_slash(obj_.value) + elif nodeName_ == 'tilde': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'tilde', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_tilde'): + self.add_tilde(obj_.value) + elif hasattr(self, 'set_tilde'): + self.set_tilde(obj_.value) + elif nodeName_ == 'cedil': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'cedil', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_cedil'): + self.add_cedil(obj_.value) + elif hasattr(self, 'set_cedil'): + self.set_cedil(obj_.value) + elif nodeName_ == 'ring': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ring', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ring'): + self.add_ring(obj_.value) + elif hasattr(self, 'set_ring'): + self.set_ring(obj_.value) + elif nodeName_ == 'szlig': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'szlig', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_szlig'): + self.add_szlig(obj_.value) + elif hasattr(self, 'set_szlig'): + self.set_szlig(obj_.value) + elif nodeName_ == 'nonbreakablespace': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'nonbreakablespace', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_nonbreakablespace'): + self.add_nonbreakablespace(obj_.value) + elif hasattr(self, 'set_nonbreakablespace'): + self.set_nonbreakablespace(obj_.value) + elif nodeName_ == 'aelig': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'aelig', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_aelig'): + self.add_aelig(obj_.value) + elif hasattr(self, 'set_aelig'): + self.set_aelig(obj_.value) + elif nodeName_ == 'AElig': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'AElig', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_AElig'): + self.add_AElig(obj_.value) + elif hasattr(self, 'set_AElig'): + self.set_AElig(obj_.value) + elif nodeName_ == 'Gamma': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Gamma', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Gamma'): + self.add_Gamma(obj_.value) + elif hasattr(self, 'set_Gamma'): + self.set_Gamma(obj_.value) + elif nodeName_ == 'Delta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Delta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Delta'): + self.add_Delta(obj_.value) + elif hasattr(self, 'set_Delta'): + self.set_Delta(obj_.value) + elif nodeName_ == 'Theta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Theta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Theta'): + self.add_Theta(obj_.value) + elif hasattr(self, 'set_Theta'): + self.set_Theta(obj_.value) + elif nodeName_ == 'Lambda': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Lambda', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Lambda'): + self.add_Lambda(obj_.value) + elif hasattr(self, 'set_Lambda'): + self.set_Lambda(obj_.value) + elif nodeName_ == 'Xi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Xi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Xi'): + self.add_Xi(obj_.value) + elif hasattr(self, 'set_Xi'): + self.set_Xi(obj_.value) + elif nodeName_ == 'Pi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Pi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Pi'): + self.add_Pi(obj_.value) + elif hasattr(self, 'set_Pi'): + self.set_Pi(obj_.value) + elif nodeName_ == 'Sigma': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Sigma', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Sigma'): + self.add_Sigma(obj_.value) + elif hasattr(self, 'set_Sigma'): + self.set_Sigma(obj_.value) + elif nodeName_ == 'Upsilon': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Upsilon', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Upsilon'): + self.add_Upsilon(obj_.value) + elif hasattr(self, 'set_Upsilon'): + self.set_Upsilon(obj_.value) + elif nodeName_ == 'Phi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Phi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Phi'): + self.add_Phi(obj_.value) + elif hasattr(self, 'set_Phi'): + self.set_Phi(obj_.value) + elif nodeName_ == 'Psi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Psi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Psi'): + self.add_Psi(obj_.value) + elif hasattr(self, 'set_Psi'): + self.set_Psi(obj_.value) + elif nodeName_ == 'Omega': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Omega', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Omega'): + self.add_Omega(obj_.value) + elif hasattr(self, 'set_Omega'): + self.set_Omega(obj_.value) + elif nodeName_ == 'alpha': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'alpha', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_alpha'): + self.add_alpha(obj_.value) + elif hasattr(self, 'set_alpha'): + self.set_alpha(obj_.value) + elif nodeName_ == 'beta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'beta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_beta'): + self.add_beta(obj_.value) + elif hasattr(self, 'set_beta'): + self.set_beta(obj_.value) + elif nodeName_ == 'gamma': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'gamma', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_gamma'): + self.add_gamma(obj_.value) + elif hasattr(self, 'set_gamma'): + self.set_gamma(obj_.value) + elif nodeName_ == 'delta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'delta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_delta'): + self.add_delta(obj_.value) + elif hasattr(self, 'set_delta'): + self.set_delta(obj_.value) + elif nodeName_ == 'epsilon': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'epsilon', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_epsilon'): + self.add_epsilon(obj_.value) + elif hasattr(self, 'set_epsilon'): + self.set_epsilon(obj_.value) + elif nodeName_ == 'zeta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'zeta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_zeta'): + self.add_zeta(obj_.value) + elif hasattr(self, 'set_zeta'): + self.set_zeta(obj_.value) + elif nodeName_ == 'eta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'eta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_eta'): + self.add_eta(obj_.value) + elif hasattr(self, 'set_eta'): + self.set_eta(obj_.value) + elif nodeName_ == 'theta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'theta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_theta'): + self.add_theta(obj_.value) + elif hasattr(self, 'set_theta'): + self.set_theta(obj_.value) + elif nodeName_ == 'iota': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'iota', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_iota'): + self.add_iota(obj_.value) + elif hasattr(self, 'set_iota'): + self.set_iota(obj_.value) + elif nodeName_ == 'kappa': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'kappa', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_kappa'): + self.add_kappa(obj_.value) + elif hasattr(self, 'set_kappa'): + self.set_kappa(obj_.value) + elif nodeName_ == 'lambda': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'lambda', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_lambda'): + self.add_lambda(obj_.value) + elif hasattr(self, 'set_lambda'): + self.set_lambda(obj_.value) + elif nodeName_ == 'mu': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'mu', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_mu'): + self.add_mu(obj_.value) + elif hasattr(self, 'set_mu'): + self.set_mu(obj_.value) + elif nodeName_ == 'nu': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'nu', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_nu'): + self.add_nu(obj_.value) + elif hasattr(self, 'set_nu'): + self.set_nu(obj_.value) + elif nodeName_ == 'xi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'xi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_xi'): + self.add_xi(obj_.value) + elif hasattr(self, 'set_xi'): + self.set_xi(obj_.value) + elif nodeName_ == 'pi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'pi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_pi'): + self.add_pi(obj_.value) + elif hasattr(self, 'set_pi'): + self.set_pi(obj_.value) + elif nodeName_ == 'rho': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rho', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rho'): + self.add_rho(obj_.value) + elif hasattr(self, 'set_rho'): + self.set_rho(obj_.value) + elif nodeName_ == 'sigma': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sigma', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sigma'): + self.add_sigma(obj_.value) + elif hasattr(self, 'set_sigma'): + self.set_sigma(obj_.value) + elif nodeName_ == 'tau': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'tau', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_tau'): + self.add_tau(obj_.value) + elif hasattr(self, 'set_tau'): + self.set_tau(obj_.value) + elif nodeName_ == 'upsilon': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'upsilon', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_upsilon'): + self.add_upsilon(obj_.value) + elif hasattr(self, 'set_upsilon'): + self.set_upsilon(obj_.value) + elif nodeName_ == 'phi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'phi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_phi'): + self.add_phi(obj_.value) + elif hasattr(self, 'set_phi'): + self.set_phi(obj_.value) + elif nodeName_ == 'chi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'chi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_chi'): + self.add_chi(obj_.value) + elif hasattr(self, 'set_chi'): + self.set_chi(obj_.value) + elif nodeName_ == 'psi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'psi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_psi'): + self.add_psi(obj_.value) + elif hasattr(self, 'set_psi'): + self.set_psi(obj_.value) + elif nodeName_ == 'omega': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'omega', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_omega'): + self.add_omega(obj_.value) + elif hasattr(self, 'set_omega'): + self.set_omega(obj_.value) + elif nodeName_ == 'sigmaf': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sigmaf', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sigmaf'): + self.add_sigmaf(obj_.value) + elif hasattr(self, 'set_sigmaf'): + self.set_sigmaf(obj_.value) + elif nodeName_ == 'sect': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sect', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sect'): + self.add_sect(obj_.value) + elif hasattr(self, 'set_sect'): + self.set_sect(obj_.value) + elif nodeName_ == 'deg': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'deg', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_deg'): + self.add_deg(obj_.value) + elif hasattr(self, 'set_deg'): + self.set_deg(obj_.value) + elif nodeName_ == 'prime': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'prime', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_prime'): + self.add_prime(obj_.value) + elif hasattr(self, 'set_prime'): + self.set_prime(obj_.value) + elif nodeName_ == 'Prime': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Prime', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Prime'): + self.add_Prime(obj_.value) + elif hasattr(self, 'set_Prime'): + self.set_Prime(obj_.value) + elif nodeName_ == 'infin': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'infin', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_infin'): + self.add_infin(obj_.value) + elif hasattr(self, 'set_infin'): + self.set_infin(obj_.value) + elif nodeName_ == 'empty': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'empty', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_empty'): + self.add_empty(obj_.value) + elif hasattr(self, 'set_empty'): + self.set_empty(obj_.value) + elif nodeName_ == 'plusmn': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'plusmn', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_plusmn'): + self.add_plusmn(obj_.value) + elif hasattr(self, 'set_plusmn'): + self.set_plusmn(obj_.value) + elif nodeName_ == 'times': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'times', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_times'): + self.add_times(obj_.value) + elif hasattr(self, 'set_times'): + self.set_times(obj_.value) + elif nodeName_ == 'minus': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'minus', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_minus'): + self.add_minus(obj_.value) + elif hasattr(self, 'set_minus'): + self.set_minus(obj_.value) + elif nodeName_ == 'sdot': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sdot', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sdot'): + self.add_sdot(obj_.value) + elif hasattr(self, 'set_sdot'): + self.set_sdot(obj_.value) + elif nodeName_ == 'part': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'part', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_part'): + self.add_part(obj_.value) + elif hasattr(self, 'set_part'): + self.set_part(obj_.value) + elif nodeName_ == 'nabla': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'nabla', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_nabla'): + self.add_nabla(obj_.value) + elif hasattr(self, 'set_nabla'): + self.set_nabla(obj_.value) + elif nodeName_ == 'radic': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'radic', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_radic'): + self.add_radic(obj_.value) + elif hasattr(self, 'set_radic'): + self.set_radic(obj_.value) + elif nodeName_ == 'perp': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'perp', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_perp'): + self.add_perp(obj_.value) + elif hasattr(self, 'set_perp'): + self.set_perp(obj_.value) + elif nodeName_ == 'sum': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sum', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sum'): + self.add_sum(obj_.value) + elif hasattr(self, 'set_sum'): + self.set_sum(obj_.value) + elif nodeName_ == 'int': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'int', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_int'): + self.add_int(obj_.value) + elif hasattr(self, 'set_int'): + self.set_int(obj_.value) + elif nodeName_ == 'prod': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'prod', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_prod'): + self.add_prod(obj_.value) + elif hasattr(self, 'set_prod'): + self.set_prod(obj_.value) + elif nodeName_ == 'sim': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sim', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sim'): + self.add_sim(obj_.value) + elif hasattr(self, 'set_sim'): + self.set_sim(obj_.value) + elif nodeName_ == 'asymp': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'asymp', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_asymp'): + self.add_asymp(obj_.value) + elif hasattr(self, 'set_asymp'): + self.set_asymp(obj_.value) + elif nodeName_ == 'ne': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ne', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ne'): + self.add_ne(obj_.value) + elif hasattr(self, 'set_ne'): + self.set_ne(obj_.value) + elif nodeName_ == 'equiv': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'equiv', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_equiv'): + self.add_equiv(obj_.value) + elif hasattr(self, 'set_equiv'): + self.set_equiv(obj_.value) + elif nodeName_ == 'prop': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'prop', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_prop'): + self.add_prop(obj_.value) + elif hasattr(self, 'set_prop'): + self.set_prop(obj_.value) + elif nodeName_ == 'le': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'le', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_le'): + self.add_le(obj_.value) + elif hasattr(self, 'set_le'): + self.set_le(obj_.value) + elif nodeName_ == 'ge': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ge', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ge'): + self.add_ge(obj_.value) + elif hasattr(self, 'set_ge'): + self.set_ge(obj_.value) + elif nodeName_ == 'larr': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'larr', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_larr'): + self.add_larr(obj_.value) + elif hasattr(self, 'set_larr'): + self.set_larr(obj_.value) + elif nodeName_ == 'rarr': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rarr', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rarr'): + self.add_rarr(obj_.value) + elif hasattr(self, 'set_rarr'): + self.set_rarr(obj_.value) + elif nodeName_ == 'isin': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'isin', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_isin'): + self.add_isin(obj_.value) + elif hasattr(self, 'set_isin'): + self.set_isin(obj_.value) + elif nodeName_ == 'notin': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'notin', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_notin'): + self.add_notin(obj_.value) + elif hasattr(self, 'set_notin'): + self.set_notin(obj_.value) + elif nodeName_ == 'lceil': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'lceil', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_lceil'): + self.add_lceil(obj_.value) + elif hasattr(self, 'set_lceil'): + self.set_lceil(obj_.value) + elif nodeName_ == 'rceil': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rceil', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rceil'): + self.add_rceil(obj_.value) + elif hasattr(self, 'set_rceil'): + self.set_rceil(obj_.value) + elif nodeName_ == 'lfloor': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'lfloor', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_lfloor'): + self.add_lfloor(obj_.value) + elif hasattr(self, 'set_lfloor'): + self.set_lfloor(obj_.value) + elif nodeName_ == 'rfloor': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rfloor', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rfloor'): + self.add_rfloor(obj_.value) + elif hasattr(self, 'set_rfloor'): + self.set_rfloor(obj_.value) + if not fromsubclass_ and child_.tail is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.tail) + self.content_.append(obj_) +# end class docImageType + + +class docFileType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, name=None, ulink=None, bold=None, emphasis=None, computeroutput=None, subscript=None, superscript=None, center=None, small=None, htmlonly=None, manonly=None, xmlonly=None, rtfonly=None, latexonly=None, dot=None, msc=None, anchor=None, formula=None, ref=None, copy=None, trademark=None, registered=None, lsquo=None, rsquo=None, ldquo=None, rdquo=None, ndash=None, mdash=None, umlaut=None, acute=None, grave=None, circ=None, slash=None, tilde=None, cedil=None, ring=None, szlig=None, nonbreakablespace=None, aelig=None, AElig=None, Gamma=None, Delta=None, Theta=None, Lambda=None, Xi=None, Pi=None, Sigma=None, Upsilon=None, Phi=None, Psi=None, Omega=None, alpha=None, beta=None, gamma=None, delta=None, epsilon=None, zeta=None, eta=None, theta=None, iota=None, kappa=None, lambda_=None, mu=None, nu=None, xi=None, pi=None, rho=None, sigma=None, tau=None, upsilon=None, phi=None, chi=None, psi=None, omega=None, sigmaf=None, sect=None, deg=None, prime=None, Prime=None, infin=None, empty=None, plusmn=None, times=None, minus=None, sdot=None, part=None, nabla=None, radic=None, perp=None, sum=None, int=None, prod=None, sim=None, asymp=None, ne=None, equiv=None, prop=None, le=None, ge=None, larr=None, rarr=None, isin=None, notin=None, lceil=None, rceil=None, lfloor=None, rfloor=None, valueOf_=None, mixedclass_=None, content_=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.name = _cast(None, name) + self.name_nsprefix_ = None + if ulink is None: + self.ulink = [] + else: + self.ulink = ulink + self.ulink_nsprefix_ = None + if bold is None: + self.bold = [] + else: + self.bold = bold + self.bold_nsprefix_ = None + if emphasis is None: + self.emphasis = [] + else: + self.emphasis = emphasis + self.emphasis_nsprefix_ = None + if computeroutput is None: + self.computeroutput = [] + else: + self.computeroutput = computeroutput + self.computeroutput_nsprefix_ = None + if subscript is None: + self.subscript = [] + else: + self.subscript = subscript + self.subscript_nsprefix_ = None + if superscript is None: + self.superscript = [] + else: + self.superscript = superscript + self.superscript_nsprefix_ = None + if center is None: + self.center = [] + else: + self.center = center + self.center_nsprefix_ = None + if small is None: + self.small = [] + else: + self.small = small + self.small_nsprefix_ = None + if htmlonly is None: + self.htmlonly = [] + else: + self.htmlonly = htmlonly + self.htmlonly_nsprefix_ = None + if manonly is None: + self.manonly = [] + else: + self.manonly = manonly + self.manonly_nsprefix_ = None + if xmlonly is None: + self.xmlonly = [] + else: + self.xmlonly = xmlonly + self.xmlonly_nsprefix_ = None + if rtfonly is None: + self.rtfonly = [] + else: + self.rtfonly = rtfonly + self.rtfonly_nsprefix_ = None + if latexonly is None: + self.latexonly = [] + else: + self.latexonly = latexonly + self.latexonly_nsprefix_ = None + if dot is None: + self.dot = [] + else: + self.dot = dot + self.dot_nsprefix_ = None + if msc is None: + self.msc = [] + else: + self.msc = msc + self.msc_nsprefix_ = None + if anchor is None: + self.anchor = [] + else: + self.anchor = anchor + self.anchor_nsprefix_ = None + if formula is None: + self.formula = [] + else: + self.formula = formula + self.formula_nsprefix_ = None + if ref is None: + self.ref = [] + else: + self.ref = ref + self.ref_nsprefix_ = None + if copy is None: + self.copy = [] + else: + self.copy = copy + self.copy_nsprefix_ = None + if trademark is None: + self.trademark = [] + else: + self.trademark = trademark + self.trademark_nsprefix_ = None + if registered is None: + self.registered = [] + else: + self.registered = registered + self.registered_nsprefix_ = None + if lsquo is None: + self.lsquo = [] + else: + self.lsquo = lsquo + self.lsquo_nsprefix_ = None + if rsquo is None: + self.rsquo = [] + else: + self.rsquo = rsquo + self.rsquo_nsprefix_ = None + if ldquo is None: + self.ldquo = [] + else: + self.ldquo = ldquo + self.ldquo_nsprefix_ = None + if rdquo is None: + self.rdquo = [] + else: + self.rdquo = rdquo + self.rdquo_nsprefix_ = None + if ndash is None: + self.ndash = [] + else: + self.ndash = ndash + self.ndash_nsprefix_ = None + if mdash is None: + self.mdash = [] + else: + self.mdash = mdash + self.mdash_nsprefix_ = None + if umlaut is None: + self.umlaut = [] + else: + self.umlaut = umlaut + self.umlaut_nsprefix_ = None + if acute is None: + self.acute = [] + else: + self.acute = acute + self.acute_nsprefix_ = None + if grave is None: + self.grave = [] + else: + self.grave = grave + self.grave_nsprefix_ = None + if circ is None: + self.circ = [] + else: + self.circ = circ + self.circ_nsprefix_ = None + if slash is None: + self.slash = [] + else: + self.slash = slash + self.slash_nsprefix_ = None + if tilde is None: + self.tilde = [] + else: + self.tilde = tilde + self.tilde_nsprefix_ = None + if cedil is None: + self.cedil = [] + else: + self.cedil = cedil + self.cedil_nsprefix_ = None + if ring is None: + self.ring = [] + else: + self.ring = ring + self.ring_nsprefix_ = None + if szlig is None: + self.szlig = [] + else: + self.szlig = szlig + self.szlig_nsprefix_ = None + if nonbreakablespace is None: + self.nonbreakablespace = [] + else: + self.nonbreakablespace = nonbreakablespace + self.nonbreakablespace_nsprefix_ = None + if aelig is None: + self.aelig = [] + else: + self.aelig = aelig + self.aelig_nsprefix_ = None + if AElig is None: + self.AElig = [] + else: + self.AElig = AElig + self.AElig_nsprefix_ = None + if Gamma is None: + self.Gamma = [] + else: + self.Gamma = Gamma + self.Gamma_nsprefix_ = None + if Delta is None: + self.Delta = [] + else: + self.Delta = Delta + self.Delta_nsprefix_ = None + if Theta is None: + self.Theta = [] + else: + self.Theta = Theta + self.Theta_nsprefix_ = None + if Lambda is None: + self.Lambda = [] + else: + self.Lambda = Lambda + self.Lambda_nsprefix_ = None + if Xi is None: + self.Xi = [] + else: + self.Xi = Xi + self.Xi_nsprefix_ = None + if Pi is None: + self.Pi = [] + else: + self.Pi = Pi + self.Pi_nsprefix_ = None + if Sigma is None: + self.Sigma = [] + else: + self.Sigma = Sigma + self.Sigma_nsprefix_ = None + if Upsilon is None: + self.Upsilon = [] + else: + self.Upsilon = Upsilon + self.Upsilon_nsprefix_ = None + if Phi is None: + self.Phi = [] + else: + self.Phi = Phi + self.Phi_nsprefix_ = None + if Psi is None: + self.Psi = [] + else: + self.Psi = Psi + self.Psi_nsprefix_ = None + if Omega is None: + self.Omega = [] + else: + self.Omega = Omega + self.Omega_nsprefix_ = None + if alpha is None: + self.alpha = [] + else: + self.alpha = alpha + self.alpha_nsprefix_ = None + if beta is None: + self.beta = [] + else: + self.beta = beta + self.beta_nsprefix_ = None + if gamma is None: + self.gamma = [] + else: + self.gamma = gamma + self.gamma_nsprefix_ = None + if delta is None: + self.delta = [] + else: + self.delta = delta + self.delta_nsprefix_ = None + if epsilon is None: + self.epsilon = [] + else: + self.epsilon = epsilon + self.epsilon_nsprefix_ = None + if zeta is None: + self.zeta = [] + else: + self.zeta = zeta + self.zeta_nsprefix_ = None + if eta is None: + self.eta = [] + else: + self.eta = eta + self.eta_nsprefix_ = None + if theta is None: + self.theta = [] + else: + self.theta = theta + self.theta_nsprefix_ = None + if iota is None: + self.iota = [] + else: + self.iota = iota + self.iota_nsprefix_ = None + if kappa is None: + self.kappa = [] + else: + self.kappa = kappa + self.kappa_nsprefix_ = None + if lambda_ is None: + self.lambda_ = [] + else: + self.lambda_ = lambda_ + self.lambda__nsprefix_ = None + if mu is None: + self.mu = [] + else: + self.mu = mu + self.mu_nsprefix_ = None + if nu is None: + self.nu = [] + else: + self.nu = nu + self.nu_nsprefix_ = None + if xi is None: + self.xi = [] + else: + self.xi = xi + self.xi_nsprefix_ = None + if pi is None: + self.pi = [] + else: + self.pi = pi + self.pi_nsprefix_ = None + if rho is None: + self.rho = [] + else: + self.rho = rho + self.rho_nsprefix_ = None + if sigma is None: + self.sigma = [] + else: + self.sigma = sigma + self.sigma_nsprefix_ = None + if tau is None: + self.tau = [] + else: + self.tau = tau + self.tau_nsprefix_ = None + if upsilon is None: + self.upsilon = [] + else: + self.upsilon = upsilon + self.upsilon_nsprefix_ = None + if phi is None: + self.phi = [] + else: + self.phi = phi + self.phi_nsprefix_ = None + if chi is None: + self.chi = [] + else: + self.chi = chi + self.chi_nsprefix_ = None + if psi is None: + self.psi = [] + else: + self.psi = psi + self.psi_nsprefix_ = None + if omega is None: + self.omega = [] + else: + self.omega = omega + self.omega_nsprefix_ = None + if sigmaf is None: + self.sigmaf = [] + else: + self.sigmaf = sigmaf + self.sigmaf_nsprefix_ = None + if sect is None: + self.sect = [] + else: + self.sect = sect + self.sect_nsprefix_ = None + if deg is None: + self.deg = [] + else: + self.deg = deg + self.deg_nsprefix_ = None + if prime is None: + self.prime = [] + else: + self.prime = prime + self.prime_nsprefix_ = None + if Prime is None: + self.Prime = [] + else: + self.Prime = Prime + self.Prime_nsprefix_ = None + if infin is None: + self.infin = [] + else: + self.infin = infin + self.infin_nsprefix_ = None + if empty is None: + self.empty = [] + else: + self.empty = empty + self.empty_nsprefix_ = None + if plusmn is None: + self.plusmn = [] + else: + self.plusmn = plusmn + self.plusmn_nsprefix_ = None + if times is None: + self.times = [] + else: + self.times = times + self.times_nsprefix_ = None + if minus is None: + self.minus = [] + else: + self.minus = minus + self.minus_nsprefix_ = None + if sdot is None: + self.sdot = [] + else: + self.sdot = sdot + self.sdot_nsprefix_ = None + if part is None: + self.part = [] + else: + self.part = part + self.part_nsprefix_ = None + if nabla is None: + self.nabla = [] + else: + self.nabla = nabla + self.nabla_nsprefix_ = None + if radic is None: + self.radic = [] + else: + self.radic = radic + self.radic_nsprefix_ = None + if perp is None: + self.perp = [] + else: + self.perp = perp + self.perp_nsprefix_ = None + if sum is None: + self.sum = [] + else: + self.sum = sum + self.sum_nsprefix_ = None + if int is None: + self.int = [] + else: + self.int = int + self.int_nsprefix_ = None + if prod is None: + self.prod = [] + else: + self.prod = prod + self.prod_nsprefix_ = None + if sim is None: + self.sim = [] + else: + self.sim = sim + self.sim_nsprefix_ = None + if asymp is None: + self.asymp = [] + else: + self.asymp = asymp + self.asymp_nsprefix_ = None + if ne is None: + self.ne = [] + else: + self.ne = ne + self.ne_nsprefix_ = None + if equiv is None: + self.equiv = [] + else: + self.equiv = equiv + self.equiv_nsprefix_ = None + if prop is None: + self.prop = [] + else: + self.prop = prop + self.prop_nsprefix_ = None + if le is None: + self.le = [] + else: + self.le = le + self.le_nsprefix_ = None + if ge is None: + self.ge = [] + else: + self.ge = ge + self.ge_nsprefix_ = None + if larr is None: + self.larr = [] + else: + self.larr = larr + self.larr_nsprefix_ = None + if rarr is None: + self.rarr = [] + else: + self.rarr = rarr + self.rarr_nsprefix_ = None + if isin is None: + self.isin = [] + else: + self.isin = isin + self.isin_nsprefix_ = None + if notin is None: + self.notin = [] + else: + self.notin = notin + self.notin_nsprefix_ = None + if lceil is None: + self.lceil = [] + else: + self.lceil = lceil + self.lceil_nsprefix_ = None + if rceil is None: + self.rceil = [] + else: + self.rceil = rceil + self.rceil_nsprefix_ = None + if lfloor is None: + self.lfloor = [] + else: + self.lfloor = lfloor + self.lfloor_nsprefix_ = None + if rfloor is None: + self.rfloor = [] + else: + self.rfloor = rfloor + self.rfloor_nsprefix_ = None + self.valueOf_ = valueOf_ + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + self.valueOf_ = valueOf_ + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docFileType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docFileType.subclass: + return docFileType.subclass(*args_, **kwargs_) + return docFileType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + def get_ulink(self): + return self.ulink + def set_ulink(self, ulink): + self.ulink = ulink + def add_ulink(self, value): + self.ulink.append(value) + def insert_ulink_at(self, index, value): + self.ulink.insert(index, value) + def replace_ulink_at(self, index, value): + self.ulink[index] = value + def get_bold(self): + return self.bold + def set_bold(self, bold): + self.bold = bold + def add_bold(self, value): + self.bold.append(value) + def insert_bold_at(self, index, value): + self.bold.insert(index, value) + def replace_bold_at(self, index, value): + self.bold[index] = value + def get_emphasis(self): + return self.emphasis + def set_emphasis(self, emphasis): + self.emphasis = emphasis + def add_emphasis(self, value): + self.emphasis.append(value) + def insert_emphasis_at(self, index, value): + self.emphasis.insert(index, value) + def replace_emphasis_at(self, index, value): + self.emphasis[index] = value + def get_computeroutput(self): + return self.computeroutput + def set_computeroutput(self, computeroutput): + self.computeroutput = computeroutput + def add_computeroutput(self, value): + self.computeroutput.append(value) + def insert_computeroutput_at(self, index, value): + self.computeroutput.insert(index, value) + def replace_computeroutput_at(self, index, value): + self.computeroutput[index] = value + def get_subscript(self): + return self.subscript + def set_subscript(self, subscript): + self.subscript = subscript + def add_subscript(self, value): + self.subscript.append(value) + def insert_subscript_at(self, index, value): + self.subscript.insert(index, value) + def replace_subscript_at(self, index, value): + self.subscript[index] = value + def get_superscript(self): + return self.superscript + def set_superscript(self, superscript): + self.superscript = superscript + def add_superscript(self, value): + self.superscript.append(value) + def insert_superscript_at(self, index, value): + self.superscript.insert(index, value) + def replace_superscript_at(self, index, value): + self.superscript[index] = value + def get_center(self): + return self.center + def set_center(self, center): + self.center = center + def add_center(self, value): + self.center.append(value) + def insert_center_at(self, index, value): + self.center.insert(index, value) + def replace_center_at(self, index, value): + self.center[index] = value + def get_small(self): + return self.small + def set_small(self, small): + self.small = small + def add_small(self, value): + self.small.append(value) + def insert_small_at(self, index, value): + self.small.insert(index, value) + def replace_small_at(self, index, value): + self.small[index] = value + def get_htmlonly(self): + return self.htmlonly + def set_htmlonly(self, htmlonly): + self.htmlonly = htmlonly + def add_htmlonly(self, value): + self.htmlonly.append(value) + def insert_htmlonly_at(self, index, value): + self.htmlonly.insert(index, value) + def replace_htmlonly_at(self, index, value): + self.htmlonly[index] = value + def get_manonly(self): + return self.manonly + def set_manonly(self, manonly): + self.manonly = manonly + def add_manonly(self, value): + self.manonly.append(value) + def insert_manonly_at(self, index, value): + self.manonly.insert(index, value) + def replace_manonly_at(self, index, value): + self.manonly[index] = value + def get_xmlonly(self): + return self.xmlonly + def set_xmlonly(self, xmlonly): + self.xmlonly = xmlonly + def add_xmlonly(self, value): + self.xmlonly.append(value) + def insert_xmlonly_at(self, index, value): + self.xmlonly.insert(index, value) + def replace_xmlonly_at(self, index, value): + self.xmlonly[index] = value + def get_rtfonly(self): + return self.rtfonly + def set_rtfonly(self, rtfonly): + self.rtfonly = rtfonly + def add_rtfonly(self, value): + self.rtfonly.append(value) + def insert_rtfonly_at(self, index, value): + self.rtfonly.insert(index, value) + def replace_rtfonly_at(self, index, value): + self.rtfonly[index] = value + def get_latexonly(self): + return self.latexonly + def set_latexonly(self, latexonly): + self.latexonly = latexonly + def add_latexonly(self, value): + self.latexonly.append(value) + def insert_latexonly_at(self, index, value): + self.latexonly.insert(index, value) + def replace_latexonly_at(self, index, value): + self.latexonly[index] = value + def get_dot(self): + return self.dot + def set_dot(self, dot): + self.dot = dot + def add_dot(self, value): + self.dot.append(value) + def insert_dot_at(self, index, value): + self.dot.insert(index, value) + def replace_dot_at(self, index, value): + self.dot[index] = value + def get_msc(self): + return self.msc + def set_msc(self, msc): + self.msc = msc + def add_msc(self, value): + self.msc.append(value) + def insert_msc_at(self, index, value): + self.msc.insert(index, value) + def replace_msc_at(self, index, value): + self.msc[index] = value + def get_anchor(self): + return self.anchor + def set_anchor(self, anchor): + self.anchor = anchor + def add_anchor(self, value): + self.anchor.append(value) + def insert_anchor_at(self, index, value): + self.anchor.insert(index, value) + def replace_anchor_at(self, index, value): + self.anchor[index] = value + def get_formula(self): + return self.formula + def set_formula(self, formula): + self.formula = formula + def add_formula(self, value): + self.formula.append(value) + def insert_formula_at(self, index, value): + self.formula.insert(index, value) + def replace_formula_at(self, index, value): + self.formula[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_at(self, index, value): + self.ref.insert(index, value) + def replace_ref_at(self, index, value): + self.ref[index] = value + def get_copy(self): + return self.copy + def set_copy(self, copy): + self.copy = copy + def add_copy(self, value): + self.copy.append(value) + def insert_copy_at(self, index, value): + self.copy.insert(index, value) + def replace_copy_at(self, index, value): + self.copy[index] = value + def get_trademark(self): + return self.trademark + def set_trademark(self, trademark): + self.trademark = trademark + def add_trademark(self, value): + self.trademark.append(value) + def insert_trademark_at(self, index, value): + self.trademark.insert(index, value) + def replace_trademark_at(self, index, value): + self.trademark[index] = value + def get_registered(self): + return self.registered + def set_registered(self, registered): + self.registered = registered + def add_registered(self, value): + self.registered.append(value) + def insert_registered_at(self, index, value): + self.registered.insert(index, value) + def replace_registered_at(self, index, value): + self.registered[index] = value + def get_lsquo(self): + return self.lsquo + def set_lsquo(self, lsquo): + self.lsquo = lsquo + def add_lsquo(self, value): + self.lsquo.append(value) + def insert_lsquo_at(self, index, value): + self.lsquo.insert(index, value) + def replace_lsquo_at(self, index, value): + self.lsquo[index] = value + def get_rsquo(self): + return self.rsquo + def set_rsquo(self, rsquo): + self.rsquo = rsquo + def add_rsquo(self, value): + self.rsquo.append(value) + def insert_rsquo_at(self, index, value): + self.rsquo.insert(index, value) + def replace_rsquo_at(self, index, value): + self.rsquo[index] = value + def get_ldquo(self): + return self.ldquo + def set_ldquo(self, ldquo): + self.ldquo = ldquo + def add_ldquo(self, value): + self.ldquo.append(value) + def insert_ldquo_at(self, index, value): + self.ldquo.insert(index, value) + def replace_ldquo_at(self, index, value): + self.ldquo[index] = value + def get_rdquo(self): + return self.rdquo + def set_rdquo(self, rdquo): + self.rdquo = rdquo + def add_rdquo(self, value): + self.rdquo.append(value) + def insert_rdquo_at(self, index, value): + self.rdquo.insert(index, value) + def replace_rdquo_at(self, index, value): + self.rdquo[index] = value + def get_ndash(self): + return self.ndash + def set_ndash(self, ndash): + self.ndash = ndash + def add_ndash(self, value): + self.ndash.append(value) + def insert_ndash_at(self, index, value): + self.ndash.insert(index, value) + def replace_ndash_at(self, index, value): + self.ndash[index] = value + def get_mdash(self): + return self.mdash + def set_mdash(self, mdash): + self.mdash = mdash + def add_mdash(self, value): + self.mdash.append(value) + def insert_mdash_at(self, index, value): + self.mdash.insert(index, value) + def replace_mdash_at(self, index, value): + self.mdash[index] = value + def get_umlaut(self): + return self.umlaut + def set_umlaut(self, umlaut): + self.umlaut = umlaut + def add_umlaut(self, value): + self.umlaut.append(value) + def insert_umlaut_at(self, index, value): + self.umlaut.insert(index, value) + def replace_umlaut_at(self, index, value): + self.umlaut[index] = value + def get_acute(self): + return self.acute + def set_acute(self, acute): + self.acute = acute + def add_acute(self, value): + self.acute.append(value) + def insert_acute_at(self, index, value): + self.acute.insert(index, value) + def replace_acute_at(self, index, value): + self.acute[index] = value + def get_grave(self): + return self.grave + def set_grave(self, grave): + self.grave = grave + def add_grave(self, value): + self.grave.append(value) + def insert_grave_at(self, index, value): + self.grave.insert(index, value) + def replace_grave_at(self, index, value): + self.grave[index] = value + def get_circ(self): + return self.circ + def set_circ(self, circ): + self.circ = circ + def add_circ(self, value): + self.circ.append(value) + def insert_circ_at(self, index, value): + self.circ.insert(index, value) + def replace_circ_at(self, index, value): + self.circ[index] = value + def get_slash(self): + return self.slash + def set_slash(self, slash): + self.slash = slash + def add_slash(self, value): + self.slash.append(value) + def insert_slash_at(self, index, value): + self.slash.insert(index, value) + def replace_slash_at(self, index, value): + self.slash[index] = value + def get_tilde(self): + return self.tilde + def set_tilde(self, tilde): + self.tilde = tilde + def add_tilde(self, value): + self.tilde.append(value) + def insert_tilde_at(self, index, value): + self.tilde.insert(index, value) + def replace_tilde_at(self, index, value): + self.tilde[index] = value + def get_cedil(self): + return self.cedil + def set_cedil(self, cedil): + self.cedil = cedil + def add_cedil(self, value): + self.cedil.append(value) + def insert_cedil_at(self, index, value): + self.cedil.insert(index, value) + def replace_cedil_at(self, index, value): + self.cedil[index] = value + def get_ring(self): + return self.ring + def set_ring(self, ring): + self.ring = ring + def add_ring(self, value): + self.ring.append(value) + def insert_ring_at(self, index, value): + self.ring.insert(index, value) + def replace_ring_at(self, index, value): + self.ring[index] = value + def get_szlig(self): + return self.szlig + def set_szlig(self, szlig): + self.szlig = szlig + def add_szlig(self, value): + self.szlig.append(value) + def insert_szlig_at(self, index, value): + self.szlig.insert(index, value) + def replace_szlig_at(self, index, value): + self.szlig[index] = value + def get_nonbreakablespace(self): + return self.nonbreakablespace + def set_nonbreakablespace(self, nonbreakablespace): + self.nonbreakablespace = nonbreakablespace + def add_nonbreakablespace(self, value): + self.nonbreakablespace.append(value) + def insert_nonbreakablespace_at(self, index, value): + self.nonbreakablespace.insert(index, value) + def replace_nonbreakablespace_at(self, index, value): + self.nonbreakablespace[index] = value + def get_aelig(self): + return self.aelig + def set_aelig(self, aelig): + self.aelig = aelig + def add_aelig(self, value): + self.aelig.append(value) + def insert_aelig_at(self, index, value): + self.aelig.insert(index, value) + def replace_aelig_at(self, index, value): + self.aelig[index] = value + def get_AElig(self): + return self.AElig + def set_AElig(self, AElig): + self.AElig = AElig + def add_AElig(self, value): + self.AElig.append(value) + def insert_AElig_at(self, index, value): + self.AElig.insert(index, value) + def replace_AElig_at(self, index, value): + self.AElig[index] = value + def get_Gamma(self): + return self.Gamma + def set_Gamma(self, Gamma): + self.Gamma = Gamma + def add_Gamma(self, value): + self.Gamma.append(value) + def insert_Gamma_at(self, index, value): + self.Gamma.insert(index, value) + def replace_Gamma_at(self, index, value): + self.Gamma[index] = value + def get_Delta(self): + return self.Delta + def set_Delta(self, Delta): + self.Delta = Delta + def add_Delta(self, value): + self.Delta.append(value) + def insert_Delta_at(self, index, value): + self.Delta.insert(index, value) + def replace_Delta_at(self, index, value): + self.Delta[index] = value + def get_Theta(self): + return self.Theta + def set_Theta(self, Theta): + self.Theta = Theta + def add_Theta(self, value): + self.Theta.append(value) + def insert_Theta_at(self, index, value): + self.Theta.insert(index, value) + def replace_Theta_at(self, index, value): + self.Theta[index] = value + def get_Lambda(self): + return self.Lambda + def set_Lambda(self, Lambda): + self.Lambda = Lambda + def add_Lambda(self, value): + self.Lambda.append(value) + def insert_Lambda_at(self, index, value): + self.Lambda.insert(index, value) + def replace_Lambda_at(self, index, value): + self.Lambda[index] = value + def get_Xi(self): + return self.Xi + def set_Xi(self, Xi): + self.Xi = Xi + def add_Xi(self, value): + self.Xi.append(value) + def insert_Xi_at(self, index, value): + self.Xi.insert(index, value) + def replace_Xi_at(self, index, value): + self.Xi[index] = value + def get_Pi(self): + return self.Pi + def set_Pi(self, Pi): + self.Pi = Pi + def add_Pi(self, value): + self.Pi.append(value) + def insert_Pi_at(self, index, value): + self.Pi.insert(index, value) + def replace_Pi_at(self, index, value): + self.Pi[index] = value + def get_Sigma(self): + return self.Sigma + def set_Sigma(self, Sigma): + self.Sigma = Sigma + def add_Sigma(self, value): + self.Sigma.append(value) + def insert_Sigma_at(self, index, value): + self.Sigma.insert(index, value) + def replace_Sigma_at(self, index, value): + self.Sigma[index] = value + def get_Upsilon(self): + return self.Upsilon + def set_Upsilon(self, Upsilon): + self.Upsilon = Upsilon + def add_Upsilon(self, value): + self.Upsilon.append(value) + def insert_Upsilon_at(self, index, value): + self.Upsilon.insert(index, value) + def replace_Upsilon_at(self, index, value): + self.Upsilon[index] = value + def get_Phi(self): + return self.Phi + def set_Phi(self, Phi): + self.Phi = Phi + def add_Phi(self, value): + self.Phi.append(value) + def insert_Phi_at(self, index, value): + self.Phi.insert(index, value) + def replace_Phi_at(self, index, value): + self.Phi[index] = value + def get_Psi(self): + return self.Psi + def set_Psi(self, Psi): + self.Psi = Psi + def add_Psi(self, value): + self.Psi.append(value) + def insert_Psi_at(self, index, value): + self.Psi.insert(index, value) + def replace_Psi_at(self, index, value): + self.Psi[index] = value + def get_Omega(self): + return self.Omega + def set_Omega(self, Omega): + self.Omega = Omega + def add_Omega(self, value): + self.Omega.append(value) + def insert_Omega_at(self, index, value): + self.Omega.insert(index, value) + def replace_Omega_at(self, index, value): + self.Omega[index] = value + def get_alpha(self): + return self.alpha + def set_alpha(self, alpha): + self.alpha = alpha + def add_alpha(self, value): + self.alpha.append(value) + def insert_alpha_at(self, index, value): + self.alpha.insert(index, value) + def replace_alpha_at(self, index, value): + self.alpha[index] = value + def get_beta(self): + return self.beta + def set_beta(self, beta): + self.beta = beta + def add_beta(self, value): + self.beta.append(value) + def insert_beta_at(self, index, value): + self.beta.insert(index, value) + def replace_beta_at(self, index, value): + self.beta[index] = value + def get_gamma(self): + return self.gamma + def set_gamma(self, gamma): + self.gamma = gamma + def add_gamma(self, value): + self.gamma.append(value) + def insert_gamma_at(self, index, value): + self.gamma.insert(index, value) + def replace_gamma_at(self, index, value): + self.gamma[index] = value + def get_delta(self): + return self.delta + def set_delta(self, delta): + self.delta = delta + def add_delta(self, value): + self.delta.append(value) + def insert_delta_at(self, index, value): + self.delta.insert(index, value) + def replace_delta_at(self, index, value): + self.delta[index] = value + def get_epsilon(self): + return self.epsilon + def set_epsilon(self, epsilon): + self.epsilon = epsilon + def add_epsilon(self, value): + self.epsilon.append(value) + def insert_epsilon_at(self, index, value): + self.epsilon.insert(index, value) + def replace_epsilon_at(self, index, value): + self.epsilon[index] = value + def get_zeta(self): + return self.zeta + def set_zeta(self, zeta): + self.zeta = zeta + def add_zeta(self, value): + self.zeta.append(value) + def insert_zeta_at(self, index, value): + self.zeta.insert(index, value) + def replace_zeta_at(self, index, value): + self.zeta[index] = value + def get_eta(self): + return self.eta + def set_eta(self, eta): + self.eta = eta + def add_eta(self, value): + self.eta.append(value) + def insert_eta_at(self, index, value): + self.eta.insert(index, value) + def replace_eta_at(self, index, value): + self.eta[index] = value + def get_theta(self): + return self.theta + def set_theta(self, theta): + self.theta = theta + def add_theta(self, value): + self.theta.append(value) + def insert_theta_at(self, index, value): + self.theta.insert(index, value) + def replace_theta_at(self, index, value): + self.theta[index] = value + def get_iota(self): + return self.iota + def set_iota(self, iota): + self.iota = iota + def add_iota(self, value): + self.iota.append(value) + def insert_iota_at(self, index, value): + self.iota.insert(index, value) + def replace_iota_at(self, index, value): + self.iota[index] = value + def get_kappa(self): + return self.kappa + def set_kappa(self, kappa): + self.kappa = kappa + def add_kappa(self, value): + self.kappa.append(value) + def insert_kappa_at(self, index, value): + self.kappa.insert(index, value) + def replace_kappa_at(self, index, value): + self.kappa[index] = value + def get_lambda(self): + return self.lambda_ + def set_lambda(self, lambda_): + self.lambda_ = lambda_ + def add_lambda(self, value): + self.lambda_.append(value) + def insert_lambda_at(self, index, value): + self.lambda_.insert(index, value) + def replace_lambda_at(self, index, value): + self.lambda_[index] = value + def get_mu(self): + return self.mu + def set_mu(self, mu): + self.mu = mu + def add_mu(self, value): + self.mu.append(value) + def insert_mu_at(self, index, value): + self.mu.insert(index, value) + def replace_mu_at(self, index, value): + self.mu[index] = value + def get_nu(self): + return self.nu + def set_nu(self, nu): + self.nu = nu + def add_nu(self, value): + self.nu.append(value) + def insert_nu_at(self, index, value): + self.nu.insert(index, value) + def replace_nu_at(self, index, value): + self.nu[index] = value + def get_xi(self): + return self.xi + def set_xi(self, xi): + self.xi = xi + def add_xi(self, value): + self.xi.append(value) + def insert_xi_at(self, index, value): + self.xi.insert(index, value) + def replace_xi_at(self, index, value): + self.xi[index] = value + def get_pi(self): + return self.pi + def set_pi(self, pi): + self.pi = pi + def add_pi(self, value): + self.pi.append(value) + def insert_pi_at(self, index, value): + self.pi.insert(index, value) + def replace_pi_at(self, index, value): + self.pi[index] = value + def get_rho(self): + return self.rho + def set_rho(self, rho): + self.rho = rho + def add_rho(self, value): + self.rho.append(value) + def insert_rho_at(self, index, value): + self.rho.insert(index, value) + def replace_rho_at(self, index, value): + self.rho[index] = value + def get_sigma(self): + return self.sigma + def set_sigma(self, sigma): + self.sigma = sigma + def add_sigma(self, value): + self.sigma.append(value) + def insert_sigma_at(self, index, value): + self.sigma.insert(index, value) + def replace_sigma_at(self, index, value): + self.sigma[index] = value + def get_tau(self): + return self.tau + def set_tau(self, tau): + self.tau = tau + def add_tau(self, value): + self.tau.append(value) + def insert_tau_at(self, index, value): + self.tau.insert(index, value) + def replace_tau_at(self, index, value): + self.tau[index] = value + def get_upsilon(self): + return self.upsilon + def set_upsilon(self, upsilon): + self.upsilon = upsilon + def add_upsilon(self, value): + self.upsilon.append(value) + def insert_upsilon_at(self, index, value): + self.upsilon.insert(index, value) + def replace_upsilon_at(self, index, value): + self.upsilon[index] = value + def get_phi(self): + return self.phi + def set_phi(self, phi): + self.phi = phi + def add_phi(self, value): + self.phi.append(value) + def insert_phi_at(self, index, value): + self.phi.insert(index, value) + def replace_phi_at(self, index, value): + self.phi[index] = value + def get_chi(self): + return self.chi + def set_chi(self, chi): + self.chi = chi + def add_chi(self, value): + self.chi.append(value) + def insert_chi_at(self, index, value): + self.chi.insert(index, value) + def replace_chi_at(self, index, value): + self.chi[index] = value + def get_psi(self): + return self.psi + def set_psi(self, psi): + self.psi = psi + def add_psi(self, value): + self.psi.append(value) + def insert_psi_at(self, index, value): + self.psi.insert(index, value) + def replace_psi_at(self, index, value): + self.psi[index] = value + def get_omega(self): + return self.omega + def set_omega(self, omega): + self.omega = omega + def add_omega(self, value): + self.omega.append(value) + def insert_omega_at(self, index, value): + self.omega.insert(index, value) + def replace_omega_at(self, index, value): + self.omega[index] = value + def get_sigmaf(self): + return self.sigmaf + def set_sigmaf(self, sigmaf): + self.sigmaf = sigmaf + def add_sigmaf(self, value): + self.sigmaf.append(value) + def insert_sigmaf_at(self, index, value): + self.sigmaf.insert(index, value) + def replace_sigmaf_at(self, index, value): + self.sigmaf[index] = value + def get_sect(self): + return self.sect + def set_sect(self, sect): + self.sect = sect + def add_sect(self, value): + self.sect.append(value) + def insert_sect_at(self, index, value): + self.sect.insert(index, value) + def replace_sect_at(self, index, value): + self.sect[index] = value + def get_deg(self): + return self.deg + def set_deg(self, deg): + self.deg = deg + def add_deg(self, value): + self.deg.append(value) + def insert_deg_at(self, index, value): + self.deg.insert(index, value) + def replace_deg_at(self, index, value): + self.deg[index] = value + def get_prime(self): + return self.prime + def set_prime(self, prime): + self.prime = prime + def add_prime(self, value): + self.prime.append(value) + def insert_prime_at(self, index, value): + self.prime.insert(index, value) + def replace_prime_at(self, index, value): + self.prime[index] = value + def get_Prime(self): + return self.Prime + def set_Prime(self, Prime): + self.Prime = Prime + def add_Prime(self, value): + self.Prime.append(value) + def insert_Prime_at(self, index, value): + self.Prime.insert(index, value) + def replace_Prime_at(self, index, value): + self.Prime[index] = value + def get_infin(self): + return self.infin + def set_infin(self, infin): + self.infin = infin + def add_infin(self, value): + self.infin.append(value) + def insert_infin_at(self, index, value): + self.infin.insert(index, value) + def replace_infin_at(self, index, value): + self.infin[index] = value + def get_empty(self): + return self.empty + def set_empty(self, empty): + self.empty = empty + def add_empty(self, value): + self.empty.append(value) + def insert_empty_at(self, index, value): + self.empty.insert(index, value) + def replace_empty_at(self, index, value): + self.empty[index] = value + def get_plusmn(self): + return self.plusmn + def set_plusmn(self, plusmn): + self.plusmn = plusmn + def add_plusmn(self, value): + self.plusmn.append(value) + def insert_plusmn_at(self, index, value): + self.plusmn.insert(index, value) + def replace_plusmn_at(self, index, value): + self.plusmn[index] = value + def get_times(self): + return self.times + def set_times(self, times): + self.times = times + def add_times(self, value): + self.times.append(value) + def insert_times_at(self, index, value): + self.times.insert(index, value) + def replace_times_at(self, index, value): + self.times[index] = value + def get_minus(self): + return self.minus + def set_minus(self, minus): + self.minus = minus + def add_minus(self, value): + self.minus.append(value) + def insert_minus_at(self, index, value): + self.minus.insert(index, value) + def replace_minus_at(self, index, value): + self.minus[index] = value + def get_sdot(self): + return self.sdot + def set_sdot(self, sdot): + self.sdot = sdot + def add_sdot(self, value): + self.sdot.append(value) + def insert_sdot_at(self, index, value): + self.sdot.insert(index, value) + def replace_sdot_at(self, index, value): + self.sdot[index] = value + def get_part(self): + return self.part + def set_part(self, part): + self.part = part + def add_part(self, value): + self.part.append(value) + def insert_part_at(self, index, value): + self.part.insert(index, value) + def replace_part_at(self, index, value): + self.part[index] = value + def get_nabla(self): + return self.nabla + def set_nabla(self, nabla): + self.nabla = nabla + def add_nabla(self, value): + self.nabla.append(value) + def insert_nabla_at(self, index, value): + self.nabla.insert(index, value) + def replace_nabla_at(self, index, value): + self.nabla[index] = value + def get_radic(self): + return self.radic + def set_radic(self, radic): + self.radic = radic + def add_radic(self, value): + self.radic.append(value) + def insert_radic_at(self, index, value): + self.radic.insert(index, value) + def replace_radic_at(self, index, value): + self.radic[index] = value + def get_perp(self): + return self.perp + def set_perp(self, perp): + self.perp = perp + def add_perp(self, value): + self.perp.append(value) + def insert_perp_at(self, index, value): + self.perp.insert(index, value) + def replace_perp_at(self, index, value): + self.perp[index] = value + def get_sum(self): + return self.sum + def set_sum(self, sum): + self.sum = sum + def add_sum(self, value): + self.sum.append(value) + def insert_sum_at(self, index, value): + self.sum.insert(index, value) + def replace_sum_at(self, index, value): + self.sum[index] = value + def get_int(self): + return self.int + def set_int(self, int): + self.int = int + def add_int(self, value): + self.int.append(value) + def insert_int_at(self, index, value): + self.int.insert(index, value) + def replace_int_at(self, index, value): + self.int[index] = value + def get_prod(self): + return self.prod + def set_prod(self, prod): + self.prod = prod + def add_prod(self, value): + self.prod.append(value) + def insert_prod_at(self, index, value): + self.prod.insert(index, value) + def replace_prod_at(self, index, value): + self.prod[index] = value + def get_sim(self): + return self.sim + def set_sim(self, sim): + self.sim = sim + def add_sim(self, value): + self.sim.append(value) + def insert_sim_at(self, index, value): + self.sim.insert(index, value) + def replace_sim_at(self, index, value): + self.sim[index] = value + def get_asymp(self): + return self.asymp + def set_asymp(self, asymp): + self.asymp = asymp + def add_asymp(self, value): + self.asymp.append(value) + def insert_asymp_at(self, index, value): + self.asymp.insert(index, value) + def replace_asymp_at(self, index, value): + self.asymp[index] = value + def get_ne(self): + return self.ne + def set_ne(self, ne): + self.ne = ne + def add_ne(self, value): + self.ne.append(value) + def insert_ne_at(self, index, value): + self.ne.insert(index, value) + def replace_ne_at(self, index, value): + self.ne[index] = value + def get_equiv(self): + return self.equiv + def set_equiv(self, equiv): + self.equiv = equiv + def add_equiv(self, value): + self.equiv.append(value) + def insert_equiv_at(self, index, value): + self.equiv.insert(index, value) + def replace_equiv_at(self, index, value): + self.equiv[index] = value + def get_prop(self): + return self.prop + def set_prop(self, prop): + self.prop = prop + def add_prop(self, value): + self.prop.append(value) + def insert_prop_at(self, index, value): + self.prop.insert(index, value) + def replace_prop_at(self, index, value): + self.prop[index] = value + def get_le(self): + return self.le + def set_le(self, le): + self.le = le + def add_le(self, value): + self.le.append(value) + def insert_le_at(self, index, value): + self.le.insert(index, value) + def replace_le_at(self, index, value): + self.le[index] = value + def get_ge(self): + return self.ge + def set_ge(self, ge): + self.ge = ge + def add_ge(self, value): + self.ge.append(value) + def insert_ge_at(self, index, value): + self.ge.insert(index, value) + def replace_ge_at(self, index, value): + self.ge[index] = value + def get_larr(self): + return self.larr + def set_larr(self, larr): + self.larr = larr + def add_larr(self, value): + self.larr.append(value) + def insert_larr_at(self, index, value): + self.larr.insert(index, value) + def replace_larr_at(self, index, value): + self.larr[index] = value + def get_rarr(self): + return self.rarr + def set_rarr(self, rarr): + self.rarr = rarr + def add_rarr(self, value): + self.rarr.append(value) + def insert_rarr_at(self, index, value): + self.rarr.insert(index, value) + def replace_rarr_at(self, index, value): + self.rarr[index] = value + def get_isin(self): + return self.isin + def set_isin(self, isin): + self.isin = isin + def add_isin(self, value): + self.isin.append(value) + def insert_isin_at(self, index, value): + self.isin.insert(index, value) + def replace_isin_at(self, index, value): + self.isin[index] = value + def get_notin(self): + return self.notin + def set_notin(self, notin): + self.notin = notin + def add_notin(self, value): + self.notin.append(value) + def insert_notin_at(self, index, value): + self.notin.insert(index, value) + def replace_notin_at(self, index, value): + self.notin[index] = value + def get_lceil(self): + return self.lceil + def set_lceil(self, lceil): + self.lceil = lceil + def add_lceil(self, value): + self.lceil.append(value) + def insert_lceil_at(self, index, value): + self.lceil.insert(index, value) + def replace_lceil_at(self, index, value): + self.lceil[index] = value + def get_rceil(self): + return self.rceil + def set_rceil(self, rceil): + self.rceil = rceil + def add_rceil(self, value): + self.rceil.append(value) + def insert_rceil_at(self, index, value): + self.rceil.insert(index, value) + def replace_rceil_at(self, index, value): + self.rceil[index] = value + def get_lfloor(self): + return self.lfloor + def set_lfloor(self, lfloor): + self.lfloor = lfloor + def add_lfloor(self, value): + self.lfloor.append(value) + def insert_lfloor_at(self, index, value): + self.lfloor.insert(index, value) + def replace_lfloor_at(self, index, value): + self.lfloor[index] = value + def get_rfloor(self): + return self.rfloor + def set_rfloor(self, rfloor): + self.rfloor = rfloor + def add_rfloor(self, value): + self.rfloor.append(value) + def insert_rfloor_at(self, index, value): + self.rfloor.insert(index, value) + def replace_rfloor_at(self, index, value): + self.rfloor[index] = value + def get_name(self): + return self.name + def set_name(self, name): + self.name = name + def get_valueOf_(self): return self.valueOf_ + def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def hasContent_(self): + if ( + self.ulink or + self.bold or + self.emphasis or + self.computeroutput or + self.subscript or + self.superscript or + self.center or + self.small or + self.htmlonly or + self.manonly or + self.xmlonly or + self.rtfonly or + self.latexonly or + self.dot or + self.msc or + self.anchor or + self.formula or + self.ref or + self.copy or + self.trademark or + self.registered or + self.lsquo or + self.rsquo or + self.ldquo or + self.rdquo or + self.ndash or + self.mdash or + self.umlaut or + self.acute or + self.grave or + self.circ or + self.slash or + self.tilde or + self.cedil or + self.ring or + self.szlig or + self.nonbreakablespace or + self.aelig or + self.AElig or + self.Gamma or + self.Delta or + self.Theta or + self.Lambda or + self.Xi or + self.Pi or + self.Sigma or + self.Upsilon or + self.Phi or + self.Psi or + self.Omega or + self.alpha or + self.beta or + self.gamma or + self.delta or + self.epsilon or + self.zeta or + self.eta or + self.theta or + self.iota or + self.kappa or + self.lambda_ or + self.mu or + self.nu or + self.xi or + self.pi or + self.rho or + self.sigma or + self.tau or + self.upsilon or + self.phi or + self.chi or + self.psi or + self.omega or + self.sigmaf or + self.sect or + self.deg or + self.prime or + self.Prime or + self.infin or + self.empty or + self.plusmn or + self.times or + self.minus or + self.sdot or + self.part or + self.nabla or + self.radic or + self.perp or + self.sum or + self.int or + self.prod or + self.sim or + self.asymp or + self.ne or + self.equiv or + self.prop or + self.le or + self.ge or + self.larr or + self.rarr or + self.isin or + self.notin or + self.lceil or + self.rceil or + self.lfloor or + self.rfloor or + (1 if type(self.valueOf_) in [int,float] else self.valueOf_) or + self.content_ + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docFileType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docFileType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docFileType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docFileType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docFileType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docFileType'): + if self.name is not None and 'name' not in already_processed: + already_processed.add('name') + outfile.write(' name=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.name), input_name='name')), )) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docFileType', fromsubclass_=False, pretty_print=True): + if not fromsubclass_: + for item_ in self.content_: + item_.export(outfile, level, item_.name, namespaceprefix_, pretty_print=pretty_print) + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for ulink_ in self.ulink: + namespaceprefix_ = self.ulink_nsprefix_ + ':' if (UseCapturedNS_ and self.ulink_nsprefix_) else '' + ulink_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ulink', pretty_print=pretty_print) + for bold_ in self.bold: + namespaceprefix_ = self.bold_nsprefix_ + ':' if (UseCapturedNS_ and self.bold_nsprefix_) else '' + bold_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='bold', pretty_print=pretty_print) + for emphasis_ in self.emphasis: + namespaceprefix_ = self.emphasis_nsprefix_ + ':' if (UseCapturedNS_ and self.emphasis_nsprefix_) else '' + emphasis_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='emphasis', pretty_print=pretty_print) + for computeroutput_ in self.computeroutput: + namespaceprefix_ = self.computeroutput_nsprefix_ + ':' if (UseCapturedNS_ and self.computeroutput_nsprefix_) else '' + computeroutput_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='computeroutput', pretty_print=pretty_print) + for subscript_ in self.subscript: + namespaceprefix_ = self.subscript_nsprefix_ + ':' if (UseCapturedNS_ and self.subscript_nsprefix_) else '' + subscript_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='subscript', pretty_print=pretty_print) + for superscript_ in self.superscript: + namespaceprefix_ = self.superscript_nsprefix_ + ':' if (UseCapturedNS_ and self.superscript_nsprefix_) else '' + superscript_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='superscript', pretty_print=pretty_print) + for center_ in self.center: + namespaceprefix_ = self.center_nsprefix_ + ':' if (UseCapturedNS_ and self.center_nsprefix_) else '' + center_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='center', pretty_print=pretty_print) + for small_ in self.small: + namespaceprefix_ = self.small_nsprefix_ + ':' if (UseCapturedNS_ and self.small_nsprefix_) else '' + small_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='small', pretty_print=pretty_print) + for htmlonly_ in self.htmlonly: + namespaceprefix_ = self.htmlonly_nsprefix_ + ':' if (UseCapturedNS_ and self.htmlonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%shtmlonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(htmlonly_), input_name='htmlonly')), namespaceprefix_ , eol_)) + for manonly_ in self.manonly: + namespaceprefix_ = self.manonly_nsprefix_ + ':' if (UseCapturedNS_ and self.manonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%smanonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(manonly_), input_name='manonly')), namespaceprefix_ , eol_)) + for xmlonly_ in self.xmlonly: + namespaceprefix_ = self.xmlonly_nsprefix_ + ':' if (UseCapturedNS_ and self.xmlonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%sxmlonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(xmlonly_), input_name='xmlonly')), namespaceprefix_ , eol_)) + for rtfonly_ in self.rtfonly: + namespaceprefix_ = self.rtfonly_nsprefix_ + ':' if (UseCapturedNS_ and self.rtfonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%srtfonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(rtfonly_), input_name='rtfonly')), namespaceprefix_ , eol_)) + for latexonly_ in self.latexonly: + namespaceprefix_ = self.latexonly_nsprefix_ + ':' if (UseCapturedNS_ and self.latexonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%slatexonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(latexonly_), input_name='latexonly')), namespaceprefix_ , eol_)) + for dot_ in self.dot: + namespaceprefix_ = self.dot_nsprefix_ + ':' if (UseCapturedNS_ and self.dot_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%sdot>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(dot_), input_name='dot')), namespaceprefix_ , eol_)) + for msc_ in self.msc: + namespaceprefix_ = self.msc_nsprefix_ + ':' if (UseCapturedNS_ and self.msc_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%smsc>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(msc_), input_name='msc')), namespaceprefix_ , eol_)) + for anchor_ in self.anchor: + namespaceprefix_ = self.anchor_nsprefix_ + ':' if (UseCapturedNS_ and self.anchor_nsprefix_) else '' + anchor_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='anchor', pretty_print=pretty_print) + for formula_ in self.formula: + namespaceprefix_ = self.formula_nsprefix_ + ':' if (UseCapturedNS_ and self.formula_nsprefix_) else '' + formula_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='formula', pretty_print=pretty_print) + for ref_ in self.ref: + namespaceprefix_ = self.ref_nsprefix_ + ':' if (UseCapturedNS_ and self.ref_nsprefix_) else '' + ref_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ref', pretty_print=pretty_print) + for copy_ in self.copy: + namespaceprefix_ = self.copy_nsprefix_ + ':' if (UseCapturedNS_ and self.copy_nsprefix_) else '' + copy_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='copy', pretty_print=pretty_print) + for trademark_ in self.trademark: + namespaceprefix_ = self.trademark_nsprefix_ + ':' if (UseCapturedNS_ and self.trademark_nsprefix_) else '' + trademark_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='trademark', pretty_print=pretty_print) + for registered_ in self.registered: + namespaceprefix_ = self.registered_nsprefix_ + ':' if (UseCapturedNS_ and self.registered_nsprefix_) else '' + registered_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='registered', pretty_print=pretty_print) + for lsquo_ in self.lsquo: + namespaceprefix_ = self.lsquo_nsprefix_ + ':' if (UseCapturedNS_ and self.lsquo_nsprefix_) else '' + lsquo_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='lsquo', pretty_print=pretty_print) + for rsquo_ in self.rsquo: + namespaceprefix_ = self.rsquo_nsprefix_ + ':' if (UseCapturedNS_ and self.rsquo_nsprefix_) else '' + rsquo_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rsquo', pretty_print=pretty_print) + for ldquo_ in self.ldquo: + namespaceprefix_ = self.ldquo_nsprefix_ + ':' if (UseCapturedNS_ and self.ldquo_nsprefix_) else '' + ldquo_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ldquo', pretty_print=pretty_print) + for rdquo_ in self.rdquo: + namespaceprefix_ = self.rdquo_nsprefix_ + ':' if (UseCapturedNS_ and self.rdquo_nsprefix_) else '' + rdquo_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rdquo', pretty_print=pretty_print) + for ndash_ in self.ndash: + namespaceprefix_ = self.ndash_nsprefix_ + ':' if (UseCapturedNS_ and self.ndash_nsprefix_) else '' + ndash_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ndash', pretty_print=pretty_print) + for mdash_ in self.mdash: + namespaceprefix_ = self.mdash_nsprefix_ + ':' if (UseCapturedNS_ and self.mdash_nsprefix_) else '' + mdash_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='mdash', pretty_print=pretty_print) + for umlaut_ in self.umlaut: + namespaceprefix_ = self.umlaut_nsprefix_ + ':' if (UseCapturedNS_ and self.umlaut_nsprefix_) else '' + umlaut_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='umlaut', pretty_print=pretty_print) + for acute_ in self.acute: + namespaceprefix_ = self.acute_nsprefix_ + ':' if (UseCapturedNS_ and self.acute_nsprefix_) else '' + acute_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='acute', pretty_print=pretty_print) + for grave_ in self.grave: + namespaceprefix_ = self.grave_nsprefix_ + ':' if (UseCapturedNS_ and self.grave_nsprefix_) else '' + grave_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='grave', pretty_print=pretty_print) + for circ_ in self.circ: + namespaceprefix_ = self.circ_nsprefix_ + ':' if (UseCapturedNS_ and self.circ_nsprefix_) else '' + circ_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='circ', pretty_print=pretty_print) + for slash_ in self.slash: + namespaceprefix_ = self.slash_nsprefix_ + ':' if (UseCapturedNS_ and self.slash_nsprefix_) else '' + slash_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='slash', pretty_print=pretty_print) + for tilde_ in self.tilde: + namespaceprefix_ = self.tilde_nsprefix_ + ':' if (UseCapturedNS_ and self.tilde_nsprefix_) else '' + tilde_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='tilde', pretty_print=pretty_print) + for cedil_ in self.cedil: + namespaceprefix_ = self.cedil_nsprefix_ + ':' if (UseCapturedNS_ and self.cedil_nsprefix_) else '' + cedil_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='cedil', pretty_print=pretty_print) + for ring_ in self.ring: + namespaceprefix_ = self.ring_nsprefix_ + ':' if (UseCapturedNS_ and self.ring_nsprefix_) else '' + ring_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ring', pretty_print=pretty_print) + for szlig_ in self.szlig: + namespaceprefix_ = self.szlig_nsprefix_ + ':' if (UseCapturedNS_ and self.szlig_nsprefix_) else '' + szlig_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='szlig', pretty_print=pretty_print) + for nonbreakablespace_ in self.nonbreakablespace: + namespaceprefix_ = self.nonbreakablespace_nsprefix_ + ':' if (UseCapturedNS_ and self.nonbreakablespace_nsprefix_) else '' + nonbreakablespace_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='nonbreakablespace', pretty_print=pretty_print) + for aelig_ in self.aelig: + namespaceprefix_ = self.aelig_nsprefix_ + ':' if (UseCapturedNS_ and self.aelig_nsprefix_) else '' + aelig_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='aelig', pretty_print=pretty_print) + for AElig_ in self.AElig: + namespaceprefix_ = self.AElig_nsprefix_ + ':' if (UseCapturedNS_ and self.AElig_nsprefix_) else '' + AElig_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='AElig', pretty_print=pretty_print) + for Gamma_ in self.Gamma: + namespaceprefix_ = self.Gamma_nsprefix_ + ':' if (UseCapturedNS_ and self.Gamma_nsprefix_) else '' + Gamma_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Gamma', pretty_print=pretty_print) + for Delta_ in self.Delta: + namespaceprefix_ = self.Delta_nsprefix_ + ':' if (UseCapturedNS_ and self.Delta_nsprefix_) else '' + Delta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Delta', pretty_print=pretty_print) + for Theta_ in self.Theta: + namespaceprefix_ = self.Theta_nsprefix_ + ':' if (UseCapturedNS_ and self.Theta_nsprefix_) else '' + Theta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Theta', pretty_print=pretty_print) + for Lambda_ in self.Lambda: + namespaceprefix_ = self.Lambda_nsprefix_ + ':' if (UseCapturedNS_ and self.Lambda_nsprefix_) else '' + Lambda_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Lambda', pretty_print=pretty_print) + for Xi_ in self.Xi: + namespaceprefix_ = self.Xi_nsprefix_ + ':' if (UseCapturedNS_ and self.Xi_nsprefix_) else '' + Xi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Xi', pretty_print=pretty_print) + for Pi_ in self.Pi: + namespaceprefix_ = self.Pi_nsprefix_ + ':' if (UseCapturedNS_ and self.Pi_nsprefix_) else '' + Pi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Pi', pretty_print=pretty_print) + for Sigma_ in self.Sigma: + namespaceprefix_ = self.Sigma_nsprefix_ + ':' if (UseCapturedNS_ and self.Sigma_nsprefix_) else '' + Sigma_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Sigma', pretty_print=pretty_print) + for Upsilon_ in self.Upsilon: + namespaceprefix_ = self.Upsilon_nsprefix_ + ':' if (UseCapturedNS_ and self.Upsilon_nsprefix_) else '' + Upsilon_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Upsilon', pretty_print=pretty_print) + for Phi_ in self.Phi: + namespaceprefix_ = self.Phi_nsprefix_ + ':' if (UseCapturedNS_ and self.Phi_nsprefix_) else '' + Phi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Phi', pretty_print=pretty_print) + for Psi_ in self.Psi: + namespaceprefix_ = self.Psi_nsprefix_ + ':' if (UseCapturedNS_ and self.Psi_nsprefix_) else '' + Psi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Psi', pretty_print=pretty_print) + for Omega_ in self.Omega: + namespaceprefix_ = self.Omega_nsprefix_ + ':' if (UseCapturedNS_ and self.Omega_nsprefix_) else '' + Omega_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Omega', pretty_print=pretty_print) + for alpha_ in self.alpha: + namespaceprefix_ = self.alpha_nsprefix_ + ':' if (UseCapturedNS_ and self.alpha_nsprefix_) else '' + alpha_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='alpha', pretty_print=pretty_print) + for beta_ in self.beta: + namespaceprefix_ = self.beta_nsprefix_ + ':' if (UseCapturedNS_ and self.beta_nsprefix_) else '' + beta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='beta', pretty_print=pretty_print) + for gamma_ in self.gamma: + namespaceprefix_ = self.gamma_nsprefix_ + ':' if (UseCapturedNS_ and self.gamma_nsprefix_) else '' + gamma_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='gamma', pretty_print=pretty_print) + for delta_ in self.delta: + namespaceprefix_ = self.delta_nsprefix_ + ':' if (UseCapturedNS_ and self.delta_nsprefix_) else '' + delta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='delta', pretty_print=pretty_print) + for epsilon_ in self.epsilon: + namespaceprefix_ = self.epsilon_nsprefix_ + ':' if (UseCapturedNS_ and self.epsilon_nsprefix_) else '' + epsilon_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='epsilon', pretty_print=pretty_print) + for zeta_ in self.zeta: + namespaceprefix_ = self.zeta_nsprefix_ + ':' if (UseCapturedNS_ and self.zeta_nsprefix_) else '' + zeta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='zeta', pretty_print=pretty_print) + for eta_ in self.eta: + namespaceprefix_ = self.eta_nsprefix_ + ':' if (UseCapturedNS_ and self.eta_nsprefix_) else '' + eta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='eta', pretty_print=pretty_print) + for theta_ in self.theta: + namespaceprefix_ = self.theta_nsprefix_ + ':' if (UseCapturedNS_ and self.theta_nsprefix_) else '' + theta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='theta', pretty_print=pretty_print) + for iota_ in self.iota: + namespaceprefix_ = self.iota_nsprefix_ + ':' if (UseCapturedNS_ and self.iota_nsprefix_) else '' + iota_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='iota', pretty_print=pretty_print) + for kappa_ in self.kappa: + namespaceprefix_ = self.kappa_nsprefix_ + ':' if (UseCapturedNS_ and self.kappa_nsprefix_) else '' + kappa_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='kappa', pretty_print=pretty_print) + for lambda_ in self.lambda_: + namespaceprefix_ = self.lambda__nsprefix_ + ':' if (UseCapturedNS_ and self.lambda__nsprefix_) else '' + lambda_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='lambda', pretty_print=pretty_print) + for mu_ in self.mu: + namespaceprefix_ = self.mu_nsprefix_ + ':' if (UseCapturedNS_ and self.mu_nsprefix_) else '' + mu_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='mu', pretty_print=pretty_print) + for nu_ in self.nu: + namespaceprefix_ = self.nu_nsprefix_ + ':' if (UseCapturedNS_ and self.nu_nsprefix_) else '' + nu_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='nu', pretty_print=pretty_print) + for xi_ in self.xi: + namespaceprefix_ = self.xi_nsprefix_ + ':' if (UseCapturedNS_ and self.xi_nsprefix_) else '' + xi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='xi', pretty_print=pretty_print) + for pi_ in self.pi: + namespaceprefix_ = self.pi_nsprefix_ + ':' if (UseCapturedNS_ and self.pi_nsprefix_) else '' + pi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='pi', pretty_print=pretty_print) + for rho_ in self.rho: + namespaceprefix_ = self.rho_nsprefix_ + ':' if (UseCapturedNS_ and self.rho_nsprefix_) else '' + rho_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rho', pretty_print=pretty_print) + for sigma_ in self.sigma: + namespaceprefix_ = self.sigma_nsprefix_ + ':' if (UseCapturedNS_ and self.sigma_nsprefix_) else '' + sigma_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sigma', pretty_print=pretty_print) + for tau_ in self.tau: + namespaceprefix_ = self.tau_nsprefix_ + ':' if (UseCapturedNS_ and self.tau_nsprefix_) else '' + tau_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='tau', pretty_print=pretty_print) + for upsilon_ in self.upsilon: + namespaceprefix_ = self.upsilon_nsprefix_ + ':' if (UseCapturedNS_ and self.upsilon_nsprefix_) else '' + upsilon_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='upsilon', pretty_print=pretty_print) + for phi_ in self.phi: + namespaceprefix_ = self.phi_nsprefix_ + ':' if (UseCapturedNS_ and self.phi_nsprefix_) else '' + phi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='phi', pretty_print=pretty_print) + for chi_ in self.chi: + namespaceprefix_ = self.chi_nsprefix_ + ':' if (UseCapturedNS_ and self.chi_nsprefix_) else '' + chi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='chi', pretty_print=pretty_print) + for psi_ in self.psi: + namespaceprefix_ = self.psi_nsprefix_ + ':' if (UseCapturedNS_ and self.psi_nsprefix_) else '' + psi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='psi', pretty_print=pretty_print) + for omega_ in self.omega: + namespaceprefix_ = self.omega_nsprefix_ + ':' if (UseCapturedNS_ and self.omega_nsprefix_) else '' + omega_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='omega', pretty_print=pretty_print) + for sigmaf_ in self.sigmaf: + namespaceprefix_ = self.sigmaf_nsprefix_ + ':' if (UseCapturedNS_ and self.sigmaf_nsprefix_) else '' + sigmaf_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sigmaf', pretty_print=pretty_print) + for sect_ in self.sect: + namespaceprefix_ = self.sect_nsprefix_ + ':' if (UseCapturedNS_ and self.sect_nsprefix_) else '' + sect_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sect', pretty_print=pretty_print) + for deg_ in self.deg: + namespaceprefix_ = self.deg_nsprefix_ + ':' if (UseCapturedNS_ and self.deg_nsprefix_) else '' + deg_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='deg', pretty_print=pretty_print) + for prime_ in self.prime: + namespaceprefix_ = self.prime_nsprefix_ + ':' if (UseCapturedNS_ and self.prime_nsprefix_) else '' + prime_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='prime', pretty_print=pretty_print) + for Prime_ in self.Prime: + namespaceprefix_ = self.Prime_nsprefix_ + ':' if (UseCapturedNS_ and self.Prime_nsprefix_) else '' + Prime_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Prime', pretty_print=pretty_print) + for infin_ in self.infin: + namespaceprefix_ = self.infin_nsprefix_ + ':' if (UseCapturedNS_ and self.infin_nsprefix_) else '' + infin_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='infin', pretty_print=pretty_print) + for empty_ in self.empty: + namespaceprefix_ = self.empty_nsprefix_ + ':' if (UseCapturedNS_ and self.empty_nsprefix_) else '' + empty_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='empty', pretty_print=pretty_print) + for plusmn_ in self.plusmn: + namespaceprefix_ = self.plusmn_nsprefix_ + ':' if (UseCapturedNS_ and self.plusmn_nsprefix_) else '' + plusmn_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='plusmn', pretty_print=pretty_print) + for times_ in self.times: + namespaceprefix_ = self.times_nsprefix_ + ':' if (UseCapturedNS_ and self.times_nsprefix_) else '' + times_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='times', pretty_print=pretty_print) + for minus_ in self.minus: + namespaceprefix_ = self.minus_nsprefix_ + ':' if (UseCapturedNS_ and self.minus_nsprefix_) else '' + minus_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='minus', pretty_print=pretty_print) + for sdot_ in self.sdot: + namespaceprefix_ = self.sdot_nsprefix_ + ':' if (UseCapturedNS_ and self.sdot_nsprefix_) else '' + sdot_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sdot', pretty_print=pretty_print) + for part_ in self.part: + namespaceprefix_ = self.part_nsprefix_ + ':' if (UseCapturedNS_ and self.part_nsprefix_) else '' + part_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='part', pretty_print=pretty_print) + for nabla_ in self.nabla: + namespaceprefix_ = self.nabla_nsprefix_ + ':' if (UseCapturedNS_ and self.nabla_nsprefix_) else '' + nabla_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='nabla', pretty_print=pretty_print) + for radic_ in self.radic: + namespaceprefix_ = self.radic_nsprefix_ + ':' if (UseCapturedNS_ and self.radic_nsprefix_) else '' + radic_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='radic', pretty_print=pretty_print) + for perp_ in self.perp: + namespaceprefix_ = self.perp_nsprefix_ + ':' if (UseCapturedNS_ and self.perp_nsprefix_) else '' + perp_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='perp', pretty_print=pretty_print) + for sum_ in self.sum: + namespaceprefix_ = self.sum_nsprefix_ + ':' if (UseCapturedNS_ and self.sum_nsprefix_) else '' + sum_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sum', pretty_print=pretty_print) + for int_ in self.int: + namespaceprefix_ = self.int_nsprefix_ + ':' if (UseCapturedNS_ and self.int_nsprefix_) else '' + int_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='int', pretty_print=pretty_print) + for prod_ in self.prod: + namespaceprefix_ = self.prod_nsprefix_ + ':' if (UseCapturedNS_ and self.prod_nsprefix_) else '' + prod_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='prod', pretty_print=pretty_print) + for sim_ in self.sim: + namespaceprefix_ = self.sim_nsprefix_ + ':' if (UseCapturedNS_ and self.sim_nsprefix_) else '' + sim_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sim', pretty_print=pretty_print) + for asymp_ in self.asymp: + namespaceprefix_ = self.asymp_nsprefix_ + ':' if (UseCapturedNS_ and self.asymp_nsprefix_) else '' + asymp_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='asymp', pretty_print=pretty_print) + for ne_ in self.ne: + namespaceprefix_ = self.ne_nsprefix_ + ':' if (UseCapturedNS_ and self.ne_nsprefix_) else '' + ne_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ne', pretty_print=pretty_print) + for equiv_ in self.equiv: + namespaceprefix_ = self.equiv_nsprefix_ + ':' if (UseCapturedNS_ and self.equiv_nsprefix_) else '' + equiv_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='equiv', pretty_print=pretty_print) + for prop_ in self.prop: + namespaceprefix_ = self.prop_nsprefix_ + ':' if (UseCapturedNS_ and self.prop_nsprefix_) else '' + prop_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='prop', pretty_print=pretty_print) + for le_ in self.le: + namespaceprefix_ = self.le_nsprefix_ + ':' if (UseCapturedNS_ and self.le_nsprefix_) else '' + le_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='le', pretty_print=pretty_print) + for ge_ in self.ge: + namespaceprefix_ = self.ge_nsprefix_ + ':' if (UseCapturedNS_ and self.ge_nsprefix_) else '' + ge_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ge', pretty_print=pretty_print) + for larr_ in self.larr: + namespaceprefix_ = self.larr_nsprefix_ + ':' if (UseCapturedNS_ and self.larr_nsprefix_) else '' + larr_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='larr', pretty_print=pretty_print) + for rarr_ in self.rarr: + namespaceprefix_ = self.rarr_nsprefix_ + ':' if (UseCapturedNS_ and self.rarr_nsprefix_) else '' + rarr_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rarr', pretty_print=pretty_print) + for isin_ in self.isin: + namespaceprefix_ = self.isin_nsprefix_ + ':' if (UseCapturedNS_ and self.isin_nsprefix_) else '' + isin_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='isin', pretty_print=pretty_print) + for notin_ in self.notin: + namespaceprefix_ = self.notin_nsprefix_ + ':' if (UseCapturedNS_ and self.notin_nsprefix_) else '' + notin_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='notin', pretty_print=pretty_print) + for lceil_ in self.lceil: + namespaceprefix_ = self.lceil_nsprefix_ + ':' if (UseCapturedNS_ and self.lceil_nsprefix_) else '' + lceil_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='lceil', pretty_print=pretty_print) + for rceil_ in self.rceil: + namespaceprefix_ = self.rceil_nsprefix_ + ':' if (UseCapturedNS_ and self.rceil_nsprefix_) else '' + rceil_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rceil', pretty_print=pretty_print) + for lfloor_ in self.lfloor: + namespaceprefix_ = self.lfloor_nsprefix_ + ':' if (UseCapturedNS_ and self.lfloor_nsprefix_) else '' + lfloor_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='lfloor', pretty_print=pretty_print) + for rfloor_ in self.rfloor: + namespaceprefix_ = self.rfloor_nsprefix_ + ':' if (UseCapturedNS_ and self.rfloor_nsprefix_) else '' + rfloor_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rfloor', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + self.valueOf_ = get_all_text_(node) + if node.text is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', node.text) + self.content_.append(obj_) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('name', node) + if value is not None and 'name' not in already_processed: + already_processed.add('name') + self.name = value + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'ulink': + obj_ = docURLLink.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ulink', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ulink'): + self.add_ulink(obj_.value) + elif hasattr(self, 'set_ulink'): + self.set_ulink(obj_.value) + elif nodeName_ == 'bold': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'bold', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_bold'): + self.add_bold(obj_.value) + elif hasattr(self, 'set_bold'): + self.set_bold(obj_.value) + elif nodeName_ == 'emphasis': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'emphasis', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_emphasis'): + self.add_emphasis(obj_.value) + elif hasattr(self, 'set_emphasis'): + self.set_emphasis(obj_.value) + elif nodeName_ == 'computeroutput': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'computeroutput', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_computeroutput'): + self.add_computeroutput(obj_.value) + elif hasattr(self, 'set_computeroutput'): + self.set_computeroutput(obj_.value) + elif nodeName_ == 'subscript': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'subscript', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_subscript'): + self.add_subscript(obj_.value) + elif hasattr(self, 'set_subscript'): + self.set_subscript(obj_.value) + elif nodeName_ == 'superscript': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'superscript', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_superscript'): + self.add_superscript(obj_.value) + elif hasattr(self, 'set_superscript'): + self.set_superscript(obj_.value) + elif nodeName_ == 'center': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'center', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_center'): + self.add_center(obj_.value) + elif hasattr(self, 'set_center'): + self.set_center(obj_.value) + elif nodeName_ == 'small': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'small', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_small'): + self.add_small(obj_.value) + elif hasattr(self, 'set_small'): + self.set_small(obj_.value) + elif nodeName_ == 'htmlonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'htmlonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'htmlonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'htmlonly', valuestr_) + self.content_.append(obj_) + self.htmlonly_nsprefix_ = child_.prefix + elif nodeName_ == 'manonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'manonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'manonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'manonly', valuestr_) + self.content_.append(obj_) + self.manonly_nsprefix_ = child_.prefix + elif nodeName_ == 'xmlonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'xmlonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'xmlonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'xmlonly', valuestr_) + self.content_.append(obj_) + self.xmlonly_nsprefix_ = child_.prefix + elif nodeName_ == 'rtfonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'rtfonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'rtfonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'rtfonly', valuestr_) + self.content_.append(obj_) + self.rtfonly_nsprefix_ = child_.prefix + elif nodeName_ == 'latexonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'latexonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'latexonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'latexonly', valuestr_) + self.content_.append(obj_) + self.latexonly_nsprefix_ = child_.prefix + elif nodeName_ == 'dot' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'dot') + valuestr_ = self.gds_validate_string(valuestr_, node, 'dot') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'dot', valuestr_) + self.content_.append(obj_) + self.dot_nsprefix_ = child_.prefix + elif nodeName_ == 'msc' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'msc') + valuestr_ = self.gds_validate_string(valuestr_, node, 'msc') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'msc', valuestr_) + self.content_.append(obj_) + self.msc_nsprefix_ = child_.prefix + elif nodeName_ == 'anchor': + obj_ = docAnchorType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'anchor', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_anchor'): + self.add_anchor(obj_.value) + elif hasattr(self, 'set_anchor'): + self.set_anchor(obj_.value) + elif nodeName_ == 'formula': + obj_ = docFormulaType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'formula', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_formula'): + self.add_formula(obj_.value) + elif hasattr(self, 'set_formula'): + self.set_formula(obj_.value) + elif nodeName_ == 'ref': + obj_ = docRefTextType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ref', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ref'): + self.add_ref(obj_.value) + elif hasattr(self, 'set_ref'): + self.set_ref(obj_.value) + elif nodeName_ == 'copy': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'copy', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_copy'): + self.add_copy(obj_.value) + elif hasattr(self, 'set_copy'): + self.set_copy(obj_.value) + elif nodeName_ == 'trademark': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'trademark', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_trademark'): + self.add_trademark(obj_.value) + elif hasattr(self, 'set_trademark'): + self.set_trademark(obj_.value) + elif nodeName_ == 'registered': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'registered', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_registered'): + self.add_registered(obj_.value) + elif hasattr(self, 'set_registered'): + self.set_registered(obj_.value) + elif nodeName_ == 'lsquo': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'lsquo', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_lsquo'): + self.add_lsquo(obj_.value) + elif hasattr(self, 'set_lsquo'): + self.set_lsquo(obj_.value) + elif nodeName_ == 'rsquo': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rsquo', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rsquo'): + self.add_rsquo(obj_.value) + elif hasattr(self, 'set_rsquo'): + self.set_rsquo(obj_.value) + elif nodeName_ == 'ldquo': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ldquo', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ldquo'): + self.add_ldquo(obj_.value) + elif hasattr(self, 'set_ldquo'): + self.set_ldquo(obj_.value) + elif nodeName_ == 'rdquo': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rdquo', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rdquo'): + self.add_rdquo(obj_.value) + elif hasattr(self, 'set_rdquo'): + self.set_rdquo(obj_.value) + elif nodeName_ == 'ndash': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ndash', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ndash'): + self.add_ndash(obj_.value) + elif hasattr(self, 'set_ndash'): + self.set_ndash(obj_.value) + elif nodeName_ == 'mdash': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'mdash', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_mdash'): + self.add_mdash(obj_.value) + elif hasattr(self, 'set_mdash'): + self.set_mdash(obj_.value) + elif nodeName_ == 'umlaut': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'umlaut', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_umlaut'): + self.add_umlaut(obj_.value) + elif hasattr(self, 'set_umlaut'): + self.set_umlaut(obj_.value) + elif nodeName_ == 'acute': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'acute', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_acute'): + self.add_acute(obj_.value) + elif hasattr(self, 'set_acute'): + self.set_acute(obj_.value) + elif nodeName_ == 'grave': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'grave', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_grave'): + self.add_grave(obj_.value) + elif hasattr(self, 'set_grave'): + self.set_grave(obj_.value) + elif nodeName_ == 'circ': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'circ', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_circ'): + self.add_circ(obj_.value) + elif hasattr(self, 'set_circ'): + self.set_circ(obj_.value) + elif nodeName_ == 'slash': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'slash', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_slash'): + self.add_slash(obj_.value) + elif hasattr(self, 'set_slash'): + self.set_slash(obj_.value) + elif nodeName_ == 'tilde': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'tilde', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_tilde'): + self.add_tilde(obj_.value) + elif hasattr(self, 'set_tilde'): + self.set_tilde(obj_.value) + elif nodeName_ == 'cedil': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'cedil', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_cedil'): + self.add_cedil(obj_.value) + elif hasattr(self, 'set_cedil'): + self.set_cedil(obj_.value) + elif nodeName_ == 'ring': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ring', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ring'): + self.add_ring(obj_.value) + elif hasattr(self, 'set_ring'): + self.set_ring(obj_.value) + elif nodeName_ == 'szlig': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'szlig', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_szlig'): + self.add_szlig(obj_.value) + elif hasattr(self, 'set_szlig'): + self.set_szlig(obj_.value) + elif nodeName_ == 'nonbreakablespace': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'nonbreakablespace', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_nonbreakablespace'): + self.add_nonbreakablespace(obj_.value) + elif hasattr(self, 'set_nonbreakablespace'): + self.set_nonbreakablespace(obj_.value) + elif nodeName_ == 'aelig': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'aelig', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_aelig'): + self.add_aelig(obj_.value) + elif hasattr(self, 'set_aelig'): + self.set_aelig(obj_.value) + elif nodeName_ == 'AElig': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'AElig', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_AElig'): + self.add_AElig(obj_.value) + elif hasattr(self, 'set_AElig'): + self.set_AElig(obj_.value) + elif nodeName_ == 'Gamma': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Gamma', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Gamma'): + self.add_Gamma(obj_.value) + elif hasattr(self, 'set_Gamma'): + self.set_Gamma(obj_.value) + elif nodeName_ == 'Delta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Delta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Delta'): + self.add_Delta(obj_.value) + elif hasattr(self, 'set_Delta'): + self.set_Delta(obj_.value) + elif nodeName_ == 'Theta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Theta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Theta'): + self.add_Theta(obj_.value) + elif hasattr(self, 'set_Theta'): + self.set_Theta(obj_.value) + elif nodeName_ == 'Lambda': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Lambda', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Lambda'): + self.add_Lambda(obj_.value) + elif hasattr(self, 'set_Lambda'): + self.set_Lambda(obj_.value) + elif nodeName_ == 'Xi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Xi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Xi'): + self.add_Xi(obj_.value) + elif hasattr(self, 'set_Xi'): + self.set_Xi(obj_.value) + elif nodeName_ == 'Pi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Pi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Pi'): + self.add_Pi(obj_.value) + elif hasattr(self, 'set_Pi'): + self.set_Pi(obj_.value) + elif nodeName_ == 'Sigma': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Sigma', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Sigma'): + self.add_Sigma(obj_.value) + elif hasattr(self, 'set_Sigma'): + self.set_Sigma(obj_.value) + elif nodeName_ == 'Upsilon': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Upsilon', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Upsilon'): + self.add_Upsilon(obj_.value) + elif hasattr(self, 'set_Upsilon'): + self.set_Upsilon(obj_.value) + elif nodeName_ == 'Phi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Phi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Phi'): + self.add_Phi(obj_.value) + elif hasattr(self, 'set_Phi'): + self.set_Phi(obj_.value) + elif nodeName_ == 'Psi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Psi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Psi'): + self.add_Psi(obj_.value) + elif hasattr(self, 'set_Psi'): + self.set_Psi(obj_.value) + elif nodeName_ == 'Omega': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Omega', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Omega'): + self.add_Omega(obj_.value) + elif hasattr(self, 'set_Omega'): + self.set_Omega(obj_.value) + elif nodeName_ == 'alpha': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'alpha', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_alpha'): + self.add_alpha(obj_.value) + elif hasattr(self, 'set_alpha'): + self.set_alpha(obj_.value) + elif nodeName_ == 'beta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'beta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_beta'): + self.add_beta(obj_.value) + elif hasattr(self, 'set_beta'): + self.set_beta(obj_.value) + elif nodeName_ == 'gamma': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'gamma', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_gamma'): + self.add_gamma(obj_.value) + elif hasattr(self, 'set_gamma'): + self.set_gamma(obj_.value) + elif nodeName_ == 'delta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'delta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_delta'): + self.add_delta(obj_.value) + elif hasattr(self, 'set_delta'): + self.set_delta(obj_.value) + elif nodeName_ == 'epsilon': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'epsilon', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_epsilon'): + self.add_epsilon(obj_.value) + elif hasattr(self, 'set_epsilon'): + self.set_epsilon(obj_.value) + elif nodeName_ == 'zeta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'zeta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_zeta'): + self.add_zeta(obj_.value) + elif hasattr(self, 'set_zeta'): + self.set_zeta(obj_.value) + elif nodeName_ == 'eta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'eta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_eta'): + self.add_eta(obj_.value) + elif hasattr(self, 'set_eta'): + self.set_eta(obj_.value) + elif nodeName_ == 'theta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'theta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_theta'): + self.add_theta(obj_.value) + elif hasattr(self, 'set_theta'): + self.set_theta(obj_.value) + elif nodeName_ == 'iota': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'iota', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_iota'): + self.add_iota(obj_.value) + elif hasattr(self, 'set_iota'): + self.set_iota(obj_.value) + elif nodeName_ == 'kappa': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'kappa', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_kappa'): + self.add_kappa(obj_.value) + elif hasattr(self, 'set_kappa'): + self.set_kappa(obj_.value) + elif nodeName_ == 'lambda': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'lambda', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_lambda'): + self.add_lambda(obj_.value) + elif hasattr(self, 'set_lambda'): + self.set_lambda(obj_.value) + elif nodeName_ == 'mu': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'mu', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_mu'): + self.add_mu(obj_.value) + elif hasattr(self, 'set_mu'): + self.set_mu(obj_.value) + elif nodeName_ == 'nu': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'nu', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_nu'): + self.add_nu(obj_.value) + elif hasattr(self, 'set_nu'): + self.set_nu(obj_.value) + elif nodeName_ == 'xi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'xi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_xi'): + self.add_xi(obj_.value) + elif hasattr(self, 'set_xi'): + self.set_xi(obj_.value) + elif nodeName_ == 'pi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'pi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_pi'): + self.add_pi(obj_.value) + elif hasattr(self, 'set_pi'): + self.set_pi(obj_.value) + elif nodeName_ == 'rho': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rho', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rho'): + self.add_rho(obj_.value) + elif hasattr(self, 'set_rho'): + self.set_rho(obj_.value) + elif nodeName_ == 'sigma': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sigma', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sigma'): + self.add_sigma(obj_.value) + elif hasattr(self, 'set_sigma'): + self.set_sigma(obj_.value) + elif nodeName_ == 'tau': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'tau', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_tau'): + self.add_tau(obj_.value) + elif hasattr(self, 'set_tau'): + self.set_tau(obj_.value) + elif nodeName_ == 'upsilon': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'upsilon', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_upsilon'): + self.add_upsilon(obj_.value) + elif hasattr(self, 'set_upsilon'): + self.set_upsilon(obj_.value) + elif nodeName_ == 'phi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'phi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_phi'): + self.add_phi(obj_.value) + elif hasattr(self, 'set_phi'): + self.set_phi(obj_.value) + elif nodeName_ == 'chi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'chi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_chi'): + self.add_chi(obj_.value) + elif hasattr(self, 'set_chi'): + self.set_chi(obj_.value) + elif nodeName_ == 'psi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'psi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_psi'): + self.add_psi(obj_.value) + elif hasattr(self, 'set_psi'): + self.set_psi(obj_.value) + elif nodeName_ == 'omega': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'omega', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_omega'): + self.add_omega(obj_.value) + elif hasattr(self, 'set_omega'): + self.set_omega(obj_.value) + elif nodeName_ == 'sigmaf': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sigmaf', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sigmaf'): + self.add_sigmaf(obj_.value) + elif hasattr(self, 'set_sigmaf'): + self.set_sigmaf(obj_.value) + elif nodeName_ == 'sect': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sect', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sect'): + self.add_sect(obj_.value) + elif hasattr(self, 'set_sect'): + self.set_sect(obj_.value) + elif nodeName_ == 'deg': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'deg', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_deg'): + self.add_deg(obj_.value) + elif hasattr(self, 'set_deg'): + self.set_deg(obj_.value) + elif nodeName_ == 'prime': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'prime', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_prime'): + self.add_prime(obj_.value) + elif hasattr(self, 'set_prime'): + self.set_prime(obj_.value) + elif nodeName_ == 'Prime': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Prime', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Prime'): + self.add_Prime(obj_.value) + elif hasattr(self, 'set_Prime'): + self.set_Prime(obj_.value) + elif nodeName_ == 'infin': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'infin', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_infin'): + self.add_infin(obj_.value) + elif hasattr(self, 'set_infin'): + self.set_infin(obj_.value) + elif nodeName_ == 'empty': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'empty', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_empty'): + self.add_empty(obj_.value) + elif hasattr(self, 'set_empty'): + self.set_empty(obj_.value) + elif nodeName_ == 'plusmn': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'plusmn', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_plusmn'): + self.add_plusmn(obj_.value) + elif hasattr(self, 'set_plusmn'): + self.set_plusmn(obj_.value) + elif nodeName_ == 'times': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'times', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_times'): + self.add_times(obj_.value) + elif hasattr(self, 'set_times'): + self.set_times(obj_.value) + elif nodeName_ == 'minus': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'minus', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_minus'): + self.add_minus(obj_.value) + elif hasattr(self, 'set_minus'): + self.set_minus(obj_.value) + elif nodeName_ == 'sdot': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sdot', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sdot'): + self.add_sdot(obj_.value) + elif hasattr(self, 'set_sdot'): + self.set_sdot(obj_.value) + elif nodeName_ == 'part': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'part', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_part'): + self.add_part(obj_.value) + elif hasattr(self, 'set_part'): + self.set_part(obj_.value) + elif nodeName_ == 'nabla': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'nabla', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_nabla'): + self.add_nabla(obj_.value) + elif hasattr(self, 'set_nabla'): + self.set_nabla(obj_.value) + elif nodeName_ == 'radic': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'radic', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_radic'): + self.add_radic(obj_.value) + elif hasattr(self, 'set_radic'): + self.set_radic(obj_.value) + elif nodeName_ == 'perp': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'perp', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_perp'): + self.add_perp(obj_.value) + elif hasattr(self, 'set_perp'): + self.set_perp(obj_.value) + elif nodeName_ == 'sum': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sum', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sum'): + self.add_sum(obj_.value) + elif hasattr(self, 'set_sum'): + self.set_sum(obj_.value) + elif nodeName_ == 'int': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'int', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_int'): + self.add_int(obj_.value) + elif hasattr(self, 'set_int'): + self.set_int(obj_.value) + elif nodeName_ == 'prod': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'prod', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_prod'): + self.add_prod(obj_.value) + elif hasattr(self, 'set_prod'): + self.set_prod(obj_.value) + elif nodeName_ == 'sim': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sim', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sim'): + self.add_sim(obj_.value) + elif hasattr(self, 'set_sim'): + self.set_sim(obj_.value) + elif nodeName_ == 'asymp': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'asymp', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_asymp'): + self.add_asymp(obj_.value) + elif hasattr(self, 'set_asymp'): + self.set_asymp(obj_.value) + elif nodeName_ == 'ne': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ne', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ne'): + self.add_ne(obj_.value) + elif hasattr(self, 'set_ne'): + self.set_ne(obj_.value) + elif nodeName_ == 'equiv': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'equiv', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_equiv'): + self.add_equiv(obj_.value) + elif hasattr(self, 'set_equiv'): + self.set_equiv(obj_.value) + elif nodeName_ == 'prop': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'prop', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_prop'): + self.add_prop(obj_.value) + elif hasattr(self, 'set_prop'): + self.set_prop(obj_.value) + elif nodeName_ == 'le': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'le', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_le'): + self.add_le(obj_.value) + elif hasattr(self, 'set_le'): + self.set_le(obj_.value) + elif nodeName_ == 'ge': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ge', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ge'): + self.add_ge(obj_.value) + elif hasattr(self, 'set_ge'): + self.set_ge(obj_.value) + elif nodeName_ == 'larr': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'larr', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_larr'): + self.add_larr(obj_.value) + elif hasattr(self, 'set_larr'): + self.set_larr(obj_.value) + elif nodeName_ == 'rarr': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rarr', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rarr'): + self.add_rarr(obj_.value) + elif hasattr(self, 'set_rarr'): + self.set_rarr(obj_.value) + elif nodeName_ == 'isin': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'isin', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_isin'): + self.add_isin(obj_.value) + elif hasattr(self, 'set_isin'): + self.set_isin(obj_.value) + elif nodeName_ == 'notin': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'notin', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_notin'): + self.add_notin(obj_.value) + elif hasattr(self, 'set_notin'): + self.set_notin(obj_.value) + elif nodeName_ == 'lceil': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'lceil', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_lceil'): + self.add_lceil(obj_.value) + elif hasattr(self, 'set_lceil'): + self.set_lceil(obj_.value) + elif nodeName_ == 'rceil': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rceil', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rceil'): + self.add_rceil(obj_.value) + elif hasattr(self, 'set_rceil'): + self.set_rceil(obj_.value) + elif nodeName_ == 'lfloor': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'lfloor', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_lfloor'): + self.add_lfloor(obj_.value) + elif hasattr(self, 'set_lfloor'): + self.set_lfloor(obj_.value) + elif nodeName_ == 'rfloor': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rfloor', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rfloor'): + self.add_rfloor(obj_.value) + elif hasattr(self, 'set_rfloor'): + self.set_rfloor(obj_.value) + if not fromsubclass_ and child_.tail is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.tail) + self.content_.append(obj_) +# end class docFileType + + +class docTocItemType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, id=None, ulink=None, bold=None, emphasis=None, computeroutput=None, subscript=None, superscript=None, center=None, small=None, htmlonly=None, manonly=None, xmlonly=None, rtfonly=None, latexonly=None, dot=None, msc=None, anchor=None, formula=None, ref=None, copy=None, trademark=None, registered=None, lsquo=None, rsquo=None, ldquo=None, rdquo=None, ndash=None, mdash=None, umlaut=None, acute=None, grave=None, circ=None, slash=None, tilde=None, cedil=None, ring=None, szlig=None, nonbreakablespace=None, aelig=None, AElig=None, Gamma=None, Delta=None, Theta=None, Lambda=None, Xi=None, Pi=None, Sigma=None, Upsilon=None, Phi=None, Psi=None, Omega=None, alpha=None, beta=None, gamma=None, delta=None, epsilon=None, zeta=None, eta=None, theta=None, iota=None, kappa=None, lambda_=None, mu=None, nu=None, xi=None, pi=None, rho=None, sigma=None, tau=None, upsilon=None, phi=None, chi=None, psi=None, omega=None, sigmaf=None, sect=None, deg=None, prime=None, Prime=None, infin=None, empty=None, plusmn=None, times=None, minus=None, sdot=None, part=None, nabla=None, radic=None, perp=None, sum=None, int=None, prod=None, sim=None, asymp=None, ne=None, equiv=None, prop=None, le=None, ge=None, larr=None, rarr=None, isin=None, notin=None, lceil=None, rceil=None, lfloor=None, rfloor=None, valueOf_=None, mixedclass_=None, content_=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.id = _cast(None, id) + self.id_nsprefix_ = None + if ulink is None: + self.ulink = [] + else: + self.ulink = ulink + self.ulink_nsprefix_ = None + if bold is None: + self.bold = [] + else: + self.bold = bold + self.bold_nsprefix_ = None + if emphasis is None: + self.emphasis = [] + else: + self.emphasis = emphasis + self.emphasis_nsprefix_ = None + if computeroutput is None: + self.computeroutput = [] + else: + self.computeroutput = computeroutput + self.computeroutput_nsprefix_ = None + if subscript is None: + self.subscript = [] + else: + self.subscript = subscript + self.subscript_nsprefix_ = None + if superscript is None: + self.superscript = [] + else: + self.superscript = superscript + self.superscript_nsprefix_ = None + if center is None: + self.center = [] + else: + self.center = center + self.center_nsprefix_ = None + if small is None: + self.small = [] + else: + self.small = small + self.small_nsprefix_ = None + if htmlonly is None: + self.htmlonly = [] + else: + self.htmlonly = htmlonly + self.htmlonly_nsprefix_ = None + if manonly is None: + self.manonly = [] + else: + self.manonly = manonly + self.manonly_nsprefix_ = None + if xmlonly is None: + self.xmlonly = [] + else: + self.xmlonly = xmlonly + self.xmlonly_nsprefix_ = None + if rtfonly is None: + self.rtfonly = [] + else: + self.rtfonly = rtfonly + self.rtfonly_nsprefix_ = None + if latexonly is None: + self.latexonly = [] + else: + self.latexonly = latexonly + self.latexonly_nsprefix_ = None + if dot is None: + self.dot = [] + else: + self.dot = dot + self.dot_nsprefix_ = None + if msc is None: + self.msc = [] + else: + self.msc = msc + self.msc_nsprefix_ = None + if anchor is None: + self.anchor = [] + else: + self.anchor = anchor + self.anchor_nsprefix_ = None + if formula is None: + self.formula = [] + else: + self.formula = formula + self.formula_nsprefix_ = None + if ref is None: + self.ref = [] + else: + self.ref = ref + self.ref_nsprefix_ = None + if copy is None: + self.copy = [] + else: + self.copy = copy + self.copy_nsprefix_ = None + if trademark is None: + self.trademark = [] + else: + self.trademark = trademark + self.trademark_nsprefix_ = None + if registered is None: + self.registered = [] + else: + self.registered = registered + self.registered_nsprefix_ = None + if lsquo is None: + self.lsquo = [] + else: + self.lsquo = lsquo + self.lsquo_nsprefix_ = None + if rsquo is None: + self.rsquo = [] + else: + self.rsquo = rsquo + self.rsquo_nsprefix_ = None + if ldquo is None: + self.ldquo = [] + else: + self.ldquo = ldquo + self.ldquo_nsprefix_ = None + if rdquo is None: + self.rdquo = [] + else: + self.rdquo = rdquo + self.rdquo_nsprefix_ = None + if ndash is None: + self.ndash = [] + else: + self.ndash = ndash + self.ndash_nsprefix_ = None + if mdash is None: + self.mdash = [] + else: + self.mdash = mdash + self.mdash_nsprefix_ = None + if umlaut is None: + self.umlaut = [] + else: + self.umlaut = umlaut + self.umlaut_nsprefix_ = None + if acute is None: + self.acute = [] + else: + self.acute = acute + self.acute_nsprefix_ = None + if grave is None: + self.grave = [] + else: + self.grave = grave + self.grave_nsprefix_ = None + if circ is None: + self.circ = [] + else: + self.circ = circ + self.circ_nsprefix_ = None + if slash is None: + self.slash = [] + else: + self.slash = slash + self.slash_nsprefix_ = None + if tilde is None: + self.tilde = [] + else: + self.tilde = tilde + self.tilde_nsprefix_ = None + if cedil is None: + self.cedil = [] + else: + self.cedil = cedil + self.cedil_nsprefix_ = None + if ring is None: + self.ring = [] + else: + self.ring = ring + self.ring_nsprefix_ = None + if szlig is None: + self.szlig = [] + else: + self.szlig = szlig + self.szlig_nsprefix_ = None + if nonbreakablespace is None: + self.nonbreakablespace = [] + else: + self.nonbreakablespace = nonbreakablespace + self.nonbreakablespace_nsprefix_ = None + if aelig is None: + self.aelig = [] + else: + self.aelig = aelig + self.aelig_nsprefix_ = None + if AElig is None: + self.AElig = [] + else: + self.AElig = AElig + self.AElig_nsprefix_ = None + if Gamma is None: + self.Gamma = [] + else: + self.Gamma = Gamma + self.Gamma_nsprefix_ = None + if Delta is None: + self.Delta = [] + else: + self.Delta = Delta + self.Delta_nsprefix_ = None + if Theta is None: + self.Theta = [] + else: + self.Theta = Theta + self.Theta_nsprefix_ = None + if Lambda is None: + self.Lambda = [] + else: + self.Lambda = Lambda + self.Lambda_nsprefix_ = None + if Xi is None: + self.Xi = [] + else: + self.Xi = Xi + self.Xi_nsprefix_ = None + if Pi is None: + self.Pi = [] + else: + self.Pi = Pi + self.Pi_nsprefix_ = None + if Sigma is None: + self.Sigma = [] + else: + self.Sigma = Sigma + self.Sigma_nsprefix_ = None + if Upsilon is None: + self.Upsilon = [] + else: + self.Upsilon = Upsilon + self.Upsilon_nsprefix_ = None + if Phi is None: + self.Phi = [] + else: + self.Phi = Phi + self.Phi_nsprefix_ = None + if Psi is None: + self.Psi = [] + else: + self.Psi = Psi + self.Psi_nsprefix_ = None + if Omega is None: + self.Omega = [] + else: + self.Omega = Omega + self.Omega_nsprefix_ = None + if alpha is None: + self.alpha = [] + else: + self.alpha = alpha + self.alpha_nsprefix_ = None + if beta is None: + self.beta = [] + else: + self.beta = beta + self.beta_nsprefix_ = None + if gamma is None: + self.gamma = [] + else: + self.gamma = gamma + self.gamma_nsprefix_ = None + if delta is None: + self.delta = [] + else: + self.delta = delta + self.delta_nsprefix_ = None + if epsilon is None: + self.epsilon = [] + else: + self.epsilon = epsilon + self.epsilon_nsprefix_ = None + if zeta is None: + self.zeta = [] + else: + self.zeta = zeta + self.zeta_nsprefix_ = None + if eta is None: + self.eta = [] + else: + self.eta = eta + self.eta_nsprefix_ = None + if theta is None: + self.theta = [] + else: + self.theta = theta + self.theta_nsprefix_ = None + if iota is None: + self.iota = [] + else: + self.iota = iota + self.iota_nsprefix_ = None + if kappa is None: + self.kappa = [] + else: + self.kappa = kappa + self.kappa_nsprefix_ = None + if lambda_ is None: + self.lambda_ = [] + else: + self.lambda_ = lambda_ + self.lambda__nsprefix_ = None + if mu is None: + self.mu = [] + else: + self.mu = mu + self.mu_nsprefix_ = None + if nu is None: + self.nu = [] + else: + self.nu = nu + self.nu_nsprefix_ = None + if xi is None: + self.xi = [] + else: + self.xi = xi + self.xi_nsprefix_ = None + if pi is None: + self.pi = [] + else: + self.pi = pi + self.pi_nsprefix_ = None + if rho is None: + self.rho = [] + else: + self.rho = rho + self.rho_nsprefix_ = None + if sigma is None: + self.sigma = [] + else: + self.sigma = sigma + self.sigma_nsprefix_ = None + if tau is None: + self.tau = [] + else: + self.tau = tau + self.tau_nsprefix_ = None + if upsilon is None: + self.upsilon = [] + else: + self.upsilon = upsilon + self.upsilon_nsprefix_ = None + if phi is None: + self.phi = [] + else: + self.phi = phi + self.phi_nsprefix_ = None + if chi is None: + self.chi = [] + else: + self.chi = chi + self.chi_nsprefix_ = None + if psi is None: + self.psi = [] + else: + self.psi = psi + self.psi_nsprefix_ = None + if omega is None: + self.omega = [] + else: + self.omega = omega + self.omega_nsprefix_ = None + if sigmaf is None: + self.sigmaf = [] + else: + self.sigmaf = sigmaf + self.sigmaf_nsprefix_ = None + if sect is None: + self.sect = [] + else: + self.sect = sect + self.sect_nsprefix_ = None + if deg is None: + self.deg = [] + else: + self.deg = deg + self.deg_nsprefix_ = None + if prime is None: + self.prime = [] + else: + self.prime = prime + self.prime_nsprefix_ = None + if Prime is None: + self.Prime = [] + else: + self.Prime = Prime + self.Prime_nsprefix_ = None + if infin is None: + self.infin = [] + else: + self.infin = infin + self.infin_nsprefix_ = None + if empty is None: + self.empty = [] + else: + self.empty = empty + self.empty_nsprefix_ = None + if plusmn is None: + self.plusmn = [] + else: + self.plusmn = plusmn + self.plusmn_nsprefix_ = None + if times is None: + self.times = [] + else: + self.times = times + self.times_nsprefix_ = None + if minus is None: + self.minus = [] + else: + self.minus = minus + self.minus_nsprefix_ = None + if sdot is None: + self.sdot = [] + else: + self.sdot = sdot + self.sdot_nsprefix_ = None + if part is None: + self.part = [] + else: + self.part = part + self.part_nsprefix_ = None + if nabla is None: + self.nabla = [] + else: + self.nabla = nabla + self.nabla_nsprefix_ = None + if radic is None: + self.radic = [] + else: + self.radic = radic + self.radic_nsprefix_ = None + if perp is None: + self.perp = [] + else: + self.perp = perp + self.perp_nsprefix_ = None + if sum is None: + self.sum = [] + else: + self.sum = sum + self.sum_nsprefix_ = None + if int is None: + self.int = [] + else: + self.int = int + self.int_nsprefix_ = None + if prod is None: + self.prod = [] + else: + self.prod = prod + self.prod_nsprefix_ = None + if sim is None: + self.sim = [] + else: + self.sim = sim + self.sim_nsprefix_ = None + if asymp is None: + self.asymp = [] + else: + self.asymp = asymp + self.asymp_nsprefix_ = None + if ne is None: + self.ne = [] + else: + self.ne = ne + self.ne_nsprefix_ = None + if equiv is None: + self.equiv = [] + else: + self.equiv = equiv + self.equiv_nsprefix_ = None + if prop is None: + self.prop = [] + else: + self.prop = prop + self.prop_nsprefix_ = None + if le is None: + self.le = [] + else: + self.le = le + self.le_nsprefix_ = None + if ge is None: + self.ge = [] + else: + self.ge = ge + self.ge_nsprefix_ = None + if larr is None: + self.larr = [] + else: + self.larr = larr + self.larr_nsprefix_ = None + if rarr is None: + self.rarr = [] + else: + self.rarr = rarr + self.rarr_nsprefix_ = None + if isin is None: + self.isin = [] + else: + self.isin = isin + self.isin_nsprefix_ = None + if notin is None: + self.notin = [] + else: + self.notin = notin + self.notin_nsprefix_ = None + if lceil is None: + self.lceil = [] + else: + self.lceil = lceil + self.lceil_nsprefix_ = None + if rceil is None: + self.rceil = [] + else: + self.rceil = rceil + self.rceil_nsprefix_ = None + if lfloor is None: + self.lfloor = [] + else: + self.lfloor = lfloor + self.lfloor_nsprefix_ = None + if rfloor is None: + self.rfloor = [] + else: + self.rfloor = rfloor + self.rfloor_nsprefix_ = None + self.valueOf_ = valueOf_ + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + self.valueOf_ = valueOf_ + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docTocItemType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docTocItemType.subclass: + return docTocItemType.subclass(*args_, **kwargs_) + return docTocItemType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + def get_ulink(self): + return self.ulink + def set_ulink(self, ulink): + self.ulink = ulink + def add_ulink(self, value): + self.ulink.append(value) + def insert_ulink_at(self, index, value): + self.ulink.insert(index, value) + def replace_ulink_at(self, index, value): + self.ulink[index] = value + def get_bold(self): + return self.bold + def set_bold(self, bold): + self.bold = bold + def add_bold(self, value): + self.bold.append(value) + def insert_bold_at(self, index, value): + self.bold.insert(index, value) + def replace_bold_at(self, index, value): + self.bold[index] = value + def get_emphasis(self): + return self.emphasis + def set_emphasis(self, emphasis): + self.emphasis = emphasis + def add_emphasis(self, value): + self.emphasis.append(value) + def insert_emphasis_at(self, index, value): + self.emphasis.insert(index, value) + def replace_emphasis_at(self, index, value): + self.emphasis[index] = value + def get_computeroutput(self): + return self.computeroutput + def set_computeroutput(self, computeroutput): + self.computeroutput = computeroutput + def add_computeroutput(self, value): + self.computeroutput.append(value) + def insert_computeroutput_at(self, index, value): + self.computeroutput.insert(index, value) + def replace_computeroutput_at(self, index, value): + self.computeroutput[index] = value + def get_subscript(self): + return self.subscript + def set_subscript(self, subscript): + self.subscript = subscript + def add_subscript(self, value): + self.subscript.append(value) + def insert_subscript_at(self, index, value): + self.subscript.insert(index, value) + def replace_subscript_at(self, index, value): + self.subscript[index] = value + def get_superscript(self): + return self.superscript + def set_superscript(self, superscript): + self.superscript = superscript + def add_superscript(self, value): + self.superscript.append(value) + def insert_superscript_at(self, index, value): + self.superscript.insert(index, value) + def replace_superscript_at(self, index, value): + self.superscript[index] = value + def get_center(self): + return self.center + def set_center(self, center): + self.center = center + def add_center(self, value): + self.center.append(value) + def insert_center_at(self, index, value): + self.center.insert(index, value) + def replace_center_at(self, index, value): + self.center[index] = value + def get_small(self): + return self.small + def set_small(self, small): + self.small = small + def add_small(self, value): + self.small.append(value) + def insert_small_at(self, index, value): + self.small.insert(index, value) + def replace_small_at(self, index, value): + self.small[index] = value + def get_htmlonly(self): + return self.htmlonly + def set_htmlonly(self, htmlonly): + self.htmlonly = htmlonly + def add_htmlonly(self, value): + self.htmlonly.append(value) + def insert_htmlonly_at(self, index, value): + self.htmlonly.insert(index, value) + def replace_htmlonly_at(self, index, value): + self.htmlonly[index] = value + def get_manonly(self): + return self.manonly + def set_manonly(self, manonly): + self.manonly = manonly + def add_manonly(self, value): + self.manonly.append(value) + def insert_manonly_at(self, index, value): + self.manonly.insert(index, value) + def replace_manonly_at(self, index, value): + self.manonly[index] = value + def get_xmlonly(self): + return self.xmlonly + def set_xmlonly(self, xmlonly): + self.xmlonly = xmlonly + def add_xmlonly(self, value): + self.xmlonly.append(value) + def insert_xmlonly_at(self, index, value): + self.xmlonly.insert(index, value) + def replace_xmlonly_at(self, index, value): + self.xmlonly[index] = value + def get_rtfonly(self): + return self.rtfonly + def set_rtfonly(self, rtfonly): + self.rtfonly = rtfonly + def add_rtfonly(self, value): + self.rtfonly.append(value) + def insert_rtfonly_at(self, index, value): + self.rtfonly.insert(index, value) + def replace_rtfonly_at(self, index, value): + self.rtfonly[index] = value + def get_latexonly(self): + return self.latexonly + def set_latexonly(self, latexonly): + self.latexonly = latexonly + def add_latexonly(self, value): + self.latexonly.append(value) + def insert_latexonly_at(self, index, value): + self.latexonly.insert(index, value) + def replace_latexonly_at(self, index, value): + self.latexonly[index] = value + def get_dot(self): + return self.dot + def set_dot(self, dot): + self.dot = dot + def add_dot(self, value): + self.dot.append(value) + def insert_dot_at(self, index, value): + self.dot.insert(index, value) + def replace_dot_at(self, index, value): + self.dot[index] = value + def get_msc(self): + return self.msc + def set_msc(self, msc): + self.msc = msc + def add_msc(self, value): + self.msc.append(value) + def insert_msc_at(self, index, value): + self.msc.insert(index, value) + def replace_msc_at(self, index, value): + self.msc[index] = value + def get_anchor(self): + return self.anchor + def set_anchor(self, anchor): + self.anchor = anchor + def add_anchor(self, value): + self.anchor.append(value) + def insert_anchor_at(self, index, value): + self.anchor.insert(index, value) + def replace_anchor_at(self, index, value): + self.anchor[index] = value + def get_formula(self): + return self.formula + def set_formula(self, formula): + self.formula = formula + def add_formula(self, value): + self.formula.append(value) + def insert_formula_at(self, index, value): + self.formula.insert(index, value) + def replace_formula_at(self, index, value): + self.formula[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_at(self, index, value): + self.ref.insert(index, value) + def replace_ref_at(self, index, value): + self.ref[index] = value + def get_copy(self): + return self.copy + def set_copy(self, copy): + self.copy = copy + def add_copy(self, value): + self.copy.append(value) + def insert_copy_at(self, index, value): + self.copy.insert(index, value) + def replace_copy_at(self, index, value): + self.copy[index] = value + def get_trademark(self): + return self.trademark + def set_trademark(self, trademark): + self.trademark = trademark + def add_trademark(self, value): + self.trademark.append(value) + def insert_trademark_at(self, index, value): + self.trademark.insert(index, value) + def replace_trademark_at(self, index, value): + self.trademark[index] = value + def get_registered(self): + return self.registered + def set_registered(self, registered): + self.registered = registered + def add_registered(self, value): + self.registered.append(value) + def insert_registered_at(self, index, value): + self.registered.insert(index, value) + def replace_registered_at(self, index, value): + self.registered[index] = value + def get_lsquo(self): + return self.lsquo + def set_lsquo(self, lsquo): + self.lsquo = lsquo + def add_lsquo(self, value): + self.lsquo.append(value) + def insert_lsquo_at(self, index, value): + self.lsquo.insert(index, value) + def replace_lsquo_at(self, index, value): + self.lsquo[index] = value + def get_rsquo(self): + return self.rsquo + def set_rsquo(self, rsquo): + self.rsquo = rsquo + def add_rsquo(self, value): + self.rsquo.append(value) + def insert_rsquo_at(self, index, value): + self.rsquo.insert(index, value) + def replace_rsquo_at(self, index, value): + self.rsquo[index] = value + def get_ldquo(self): + return self.ldquo + def set_ldquo(self, ldquo): + self.ldquo = ldquo + def add_ldquo(self, value): + self.ldquo.append(value) + def insert_ldquo_at(self, index, value): + self.ldquo.insert(index, value) + def replace_ldquo_at(self, index, value): + self.ldquo[index] = value + def get_rdquo(self): + return self.rdquo + def set_rdquo(self, rdquo): + self.rdquo = rdquo + def add_rdquo(self, value): + self.rdquo.append(value) + def insert_rdquo_at(self, index, value): + self.rdquo.insert(index, value) + def replace_rdquo_at(self, index, value): + self.rdquo[index] = value + def get_ndash(self): + return self.ndash + def set_ndash(self, ndash): + self.ndash = ndash + def add_ndash(self, value): + self.ndash.append(value) + def insert_ndash_at(self, index, value): + self.ndash.insert(index, value) + def replace_ndash_at(self, index, value): + self.ndash[index] = value + def get_mdash(self): + return self.mdash + def set_mdash(self, mdash): + self.mdash = mdash + def add_mdash(self, value): + self.mdash.append(value) + def insert_mdash_at(self, index, value): + self.mdash.insert(index, value) + def replace_mdash_at(self, index, value): + self.mdash[index] = value + def get_umlaut(self): + return self.umlaut + def set_umlaut(self, umlaut): + self.umlaut = umlaut + def add_umlaut(self, value): + self.umlaut.append(value) + def insert_umlaut_at(self, index, value): + self.umlaut.insert(index, value) + def replace_umlaut_at(self, index, value): + self.umlaut[index] = value + def get_acute(self): + return self.acute + def set_acute(self, acute): + self.acute = acute + def add_acute(self, value): + self.acute.append(value) + def insert_acute_at(self, index, value): + self.acute.insert(index, value) + def replace_acute_at(self, index, value): + self.acute[index] = value + def get_grave(self): + return self.grave + def set_grave(self, grave): + self.grave = grave + def add_grave(self, value): + self.grave.append(value) + def insert_grave_at(self, index, value): + self.grave.insert(index, value) + def replace_grave_at(self, index, value): + self.grave[index] = value + def get_circ(self): + return self.circ + def set_circ(self, circ): + self.circ = circ + def add_circ(self, value): + self.circ.append(value) + def insert_circ_at(self, index, value): + self.circ.insert(index, value) + def replace_circ_at(self, index, value): + self.circ[index] = value + def get_slash(self): + return self.slash + def set_slash(self, slash): + self.slash = slash + def add_slash(self, value): + self.slash.append(value) + def insert_slash_at(self, index, value): + self.slash.insert(index, value) + def replace_slash_at(self, index, value): + self.slash[index] = value + def get_tilde(self): + return self.tilde + def set_tilde(self, tilde): + self.tilde = tilde + def add_tilde(self, value): + self.tilde.append(value) + def insert_tilde_at(self, index, value): + self.tilde.insert(index, value) + def replace_tilde_at(self, index, value): + self.tilde[index] = value + def get_cedil(self): + return self.cedil + def set_cedil(self, cedil): + self.cedil = cedil + def add_cedil(self, value): + self.cedil.append(value) + def insert_cedil_at(self, index, value): + self.cedil.insert(index, value) + def replace_cedil_at(self, index, value): + self.cedil[index] = value + def get_ring(self): + return self.ring + def set_ring(self, ring): + self.ring = ring + def add_ring(self, value): + self.ring.append(value) + def insert_ring_at(self, index, value): + self.ring.insert(index, value) + def replace_ring_at(self, index, value): + self.ring[index] = value + def get_szlig(self): + return self.szlig + def set_szlig(self, szlig): + self.szlig = szlig + def add_szlig(self, value): + self.szlig.append(value) + def insert_szlig_at(self, index, value): + self.szlig.insert(index, value) + def replace_szlig_at(self, index, value): + self.szlig[index] = value + def get_nonbreakablespace(self): + return self.nonbreakablespace + def set_nonbreakablespace(self, nonbreakablespace): + self.nonbreakablespace = nonbreakablespace + def add_nonbreakablespace(self, value): + self.nonbreakablespace.append(value) + def insert_nonbreakablespace_at(self, index, value): + self.nonbreakablespace.insert(index, value) + def replace_nonbreakablespace_at(self, index, value): + self.nonbreakablespace[index] = value + def get_aelig(self): + return self.aelig + def set_aelig(self, aelig): + self.aelig = aelig + def add_aelig(self, value): + self.aelig.append(value) + def insert_aelig_at(self, index, value): + self.aelig.insert(index, value) + def replace_aelig_at(self, index, value): + self.aelig[index] = value + def get_AElig(self): + return self.AElig + def set_AElig(self, AElig): + self.AElig = AElig + def add_AElig(self, value): + self.AElig.append(value) + def insert_AElig_at(self, index, value): + self.AElig.insert(index, value) + def replace_AElig_at(self, index, value): + self.AElig[index] = value + def get_Gamma(self): + return self.Gamma + def set_Gamma(self, Gamma): + self.Gamma = Gamma + def add_Gamma(self, value): + self.Gamma.append(value) + def insert_Gamma_at(self, index, value): + self.Gamma.insert(index, value) + def replace_Gamma_at(self, index, value): + self.Gamma[index] = value + def get_Delta(self): + return self.Delta + def set_Delta(self, Delta): + self.Delta = Delta + def add_Delta(self, value): + self.Delta.append(value) + def insert_Delta_at(self, index, value): + self.Delta.insert(index, value) + def replace_Delta_at(self, index, value): + self.Delta[index] = value + def get_Theta(self): + return self.Theta + def set_Theta(self, Theta): + self.Theta = Theta + def add_Theta(self, value): + self.Theta.append(value) + def insert_Theta_at(self, index, value): + self.Theta.insert(index, value) + def replace_Theta_at(self, index, value): + self.Theta[index] = value + def get_Lambda(self): + return self.Lambda + def set_Lambda(self, Lambda): + self.Lambda = Lambda + def add_Lambda(self, value): + self.Lambda.append(value) + def insert_Lambda_at(self, index, value): + self.Lambda.insert(index, value) + def replace_Lambda_at(self, index, value): + self.Lambda[index] = value + def get_Xi(self): + return self.Xi + def set_Xi(self, Xi): + self.Xi = Xi + def add_Xi(self, value): + self.Xi.append(value) + def insert_Xi_at(self, index, value): + self.Xi.insert(index, value) + def replace_Xi_at(self, index, value): + self.Xi[index] = value + def get_Pi(self): + return self.Pi + def set_Pi(self, Pi): + self.Pi = Pi + def add_Pi(self, value): + self.Pi.append(value) + def insert_Pi_at(self, index, value): + self.Pi.insert(index, value) + def replace_Pi_at(self, index, value): + self.Pi[index] = value + def get_Sigma(self): + return self.Sigma + def set_Sigma(self, Sigma): + self.Sigma = Sigma + def add_Sigma(self, value): + self.Sigma.append(value) + def insert_Sigma_at(self, index, value): + self.Sigma.insert(index, value) + def replace_Sigma_at(self, index, value): + self.Sigma[index] = value + def get_Upsilon(self): + return self.Upsilon + def set_Upsilon(self, Upsilon): + self.Upsilon = Upsilon + def add_Upsilon(self, value): + self.Upsilon.append(value) + def insert_Upsilon_at(self, index, value): + self.Upsilon.insert(index, value) + def replace_Upsilon_at(self, index, value): + self.Upsilon[index] = value + def get_Phi(self): + return self.Phi + def set_Phi(self, Phi): + self.Phi = Phi + def add_Phi(self, value): + self.Phi.append(value) + def insert_Phi_at(self, index, value): + self.Phi.insert(index, value) + def replace_Phi_at(self, index, value): + self.Phi[index] = value + def get_Psi(self): + return self.Psi + def set_Psi(self, Psi): + self.Psi = Psi + def add_Psi(self, value): + self.Psi.append(value) + def insert_Psi_at(self, index, value): + self.Psi.insert(index, value) + def replace_Psi_at(self, index, value): + self.Psi[index] = value + def get_Omega(self): + return self.Omega + def set_Omega(self, Omega): + self.Omega = Omega + def add_Omega(self, value): + self.Omega.append(value) + def insert_Omega_at(self, index, value): + self.Omega.insert(index, value) + def replace_Omega_at(self, index, value): + self.Omega[index] = value + def get_alpha(self): + return self.alpha + def set_alpha(self, alpha): + self.alpha = alpha + def add_alpha(self, value): + self.alpha.append(value) + def insert_alpha_at(self, index, value): + self.alpha.insert(index, value) + def replace_alpha_at(self, index, value): + self.alpha[index] = value + def get_beta(self): + return self.beta + def set_beta(self, beta): + self.beta = beta + def add_beta(self, value): + self.beta.append(value) + def insert_beta_at(self, index, value): + self.beta.insert(index, value) + def replace_beta_at(self, index, value): + self.beta[index] = value + def get_gamma(self): + return self.gamma + def set_gamma(self, gamma): + self.gamma = gamma + def add_gamma(self, value): + self.gamma.append(value) + def insert_gamma_at(self, index, value): + self.gamma.insert(index, value) + def replace_gamma_at(self, index, value): + self.gamma[index] = value + def get_delta(self): + return self.delta + def set_delta(self, delta): + self.delta = delta + def add_delta(self, value): + self.delta.append(value) + def insert_delta_at(self, index, value): + self.delta.insert(index, value) + def replace_delta_at(self, index, value): + self.delta[index] = value + def get_epsilon(self): + return self.epsilon + def set_epsilon(self, epsilon): + self.epsilon = epsilon + def add_epsilon(self, value): + self.epsilon.append(value) + def insert_epsilon_at(self, index, value): + self.epsilon.insert(index, value) + def replace_epsilon_at(self, index, value): + self.epsilon[index] = value + def get_zeta(self): + return self.zeta + def set_zeta(self, zeta): + self.zeta = zeta + def add_zeta(self, value): + self.zeta.append(value) + def insert_zeta_at(self, index, value): + self.zeta.insert(index, value) + def replace_zeta_at(self, index, value): + self.zeta[index] = value + def get_eta(self): + return self.eta + def set_eta(self, eta): + self.eta = eta + def add_eta(self, value): + self.eta.append(value) + def insert_eta_at(self, index, value): + self.eta.insert(index, value) + def replace_eta_at(self, index, value): + self.eta[index] = value + def get_theta(self): + return self.theta + def set_theta(self, theta): + self.theta = theta + def add_theta(self, value): + self.theta.append(value) + def insert_theta_at(self, index, value): + self.theta.insert(index, value) + def replace_theta_at(self, index, value): + self.theta[index] = value + def get_iota(self): + return self.iota + def set_iota(self, iota): + self.iota = iota + def add_iota(self, value): + self.iota.append(value) + def insert_iota_at(self, index, value): + self.iota.insert(index, value) + def replace_iota_at(self, index, value): + self.iota[index] = value + def get_kappa(self): + return self.kappa + def set_kappa(self, kappa): + self.kappa = kappa + def add_kappa(self, value): + self.kappa.append(value) + def insert_kappa_at(self, index, value): + self.kappa.insert(index, value) + def replace_kappa_at(self, index, value): + self.kappa[index] = value + def get_lambda(self): + return self.lambda_ + def set_lambda(self, lambda_): + self.lambda_ = lambda_ + def add_lambda(self, value): + self.lambda_.append(value) + def insert_lambda_at(self, index, value): + self.lambda_.insert(index, value) + def replace_lambda_at(self, index, value): + self.lambda_[index] = value + def get_mu(self): + return self.mu + def set_mu(self, mu): + self.mu = mu + def add_mu(self, value): + self.mu.append(value) + def insert_mu_at(self, index, value): + self.mu.insert(index, value) + def replace_mu_at(self, index, value): + self.mu[index] = value + def get_nu(self): + return self.nu + def set_nu(self, nu): + self.nu = nu + def add_nu(self, value): + self.nu.append(value) + def insert_nu_at(self, index, value): + self.nu.insert(index, value) + def replace_nu_at(self, index, value): + self.nu[index] = value + def get_xi(self): + return self.xi + def set_xi(self, xi): + self.xi = xi + def add_xi(self, value): + self.xi.append(value) + def insert_xi_at(self, index, value): + self.xi.insert(index, value) + def replace_xi_at(self, index, value): + self.xi[index] = value + def get_pi(self): + return self.pi + def set_pi(self, pi): + self.pi = pi + def add_pi(self, value): + self.pi.append(value) + def insert_pi_at(self, index, value): + self.pi.insert(index, value) + def replace_pi_at(self, index, value): + self.pi[index] = value + def get_rho(self): + return self.rho + def set_rho(self, rho): + self.rho = rho + def add_rho(self, value): + self.rho.append(value) + def insert_rho_at(self, index, value): + self.rho.insert(index, value) + def replace_rho_at(self, index, value): + self.rho[index] = value + def get_sigma(self): + return self.sigma + def set_sigma(self, sigma): + self.sigma = sigma + def add_sigma(self, value): + self.sigma.append(value) + def insert_sigma_at(self, index, value): + self.sigma.insert(index, value) + def replace_sigma_at(self, index, value): + self.sigma[index] = value + def get_tau(self): + return self.tau + def set_tau(self, tau): + self.tau = tau + def add_tau(self, value): + self.tau.append(value) + def insert_tau_at(self, index, value): + self.tau.insert(index, value) + def replace_tau_at(self, index, value): + self.tau[index] = value + def get_upsilon(self): + return self.upsilon + def set_upsilon(self, upsilon): + self.upsilon = upsilon + def add_upsilon(self, value): + self.upsilon.append(value) + def insert_upsilon_at(self, index, value): + self.upsilon.insert(index, value) + def replace_upsilon_at(self, index, value): + self.upsilon[index] = value + def get_phi(self): + return self.phi + def set_phi(self, phi): + self.phi = phi + def add_phi(self, value): + self.phi.append(value) + def insert_phi_at(self, index, value): + self.phi.insert(index, value) + def replace_phi_at(self, index, value): + self.phi[index] = value + def get_chi(self): + return self.chi + def set_chi(self, chi): + self.chi = chi + def add_chi(self, value): + self.chi.append(value) + def insert_chi_at(self, index, value): + self.chi.insert(index, value) + def replace_chi_at(self, index, value): + self.chi[index] = value + def get_psi(self): + return self.psi + def set_psi(self, psi): + self.psi = psi + def add_psi(self, value): + self.psi.append(value) + def insert_psi_at(self, index, value): + self.psi.insert(index, value) + def replace_psi_at(self, index, value): + self.psi[index] = value + def get_omega(self): + return self.omega + def set_omega(self, omega): + self.omega = omega + def add_omega(self, value): + self.omega.append(value) + def insert_omega_at(self, index, value): + self.omega.insert(index, value) + def replace_omega_at(self, index, value): + self.omega[index] = value + def get_sigmaf(self): + return self.sigmaf + def set_sigmaf(self, sigmaf): + self.sigmaf = sigmaf + def add_sigmaf(self, value): + self.sigmaf.append(value) + def insert_sigmaf_at(self, index, value): + self.sigmaf.insert(index, value) + def replace_sigmaf_at(self, index, value): + self.sigmaf[index] = value + def get_sect(self): + return self.sect + def set_sect(self, sect): + self.sect = sect + def add_sect(self, value): + self.sect.append(value) + def insert_sect_at(self, index, value): + self.sect.insert(index, value) + def replace_sect_at(self, index, value): + self.sect[index] = value + def get_deg(self): + return self.deg + def set_deg(self, deg): + self.deg = deg + def add_deg(self, value): + self.deg.append(value) + def insert_deg_at(self, index, value): + self.deg.insert(index, value) + def replace_deg_at(self, index, value): + self.deg[index] = value + def get_prime(self): + return self.prime + def set_prime(self, prime): + self.prime = prime + def add_prime(self, value): + self.prime.append(value) + def insert_prime_at(self, index, value): + self.prime.insert(index, value) + def replace_prime_at(self, index, value): + self.prime[index] = value + def get_Prime(self): + return self.Prime + def set_Prime(self, Prime): + self.Prime = Prime + def add_Prime(self, value): + self.Prime.append(value) + def insert_Prime_at(self, index, value): + self.Prime.insert(index, value) + def replace_Prime_at(self, index, value): + self.Prime[index] = value + def get_infin(self): + return self.infin + def set_infin(self, infin): + self.infin = infin + def add_infin(self, value): + self.infin.append(value) + def insert_infin_at(self, index, value): + self.infin.insert(index, value) + def replace_infin_at(self, index, value): + self.infin[index] = value + def get_empty(self): + return self.empty + def set_empty(self, empty): + self.empty = empty + def add_empty(self, value): + self.empty.append(value) + def insert_empty_at(self, index, value): + self.empty.insert(index, value) + def replace_empty_at(self, index, value): + self.empty[index] = value + def get_plusmn(self): + return self.plusmn + def set_plusmn(self, plusmn): + self.plusmn = plusmn + def add_plusmn(self, value): + self.plusmn.append(value) + def insert_plusmn_at(self, index, value): + self.plusmn.insert(index, value) + def replace_plusmn_at(self, index, value): + self.plusmn[index] = value + def get_times(self): + return self.times + def set_times(self, times): + self.times = times + def add_times(self, value): + self.times.append(value) + def insert_times_at(self, index, value): + self.times.insert(index, value) + def replace_times_at(self, index, value): + self.times[index] = value + def get_minus(self): + return self.minus + def set_minus(self, minus): + self.minus = minus + def add_minus(self, value): + self.minus.append(value) + def insert_minus_at(self, index, value): + self.minus.insert(index, value) + def replace_minus_at(self, index, value): + self.minus[index] = value + def get_sdot(self): + return self.sdot + def set_sdot(self, sdot): + self.sdot = sdot + def add_sdot(self, value): + self.sdot.append(value) + def insert_sdot_at(self, index, value): + self.sdot.insert(index, value) + def replace_sdot_at(self, index, value): + self.sdot[index] = value + def get_part(self): + return self.part + def set_part(self, part): + self.part = part + def add_part(self, value): + self.part.append(value) + def insert_part_at(self, index, value): + self.part.insert(index, value) + def replace_part_at(self, index, value): + self.part[index] = value + def get_nabla(self): + return self.nabla + def set_nabla(self, nabla): + self.nabla = nabla + def add_nabla(self, value): + self.nabla.append(value) + def insert_nabla_at(self, index, value): + self.nabla.insert(index, value) + def replace_nabla_at(self, index, value): + self.nabla[index] = value + def get_radic(self): + return self.radic + def set_radic(self, radic): + self.radic = radic + def add_radic(self, value): + self.radic.append(value) + def insert_radic_at(self, index, value): + self.radic.insert(index, value) + def replace_radic_at(self, index, value): + self.radic[index] = value + def get_perp(self): + return self.perp + def set_perp(self, perp): + self.perp = perp + def add_perp(self, value): + self.perp.append(value) + def insert_perp_at(self, index, value): + self.perp.insert(index, value) + def replace_perp_at(self, index, value): + self.perp[index] = value + def get_sum(self): + return self.sum + def set_sum(self, sum): + self.sum = sum + def add_sum(self, value): + self.sum.append(value) + def insert_sum_at(self, index, value): + self.sum.insert(index, value) + def replace_sum_at(self, index, value): + self.sum[index] = value + def get_int(self): + return self.int + def set_int(self, int): + self.int = int + def add_int(self, value): + self.int.append(value) + def insert_int_at(self, index, value): + self.int.insert(index, value) + def replace_int_at(self, index, value): + self.int[index] = value + def get_prod(self): + return self.prod + def set_prod(self, prod): + self.prod = prod + def add_prod(self, value): + self.prod.append(value) + def insert_prod_at(self, index, value): + self.prod.insert(index, value) + def replace_prod_at(self, index, value): + self.prod[index] = value + def get_sim(self): + return self.sim + def set_sim(self, sim): + self.sim = sim + def add_sim(self, value): + self.sim.append(value) + def insert_sim_at(self, index, value): + self.sim.insert(index, value) + def replace_sim_at(self, index, value): + self.sim[index] = value + def get_asymp(self): + return self.asymp + def set_asymp(self, asymp): + self.asymp = asymp + def add_asymp(self, value): + self.asymp.append(value) + def insert_asymp_at(self, index, value): + self.asymp.insert(index, value) + def replace_asymp_at(self, index, value): + self.asymp[index] = value + def get_ne(self): + return self.ne + def set_ne(self, ne): + self.ne = ne + def add_ne(self, value): + self.ne.append(value) + def insert_ne_at(self, index, value): + self.ne.insert(index, value) + def replace_ne_at(self, index, value): + self.ne[index] = value + def get_equiv(self): + return self.equiv + def set_equiv(self, equiv): + self.equiv = equiv + def add_equiv(self, value): + self.equiv.append(value) + def insert_equiv_at(self, index, value): + self.equiv.insert(index, value) + def replace_equiv_at(self, index, value): + self.equiv[index] = value + def get_prop(self): + return self.prop + def set_prop(self, prop): + self.prop = prop + def add_prop(self, value): + self.prop.append(value) + def insert_prop_at(self, index, value): + self.prop.insert(index, value) + def replace_prop_at(self, index, value): + self.prop[index] = value + def get_le(self): + return self.le + def set_le(self, le): + self.le = le + def add_le(self, value): + self.le.append(value) + def insert_le_at(self, index, value): + self.le.insert(index, value) + def replace_le_at(self, index, value): + self.le[index] = value + def get_ge(self): + return self.ge + def set_ge(self, ge): + self.ge = ge + def add_ge(self, value): + self.ge.append(value) + def insert_ge_at(self, index, value): + self.ge.insert(index, value) + def replace_ge_at(self, index, value): + self.ge[index] = value + def get_larr(self): + return self.larr + def set_larr(self, larr): + self.larr = larr + def add_larr(self, value): + self.larr.append(value) + def insert_larr_at(self, index, value): + self.larr.insert(index, value) + def replace_larr_at(self, index, value): + self.larr[index] = value + def get_rarr(self): + return self.rarr + def set_rarr(self, rarr): + self.rarr = rarr + def add_rarr(self, value): + self.rarr.append(value) + def insert_rarr_at(self, index, value): + self.rarr.insert(index, value) + def replace_rarr_at(self, index, value): + self.rarr[index] = value + def get_isin(self): + return self.isin + def set_isin(self, isin): + self.isin = isin + def add_isin(self, value): + self.isin.append(value) + def insert_isin_at(self, index, value): + self.isin.insert(index, value) + def replace_isin_at(self, index, value): + self.isin[index] = value + def get_notin(self): + return self.notin + def set_notin(self, notin): + self.notin = notin + def add_notin(self, value): + self.notin.append(value) + def insert_notin_at(self, index, value): + self.notin.insert(index, value) + def replace_notin_at(self, index, value): + self.notin[index] = value + def get_lceil(self): + return self.lceil + def set_lceil(self, lceil): + self.lceil = lceil + def add_lceil(self, value): + self.lceil.append(value) + def insert_lceil_at(self, index, value): + self.lceil.insert(index, value) + def replace_lceil_at(self, index, value): + self.lceil[index] = value + def get_rceil(self): + return self.rceil + def set_rceil(self, rceil): + self.rceil = rceil + def add_rceil(self, value): + self.rceil.append(value) + def insert_rceil_at(self, index, value): + self.rceil.insert(index, value) + def replace_rceil_at(self, index, value): + self.rceil[index] = value + def get_lfloor(self): + return self.lfloor + def set_lfloor(self, lfloor): + self.lfloor = lfloor + def add_lfloor(self, value): + self.lfloor.append(value) + def insert_lfloor_at(self, index, value): + self.lfloor.insert(index, value) + def replace_lfloor_at(self, index, value): + self.lfloor[index] = value + def get_rfloor(self): + return self.rfloor + def set_rfloor(self, rfloor): + self.rfloor = rfloor + def add_rfloor(self, value): + self.rfloor.append(value) + def insert_rfloor_at(self, index, value): + self.rfloor.insert(index, value) + def replace_rfloor_at(self, index, value): + self.rfloor[index] = value + def get_id(self): + return self.id + def set_id(self, id): + self.id = id + def get_valueOf_(self): return self.valueOf_ + def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def hasContent_(self): + if ( + self.ulink or + self.bold or + self.emphasis or + self.computeroutput or + self.subscript or + self.superscript or + self.center or + self.small or + self.htmlonly or + self.manonly or + self.xmlonly or + self.rtfonly or + self.latexonly or + self.dot or + self.msc or + self.anchor or + self.formula or + self.ref or + self.copy or + self.trademark or + self.registered or + self.lsquo or + self.rsquo or + self.ldquo or + self.rdquo or + self.ndash or + self.mdash or + self.umlaut or + self.acute or + self.grave or + self.circ or + self.slash or + self.tilde or + self.cedil or + self.ring or + self.szlig or + self.nonbreakablespace or + self.aelig or + self.AElig or + self.Gamma or + self.Delta or + self.Theta or + self.Lambda or + self.Xi or + self.Pi or + self.Sigma or + self.Upsilon or + self.Phi or + self.Psi or + self.Omega or + self.alpha or + self.beta or + self.gamma or + self.delta or + self.epsilon or + self.zeta or + self.eta or + self.theta or + self.iota or + self.kappa or + self.lambda_ or + self.mu or + self.nu or + self.xi or + self.pi or + self.rho or + self.sigma or + self.tau or + self.upsilon or + self.phi or + self.chi or + self.psi or + self.omega or + self.sigmaf or + self.sect or + self.deg or + self.prime or + self.Prime or + self.infin or + self.empty or + self.plusmn or + self.times or + self.minus or + self.sdot or + self.part or + self.nabla or + self.radic or + self.perp or + self.sum or + self.int or + self.prod or + self.sim or + self.asymp or + self.ne or + self.equiv or + self.prop or + self.le or + self.ge or + self.larr or + self.rarr or + self.isin or + self.notin or + self.lceil or + self.rceil or + self.lfloor or + self.rfloor or + (1 if type(self.valueOf_) in [int,float] else self.valueOf_) or + self.content_ + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docTocItemType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docTocItemType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docTocItemType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docTocItemType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docTocItemType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docTocItemType'): + if self.id is not None and 'id' not in already_processed: + already_processed.add('id') + outfile.write(' id=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.id), input_name='id')), )) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docTocItemType', fromsubclass_=False, pretty_print=True): + if not fromsubclass_: + for item_ in self.content_: + item_.export(outfile, level, item_.name, namespaceprefix_, pretty_print=pretty_print) + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for ulink_ in self.ulink: + namespaceprefix_ = self.ulink_nsprefix_ + ':' if (UseCapturedNS_ and self.ulink_nsprefix_) else '' + ulink_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ulink', pretty_print=pretty_print) + for bold_ in self.bold: + namespaceprefix_ = self.bold_nsprefix_ + ':' if (UseCapturedNS_ and self.bold_nsprefix_) else '' + bold_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='bold', pretty_print=pretty_print) + for emphasis_ in self.emphasis: + namespaceprefix_ = self.emphasis_nsprefix_ + ':' if (UseCapturedNS_ and self.emphasis_nsprefix_) else '' + emphasis_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='emphasis', pretty_print=pretty_print) + for computeroutput_ in self.computeroutput: + namespaceprefix_ = self.computeroutput_nsprefix_ + ':' if (UseCapturedNS_ and self.computeroutput_nsprefix_) else '' + computeroutput_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='computeroutput', pretty_print=pretty_print) + for subscript_ in self.subscript: + namespaceprefix_ = self.subscript_nsprefix_ + ':' if (UseCapturedNS_ and self.subscript_nsprefix_) else '' + subscript_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='subscript', pretty_print=pretty_print) + for superscript_ in self.superscript: + namespaceprefix_ = self.superscript_nsprefix_ + ':' if (UseCapturedNS_ and self.superscript_nsprefix_) else '' + superscript_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='superscript', pretty_print=pretty_print) + for center_ in self.center: + namespaceprefix_ = self.center_nsprefix_ + ':' if (UseCapturedNS_ and self.center_nsprefix_) else '' + center_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='center', pretty_print=pretty_print) + for small_ in self.small: + namespaceprefix_ = self.small_nsprefix_ + ':' if (UseCapturedNS_ and self.small_nsprefix_) else '' + small_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='small', pretty_print=pretty_print) + for htmlonly_ in self.htmlonly: + namespaceprefix_ = self.htmlonly_nsprefix_ + ':' if (UseCapturedNS_ and self.htmlonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%shtmlonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(htmlonly_), input_name='htmlonly')), namespaceprefix_ , eol_)) + for manonly_ in self.manonly: + namespaceprefix_ = self.manonly_nsprefix_ + ':' if (UseCapturedNS_ and self.manonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%smanonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(manonly_), input_name='manonly')), namespaceprefix_ , eol_)) + for xmlonly_ in self.xmlonly: + namespaceprefix_ = self.xmlonly_nsprefix_ + ':' if (UseCapturedNS_ and self.xmlonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%sxmlonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(xmlonly_), input_name='xmlonly')), namespaceprefix_ , eol_)) + for rtfonly_ in self.rtfonly: + namespaceprefix_ = self.rtfonly_nsprefix_ + ':' if (UseCapturedNS_ and self.rtfonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%srtfonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(rtfonly_), input_name='rtfonly')), namespaceprefix_ , eol_)) + for latexonly_ in self.latexonly: + namespaceprefix_ = self.latexonly_nsprefix_ + ':' if (UseCapturedNS_ and self.latexonly_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%slatexonly>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(latexonly_), input_name='latexonly')), namespaceprefix_ , eol_)) + for dot_ in self.dot: + namespaceprefix_ = self.dot_nsprefix_ + ':' if (UseCapturedNS_ and self.dot_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%sdot>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(dot_), input_name='dot')), namespaceprefix_ , eol_)) + for msc_ in self.msc: + namespaceprefix_ = self.msc_nsprefix_ + ':' if (UseCapturedNS_ and self.msc_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%smsc>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(msc_), input_name='msc')), namespaceprefix_ , eol_)) + for anchor_ in self.anchor: + namespaceprefix_ = self.anchor_nsprefix_ + ':' if (UseCapturedNS_ and self.anchor_nsprefix_) else '' + anchor_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='anchor', pretty_print=pretty_print) + for formula_ in self.formula: + namespaceprefix_ = self.formula_nsprefix_ + ':' if (UseCapturedNS_ and self.formula_nsprefix_) else '' + formula_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='formula', pretty_print=pretty_print) + for ref_ in self.ref: + namespaceprefix_ = self.ref_nsprefix_ + ':' if (UseCapturedNS_ and self.ref_nsprefix_) else '' + ref_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ref', pretty_print=pretty_print) + for copy_ in self.copy: + namespaceprefix_ = self.copy_nsprefix_ + ':' if (UseCapturedNS_ and self.copy_nsprefix_) else '' + copy_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='copy', pretty_print=pretty_print) + for trademark_ in self.trademark: + namespaceprefix_ = self.trademark_nsprefix_ + ':' if (UseCapturedNS_ and self.trademark_nsprefix_) else '' + trademark_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='trademark', pretty_print=pretty_print) + for registered_ in self.registered: + namespaceprefix_ = self.registered_nsprefix_ + ':' if (UseCapturedNS_ and self.registered_nsprefix_) else '' + registered_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='registered', pretty_print=pretty_print) + for lsquo_ in self.lsquo: + namespaceprefix_ = self.lsquo_nsprefix_ + ':' if (UseCapturedNS_ and self.lsquo_nsprefix_) else '' + lsquo_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='lsquo', pretty_print=pretty_print) + for rsquo_ in self.rsquo: + namespaceprefix_ = self.rsquo_nsprefix_ + ':' if (UseCapturedNS_ and self.rsquo_nsprefix_) else '' + rsquo_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rsquo', pretty_print=pretty_print) + for ldquo_ in self.ldquo: + namespaceprefix_ = self.ldquo_nsprefix_ + ':' if (UseCapturedNS_ and self.ldquo_nsprefix_) else '' + ldquo_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ldquo', pretty_print=pretty_print) + for rdquo_ in self.rdquo: + namespaceprefix_ = self.rdquo_nsprefix_ + ':' if (UseCapturedNS_ and self.rdquo_nsprefix_) else '' + rdquo_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rdquo', pretty_print=pretty_print) + for ndash_ in self.ndash: + namespaceprefix_ = self.ndash_nsprefix_ + ':' if (UseCapturedNS_ and self.ndash_nsprefix_) else '' + ndash_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ndash', pretty_print=pretty_print) + for mdash_ in self.mdash: + namespaceprefix_ = self.mdash_nsprefix_ + ':' if (UseCapturedNS_ and self.mdash_nsprefix_) else '' + mdash_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='mdash', pretty_print=pretty_print) + for umlaut_ in self.umlaut: + namespaceprefix_ = self.umlaut_nsprefix_ + ':' if (UseCapturedNS_ and self.umlaut_nsprefix_) else '' + umlaut_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='umlaut', pretty_print=pretty_print) + for acute_ in self.acute: + namespaceprefix_ = self.acute_nsprefix_ + ':' if (UseCapturedNS_ and self.acute_nsprefix_) else '' + acute_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='acute', pretty_print=pretty_print) + for grave_ in self.grave: + namespaceprefix_ = self.grave_nsprefix_ + ':' if (UseCapturedNS_ and self.grave_nsprefix_) else '' + grave_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='grave', pretty_print=pretty_print) + for circ_ in self.circ: + namespaceprefix_ = self.circ_nsprefix_ + ':' if (UseCapturedNS_ and self.circ_nsprefix_) else '' + circ_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='circ', pretty_print=pretty_print) + for slash_ in self.slash: + namespaceprefix_ = self.slash_nsprefix_ + ':' if (UseCapturedNS_ and self.slash_nsprefix_) else '' + slash_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='slash', pretty_print=pretty_print) + for tilde_ in self.tilde: + namespaceprefix_ = self.tilde_nsprefix_ + ':' if (UseCapturedNS_ and self.tilde_nsprefix_) else '' + tilde_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='tilde', pretty_print=pretty_print) + for cedil_ in self.cedil: + namespaceprefix_ = self.cedil_nsprefix_ + ':' if (UseCapturedNS_ and self.cedil_nsprefix_) else '' + cedil_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='cedil', pretty_print=pretty_print) + for ring_ in self.ring: + namespaceprefix_ = self.ring_nsprefix_ + ':' if (UseCapturedNS_ and self.ring_nsprefix_) else '' + ring_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ring', pretty_print=pretty_print) + for szlig_ in self.szlig: + namespaceprefix_ = self.szlig_nsprefix_ + ':' if (UseCapturedNS_ and self.szlig_nsprefix_) else '' + szlig_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='szlig', pretty_print=pretty_print) + for nonbreakablespace_ in self.nonbreakablespace: + namespaceprefix_ = self.nonbreakablespace_nsprefix_ + ':' if (UseCapturedNS_ and self.nonbreakablespace_nsprefix_) else '' + nonbreakablespace_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='nonbreakablespace', pretty_print=pretty_print) + for aelig_ in self.aelig: + namespaceprefix_ = self.aelig_nsprefix_ + ':' if (UseCapturedNS_ and self.aelig_nsprefix_) else '' + aelig_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='aelig', pretty_print=pretty_print) + for AElig_ in self.AElig: + namespaceprefix_ = self.AElig_nsprefix_ + ':' if (UseCapturedNS_ and self.AElig_nsprefix_) else '' + AElig_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='AElig', pretty_print=pretty_print) + for Gamma_ in self.Gamma: + namespaceprefix_ = self.Gamma_nsprefix_ + ':' if (UseCapturedNS_ and self.Gamma_nsprefix_) else '' + Gamma_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Gamma', pretty_print=pretty_print) + for Delta_ in self.Delta: + namespaceprefix_ = self.Delta_nsprefix_ + ':' if (UseCapturedNS_ and self.Delta_nsprefix_) else '' + Delta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Delta', pretty_print=pretty_print) + for Theta_ in self.Theta: + namespaceprefix_ = self.Theta_nsprefix_ + ':' if (UseCapturedNS_ and self.Theta_nsprefix_) else '' + Theta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Theta', pretty_print=pretty_print) + for Lambda_ in self.Lambda: + namespaceprefix_ = self.Lambda_nsprefix_ + ':' if (UseCapturedNS_ and self.Lambda_nsprefix_) else '' + Lambda_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Lambda', pretty_print=pretty_print) + for Xi_ in self.Xi: + namespaceprefix_ = self.Xi_nsprefix_ + ':' if (UseCapturedNS_ and self.Xi_nsprefix_) else '' + Xi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Xi', pretty_print=pretty_print) + for Pi_ in self.Pi: + namespaceprefix_ = self.Pi_nsprefix_ + ':' if (UseCapturedNS_ and self.Pi_nsprefix_) else '' + Pi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Pi', pretty_print=pretty_print) + for Sigma_ in self.Sigma: + namespaceprefix_ = self.Sigma_nsprefix_ + ':' if (UseCapturedNS_ and self.Sigma_nsprefix_) else '' + Sigma_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Sigma', pretty_print=pretty_print) + for Upsilon_ in self.Upsilon: + namespaceprefix_ = self.Upsilon_nsprefix_ + ':' if (UseCapturedNS_ and self.Upsilon_nsprefix_) else '' + Upsilon_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Upsilon', pretty_print=pretty_print) + for Phi_ in self.Phi: + namespaceprefix_ = self.Phi_nsprefix_ + ':' if (UseCapturedNS_ and self.Phi_nsprefix_) else '' + Phi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Phi', pretty_print=pretty_print) + for Psi_ in self.Psi: + namespaceprefix_ = self.Psi_nsprefix_ + ':' if (UseCapturedNS_ and self.Psi_nsprefix_) else '' + Psi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Psi', pretty_print=pretty_print) + for Omega_ in self.Omega: + namespaceprefix_ = self.Omega_nsprefix_ + ':' if (UseCapturedNS_ and self.Omega_nsprefix_) else '' + Omega_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Omega', pretty_print=pretty_print) + for alpha_ in self.alpha: + namespaceprefix_ = self.alpha_nsprefix_ + ':' if (UseCapturedNS_ and self.alpha_nsprefix_) else '' + alpha_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='alpha', pretty_print=pretty_print) + for beta_ in self.beta: + namespaceprefix_ = self.beta_nsprefix_ + ':' if (UseCapturedNS_ and self.beta_nsprefix_) else '' + beta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='beta', pretty_print=pretty_print) + for gamma_ in self.gamma: + namespaceprefix_ = self.gamma_nsprefix_ + ':' if (UseCapturedNS_ and self.gamma_nsprefix_) else '' + gamma_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='gamma', pretty_print=pretty_print) + for delta_ in self.delta: + namespaceprefix_ = self.delta_nsprefix_ + ':' if (UseCapturedNS_ and self.delta_nsprefix_) else '' + delta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='delta', pretty_print=pretty_print) + for epsilon_ in self.epsilon: + namespaceprefix_ = self.epsilon_nsprefix_ + ':' if (UseCapturedNS_ and self.epsilon_nsprefix_) else '' + epsilon_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='epsilon', pretty_print=pretty_print) + for zeta_ in self.zeta: + namespaceprefix_ = self.zeta_nsprefix_ + ':' if (UseCapturedNS_ and self.zeta_nsprefix_) else '' + zeta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='zeta', pretty_print=pretty_print) + for eta_ in self.eta: + namespaceprefix_ = self.eta_nsprefix_ + ':' if (UseCapturedNS_ and self.eta_nsprefix_) else '' + eta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='eta', pretty_print=pretty_print) + for theta_ in self.theta: + namespaceprefix_ = self.theta_nsprefix_ + ':' if (UseCapturedNS_ and self.theta_nsprefix_) else '' + theta_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='theta', pretty_print=pretty_print) + for iota_ in self.iota: + namespaceprefix_ = self.iota_nsprefix_ + ':' if (UseCapturedNS_ and self.iota_nsprefix_) else '' + iota_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='iota', pretty_print=pretty_print) + for kappa_ in self.kappa: + namespaceprefix_ = self.kappa_nsprefix_ + ':' if (UseCapturedNS_ and self.kappa_nsprefix_) else '' + kappa_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='kappa', pretty_print=pretty_print) + for lambda_ in self.lambda_: + namespaceprefix_ = self.lambda__nsprefix_ + ':' if (UseCapturedNS_ and self.lambda__nsprefix_) else '' + lambda_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='lambda', pretty_print=pretty_print) + for mu_ in self.mu: + namespaceprefix_ = self.mu_nsprefix_ + ':' if (UseCapturedNS_ and self.mu_nsprefix_) else '' + mu_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='mu', pretty_print=pretty_print) + for nu_ in self.nu: + namespaceprefix_ = self.nu_nsprefix_ + ':' if (UseCapturedNS_ and self.nu_nsprefix_) else '' + nu_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='nu', pretty_print=pretty_print) + for xi_ in self.xi: + namespaceprefix_ = self.xi_nsprefix_ + ':' if (UseCapturedNS_ and self.xi_nsprefix_) else '' + xi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='xi', pretty_print=pretty_print) + for pi_ in self.pi: + namespaceprefix_ = self.pi_nsprefix_ + ':' if (UseCapturedNS_ and self.pi_nsprefix_) else '' + pi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='pi', pretty_print=pretty_print) + for rho_ in self.rho: + namespaceprefix_ = self.rho_nsprefix_ + ':' if (UseCapturedNS_ and self.rho_nsprefix_) else '' + rho_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rho', pretty_print=pretty_print) + for sigma_ in self.sigma: + namespaceprefix_ = self.sigma_nsprefix_ + ':' if (UseCapturedNS_ and self.sigma_nsprefix_) else '' + sigma_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sigma', pretty_print=pretty_print) + for tau_ in self.tau: + namespaceprefix_ = self.tau_nsprefix_ + ':' if (UseCapturedNS_ and self.tau_nsprefix_) else '' + tau_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='tau', pretty_print=pretty_print) + for upsilon_ in self.upsilon: + namespaceprefix_ = self.upsilon_nsprefix_ + ':' if (UseCapturedNS_ and self.upsilon_nsprefix_) else '' + upsilon_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='upsilon', pretty_print=pretty_print) + for phi_ in self.phi: + namespaceprefix_ = self.phi_nsprefix_ + ':' if (UseCapturedNS_ and self.phi_nsprefix_) else '' + phi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='phi', pretty_print=pretty_print) + for chi_ in self.chi: + namespaceprefix_ = self.chi_nsprefix_ + ':' if (UseCapturedNS_ and self.chi_nsprefix_) else '' + chi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='chi', pretty_print=pretty_print) + for psi_ in self.psi: + namespaceprefix_ = self.psi_nsprefix_ + ':' if (UseCapturedNS_ and self.psi_nsprefix_) else '' + psi_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='psi', pretty_print=pretty_print) + for omega_ in self.omega: + namespaceprefix_ = self.omega_nsprefix_ + ':' if (UseCapturedNS_ and self.omega_nsprefix_) else '' + omega_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='omega', pretty_print=pretty_print) + for sigmaf_ in self.sigmaf: + namespaceprefix_ = self.sigmaf_nsprefix_ + ':' if (UseCapturedNS_ and self.sigmaf_nsprefix_) else '' + sigmaf_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sigmaf', pretty_print=pretty_print) + for sect_ in self.sect: + namespaceprefix_ = self.sect_nsprefix_ + ':' if (UseCapturedNS_ and self.sect_nsprefix_) else '' + sect_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sect', pretty_print=pretty_print) + for deg_ in self.deg: + namespaceprefix_ = self.deg_nsprefix_ + ':' if (UseCapturedNS_ and self.deg_nsprefix_) else '' + deg_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='deg', pretty_print=pretty_print) + for prime_ in self.prime: + namespaceprefix_ = self.prime_nsprefix_ + ':' if (UseCapturedNS_ and self.prime_nsprefix_) else '' + prime_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='prime', pretty_print=pretty_print) + for Prime_ in self.Prime: + namespaceprefix_ = self.Prime_nsprefix_ + ':' if (UseCapturedNS_ and self.Prime_nsprefix_) else '' + Prime_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Prime', pretty_print=pretty_print) + for infin_ in self.infin: + namespaceprefix_ = self.infin_nsprefix_ + ':' if (UseCapturedNS_ and self.infin_nsprefix_) else '' + infin_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='infin', pretty_print=pretty_print) + for empty_ in self.empty: + namespaceprefix_ = self.empty_nsprefix_ + ':' if (UseCapturedNS_ and self.empty_nsprefix_) else '' + empty_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='empty', pretty_print=pretty_print) + for plusmn_ in self.plusmn: + namespaceprefix_ = self.plusmn_nsprefix_ + ':' if (UseCapturedNS_ and self.plusmn_nsprefix_) else '' + plusmn_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='plusmn', pretty_print=pretty_print) + for times_ in self.times: + namespaceprefix_ = self.times_nsprefix_ + ':' if (UseCapturedNS_ and self.times_nsprefix_) else '' + times_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='times', pretty_print=pretty_print) + for minus_ in self.minus: + namespaceprefix_ = self.minus_nsprefix_ + ':' if (UseCapturedNS_ and self.minus_nsprefix_) else '' + minus_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='minus', pretty_print=pretty_print) + for sdot_ in self.sdot: + namespaceprefix_ = self.sdot_nsprefix_ + ':' if (UseCapturedNS_ and self.sdot_nsprefix_) else '' + sdot_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sdot', pretty_print=pretty_print) + for part_ in self.part: + namespaceprefix_ = self.part_nsprefix_ + ':' if (UseCapturedNS_ and self.part_nsprefix_) else '' + part_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='part', pretty_print=pretty_print) + for nabla_ in self.nabla: + namespaceprefix_ = self.nabla_nsprefix_ + ':' if (UseCapturedNS_ and self.nabla_nsprefix_) else '' + nabla_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='nabla', pretty_print=pretty_print) + for radic_ in self.radic: + namespaceprefix_ = self.radic_nsprefix_ + ':' if (UseCapturedNS_ and self.radic_nsprefix_) else '' + radic_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='radic', pretty_print=pretty_print) + for perp_ in self.perp: + namespaceprefix_ = self.perp_nsprefix_ + ':' if (UseCapturedNS_ and self.perp_nsprefix_) else '' + perp_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='perp', pretty_print=pretty_print) + for sum_ in self.sum: + namespaceprefix_ = self.sum_nsprefix_ + ':' if (UseCapturedNS_ and self.sum_nsprefix_) else '' + sum_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sum', pretty_print=pretty_print) + for int_ in self.int: + namespaceprefix_ = self.int_nsprefix_ + ':' if (UseCapturedNS_ and self.int_nsprefix_) else '' + int_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='int', pretty_print=pretty_print) + for prod_ in self.prod: + namespaceprefix_ = self.prod_nsprefix_ + ':' if (UseCapturedNS_ and self.prod_nsprefix_) else '' + prod_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='prod', pretty_print=pretty_print) + for sim_ in self.sim: + namespaceprefix_ = self.sim_nsprefix_ + ':' if (UseCapturedNS_ and self.sim_nsprefix_) else '' + sim_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sim', pretty_print=pretty_print) + for asymp_ in self.asymp: + namespaceprefix_ = self.asymp_nsprefix_ + ':' if (UseCapturedNS_ and self.asymp_nsprefix_) else '' + asymp_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='asymp', pretty_print=pretty_print) + for ne_ in self.ne: + namespaceprefix_ = self.ne_nsprefix_ + ':' if (UseCapturedNS_ and self.ne_nsprefix_) else '' + ne_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ne', pretty_print=pretty_print) + for equiv_ in self.equiv: + namespaceprefix_ = self.equiv_nsprefix_ + ':' if (UseCapturedNS_ and self.equiv_nsprefix_) else '' + equiv_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='equiv', pretty_print=pretty_print) + for prop_ in self.prop: + namespaceprefix_ = self.prop_nsprefix_ + ':' if (UseCapturedNS_ and self.prop_nsprefix_) else '' + prop_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='prop', pretty_print=pretty_print) + for le_ in self.le: + namespaceprefix_ = self.le_nsprefix_ + ':' if (UseCapturedNS_ and self.le_nsprefix_) else '' + le_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='le', pretty_print=pretty_print) + for ge_ in self.ge: + namespaceprefix_ = self.ge_nsprefix_ + ':' if (UseCapturedNS_ and self.ge_nsprefix_) else '' + ge_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ge', pretty_print=pretty_print) + for larr_ in self.larr: + namespaceprefix_ = self.larr_nsprefix_ + ':' if (UseCapturedNS_ and self.larr_nsprefix_) else '' + larr_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='larr', pretty_print=pretty_print) + for rarr_ in self.rarr: + namespaceprefix_ = self.rarr_nsprefix_ + ':' if (UseCapturedNS_ and self.rarr_nsprefix_) else '' + rarr_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rarr', pretty_print=pretty_print) + for isin_ in self.isin: + namespaceprefix_ = self.isin_nsprefix_ + ':' if (UseCapturedNS_ and self.isin_nsprefix_) else '' + isin_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='isin', pretty_print=pretty_print) + for notin_ in self.notin: + namespaceprefix_ = self.notin_nsprefix_ + ':' if (UseCapturedNS_ and self.notin_nsprefix_) else '' + notin_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='notin', pretty_print=pretty_print) + for lceil_ in self.lceil: + namespaceprefix_ = self.lceil_nsprefix_ + ':' if (UseCapturedNS_ and self.lceil_nsprefix_) else '' + lceil_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='lceil', pretty_print=pretty_print) + for rceil_ in self.rceil: + namespaceprefix_ = self.rceil_nsprefix_ + ':' if (UseCapturedNS_ and self.rceil_nsprefix_) else '' + rceil_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rceil', pretty_print=pretty_print) + for lfloor_ in self.lfloor: + namespaceprefix_ = self.lfloor_nsprefix_ + ':' if (UseCapturedNS_ and self.lfloor_nsprefix_) else '' + lfloor_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='lfloor', pretty_print=pretty_print) + for rfloor_ in self.rfloor: + namespaceprefix_ = self.rfloor_nsprefix_ + ':' if (UseCapturedNS_ and self.rfloor_nsprefix_) else '' + rfloor_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='rfloor', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + self.valueOf_ = get_all_text_(node) + if node.text is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', node.text) + self.content_.append(obj_) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('id', node) + if value is not None and 'id' not in already_processed: + already_processed.add('id') + self.id = value + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'ulink': + obj_ = docURLLink.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ulink', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ulink'): + self.add_ulink(obj_.value) + elif hasattr(self, 'set_ulink'): + self.set_ulink(obj_.value) + elif nodeName_ == 'bold': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'bold', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_bold'): + self.add_bold(obj_.value) + elif hasattr(self, 'set_bold'): + self.set_bold(obj_.value) + elif nodeName_ == 'emphasis': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'emphasis', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_emphasis'): + self.add_emphasis(obj_.value) + elif hasattr(self, 'set_emphasis'): + self.set_emphasis(obj_.value) + elif nodeName_ == 'computeroutput': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'computeroutput', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_computeroutput'): + self.add_computeroutput(obj_.value) + elif hasattr(self, 'set_computeroutput'): + self.set_computeroutput(obj_.value) + elif nodeName_ == 'subscript': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'subscript', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_subscript'): + self.add_subscript(obj_.value) + elif hasattr(self, 'set_subscript'): + self.set_subscript(obj_.value) + elif nodeName_ == 'superscript': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'superscript', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_superscript'): + self.add_superscript(obj_.value) + elif hasattr(self, 'set_superscript'): + self.set_superscript(obj_.value) + elif nodeName_ == 'center': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'center', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_center'): + self.add_center(obj_.value) + elif hasattr(self, 'set_center'): + self.set_center(obj_.value) + elif nodeName_ == 'small': + obj_ = docMarkupType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'small', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_small'): + self.add_small(obj_.value) + elif hasattr(self, 'set_small'): + self.set_small(obj_.value) + elif nodeName_ == 'htmlonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'htmlonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'htmlonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'htmlonly', valuestr_) + self.content_.append(obj_) + self.htmlonly_nsprefix_ = child_.prefix + elif nodeName_ == 'manonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'manonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'manonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'manonly', valuestr_) + self.content_.append(obj_) + self.manonly_nsprefix_ = child_.prefix + elif nodeName_ == 'xmlonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'xmlonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'xmlonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'xmlonly', valuestr_) + self.content_.append(obj_) + self.xmlonly_nsprefix_ = child_.prefix + elif nodeName_ == 'rtfonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'rtfonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'rtfonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'rtfonly', valuestr_) + self.content_.append(obj_) + self.rtfonly_nsprefix_ = child_.prefix + elif nodeName_ == 'latexonly' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'latexonly') + valuestr_ = self.gds_validate_string(valuestr_, node, 'latexonly') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'latexonly', valuestr_) + self.content_.append(obj_) + self.latexonly_nsprefix_ = child_.prefix + elif nodeName_ == 'dot' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'dot') + valuestr_ = self.gds_validate_string(valuestr_, node, 'dot') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'dot', valuestr_) + self.content_.append(obj_) + self.dot_nsprefix_ = child_.prefix + elif nodeName_ == 'msc' and child_.text is not None: + valuestr_ = child_.text + valuestr_ = self.gds_parse_string(valuestr_, node, 'msc') + valuestr_ = self.gds_validate_string(valuestr_, node, 'msc') + obj_ = self.mixedclass_(MixedContainer.CategorySimple, + MixedContainer.TypeString, 'msc', valuestr_) + self.content_.append(obj_) + self.msc_nsprefix_ = child_.prefix + elif nodeName_ == 'anchor': + obj_ = docAnchorType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'anchor', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_anchor'): + self.add_anchor(obj_.value) + elif hasattr(self, 'set_anchor'): + self.set_anchor(obj_.value) + elif nodeName_ == 'formula': + obj_ = docFormulaType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'formula', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_formula'): + self.add_formula(obj_.value) + elif hasattr(self, 'set_formula'): + self.set_formula(obj_.value) + elif nodeName_ == 'ref': + obj_ = docRefTextType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ref', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ref'): + self.add_ref(obj_.value) + elif hasattr(self, 'set_ref'): + self.set_ref(obj_.value) + elif nodeName_ == 'copy': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'copy', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_copy'): + self.add_copy(obj_.value) + elif hasattr(self, 'set_copy'): + self.set_copy(obj_.value) + elif nodeName_ == 'trademark': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'trademark', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_trademark'): + self.add_trademark(obj_.value) + elif hasattr(self, 'set_trademark'): + self.set_trademark(obj_.value) + elif nodeName_ == 'registered': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'registered', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_registered'): + self.add_registered(obj_.value) + elif hasattr(self, 'set_registered'): + self.set_registered(obj_.value) + elif nodeName_ == 'lsquo': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'lsquo', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_lsquo'): + self.add_lsquo(obj_.value) + elif hasattr(self, 'set_lsquo'): + self.set_lsquo(obj_.value) + elif nodeName_ == 'rsquo': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rsquo', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rsquo'): + self.add_rsquo(obj_.value) + elif hasattr(self, 'set_rsquo'): + self.set_rsquo(obj_.value) + elif nodeName_ == 'ldquo': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ldquo', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ldquo'): + self.add_ldquo(obj_.value) + elif hasattr(self, 'set_ldquo'): + self.set_ldquo(obj_.value) + elif nodeName_ == 'rdquo': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rdquo', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rdquo'): + self.add_rdquo(obj_.value) + elif hasattr(self, 'set_rdquo'): + self.set_rdquo(obj_.value) + elif nodeName_ == 'ndash': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ndash', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ndash'): + self.add_ndash(obj_.value) + elif hasattr(self, 'set_ndash'): + self.set_ndash(obj_.value) + elif nodeName_ == 'mdash': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'mdash', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_mdash'): + self.add_mdash(obj_.value) + elif hasattr(self, 'set_mdash'): + self.set_mdash(obj_.value) + elif nodeName_ == 'umlaut': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'umlaut', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_umlaut'): + self.add_umlaut(obj_.value) + elif hasattr(self, 'set_umlaut'): + self.set_umlaut(obj_.value) + elif nodeName_ == 'acute': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'acute', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_acute'): + self.add_acute(obj_.value) + elif hasattr(self, 'set_acute'): + self.set_acute(obj_.value) + elif nodeName_ == 'grave': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'grave', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_grave'): + self.add_grave(obj_.value) + elif hasattr(self, 'set_grave'): + self.set_grave(obj_.value) + elif nodeName_ == 'circ': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'circ', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_circ'): + self.add_circ(obj_.value) + elif hasattr(self, 'set_circ'): + self.set_circ(obj_.value) + elif nodeName_ == 'slash': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'slash', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_slash'): + self.add_slash(obj_.value) + elif hasattr(self, 'set_slash'): + self.set_slash(obj_.value) + elif nodeName_ == 'tilde': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'tilde', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_tilde'): + self.add_tilde(obj_.value) + elif hasattr(self, 'set_tilde'): + self.set_tilde(obj_.value) + elif nodeName_ == 'cedil': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'cedil', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_cedil'): + self.add_cedil(obj_.value) + elif hasattr(self, 'set_cedil'): + self.set_cedil(obj_.value) + elif nodeName_ == 'ring': + obj_ = docCharType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ring', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ring'): + self.add_ring(obj_.value) + elif hasattr(self, 'set_ring'): + self.set_ring(obj_.value) + elif nodeName_ == 'szlig': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'szlig', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_szlig'): + self.add_szlig(obj_.value) + elif hasattr(self, 'set_szlig'): + self.set_szlig(obj_.value) + elif nodeName_ == 'nonbreakablespace': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'nonbreakablespace', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_nonbreakablespace'): + self.add_nonbreakablespace(obj_.value) + elif hasattr(self, 'set_nonbreakablespace'): + self.set_nonbreakablespace(obj_.value) + elif nodeName_ == 'aelig': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'aelig', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_aelig'): + self.add_aelig(obj_.value) + elif hasattr(self, 'set_aelig'): + self.set_aelig(obj_.value) + elif nodeName_ == 'AElig': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'AElig', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_AElig'): + self.add_AElig(obj_.value) + elif hasattr(self, 'set_AElig'): + self.set_AElig(obj_.value) + elif nodeName_ == 'Gamma': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Gamma', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Gamma'): + self.add_Gamma(obj_.value) + elif hasattr(self, 'set_Gamma'): + self.set_Gamma(obj_.value) + elif nodeName_ == 'Delta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Delta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Delta'): + self.add_Delta(obj_.value) + elif hasattr(self, 'set_Delta'): + self.set_Delta(obj_.value) + elif nodeName_ == 'Theta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Theta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Theta'): + self.add_Theta(obj_.value) + elif hasattr(self, 'set_Theta'): + self.set_Theta(obj_.value) + elif nodeName_ == 'Lambda': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Lambda', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Lambda'): + self.add_Lambda(obj_.value) + elif hasattr(self, 'set_Lambda'): + self.set_Lambda(obj_.value) + elif nodeName_ == 'Xi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Xi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Xi'): + self.add_Xi(obj_.value) + elif hasattr(self, 'set_Xi'): + self.set_Xi(obj_.value) + elif nodeName_ == 'Pi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Pi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Pi'): + self.add_Pi(obj_.value) + elif hasattr(self, 'set_Pi'): + self.set_Pi(obj_.value) + elif nodeName_ == 'Sigma': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Sigma', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Sigma'): + self.add_Sigma(obj_.value) + elif hasattr(self, 'set_Sigma'): + self.set_Sigma(obj_.value) + elif nodeName_ == 'Upsilon': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Upsilon', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Upsilon'): + self.add_Upsilon(obj_.value) + elif hasattr(self, 'set_Upsilon'): + self.set_Upsilon(obj_.value) + elif nodeName_ == 'Phi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Phi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Phi'): + self.add_Phi(obj_.value) + elif hasattr(self, 'set_Phi'): + self.set_Phi(obj_.value) + elif nodeName_ == 'Psi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Psi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Psi'): + self.add_Psi(obj_.value) + elif hasattr(self, 'set_Psi'): + self.set_Psi(obj_.value) + elif nodeName_ == 'Omega': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Omega', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Omega'): + self.add_Omega(obj_.value) + elif hasattr(self, 'set_Omega'): + self.set_Omega(obj_.value) + elif nodeName_ == 'alpha': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'alpha', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_alpha'): + self.add_alpha(obj_.value) + elif hasattr(self, 'set_alpha'): + self.set_alpha(obj_.value) + elif nodeName_ == 'beta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'beta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_beta'): + self.add_beta(obj_.value) + elif hasattr(self, 'set_beta'): + self.set_beta(obj_.value) + elif nodeName_ == 'gamma': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'gamma', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_gamma'): + self.add_gamma(obj_.value) + elif hasattr(self, 'set_gamma'): + self.set_gamma(obj_.value) + elif nodeName_ == 'delta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'delta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_delta'): + self.add_delta(obj_.value) + elif hasattr(self, 'set_delta'): + self.set_delta(obj_.value) + elif nodeName_ == 'epsilon': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'epsilon', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_epsilon'): + self.add_epsilon(obj_.value) + elif hasattr(self, 'set_epsilon'): + self.set_epsilon(obj_.value) + elif nodeName_ == 'zeta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'zeta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_zeta'): + self.add_zeta(obj_.value) + elif hasattr(self, 'set_zeta'): + self.set_zeta(obj_.value) + elif nodeName_ == 'eta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'eta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_eta'): + self.add_eta(obj_.value) + elif hasattr(self, 'set_eta'): + self.set_eta(obj_.value) + elif nodeName_ == 'theta': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'theta', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_theta'): + self.add_theta(obj_.value) + elif hasattr(self, 'set_theta'): + self.set_theta(obj_.value) + elif nodeName_ == 'iota': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'iota', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_iota'): + self.add_iota(obj_.value) + elif hasattr(self, 'set_iota'): + self.set_iota(obj_.value) + elif nodeName_ == 'kappa': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'kappa', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_kappa'): + self.add_kappa(obj_.value) + elif hasattr(self, 'set_kappa'): + self.set_kappa(obj_.value) + elif nodeName_ == 'lambda': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'lambda', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_lambda'): + self.add_lambda(obj_.value) + elif hasattr(self, 'set_lambda'): + self.set_lambda(obj_.value) + elif nodeName_ == 'mu': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'mu', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_mu'): + self.add_mu(obj_.value) + elif hasattr(self, 'set_mu'): + self.set_mu(obj_.value) + elif nodeName_ == 'nu': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'nu', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_nu'): + self.add_nu(obj_.value) + elif hasattr(self, 'set_nu'): + self.set_nu(obj_.value) + elif nodeName_ == 'xi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'xi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_xi'): + self.add_xi(obj_.value) + elif hasattr(self, 'set_xi'): + self.set_xi(obj_.value) + elif nodeName_ == 'pi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'pi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_pi'): + self.add_pi(obj_.value) + elif hasattr(self, 'set_pi'): + self.set_pi(obj_.value) + elif nodeName_ == 'rho': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rho', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rho'): + self.add_rho(obj_.value) + elif hasattr(self, 'set_rho'): + self.set_rho(obj_.value) + elif nodeName_ == 'sigma': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sigma', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sigma'): + self.add_sigma(obj_.value) + elif hasattr(self, 'set_sigma'): + self.set_sigma(obj_.value) + elif nodeName_ == 'tau': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'tau', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_tau'): + self.add_tau(obj_.value) + elif hasattr(self, 'set_tau'): + self.set_tau(obj_.value) + elif nodeName_ == 'upsilon': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'upsilon', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_upsilon'): + self.add_upsilon(obj_.value) + elif hasattr(self, 'set_upsilon'): + self.set_upsilon(obj_.value) + elif nodeName_ == 'phi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'phi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_phi'): + self.add_phi(obj_.value) + elif hasattr(self, 'set_phi'): + self.set_phi(obj_.value) + elif nodeName_ == 'chi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'chi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_chi'): + self.add_chi(obj_.value) + elif hasattr(self, 'set_chi'): + self.set_chi(obj_.value) + elif nodeName_ == 'psi': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'psi', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_psi'): + self.add_psi(obj_.value) + elif hasattr(self, 'set_psi'): + self.set_psi(obj_.value) + elif nodeName_ == 'omega': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'omega', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_omega'): + self.add_omega(obj_.value) + elif hasattr(self, 'set_omega'): + self.set_omega(obj_.value) + elif nodeName_ == 'sigmaf': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sigmaf', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sigmaf'): + self.add_sigmaf(obj_.value) + elif hasattr(self, 'set_sigmaf'): + self.set_sigmaf(obj_.value) + elif nodeName_ == 'sect': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sect', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sect'): + self.add_sect(obj_.value) + elif hasattr(self, 'set_sect'): + self.set_sect(obj_.value) + elif nodeName_ == 'deg': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'deg', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_deg'): + self.add_deg(obj_.value) + elif hasattr(self, 'set_deg'): + self.set_deg(obj_.value) + elif nodeName_ == 'prime': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'prime', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_prime'): + self.add_prime(obj_.value) + elif hasattr(self, 'set_prime'): + self.set_prime(obj_.value) + elif nodeName_ == 'Prime': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'Prime', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_Prime'): + self.add_Prime(obj_.value) + elif hasattr(self, 'set_Prime'): + self.set_Prime(obj_.value) + elif nodeName_ == 'infin': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'infin', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_infin'): + self.add_infin(obj_.value) + elif hasattr(self, 'set_infin'): + self.set_infin(obj_.value) + elif nodeName_ == 'empty': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'empty', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_empty'): + self.add_empty(obj_.value) + elif hasattr(self, 'set_empty'): + self.set_empty(obj_.value) + elif nodeName_ == 'plusmn': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'plusmn', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_plusmn'): + self.add_plusmn(obj_.value) + elif hasattr(self, 'set_plusmn'): + self.set_plusmn(obj_.value) + elif nodeName_ == 'times': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'times', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_times'): + self.add_times(obj_.value) + elif hasattr(self, 'set_times'): + self.set_times(obj_.value) + elif nodeName_ == 'minus': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'minus', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_minus'): + self.add_minus(obj_.value) + elif hasattr(self, 'set_minus'): + self.set_minus(obj_.value) + elif nodeName_ == 'sdot': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sdot', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sdot'): + self.add_sdot(obj_.value) + elif hasattr(self, 'set_sdot'): + self.set_sdot(obj_.value) + elif nodeName_ == 'part': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'part', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_part'): + self.add_part(obj_.value) + elif hasattr(self, 'set_part'): + self.set_part(obj_.value) + elif nodeName_ == 'nabla': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'nabla', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_nabla'): + self.add_nabla(obj_.value) + elif hasattr(self, 'set_nabla'): + self.set_nabla(obj_.value) + elif nodeName_ == 'radic': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'radic', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_radic'): + self.add_radic(obj_.value) + elif hasattr(self, 'set_radic'): + self.set_radic(obj_.value) + elif nodeName_ == 'perp': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'perp', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_perp'): + self.add_perp(obj_.value) + elif hasattr(self, 'set_perp'): + self.set_perp(obj_.value) + elif nodeName_ == 'sum': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sum', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sum'): + self.add_sum(obj_.value) + elif hasattr(self, 'set_sum'): + self.set_sum(obj_.value) + elif nodeName_ == 'int': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'int', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_int'): + self.add_int(obj_.value) + elif hasattr(self, 'set_int'): + self.set_int(obj_.value) + elif nodeName_ == 'prod': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'prod', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_prod'): + self.add_prod(obj_.value) + elif hasattr(self, 'set_prod'): + self.set_prod(obj_.value) + elif nodeName_ == 'sim': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'sim', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_sim'): + self.add_sim(obj_.value) + elif hasattr(self, 'set_sim'): + self.set_sim(obj_.value) + elif nodeName_ == 'asymp': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'asymp', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_asymp'): + self.add_asymp(obj_.value) + elif hasattr(self, 'set_asymp'): + self.set_asymp(obj_.value) + elif nodeName_ == 'ne': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ne', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ne'): + self.add_ne(obj_.value) + elif hasattr(self, 'set_ne'): + self.set_ne(obj_.value) + elif nodeName_ == 'equiv': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'equiv', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_equiv'): + self.add_equiv(obj_.value) + elif hasattr(self, 'set_equiv'): + self.set_equiv(obj_.value) + elif nodeName_ == 'prop': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'prop', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_prop'): + self.add_prop(obj_.value) + elif hasattr(self, 'set_prop'): + self.set_prop(obj_.value) + elif nodeName_ == 'le': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'le', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_le'): + self.add_le(obj_.value) + elif hasattr(self, 'set_le'): + self.set_le(obj_.value) + elif nodeName_ == 'ge': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ge', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ge'): + self.add_ge(obj_.value) + elif hasattr(self, 'set_ge'): + self.set_ge(obj_.value) + elif nodeName_ == 'larr': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'larr', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_larr'): + self.add_larr(obj_.value) + elif hasattr(self, 'set_larr'): + self.set_larr(obj_.value) + elif nodeName_ == 'rarr': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rarr', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rarr'): + self.add_rarr(obj_.value) + elif hasattr(self, 'set_rarr'): + self.set_rarr(obj_.value) + elif nodeName_ == 'isin': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'isin', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_isin'): + self.add_isin(obj_.value) + elif hasattr(self, 'set_isin'): + self.set_isin(obj_.value) + elif nodeName_ == 'notin': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'notin', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_notin'): + self.add_notin(obj_.value) + elif hasattr(self, 'set_notin'): + self.set_notin(obj_.value) + elif nodeName_ == 'lceil': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'lceil', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_lceil'): + self.add_lceil(obj_.value) + elif hasattr(self, 'set_lceil'): + self.set_lceil(obj_.value) + elif nodeName_ == 'rceil': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rceil', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rceil'): + self.add_rceil(obj_.value) + elif hasattr(self, 'set_rceil'): + self.set_rceil(obj_.value) + elif nodeName_ == 'lfloor': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'lfloor', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_lfloor'): + self.add_lfloor(obj_.value) + elif hasattr(self, 'set_lfloor'): + self.set_lfloor(obj_.value) + elif nodeName_ == 'rfloor': + obj_ = docEmptyType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'rfloor', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_rfloor'): + self.add_rfloor(obj_.value) + elif hasattr(self, 'set_rfloor'): + self.set_rfloor(obj_.value) + if not fromsubclass_ and child_.tail is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.tail) + self.content_.append(obj_) +# end class docTocItemType + + +class docTocListType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, tocitem=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + if tocitem is None: + self.tocitem = [] + else: + self.tocitem = tocitem + self.tocitem_nsprefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docTocListType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docTocListType.subclass: + return docTocListType.subclass(*args_, **kwargs_) + return docTocListType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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_at(self, index, value): + self.tocitem.insert(index, value) + def replace_tocitem_at(self, index, value): + self.tocitem[index] = value + def hasContent_(self): + if ( + self.tocitem + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docTocListType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docTocListType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docTocListType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docTocListType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docTocListType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docTocListType'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docTocListType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for tocitem_ in self.tocitem: + namespaceprefix_ = self.tocitem_nsprefix_ + ':' if (UseCapturedNS_ and self.tocitem_nsprefix_) else '' + tocitem_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='tocitem', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'tocitem': + obj_ = docTocItemType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.tocitem.append(obj_) + obj_.original_tagname_ = 'tocitem' +# end class docTocListType + + +class docLanguageType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, langid=None, para=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.langid = _cast(None, langid) + self.langid_nsprefix_ = None + if para is None: + self.para = [] + else: + self.para = para + self.para_nsprefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docLanguageType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docLanguageType.subclass: + return docLanguageType.subclass(*args_, **kwargs_) + return docLanguageType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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_at(self, index, value): + self.para.insert(index, value) + def replace_para_at(self, index, value): + self.para[index] = value + def get_langid(self): + return self.langid + def set_langid(self, langid): + self.langid = langid + def hasContent_(self): + if ( + self.para + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docLanguageType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docLanguageType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docLanguageType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docLanguageType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docLanguageType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docLanguageType'): + if self.langid is not None and 'langid' not in already_processed: + already_processed.add('langid') + outfile.write(' langid=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.langid), input_name='langid')), )) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docLanguageType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for para_ in self.para: + namespaceprefix_ = self.para_nsprefix_ + ':' if (UseCapturedNS_ and self.para_nsprefix_) else '' + para_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='para', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('langid', node) + if value is not None and 'langid' not in already_processed: + already_processed.add('langid') + self.langid = value + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'para': + obj_ = docParaType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.para.append(obj_) + obj_.original_tagname_ = 'para' +# end class docLanguageType + + +class docParamListType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, kind=None, parameteritem=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.kind = _cast(None, kind) + self.kind_nsprefix_ = None + if parameteritem is None: + self.parameteritem = [] + else: + self.parameteritem = parameteritem + self.parameteritem_nsprefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docParamListType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docParamListType.subclass: + return docParamListType.subclass(*args_, **kwargs_) + return docParamListType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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_at(self, index, value): + self.parameteritem.insert(index, value) + def replace_parameteritem_at(self, index, value): + self.parameteritem[index] = value + def get_kind(self): + return self.kind + def set_kind(self, kind): + self.kind = kind + def validate_DoxParamListKind(self, value): + # Validate type DoxParamListKind, a restriction on xsd:string. + if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) + return False + value = value + enumerations = ['param', 'retval', 'exception', 'templateparam'] + if value not in enumerations: + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on DoxParamListKind' % {"value" : encode_str_2_3(value), "lineno": lineno} ) + result = False + def hasContent_(self): + if ( + self.parameteritem + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docParamListType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docParamListType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docParamListType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docParamListType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docParamListType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docParamListType'): + if self.kind is not None and 'kind' not in already_processed: + already_processed.add('kind') + outfile.write(' kind=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.kind), input_name='kind')), )) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docParamListType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for parameteritem_ in self.parameteritem: + namespaceprefix_ = self.parameteritem_nsprefix_ + ':' if (UseCapturedNS_ and self.parameteritem_nsprefix_) else '' + parameteritem_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='parameteritem', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('kind', node) + if value is not None and 'kind' not in already_processed: + already_processed.add('kind') + self.kind = value + self.validate_DoxParamListKind(self.kind) # validate type DoxParamListKind + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'parameteritem': + obj_ = docParamListItem.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.parameteritem.append(obj_) + obj_.original_tagname_ = 'parameteritem' +# end class docParamListType + + +class docParamListItem(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, parameternamelist=None, parameterdescription=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + if parameternamelist is None: + self.parameternamelist = [] + else: + self.parameternamelist = parameternamelist + self.parameternamelist_nsprefix_ = None + self.parameterdescription = parameterdescription + self.parameterdescription_nsprefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docParamListItem) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docParamListItem.subclass: + return docParamListItem.subclass(*args_, **kwargs_) + return docParamListItem(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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_at(self, index, value): + self.parameternamelist.insert(index, value) + def replace_parameternamelist_at(self, index, value): + self.parameternamelist[index] = value + def get_parameterdescription(self): + return self.parameterdescription + def set_parameterdescription(self, parameterdescription): + self.parameterdescription = parameterdescription + def hasContent_(self): + if ( + self.parameternamelist or + self.parameterdescription is not None + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docParamListItem', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docParamListItem') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docParamListItem': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docParamListItem') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docParamListItem', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docParamListItem'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docParamListItem', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for parameternamelist_ in self.parameternamelist: + namespaceprefix_ = self.parameternamelist_nsprefix_ + ':' if (UseCapturedNS_ and self.parameternamelist_nsprefix_) else '' + parameternamelist_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='parameternamelist', pretty_print=pretty_print) + if self.parameterdescription is not None: + namespaceprefix_ = self.parameterdescription_nsprefix_ + ':' if (UseCapturedNS_ and self.parameterdescription_nsprefix_) else '' + self.parameterdescription.export(outfile, level, namespaceprefix_, namespacedef_='', name_='parameterdescription', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'parameternamelist': + obj_ = docParamNameList.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.parameternamelist.append(obj_) + obj_.original_tagname_ = 'parameternamelist' + elif nodeName_ == 'parameterdescription': + obj_ = descriptionType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.parameterdescription = obj_ + obj_.original_tagname_ = 'parameterdescription' +# end class docParamListItem + + +class docParamNameList(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, parametertype=None, parametername=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + if parametertype is None: + self.parametertype = [] + else: + self.parametertype = parametertype + self.parametertype_nsprefix_ = None + if parametername is None: + self.parametername = [] + else: + self.parametername = parametername + self.parametername_nsprefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docParamNameList) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docParamNameList.subclass: + return docParamNameList.subclass(*args_, **kwargs_) + return docParamNameList(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + def get_parametertype(self): + return self.parametertype + def set_parametertype(self, parametertype): + self.parametertype = parametertype + def add_parametertype(self, value): + self.parametertype.append(value) + def insert_parametertype_at(self, index, value): + self.parametertype.insert(index, value) + def replace_parametertype_at(self, index, value): + self.parametertype[index] = value + 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_at(self, index, value): + self.parametername.insert(index, value) + def replace_parametername_at(self, index, value): + self.parametername[index] = value + def hasContent_(self): + if ( + self.parametertype or + self.parametername + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docParamNameList', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docParamNameList') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docParamNameList': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docParamNameList') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docParamNameList', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docParamNameList'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docParamNameList', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for parametertype_ in self.parametertype: + namespaceprefix_ = self.parametertype_nsprefix_ + ':' if (UseCapturedNS_ and self.parametertype_nsprefix_) else '' + parametertype_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='parametertype', pretty_print=pretty_print) + for parametername_ in self.parametername: + namespaceprefix_ = self.parametername_nsprefix_ + ':' if (UseCapturedNS_ and self.parametername_nsprefix_) else '' + parametername_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='parametername', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'parametertype': + obj_ = docParamType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.parametertype.append(obj_) + obj_.original_tagname_ = 'parametertype' + elif nodeName_ == 'parametername': + obj_ = docParamName.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.parametername.append(obj_) + obj_.original_tagname_ = 'parametername' +# end class docParamNameList + + +class docParamType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, ref=None, valueOf_=None, mixedclass_=None, content_=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.ref = ref + self.ref_nsprefix_ = None + self.valueOf_ = valueOf_ + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + self.valueOf_ = valueOf_ + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docParamType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docParamType.subclass: + return docParamType.subclass(*args_, **kwargs_) + return docParamType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + def get_ref(self): + return self.ref + def set_ref(self, ref): + self.ref = ref + def get_valueOf_(self): return self.valueOf_ + def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def hasContent_(self): + if ( + self.ref is not None or + (1 if type(self.valueOf_) in [int,float] else self.valueOf_) or + self.content_ + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docParamType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docParamType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docParamType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docParamType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docParamType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docParamType'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docParamType', fromsubclass_=False, pretty_print=True): + if not fromsubclass_: + for item_ in self.content_: + item_.export(outfile, level, item_.name, namespaceprefix_, pretty_print=pretty_print) + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.ref is not None: + namespaceprefix_ = self.ref_nsprefix_ + ':' if (UseCapturedNS_ and self.ref_nsprefix_) else '' + self.ref.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ref', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + self.valueOf_ = get_all_text_(node) + if node.text is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', node.text) + self.content_.append(obj_) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'ref': + obj_ = refTextType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ref', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ref'): + self.add_ref(obj_.value) + elif hasattr(self, 'set_ref'): + self.set_ref(obj_.value) + if not fromsubclass_ and child_.tail is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.tail) + self.content_.append(obj_) +# end class docParamType + + +class docParamName(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, direction=None, ref=None, valueOf_=None, mixedclass_=None, content_=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.direction = _cast(None, direction) + self.direction_nsprefix_ = None + self.ref = ref + self.ref_nsprefix_ = None + self.valueOf_ = valueOf_ + if mixedclass_ is None: + self.mixedclass_ = MixedContainer + else: + self.mixedclass_ = mixedclass_ + if content_ is None: + self.content_ = [] + else: + self.content_ = content_ + self.valueOf_ = valueOf_ + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docParamName) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docParamName.subclass: + return docParamName.subclass(*args_, **kwargs_) + return docParamName(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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 get_valueOf_(self): return self.valueOf_ + def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ + def validate_DoxParamDir(self, value): + # Validate type DoxParamDir, a restriction on xsd:string. + if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) + return False + value = value + enumerations = ['in', 'out', 'inout'] + if value not in enumerations: + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on DoxParamDir' % {"value" : encode_str_2_3(value), "lineno": lineno} ) + result = False + def hasContent_(self): + if ( + self.ref is not None or + (1 if type(self.valueOf_) in [int,float] else self.valueOf_) or + self.content_ + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docParamName', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docParamName') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docParamName': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docParamName') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docParamName', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docParamName'): + if self.direction is not None and 'direction' not in already_processed: + already_processed.add('direction') + outfile.write(' direction=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.direction), input_name='direction')), )) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docParamName', fromsubclass_=False, pretty_print=True): + if not fromsubclass_: + for item_ in self.content_: + item_.export(outfile, level, item_.name, namespaceprefix_, pretty_print=pretty_print) + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.ref is not None: + namespaceprefix_ = self.ref_nsprefix_ + ':' if (UseCapturedNS_ and self.ref_nsprefix_) else '' + self.ref.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ref', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + self.valueOf_ = get_all_text_(node) + if node.text is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', node.text) + self.content_.append(obj_) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('direction', node) + if value is not None and 'direction' not in already_processed: + already_processed.add('direction') + self.direction = value + self.validate_DoxParamDir(self.direction) # validate type DoxParamDir + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'ref': + obj_ = refTextType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + obj_ = self.mixedclass_(MixedContainer.CategoryComplex, + MixedContainer.TypeNone, 'ref', obj_) + self.content_.append(obj_) + if hasattr(self, 'add_ref'): + self.add_ref(obj_.value) + elif hasattr(self, 'set_ref'): + self.set_ref(obj_.value) + if not fromsubclass_ and child_.tail is not None: + obj_ = self.mixedclass_(MixedContainer.CategoryText, + MixedContainer.TypeNone, '', child_.tail) + self.content_.append(obj_) +# end class docParamName + + +class docXRefSectType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, id=None, xreftitle=None, xrefdescription=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.id = _cast(None, id) + self.id_nsprefix_ = None + if xreftitle is None: + self.xreftitle = [] + else: + self.xreftitle = xreftitle + self.xreftitle_nsprefix_ = None + self.xrefdescription = xrefdescription + self.xrefdescription_nsprefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docXRefSectType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docXRefSectType.subclass: + return docXRefSectType.subclass(*args_, **kwargs_) + return docXRefSectType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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_at(self, index, value): + self.xreftitle.insert(index, value) + def replace_xreftitle_at(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 hasContent_(self): + if ( + self.xreftitle or + self.xrefdescription is not None + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docXRefSectType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docXRefSectType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docXRefSectType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docXRefSectType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docXRefSectType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docXRefSectType'): + if self.id is not None and 'id' not in already_processed: + already_processed.add('id') + outfile.write(' id=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.id), input_name='id')), )) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docXRefSectType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for xreftitle_ in self.xreftitle: + namespaceprefix_ = self.xreftitle_nsprefix_ + ':' if (UseCapturedNS_ and self.xreftitle_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%sxreftitle>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(xreftitle_), input_name='xreftitle')), namespaceprefix_ , eol_)) + if self.xrefdescription is not None: + namespaceprefix_ = self.xrefdescription_nsprefix_ + ':' if (UseCapturedNS_ and self.xrefdescription_nsprefix_) else '' + self.xrefdescription.export(outfile, level, namespaceprefix_, namespacedef_='', name_='xrefdescription', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('id', node) + if value is not None and 'id' not in already_processed: + already_processed.add('id') + self.id = value + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'xreftitle': + value_ = child_.text + value_ = self.gds_parse_string(value_, node, 'xreftitle') + value_ = self.gds_validate_string(value_, node, 'xreftitle') + self.xreftitle.append(value_) + self.xreftitle_nsprefix_ = child_.prefix + elif nodeName_ == 'xrefdescription': + obj_ = descriptionType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.xrefdescription = obj_ + obj_.original_tagname_ = 'xrefdescription' +# end class docXRefSectType + + +class docCopyType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, link=None, para=None, sect1=None, internal=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.link = _cast(None, link) + self.link_nsprefix_ = None + if para is None: + self.para = [] + else: + self.para = para + self.para_nsprefix_ = None + if sect1 is None: + self.sect1 = [] + else: + self.sect1 = sect1 + self.sect1_nsprefix_ = None + self.internal = internal + self.internal_nsprefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docCopyType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docCopyType.subclass: + return docCopyType.subclass(*args_, **kwargs_) + return docCopyType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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_at(self, index, value): + self.para.insert(index, value) + def replace_para_at(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_at(self, index, value): + self.sect1.insert(index, value) + def replace_sect1_at(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 hasContent_(self): + if ( + self.para or + self.sect1 or + self.internal is not None + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docCopyType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docCopyType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docCopyType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docCopyType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docCopyType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docCopyType'): + if self.link is not None and 'link' not in already_processed: + already_processed.add('link') + outfile.write(' link=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.link), input_name='link')), )) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docCopyType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for para_ in self.para: + namespaceprefix_ = self.para_nsprefix_ + ':' if (UseCapturedNS_ and self.para_nsprefix_) else '' + para_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='para', pretty_print=pretty_print) + for sect1_ in self.sect1: + namespaceprefix_ = self.sect1_nsprefix_ + ':' if (UseCapturedNS_ and self.sect1_nsprefix_) else '' + sect1_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='sect1', pretty_print=pretty_print) + if self.internal is not None: + namespaceprefix_ = self.internal_nsprefix_ + ':' if (UseCapturedNS_ and self.internal_nsprefix_) else '' + self.internal.export(outfile, level, namespaceprefix_, namespacedef_='', name_='internal', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('link', node) + if value is not None and 'link' not in already_processed: + already_processed.add('link') + self.link = value + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'para': + obj_ = docParaType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.para.append(obj_) + obj_.original_tagname_ = 'para' + elif nodeName_ == 'sect1': + obj_ = docSect1Type.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.sect1.append(obj_) + obj_.original_tagname_ = 'sect1' + elif nodeName_ == 'internal': + obj_ = docInternalType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.internal = obj_ + obj_.original_tagname_ = 'internal' +# end class docCopyType + + +class docBlockQuoteType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, para=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + if para is None: + self.para = [] + else: + self.para = para + self.para_nsprefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docBlockQuoteType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docBlockQuoteType.subclass: + return docBlockQuoteType.subclass(*args_, **kwargs_) + return docBlockQuoteType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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_at(self, index, value): + self.para.insert(index, value) + def replace_para_at(self, index, value): + self.para[index] = value + def hasContent_(self): + if ( + self.para + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docBlockQuoteType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docBlockQuoteType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docBlockQuoteType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docBlockQuoteType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docBlockQuoteType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docBlockQuoteType'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docBlockQuoteType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for para_ in self.para: + namespaceprefix_ = self.para_nsprefix_ + ':' if (UseCapturedNS_ and self.para_nsprefix_) else '' + para_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='para', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'para': + obj_ = docParaType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.para.append(obj_) + obj_.original_tagname_ = 'para' +# end class docBlockQuoteType + + +class docParBlockType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, para=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + if para is None: + self.para = [] + else: + self.para = para + self.para_nsprefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docParBlockType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docParBlockType.subclass: + return docParBlockType.subclass(*args_, **kwargs_) + return docParBlockType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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_at(self, index, value): + self.para.insert(index, value) + def replace_para_at(self, index, value): + self.para[index] = value + def hasContent_(self): + if ( + self.para + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docParBlockType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docParBlockType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docParBlockType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docParBlockType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docParBlockType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docParBlockType'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docParBlockType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for para_ in self.para: + namespaceprefix_ = self.para_nsprefix_ + ':' if (UseCapturedNS_ and self.para_nsprefix_) else '' + para_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='para', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'para': + obj_ = docParaType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.para.append(obj_) + obj_.original_tagname_ = 'para' +# end class docParBlockType + + +class docCharType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, char=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.char = _cast(None, char) + self.char_nsprefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docCharType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docCharType.subclass: + return docCharType.subclass(*args_, **kwargs_) + return docCharType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + def get_char(self): + return self.char + def set_char(self, char): + self.char = char + def validate_DoxCharRange(self, value): + # Validate type DoxCharRange, a restriction on xsd:string. + if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) + return False + if not self.gds_validate_simple_patterns( + self.validate_DoxCharRange_patterns_, value): + self.gds_collector_.add_message('Value "%s" does not match xsd pattern restrictions: %s' % (encode_str_2_3(value), self.validate_DoxCharRange_patterns_, )) + validate_DoxCharRange_patterns_ = [['^([aeiouncAEIOUNC])$']] + def hasContent_(self): + if ( + + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docCharType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docCharType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docCharType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docCharType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docCharType', pretty_print=pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docCharType'): + if self.char is not None and 'char' not in already_processed: + already_processed.add('char') + outfile.write(' char=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.char), input_name='char')), )) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docCharType', fromsubclass_=False, pretty_print=True): + pass + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('char', node) + if value is not None and 'char' not in already_processed: + already_processed.add('char') + self.char = value + self.validate_DoxCharRange(self.char) # validate type DoxCharRange + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + pass +# end class docCharType + + +class docEmptyType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, docEmptyType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if docEmptyType.subclass: + return docEmptyType.subclass(*args_, **kwargs_) + return docEmptyType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + def hasContent_(self): + if ( + + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docEmptyType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('docEmptyType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'docEmptyType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='docEmptyType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='docEmptyType', pretty_print=pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='docEmptyType'): + pass + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='docEmptyType', fromsubclass_=False, pretty_print=True): + pass + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + pass +# end class docEmptyType + + +GDSClassesMapping = { + 'doxygen': DoxygenType, +} + + +USAGE_TEXT = """ +Usage: python .py [ -s ] +""" + + +def usage(): + print(USAGE_TEXT) + sys.exit(1) + + +def get_root_tag(node): + tag = Tag_pattern_.match(node.tag).groups()[-1] + rootClass = GDSClassesMapping.get(tag) + if rootClass is None: + rootClass = globals().get(tag) + return tag, rootClass + + +def get_required_ns_prefix_defs(rootNode): + '''Get all name space prefix definitions required in this XML doc. + Return a dictionary of definitions and a char string of definitions. + ''' + nsmap = { + prefix: uri + for node in rootNode.iter() + for (prefix, uri) in node.nsmap.items() + if prefix is not None + } + namespacedefs = ' '.join([ + 'xmlns:{}="{}"'.format(prefix, uri) + for prefix, uri in nsmap.items() + ]) + return nsmap, namespacedefs + + +def parse(inFileName, silence=False, print_warnings=True): + global CapturedNsmap_ + gds_collector = GdsCollector_() + parser = None + doc = parsexml_(inFileName, parser) + rootNode = doc.getroot() + rootTag, rootClass = get_root_tag(rootNode) + if rootClass is None: + rootTag = 'DoxygenType' + rootClass = DoxygenType + rootObj = rootClass.factory() + rootObj.build(rootNode, gds_collector_=gds_collector) + CapturedNsmap_, namespacedefs = get_required_ns_prefix_defs(rootNode) + if not SaveElementTreeNode: + doc = None + rootNode = None + if not silence: + sys.stdout.write('\n') + rootObj.export( + sys.stdout, 0, name_=rootTag, + namespacedef_=namespacedefs, + pretty_print=True) + if print_warnings and len(gds_collector.get_messages()) > 0: + separator = ('-' * 50) + '\n' + sys.stderr.write(separator) + sys.stderr.write('----- Warnings -- count: {} -----\n'.format( + len(gds_collector.get_messages()), )) + gds_collector.write_messages(sys.stderr) + sys.stderr.write(separator) + return rootObj + + +def parseEtree(inFileName, silence=False, print_warnings=True, + mapping=None, nsmap=None): + parser = None + doc = parsexml_(inFileName, parser) + gds_collector = GdsCollector_() + rootNode = doc.getroot() + rootTag, rootClass = get_root_tag(rootNode) + if rootClass is None: + rootTag = 'DoxygenType' + rootClass = DoxygenType + rootObj = rootClass.factory() + rootObj.build(rootNode, gds_collector_=gds_collector) + # Enable Python to collect the space used by the DOM. + if mapping is None: + mapping = {} + rootElement = rootObj.to_etree( + None, name_=rootTag, mapping_=mapping, nsmap_=nsmap) + reverse_mapping = rootObj.gds_reverse_node_mapping(mapping) + if not SaveElementTreeNode: + doc = None + rootNode = None + if not silence: + content = etree_.tostring( + rootElement, pretty_print=True, + xml_declaration=True, encoding="utf-8") + sys.stdout.write(str(content)) + sys.stdout.write('\n') + if print_warnings and len(gds_collector.get_messages()) > 0: + separator = ('-' * 50) + '\n' + sys.stderr.write(separator) + sys.stderr.write('----- Warnings -- count: {} -----\n'.format( + len(gds_collector.get_messages()), )) + gds_collector.write_messages(sys.stderr) + sys.stderr.write(separator) + return rootObj, rootElement, mapping, reverse_mapping + + +def parseString(inString, silence=False, print_warnings=True): + '''Parse a string, create the object tree, and export it. + + Arguments: + - inString -- A string. This XML fragment should not start + with an XML declaration containing an encoding. + - silence -- A boolean. If False, export the object. + Returns -- The root object in the tree. + ''' + parser = None + rootNode= parsexmlstring_(inString, parser) + gds_collector = GdsCollector_() + rootTag, rootClass = get_root_tag(rootNode) + if rootClass is None: + rootTag = 'DoxygenType' + rootClass = DoxygenType + rootObj = rootClass.factory() + rootObj.build(rootNode, gds_collector_=gds_collector) + if not SaveElementTreeNode: + rootNode = None + if not silence: + sys.stdout.write('\n') + rootObj.export( + sys.stdout, 0, name_=rootTag, + namespacedef_='') + if print_warnings and len(gds_collector.get_messages()) > 0: + separator = ('-' * 50) + '\n' + sys.stderr.write(separator) + sys.stderr.write('----- Warnings -- count: {} -----\n'.format( + len(gds_collector.get_messages()), )) + gds_collector.write_messages(sys.stderr) + sys.stderr.write(separator) + return rootObj + + +def parseLiteral(inFileName, silence=False, print_warnings=True): + parser = None + doc = parsexml_(inFileName, parser) + gds_collector = GdsCollector_() + rootNode = doc.getroot() + rootTag, rootClass = get_root_tag(rootNode) + if rootClass is None: + rootTag = 'DoxygenType' + rootClass = DoxygenType + rootObj = rootClass.factory() + rootObj.build(rootNode, gds_collector_=gds_collector) + # Enable Python to collect the space used by the DOM. + if not SaveElementTreeNode: + doc = None + rootNode = None + if not silence: + sys.stdout.write('#from compound_parser import *\n\n') + sys.stdout.write('import compound_parser as model_\n\n') + sys.stdout.write('rootObj = model_.rootClass(\n') + rootObj.exportLiteral(sys.stdout, 0, name_=rootTag) + sys.stdout.write(')\n') + if print_warnings and len(gds_collector.get_messages()) > 0: + separator = ('-' * 50) + '\n' + sys.stderr.write(separator) + sys.stderr.write('----- Warnings -- count: {} -----\n'.format( + len(gds_collector.get_messages()), )) + gds_collector.write_messages(sys.stderr) + sys.stderr.write(separator) + return rootObj + + +def main(): + args = sys.argv[1:] + if len(args) == 1: + parse(args[0]) + else: + usage() + + +if __name__ == '__main__': + #import pdb; pdb.set_trace() + main() + +RenameMappings_ = { +} + +__all__ = [ + "DoxygenType", + "childnodeType", + "codelineType", + "compoundRefType", + "compounddefType", + "descriptionType", + "docAnchorType", + "docBlockQuoteType", + "docCaptionType", + "docCharType", + "docCopyType", + "docEmptyType", + "docEntryType", + "docFileType", + "docFormulaType", + "docHeadingType", + "docImageType", + "docIndexEntryType", + "docInternalS1Type", + "docInternalS2Type", + "docInternalS3Type", + "docInternalS4Type", + "docInternalType", + "docLanguageType", + "docListItemType", + "docListType", + "docMarkupType", + "docParBlockType", + "docParaType", + "docParamListItem", + "docParamListType", + "docParamName", + "docParamNameList", + "docParamType", + "docRefTextType", + "docRowType", + "docSect1Type", + "docSect2Type", + "docSect3Type", + "docSect4Type", + "docSimpleSectType", + "docTableType", + "docTitleType", + "docTocItemType", + "docTocListType", + "docURLLink", + "docVarListEntryType", + "docVariableListType", + "docXRefSectType", + "enumvalueType", + "graphType", + "highlightType", + "incType", + "linkType", + "linkedTextType", + "listingType", + "listofallmembersType", + "locationType", + "memberRefType", + "memberdefType", + "nodeType", + "paramType", + "refTextType", + "refType", + "referenceType", + "reimplementType", + "sectiondefType", + "templateparamlistType" +] diff --git a/docs/dalapi/doxypy/parser/index.py b/docs/dalapi/doxypy/parser/index.py new file mode 100644 index 00000000000..4a3bcb7a1f3 --- /dev/null +++ b/docs/dalapi/doxypy/parser/index.py @@ -0,0 +1,1582 @@ +#!/usr/bin/env python + +# file: index.py +#=============================================================================== +# Copyright 2019-2020 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +#=============================================================================== + +# -*- coding: utf-8 -*- + +# +# Generated Fri Apr 24 17:42:25 2020 by generateDS.py version 2.35.21. +# Python 3.6.10 |Anaconda, Inc.| (default, Mar 25 2020, 23:51:54) [GCC 7.3.0] +# +# Command line options: +# ('-o', '../../dalapi/index_parser.py') +# +# Command line arguments: +# index.xsd +# +# Command line: +# /root/miniconda3/envs/spec/bin/generateDS -o "../../dalapi/index_parser.py" index.xsd +# +# Current working directory (os.getcwd()): +# xml +# + +from six.moves import zip_longest +import os +import sys +import re as re_ +import base64 +import datetime as datetime_ +import decimal as decimal_ +from lxml import etree as etree_ + + +Validate_simpletypes_ = True +SaveElementTreeNode = True +if sys.version_info.major == 2: + BaseStrType_ = basestring +else: + BaseStrType_ = str + + +def parsexml_(infile, parser=None, **kwargs): + if parser is None: + # Use the lxml ElementTree compatible parser so that, e.g., + # we ignore comments. + try: + parser = etree_.ETCompatXMLParser() + except AttributeError: + # fallback to xml.etree + parser = etree_.XMLParser() + try: + if isinstance(infile, os.PathLike): + infile = os.path.join(infile) + except AttributeError: + pass + doc = etree_.parse(infile, parser=parser, **kwargs) + return doc + +def parsexmlstring_(instring, parser=None, **kwargs): + if parser is None: + # Use the lxml ElementTree compatible parser so that, e.g., + # we ignore comments. + try: + parser = etree_.ETCompatXMLParser() + except AttributeError: + # fallback to xml.etree + parser = etree_.XMLParser() + element = etree_.fromstring(instring, parser=parser, **kwargs) + return element + +# +# Namespace prefix definition table (and other attributes, too) +# +# The module generatedsnamespaces, if it is importable, must contain +# a dictionary named GeneratedsNamespaceDefs. This Python dictionary +# should map element type names (strings) to XML schema namespace prefix +# definitions. The export method for any class for which there is +# a namespace prefix definition, will export that definition in the +# XML representation of that element. See the export method of +# any generated element type class for an example of the use of this +# table. +# A sample table is: +# +# # File: generatedsnamespaces.py +# +# GenerateDSNamespaceDefs = { +# "ElementtypeA": "http://www.xxx.com/namespaceA", +# "ElementtypeB": "http://www.xxx.com/namespaceB", +# } +# +# Additionally, the generatedsnamespaces module can contain a python +# dictionary named GenerateDSNamespaceTypePrefixes that associates element +# types with the namespace prefixes that are to be added to the +# "xsi:type" attribute value. See the exportAttributes method of +# any generated element type and the generation of "xsi:type" for an +# example of the use of this table. +# An example table: +# +# # File: generatedsnamespaces.py +# +# GenerateDSNamespaceTypePrefixes = { +# "ElementtypeC": "aaa:", +# "ElementtypeD": "bbb:", +# } +# + +try: + from generatedsnamespaces import GenerateDSNamespaceDefs as GenerateDSNamespaceDefs_ +except ImportError: + GenerateDSNamespaceDefs_ = {} +try: + from generatedsnamespaces import GenerateDSNamespaceTypePrefixes as GenerateDSNamespaceTypePrefixes_ +except ImportError: + GenerateDSNamespaceTypePrefixes_ = {} + +# +# You can replace the following class definition by defining an +# importable module named "generatedscollector" containing a class +# named "GdsCollector". See the default class definition below for +# clues about the possible content of that class. +# +try: + from generatedscollector import GdsCollector as GdsCollector_ +except ImportError: + + class GdsCollector_(object): + + def __init__(self, messages=None): + if messages is None: + self.messages = [] + else: + self.messages = messages + + def add_message(self, msg): + self.messages.append(msg) + + def get_messages(self): + return self.messages + + def clear_messages(self): + self.messages = [] + + def print_messages(self): + for msg in self.messages: + print("Warning: {}".format(msg)) + + def write_messages(self, outstream): + for msg in self.messages: + outstream.write("Warning: {}\n".format(msg)) + + +# +# The super-class for enum types +# + +try: + from enum import Enum +except ImportError: + Enum = object + +# +# The root super-class for element type classes +# +# 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(object): + __hash__ = object.__hash__ + tzoff_pattern = re_.compile(r'(\+|-)((0\d|1[0-3]):[0-5]\d|14:00)$') + class _FixedOffsetTZ(datetime_.tzinfo): + def __init__(self, offset, name): + self.__offset = datetime_.timedelta(minutes=offset) + self.__name = name + def utcoffset(self, dt): + return self.__offset + def tzname(self, dt): + return self.__name + def dst(self, dt): + return None + def gds_format_string(self, input_data, input_name=''): + return input_data + def gds_parse_string(self, input_data, node=None, input_name=''): + return input_data + def gds_validate_string(self, input_data, node=None, input_name=''): + if not input_data: + return '' + return input_data + def gds_format_base64(self, input_data, input_name=''): + return base64.b64encode(input_data) + def gds_validate_base64(self, input_data, node=None, input_name=''): + return input_data + def gds_format_integer(self, input_data, input_name=''): + return '%d' % input_data + def gds_parse_integer(self, input_data, node=None, input_name=''): + try: + ival = int(input_data) + except (TypeError, ValueError) as exp: + raise_parse_error(node, 'Requires integer value: %s' % exp) + return ival + def gds_validate_integer(self, input_data, node=None, input_name=''): + try: + value = int(input_data) + except (TypeError, ValueError): + raise_parse_error(node, 'Requires integer value') + return value + def gds_format_integer_list(self, input_data, input_name=''): + return '%s' % ' '.join(input_data) + def gds_validate_integer_list( + self, input_data, node=None, input_name=''): + values = input_data.split() + for value in values: + try: + int(value) + except (TypeError, ValueError): + raise_parse_error(node, 'Requires sequence of integer valuess') + return values + def gds_format_float(self, input_data, input_name=''): + return ('%.15f' % input_data).rstrip('0') + def gds_parse_float(self, input_data, node=None, input_name=''): + try: + fval_ = float(input_data) + except (TypeError, ValueError) as exp: + raise_parse_error(node, 'Requires float or double value: %s' % exp) + return fval_ + def gds_validate_float(self, input_data, node=None, input_name=''): + try: + value = float(input_data) + except (TypeError, ValueError): + raise_parse_error(node, 'Requires float value') + return value + def gds_format_float_list(self, input_data, input_name=''): + return '%s' % ' '.join(input_data) + def gds_validate_float_list( + self, input_data, node=None, input_name=''): + values = input_data.split() + for value in values: + try: + float(value) + except (TypeError, ValueError): + raise_parse_error(node, 'Requires sequence of float values') + return values + def gds_format_decimal(self, input_data, input_name=''): + return_value = '%s' % input_data + if '.' in return_value: + return_value = return_value.rstrip('0') + if return_value.endswith('.'): + return_value = return_value.rstrip('.') + return return_value + def gds_parse_decimal(self, input_data, node=None, input_name=''): + try: + decimal_value = decimal_.Decimal(input_data) + except (TypeError, ValueError): + raise_parse_error(node, 'Requires decimal value') + return decimal_value + def gds_validate_decimal(self, input_data, node=None, input_name=''): + try: + value = decimal_.Decimal(input_data) + except (TypeError, ValueError): + raise_parse_error(node, 'Requires decimal value') + return value + def gds_format_decimal_list(self, input_data, input_name=''): + return ' '.join([self.gds_format_decimal(item) for item in input_data]) + def gds_validate_decimal_list( + self, input_data, node=None, input_name=''): + values = input_data.split() + for value in values: + try: + decimal_.Decimal(value) + except (TypeError, ValueError): + raise_parse_error(node, 'Requires sequence of decimal values') + return values + def gds_format_double(self, input_data, input_name=''): + return '%e' % input_data + def gds_parse_double(self, input_data, node=None, input_name=''): + try: + fval_ = float(input_data) + except (TypeError, ValueError) as exp: + raise_parse_error(node, 'Requires double or float value: %s' % exp) + return fval_ + def gds_validate_double(self, input_data, node=None, input_name=''): + try: + value = float(input_data) + except (TypeError, ValueError): + raise_parse_error(node, 'Requires double or float value') + return value + def gds_format_double_list(self, input_data, input_name=''): + return '%s' % ' '.join(input_data) + def gds_validate_double_list( + self, input_data, node=None, input_name=''): + values = input_data.split() + for value in values: + try: + float(value) + except (TypeError, ValueError): + raise_parse_error( + node, 'Requires sequence of double or float values') + return values + def gds_format_boolean(self, input_data, input_name=''): + return ('%s' % input_data).lower() + def gds_parse_boolean(self, input_data, node=None, input_name=''): + if input_data in ('true', '1'): + bval = True + elif input_data in ('false', '0'): + bval = False + else: + raise_parse_error(node, 'Requires boolean value') + return bval + def gds_validate_boolean(self, input_data, node=None, input_name=''): + if input_data not in (True, 1, False, 0, ): + raise_parse_error( + node, + 'Requires boolean value ' + '(one of True, 1, False, 0)') + return input_data + def gds_format_boolean_list(self, input_data, input_name=''): + return '%s' % ' '.join(input_data) + def gds_validate_boolean_list( + self, input_data, node=None, input_name=''): + values = input_data.split() + for value in values: + if value not in (True, 1, False, 0, ): + raise_parse_error( + node, + 'Requires sequence of boolean values ' + '(one of True, 1, False, 0)') + return values + def gds_validate_datetime(self, input_data, node=None, input_name=''): + return input_data + def gds_format_datetime(self, input_data, input_name=''): + if input_data.microsecond == 0: + _svalue = '%04d-%02d-%02dT%02d:%02d:%02d' % ( + input_data.year, + input_data.month, + input_data.day, + input_data.hour, + input_data.minute, + input_data.second, + ) + else: + _svalue = '%04d-%02d-%02dT%02d:%02d:%02d.%s' % ( + input_data.year, + input_data.month, + input_data.day, + input_data.hour, + input_data.minute, + input_data.second, + ('%f' % (float(input_data.microsecond) / 1000000))[2:], + ) + if input_data.tzinfo is not None: + tzoff = input_data.tzinfo.utcoffset(input_data) + if tzoff is not None: + total_seconds = tzoff.seconds + (86400 * tzoff.days) + if total_seconds == 0: + _svalue += 'Z' + else: + if total_seconds < 0: + _svalue += '-' + total_seconds *= -1 + else: + _svalue += '+' + hours = total_seconds // 3600 + minutes = (total_seconds - (hours * 3600)) // 60 + _svalue += '{0:02d}:{1:02d}'.format(hours, minutes) + return _svalue + @classmethod + def gds_parse_datetime(cls, input_data): + tz = None + if input_data[-1] == 'Z': + tz = GeneratedsSuper._FixedOffsetTZ(0, 'UTC') + input_data = input_data[:-1] + else: + results = GeneratedsSuper.tzoff_pattern.search(input_data) + if results is not None: + tzoff_parts = results.group(2).split(':') + tzoff = int(tzoff_parts[0]) * 60 + int(tzoff_parts[1]) + if results.group(1) == '-': + tzoff *= -1 + tz = GeneratedsSuper._FixedOffsetTZ( + tzoff, results.group(0)) + input_data = input_data[:-6] + time_parts = input_data.split('.') + if len(time_parts) > 1: + micro_seconds = int(float('0.' + time_parts[1]) * 1000000) + input_data = '%s.%s' % ( + time_parts[0], "{}".format(micro_seconds).rjust(6, "0"), ) + dt = datetime_.datetime.strptime( + input_data, '%Y-%m-%dT%H:%M:%S.%f') + else: + dt = datetime_.datetime.strptime( + input_data, '%Y-%m-%dT%H:%M:%S') + dt = dt.replace(tzinfo=tz) + return dt + def gds_validate_date(self, input_data, node=None, input_name=''): + return input_data + def gds_format_date(self, input_data, input_name=''): + _svalue = '%04d-%02d-%02d' % ( + input_data.year, + input_data.month, + input_data.day, + ) + try: + if input_data.tzinfo is not None: + tzoff = input_data.tzinfo.utcoffset(input_data) + if tzoff is not None: + total_seconds = tzoff.seconds + (86400 * tzoff.days) + if total_seconds == 0: + _svalue += 'Z' + else: + if total_seconds < 0: + _svalue += '-' + total_seconds *= -1 + else: + _svalue += '+' + hours = total_seconds // 3600 + minutes = (total_seconds - (hours * 3600)) // 60 + _svalue += '{0:02d}:{1:02d}'.format( + hours, minutes) + except AttributeError: + pass + return _svalue + @classmethod + def gds_parse_date(cls, input_data): + tz = None + if input_data[-1] == 'Z': + tz = GeneratedsSuper._FixedOffsetTZ(0, 'UTC') + input_data = input_data[:-1] + else: + results = GeneratedsSuper.tzoff_pattern.search(input_data) + if results is not None: + tzoff_parts = results.group(2).split(':') + tzoff = int(tzoff_parts[0]) * 60 + int(tzoff_parts[1]) + if results.group(1) == '-': + tzoff *= -1 + tz = GeneratedsSuper._FixedOffsetTZ( + tzoff, results.group(0)) + input_data = input_data[:-6] + dt = datetime_.datetime.strptime(input_data, '%Y-%m-%d') + dt = dt.replace(tzinfo=tz) + return dt.date() + def gds_validate_time(self, input_data, node=None, input_name=''): + return input_data + def gds_format_time(self, input_data, input_name=''): + if input_data.microsecond == 0: + _svalue = '%02d:%02d:%02d' % ( + input_data.hour, + input_data.minute, + input_data.second, + ) + else: + _svalue = '%02d:%02d:%02d.%s' % ( + input_data.hour, + input_data.minute, + input_data.second, + ('%f' % (float(input_data.microsecond) / 1000000))[2:], + ) + if input_data.tzinfo is not None: + tzoff = input_data.tzinfo.utcoffset(input_data) + if tzoff is not None: + total_seconds = tzoff.seconds + (86400 * tzoff.days) + if total_seconds == 0: + _svalue += 'Z' + else: + if total_seconds < 0: + _svalue += '-' + total_seconds *= -1 + else: + _svalue += '+' + hours = total_seconds // 3600 + minutes = (total_seconds - (hours * 3600)) // 60 + _svalue += '{0:02d}:{1:02d}'.format(hours, minutes) + return _svalue + def gds_validate_simple_patterns(self, patterns, target): + # pat is a list of lists of strings/patterns. + # The target value must match at least one of the patterns + # in order for the test to succeed. + found1 = True + for patterns1 in patterns: + found2 = False + for patterns2 in patterns1: + mo = re_.search(patterns2, target) + if mo is not None and len(mo.group(0)) == len(target): + found2 = True + break + if not found2: + found1 = False + break + return found1 + @classmethod + def gds_parse_time(cls, input_data): + tz = None + if input_data[-1] == 'Z': + tz = GeneratedsSuper._FixedOffsetTZ(0, 'UTC') + input_data = input_data[:-1] + else: + results = GeneratedsSuper.tzoff_pattern.search(input_data) + if results is not None: + tzoff_parts = results.group(2).split(':') + tzoff = int(tzoff_parts[0]) * 60 + int(tzoff_parts[1]) + if results.group(1) == '-': + tzoff *= -1 + tz = GeneratedsSuper._FixedOffsetTZ( + tzoff, results.group(0)) + input_data = input_data[:-6] + if len(input_data.split('.')) > 1: + dt = datetime_.datetime.strptime(input_data, '%H:%M:%S.%f') + else: + dt = datetime_.datetime.strptime(input_data, '%H:%M:%S') + dt = dt.replace(tzinfo=tz) + return dt.time() + def gds_check_cardinality_( + self, value, input_name, + min_occurs=0, max_occurs=1, required=None): + if value is None: + length = 0 + elif isinstance(value, list): + length = len(value) + else: + length = 1 + if required is not None : + if required and length < 1: + self.gds_collector_.add_message( + "Required value {}{} is missing".format( + input_name, self.gds_get_node_lineno_())) + if length < min_occurs: + self.gds_collector_.add_message( + "Number of values for {}{} is below " + "the minimum allowed, " + "expected at least {}, found {}".format( + input_name, self.gds_get_node_lineno_(), + min_occurs, length)) + elif length > max_occurs: + self.gds_collector_.add_message( + "Number of values for {}{} is above " + "the maximum allowed, " + "expected at most {}, found {}".format( + input_name, self.gds_get_node_lineno_(), + max_occurs, length)) + def gds_validate_builtin_ST_( + self, validator, value, input_name, + min_occurs=None, max_occurs=None, required=None): + if value is not None: + try: + validator(value, input_name=input_name) + except GDSParseError as parse_error: + self.gds_collector_.add_message(str(parse_error)) + def gds_validate_defined_ST_( + self, validator, value, input_name, + min_occurs=None, max_occurs=None, required=None): + if value is not None: + try: + validator(value) + except GDSParseError as parse_error: + self.gds_collector_.add_message(str(parse_error)) + def gds_str_lower(self, instring): + return instring.lower() + def get_path_(self, node): + path_list = [] + self.get_path_list_(node, path_list) + path_list.reverse() + path = '/'.join(path_list) + return path + Tag_strip_pattern_ = re_.compile(r'\{.*\}') + def get_path_list_(self, node, path_list): + if node is None: + return + tag = GeneratedsSuper.Tag_strip_pattern_.sub('', node.tag) + if tag: + path_list.append(tag) + self.get_path_list_(node.getparent(), path_list) + def get_class_obj_(self, node, default_class=None): + class_obj1 = default_class + if 'xsi' in node.nsmap: + classname = node.get('{%s}type' % node.nsmap['xsi']) + if classname is not None: + names = classname.split(':') + if len(names) == 2: + classname = names[1] + class_obj2 = globals().get(classname) + if class_obj2 is not None: + class_obj1 = class_obj2 + return class_obj1 + def gds_build_any(self, node, type_name=None): + # provide default value in case option --disable-xml is used. + content = "" + content = etree_.tostring(node, encoding="unicode") + return content + @classmethod + def gds_reverse_node_mapping(cls, mapping): + return dict(((v, k) for k, v in mapping.items())) + @staticmethod + def gds_encode(instring): + if sys.version_info.major == 2: + if ExternalEncoding: + encoding = ExternalEncoding + else: + encoding = 'utf-8' + return instring.encode(encoding) + return instring + @staticmethod + def convert_unicode(instring): + if isinstance(instring, str): + result = quote_xml(instring) + elif sys.version_info.major == 2 and isinstance(instring, unicode): + result = quote_xml(instring).encode('utf8') + else: + result = GeneratedsSuper.gds_encode(str(instring)) + return result + def __eq__(self, other): + def excl_select_objs_(obj): + return (obj[0] != 'parent_object_' and + obj[0] != 'gds_collector_') + if type(self) != type(other): + return False + return all(x == y for x, y in zip_longest( + filter(excl_select_objs_, self.__dict__.items()), + filter(excl_select_objs_, other.__dict__.items()))) + def __ne__(self, other): + return not self.__eq__(other) + # Django ETL transform hooks. + def gds_djo_etl_transform(self): + pass + def gds_djo_etl_transform_db_obj(self, dbobj): + pass + # SQLAlchemy ETL transform hooks. + def gds_sqa_etl_transform(self): + return 0, None + def gds_sqa_etl_transform_db_obj(self, dbobj): + pass + def gds_get_node_lineno_(self): + if (hasattr(self, "gds_elementtree_node_") and + self.gds_elementtree_node_ is not None): + return ' near line {}'.format( + self.gds_elementtree_node_.sourceline) + return "" + + + def getSubclassFromModule_(module, class_): + '''Get the subclass of a class from a specific module.''' + name = class_.__name__ + 'Sub' + if hasattr(module, name): + return getattr(module, name) + return None + + +# +# 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 = '' +# Set this to false in order to deactivate during export, the use of +# name space prefixes captured from the input document. +UseCapturedNS_ = True +CapturedNsmap_ = {} +Tag_pattern_ = re_.compile(r'({.*})?(.*)') +String_cleanup_pat_ = re_.compile(r"[\n\r\s]+") +Namespace_extract_pat_ = re_.compile(r'{(.*)}(.*)') +CDATA_pattern_ = re_.compile(r"", re_.DOTALL) + +# Change this to redirect the generated superclass module to use a +# specific subclass module. +CurrentSubclassModule_ = None + +# +# Support/utility functions. +# + + +def showIndent(outfile, level, pretty_print=True): + if pretty_print: + for idx in range(level): + outfile.write(' ') + + +def quote_xml(inStr): + "Escape markup chars, but do not modify CDATA sections." + if not inStr: + return '' + s1 = (isinstance(inStr, BaseStrType_) and inStr or '%s' % inStr) + s2 = '' + pos = 0 + matchobjects = CDATA_pattern_.finditer(s1) + for mo in matchobjects: + s3 = s1[pos:mo.start()] + s2 += quote_xml_aux(s3) + s2 += s1[mo.start():mo.end()] + pos = mo.end() + s3 = s1[pos:] + s2 += quote_xml_aux(s3) + return s2 + + +def quote_xml_aux(inStr): + s1 = inStr.replace('&', '&') + s1 = s1.replace('<', '<') + s1 = s1.replace('>', '>') + return s1 + + +def quote_attrib(inStr): + s1 = (isinstance(inStr, BaseStrType_) 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 + return "'''%s'''" % s1 + else: + if s1.find('"') != -1: + s1 = s1.replace('"', '\\"') + if s1.find('\n') == -1: + return '"%s"' % s1 + return '"""%s"""' % s1 + + +def get_all_text_(node): + if node.text is not None: + text = node.text + else: + text = '' + for child in node: + if child.tail is not None: + text += child.tail + return text + + +def find_attr_value_(attr_name, node): + attrs = node.attrib + attr_parts = attr_name.split(':') + value = None + if len(attr_parts) == 1: + value = attrs.get(attr_name) + elif len(attr_parts) == 2: + prefix, name = attr_parts + namespace = node.nsmap.get(prefix) + if namespace is not None: + value = attrs.get('{%s}%s' % (namespace, name, )) + return value + + +def encode_str_2_3(instr): + return instr + + +class GDSParseError(Exception): + pass + + +def raise_parse_error(node, msg): + if node is not None: + msg = '%s (element %s/line %d)' % (msg, node.tag, node.sourceline, ) + raise GDSParseError(msg) + + +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 + TypeBase64 = 8 + def __init__(self, category, content_type, name, value): + self.category = category + self.content_type = content_type + self.name = name + self.value = value + def getCategory(self): + return self.category + def getContenttype(self, content_type): + return self.content_type + def getValue(self): + return self.value + def getName(self): + return self.name + def export(self, outfile, level, name, namespace, + pretty_print=True): + if self.category == MixedContainer.CategoryText: + # Prevent exporting empty content as empty lines. + if self.value.strip(): + outfile.write(self.value) + elif self.category == MixedContainer.CategorySimple: + self.exportSimple(outfile, level, name) + else: # category == MixedContainer.CategoryComplex + self.value.export( + outfile, level, namespace, name_=name, + pretty_print=pretty_print) + def exportSimple(self, outfile, level, name): + if self.content_type == MixedContainer.TypeString: + outfile.write('<%s>%s' % ( + self.name, self.value, self.name)) + elif self.content_type == MixedContainer.TypeInteger or \ + self.content_type == MixedContainer.TypeBoolean: + outfile.write('<%s>%d' % ( + self.name, self.value, self.name)) + elif self.content_type == MixedContainer.TypeFloat or \ + self.content_type == MixedContainer.TypeDecimal: + outfile.write('<%s>%f' % ( + self.name, self.value, self.name)) + elif self.content_type == MixedContainer.TypeDouble: + outfile.write('<%s>%g' % ( + self.name, self.value, self.name)) + elif self.content_type == MixedContainer.TypeBase64: + outfile.write('<%s>%s' % ( + self.name, + base64.b64encode(self.value), + self.name)) + def to_etree(self, element, mapping_=None, nsmap_=None): + if self.category == MixedContainer.CategoryText: + # Prevent exporting empty content as empty lines. + if self.value.strip(): + if len(element) > 0: + if element[-1].tail is None: + element[-1].tail = self.value + else: + element[-1].tail += self.value + else: + if element.text is None: + element.text = self.value + else: + element.text += self.value + elif self.category == MixedContainer.CategorySimple: + subelement = etree_.SubElement( + element, '%s' % self.name) + subelement.text = self.to_etree_simple() + else: # category == MixedContainer.CategoryComplex + self.value.to_etree(element) + def to_etree_simple(self, mapping_=None, nsmap_=None): + if self.content_type == MixedContainer.TypeString: + text = self.value + elif (self.content_type == MixedContainer.TypeInteger or + self.content_type == MixedContainer.TypeBoolean): + text = '%d' % self.value + elif (self.content_type == MixedContainer.TypeFloat or + self.content_type == MixedContainer.TypeDecimal): + text = '%f' % self.value + elif self.content_type == MixedContainer.TypeDouble: + text = '%g' % self.value + elif self.content_type == MixedContainer.TypeBase64: + text = '%s' % base64.b64encode(self.value) + return text + def exportLiteral(self, outfile, level, name): + if self.category == MixedContainer.CategoryText: + showIndent(outfile, level) + outfile.write( + 'model_.MixedContainer(%d, %d, "%s", "%s"),\n' % ( + self.category, self.content_type, + self.name, self.value)) + elif self.category == MixedContainer.CategorySimple: + showIndent(outfile, level) + outfile.write( + 'model_.MixedContainer(%d, %d, "%s", "%s"),\n' % ( + self.category, self.content_type, + self.name, self.value)) + else: # category == MixedContainer.CategoryComplex + showIndent(outfile, level) + outfile.write( + 'model_.MixedContainer(%d, %d, "%s",\n' % ( + self.category, self.content_type, self.name,)) + self.value.exportLiteral(outfile, level + 1) + showIndent(outfile, level) + outfile.write(')\n') + + +class MemberSpec_(object): + def __init__(self, name='', data_type='', container=0, + optional=0, child_attrs=None, choice=None): + self.name = name + self.data_type = data_type + self.container = container + self.child_attrs = child_attrs + self.choice = choice + self.optional = optional + 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_chain(self): return self.data_type + def get_data_type(self): + if isinstance(self.data_type, list): + if len(self.data_type) > 0: + return self.data_type[-1] + return 'xs:string' + return self.data_type + def set_container(self, container): self.container = container + def get_container(self): return self.container + def set_child_attrs(self, child_attrs): self.child_attrs = child_attrs + def get_child_attrs(self): return self.child_attrs + def set_choice(self, choice): self.choice = choice + def get_choice(self): return self.choice + def set_optional(self, optional): self.optional = optional + def get_optional(self): return self.optional + + +def _cast(typ, value): + if typ is None or value is None: + return value + return typ(value) + +# +# Data representation classes. +# + + +class CompoundKind(Enum): + CLASS='class' + STRUCT='struct' + UNION='union' + INTERFACE='interface' + PROTOCOL='protocol' + CATEGORY='category' + EXCEPTION='exception' + FILE='file' + NAMESPACE='namespace' + GROUP='group' + PAGE='page' + EXAMPLE='example' + DIR='dir' + + +class MemberKind(Enum): + DEFINE='define' + PROPERTY='property' + EVENT='event' + VARIABLE='variable' + TYPEDEF='typedef' + ENUM='enum' + ENUMVALUE='enumvalue' + FUNCTION='function' + SIGNAL='signal' + PROTOTYPE='prototype' + FRIEND='friend' + DCOP='dcop' + SLOT='slot' + + +class DoxygenType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, version=None, compound=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.version = _cast(None, version) + self.version_nsprefix_ = None + if compound is None: + self.compound = [] + else: + self.compound = compound + self.compound_nsprefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, DoxygenType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if DoxygenType.subclass: + return DoxygenType.subclass(*args_, **kwargs_) + return DoxygenType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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_at(self, index, value): + self.compound.insert(index, value) + def replace_compound_at(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 + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DoxygenType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('DoxygenType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'DoxygenType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='DoxygenType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='DoxygenType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='DoxygenType'): + if self.version is not None and 'version' not in already_processed: + already_processed.add('version') + outfile.write(' version=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.version), input_name='version')), )) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='DoxygenType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for compound_ in self.compound: + namespaceprefix_ = self.compound_nsprefix_ + ':' if (UseCapturedNS_ and self.compound_nsprefix_) else '' + compound_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='compound', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('version', node) + if value is not None and 'version' not in already_processed: + already_processed.add('version') + self.version = value + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'compound': + obj_ = CompoundType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.compound.append(obj_) + obj_.original_tagname_ = 'compound' +# end class DoxygenType + + +class CompoundType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, refid=None, kind=None, name=None, member=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.refid = _cast(None, refid) + self.refid_nsprefix_ = None + self.kind = _cast(None, kind) + self.kind_nsprefix_ = None + self.name = name + self.name_nsprefix_ = None + if member is None: + self.member = [] + else: + self.member = member + self.member_nsprefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, CompoundType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if CompoundType.subclass: + return CompoundType.subclass(*args_, **kwargs_) + return CompoundType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + 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_at(self, index, value): + self.member.insert(index, value) + def replace_member_at(self, index, value): + self.member[index] = value + def get_refid(self): + return self.refid + def set_refid(self, refid): + self.refid = refid + def get_kind(self): + return self.kind + def set_kind(self, kind): + self.kind = kind + def validate_CompoundKind(self, value): + # Validate type CompoundKind, a restriction on xsd:string. + if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) + return False + value = value + enumerations = ['class', 'struct', 'union', 'interface', 'protocol', 'category', 'exception', 'file', 'namespace', 'group', 'page', 'example', 'dir'] + if value not in enumerations: + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on CompoundKind' % {"value" : encode_str_2_3(value), "lineno": lineno} ) + result = False + def hasContent_(self): + if ( + self.name is not None or + self.member + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CompoundType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('CompoundType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'CompoundType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='CompoundType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CompoundType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='CompoundType'): + if self.refid is not None and 'refid' not in already_processed: + already_processed.add('refid') + outfile.write(' refid=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.refid), input_name='refid')), )) + if self.kind is not None and 'kind' not in already_processed: + already_processed.add('kind') + outfile.write(' kind=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.kind), input_name='kind')), )) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='CompoundType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.name is not None: + namespaceprefix_ = self.name_nsprefix_ + ':' if (UseCapturedNS_ and self.name_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%sname>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.name), input_name='name')), namespaceprefix_ , eol_)) + for member_ in self.member: + namespaceprefix_ = self.member_nsprefix_ + ':' if (UseCapturedNS_ and self.member_nsprefix_) else '' + member_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='member', pretty_print=pretty_print) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('refid', node) + if value is not None and 'refid' not in already_processed: + already_processed.add('refid') + self.refid = value + value = find_attr_value_('kind', node) + if value is not None and 'kind' not in already_processed: + already_processed.add('kind') + self.kind = value + self.validate_CompoundKind(self.kind) # validate type CompoundKind + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'name': + value_ = child_.text + value_ = self.gds_parse_string(value_, node, 'name') + value_ = self.gds_validate_string(value_, node, 'name') + self.name = value_ + self.name_nsprefix_ = child_.prefix + elif nodeName_ == 'member': + obj_ = MemberType.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.member.append(obj_) + obj_.original_tagname_ = 'member' +# end class CompoundType + + +class MemberType(GeneratedsSuper): + __hash__ = GeneratedsSuper.__hash__ + subclass = None + superclass = None + def __init__(self, refid=None, kind=None, name=None, gds_collector_=None, **kwargs_): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get('parent_object_') + self.ns_prefix_ = None + self.refid = _cast(None, refid) + self.refid_nsprefix_ = None + self.kind = _cast(None, kind) + self.kind_nsprefix_ = None + self.name = name + self.name_nsprefix_ = None + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, MemberType) + if subclass is not None: + return subclass(*args_, **kwargs_) + if MemberType.subclass: + return MemberType.subclass(*args_, **kwargs_) + return MemberType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ns_prefix_(self): + return self.ns_prefix_ + def set_ns_prefix_(self, ns_prefix): + self.ns_prefix_ = ns_prefix + def get_name(self): + return self.name + def set_name(self, name): + self.name = name + def get_refid(self): + return self.refid + def set_refid(self, refid): + self.refid = refid + def get_kind(self): + return self.kind + def set_kind(self, kind): + self.kind = kind + def validate_MemberKind(self, value): + # Validate type MemberKind, a restriction on xsd:string. + if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None: + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, }) + return False + value = value + enumerations = ['define', 'property', 'event', 'variable', 'typedef', 'enum', 'enumvalue', 'function', 'signal', 'prototype', 'friend', 'dcop', 'slot'] + if value not in enumerations: + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on MemberKind' % {"value" : encode_str_2_3(value), "lineno": lineno} ) + result = False + def hasContent_(self): + if ( + self.name is not None + ): + return True + return False + def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='MemberType', pretty_print=True): + imported_ns_def_ = GenerateDSNamespaceDefs_.get('MemberType') + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.original_tagname_ is not None and name_ == 'MemberType': + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ':' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = set() + self.exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='MemberType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='MemberType', pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('%s' % (namespaceprefix_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='MemberType'): + if self.refid is not None and 'refid' not in already_processed: + already_processed.add('refid') + outfile.write(' refid=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.refid), input_name='refid')), )) + if self.kind is not None and 'kind' not in already_processed: + already_processed.add('kind') + outfile.write(' kind=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.kind), input_name='kind')), )) + def exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='MemberType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.name is not None: + namespaceprefix_ = self.name_nsprefix_ + ':' if (UseCapturedNS_ and self.name_nsprefix_) else '' + showIndent(outfile, level, pretty_print) + outfile.write('<%sname>%s%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.name), input_name='name')), namespaceprefix_ , eol_)) + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self.buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + def buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_('refid', node) + if value is not None and 'refid' not in already_processed: + already_processed.add('refid') + self.refid = value + value = find_attr_value_('kind', node) + if value is not None and 'kind' not in already_processed: + already_processed.add('kind') + self.kind = value + self.validate_MemberKind(self.kind) # validate type MemberKind + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None): + if nodeName_ == 'name': + value_ = child_.text + value_ = self.gds_parse_string(value_, node, 'name') + value_ = self.gds_validate_string(value_, node, 'name') + self.name = value_ + self.name_nsprefix_ = child_.prefix +# end class MemberType + + +GDSClassesMapping = { + 'doxygenindex': DoxygenType, +} + + +USAGE_TEXT = """ +Usage: python .py [ -s ] +""" + + +def usage(): + print(USAGE_TEXT) + sys.exit(1) + + +def get_root_tag(node): + tag = Tag_pattern_.match(node.tag).groups()[-1] + rootClass = GDSClassesMapping.get(tag) + if rootClass is None: + rootClass = globals().get(tag) + return tag, rootClass + + +def get_required_ns_prefix_defs(rootNode): + '''Get all name space prefix definitions required in this XML doc. + Return a dictionary of definitions and a char string of definitions. + ''' + nsmap = { + prefix: uri + for node in rootNode.iter() + for (prefix, uri) in node.nsmap.items() + if prefix is not None + } + namespacedefs = ' '.join([ + 'xmlns:{}="{}"'.format(prefix, uri) + for prefix, uri in nsmap.items() + ]) + return nsmap, namespacedefs + + +def parse(inFileName, silence=False, print_warnings=True): + global CapturedNsmap_ + gds_collector = GdsCollector_() + parser = None + doc = parsexml_(inFileName, parser) + rootNode = doc.getroot() + rootTag, rootClass = get_root_tag(rootNode) + if rootClass is None: + rootTag = 'DoxygenType' + rootClass = DoxygenType + rootObj = rootClass.factory() + rootObj.build(rootNode, gds_collector_=gds_collector) + CapturedNsmap_, namespacedefs = get_required_ns_prefix_defs(rootNode) + if not SaveElementTreeNode: + doc = None + rootNode = None + if not silence: + sys.stdout.write('\n') + rootObj.export( + sys.stdout, 0, name_=rootTag, + namespacedef_=namespacedefs, + pretty_print=True) + if print_warnings and len(gds_collector.get_messages()) > 0: + separator = ('-' * 50) + '\n' + sys.stderr.write(separator) + sys.stderr.write('----- Warnings -- count: {} -----\n'.format( + len(gds_collector.get_messages()), )) + gds_collector.write_messages(sys.stderr) + sys.stderr.write(separator) + return rootObj + + +def parseEtree(inFileName, silence=False, print_warnings=True, + mapping=None, nsmap=None): + parser = None + doc = parsexml_(inFileName, parser) + gds_collector = GdsCollector_() + rootNode = doc.getroot() + rootTag, rootClass = get_root_tag(rootNode) + if rootClass is None: + rootTag = 'DoxygenType' + rootClass = DoxygenType + rootObj = rootClass.factory() + rootObj.build(rootNode, gds_collector_=gds_collector) + # Enable Python to collect the space used by the DOM. + if mapping is None: + mapping = {} + rootElement = rootObj.to_etree( + None, name_=rootTag, mapping_=mapping, nsmap_=nsmap) + reverse_mapping = rootObj.gds_reverse_node_mapping(mapping) + if not SaveElementTreeNode: + doc = None + rootNode = None + if not silence: + content = etree_.tostring( + rootElement, pretty_print=True, + xml_declaration=True, encoding="utf-8") + sys.stdout.write(str(content)) + sys.stdout.write('\n') + if print_warnings and len(gds_collector.get_messages()) > 0: + separator = ('-' * 50) + '\n' + sys.stderr.write(separator) + sys.stderr.write('----- Warnings -- count: {} -----\n'.format( + len(gds_collector.get_messages()), )) + gds_collector.write_messages(sys.stderr) + sys.stderr.write(separator) + return rootObj, rootElement, mapping, reverse_mapping + + +def parseString(inString, silence=False, print_warnings=True): + '''Parse a string, create the object tree, and export it. + + Arguments: + - inString -- A string. This XML fragment should not start + with an XML declaration containing an encoding. + - silence -- A boolean. If False, export the object. + Returns -- The root object in the tree. + ''' + parser = None + rootNode= parsexmlstring_(inString, parser) + gds_collector = GdsCollector_() + rootTag, rootClass = get_root_tag(rootNode) + if rootClass is None: + rootTag = 'DoxygenType' + rootClass = DoxygenType + rootObj = rootClass.factory() + rootObj.build(rootNode, gds_collector_=gds_collector) + if not SaveElementTreeNode: + rootNode = None + if not silence: + sys.stdout.write('\n') + rootObj.export( + sys.stdout, 0, name_=rootTag, + namespacedef_='') + if print_warnings and len(gds_collector.get_messages()) > 0: + separator = ('-' * 50) + '\n' + sys.stderr.write(separator) + sys.stderr.write('----- Warnings -- count: {} -----\n'.format( + len(gds_collector.get_messages()), )) + gds_collector.write_messages(sys.stderr) + sys.stderr.write(separator) + return rootObj + + +def parseLiteral(inFileName, silence=False, print_warnings=True): + parser = None + doc = parsexml_(inFileName, parser) + gds_collector = GdsCollector_() + rootNode = doc.getroot() + rootTag, rootClass = get_root_tag(rootNode) + if rootClass is None: + rootTag = 'DoxygenType' + rootClass = DoxygenType + rootObj = rootClass.factory() + rootObj.build(rootNode, gds_collector_=gds_collector) + # Enable Python to collect the space used by the DOM. + if not SaveElementTreeNode: + doc = None + rootNode = None + if not silence: + sys.stdout.write('#from index_parser import *\n\n') + sys.stdout.write('import index_parser as model_\n\n') + sys.stdout.write('rootObj = model_.rootClass(\n') + rootObj.exportLiteral(sys.stdout, 0, name_=rootTag) + sys.stdout.write(')\n') + if print_warnings and len(gds_collector.get_messages()) > 0: + separator = ('-' * 50) + '\n' + sys.stderr.write(separator) + sys.stderr.write('----- Warnings -- count: {} -----\n'.format( + len(gds_collector.get_messages()), )) + gds_collector.write_messages(sys.stderr) + sys.stderr.write(separator) + return rootObj + + +def main(): + args = sys.argv[1:] + if len(args) == 1: + parse(args[0]) + else: + usage() + + +if __name__ == '__main__': + #import pdb; pdb.set_trace() + main() + +RenameMappings_ = { +} + +__all__ = [ + "CompoundType", + "DoxygenType", + "MemberType" +] diff --git a/docs/dalapi/doxypy/utils.py b/docs/dalapi/doxypy/utils.py new file mode 100644 index 00000000000..c9c837b04a4 --- /dev/null +++ b/docs/dalapi/doxypy/utils.py @@ -0,0 +1,33 @@ +# file: utils.py +#=============================================================================== +# Copyright 2019-2020 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +#=============================================================================== + +def split_compound_name(compoundname): + try: + namespace, name = compoundname.rsplit('::', 1) + except ValueError: + namespace, name = '', compoundname + return namespace, name + +def return_list(func): + def wrapper(*args, **kwargs): + return list(func(*args, **kwargs)) + return wrapper + +def return_dict(func): + def wrapper(*args, **kwargs): + return dict(func(*args, **kwargs)) + return wrapper diff --git a/docs/dalapi/extension.py b/docs/dalapi/extension.py new file mode 100644 index 00000000000..68232949989 --- /dev/null +++ b/docs/dalapi/extension.py @@ -0,0 +1,202 @@ +# file: extension.py +#=============================================================================== +# Copyright 2019-2020 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +#=============================================================================== + +import os +import time +from typing import (Dict, Tuple, Text) +from . import doxypy +from . import utils +from . import roles +from . import directives +from . import transformers + +class PathResolver(object): + def __init__(self, app, + relative_doxyfile_dir, + relative_sources_dir): + self.base_dir = app.confdir + self.doxyfile_dir = self.absjoin(self.base_dir, relative_doxyfile_dir) + self.sources_dir = self.absjoin(self.base_dir, relative_sources_dir) + self.doxygen_xml = self.absjoin(self.doxyfile_dir, 'doxygen', 'xml') + + def __call__(self, relative_name): + return self.absjoin(self.base_dir, relative_name) + + def absjoin(self, *args): + return os.path.abspath(os.path.join(*args)) + + +class ProjectWatcher(object): + def __init__(self, ctx, path_resolver): + self.ctx = ctx + self._path_resolver = path_resolver + self._xml_timer = utils.FileModificationTimer( + path_resolver.doxygen_xml, '*.xml') + self._hpp_timer = utils.FileModificationTimer( + path_resolver.sources_dir, '*.hpp') + self._doxygen = utils.ProcessHandle( + 'doxygen', path_resolver.doxyfile_dir) + + def link_docname(self, docname): + full_path = self._path_resolver(f'{docname}.rst') + self._linked_docnames[docname] = (full_path, time.time()) + + def get_outdated_docnames(self, modified_docnames): + # We do not need to check the modified documents, + # they should be updated by Sphinx in any way + for docname in modified_docnames: + if docname in self._linked_docnames: + del self._linked_docnames[docname] + + xml_mtime = self._xml_timer() + hpp_mtime = self._hpp_timer() + if xml_mtime < hpp_mtime: + self.ctx.log('Run Doxygen') + self._doxygen.run() + + outdated_docnames = [] + for docname, info in self._linked_docnames.items(): + _, link_time = info + if (self.ctx.always_rebuild or + link_time < xml_mtime or link_time < hpp_mtime): + outdated_docnames.append(docname) + + if self.ctx.debug: + for docname in outdated_docnames: + self.ctx.log('OUTDATED', docname) + + return outdated_docnames + + + def _update_linked_docnames(self): + relevant_linked_docnames = {} + for docname, info in self._linked_docnames.items(): + docfilename = info[0] + if os.path.exists(docfilename): + relevant_linked_docnames[docname] = info + self._linked_docnames = relevant_linked_docnames + + @property + def _linked_docnames(self) -> Dict[Text, Tuple[Text, float]]: + if not hasattr(self.ctx.app.env, 'dalapi_linked_docnames'): + self.ctx.app.env.dalapi_linked_docnames = {} + return self.ctx.app.env.dalapi_linked_docnames + + @_linked_docnames.setter + def _linked_docnames(self, value): + self.ctx.app.env.dalapi_linked_docnames = value + + +class Context(object): + def __init__(self, app): + self.app = app + self._index = None + self._watcher = None + self._doxygen = None + self._listing = None + self._path_resolver = None + self._is_listing_enabled = False + self._read_env() + + def configure(self, relative_doxyfile_dir, relative_sources_dir, is_listing_enabled): + self._path_resolver = PathResolver( + self.app, + relative_doxyfile_dir, + relative_sources_dir + ) + self._is_listing_enabled = is_listing_enabled + + @property + def current_docname(self): + return self.app.env.docname + + @property + def index(self) -> doxypy.Index: + if self._index is None: + self._index = doxypy.index(self.path_resolver.doxygen_xml, [ + transformers.PropertyTransformer(), + transformers.RstDescriptionTransformer(), + ]) + return self._index + + @property + def watcher(self) -> ProjectWatcher: + if self._watcher is None: + self._watcher = ProjectWatcher(self, self.path_resolver) + return self._watcher + + @property + def listing(self) -> doxypy.ListingReader: + if self._listing is None: + self._listing = doxypy.ListingReader(self.path_resolver.sources_dir) + return self._listing + + @property + def listing_enabled(self) -> bool: + return self._is_listing_enabled + + @property + def path_resolver(self): + if not self._path_resolver: + raise Exception('Context is not configured') + return self._path_resolver + + def log(self, *args): + if self.debug: + print('[dalapi]:', *args) + + def _read_env(self): + def get_env_flag(env_var): + value = os.environ.get(env_var, '0') + return value.lower() in ['1', 'yes', 'y'] + self.debug = get_env_flag('DALAPI_DEBUG') + self.always_rebuild = get_env_flag('DALAPI_ALWAYS_REBUILD') + + +class EventHandler(object): + def __init__(self, ctx: Context): + self.ctx = ctx + + def env_get_outdated(self, app, env, added, changed, removed): + return self.ctx.watcher.get_outdated_docnames(added | changed | removed) + + def get_config_values(self, app): + self.ctx.configure( + relative_doxyfile_dir=app.config.onedal_relative_doxyfile_dir, + relative_sources_dir=app.config.onedal_relative_sources_dir, + is_listing_enabled=app.config.onedal_enable_listing + ) + +def setup(app): + ctx = Context(app) + + app.add_role('capterm', roles.capterm_role) + app.add_role('txtref', roles.txtref_role) + + app.add_directive('onedal_class', directives.ClassDirective(ctx)) + app.add_directive('onedal_func', directives.FunctionDirective(ctx)) + app.add_directive('onedal_code', directives.ListingDirective(ctx)) + app.add_directive('onedal_tags_namespace', directives.TagsNamespaceDirective(ctx)) + app.add_directive('onedal_enumclass', directives.EnumClassDirective(ctx)) + + app.add_config_value('onedal_relative_doxyfile_dir', '.', 'env') + app.add_config_value('onedal_relative_sources_dir', '.', 'env') + app.add_config_value('onedal_enable_listing', True, 'env') + + handler = EventHandler(ctx) + app.connect("builder-inited", handler.get_config_values) + app.connect('env-get-outdated', handler.env_get_outdated) diff --git a/docs/dalapi/generator.py b/docs/dalapi/generator.py new file mode 100644 index 00000000000..bf00519efea --- /dev/null +++ b/docs/dalapi/generator.py @@ -0,0 +1,94 @@ +# file: generator.py +#=============================================================================== +# Copyright 2019-2020 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +#=============================================================================== + +from typing import (List, Text) +from docutils.statemachine import ViewList + +class RstBuilder(object): + def __init__(self, placeholder: ViewList, filename: Text, lineno: int): + self._rst_list = placeholder + self._filename = filename + self._lineno = lineno + + def add_class(self, kind: str, declaration: str, namespace: str = None, level=0): + self._add_name(kind, declaration, namespace, level) + + def add_typedef(self, declaration: str, namespace: str = None, level=0): + self._add_name('type', declaration, namespace, level) + + def add_function(self, declaration: str, namespace: str = None, level=0): + self._add_name('function', declaration, namespace, level) + + def add_enumclass(self, declaration: str, namespace: str = None, level=0): + self._add_name('enum-class', declaration, namespace, level) + + def add_param(self, tag: str, name: str, doc_text: str, level=0): + assert tag in ['param', 'tparam'] + assert name + assert doc_text + formatted = self._format_text(doc_text) + self(f':{tag} {name}: {formatted}', level) + + def add_member(self, declaration: str, level=0): + assert declaration + self(f'.. cpp:member:: {declaration}', level) + self.add_blank_line() + + def add_property_member(self, declaration: str, parent_fully_qualified_name: str, level=0): + assert declaration + assert parent_fully_qualified_name + fake_parent_namespace = '_'.join(parent_fully_qualified_name.split('::')) + self(f'.. cpp:namespace:: {fake_parent_namespace}_properties', level) + self(f'.. cpp:member:: {declaration}', level) + self.add_blank_line() + + def add_doc(self, doc_text: str, level=0): + assert doc_text + self(self._format_text(doc_text), level) + self.add_blank_line() + + def add_code_block(self, listing: List[Text], level=0): + assert listing is not None + self(f'.. code-block:: cpp', level) + self.add_blank_line() + for line in listing: + self(line, level + 1) + self.add_blank_line() + + def add_blank_line(self): + self.add() + + def add(self, string: str = '', level: int = 0): + self._rst_list.append(' ' * level * 3 + string, self._filename, self._lineno) + + # TODO: Remove + def __call__(self, string: str = '', level:int = 0): + self._rst_list.append(' ' * level * 3 + string, self._filename, self._lineno) + + def _add_name(self, tag: str, declaration: str, namespace: str = None, level=0): + assert declaration + if namespace: + self(f'.. cpp:namespace:: {namespace}', level) + self.add_blank_line() + self(f'.. cpp:{tag}:: {declaration}', level) + self.add_blank_line() + + def _format_text(self, text): + text = text.strip() + if not (text.endswith('.') or text.endswith('|')): + text += '.' + return text diff --git a/docs/dalapi/roles.py b/docs/dalapi/roles.py new file mode 100644 index 00000000000..77481649d1b --- /dev/null +++ b/docs/dalapi/roles.py @@ -0,0 +1,62 @@ +# file: roles.py +#=============================================================================== +# Copyright 2019-2020 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +#=============================================================================== + +import re +from docutils import nodes +from sphinx import roles + +_term_ref_re = re.compile(r'(.+)<(.+)>', flags=re.DOTALL) +def capterm_role(name, rawtext, text, lineno, inliner, options={}, content=[]): + xref_role = roles.XRefRole(innernodeclass=nodes.inline, + warn_dangling=True) + term_match = _term_ref_re.match(text) + if term_match: + txt, ref = term_match.group(1), term_match.group(2) + else: + txt, ref = text, text + fixed_term = f'{txt.strip()} <{ref.strip().capitalize()}>' + return xref_role('std:term', rawtext, fixed_term, lineno, inliner, options, content) + + +_term_txt_ref_re = re.compile(r'(.*)<(.+)>(.*)', flags=re.DOTALL) +def txtref_role(name, rawtext, text, lineno, inliner, options={}, content=[]): + xref_role = roles.XRefRole(lowercase=True, + innernodeclass=nodes.inline, + warn_dangling=True) + def extract_ref_words(ref): + return [item for sub in ref.split('-') for item in sub.split('_')] + + def make_term_text(words, ref, suffix=''): + txt = ' '.join(words).strip() + txt = txt[0].lower() + txt[1:] + return f"{txt}{suffix} <{ref.strip()}>" + + term_match = _term_txt_ref_re.match(text) + if term_match: + alias, ref, suffix = term_match.group(1), term_match.group(2), term_match.group(3) + if len(alias) > 0 and len(suffix) == 0: + fixed_term = text + elif len(alias) == 0 and len(suffix) > 0: + words = extract_ref_words(ref) + fixed_term = make_term_text(words, ref, suffix) + else: + raise RuntimeError('Unexpected role syntax: ' + rawtext) + else: + ref, words = text, extract_ref_words(text) + fixed_term = make_term_text(words, ref) + + return xref_role('std:ref', rawtext, fixed_term, lineno, inliner, options, content) diff --git a/docs/dalapi/transformers.py b/docs/dalapi/transformers.py new file mode 100644 index 00000000000..a801862d9f5 --- /dev/null +++ b/docs/dalapi/transformers.py @@ -0,0 +1,136 @@ +# file: transformers.py +#=============================================================================== +# Copyright 2019-2020 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +#=============================================================================== + +import re +from typing import (Dict, Tuple, Text) +from collections import OrderedDict, namedtuple +from . import doxypy + +@doxypy.model.model_object +class Property(object): + doc: doxypy.model.Doc = None + name: Text = None + type: Text = None + getter: doxypy.model.Function = None + setter: doxypy.model.Function = None + default: Text = None + declaration: Text = None + fully_qualified_name: Text = None + parent_fully_qualified_name: Text = None + +class PropertyTransformer(doxypy.TransformerPass): + _accessor_re = re.compile(r'(get|set)_(\w+)') + _default_re = re.compile(r'default *= *(.+)') + + def enter(self, node): + return (isinstance(node, (doxypy.model.Class, doxypy.model.Namespace))) + + def transform(self, node): + if isinstance(node, doxypy.model.Class): + properties = [] + for name, info in self._get_properties_info(node): + prop = self._build_property(name, info) + prop.getter.doc = None + node.functions.remove(prop.getter) + if prop.setter: + node.functions.remove(prop.setter) + properties.append(prop) + node.properties = properties + + @classmethod + def _build_property(cls, name, info): + parent_fqn = f'{info.getter.parent_fully_qualified_name}::{name}' + default = cls._find_default(info) + decl = f'{info.getter.return_type} {name}' + if default: + decl += f' = {default}' + return Property( + doc = info.getter.doc, + name = name, + type = info.getter.return_type, + getter = info.getter, + setter = info.setter, + default = default, + declaration = decl, + fully_qualified_name = parent_fqn, + parent_fully_qualified_name = info.getter.parent_fully_qualified_name, + ) + + @classmethod + def _find_default(cls, info): + if info.getter.doc: + for remark in info.getter.doc.remarks: + if len(remark.runs) == 1 and remark.runs[0].kind == 'text': + match = cls._default_re.match(remark.runs[0].content) + if match: + return match.group(1) + + @classmethod + def _get_properties_info(cls, node): + getters = OrderedDict(cls._get_access_methods(node, 'get')) + setters = OrderedDict(cls._get_access_methods(node, 'set')) + PropertyInfo = namedtuple('PropertyInfo', ['getter', 'setter']) + for name in getters.keys(): + yield name, PropertyInfo(getters[name], setters.get(name, None)) + + @classmethod + def _get_access_methods(cls, node, direction): + for func in node.functions: + match = cls._accessor_re.match(func.name) + if match and match.group(1) == direction: + yield match.group(2), func + + +class RstDescriptionTransformer(doxypy.TransformerPass): + _sphinx_directive_re = re.compile(r':([\w:]+):$') + + def enter(self, node): + return True + + def transform(self, node): + if isinstance(node, doxypy.model.Description): + self._transform_runs(node) + + @classmethod + def _transform_runs(cls, desc: doxypy.model.Description): + for i in range(1, len(desc.runs)): + pre_run = desc.runs[i - 1] + cur_run = desc.runs[i] + if pre_run.kind == 'text' and cur_run.kind == 'code': + new_content, directive = cls._try_remove_sphinx_directive(pre_run.content) + if directive: + pre_run.content = new_content + cur_run.directive = cls._map_directive(directive) + + @classmethod + def _try_remove_sphinx_directive(cls, text): + match = None + def rep_f(m): + nonlocal match + match = m + return '' + new_text = cls._sphinx_directive_re.sub(rep_f, text) + return new_text, match.group(1) if match else None + + @classmethod + def _map_directive(cls, directive): + cpp_directives = { 'expr', 'texpr', 'any', 'class', + 'struct', 'func', 'member', 'var', + 'type', 'concept', 'enum', 'enumerator' } + if directive in cpp_directives: + return f':cpp:{directive}:' + return f':{directive}:' diff --git a/docs/dalapi/utils.py b/docs/dalapi/utils.py new file mode 100644 index 00000000000..d0b208e1fb2 --- /dev/null +++ b/docs/dalapi/utils.py @@ -0,0 +1,65 @@ +# file: utils.py +#=============================================================================== +# Copyright 2019-2020 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +#=============================================================================== + +import os +import subprocess +from typing import ( + Iterable, + Union, +) +from glob import iglob + +class _cd: + def __init__(self, new_path): + self.new_path = os.path.abspath(new_path) + + def __enter__(self): + self.saved_path = os.getcwd() + os.chdir(self.new_path) + + def __exit__(self, etype, value, traceback): + os.chdir(self.saved_path) + + +class ProcessHandle(object): + def __init__(self, command, startup_dir: str = '.'): + self._command = command + self._startup_dir = startup_dir + + def run(self): + with _cd(self._startup_dir): + subprocess.check_call(self._command, shell=True) + + +class FileModificationTimer(object): + def __init__(self, base_dir_or_files: Union[str, Iterable[str]], + pattern: str = '*'): + if isinstance(base_dir_or_files, str): + self._base_dir = os.path.abspath(base_dir_or_files) + self._pattern = pattern + else: + self._files = base_dir_or_files + + def __call__(self): + mtimes = [os.path.getmtime(x) for x in self._get_files()] + return max(mtimes) if len(mtimes) > 0 else 0 + + def _get_files(self): + if hasattr(self, '_base_dir'): + glob_str = f'{self._base_dir}/**/{self._pattern}' + return iglob(glob_str, recursive=True) + return self._files diff --git a/docs/doxygen/oneapi/Doxyfile b/docs/doxygen/oneapi/Doxyfile new file mode 100644 index 00000000000..7be8ba60c81 --- /dev/null +++ b/docs/doxygen/oneapi/Doxyfile @@ -0,0 +1,2565 @@ +# Doxyfile 1.8.20 + +# This file describes the settings to be used by the documentation system +# doxygen (www.doxygen.org) for a project. +# +# All text after a double hash (##) is considered a comment and is placed in +# front of the TAG it is preceding. +# +# All text after a single hash (#) is considered a comment and will be ignored. +# The format is: +# TAG = value [value, ...] +# For lists, items can also be appended using: +# TAG += value [value, ...] +# Values that contain spaces should be placed between quotes (\" \"). + +#--------------------------------------------------------------------------- +# Project related configuration options +#--------------------------------------------------------------------------- + +# This tag specifies the encoding used for all characters in the configuration +# file that follow. The default is UTF-8 which is also the encoding used for all +# text before the first occurrence of this tag. Doxygen uses libiconv (or the +# iconv built into libc) for the transcoding. See +# https://www.gnu.org/software/libiconv/ for the list of possible encodings. +# The default value is: UTF-8. + +DOXYFILE_ENCODING = UTF-8 + +# The PROJECT_NAME tag is a single word (or a sequence of words surrounded by +# double-quotes, unless you are using Doxywizard) that should identify the +# project for which the documentation is generated. This name is used in the +# title of most generated pages and in a few other places. +# The default value is: My Project. + +PROJECT_NAME = "oneDAL" + +# The PROJECT_NUMBER tag can be used to enter a project or revision number. This +# could be handy for archiving the generated documentation or if some version +# control system is used. + +PROJECT_NUMBER = + +# Using the PROJECT_BRIEF tag one can provide an optional one line description +# for a project that appears at the top of each page and should give viewer a +# quick idea about the purpose of the project. Keep the description short. + +PROJECT_BRIEF = + +# With the PROJECT_LOGO tag one can specify a logo or an icon that is included +# in the documentation. The maximum height of the logo should not exceed 55 +# pixels and the maximum width should not exceed 200 pixels. Doxygen will copy +# the logo to the output directory. + +PROJECT_LOGO = + +# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path +# into which the generated documentation will be written. If a relative path is +# entered, it will be relative to the location where doxygen was started. If +# left blank the current directory will be used. + +OUTPUT_DIRECTORY = doxygen + +# If the CREATE_SUBDIRS tag is set to YES then doxygen will create 4096 sub- +# directories (in 2 levels) under the output directory of each output format and +# will distribute the generated files over these directories. Enabling this +# option can be useful when feeding doxygen a huge amount of source files, where +# putting all generated files in the same directory would otherwise causes +# performance problems for the file system. +# The default value is: NO. + +CREATE_SUBDIRS = NO + +# If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII +# characters to appear in the names of generated files. If set to NO, non-ASCII +# characters will be escaped, for example _xE3_x81_x84 will be used for Unicode +# U+3044. +# The default value is: NO. + +ALLOW_UNICODE_NAMES = NO + +# The OUTPUT_LANGUAGE tag is used to specify the language in which all +# documentation generated by doxygen is written. Doxygen will use this +# information to generate all constant output in the proper language. +# Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese, +# Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States), +# Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian, +# Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages), +# Korean, Korean-en (Korean with English messages), Latvian, Lithuanian, +# Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian, +# Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish, +# Ukrainian and Vietnamese. +# The default value is: English. + +OUTPUT_LANGUAGE = English + +# The OUTPUT_TEXT_DIRECTION tag is used to specify the direction in which all +# documentation generated by doxygen is written. Doxygen will use this +# information to generate all generated output in the proper direction. +# Possible values are: None, LTR, RTL and Context. +# The default value is: None. + +OUTPUT_TEXT_DIRECTION = None + +# If the BRIEF_MEMBER_DESC tag is set to YES, doxygen will include brief member +# descriptions after the members that are listed in the file and class +# documentation (similar to Javadoc). Set to NO to disable this. +# The default value is: YES. + +BRIEF_MEMBER_DESC = YES + +# If the REPEAT_BRIEF tag is set to YES, doxygen will prepend the brief +# description of a member or function before the detailed description +# +# Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the +# brief descriptions will be completely suppressed. +# The default value is: YES. + +REPEAT_BRIEF = YES + +# This tag implements a quasi-intelligent brief description abbreviator that is +# used to form the text in various listings. Each string in this list, if found +# as the leading text of the brief description, will be stripped from the text +# and the result, after processing the whole list, is used as the annotated +# text. Otherwise, the brief description is used as-is. If left blank, the +# following values are used ($name is automatically replaced with the name of +# the entity):The $name class, The $name widget, The $name file, is, provides, +# specifies, contains, represents, a, an and the. + +ABBREVIATE_BRIEF = "The $name class" \ + "The $name widget" \ + "The $name file" \ + is \ + provides \ + specifies \ + contains \ + represents \ + a \ + an \ + the + +# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then +# doxygen will generate a detailed section even if there is only a brief +# description. +# The default value is: NO. + +ALWAYS_DETAILED_SEC = NO + +# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all +# inherited members of a class in the documentation of that class as if those +# members were ordinary class members. Constructors, destructors and assignment +# operators of the base classes will not be shown. +# The default value is: NO. + +INLINE_INHERITED_MEMB = NO + +# If the FULL_PATH_NAMES tag is set to YES, doxygen will prepend the full path +# before files name in the file list and in the header files. If set to NO the +# shortest path that makes the file name unique will be used +# The default value is: YES. + +FULL_PATH_NAMES = YES + +# The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path. +# Stripping is only done if one of the specified strings matches the left-hand +# part of the path. The tag can be used to show relative paths in the file list. +# If left blank the directory from which doxygen is run is used as the path to +# strip. +# +# Note that you can specify absolute paths here, but also relative paths, which +# will be relative from the directory where doxygen is started. +# This tag requires that the tag FULL_PATH_NAMES is set to YES. + +STRIP_FROM_PATH = + +# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the +# path mentioned in the documentation of a class, which tells the reader which +# header file to include in order to use a class. If left blank only the name of +# the header file containing the class definition is used. Otherwise one should +# specify the list of include paths that are normally passed to the compiler +# using the -I flag. + +STRIP_FROM_INC_PATH = + +# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but +# less readable) file names. This can be useful is your file systems doesn't +# support long names like on DOS, Mac, or CD-ROM. +# The default value is: NO. + +SHORT_NAMES = NO + +# If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the +# first line (until the first dot) of a Javadoc-style comment as the brief +# description. If set to NO, the Javadoc-style will behave just like regular Qt- +# style comments (thus requiring an explicit @brief command for a brief +# description.) +# The default value is: NO. + +JAVADOC_AUTOBRIEF = NO + +# If the JAVADOC_BANNER tag is set to YES then doxygen will interpret a line +# such as +# /*************** +# as being the beginning of a Javadoc-style comment "banner". If set to NO, the +# Javadoc-style will behave just like regular comments and it will not be +# interpreted by doxygen. +# The default value is: NO. + +JAVADOC_BANNER = NO + +# If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first +# line (until the first dot) of a Qt-style comment as the brief description. If +# set to NO, the Qt-style will behave just like regular Qt-style comments (thus +# requiring an explicit \brief command for a brief description.) +# The default value is: NO. + +QT_AUTOBRIEF = NO + +# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a +# multi-line C++ special comment block (i.e. a block of //! or /// comments) as +# a brief description. This used to be the default behavior. The new default is +# to treat a multi-line C++ comment block as a detailed description. Set this +# tag to YES if you prefer the old behavior instead. +# +# Note that setting this tag to YES also means that rational rose comments are +# not recognized any more. +# The default value is: NO. + +MULTILINE_CPP_IS_BRIEF = NO + +# By default Python docstrings are displayed as preformatted text and doxygen's +# special commands cannot be used. By setting PYTHON_DOCSTRING to NO the +# doxygen's special commands can be used and the contents of the docstring +# documentation blocks is shown as doxygen documentation. +# The default value is: YES. + +PYTHON_DOCSTRING = YES + +# If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the +# documentation from any documented member that it re-implements. +# The default value is: YES. + +INHERIT_DOCS = YES + +# If the SEPARATE_MEMBER_PAGES tag is set to YES then doxygen will produce a new +# page for each member. If set to NO, the documentation of a member will be part +# of the file/class/namespace that contains it. +# The default value is: NO. + +SEPARATE_MEMBER_PAGES = NO + +# The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen +# uses this value to replace tabs by spaces in code fragments. +# Minimum value: 1, maximum value: 16, default value: 4. + +TAB_SIZE = 4 + +# This tag can be used to specify a number of aliases that act as commands in +# the documentation. An alias has the form: +# name=value +# For example adding +# "sideeffect=@par Side Effects:\n" +# will allow you to put the command \sideeffect (or @sideeffect) in the +# documentation, which will result in a user-defined paragraph with heading +# "Side Effects:". You can put \n's in the value part of an alias to insert +# newlines (in the resulting output). You can put ^^ in the value part of an +# alias to insert a newline as if a physical newline was in the original file. +# When you need a literal { or } or , in the value part of an alias you have to +# escape them by means of a backslash (\), this can lead to conflicts with the +# commands \{ and \} for these it is advised to use the version @{ and @} or use +# a double escape (\\{ and \\}) + +ALIASES = + +# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources +# only. Doxygen will then generate output that is more tailored for C. For +# instance, some of the names that are used will be different. The list of all +# members will be omitted, etc. +# The default value is: NO. + +OPTIMIZE_OUTPUT_FOR_C = NO + +# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or +# Python sources only. Doxygen will then generate output that is more tailored +# for that language. For instance, namespaces will be presented as packages, +# qualified scopes will look different, etc. +# The default value is: NO. + +OPTIMIZE_OUTPUT_JAVA = NO + +# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran +# sources. Doxygen will then generate output that is tailored for Fortran. +# The default value is: NO. + +OPTIMIZE_FOR_FORTRAN = NO + +# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL +# sources. Doxygen will then generate output that is tailored for VHDL. +# The default value is: NO. + +OPTIMIZE_OUTPUT_VHDL = NO + +# Set the OPTIMIZE_OUTPUT_SLICE tag to YES if your project consists of Slice +# sources only. Doxygen will then generate output that is more tailored for that +# language. For instance, namespaces will be presented as modules, types will be +# separated into more groups, etc. +# The default value is: NO. + +OPTIMIZE_OUTPUT_SLICE = NO + +# Doxygen selects the parser to use depending on the extension of the files it +# parses. With this tag you can assign which parser to use for a given +# extension. Doxygen has a built-in mapping, but you can override or extend it +# using this tag. The format is ext=language, where ext is a file extension, and +# language is one of the parsers supported by doxygen: IDL, Java, JavaScript, +# Csharp (C#), C, C++, D, PHP, md (Markdown), Objective-C, Python, Slice, VHDL, +# Fortran (fixed format Fortran: FortranFixed, free formatted Fortran: +# FortranFree, unknown formatted Fortran: Fortran. In the later case the parser +# tries to guess whether the code is fixed or free formatted code, this is the +# default for Fortran type files). For instance to make doxygen treat .inc files +# as Fortran files (default is PHP), and .f files as C (default is Fortran), +# use: inc=Fortran f=C. +# +# Note: For files without extension you can use no_extension as a placeholder. +# +# Note that for custom extensions you also need to set FILE_PATTERNS otherwise +# the files are not read by doxygen. + +EXTENSION_MAPPING = + +# If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments +# according to the Markdown format, which allows for more readable +# documentation. See https://daringfireball.net/projects/markdown/ for details. +# The output of markdown processing is further processed by doxygen, so you can +# mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in +# case of backward compatibilities issues. +# The default value is: YES. + +MARKDOWN_SUPPORT = YES + +# When the TOC_INCLUDE_HEADINGS tag is set to a non-zero value, all headings up +# to that level are automatically included in the table of contents, even if +# they do not have an id attribute. +# Note: This feature currently applies only to Markdown headings. +# Minimum value: 0, maximum value: 99, default value: 5. +# This tag requires that the tag MARKDOWN_SUPPORT is set to YES. + +TOC_INCLUDE_HEADINGS = 5 + +# When enabled doxygen tries to link words that correspond to documented +# classes, or namespaces to their corresponding documentation. Such a link can +# be prevented in individual cases by putting a % sign in front of the word or +# globally by setting AUTOLINK_SUPPORT to NO. +# The default value is: YES. + +AUTOLINK_SUPPORT = YES + +# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want +# to include (a tag file for) the STL sources as input, then you should set this +# tag to YES in order to let doxygen match functions declarations and +# definitions whose arguments contain STL classes (e.g. func(std::string); +# versus func(std::string) {}). This also make the inheritance and collaboration +# diagrams that involve STL classes more complete and accurate. +# The default value is: NO. + +BUILTIN_STL_SUPPORT = NO + +# If you use Microsoft's C++/CLI language, you should set this option to YES to +# enable parsing support. +# The default value is: NO. + +CPP_CLI_SUPPORT = NO + +# Set the SIP_SUPPORT tag to YES if your project consists of sip (see: +# https://www.riverbankcomputing.com/software/sip/intro) sources only. Doxygen +# will parse them like normal C++ but will assume all classes use public instead +# of private inheritance when no explicit protection keyword is present. +# The default value is: NO. + +SIP_SUPPORT = NO + +# For Microsoft's IDL there are propget and propput attributes to indicate +# getter and setter methods for a property. Setting this option to YES will make +# doxygen to replace the get and set methods by a property in the documentation. +# This will only work if the methods are indeed getting or setting a simple +# type. If this is not the case, or you want to show the methods anyway, you +# should set this option to NO. +# The default value is: YES. + +IDL_PROPERTY_SUPPORT = YES + +# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC +# tag is set to YES then doxygen will reuse the documentation of the first +# member in the group (if any) for the other members of the group. By default +# all members of a group must be documented explicitly. +# The default value is: NO. + +DISTRIBUTE_GROUP_DOC = NO + +# If one adds a struct or class to a group and this option is enabled, then also +# any nested class or struct is added to the same group. By default this option +# is disabled and one has to add nested compounds explicitly via \ingroup. +# The default value is: NO. + +GROUP_NESTED_COMPOUNDS = NO + +# Set the SUBGROUPING tag to YES to allow class member groups of the same type +# (for instance a group of public functions) to be put as a subgroup of that +# type (e.g. under the Public Functions section). Set it to NO to prevent +# subgrouping. Alternatively, this can be done per class using the +# \nosubgrouping command. +# The default value is: YES. + +SUBGROUPING = YES + +# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions +# are shown inside the group in which they are included (e.g. using \ingroup) +# instead of on a separate page (for HTML and Man pages) or section (for LaTeX +# and RTF). +# +# Note that this feature does not work in combination with +# SEPARATE_MEMBER_PAGES. +# The default value is: NO. + +INLINE_GROUPED_CLASSES = NO + +# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions +# with only public data fields or simple typedef fields will be shown inline in +# the documentation of the scope in which they are defined (i.e. file, +# namespace, or group documentation), provided this scope is documented. If set +# to NO, structs, classes, and unions are shown on a separate page (for HTML and +# Man pages) or section (for LaTeX and RTF). +# The default value is: NO. + +INLINE_SIMPLE_STRUCTS = NO + +# When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or +# enum is documented as struct, union, or enum with the name of the typedef. So +# typedef struct TypeS {} TypeT, will appear in the documentation as a struct +# with name TypeT. When disabled the typedef will appear as a member of a file, +# namespace, or class. And the struct will be named TypeS. This can typically be +# useful for C code in case the coding convention dictates that all compound +# types are typedef'ed and only the typedef is referenced, never the tag name. +# The default value is: NO. + +TYPEDEF_HIDES_STRUCT = NO + +# The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This +# cache is used to resolve symbols given their name and scope. Since this can be +# an expensive process and often the same symbol appears multiple times in the +# code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small +# doxygen will become slower. If the cache is too large, memory is wasted. The +# cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range +# is 0..9, the default is 0, corresponding to a cache size of 2^16=65536 +# symbols. At the end of a run doxygen will report the cache usage and suggest +# the optimal cache size from a speed point of view. +# Minimum value: 0, maximum value: 9, default value: 0. + +LOOKUP_CACHE_SIZE = 0 + +# The NUM_PROC_THREADS specifies the number threads doxygen is allowed to use +# during processing. When set to 0 doxygen will based this on the number of +# cores available in the system. You can set it explicitly to a value larger +# than 0 to get more control over the balance between CPU load and processing +# speed. At this moment only the input processing can be done using multiple +# threads. Since this is still an experimental feature the default is set to 1, +# which efficively disables parallel processing. Please report any issues you +# encounter. Generating dot graphs in parallel is controlled by the +# DOT_NUM_THREADS setting. +# Minimum value: 0, maximum value: 32, default value: 1. + +NUM_PROC_THREADS = 1 + +#--------------------------------------------------------------------------- +# Build related configuration options +#--------------------------------------------------------------------------- + +# If the EXTRACT_ALL tag is set to YES, doxygen will assume all entities in +# documentation are documented, even if no documentation was available. Private +# class members and static file members will be hidden unless the +# EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES. +# Note: This will also disable the warnings about undocumented members that are +# normally produced when WARNINGS is set to YES. +# The default value is: NO. + +EXTRACT_ALL = NO + +# If the EXTRACT_PRIVATE tag is set to YES, all private members of a class will +# be included in the documentation. +# The default value is: NO. + +EXTRACT_PRIVATE = NO + +# If the EXTRACT_PRIV_VIRTUAL tag is set to YES, documented private virtual +# methods of a class will be included in the documentation. +# The default value is: NO. + +EXTRACT_PRIV_VIRTUAL = NO + +# If the EXTRACT_PACKAGE tag is set to YES, all members with package or internal +# scope will be included in the documentation. +# The default value is: NO. + +EXTRACT_PACKAGE = NO + +# If the EXTRACT_STATIC tag is set to YES, all static members of a file will be +# included in the documentation. +# The default value is: NO. + +EXTRACT_STATIC = NO + +# If the EXTRACT_LOCAL_CLASSES tag is set to YES, classes (and structs) defined +# locally in source files will be included in the documentation. If set to NO, +# only classes defined in header files are included. Does not have any effect +# for Java sources. +# The default value is: YES. + +EXTRACT_LOCAL_CLASSES = YES + +# This flag is only useful for Objective-C code. If set to YES, local methods, +# which are defined in the implementation section but not in the interface are +# included in the documentation. If set to NO, only methods in the interface are +# included. +# The default value is: NO. + +EXTRACT_LOCAL_METHODS = NO + +# If this flag is set to YES, the members of anonymous namespaces will be +# extracted and appear in the documentation as a namespace called +# 'anonymous_namespace{file}', where file will be replaced with the base name of +# the file that contains the anonymous namespace. By default anonymous namespace +# are hidden. +# The default value is: NO. + +EXTRACT_ANON_NSPACES = NO + +# If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all +# undocumented members inside documented classes or files. If set to NO these +# members will be included in the various overviews, but no documentation +# section is generated. This option has no effect if EXTRACT_ALL is enabled. +# The default value is: NO. + +HIDE_UNDOC_MEMBERS = NO + +# If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all +# undocumented classes that are normally visible in the class hierarchy. If set +# to NO, these classes will be included in the various overviews. This option +# has no effect if EXTRACT_ALL is enabled. +# The default value is: NO. + +HIDE_UNDOC_CLASSES = NO + +# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend +# declarations. If set to NO, these declarations will be included in the +# documentation. +# The default value is: NO. + +HIDE_FRIEND_COMPOUNDS = NO + +# If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any +# documentation blocks found inside the body of a function. If set to NO, these +# blocks will be appended to the function's detailed documentation block. +# The default value is: NO. + +HIDE_IN_BODY_DOCS = NO + +# The INTERNAL_DOCS tag determines if documentation that is typed after a +# \internal command is included. If the tag is set to NO then the documentation +# will be excluded. Set it to YES to include the internal documentation. +# The default value is: NO. + +INTERNAL_DOCS = NO + +# If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file +# names in lower-case letters. If set to YES, upper-case letters are also +# allowed. This is useful if you have classes or files whose names only differ +# in case and if your file system supports case sensitive file names. Windows +# (including Cygwin) and Mac users are advised to set this option to NO. +# The default value is: system dependent. + +CASE_SENSE_NAMES = NO + +# If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with +# their full class and namespace scopes in the documentation. If set to YES, the +# scope will be hidden. +# The default value is: NO. + +HIDE_SCOPE_NAMES = YES + +# If the HIDE_COMPOUND_REFERENCE tag is set to NO (default) then doxygen will +# append additional text to a page's title, such as Class Reference. If set to +# YES the compound reference will be hidden. +# The default value is: NO. + +HIDE_COMPOUND_REFERENCE= YES + +# If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of +# the files that are included by a file in the documentation of that file. +# The default value is: YES. + +SHOW_INCLUDE_FILES = YES + +# If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each +# grouped member an include statement to the documentation, telling the reader +# which file to include in order to use the member. +# The default value is: NO. + +SHOW_GROUPED_MEMB_INC = NO + +# If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include +# files with double quotes in the documentation rather than with sharp brackets. +# The default value is: NO. + +FORCE_LOCAL_INCLUDES = NO + +# If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the +# documentation for inline members. +# The default value is: YES. + +INLINE_INFO = YES + +# If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the +# (detailed) documentation of file and class members alphabetically by member +# name. If set to NO, the members will appear in declaration order. +# The default value is: YES. + +SORT_MEMBER_DOCS = YES + +# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief +# descriptions of file, namespace and class members alphabetically by member +# name. If set to NO, the members will appear in declaration order. Note that +# this will also influence the order of the classes in the class list. +# The default value is: NO. + +SORT_BRIEF_DOCS = NO + +# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the +# (brief and detailed) documentation of class members so that constructors and +# destructors are listed first. If set to NO the constructors will appear in the +# respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS. +# Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief +# member documentation. +# Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting +# detailed member documentation. +# The default value is: NO. + +SORT_MEMBERS_CTORS_1ST = NO + +# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy +# of group names into alphabetical order. If set to NO the group names will +# appear in their defined order. +# The default value is: NO. + +SORT_GROUP_NAMES = NO + +# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by +# fully-qualified names, including namespaces. If set to NO, the class list will +# be sorted only by class name, not including the namespace part. +# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. +# Note: This option applies only to the class list, not to the alphabetical +# list. +# The default value is: NO. + +SORT_BY_SCOPE_NAME = NO + +# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper +# type resolution of all parameters of a function it will reject a match between +# the prototype and the implementation of a member function even if there is +# only one candidate or it is obvious which candidate to choose by doing a +# simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still +# accept a match between prototype and implementation in such cases. +# The default value is: NO. + +STRICT_PROTO_MATCHING = NO + +# The GENERATE_TODOLIST tag can be used to enable (YES) or disable (NO) the todo +# list. This list is created by putting \todo commands in the documentation. +# The default value is: YES. + +GENERATE_TODOLIST = YES + +# The GENERATE_TESTLIST tag can be used to enable (YES) or disable (NO) the test +# list. This list is created by putting \test commands in the documentation. +# The default value is: YES. + +GENERATE_TESTLIST = YES + +# The GENERATE_BUGLIST tag can be used to enable (YES) or disable (NO) the bug +# list. This list is created by putting \bug commands in the documentation. +# The default value is: YES. + +GENERATE_BUGLIST = YES + +# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or disable (NO) +# the deprecated list. This list is created by putting \deprecated commands in +# the documentation. +# The default value is: YES. + +GENERATE_DEPRECATEDLIST= YES + +# The ENABLED_SECTIONS tag can be used to enable conditional documentation +# sections, marked by \if ... \endif and \cond +# ... \endcond blocks. + +ENABLED_SECTIONS = + +# The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the +# initial value of a variable or macro / define can have for it to appear in the +# documentation. If the initializer consists of more lines than specified here +# it will be hidden. Use a value of 0 to hide initializers completely. The +# appearance of the value of individual variables and macros / defines can be +# controlled using \showinitializer or \hideinitializer command in the +# documentation regardless of this setting. +# Minimum value: 0, maximum value: 10000, default value: 30. + +MAX_INITIALIZER_LINES = 30 + +# Set the SHOW_USED_FILES tag to NO to disable the list of files generated at +# the bottom of the documentation of classes and structs. If set to YES, the +# list will mention the files that were used to generate the documentation. +# The default value is: YES. + +SHOW_USED_FILES = YES + +# Set the SHOW_FILES tag to NO to disable the generation of the Files page. This +# will remove the Files entry from the Quick Index and from the Folder Tree View +# (if specified). +# The default value is: YES. + +SHOW_FILES = YES + +# Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces +# page. This will remove the Namespaces entry from the Quick Index and from the +# Folder Tree View (if specified). +# The default value is: YES. + +SHOW_NAMESPACES = YES + +# The FILE_VERSION_FILTER tag can be used to specify a program or script that +# doxygen should invoke to get the current version for each file (typically from +# the version control system). Doxygen will invoke the program by executing (via +# popen()) the command command input-file, where command is the value of the +# FILE_VERSION_FILTER tag, and input-file is the name of an input file provided +# by doxygen. Whatever the program writes to standard output is used as the file +# version. For an example see the documentation. + +FILE_VERSION_FILTER = + +# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed +# by doxygen. The layout file controls the global structure of the generated +# output files in an output format independent way. To create the layout file +# that represents doxygen's defaults, run doxygen with the -l option. You can +# optionally specify a file name after the option, if omitted DoxygenLayout.xml +# will be used as the name of the layout file. +# +# Note that if you run doxygen from a directory containing a file called +# DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE +# tag is left empty. + +LAYOUT_FILE = + +# The CITE_BIB_FILES tag can be used to specify one or more bib files containing +# the reference definitions. This must be a list of .bib files. The .bib +# extension is automatically appended if omitted. This requires the bibtex tool +# to be installed. See also https://en.wikipedia.org/wiki/BibTeX for more info. +# For LaTeX the style of the bibliography can be controlled using +# LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the +# search path. See also \cite for info how to create references. + +CITE_BIB_FILES = + +#--------------------------------------------------------------------------- +# Configuration options related to warning and progress messages +#--------------------------------------------------------------------------- + +# The QUIET tag can be used to turn on/off the messages that are generated to +# standard output by doxygen. If QUIET is set to YES this implies that the +# messages are off. +# The default value is: NO. + +QUIET = YES + +# The WARNINGS tag can be used to turn on/off the warning messages that are +# generated to standard error (stderr) by doxygen. If WARNINGS is set to YES +# this implies that the warnings are on. +# +# Tip: Turn warnings on while writing the documentation. +# The default value is: YES. + +WARNINGS = YES + +# If the WARN_IF_UNDOCUMENTED tag is set to YES then doxygen will generate +# warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag +# will automatically be disabled. +# The default value is: YES. + +WARN_IF_UNDOCUMENTED = NO + +# If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for +# potential errors in the documentation, such as not documenting some parameters +# in a documented function, or documenting parameters that don't exist or using +# markup commands wrongly. +# The default value is: YES. + +WARN_IF_DOC_ERROR = YES + +# This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that +# are documented, but have no documentation for their parameters or return +# value. If set to NO, doxygen will only warn about wrong or incomplete +# parameter documentation, but not about the absence of documentation. If +# EXTRACT_ALL is set to YES then this flag will automatically be disabled. +# The default value is: NO. + +WARN_NO_PARAMDOC = NO + +# If the WARN_AS_ERROR tag is set to YES then doxygen will immediately stop when +# a warning is encountered. +# The default value is: NO. + +WARN_AS_ERROR = NO + +# The WARN_FORMAT tag determines the format of the warning messages that doxygen +# can produce. The string should contain the $file, $line, and $text tags, which +# will be replaced by the file and line number from which the warning originated +# and the warning text. Optionally the format may contain $version, which will +# be replaced by the version of the file (if it could be obtained via +# FILE_VERSION_FILTER) +# The default value is: $file:$line: $text. + +WARN_FORMAT = "$file:$line: $text" + +# The WARN_LOGFILE tag can be used to specify a file to which warning and error +# messages should be written. If left blank the output is written to standard +# error (stderr). + +WARN_LOGFILE = + +#--------------------------------------------------------------------------- +# Configuration options related to the input files +#--------------------------------------------------------------------------- + +# The INPUT tag is used to specify the files and/or directories that contain +# documented source files. You may enter file names like myfile.cpp or +# directories like /usr/src/myproject. Separate the files or directories with +# spaces. See also FILE_PATTERNS and EXTENSION_MAPPING +# Note: If this tag is empty the current directory is searched. + +INPUT = ../../../cpp/oneapi/dal + +# This tag can be used to specify the character encoding of the source files +# that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses +# libiconv (or the iconv built into libc) for the transcoding. See the libiconv +# documentation (see: https://www.gnu.org/software/libiconv/) for the list of +# possible encodings. +# The default value is: UTF-8. + +INPUT_ENCODING = UTF-8 + +# If the value of the INPUT tag contains directories, you can use the +# FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and +# *.h) to filter out the source-files in the directories. +# +# Note that for custom extensions or not directly supported extensions you also +# need to set EXTENSION_MAPPING for the extension otherwise the files are not +# read by doxygen. +# +# If left blank the following patterns are tested:*.c, *.cc, *.cxx, *.cpp, +# *.c++, *.java, *.ii, *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h, +# *.hh, *.hxx, *.hpp, *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc, +# *.m, *.markdown, *.md, *.mm, *.dox (to be provided as doxygen C comment), +# *.doc (to be provided as doxygen C comment), *.txt (to be provided as doxygen +# C comment), *.py, *.pyw, *.f90, *.f95, *.f03, *.f08, *.f18, *.f, *.for, *.vhd, +# *.vhdl, *.ucf, *.qsf and *.ice. + +FILE_PATTERNS = *.hpp + +# The RECURSIVE tag can be used to specify whether or not subdirectories should +# be searched for input files as well. +# The default value is: NO. + +RECURSIVE = YES + +# The EXCLUDE tag can be used to specify files and/or directories that should be +# excluded from the INPUT source files. This way you can easily exclude a +# subdirectory from a directory tree whose root is specified with the INPUT tag. +# +# Note that relative paths are relative to the directory from which doxygen is +# run. + +EXCLUDE = + +# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or +# directories that are symbolic links (a Unix file system feature) are excluded +# from the input. +# The default value is: NO. + +EXCLUDE_SYMLINKS = NO + +# If the value of the INPUT tag contains directories, you can use the +# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude +# certain files from those directories. +# +# Note that the wildcards are matched against the file with absolute path, so to +# exclude all test directories for example use the pattern */test/* + +EXCLUDE_PATTERNS = */backend/* \ + */detail/* \ + */graph/* \ + */algo/jaccard/* + +# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names +# (namespaces, classes, functions, etc.) that should be excluded from the +# output. The symbol name can be a fully qualified name, a word, or if the +# wildcard * is used, a substring. Examples: ANamespace, AClass, +# AClass::ANamespace, ANamespace::*Test +# +# Note that the wildcards are matched against the file with absolute path, so to +# exclude all test directories use the pattern */test/* + +EXCLUDE_SYMBOLS = + +# The EXAMPLE_PATH tag can be used to specify one or more files or directories +# that contain example code fragments that are included (see the \include +# command). + +EXAMPLE_PATH = + +# If the value of the EXAMPLE_PATH tag contains directories, you can use the +# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and +# *.h) to filter out the source-files in the directories. If left blank all +# files are included. + +EXAMPLE_PATTERNS = * + +# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be +# searched for input files to be used with the \include or \dontinclude commands +# irrespective of the value of the RECURSIVE tag. +# The default value is: NO. + +EXAMPLE_RECURSIVE = NO + +# The IMAGE_PATH tag can be used to specify one or more files or directories +# that contain images that are to be included in the documentation (see the +# \image command). + +IMAGE_PATH = + +# The INPUT_FILTER tag can be used to specify a program that doxygen should +# invoke to filter for each input file. Doxygen will invoke the filter program +# by executing (via popen()) the command: +# +# +# +# where is the value of the INPUT_FILTER tag, and is the +# name of an input file. Doxygen will then use the output that the filter +# program writes to standard output. If FILTER_PATTERNS is specified, this tag +# will be ignored. +# +# Note that the filter must not add or remove lines; it is applied before the +# code is scanned, but not when the output code is generated. If lines are added +# or removed, the anchors will not be placed correctly. +# +# Note that for custom extensions or not directly supported extensions you also +# need to set EXTENSION_MAPPING for the extension otherwise the files are not +# properly processed by doxygen. + +INPUT_FILTER = + +# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern +# basis. Doxygen will compare the file name with each pattern and apply the +# filter if there is a match. The filters are a list of the form: pattern=filter +# (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how +# filters are used. If the FILTER_PATTERNS tag is empty or if none of the +# patterns match the file name, INPUT_FILTER is applied. +# +# Note that for custom extensions or not directly supported extensions you also +# need to set EXTENSION_MAPPING for the extension otherwise the files are not +# properly processed by doxygen. + +FILTER_PATTERNS = + +# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using +# INPUT_FILTER) will also be used to filter the input files that are used for +# producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES). +# The default value is: NO. + +FILTER_SOURCE_FILES = NO + +# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file +# pattern. A pattern will override the setting for FILTER_PATTERN (if any) and +# it is also possible to disable source filtering for a specific pattern using +# *.ext= (so without naming a filter). +# This tag requires that the tag FILTER_SOURCE_FILES is set to YES. + +FILTER_SOURCE_PATTERNS = + +# If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that +# is part of the input, its contents will be placed on the main page +# (index.html). This can be useful if you have a project on for instance GitHub +# and want to reuse the introduction page also for the doxygen output. + +USE_MDFILE_AS_MAINPAGE = + +#--------------------------------------------------------------------------- +# Configuration options related to source browsing +#--------------------------------------------------------------------------- + +# If the SOURCE_BROWSER tag is set to YES then a list of source files will be +# generated. Documented entities will be cross-referenced with these sources. +# +# Note: To get rid of all source code in the generated output, make sure that +# also VERBATIM_HEADERS is set to NO. +# The default value is: NO. + +SOURCE_BROWSER = NO + +# Setting the INLINE_SOURCES tag to YES will include the body of functions, +# classes and enums directly into the documentation. +# The default value is: NO. + +INLINE_SOURCES = NO + +# Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any +# special comment blocks from generated source code fragments. Normal C, C++ and +# Fortran comments will always remain visible. +# The default value is: YES. + +STRIP_CODE_COMMENTS = YES + +# If the REFERENCED_BY_RELATION tag is set to YES then for each documented +# entity all documented functions referencing it will be listed. +# The default value is: NO. + +REFERENCED_BY_RELATION = NO + +# If the REFERENCES_RELATION tag is set to YES then for each documented function +# all documented entities called/used by that function will be listed. +# The default value is: NO. + +REFERENCES_RELATION = NO + +# If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set +# to YES then the hyperlinks from functions in REFERENCES_RELATION and +# REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will +# link to the documentation. +# The default value is: YES. + +REFERENCES_LINK_SOURCE = YES + +# If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the +# source code will show a tooltip with additional information such as prototype, +# brief description and links to the definition and documentation. Since this +# will make the HTML file larger and loading of large files a bit slower, you +# can opt to disable this feature. +# The default value is: YES. +# This tag requires that the tag SOURCE_BROWSER is set to YES. + +SOURCE_TOOLTIPS = YES + +# If the USE_HTAGS tag is set to YES then the references to source code will +# point to the HTML generated by the htags(1) tool instead of doxygen built-in +# source browser. The htags tool is part of GNU's global source tagging system +# (see https://www.gnu.org/software/global/global.html). You will need version +# 4.8.6 or higher. +# +# To use it do the following: +# - Install the latest version of global +# - Enable SOURCE_BROWSER and USE_HTAGS in the configuration file +# - Make sure the INPUT points to the root of the source tree +# - Run doxygen as normal +# +# Doxygen will invoke htags (and that will in turn invoke gtags), so these +# tools must be available from the command line (i.e. in the search path). +# +# The result: instead of the source browser generated by doxygen, the links to +# source code will now point to the output of htags. +# The default value is: NO. +# This tag requires that the tag SOURCE_BROWSER is set to YES. + +USE_HTAGS = NO + +# If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a +# verbatim copy of the header file for each class for which an include is +# specified. Set to NO to disable this. +# See also: Section \class. +# The default value is: YES. + +VERBATIM_HEADERS = YES + +# If the CLANG_ASSISTED_PARSING tag is set to YES then doxygen will use the +# clang parser (see: http://clang.llvm.org/) for more accurate parsing at the +# cost of reduced performance. This can be particularly helpful with template +# rich C++ code for which doxygen's built-in parser lacks the necessary type +# information. +# Note: The availability of this option depends on whether or not doxygen was +# generated with the -Duse_libclang=ON option for CMake. +# The default value is: NO. + +CLANG_ASSISTED_PARSING = NO + +# If clang assisted parsing is enabled you can provide the compiler with command +# line options that you would normally use when invoking the compiler. Note that +# the include paths will already be set by doxygen for the files and directories +# specified with INPUT and INCLUDE_PATH. +# This tag requires that the tag CLANG_ASSISTED_PARSING is set to YES. + +CLANG_OPTIONS = + +# If clang assisted parsing is enabled you can provide the clang parser with the +# path to the directory containing a file called compile_commands.json. This +# file is the compilation database (see: +# http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html) containing the +# options used when the source files were built. This is equivalent to +# specifying the "-p" option to a clang tool, such as clang-check. These options +# will then be passed to the parser. Any options specified with CLANG_OPTIONS +# will be added as well. +# Note: The availability of this option depends on whether or not doxygen was +# generated with the -Duse_libclang=ON option for CMake. + +CLANG_DATABASE_PATH = + +#--------------------------------------------------------------------------- +# Configuration options related to the alphabetical class index +#--------------------------------------------------------------------------- + +# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all +# compounds will be generated. Enable this if the project contains a lot of +# classes, structs, unions or interfaces. +# The default value is: YES. + +ALPHABETICAL_INDEX = YES + +# The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in +# which the alphabetical index list will be split. +# Minimum value: 1, maximum value: 20, default value: 5. +# This tag requires that the tag ALPHABETICAL_INDEX is set to YES. + +COLS_IN_ALPHA_INDEX = 5 + +# In case all classes in a project start with a common prefix, all classes will +# be put under the same header in the alphabetical index. The IGNORE_PREFIX tag +# can be used to specify a prefix (or a list of prefixes) that should be ignored +# while generating the index headers. +# This tag requires that the tag ALPHABETICAL_INDEX is set to YES. + +IGNORE_PREFIX = + +#--------------------------------------------------------------------------- +# Configuration options related to the HTML output +#--------------------------------------------------------------------------- + +# If the GENERATE_HTML tag is set to YES, doxygen will generate HTML output +# The default value is: YES. + +GENERATE_HTML = NO + +# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a +# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of +# it. +# The default directory is: html. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_OUTPUT = html + +# The HTML_FILE_EXTENSION tag can be used to specify the file extension for each +# generated HTML page (for example: .htm, .php, .asp). +# The default value is: .html. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_FILE_EXTENSION = .html + +# The HTML_HEADER tag can be used to specify a user-defined HTML header file for +# each generated HTML page. If the tag is left blank doxygen will generate a +# standard header. +# +# To get valid HTML the header file that includes any scripts and style sheets +# that doxygen needs, which is dependent on the configuration options used (e.g. +# the setting GENERATE_TREEVIEW). It is highly recommended to start with a +# default header using +# doxygen -w html new_header.html new_footer.html new_stylesheet.css +# YourConfigFile +# and then modify the file new_header.html. See also section "Doxygen usage" +# for information on how to generate the default header that doxygen normally +# uses. +# Note: The header is subject to change so you typically have to regenerate the +# default header when upgrading to a newer version of doxygen. For a description +# of the possible markers and block names see the documentation. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_HEADER = + +# The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each +# generated HTML page. If the tag is left blank doxygen will generate a standard +# footer. See HTML_HEADER for more information on how to generate a default +# footer and what special commands can be used inside the footer. See also +# section "Doxygen usage" for information on how to generate the default footer +# that doxygen normally uses. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_FOOTER = + +# The HTML_STYLESHEET tag can be used to specify a user-defined cascading style +# sheet that is used by each HTML page. It can be used to fine-tune the look of +# the HTML output. If left blank doxygen will generate a default style sheet. +# See also section "Doxygen usage" for information on how to generate the style +# sheet that doxygen normally uses. +# Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as +# it is more robust and this tag (HTML_STYLESHEET) will in the future become +# obsolete. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_STYLESHEET = + +# The HTML_EXTRA_STYLESHEET tag can be used to specify additional user-defined +# cascading style sheets that are included after the standard style sheets +# created by doxygen. Using this option one can overrule certain style aspects. +# This is preferred over using HTML_STYLESHEET since it does not replace the +# standard style sheet and is therefore more robust against future updates. +# Doxygen will copy the style sheet files to the output directory. +# Note: The order of the extra style sheet files is of importance (e.g. the last +# style sheet in the list overrules the setting of the previous ones in the +# list). For an example see the documentation. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_EXTRA_STYLESHEET = + +# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or +# other source files which should be copied to the HTML output directory. Note +# that these files will be copied to the base HTML output directory. Use the +# $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these +# files. In the HTML_STYLESHEET file, use the file name only. Also note that the +# files will be copied as-is; there are no commands or markers available. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_EXTRA_FILES = + +# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen +# will adjust the colors in the style sheet and background images according to +# this color. Hue is specified as an angle on a colorwheel, see +# https://en.wikipedia.org/wiki/Hue for more information. For instance the value +# 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300 +# purple, and 360 is red again. +# Minimum value: 0, maximum value: 359, default value: 220. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_COLORSTYLE_HUE = 220 + +# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors +# in the HTML output. For a value of 0 the output will use grayscales only. A +# value of 255 will produce the most vivid colors. +# Minimum value: 0, maximum value: 255, default value: 100. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_COLORSTYLE_SAT = 100 + +# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the +# luminance component of the colors in the HTML output. Values below 100 +# gradually make the output lighter, whereas values above 100 make the output +# darker. The value divided by 100 is the actual gamma applied, so 80 represents +# a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not +# change the gamma. +# Minimum value: 40, maximum value: 240, default value: 80. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_COLORSTYLE_GAMMA = 80 + +# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML +# page will contain the date and time when the page was generated. Setting this +# to YES can help to show when doxygen was last run and thus if the +# documentation is up to date. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_TIMESTAMP = NO + +# If the HTML_DYNAMIC_MENUS tag is set to YES then the generated HTML +# documentation will contain a main index with vertical navigation menus that +# are dynamically created via JavaScript. If disabled, the navigation index will +# consists of multiple levels of tabs that are statically embedded in every HTML +# page. Disable this option to support browsers that do not have JavaScript, +# like the Qt help browser. +# The default value is: YES. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_DYNAMIC_MENUS = YES + +# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML +# documentation will contain sections that can be hidden and shown after the +# page has loaded. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_DYNAMIC_SECTIONS = NO + +# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries +# shown in the various tree structured indices initially; the user can expand +# and collapse entries dynamically later on. Doxygen will expand the tree to +# such a level that at most the specified number of entries are visible (unless +# a fully collapsed tree already exceeds this amount). So setting the number of +# entries 1 will produce a full collapsed tree by default. 0 is a special value +# representing an infinite number of entries and will result in a full expanded +# tree by default. +# Minimum value: 0, maximum value: 9999, default value: 100. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_INDEX_NUM_ENTRIES = 100 + +# If the GENERATE_DOCSET tag is set to YES, additional index files will be +# generated that can be used as input for Apple's Xcode 3 integrated development +# environment (see: https://developer.apple.com/xcode/), introduced with OSX +# 10.5 (Leopard). To create a documentation set, doxygen will generate a +# Makefile in the HTML output directory. Running make will produce the docset in +# that directory and running make install will install the docset in +# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at +# startup. See https://developer.apple.com/library/archive/featuredarticles/Doxy +# genXcode/_index.html for more information. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_DOCSET = NO + +# This tag determines the name of the docset feed. A documentation feed provides +# an umbrella under which multiple documentation sets from a single provider +# (such as a company or product suite) can be grouped. +# The default value is: Doxygen generated docs. +# This tag requires that the tag GENERATE_DOCSET is set to YES. + +DOCSET_FEEDNAME = "Doxygen generated docs" + +# This tag specifies a string that should uniquely identify the documentation +# set bundle. This should be a reverse domain-name style string, e.g. +# com.mycompany.MyDocSet. Doxygen will append .docset to the name. +# The default value is: org.doxygen.Project. +# This tag requires that the tag GENERATE_DOCSET is set to YES. + +DOCSET_BUNDLE_ID = org.doxygen.Project + +# The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify +# the documentation publisher. This should be a reverse domain-name style +# string, e.g. com.mycompany.MyDocSet.documentation. +# The default value is: org.doxygen.Publisher. +# This tag requires that the tag GENERATE_DOCSET is set to YES. + +DOCSET_PUBLISHER_ID = org.doxygen.Publisher + +# The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher. +# The default value is: Publisher. +# This tag requires that the tag GENERATE_DOCSET is set to YES. + +DOCSET_PUBLISHER_NAME = Publisher + +# If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three +# additional HTML index files: index.hhp, index.hhc, and index.hhk. The +# index.hhp is a project file that can be read by Microsoft's HTML Help Workshop +# (see: https://www.microsoft.com/en-us/download/details.aspx?id=21138) on +# Windows. +# +# The HTML Help Workshop contains a compiler that can convert all HTML output +# generated by doxygen into a single compiled HTML file (.chm). Compiled HTML +# files are now used as the Windows 98 help format, and will replace the old +# Windows help format (.hlp) on all Windows platforms in the future. Compressed +# HTML files also contain an index, a table of contents, and you can search for +# words in the documentation. The HTML workshop also contains a viewer for +# compressed HTML files. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_HTMLHELP = NO + +# The CHM_FILE tag can be used to specify the file name of the resulting .chm +# file. You can add a path in front of the file if the result should not be +# written to the html output directory. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +CHM_FILE = + +# The HHC_LOCATION tag can be used to specify the location (absolute path +# including file name) of the HTML help compiler (hhc.exe). If non-empty, +# doxygen will try to run the HTML help compiler on the generated index.hhp. +# The file has to be specified with full path. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +HHC_LOCATION = + +# The GENERATE_CHI flag controls if a separate .chi index file is generated +# (YES) or that it should be included in the main .chm file (NO). +# The default value is: NO. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +GENERATE_CHI = NO + +# The CHM_INDEX_ENCODING is used to encode HtmlHelp index (hhk), content (hhc) +# and project file content. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +CHM_INDEX_ENCODING = + +# The BINARY_TOC flag controls whether a binary table of contents is generated +# (YES) or a normal table of contents (NO) in the .chm file. Furthermore it +# enables the Previous and Next buttons. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +BINARY_TOC = NO + +# The TOC_EXPAND flag can be set to YES to add extra items for group members to +# the table of contents of the HTML help documentation and to the tree view. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +TOC_EXPAND = NO + +# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and +# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that +# can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help +# (.qch) of the generated HTML documentation. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_QHP = NO + +# If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify +# the file name of the resulting .qch file. The path specified is relative to +# the HTML output folder. +# This tag requires that the tag GENERATE_QHP is set to YES. + +QCH_FILE = + +# The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help +# Project output. For more information please see Qt Help Project / Namespace +# (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#namespace). +# The default value is: org.doxygen.Project. +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_NAMESPACE = org.doxygen.Project + +# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt +# Help Project output. For more information please see Qt Help Project / Virtual +# Folders (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#virtual- +# folders). +# The default value is: doc. +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_VIRTUAL_FOLDER = doc + +# If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom +# filter to add. For more information please see Qt Help Project / Custom +# Filters (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom- +# filters). +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_CUST_FILTER_NAME = + +# The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the +# custom filter to add. For more information please see Qt Help Project / Custom +# Filters (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom- +# filters). +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_CUST_FILTER_ATTRS = + +# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this +# project's filter section matches. Qt Help Project / Filter Attributes (see: +# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#filter-attributes). +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_SECT_FILTER_ATTRS = + +# The QHG_LOCATION tag can be used to specify the location of Qt's +# qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the +# generated .qhp file. +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHG_LOCATION = + +# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be +# generated, together with the HTML files, they form an Eclipse help plugin. To +# install this plugin and make it available under the help contents menu in +# Eclipse, the contents of the directory containing the HTML and XML files needs +# to be copied into the plugins directory of eclipse. The name of the directory +# within the plugins directory should be the same as the ECLIPSE_DOC_ID value. +# After copying Eclipse needs to be restarted before the help appears. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_ECLIPSEHELP = NO + +# A unique identifier for the Eclipse help plugin. When installing the plugin +# the directory name containing the HTML and XML files should also have this +# name. Each documentation set should have its own identifier. +# The default value is: org.doxygen.Project. +# This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES. + +ECLIPSE_DOC_ID = org.doxygen.Project + +# If you want full control over the layout of the generated HTML pages it might +# be necessary to disable the index and replace it with your own. The +# DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top +# of each HTML page. A value of NO enables the index and the value YES disables +# it. Since the tabs in the index contain the same information as the navigation +# tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +DISABLE_INDEX = NO + +# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index +# structure should be generated to display hierarchical information. If the tag +# value is set to YES, a side panel will be generated containing a tree-like +# index structure (just like the one that is generated for HTML Help). For this +# to work a browser that supports JavaScript, DHTML, CSS and frames is required +# (i.e. any modern browser). Windows users are probably better off using the +# HTML help feature. Via custom style sheets (see HTML_EXTRA_STYLESHEET) one can +# further fine-tune the look of the index. As an example, the default style +# sheet generated by doxygen has an example that shows how to put an image at +# the root of the tree instead of the PROJECT_NAME. Since the tree basically has +# the same information as the tab index, you could consider setting +# DISABLE_INDEX to YES when enabling this option. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_TREEVIEW = NO + +# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that +# doxygen will group on one line in the generated HTML documentation. +# +# Note that a value of 0 will completely suppress the enum values from appearing +# in the overview section. +# Minimum value: 0, maximum value: 20, default value: 4. +# This tag requires that the tag GENERATE_HTML is set to YES. + +ENUM_VALUES_PER_LINE = 4 + +# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used +# to set the initial width (in pixels) of the frame in which the tree is shown. +# Minimum value: 0, maximum value: 1500, default value: 250. +# This tag requires that the tag GENERATE_HTML is set to YES. + +TREEVIEW_WIDTH = 250 + +# If the EXT_LINKS_IN_WINDOW option is set to YES, doxygen will open links to +# external symbols imported via tag files in a separate window. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +EXT_LINKS_IN_WINDOW = NO + +# If the HTML_FORMULA_FORMAT option is set to svg, doxygen will use the pdf2svg +# tool (see https://github.com/dawbarton/pdf2svg) or inkscape (see +# https://inkscape.org) to generate formulas as SVG images instead of PNGs for +# the HTML output. These images will generally look nicer at scaled resolutions. +# Possible values are: png (the default) and svg (looks nicer but requires the +# pdf2svg or inkscape tool). +# The default value is: png. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_FORMULA_FORMAT = png + +# Use this tag to change the font size of LaTeX formulas included as images in +# the HTML documentation. When you change the font size after a successful +# doxygen run you need to manually remove any form_*.png images from the HTML +# output directory to force them to be regenerated. +# Minimum value: 8, maximum value: 50, default value: 10. +# This tag requires that the tag GENERATE_HTML is set to YES. + +FORMULA_FONTSIZE = 10 + +# Use the FORMULA_TRANSPARENT tag to determine whether or not the images +# generated for formulas are transparent PNGs. Transparent PNGs are not +# supported properly for IE 6.0, but are supported on all modern browsers. +# +# Note that when changing this option you need to delete any form_*.png files in +# the HTML output directory before the changes have effect. +# The default value is: YES. +# This tag requires that the tag GENERATE_HTML is set to YES. + +FORMULA_TRANSPARENT = YES + +# The FORMULA_MACROFILE can contain LaTeX \newcommand and \renewcommand commands +# to create new LaTeX commands to be used in formulas as building blocks. See +# the section "Including formulas" for details. + +FORMULA_MACROFILE = + +# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see +# https://www.mathjax.org) which uses client side JavaScript for the rendering +# instead of using pre-rendered bitmaps. Use this if you do not have LaTeX +# installed or if you want to formulas look prettier in the HTML output. When +# enabled you may also need to install MathJax separately and configure the path +# to it using the MATHJAX_RELPATH option. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +USE_MATHJAX = NO + +# When MathJax is enabled you can set the default output format to be used for +# the MathJax output. See the MathJax site (see: +# http://docs.mathjax.org/en/latest/output.html) for more details. +# Possible values are: HTML-CSS (which is slower, but has the best +# compatibility), NativeMML (i.e. MathML) and SVG. +# The default value is: HTML-CSS. +# This tag requires that the tag USE_MATHJAX is set to YES. + +MATHJAX_FORMAT = HTML-CSS + +# When MathJax is enabled you need to specify the location relative to the HTML +# output directory using the MATHJAX_RELPATH option. The destination directory +# should contain the MathJax.js script. For instance, if the mathjax directory +# is located at the same level as the HTML output directory, then +# MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax +# Content Delivery Network so you can quickly see the result without installing +# MathJax. However, it is strongly recommended to install a local copy of +# MathJax from https://www.mathjax.org before deployment. +# The default value is: https://cdn.jsdelivr.net/npm/mathjax@2. +# This tag requires that the tag USE_MATHJAX is set to YES. + +MATHJAX_RELPATH = https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/ + +# The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax +# extension names that should be enabled during MathJax rendering. For example +# MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols +# This tag requires that the tag USE_MATHJAX is set to YES. + +MATHJAX_EXTENSIONS = + +# The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces +# of code that will be used on startup of the MathJax code. See the MathJax site +# (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an +# example see the documentation. +# This tag requires that the tag USE_MATHJAX is set to YES. + +MATHJAX_CODEFILE = + +# When the SEARCHENGINE tag is enabled doxygen will generate a search box for +# the HTML output. The underlying search engine uses javascript and DHTML and +# should work on any modern browser. Note that when using HTML help +# (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET) +# there is already a search function so this one should typically be disabled. +# For large projects the javascript based search engine can be slow, then +# enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to +# search using the keyboard; to jump to the search box use + S +# (what the is depends on the OS and browser, but it is typically +# , /