class BindTool(object):

target_bindings = 'pybind11'

def __init__(self):

import hashlib

import re

class BindingGenerator:

"""Initialize BindingGenerator

prefix -- path to installed gnuradio prefix (use gr.prefix() if unsure)

namespace -- desired namespace to parse e.g. ['gr','module_name']

output_dir -- path where bindings will be placed

define_symbols -- comma separated tuple of defines

addl_includes -- comma separated list of additional include directories (default "")

If set to False, a bindings/ dir will be placed directly under the specified output_dir

If set to True, the directory structure under include/ will be mirrored

"""

self.header_extensions = ['.h', '.hh', '.hpp']

self.addl_include = addl_includes

self.prefix = prefix

self.namespace = namespace

tpl = Template(filename=os.path.join(current_path, '..',

'templates', 'generic_python_cc.mako'))

return tpl.render(

license=license,

header_info=header_info,

header_info = json.load(fp)

return header_info

"""Update the hash in blockname_python.cc python bindings"""

output_dir = self.get_output_dir(file_to_process)

with open(binding_pathname_cc, 'r') as f:

file_contents = f.read()

with open(binding_pathname_cc, 'w') as updated_f:

updated_f.write(new_file_contents)

print(f"Update hash in {binding_pathname_cc} to {newhash}")

def gen_file_binding(self, file_to_process):

"""Produce the blockname_python.cc python bindings"""

output_dir = self.get_output_dir(file_to_process)

base_name = os.path.splitext(os.path.basename(file_to_process))[0]

module_include_path = os.path.abspath(os.path.dirname(file_to_process))

top_include_path = os.path.join(

include_paths = ','.join(

(module_include_path, top_include_path))

include_paths = ','.join((include_paths, self.addl_include))

parser = GenericHeaderParser(

try:

header_info = parser.get_header_info(self.namespace)

if self.write_json_output:

self.write_json(header_info, base_name, output_dir)

self.write_pybind_cc(header_info, base_name, output_dir)

output_dir = self.output_dir

rel_path_after_include = ""

if self.match_include_structure:

rel_path_after_include = os.path.split(

output_dir = os.path.join(

self.output_dir, rel_path_after_include, 'bindings')

def gen_bindings(self, module_dir):

"""Generate bindings for an entire GR module

for each block in the module

module_dir -- path to the include directory where the public headers live

from gnuradio.bindtool import BindingGenerator

import pathlib

parser.add_argument('pathnames', type=str, nargs='+',

help='Json files to bind')

bg = BindingGenerator()

for p in args.pathnames:

help='Output directory of generated bindings')

parser.add_argument('--prefix', help='Prefix of Installed GNU Radio')

parser.add_argument('--src', help='Directory of gnuradio source tree',

parser.add_argument(

'--include', help='Additional Include Dirs, comma separated', default='')

args = parser.parse_args()

# /usr/include/x86_64-linux-gnu/qt5/QtCore,/usr/include/x86_64-linux-gnu/qt5/QtWidgets,/usr/include/qwt qtgui

# To generate UHD requires adding the UHD headers, e.g.

# --output_dir /share/tmp/take5 uhd

includes = args.include

for name in args.names:

if name not in ['gr', 'pmt']:

module_dir = os.path.abspath(

else:

namespace = [name]

module_dir = os.path.abspath(os.path.join(

help='Output directory of generated bindings')

parser.add_argument('--prefix', help='Prefix of Installed GNU Radio')

parser.add_argument('--src', help='Directory of gnuradio source tree',

parser.add_argument(

'--filename', help="File to be parsed")

if name not in ['gr', 'pmt']:

namespace = ['gr', name]

else:

namespace = [name]

if name == 'gr':

bg = BindingGenerator(args.prefix, namespace,

prefix_include_root, output_dir, addl_includes=','.join(args.include), catch_exceptions=False, write_json_output=False, status_output=args.status,

bg.gen_file_binding(args.filename)

class PybindHeaderParser:

def __init__(self, pathname):

try:

self.file_txt = f.read()

except:

self.file_txt = ""

except:

return None

def get_header_file_hash(self):

try:

if (m):

return m.group(1)

else:

return f'{self.get_flag_automatic()};{self.get_flag_pygccxml()};{self.get_header_filename()};{self.get_header_file_hash()};'

def argParse():

"""Parses commandline args."""

parser = ArgumentParser(description=desc)

return parser.parse_args()

if __name__ == "__main__":

# Parse command line options and set up doxyxml.

args = argParse()

elif args.function == "header_filename":

print(pbhp.get_header_filename())

elif args.function == "header_file_hash":

elif args.function == "all":

# This file is part of GNU Radio

#

# SPDX-License-Identifier: GPL-2.0-or-later

#

""" main function to run the blocktool api from the command line. """

header = parser.filename.split('.')[0]

block = parser.modname.split('-')[-1]

if kwargs['output']:

with open(json_file, 'w') as _file:

json.dump(parser.parsed_data, _file, indent=4)

else:

json_generator(parse_dir, **kwargs)

except:

logging.basicConfig(level=logging.DEBUG,

logging.exception(

'Log for Exception raised for the header: {}\n'.format(header))

click.secho('Parsing unsuccessful: {}'.format(

_index = lines.index(line)

if _index is not None:

for num in range(_index, len(lines)):

if Constants.END_BLOCKTOOL in lines[num]:

break

if _index is None:

with open(self.target_file, 'a') as header:

header.write('\n')

header.write('input_signature: ' +

parsed_io['input']['signature'] + '\n')

header.write('input_min_streams: ' +

for signature in Constants.SIGNATURE_LIST:

if signature in io_func[0] and parsed_io['input']['signature'] is None:

parsed_io['input']['signature'] = signature

if signature in io_func[1] and parsed_io['output']['signature'] is None:

parsed_io['output']['signature'] = signature

io_elements = []

for _io in io_func:

_io = _io.split(',')

if re.findall(r'"([^"]*)"', port)[0]:

input_port.append(re.findall(r'"([^"]*)"', port)[0])

else:

_temp_port = ''.join(map(str, input_port))

input_port.clear()

input_port.append(_temp_port)

if re.findall(r'"([^"]*)"', port)[0]:

output_port.append(re.findall(r'"([^"]*)"', port)[0])

else:

_temp_port = ''.join(map(str, output_port))

output_port.clear()

output_port.append(_temp_port)

""" Module to generate AST for the headers and parse it """

import os

import re

import codecs

PYGCCXML_AVAILABLE = False

# ugly hack to make pygccxml work with Python >= 3.8

try:

time.clock

except:

except:

pass

LOGGER = logging.getLogger(__name__)

if dirs.path.endswith('lib'):

self.impldir = dirs.path

self.impl_file = os.path.join(self.impldir,

def validate(self):

""" Override the Blocktool validate function """

self.parsed_data['member_functions'] = []

query_methods = declarations.access_type_matcher_t('public')

functions = main_class.member_functions(function=query_methods,

if functions:

for fcn in functions:

fcn_args = {

"name": str(fcn.name),

"arguments": []

"default": argument.default_value

}

fcn_args['arguments'].append(args.copy())

except RuntimeError:

self.parsed_data['member_functions'] = []

""" Module to generate AST for the headers and parse it """

import os

import re

import codecs

LOGGER = logging.getLogger(__name__)

PYGCCXML_AVAILABLE = False

# ugly hack to make pygccxml work with Python >= 3.8

try:

time.clock

except:

from ...modtool.tools import ParserCCBlock

from ...modtool.cli import ModToolException

class GenericHeaderParser(BlockTool):

"""

: Single argument required: file_path

name = 'Block Parse Header'

description = 'Create a parsed output from a block header file'

""" __init__ """

BlockTool.__init__(self, **kwargs)

self.parsed_data = {}

file_path = os.path.abspath(file_path)

self.target_file = file_path

self.initialize()

self.validate()

if not os.path.basename(self.module).startswith(Constants.GR):

self.module = os.path.abspath(

os.path.join(self.module, os.pardir))

self.modname = os.path.basename(self.module)

self.filename = os.path.basename(self.target_file)

self.targetdir = os.path.dirname(self.target_file)

fname_h))[0]

fname_cc = blockname + '_impl' + '.cc'

contains_modulename = blockname.startswith(

return (blockname, fname_cc, contains_modulename)

# Go, go, go

LOGGER.info("Making GRC bindings for {}...".format(fname_h))

"Can't open some of the files necessary to parse {}.".format(fname_cc))

if contains_modulename:

else:

return (parser.read_params(), parser.read_io_signature(), blockname)

allow_empty=True, recursive=False,

header_file=self.target_file)

for fcn in functions:

member_functions.append(self.parse_function(fcn))

class_dict['member_functions'] = member_functions

mf_dict = {

"name": "make",

"has_static": "1"

}

args = []

for p in params:

arg_dict = {

}

args.append(arg_dict)

raise BlockToolException('namespace cannot be none')

self.parsed_data['target_namespace'] = namespace_to_parse

# except RuntimeError:

# raise BlockToolException(

"""Adds a block to the out-of-tree module."""

kwargs['cli'] = True

self = ModToolAdd(**kwargs)

get_blockname(self)

get_blocktype(self)

get_lang(self)

info_lang = {'cpp': 'C++', 'python': 'Python'}[self.info['lang']]

click.secho(f"Language: {info_lang}", fg='green')

raise ModToolException('Missing or skipping relevant subdir.')

click.secho("Block/code identifier: " + self.info['blockname'], fg='green')

if not self.license_file:

get_py_qa(self)

get_cpp_qa(self)

if self.info['version'] == 'autofoo' and not self.skip_cmakefiles:

"Files will be created, but Makefiles will not be edited.",

fg='yellow')

self.skip_cmakefiles = True

run(self)

def get_blocktype(self):

""" Get the blocktype of the block to be added """

if self.info['blocktype'] is None:

while self.info['blocktype'] not in self.block_types:

self.info['blocktype'] = cli_input("Enter block type: ")

if self.info['blocktype'] not in self.block_types:

def get_lang(self):

""" Get the Programming Language of the block to be added """

if self.info['lang'] == 'c++':

self.info['lang'] = 'cpp'

def get_blockname(self):

""" Get the blockname"""

if not self.info['blockname'] or self.info['blockname'].isspace():

while not self.info['blockname'] or self.info['blockname'].isspace():

validate_name('block', self.info['blockname'])

fname_grc = self.info['fullblockname'] + '.block.yml'

for block in os.scandir('./grc/'):

if block.is_file():

s = block.name

if s == fname_grc:

raise ModToolException('Block Already Present.')

def get_copyrightholder(self):

""" Get the copyrightholder of the block to be added """

if not self.info['copyrightholder'] or self.info['copyrightholder'].isspace():

else:

copyright_candidates = (user, 'GNU Radio')

with SequenceCompleter(copyright_candidates):

if not self.info['copyrightholder'] or self.info['copyrightholder'].isspace():

self.info['copyrightholder'] = f'gr-{self.info["modname"]} author'

elif self.info['is_component']:

click.secho("For GNU Radio components the FSF is added as copyright holder",

fg='cyan')

def get_arglist(self):

""" Get the argument list of the block to be added """

if self.info['arglist'] is None:

self.info['arglist'] = click.prompt(click.style(

'Enter valid argument list, including default arguments: \n',

fg='cyan'),

def get_py_qa(self):

""" Get a boolean value for addition of py_qa """

if self.add_py_qa is None:

if not (self.info['blocktype'] in ('noblock') or self.skip_subdirs['python']):

else:

self.add_py_qa = False

def get_cpp_qa(self):

""" Get a boolean value for addition of cpp_qa """

if self.add_cc_qa is None:

class ModToolException(ClickException):

""" Exception class for enhanced CLI interface """

""" displays the colored message """

click.secho(f'ModToolException: {self.format_message()}', fg='red')

StreamHandler which overrides some of its functional

definitions to add colors to the stream output

"""

def emit(self, record):

""" Writes message to the stream """

colormap = {

return wrapper

@with_plugins(iter_entry_points('gnuradio.modtool.cli.plugins'))

@click.command('bind', short_help=ModToolGenBindings.description)

@click.option('-o', '--output', is_flag=True,

@click.option('-D', '--define_symbols', multiple=True, default=None,

@common_params

@block_name

def cli(**kwargs):

"""

kwargs['cli'] = True

self = ModToolGenBindings(**kwargs)

get_pattern(self)

run(self)

def get_pattern(self):

""" Get the regex pattern for block(s) to be parsed """

if self.info['pattern'] is None:

block_candidates = get_block_candidates()

with SequenceCompleter(block_candidates):

if not self.info['pattern'] or self.info['pattern'].isspace():

self.info['pattern'] = '.'

"""Disable a block (comments out CMake entries for files)"""

kwargs['cli'] = True

self = ModToolDisable(**kwargs)

get_pattern(self)

run(self)

def get_pattern(self):

""" Get the regex pattern for block(s) to be disabled """

if self.info['pattern'] is None:

block_candidates = get_block_candidates()

with SequenceCompleter(block_candidates):

if not self.info['pattern'] or self.info['pattern'].isspace():

self.info['pattern'] = '.'

if kwargs['blocktool']:

kwargs['modtool'] = True

if kwargs['blockname'] is None:

kwargs['file_path'] = os.path.abspath(kwargs['blockname'])

if os.path.isfile(kwargs['file_path']):

parse_yml = BlockHeaderParser(**kwargs)

raise BlockToolException('Invalid file path.')

else:

self = ModToolMakeYAML(**kwargs)

get_pattern(self)

run(self)

def get_pattern(self):

""" Get the regex pattern for block(s) to be parsed """

if self.info['pattern'] is None:

block_candidates = get_block_candidates()

with SequenceCompleter(block_candidates):

if not self.info['pattern'] or self.info['pattern'].isspace():

self.info['pattern'] = '.'

from ..core import ModToolNewModule, validate_name

from .base import common_params, run, cli_input, ModToolException

@click.command('newmod', short_help=ModToolNewModule.description)

@click.option('--srcdir',

help="Source directory for the module template.")

try:

os.stat(self.dir)

except OSError:

else:

raise ModToolException('The given directory exists.')

if self.srcdir is None:

if not os.path.isdir(self.srcdir):

raise ModToolException('Could not find gr-newmod source dir.')

run(self)

def get_modname(self):

""" Get the name of the new module to be added """

if self.info['modname'] is None:

"""

kwargs['cli'] = True

self = ModToolRename(**kwargs)

# first make sure the old block name is provided

get_oldname(self)

# now get the new block name

get_newname(self)

click.secho("Block/code identifier: " + self.info['newname'], fg='green')

run(self)

def get_oldname(self):

""" Get the old block name to be replaced """

block_candidates = get_block_candidates()

if self.info['oldname'] is None:

with SequenceCompleter(block_candidates):

while not self.info['oldname'] or self.info['oldname'].isspace():

"(without module name prefix): ")

if self.info['oldname'] not in block_candidates:

choices = [x for x in block_candidates if self.info['oldname'] in x]

if len(choices) > 0:

raise ModToolException("Blockname for renaming does not exists!")

validate_name('block', self.info['oldname'])

def get_newname(self):

""" Get the new block name """

if self.info['newname'] is None:

while not self.info['newname'] or self.info['newname'].isspace():

"(without module name prefix): ")

validate_name('block', self.info['newname'])

""" Remove block (delete files and remove Makefile entries) """

kwargs['cli'] = True

self = ModToolRemove(**kwargs)

get_pattern(self)

run(self)

def get_pattern(self):

""" Returns the regex pattern for block(s) to be removed """

if self.info['pattern'] is None:

block_candidates = get_block_candidates()

with SequenceCompleter(block_candidates):

if not self.info['pattern'] or self.info['pattern'].isspace():

self.info['pattern'] = '.'

""" Update the XML bindings to YAML bindings """

kwargs['cli'] = True

self = ModToolUpdate(**kwargs)

get_blockname(self)

run(self)

def get_blockname(self):

""" Returns the blockname for block to be updated """

if self.info['complete']:

block_candidates = get_xml_candidates()

if self.info['blockname'] is None:

with SequenceCompleter(block_candidates):

if not self.info['blockname'] or self.info['blockname'].isspace():

raise ModToolException('Block name not specified!')

if self.info['blockname'] not in block_candidates:

choices = [x for x in block_candidates if self.info['blockname'] in x]

if len(choices) > 0:

raise ModToolException("The XML bindings does not exists!")

def clang_format(s):

try:

except (RuntimeError, FileNotFoundError) as e:

class ModToolAdd(ModTool):

name = 'add'

description = 'Add new block into a module.'

block_types = ('sink', 'source', 'sync', 'decimator', 'interpolator',

language_candidates = ('cpp', 'python', 'c++')

def __init__(self, blockname=None, block_type=None, lang=None, copyright=None,

if self.info['lang'] not in self.language_candidates:

raise ModToolException('Invalid programming language.')

if self.info['blocktype'] == 'tagged_stream' and self.info['lang'] == 'python':

if self.info['blockname'] is None:

raise ModToolException('Blockname not specified.')

validate_name('block', self.info['blockname'])

if not isinstance(self.add_py_qa, bool):

if not isinstance(self.add_cc_qa, bool):

raise ModToolException('Expected a boolean value for add_cpp_qa.')

if not isinstance(self.skip_cmakefiles, bool):

def assign(self):

if self.info['lang'] == 'c++':

self.info['lang'] = 'cpp'

raise ModToolException('Missing or skipping relevant subdir.')

if not self.license_file:

if self.info['copyrightholder'] is None:

self.info['copyrightholder'] = '<+YOU OR YOUR COMPANY+>'

top directory

3) The default license. """

if self.license_file is not None \

with open(self.license_file) as f:

return f.read()

elif os.path.isfile('LICENSE'):

""" Shorthand for writing a substituted template to a file"""

path_to_file = os.path.join(path, fname)

logger.info(f"Adding file '{path_to_file}'...")

if fname.endswith('.cc') or fname.endswith('.h'):

with open(path_to_file, 'w') as f:

f.write(formatter(render_template(tpl, **self.info)))

self.scm.add_files((path_to_file,))

self.assign()

has_pybind = (

)

has_grc = False

if self.info['lang'] == 'cpp':

self._run_lib()

has_grc = has_pybind

self._run_python()

if self.info['blocktype'] != 'noblock':

has_grc = True

def _run_cc_qa(self):

" Add C++ QA files for 3.7 API if intructed from _run_lib"

blockname_ = self.info['blockname']

fname_qa_cc = f'qa_{blockname_}.cc'

self._write_tpl('qa_cpp', 'lib', fname_qa_cc)

modname_ = self.info['modname']

if self.skip_cmakefiles:

return

return

try:

append_re_line_sequence(self._file['cmlib'],

f'qa_{blockname_}.cc')

self.scm.mark_files_updated((self._file['cmlib'],))

except IOError:

fname_h = self.info['blockname'] + '.h'

fname_cc = self.info['blockname'] + '.cc'

if self.info['blocktype'] in ('source', 'sink', 'sync', 'decimator',

fname_cc = self.info['blockname'] + '_impl.cc'

self._write_tpl('block_impl_cpp', 'lib', fname_cc)

fname_cc = self.info['fullblockname'] + '.cc'

if self.add_cc_qa:

self._run_cc_qa_boostutf()

elif self.info['version'] == '37':

self._run_cc_qa()

elif self.info['version'] == '36':

elif self.info['version'] == 'autofoo':

if not self.skip_cmakefiles:

ed = CMakeFileEditor(self._file['cmlib'])

cmake_list_var = '[a-z]*_?' + self.info['modname'] + '_sources'

ed.append_value('add_library', fname_cc)

ed.write()

ed = CMakeFileEditor(self._file['cminclude'])

ed.write()

def _run_pybind(self):

""" Do everything that needs doing in the python bindings subdir.

- add reference and call to bind_blockname()

- include them into CMakeLists.txt

"""

# Generate bindings cc file

fname_cc = self.info['blockname'] + '_python.cc'

# Update python_bindings.cc

ed = CPPFileEditor(self._file['ccpybind'])

ed.write()

self.scm.mark_files_updated((self._file['ccpybind']))

if self.info['version'] in ['310']:

else:

prefix_include_root = self.info['modname']

block_base = ""

if self.info['blocktype'] in ('source', 'sink', 'sync', 'decimator',

block_base = code_generator.GRTYPELIST[self.info['blocktype']]

import hashlib

"member_functions": [

{

"name": "make",

"has_static": "1",

"arguments": []

}

}

}

# def gen_pybind_cc(self, header_info, base_name):

logger.info("Adding file '{}'...".format(path_to_file))

with open(path_to_file, 'w') as f:

f.write(pydoc_txt)

self.scm.add_files((path_to_file,))

path_to_file = os.path.join(bindings_dir, fname_cc)

logger.info("Adding file '{}'...".format(path_to_file))

with open(path_to_file, 'w') as f:

if not self.skip_cmakefiles:

ed = CMakeFileEditor(self._file['cmpybind'])

ed.write()

self.scm.mark_files_updated((self._file['cmpybind']))

fname_py_qa = 'qa_' + self.info['blockname'] + '.py'

self._write_tpl('qa_python', self.info['pydir'], fname_py_qa)

os.chmod(os.path.join(self.info['pydir'], fname_py_qa), 0o755)

if self.skip_cmakefiles or CMakeFileEditor(self._file['cmpython']).check_for_glob('qa_*.py'):

return

logger.info(f'Editing {self.info["pydir"]}/CMakeLists.txt...')

with open(self._file['cmpython'], 'a') as f:

f.write(

(self.info['blockname'], fname_py_qa))

self.scm.mark_files_updated((self._file['cmpython'],))

if self.skip_cmakefiles:

return

ed = CMakeFileEditor(self._file['cmpython'])

ed.write()

self.scm.mark_files_updated((self._file['cmpython'],))

if self.skip_cmakefiles or ed.check_for_glob('*.yml'):

return

logger.info("Editing grc/CMakeLists.txt...")

ed.write()

self.scm.mark_files_updated((self._file['cmgrc'],))

def validate_name(kind, name):

""" Checks that block, module etc names are alphanumeric. """

if not re.fullmatch('[a-zA-Z0-9_]+', name):

class ModTool(object):

def _assign(self):

if not self._check_directory(self.dir):

if self.info['modname'] is None:

self.info['modname'] = get_modname()

if self.info['modname'] is None:

if self.info['version'] == '36' and (

os.path.isdir(os.path.join('include', self.info['modname'])) or

self.info['version'] = '37'

if not os.path.isfile(os.path.join('cmake', 'Modules', 'FindCppUnit.cmake')):

self.info['version'] = '38'

self.info['version'] = '310'

if self.skip_subdirs['lib'] or not self.has_subdirs['lib']:

self.skip_subdirs['lib'] = True

self.info['pydir'] = 'python'

if os.path.isdir(os.path.join('python', self.info['modname'])):

self.info['pydir'] = os.path.join('python', self.info['modname'])

if self.info['is_component']:

elif self.info['version'] in ('37', '38'):

elif self.info['version'] in ('310'):

else:

self.info['includedir'] = 'include'

def _setup_scm(self, mode='active'):

""" Initialize source control management. """

if mode == 'active':

else:

if self.scm is None:

logger.error("Error: Can't set up SCM.")

exit(1)

def _check_directory(self, directory):

""" Guesses if dir is a valid GNU Radio module directory by looking for

Changes the directory, if valid. """

has_makefile = False

try:

if os.path.isfile(f) and f == 'CMakeLists.txt':

with open(f) as filetext:

if re.search(r'find_package\(Gnuradio', filetext.read()) is not None:

has_makefile = True

elif re.search('GR_REGISTER_COMPONENT', filetext.read()) is not None:

self.info['is_component'] = True

has_makefile = True

# TODO search for autofoo

""" Module to call bindtool and create Python bindings """

import os

import logging

import warnings

logger = logging.getLogger(__name__)

class ModToolGenBindings(ModTool):

""" Make YAML file for GRC block bindings """

name = 'bind'

blocknames_to_process.append(self.info['blockname'])

elif self.info['pattern']:

# A regex resembling one or several blocks were given

else:

raise ModToolException("No block name or regex was specified!")

if self.info['version'] in ['310']:

else:

prefix_include_root = self.info['modname']

bg = BindingGenerator(prefix=gr.prefix(), namespace=[

for file_to_process in files_to_process:

if self.info['update_hash_only']:

bg.fix_file_hash(file_to_process)

""" Go, go, go! """

def _handle_py_qa(cmake, fname):

""" Do stuff for py qa """

self.scm.mark_file_updated(cmake.filename)

return True

def _handle_py_mod(cmake, fname):

""" Do stuff for py extra files """

try:

with open(self._file['pyinit']) as f:

initfile = f.read()

except IOError:

return False

pymodname = os.path.splitext(fname)[0]

with open(self._file['pyinit'], 'w') as f:

f.write(initfile)

self.scm.mark_file_updated(self._file['pyinit'])

return False

def _handle_cc_qa(cmake, fname):

""" Do stuff for cc qa """

if self.info['version'] == '37':

fname_base = os.path.splitext(fname)[0]

ed.write()

self.scm.mark_file_updated(self._file['qalib'])

fname_qa_cc = f'qa_{self.info["blockname"]}.cc'

cmake.comment_out_lines(fname_qa_cc)

elif self.info['version'] == '36':

self.scm.mark_file_updated(cmake.filename)

return True

from ..cli import cli_input

# List of special rules: 0: subdir, 1: filename re match, 2: callback

special_treatments = (

)

for subdir in self._subdirs:

if self.skip_subdirs[subdir]:

for fname in filenames:

file_disabled = False

if not yes:

if ans == 'a':

yes = True

if ans == 'q':

if not file_disabled:

cmake.disable_file(fname)

cmake.write()

mod_info = dict()

mod_info['base_dir'] = self._get_base_dir(self._directory)

if mod_info['base_dir'] is None:

os.chdir(mod_info['base_dir'])

mod_info['modname'] = get_modname()

if mod_info['modname'] is None:

if self.info['version'] == '36' and (

os.path.isdir(os.path.join('include', mod_info['modname'])) or

self.info['version'] = '37'

if not os.path.isfile(os.path.join('cmake', 'Modules', 'FindCppUnit.cmake')):

self.info['version'] = '38'

self.info['version'] = '310'

mod_info['version'] = self.info['version']

if 'is_component' in list(self.info.keys()) and self.info['is_component']:

mod_info['incdirs'] = []

mod_incl_dir = os.path.join(mod_info['base_dir'], 'include')

if os.path.isdir(os.path.join(mod_incl_dir, mod_info['modname'])):

else:

mod_info['incdirs'].append(mod_incl_dir)

build_dir = self._get_build_dir(mod_info)

path_or_internal = {True: 'INTERNAL',

False: 'PATH'}['is_component' in list(mod_info.keys())]

try:

for line in cmakecache_fid:

if line.find(f'GNURADIO_RUNTIME_INCLUDE_DIRS:{path_or_internal}') != -1:

except IOError:

pass

if not inc_dirs and self._suggested_dirs is not None:

return inc_dirs

def _pretty_print(elf, mod_info):

""" Output the module info in human-readable format """

index_names = {'base_dir': 'Base directory',

'build_dir': 'Build directory',

'incdirs': 'Include directories'}

for key in list(mod_info.keys()):

if key == 'version':

version = {

print(f" API version: {version}")

else:

print('%19s: %s' % (index_names[key], mod_info[key]))

# This portion will be covered by the CLI

if not self.cli:

self.validate()

# 1) Go through lib/

if not self.skip_subdirs['lib']:

if self.info['version'] in ('37', '38', '310'):

ed = CMakeFileEditor(self._file['cmgrc'])

if re.search(fname_yml, ed.cfile) is None and not ed.check_for_glob('*.yml'):

logger.info("Adding GRC bindings to grc/CMakeLists.txt...")

ed.write()

self.scm.mark_files_updated(self._file['cmgrc'])

def _get_blockdata(fname_cc):

""" Return the block name and the header file name from the .cc file name """

fname_h = (blockname + '.h').replace('_impl.', '.')

return (blockname, fname_h, contains_modulename)

# Go, go, go

logger.info(f"Making GRC bindings for {fname_cc}...")

(blockname, fname_h, contains_modulename) = _get_blockdata(fname_cc)

try:

parser = ParserCCBlock(fname_cc,

blockname,

self.info['version'],

_type_translate

)

except IOError:

if contains_modulename:

else:

return (parser.read_params(), parser.read_io_signature(), blockname)

block = self.modname.split('-')[-1]

label = header.split('_')

del label[-1]

_header = (('id', f'{block}_{ header}'),

('label', ' '.join(label).upper()),

('category', f'[{block.capitalize()}]'),

('flags', '[python, cpp]')

)

params_list = [

str_ = ', '.join(params_list)

_templates = [('imports', f'from gnuradio import {block}'),

('make', f'{block}.{ header}({str_})')

arguments = []

for args in param['arguments_type']:

arguments.append(args['name'])

arg_ = ', '.join(arg_list)

list_callbacks.append(

callback_key = ('callbacks')

callbacks = (callback_key, tuple(list_callbacks))

_templates.append(callbacks)

elif i_sig is Constants.MAKE2:

input_sig['domain'] = 'stream'

input_sig['dtype'] = self.parsed_data['io_signature']['input']['sizeof_stream_item' +

elif i_sig is Constants.MAKE3:

input_sig['domain'] = 'stream'

input_sig['dtype'] = self.parsed_data['io_signature']['input']['sizeof_stream_item' +

elif i_sig is Constants.MAKEV:

input_sig['domain'] = 'stream'

input_sig['dtype'] = self.parsed_data['io_signature']['input']['sizeof_stream_items']

elif o_sig is Constants.MAKE2:

output_sig['domain'] = 'stream'

output_sig['dtype'] = self.parsed_data['io_signature']['output']['sizeof_stream_item' +

elif o_sig is Constants.MAKE3:

output_sig['domain'] = 'stream'

output_sig['dtype'] = self.parsed_data['io_signature']['output']['sizeof_stream_item' +

elif o_sig is Constants.MAKEV:

output_sig['domain'] = 'stream'

output_sig['dtype'] = self.parsed_data['io_signature']['output']['sizeof_stream_items']

output_signature.append(m_output_sig)

if output_signature:

data['outputs'] = output_signature

param_ = ', '.join(params_list)

_cpp_templates = [('includes', '#include <gnuradio/{block}/{self.filename}>'),

('declarations', '{block}::{ header}::sptr ${{id}}'),

]

if self.parsed_data['methods']:

arguments = []

for args in param['arguments_type']:

arguments.append(args['name'])

arg_ = ', '.join(arg_list)

list_callbacks.append(

callback_key = ('callbacks')

callbacks = (callback_key, tuple(list_callbacks))

_cpp_templates.append(callbacks)

logger = logging.getLogger(__name__)

class ModToolNewModule(ModTool):

""" Create a new out-of-tree module """

name = 'newmod'

description = 'Create new empty module, use add to add blocks.'

def __init__(self, module_name=None, srcdir=None, **kwargs):

ModTool.__init__(self, None, module_name, **kwargs)

# Don't call ModTool._validate(), that assumes an existing module.

def assign(self):

self.dir = os.path.join(self.directory, f'gr-{self.info["modname"]}')

if self.srcdir is None:

def validate(self):

""" Validates the arguments """

try:

os.stat(self.dir)

except OSError:

else:

raise ModToolException('The given directory exists.')

if not os.path.isdir(self.srcdir):

def run(self):

"""

try:

shutil.copytree(self.srcdir, self.dir)

try:

except FileNotFoundError as e:

os.chdir(self.dir)

except OSError:

raise ModToolException(f'Could not create directory {self.dir}.')

for filename in files:

f = os.path.join(root, filename)

if filename.find('howto') != -1:

if os.path.basename(root) == 'howto':

logger.info("Done.")

if self.scm.init_repo(path_to_repo="."):

block_candidates = get_block_candidates()

if self.info['oldname'] not in block_candidates:

choices = [x for x in block_candidates if self.info['oldname'] in x]

raise ModToolException("Blockname for renaming does not exists!")

if not self.info['newname']:

raise ModToolException('New blockname (new_name) not specified.')

validate_name('new block', self.info['newname'])

def assign(self):

def run(self):

""" Go, go, go. """

module = self.info['modname']

oldname = self.info['oldname']

newname = self.info['newname']

self._run_grc_rename(self.info['modname'], oldname, newname)

self._run_python_qa(self.info['modname'], oldname, newname)

self._run_python(self.info['modname'], oldname, newname)

hfile = './lib/' + old + '_impl.h'

self._run_file_replace(ccfile, old, new)

self._run_file_replace(hfile, old, new)

self._run_cmakelists('./lib/', old, new, '_impl.cc')

self._run_cmakelists('./lib/', old, new, '_impl.h')

self._run_file_rename('./lib/', old, new, '_impl.cc')

path = self.info['includedir']

filename = os.path.join(path, old + '.h')

self._run_file_replace(filename, old, new)

self._run_cmakelists(path, old, new, '.h')

self._run_file_rename(path, old, new, '.h')

logger.info("Not a Python block, nothing to do here...")

def _run_pybind(self, module, old, new):

filename = os.path.join(path, old + '_python.cc')

self._run_file_replace(filename, old, new)

self._run_file_rename(path, old, new, '_python.cc')

# update the hash in the new file

import hashlib

hasher = hashlib.md5()

with open(header_filename, 'rb') as file_in:

buf = file_in.read()

hasher.update(buf)

f.write(file_txt)

filename = path + 'python_bindings.cc'

path = os.path.join(path, 'docstrings')

filename = os.path.join(path, old + '_pydoc_template.h')

def _run_grc_rename(self, module, old, new):

grcfile = './grc/' + module + '_' + old + '.block.yml'

self._run_file_replace(grcfile, old, new)

def _run_cmakelists(self, path, first, second, suffix):

filename = os.path.join(path, 'CMakeLists.txt')

# space character and suffix ensures similiarly named blocks are not mixed up

if nsubs < 1:

logger.info(f"'{first}' wasn't in '{filename}'.")

if not os.path.isfile(filename):

return False

else:

with open(filename) as f:

cfile = f.read()

self.validate()

else:

from ..cli import cli_input

def _remove_cc_test_case(filename=None, ed=None):

""" Special function that removes the occurrences of a qa*.cc file

from the CMakeLists.txt. """

fr'^#include "{filename}"\s*$')

remove_pattern_from_file(self._file['qalib'],

fr'^\s*s->addTest\(gr::{modname_}::{base}::suite\(\)\);\s*$'

self.scm.mark_file_updated(self._file['qalib'])

elif ext == '.cc':

ed.remove_value('list',

r'\$\{CMAKE_CURRENT_SOURCE_DIR\}/%s' % filename,

to_ignore_start=f'APPEND test_{modname_}_sources')

self.scm.mark_file_updated(ed.filename)

(base, ext) = os.path.splitext(filename)

if ext == '.cc':

ed.remove_value(

'list', filename,

self.scm.mark_file_updated(ed.filename)

else:

filebase = os.path.splitext(filename)[0]

py_files_deleted = self._run_subdir(self.info['pydir'], ('*.py',), ('GR_PYTHON_INSTALL',),

cmakeedit_func=_remove_py_test_case)

for f in py_files_deleted:

# Update python_bindings.cc

blocknames_to_delete = []

blocknames_to_delete.append(self.info['blockname'])

elif self.info['pattern']:

# A regex resembling one or several blocks were given

else:

raise ModToolException("No block name or regex was specified!")

for blockname in blocknames_to_delete:

ed = CPPFileEditor(self._file['ccpybind'])

ed.write()

if not self.skip_subdirs['lib']:

self._run_subdir('lib', ('*.cc', '*.h'), ('add_library', 'list'),

cmakeedit_func=_remove_cc_test_case)

if not self.skip_subdirs['include']:

if not self.skip_subdirs['grc']:

self._run_subdir('grc', ('*.yml',), ('install',))

blockname_pattern = ''

if path == self.info['pydir']:

blockname_pattern = f"^(qa_)?{self.info['blockname']}.py$"

blockname_pattern = f"^{self.info['blockname']}_python.cc$"

blockname_pattern = f"^{self.info['blockname']}_pydoc_template.h$"

elif path == 'lib':

blockname_pattern = f"^{self.info['blockname']}_impl(\\.h|\\.cc)$"

for f in files_filt:

b = os.path.basename(f)

if not yes and self.cli:

if ans == 'a':

yes = True

if ans == 'q':

if (os.path.exists(f'{path}/CMakeLists.txt')):

ed = CMakeFileEditor(f'{path}/CMakeLists.txt')

for var in makefile_vars:

ed.remove_value(var, b)

if cmakeedit_func is not None:

self.info['complete'] = complete

self.info['include_blacklisted'] = include_blacklisted

def validate(self):

""" Validates the arguments """

ModTool._validate(self)

raise ModToolException('Block name not specified!')

block_candidates = get_xml_candidates()

if self.info['blockname'] not in block_candidates:

if len(choices) > 0:

raise ModToolException("The XML bindings does not exists!")

def run(self):

from gnuradio.grc.converter import Converter

if not self.cli:

self.validate()

module_name = self.info['modname']

path = './grc/'

conv = Converter(path, path)

for blockname in blocks:

xml_file = f"{module_name}_{blockname}.xml"

yml_file = f"{module_name}_{blockname}.block.yml"

continue

logger.info(f"Converted {xml_file} to {yml_file}")

nsubs = self._run_cmakelists(xml_file, yml_file)

if nsubs > 1:

logger.warning("Changed more than expected for the block '%s' in the CMakeLists.txt. "

from .doxyindex import DoxyIndex, DoxyFunction, DoxyParam, DoxyClass, DoxyFile, DoxyNamespace, DoxyGroup, DoxyFriend, DoxyOther

def _test():

import os

this_dir = os.path.dirname(globals()['__file__'])

import doctest

return doctest.testmod()

if __name__ == "__main__":

_test()

for cls in self.mem_classes:

if cls.can_parse(mem):

return cls

def convert_mem(self, mem):

try:

from .base import Base

from .text import description

class DoxyIndex(Base):

"""

Parses a doxygen xml directory.

class DoxyCompMem(Base):

kind = None

def __init__(self, *args, **kwargs):

class DoxyCompound(DoxyCompMem):

pass

class DoxyMember(DoxyCompMem):

pass

class DoxyFunction(DoxyMember):

__module__ = "gnuradio.utils.doxyxml"

self._data['params'].append(DoxyParam(prm))

brief_description = property(lambda self: self.data()['brief_description'])

params = property(lambda self: self.data()['params'])

Base.mem_classes.append(DoxyFunction)

return '\n\n'.join(descriptions)

brief_description = property(lambda self: self.data()['brief_description'])

name = property(lambda self: self.data()['declname'])

class DoxyParameterItem(DoxyMember):

"""A different representation of a parameter in Doxygen."""

self.process_memberdefs()

brief_description = property(lambda self: self.data()['brief_description'])

params = property(lambda self: self.data()['params'])

Base.mem_classes.append(DoxyClass)

self.process_memberdefs()

brief_description = property(lambda self: self.data()['brief_description'])

Base.mem_classes.append(DoxyFile)

return

self.process_memberdefs()

Base.mem_classes.append(DoxyNamespace)

kind = 'friend'

Base.mem_classes.append(DoxyFriend)

def can_parse(cls, obj):

return obj.kind in cls.kinds

Base.mem_classes.append(DoxyOther)

return self.compounddef.find(details)

supermod.DoxygenType.subclass = DoxygenTypeSub

# end class DoxygenTypeSub

class compounddefTypeSub(supermod.compounddefType):

def __init__(self, kind=None, prot=None, id=None, compoundname='', title='', basecompoundref=None, derivedcompoundref=None, includes=None, includedby=None, incdepgraph=None, invincdepgraph=None, innerdir=None, innerfile=None, innerclass=None, innernamespace=None, innerpage=None, innergroup=None, templateparamlist=None, sectiondef=None, briefdescription=None, detaileddescription=None, inheritancegraph=None, collaborationgraph=None, programlisting=None, location=None, listofallmembers=None):

def find(self, details):

class listofallmembersTypeSub(supermod.listofallmembersType):

def __init__(self, member=None):

supermod.listofallmembersType.__init__(self, member)

supermod.listofallmembersType.subclass = listofallmembersTypeSub

# end class listofallmembersTypeSub

class memberRefTypeSub(supermod.memberRefType):

def __init__(self, virt=None, prot=None, refid=None, ambiguityscope=None, scope='', name=''):

supermod.memberRefType.subclass = memberRefTypeSub

# end class memberRefTypeSub

class compoundRefTypeSub(supermod.compoundRefType):

def __init__(self, virt=None, prot=None, refid=None, valueOf_='', mixedclass_=None, content_=None):

supermod.compoundRefType.__init__(self, mixedclass_, content_)

supermod.compoundRefType.subclass = compoundRefTypeSub

# end class compoundRefTypeSub

class reimplementTypeSub(supermod.reimplementType):

def __init__(self, refid=None, valueOf_='', mixedclass_=None, content_=None):

supermod.reimplementType.__init__(self, mixedclass_, content_)

supermod.reimplementType.subclass = reimplementTypeSub

# end class reimplementTypeSub

class incTypeSub(supermod.incType):

def __init__(self, local=None, refid=None, valueOf_='', mixedclass_=None, content_=None):

supermod.incType.__init__(self, mixedclass_, content_)

supermod.incType.subclass = incTypeSub

# end class incTypeSub

class refTypeSub(supermod.refType):

def __init__(self, prot=None, refid=None, valueOf_='', mixedclass_=None, content_=None):

supermod.refType.__init__(self, mixedclass_, content_)

supermod.refType.subclass = refTypeSub

# end class refTypeSub

class refTextTypeSub(supermod.refTextType):

def __init__(self, refid=None, kindref=None, external=None, valueOf_='', mixedclass_=None, content_=None):

supermod.refTextType.__init__(self, mixedclass_, content_)

supermod.refTextType.subclass = refTextTypeSub

# end class refTextTypeSub

def __init__(self, kind=None, header='', description=None, memberdef=None):

def find(self, details):

class memberdefTypeSub(supermod.memberdefType):

def __init__(self, initonly=None, kind=None, volatile=None, const=None, raise_=None, virt=None, readable=None, prot=None, explicit=None, new=None, final=None, writable=None, add=None, static=None, remove=None, sealed=None, mutable=None, gettable=None, inline=None, settable=None, id=None, templateparamlist=None, type_=None, definition='', argsstring='', name='', read='', write='', bitfield='', reimplements=None, reimplementedby=None, param=None, enumvalue=None, initializer=None, exceptions=None, briefdescription=None, detaileddescription=None, inbodydescription=None, location=None, references=None, referencedby=None):

supermod.memberdefType.subclass = memberdefTypeSub

# end class memberdefTypeSub

class descriptionTypeSub(supermod.descriptionType):

def __init__(self, title='', para=None, sect1=None, internal=None, mixedclass_=None, content_=None):

supermod.descriptionType.__init__(self, mixedclass_, content_)

supermod.descriptionType.subclass = descriptionTypeSub

# end class descriptionTypeSub

class enumvalueTypeSub(supermod.enumvalueType):

def __init__(self, prot=None, id=None, name='', initializer=None, briefdescription=None, detaileddescription=None, mixedclass_=None, content_=None):

supermod.enumvalueType.__init__(self, mixedclass_, content_)

supermod.enumvalueType.subclass = enumvalueTypeSub

# end class enumvalueTypeSub

class templateparamlistTypeSub(supermod.templateparamlistType):

def __init__(self, param=None):

supermod.templateparamlistType.__init__(self, param)

supermod.templateparamlistType.subclass = templateparamlistTypeSub

# end class templateparamlistTypeSub

class paramTypeSub(supermod.paramType):

def __init__(self, type_=None, declname='', defname='', array='', defval=None, briefdescription=None):

supermod.paramType.subclass = paramTypeSub

# end class paramTypeSub

class linkedTextTypeSub(supermod.linkedTextType):

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

supermod.linkedTextType.__init__(self, mixedclass_, content_)

supermod.linkedTextType.subclass = linkedTextTypeSub

# end class linkedTextTypeSub

class graphTypeSub(supermod.graphType):

def __init__(self, node=None):

supermod.graphType.__init__(self, node)

supermod.graphType.subclass = graphTypeSub

# end class graphTypeSub

class nodeTypeSub(supermod.nodeType):

def __init__(self, id=None, label='', link=None, childnode=None):

supermod.nodeType.__init__(self, id, label, link, childnode)

supermod.nodeType.subclass = nodeTypeSub

# end class nodeTypeSub

class childnodeTypeSub(supermod.childnodeType):

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

supermod.childnodeType.__init__(self, relation, refid, edgelabel)

supermod.childnodeType.subclass = childnodeTypeSub

# end class childnodeTypeSub

class linkTypeSub(supermod.linkType):

def __init__(self, refid=None, external=None, valueOf_=''):

supermod.linkType.__init__(self, refid, external)

supermod.linkType.subclass = linkTypeSub

# end class linkTypeSub

class listingTypeSub(supermod.listingType):

def __init__(self, codeline=None):

supermod.listingType.__init__(self, codeline)

supermod.listingType.subclass = listingTypeSub

# end class listingTypeSub

class codelineTypeSub(supermod.codelineType):

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

supermod.codelineType.subclass = codelineTypeSub

# end class codelineTypeSub

class highlightTypeSub(supermod.highlightType):

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

supermod.highlightType.__init__(self, mixedclass_, content_)

supermod.highlightType.subclass = highlightTypeSub

# end class highlightTypeSub

class referenceTypeSub(supermod.referenceType):

def __init__(self, endline=None, startline=None, refid=None, compoundref=None, valueOf_='', mixedclass_=None, content_=None):

supermod.referenceType.__init__(self, mixedclass_, content_)

supermod.referenceType.subclass = referenceTypeSub

# end class referenceTypeSub

class locationTypeSub(supermod.locationType):

def __init__(self, bodystart=None, line=None, bodyend=None, bodyfile=None, file=None, valueOf_=''):

supermod.locationType.subclass = locationTypeSub

# end class locationTypeSub

class docSect1TypeSub(supermod.docSect1Type):

def __init__(self, id=None, title='', para=None, sect2=None, internal=None, mixedclass_=None, content_=None):

supermod.docSect1Type.__init__(self, mixedclass_, content_)

supermod.docSect1Type.subclass = docSect1TypeSub

# end class docSect1TypeSub

class docSect2TypeSub(supermod.docSect2Type):

def __init__(self, id=None, title='', para=None, sect3=None, internal=None, mixedclass_=None, content_=None):

supermod.docSect2Type.__init__(self, mixedclass_, content_)

supermod.docSect2Type.subclass = docSect2TypeSub

# end class docSect2TypeSub

class docSect3TypeSub(supermod.docSect3Type):

def __init__(self, id=None, title='', para=None, sect4=None, internal=None, mixedclass_=None, content_=None):

supermod.docSect3Type.__init__(self, mixedclass_, content_)

supermod.docSect3Type.subclass = docSect3TypeSub

# end class docSect3TypeSub

class docSect4TypeSub(supermod.docSect4Type):

def __init__(self, id=None, title='', para=None, internal=None, mixedclass_=None, content_=None):

supermod.docSect4Type.__init__(self, mixedclass_, content_)

supermod.docSect4Type.subclass = docSect4TypeSub

# end class docSect4TypeSub

class docInternalTypeSub(supermod.docInternalType):

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

supermod.docInternalType.__init__(self, mixedclass_, content_)

supermod.docInternalType.subclass = docInternalTypeSub

# end class docInternalTypeSub

class docInternalS1TypeSub(supermod.docInternalS1Type):

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

supermod.docInternalS1Type.__init__(self, mixedclass_, content_)

supermod.docInternalS1Type.subclass = docInternalS1TypeSub

# end class docInternalS1TypeSub

class docInternalS2TypeSub(supermod.docInternalS2Type):

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

supermod.docInternalS2Type.__init__(self, mixedclass_, content_)

supermod.docInternalS2Type.subclass = docInternalS2TypeSub

# end class docInternalS2TypeSub

class docInternalS3TypeSub(supermod.docInternalS3Type):

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

supermod.docInternalS3Type.__init__(self, mixedclass_, content_)

supermod.docInternalS3Type.subclass = docInternalS3TypeSub

# end class docInternalS3TypeSub

class docInternalS4TypeSub(supermod.docInternalS4Type):

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

supermod.docInternalS4Type.__init__(self, mixedclass_, content_)

supermod.docInternalS4Type.subclass = docInternalS4TypeSub

# end class docInternalS4TypeSub

class docURLLinkSub(supermod.docURLLink):

def __init__(self, url=None, valueOf_='', mixedclass_=None, content_=None):

supermod.docURLLink.__init__(self, mixedclass_, content_)

supermod.docURLLink.subclass = docURLLinkSub

# end class docURLLinkSub

class docAnchorTypeSub(supermod.docAnchorType):

def __init__(self, id=None, valueOf_='', mixedclass_=None, content_=None):

supermod.docAnchorType.__init__(self, mixedclass_, content_)

supermod.docAnchorType.subclass = docAnchorTypeSub

# end class docAnchorTypeSub

class docFormulaTypeSub(supermod.docFormulaType):

def __init__(self, id=None, valueOf_='', mixedclass_=None, content_=None):

supermod.docFormulaType.__init__(self, mixedclass_, content_)

supermod.docFormulaType.subclass = docFormulaTypeSub

# end class docFormulaTypeSub

class docIndexEntryTypeSub(supermod.docIndexEntryType):

def __init__(self, primaryie='', secondaryie=''):

supermod.docIndexEntryType.__init__(self, primaryie, secondaryie)

supermod.docIndexEntryType.subclass = docIndexEntryTypeSub

# end class docIndexEntryTypeSub

class docListTypeSub(supermod.docListType):

def __init__(self, listitem=None):

supermod.docListType.__init__(self, listitem)

supermod.docListType.subclass = docListTypeSub

# end class docListTypeSub

class docListItemTypeSub(supermod.docListItemType):

def __init__(self, para=None):

supermod.docListItemType.__init__(self, para)

supermod.docListItemType.subclass = docListItemTypeSub

# end class docListItemTypeSub

class docSimpleSectTypeSub(supermod.docSimpleSectType):

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

supermod.docSimpleSectType.__init__(self, kind, title, para)

supermod.docSimpleSectType.subclass = docSimpleSectTypeSub

# end class docSimpleSectTypeSub

class docVarListEntryTypeSub(supermod.docVarListEntryType):

def __init__(self, term=None):

supermod.docVarListEntryType.__init__(self, term)

supermod.docVarListEntryType.subclass = docVarListEntryTypeSub

# end class docVarListEntryTypeSub

class docRefTextTypeSub(supermod.docRefTextType):

def __init__(self, refid=None, kindref=None, external=None, valueOf_='', mixedclass_=None, content_=None):

supermod.docRefTextType.__init__(self, mixedclass_, content_)

supermod.docRefTextType.subclass = docRefTextTypeSub

# end class docRefTextTypeSub

class docTableTypeSub(supermod.docTableType):

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

supermod.docTableType.__init__(self, rows, cols, row, caption)

supermod.docTableType.subclass = docTableTypeSub

# end class docTableTypeSub

class docRowTypeSub(supermod.docRowType):

def __init__(self, entry=None):

supermod.docRowType.__init__(self, entry)

supermod.docRowType.subclass = docRowTypeSub

# end class docRowTypeSub

class docEntryTypeSub(supermod.docEntryType):

def __init__(self, thead=None, para=None):

supermod.docEntryType.__init__(self, thead, para)

supermod.docEntryType.subclass = docEntryTypeSub

# end class docEntryTypeSub

class docHeadingTypeSub(supermod.docHeadingType):

def __init__(self, level=None, valueOf_='', mixedclass_=None, content_=None):

supermod.docHeadingType.__init__(self, mixedclass_, content_)

supermod.docHeadingType.subclass = docHeadingTypeSub

# end class docHeadingTypeSub

class docImageTypeSub(supermod.docImageType):

def __init__(self, width=None, type_=None, name=None, height=None, valueOf_='', mixedclass_=None, content_=None):

supermod.docImageType.__init__(self, mixedclass_, content_)

supermod.docImageType.subclass = docImageTypeSub

# end class docImageTypeSub

class docDotFileTypeSub(supermod.docDotFileType):

def __init__(self, name=None, valueOf_='', mixedclass_=None, content_=None):

supermod.docDotFileType.__init__(self, mixedclass_, content_)

supermod.docDotFileType.subclass = docDotFileTypeSub

# end class docDotFileTypeSub

class docTocItemTypeSub(supermod.docTocItemType):

def __init__(self, id=None, valueOf_='', mixedclass_=None, content_=None):

supermod.docTocItemType.__init__(self, mixedclass_, content_)

supermod.docTocItemType.subclass = docTocItemTypeSub

# end class docTocItemTypeSub

class docTocListTypeSub(supermod.docTocListType):

def __init__(self, tocitem=None):

supermod.docTocListType.__init__(self, tocitem)

supermod.docTocListType.subclass = docTocListTypeSub

# end class docTocListTypeSub

class docLanguageTypeSub(supermod.docLanguageType):

def __init__(self, langid=None, para=None):

supermod.docLanguageType.__init__(self, langid, para)

supermod.docLanguageType.subclass = docLanguageTypeSub

# end class docLanguageTypeSub

class docParamListTypeSub(supermod.docParamListType):

def __init__(self, kind=None, parameteritem=None):

supermod.docParamListType.__init__(self, kind, parameteritem)

supermod.docParamListType.subclass = docParamListTypeSub

# end class docParamListTypeSub

class docParamListItemSub(supermod.docParamListItem):

def __init__(self, parameternamelist=None, parameterdescription=None):

supermod.docParamListItem.subclass = docParamListItemSub

# end class docParamListItemSub

class docParamNameListSub(supermod.docParamNameList):

def __init__(self, parametername=None):

supermod.docParamNameList.__init__(self, parametername)

supermod.docParamNameList.subclass = docParamNameListSub

# end class docParamNameListSub

class docParamNameSub(supermod.docParamName):

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

supermod.docParamName.__init__(self, mixedclass_, content_)

supermod.docParamName.subclass = docParamNameSub

# end class docParamNameSub

class docXRefSectTypeSub(supermod.docXRefSectType):

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

supermod.docXRefSectType.__init__(self, id, xreftitle, xrefdescription)

supermod.docXRefSectType.subclass = docXRefSectTypeSub

# end class docXRefSectTypeSub

class docCopyTypeSub(supermod.docCopyType):

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

supermod.docCopyType.__init__(self, link, para, sect1, internal)

supermod.docCopyType.subclass = docCopyTypeSub

# end class docCopyTypeSub

class docCharTypeSub(supermod.docCharType):

def __init__(self, char=None, valueOf_=''):

supermod.docCharType.__init__(self, char)

supermod.docCharType.subclass = docCharTypeSub

# end class docCharTypeSub

class docParaTypeSub(supermod.docParaType):

def __init__(self, char=None, valueOf_=''):

supermod.docParaType.__init__(self, char)

if child_.nodeType == Node.TEXT_NODE:

obj_ = self.mixedclass_(MixedContainer.CategoryText,

self.content.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

nodeName_ == "ref":

# end class docParaTypeSub

def parse(inFilename):

doc = minidom.parse(inFilename)

rootNode = doc.documentElement

class GeneratedsSuper(object):

def format_string(self, input_data, input_name=''):

return input_data

def format_integer(self, input_data, input_name=''):

return '%d' % input_data

def format_float(self, input_data, input_name=''):

return '%f' % input_data

def format_double(self, input_data, input_name=''):

return '%e' % input_data

def format_boolean(self, input_data, input_name=''):

return '%s' % input_data

## from IPython.Shell import IPShellEmbed

## args = ''

## banner = 'Dropping into IPython',

# Then use the following line where and when you want to drop into the

# IPython shell:

# Support/utility functions.

#

def showIndent(outfile, level):

for idx in range(level):

outfile.write(' ')

def quote_xml(inStr):

s1 = (isinstance(inStr, str) and inStr or

'%s' % inStr)

s1 = s1.replace('>', '&gt;')

return s1

def quote_attrib(inStr):

s1 = (isinstance(inStr, str) and inStr or

'%s' % inStr)

s1 = '"%s"' % s1

return s1

def quote_python(inStr):

s1 = inStr

if s1.find("'") == -1:

TypeDecimal = 5

TypeDouble = 6

TypeBoolean = 7

def __init__(self, category, content_type, name, value):

self.category = category

self.content_type = content_type

self.name = name

self.value = value

def getCategory(self):

return self.category

def getContenttype(self, content_type):

return self.content_type

def getValue(self):

return self.value

def getName(self):

return self.name

def export(self, outfile, level, name, namespace):

if self.category == MixedContainer.CategoryText:

outfile.write(self.value)

elif self.category == MixedContainer.CategorySimple:

self.exportSimple(outfile, level, name)

else: # category == MixedContainer.CategoryComplex

def exportSimple(self, outfile, level, name):

if self.content_type == MixedContainer.TypeString:

outfile.write('<%s>%s</%s>' % (self.name, self.value, self.name))

outfile.write('<%s>%f</%s>' % (self.name, self.value, self.name))

elif self.content_type == MixedContainer.TypeDouble:

outfile.write('<%s>%g</%s>' % (self.name, self.value, self.name))

def exportLiteral(self, outfile, level, name):

if self.category == MixedContainer.CategoryText:

showIndent(outfile, level)

elif self.category == MixedContainer.CategorySimple:

showIndent(outfile, level)

else: # category == MixedContainer.CategoryComplex

showIndent(outfile, level)

self.value.exportLiteral(outfile, level + 1)

showIndent(outfile, level)

outfile.write(')\n')

self.name = name

self.data_type = data_type

self.container = container

def set_name(self, name): self.name = name

def get_name(self): return self.name

def set_data_type(self, data_type): self.data_type = data_type

class DoxygenType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, version=None, compounddef=None):

self.version = version

self.compounddef = compounddef

def factory(*args_, **kwargs_):

if DoxygenType.subclass:

return DoxygenType.subclass(*args_, **kwargs_)

def set_compounddef(self, compounddef): self.compounddef = compounddef

def get_version(self): return self.version

def set_version(self, version): self.version = version

def export(self, outfile, level, namespace_='', name_='DoxygenType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='DoxygenType'):

outfile.write(' version=%s' % (quote_attrib(self.version), ))

def exportChildren(self, outfile, level, namespace_='', name_='DoxygenType'):

if self.compounddef:

def hasContent_(self):

if (

self.compounddef is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='DoxygenType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.version is not None:

showIndent(outfile, level)

outfile.write('version = "%s",\n' % (self.version,))

def exportLiteralChildren(self, outfile, level, name_):

if self.compounddef:

showIndent(outfile, level)

self.compounddef.exportLiteral(outfile, level, name_='compounddef')

showIndent(outfile, level)

outfile.write('),\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('version'):

self.version = attrs.get('version').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

obj_ = compounddefType.factory()

obj_.build(child_)

self.set_compounddef(obj_)

class compounddefType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, kind=None, prot=None, id=None, compoundname=None, title=None, basecompoundref=None, derivedcompoundref=None, includes=None, includedby=None, incdepgraph=None, invincdepgraph=None, innerdir=None, innerfile=None, innerclass=None, innernamespace=None, innerpage=None, innergroup=None, templateparamlist=None, sectiondef=None, briefdescription=None, detaileddescription=None, inheritancegraph=None, collaborationgraph=None, programlisting=None, location=None, listofallmembers=None):

self.kind = kind

self.prot = prot

self.programlisting = programlisting

self.location = location

self.listofallmembers = listofallmembers

def factory(*args_, **kwargs_):

if compounddefType.subclass:

return compounddefType.subclass(*args_, **kwargs_)

def get_title(self): return self.title

def set_title(self, title): self.title = title

def get_basecompoundref(self): return self.basecompoundref

def add_basecompoundref(self, value): self.basecompoundref.append(value)

def get_derivedcompoundref(self): return self.derivedcompoundref

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 get_incdepgraph(self): return self.incdepgraph

def set_incdepgraph(self, incdepgraph): self.incdepgraph = incdepgraph

def get_invincdepgraph(self): return self.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 add_innerclass(self, value): self.innerclass.append(value)

def insert_innerclass(self, index, value): self.innerclass[index] = value

def get_innernamespace(self): return self.innernamespace

def add_innernamespace(self, value): self.innernamespace.append(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 add_innergroup(self, value): self.innergroup.append(value)

def insert_innergroup(self, index, value): self.innergroup[index] = value

def get_templateparamlist(self): return self.templateparamlist

def get_sectiondef(self): return self.sectiondef

def set_sectiondef(self, sectiondef): self.sectiondef = sectiondef

def add_sectiondef(self, value): self.sectiondef.append(value)

def insert_sectiondef(self, index, value): self.sectiondef[index] = value

def get_briefdescription(self): return self.briefdescription

def get_detaileddescription(self): return self.detaileddescription

def get_inheritancegraph(self): return self.inheritancegraph

def get_collaborationgraph(self): return self.collaborationgraph

def get_programlisting(self): return self.programlisting

def get_location(self): return self.location

def set_location(self, location): self.location = location

def get_listofallmembers(self): return self.listofallmembers

def get_kind(self): return self.kind

def set_kind(self, kind): self.kind = kind

def get_prot(self): return self.prot

def set_prot(self, prot): self.prot = prot

def get_id(self): return self.id

def set_id(self, id): self.id = id

def export(self, outfile, level, namespace_='', name_='compounddefType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

if self.hasContent_():

outfile.write('>\n')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='compounddefType'):

if self.kind is not None:

outfile.write(' kind=%s' % (quote_attrib(self.kind), ))

if self.prot is not None:

outfile.write(' prot=%s' % (quote_attrib(self.prot), ))

if self.id is not None:

def exportChildren(self, outfile, level, namespace_='', name_='compounddefType'):

if self.compoundname is not None:

showIndent(outfile, level)

if self.title is not None:

showIndent(outfile, level)

for basecompoundref_ in self.basecompoundref:

for derivedcompoundref_ in self.derivedcompoundref:

for includes_ in self.includes:

includes_.export(outfile, level, namespace_, name_='includes')

for includedby_ in self.includedby:

includedby_.export(outfile, level, namespace_, name_='includedby')

if self.incdepgraph:

if self.invincdepgraph:

for innerdir_ in self.innerdir:

innerdir_.export(outfile, level, namespace_, name_='innerdir')

for innerfile_ in self.innerfile:

for innerclass_ in self.innerclass:

innerclass_.export(outfile, level, namespace_, name_='innerclass')

for innernamespace_ in self.innernamespace:

for innerpage_ in self.innerpage:

innerpage_.export(outfile, level, namespace_, name_='innerpage')

for innergroup_ in self.innergroup:

innergroup_.export(outfile, level, namespace_, name_='innergroup')

if self.templateparamlist:

for sectiondef_ in self.sectiondef:

sectiondef_.export(outfile, level, namespace_, name_='sectiondef')

if self.briefdescription:

if self.detaileddescription:

if self.inheritancegraph:

if self.collaborationgraph:

if self.programlisting:

if self.location:

self.location.export(outfile, level, namespace_, name_='location')

if self.listofallmembers:

def hasContent_(self):

if (

self.compoundname is not None or

self.programlisting is not None or

self.location is not None or

self.listofallmembers is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='compounddefType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.kind is not None:

showIndent(outfile, level)

if self.id is not None:

showIndent(outfile, level)

outfile.write('id = %s,\n' % (self.id,))

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

if self.title:

showIndent(outfile, level)

outfile.write('title=model_.xsd_string(\n')

for basecompoundref in self.basecompoundref:

showIndent(outfile, level)

outfile.write('model_.basecompoundref(\n')

showIndent(outfile, level)

outfile.write('),\n')

level -= 1

for derivedcompoundref in self.derivedcompoundref:

showIndent(outfile, level)

outfile.write('model_.derivedcompoundref(\n')

showIndent(outfile, level)

outfile.write('),\n')

level -= 1

if self.invincdepgraph:

showIndent(outfile, level)

outfile.write('invincdepgraph=model_.graphType(\n')

showIndent(outfile, level)

outfile.write('),\n')

showIndent(outfile, level)

for innernamespace in self.innernamespace:

showIndent(outfile, level)

outfile.write('model_.innernamespace(\n')

showIndent(outfile, level)

outfile.write('),\n')

level -= 1

if self.templateparamlist:

showIndent(outfile, level)

outfile.write('templateparamlist=model_.templateparamlistType(\n')

showIndent(outfile, level)

outfile.write('),\n')

showIndent(outfile, level)

if self.briefdescription:

showIndent(outfile, level)

outfile.write('briefdescription=model_.descriptionType(\n')

showIndent(outfile, level)

outfile.write('),\n')

if self.detaileddescription:

showIndent(outfile, level)

outfile.write('detaileddescription=model_.descriptionType(\n')

showIndent(outfile, level)

outfile.write('),\n')

if self.inheritancegraph:

showIndent(outfile, level)

outfile.write('inheritancegraph=model_.graphType(\n')

showIndent(outfile, level)

outfile.write('),\n')

if self.collaborationgraph:

showIndent(outfile, level)

outfile.write('collaborationgraph=model_.graphType(\n')

showIndent(outfile, level)

outfile.write('),\n')

if self.programlisting:

showIndent(outfile, level)

outfile.write('programlisting=model_.listingType(\n')

showIndent(outfile, level)

outfile.write('),\n')

if self.location:

if self.listofallmembers:

showIndent(outfile, level)

outfile.write('listofallmembers=model_.listofallmembersType(\n')

showIndent(outfile, level)

outfile.write('),\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('kind'):

self.kind = attrs.get('kind').value

self.prot = attrs.get('prot').value

if attrs.get('id'):

self.id = attrs.get('id').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

compoundname_ = ''

for text__content_ in child_.childNodes:

compoundname_ += text__content_.nodeValue

self.compoundname = compoundname_

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = docTitleType.factory()

obj_.build(child_)

self.set_title(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = compoundRefType.factory()

obj_.build(child_)

self.basecompoundref.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = compoundRefType.factory()

obj_.build(child_)

self.derivedcompoundref.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = incType.factory()

obj_.build(child_)

self.includes.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = incType.factory()

obj_.build(child_)

self.includedby.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = graphType.factory()

obj_.build(child_)

self.set_incdepgraph(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = graphType.factory()

obj_.build(child_)

self.set_invincdepgraph(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = refType.factory()

obj_.build(child_)

self.innerdir.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = refType.factory()

obj_.build(child_)

self.innerfile.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = refType.factory()

obj_.build(child_)

self.innerclass.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = refType.factory()

obj_.build(child_)

self.innernamespace.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = refType.factory()

obj_.build(child_)

self.innerpage.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = refType.factory()

obj_.build(child_)

self.innergroup.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = templateparamlistType.factory()

obj_.build(child_)

self.set_templateparamlist(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = sectiondefType.factory()

obj_.build(child_)

self.sectiondef.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = descriptionType.factory()

obj_.build(child_)

self.set_briefdescription(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = descriptionType.factory()

obj_.build(child_)

self.set_detaileddescription(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = graphType.factory()

obj_.build(child_)

self.set_inheritancegraph(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = graphType.factory()

obj_.build(child_)

self.set_collaborationgraph(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = listingType.factory()

obj_.build(child_)

self.set_programlisting(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = locationType.factory()

obj_.build(child_)

self.set_location(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = listofallmembersType.factory()

obj_.build(child_)

self.set_listofallmembers(obj_)

class listofallmembersType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, member=None):

if member is None:

self.member = []

else:

self.member = member

def factory(*args_, **kwargs_):

if listofallmembersType.subclass:

return listofallmembersType.subclass(*args_, **kwargs_)

def set_member(self, member): self.member = member

def add_member(self, value): self.member.append(value)

def insert_member(self, index, value): self.member[index] = value

def export(self, outfile, level, namespace_='', name_='listofallmembersType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

if self.hasContent_():

outfile.write('>\n')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='listofallmembersType'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='listofallmembersType'):

for member_ in self.member:

member_.export(outfile, level, namespace_, name_='member')

def hasContent_(self):

if (

self.member is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='listofallmembersType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('member=[\n')

level -= 1

showIndent(outfile, level)

outfile.write('],\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

obj_ = memberRefType.factory()

obj_.build(child_)

self.member.append(obj_)

class memberRefType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, virt=None, prot=None, refid=None, ambiguityscope=None, scope=None, name=None):

self.virt = virt

self.prot = prot

self.ambiguityscope = ambiguityscope

self.scope = scope

self.name = name

def factory(*args_, **kwargs_):

if memberRefType.subclass:

return memberRefType.subclass(*args_, **kwargs_)

def get_refid(self): return self.refid

def set_refid(self, refid): self.refid = refid

def get_ambiguityscope(self): return self.ambiguityscope

def export(self, outfile, level, namespace_='', name_='memberRefType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

if self.hasContent_():

outfile.write('>\n')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='memberRefType'):

if self.virt is not None:

outfile.write(' virt=%s' % (quote_attrib(self.virt), ))

if self.prot is not None:

outfile.write(' prot=%s' % (quote_attrib(self.prot), ))

if self.refid is not None:

if self.ambiguityscope is not None:

def exportChildren(self, outfile, level, namespace_='', name_='memberRefType'):

if self.scope is not None:

showIndent(outfile, level)

if self.name is not None:

showIndent(outfile, level)

def hasContent_(self):

if (

self.scope is not None or

self.name is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='memberRefType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.virt is not None:

showIndent(outfile, level)

if self.ambiguityscope is not None:

showIndent(outfile, level)

outfile.write('ambiguityscope = %s,\n' % (self.ambiguityscope,))

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

showIndent(outfile, level)

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('virt'):

self.virt = attrs.get('virt').value

self.refid = attrs.get('refid').value

if attrs.get('ambiguityscope'):

self.ambiguityscope = attrs.get('ambiguityscope').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

scope_ = ''

for text__content_ in child_.childNodes:

scope_ += text__content_.nodeValue

self.scope = scope_

elif child_.nodeType == Node.ELEMENT_NODE and \

name_ = ''

for text__content_ in child_.childNodes:

name_ += text__content_.nodeValue

class scope(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, valueOf_=''):

self.valueOf_ = valueOf_

def factory(*args_, **kwargs_):

if scope.subclass:

return scope.subclass(*args_, **kwargs_)

factory = staticmethod(factory)

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='scope', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='scope'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='scope'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='scope'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class scope

class name(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, valueOf_=''):

self.valueOf_ = valueOf_

def factory(*args_, **kwargs_):

if name.subclass:

return name.subclass(*args_, **kwargs_)

factory = staticmethod(factory)

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='name', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='name'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='name'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='name'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class name

class compoundRefType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, virt=None, prot=None, refid=None, valueOf_='', mixedclass_=None, content_=None):

self.virt = virt

self.prot = prot

self.content_ = []

else:

self.content_ = content_

def factory(*args_, **kwargs_):

if compoundRefType.subclass:

return compoundRefType.subclass(*args_, **kwargs_)

def set_refid(self, refid): self.refid = refid

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='compoundRefType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('>')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

def exportAttributes(self, outfile, level, namespace_='', name_='compoundRefType'):

if self.virt is not None:

outfile.write(' virt=%s' % (quote_attrib(self.virt), ))

if self.prot is not None:

outfile.write(' prot=%s' % (quote_attrib(self.prot), ))

if self.refid is not None:

def exportChildren(self, outfile, level, namespace_='', name_='compoundRefType'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='compoundRefType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.virt is not None:

showIndent(outfile, level)

if self.refid is not None:

showIndent(outfile, level)

outfile.write('refid = %s,\n' % (self.refid,))

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('virt'):

self.virt = attrs.get('virt').value

self.prot = attrs.get('prot').value

if attrs.get('refid'):

self.refid = attrs.get('refid').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

obj_ = self.mixedclass_(MixedContainer.CategoryText,

self.content_.append(obj_)

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class compoundRefType

class reimplementType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, refid=None, valueOf_='', mixedclass_=None, content_=None):

self.refid = refid

if mixedclass_ is None:

self.content_ = []

else:

self.content_ = content_

def factory(*args_, **kwargs_):

if reimplementType.subclass:

return reimplementType.subclass(*args_, **kwargs_)

def set_refid(self, refid): self.refid = refid

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='reimplementType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('>')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

def exportAttributes(self, outfile, level, namespace_='', name_='reimplementType'):

if self.refid is not None:

def exportChildren(self, outfile, level, namespace_='', name_='reimplementType'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='reimplementType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.refid is not None:

showIndent(outfile, level)

outfile.write('refid = %s,\n' % (self.refid,))

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('refid'):

self.refid = attrs.get('refid').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

obj_ = self.mixedclass_(MixedContainer.CategoryText,

self.content_.append(obj_)

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class reimplementType

class incType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, local=None, refid=None, valueOf_='', mixedclass_=None, content_=None):

self.local = local

self.refid = refid

self.content_ = []

else:

self.content_ = content_

def factory(*args_, **kwargs_):

if incType.subclass:

return incType.subclass(*args_, **kwargs_)

def set_refid(self, refid): self.refid = refid

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='incType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('>')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

def exportAttributes(self, outfile, level, namespace_='', name_='incType'):

if self.local is not None:

outfile.write(' local=%s' % (quote_attrib(self.local), ))

if self.refid is not None:

def exportChildren(self, outfile, level, namespace_='', name_='incType'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='incType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.local is not None:

showIndent(outfile, level)

if self.refid is not None:

showIndent(outfile, level)

outfile.write('refid = %s,\n' % (self.refid,))

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('local'):

self.local = attrs.get('local').value

if attrs.get('refid'):

self.refid = attrs.get('refid').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

obj_ = self.mixedclass_(MixedContainer.CategoryText,

self.content_.append(obj_)

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class incType

class refType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, prot=None, refid=None, valueOf_='', mixedclass_=None, content_=None):

self.prot = prot

self.refid = refid

self.content_ = []

else:

self.content_ = content_

def factory(*args_, **kwargs_):

if refType.subclass:

return refType.subclass(*args_, **kwargs_)

def set_refid(self, refid): self.refid = refid

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='refType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('>')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

def exportAttributes(self, outfile, level, namespace_='', name_='refType'):

if self.prot is not None:

outfile.write(' prot=%s' % (quote_attrib(self.prot), ))

if self.refid is not None:

def exportChildren(self, outfile, level, namespace_='', name_='refType'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='refType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.prot is not None:

showIndent(outfile, level)

if self.refid is not None:

showIndent(outfile, level)

outfile.write('refid = %s,\n' % (self.refid,))

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('prot'):

self.prot = attrs.get('prot').value

if attrs.get('refid'):

self.refid = attrs.get('refid').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

obj_ = self.mixedclass_(MixedContainer.CategoryText,

self.content_.append(obj_)

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class refType

class refTextType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, refid=None, kindref=None, external=None, valueOf_='', mixedclass_=None, content_=None):

self.refid = refid

self.kindref = kindref

self.content_ = []

else:

self.content_ = content_

def factory(*args_, **kwargs_):

if refTextType.subclass:

return refTextType.subclass(*args_, **kwargs_)

def set_external(self, external): self.external = external

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='refTextType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('>')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

def exportAttributes(self, outfile, level, namespace_='', name_='refTextType'):

if self.refid is not None:

if self.kindref is not None:

outfile.write(' kindref=%s' % (quote_attrib(self.kindref), ))

if self.external is not None:

def exportChildren(self, outfile, level, namespace_='', name_='refTextType'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='refTextType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.refid is not None:

showIndent(outfile, level)

if self.external is not None:

showIndent(outfile, level)

outfile.write('external = %s,\n' % (self.external,))

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('refid'):

self.refid = attrs.get('refid').value

self.kindref = attrs.get('kindref').value

if attrs.get('external'):

self.external = attrs.get('external').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

obj_ = self.mixedclass_(MixedContainer.CategoryText,

self.content_.append(obj_)

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class refTextType

class sectiondefType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, kind=None, header=None, description=None, memberdef=None):

self.kind = kind

self.header = header

self.memberdef = []

else:

self.memberdef = memberdef

def factory(*args_, **kwargs_):

if sectiondefType.subclass:

return sectiondefType.subclass(*args_, **kwargs_)

def insert_memberdef(self, index, value): self.memberdef[index] = value

def get_kind(self): return self.kind

def set_kind(self, kind): self.kind = kind

def export(self, outfile, level, namespace_='', name_='sectiondefType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

if self.hasContent_():

outfile.write('>\n')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='sectiondefType'):

if self.kind is not None:

outfile.write(' kind=%s' % (quote_attrib(self.kind), ))

def exportChildren(self, outfile, level, namespace_='', name_='sectiondefType'):

if self.header is not None:

showIndent(outfile, level)

if self.description:

for memberdef_ in self.memberdef:

memberdef_.export(outfile, level, namespace_, name_='memberdef')

def hasContent_(self):

if (

self.header is not None or

self.description is not None or

self.memberdef is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='sectiondefType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.kind is not None:

showIndent(outfile, level)

outfile.write('kind = "%s",\n' % (self.kind,))

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

if self.description:

showIndent(outfile, level)

outfile.write('description=model_.descriptionType(\n')

level -= 1

showIndent(outfile, level)

outfile.write('],\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('kind'):

self.kind = attrs.get('kind').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

header_ = ''

for text__content_ in child_.childNodes:

header_ += text__content_.nodeValue

self.header = header_

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = descriptionType.factory()

obj_.build(child_)

self.set_description(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = memberdefType.factory()

obj_.build(child_)

self.memberdef.append(obj_)

class memberdefType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, initonly=None, kind=None, volatile=None, const=None, raisexx=None, virt=None, readable=None, prot=None, explicit=None, new=None, final=None, writable=None, add=None, static=None, remove=None, sealed=None, mutable=None, gettable=None, inline=None, settable=None, id=None, templateparamlist=None, type_=None, definition=None, argsstring=None, name=None, read=None, write=None, bitfield=None, reimplements=None, reimplementedby=None, param=None, enumvalue=None, initializer=None, exceptions=None, briefdescription=None, detaileddescription=None, inbodydescription=None, location=None, references=None, referencedby=None):

self.initonly = initonly

self.kind = kind

self.referencedby = []

else:

self.referencedby = referencedby

def factory(*args_, **kwargs_):

if memberdefType.subclass:

return memberdefType.subclass(*args_, **kwargs_)

return memberdefType(*args_, **kwargs_)

factory = staticmethod(factory)

def get_templateparamlist(self): return self.templateparamlist

def get_type(self): return self.type_

def set_type(self, type_): self.type_ = type_

def get_definition(self): return self.definition

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 get_reimplementedby(self): return self.reimplementedby

def add_reimplementedby(self, value): self.reimplementedby.append(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 get_exceptions(self): return self.exceptions

def set_exceptions(self, exceptions): self.exceptions = exceptions

def get_briefdescription(self): return self.briefdescription

def get_detaileddescription(self): return self.detaileddescription

def get_inbodydescription(self): return self.inbodydescription

def get_location(self): return self.location

def set_location(self, location): self.location = location

def get_references(self): return self.references

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 get_initonly(self): return self.initonly

def set_initonly(self, initonly): self.initonly = initonly

def get_kind(self): return self.kind

def set_settable(self, settable): self.settable = settable

def get_id(self): return self.id

def set_id(self, id): self.id = id

def export(self, outfile, level, namespace_='', name_='memberdefType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

if self.hasContent_():

outfile.write('>\n')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='memberdefType'):

if self.initonly is not None:

outfile.write(' initonly=%s' % (quote_attrib(self.initonly), ))

if self.settable is not None:

outfile.write(' settable=%s' % (quote_attrib(self.settable), ))

if self.id is not None:

def exportChildren(self, outfile, level, namespace_='', name_='memberdefType'):

if self.templateparamlist:

if self.type_:

self.type_.export(outfile, level, namespace_, name_='type')

if self.definition is not None:

showIndent(outfile, level)

if self.argsstring is not None:

showIndent(outfile, level)

if self.name is not None:

showIndent(outfile, level)

if self.read is not None:

showIndent(outfile, level)

if self.write is not None:

showIndent(outfile, level)

if self.bitfield is not None:

showIndent(outfile, level)

for reimplements_ in self.reimplements:

for reimplementedby_ in self.reimplementedby:

for param_ in self.param:

param_.export(outfile, level, namespace_, name_='param')

for enumvalue_ in self.enumvalue:

enumvalue_.export(outfile, level, namespace_, name_='enumvalue')

if self.initializer:

if self.exceptions:

if self.briefdescription:

if self.detaileddescription:

if self.inbodydescription:

if self.location:

for references_ in self.references:

references_.export(outfile, level, namespace_, name_='references')

for referencedby_ in self.referencedby:

def hasContent_(self):

if (

self.templateparamlist is not None or

self.location is not None or

self.references is not None or

self.referencedby is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='memberdefType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.initonly is not None:

showIndent(outfile, level)

if self.id is not None:

showIndent(outfile, level)

outfile.write('id = %s,\n' % (self.id,))

def exportLiteralChildren(self, outfile, level, name_):

if self.templateparamlist:

showIndent(outfile, level)

outfile.write('templateparamlist=model_.templateparamlistType(\n')

showIndent(outfile, level)

outfile.write('),\n')

if self.type_:

showIndent(outfile, level)

outfile.write('),\n')

showIndent(outfile, level)

showIndent(outfile, level)

showIndent(outfile, level)

showIndent(outfile, level)

showIndent(outfile, level)

showIndent(outfile, level)

showIndent(outfile, level)

outfile.write('reimplements=[\n')

level += 1

for reimplementedby in self.reimplementedby:

showIndent(outfile, level)

outfile.write('model_.reimplementedby(\n')

showIndent(outfile, level)

outfile.write('),\n')

level -= 1

if self.briefdescription:

showIndent(outfile, level)

outfile.write('briefdescription=model_.descriptionType(\n')

showIndent(outfile, level)

outfile.write('),\n')

if self.detaileddescription:

showIndent(outfile, level)

outfile.write('detaileddescription=model_.descriptionType(\n')

showIndent(outfile, level)

outfile.write('),\n')

if self.inbodydescription:

showIndent(outfile, level)

outfile.write('inbodydescription=model_.descriptionType(\n')

showIndent(outfile, level)

outfile.write('),\n')

if self.location:

level -= 1

showIndent(outfile, level)

outfile.write('],\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('initonly'):

self.initonly = attrs.get('initonly').value

self.settable = attrs.get('settable').value

if attrs.get('id'):

self.id = attrs.get('id').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

obj_ = templateparamlistType.factory()

obj_.build(child_)

self.set_templateparamlist(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = linkedTextType.factory()

obj_.build(child_)

self.set_type(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

definition_ = ''

for text__content_ in child_.childNodes:

definition_ += text__content_.nodeValue

self.definition = definition_

elif child_.nodeType == Node.ELEMENT_NODE and \

argsstring_ = ''

for text__content_ in child_.childNodes:

argsstring_ += text__content_.nodeValue

self.argsstring = argsstring_

elif child_.nodeType == Node.ELEMENT_NODE and \

name_ = ''

for text__content_ in child_.childNodes:

name_ += text__content_.nodeValue

self.name = name_

elif child_.nodeType == Node.ELEMENT_NODE and \

read_ = ''

for text__content_ in child_.childNodes:

read_ += text__content_.nodeValue

self.read = read_

elif child_.nodeType == Node.ELEMENT_NODE and \

write_ = ''

for text__content_ in child_.childNodes:

write_ += text__content_.nodeValue

self.write = write_

elif child_.nodeType == Node.ELEMENT_NODE and \

bitfield_ = ''

for text__content_ in child_.childNodes:

bitfield_ += text__content_.nodeValue

self.bitfield = bitfield_

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = reimplementType.factory()

obj_.build(child_)

self.reimplements.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = reimplementType.factory()

obj_.build(child_)

self.reimplementedby.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = paramType.factory()

obj_.build(child_)

self.param.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = enumvalueType.factory()

obj_.build(child_)

self.enumvalue.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = linkedTextType.factory()

obj_.build(child_)

self.set_initializer(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = linkedTextType.factory()

obj_.build(child_)

self.set_exceptions(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = descriptionType.factory()

obj_.build(child_)

self.set_briefdescription(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = descriptionType.factory()

obj_.build(child_)

self.set_detaileddescription(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = descriptionType.factory()

obj_.build(child_)

self.set_inbodydescription(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = locationType.factory()

obj_.build(child_)

self.set_location(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = referenceType.factory()

obj_.build(child_)

self.references.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = referenceType.factory()

obj_.build(child_)

self.referencedby.append(obj_)

class definition(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, valueOf_=''):

self.valueOf_ = valueOf_

def factory(*args_, **kwargs_):

if definition.subclass:

return definition.subclass(*args_, **kwargs_)

factory = staticmethod(factory)

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='definition', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='definition'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='definition'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='definition'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class definition

class argsstring(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, valueOf_=''):

self.valueOf_ = valueOf_

def factory(*args_, **kwargs_):

if argsstring.subclass:

return argsstring.subclass(*args_, **kwargs_)

factory = staticmethod(factory)

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='argsstring', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='argsstring'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='argsstring'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='argsstring'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class argsstring

class read(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, valueOf_=''):

self.valueOf_ = valueOf_

def factory(*args_, **kwargs_):

if read.subclass:

return read.subclass(*args_, **kwargs_)

factory = staticmethod(factory)

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='read', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='read'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='read'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='read'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class read

class write(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, valueOf_=''):

self.valueOf_ = valueOf_

def factory(*args_, **kwargs_):

if write.subclass:

return write.subclass(*args_, **kwargs_)

factory = staticmethod(factory)

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='write', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='write'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='write'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='write'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class write

class bitfield(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, valueOf_=''):

self.valueOf_ = valueOf_

def factory(*args_, **kwargs_):

if bitfield.subclass:

return bitfield.subclass(*args_, **kwargs_)

factory = staticmethod(factory)

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='bitfield', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='bitfield'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='bitfield'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='bitfield'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class bitfield

class descriptionType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, title=None, para=None, sect1=None, internal=None, mixedclass_=None, content_=None):

if mixedclass_ is None:

self.mixedclass_ = MixedContainer

self.content_ = []

else:

self.content_ = content_

def factory(*args_, **kwargs_):

if descriptionType.subclass:

return descriptionType.subclass(*args_, **kwargs_)

def insert_sect1(self, index, value): self.sect1[index] = value

def get_internal(self): return self.internal

def set_internal(self, internal): self.internal = internal

def export(self, outfile, level, namespace_='', name_='descriptionType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('>')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

def exportAttributes(self, outfile, level, namespace_='', name_='descriptionType'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='descriptionType'):

for item_ in self.content_:

item_.export(outfile, level, item_.name, namespace_)

def hasContent_(self):

if (

self.title is not None or

self.para is not None or

self.sect1 is not None or

self.internal is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='descriptionType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('content_ = [\n')

item_.exportLiteral(outfile, level, name_)

showIndent(outfile, level)

outfile.write('],\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = docTitleType.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = docParaType.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = docSect1Type.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = docInternalType.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.TEXT_NODE:

obj_ = self.mixedclass_(MixedContainer.CategoryText,

self.content_.append(obj_)

# end class descriptionType

class enumvalueType(GeneratedsSuper):

subclass = None

superclass = None

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

self.prot = prot

self.id = id

self.content_ = []

else:

self.content_ = content_

def factory(*args_, **kwargs_):

if enumvalueType.subclass:

return enumvalueType.subclass(*args_, **kwargs_)

def get_initializer(self): return self.initializer

def set_initializer(self, initializer): self.initializer = initializer

def get_briefdescription(self): return self.briefdescription

def get_detaileddescription(self): return self.detaileddescription

def get_prot(self): return self.prot

def set_prot(self, prot): self.prot = prot

def get_id(self): return self.id

def set_id(self, id): self.id = id

def export(self, outfile, level, namespace_='', name_='enumvalueType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('>')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

def exportAttributes(self, outfile, level, namespace_='', name_='enumvalueType'):

if self.prot is not None:

outfile.write(' prot=%s' % (quote_attrib(self.prot), ))

if self.id is not None:

def exportChildren(self, outfile, level, namespace_='', name_='enumvalueType'):

for item_ in self.content_:

item_.export(outfile, level, item_.name, namespace_)

def hasContent_(self):

if (

self.name is not None or

self.initializer is not None or

self.briefdescription is not None or

self.detaileddescription is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='enumvalueType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.prot is not None:

showIndent(outfile, level)

if self.id is not None:

showIndent(outfile, level)

outfile.write('id = %s,\n' % (self.id,))

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('content_ = [\n')

item_.exportLiteral(outfile, level, name_)

showIndent(outfile, level)

outfile.write('],\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('prot'):

self.prot = attrs.get('prot').value

if attrs.get('id'):

self.id = attrs.get('id').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

value_ = []

for text_ in child_.childNodes:

value_.append(text_.nodeValue)

valuestr_ = ''.join(value_)

obj_ = self.mixedclass_(MixedContainer.CategorySimple,

self.content_.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = linkedTextType.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = descriptionType.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = descriptionType.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.TEXT_NODE:

obj_ = self.mixedclass_(MixedContainer.CategoryText,

self.content_.append(obj_)

# end class enumvalueType

class templateparamlistType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, param=None):

if param is None:

self.param = []

else:

self.param = param

def factory(*args_, **kwargs_):

if templateparamlistType.subclass:

return templateparamlistType.subclass(*args_, **kwargs_)

def set_param(self, param): self.param = param

def add_param(self, value): self.param.append(value)

def insert_param(self, index, value): self.param[index] = value

def export(self, outfile, level, namespace_='', name_='templateparamlistType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

if self.hasContent_():

outfile.write('>\n')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='templateparamlistType'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='templateparamlistType'):

for param_ in self.param:

param_.export(outfile, level, namespace_, name_='param')

def hasContent_(self):

if (

self.param is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='templateparamlistType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('param=[\n')

level -= 1

showIndent(outfile, level)

outfile.write('],\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

obj_ = paramType.factory()

obj_.build(child_)

self.param.append(obj_)

class paramType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, type_=None, declname=None, defname=None, array=None, defval=None, briefdescription=None):

self.type_ = type_

self.declname = declname

self.array = array

self.defval = defval

self.briefdescription = briefdescription

def factory(*args_, **kwargs_):

if paramType.subclass:

return paramType.subclass(*args_, **kwargs_)

def get_defval(self): return self.defval

def set_defval(self, defval): self.defval = defval

def get_briefdescription(self): return self.briefdescription

def export(self, outfile, level, namespace_='', name_='paramType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='paramType'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='paramType'):

if self.type_:

self.type_.export(outfile, level, namespace_, name_='type')

if self.declname is not None:

showIndent(outfile, level)

if self.defname is not None:

showIndent(outfile, level)

if self.array is not None:

showIndent(outfile, level)

if self.defval:

self.defval.export(outfile, level, namespace_, name_='defval')

if self.briefdescription:

def hasContent_(self):

if (

self.type_ is not None or

self.array is not None or

self.defval is not None or

self.briefdescription is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='paramType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

if self.type_:

showIndent(outfile, level)

showIndent(outfile, level)

outfile.write('),\n')

showIndent(outfile, level)

showIndent(outfile, level)

showIndent(outfile, level)

if self.defval:

showIndent(outfile, level)

outfile.write('defval=model_.linkedTextType(\n')

if self.briefdescription:

showIndent(outfile, level)

outfile.write('briefdescription=model_.descriptionType(\n')

showIndent(outfile, level)

outfile.write('),\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

obj_ = linkedTextType.factory()

obj_.build(child_)

self.set_type(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

declname_ = ''

for text__content_ in child_.childNodes:

declname_ += text__content_.nodeValue

self.declname = declname_

elif child_.nodeType == Node.ELEMENT_NODE and \

defname_ = ''

for text__content_ in child_.childNodes:

defname_ += text__content_.nodeValue

self.defname = defname_

elif child_.nodeType == Node.ELEMENT_NODE and \

array_ = ''

for text__content_ in child_.childNodes:

array_ += text__content_.nodeValue

self.array = array_

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = linkedTextType.factory()

obj_.build(child_)

self.set_defval(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = descriptionType.factory()

obj_.build(child_)

self.set_briefdescription(obj_)

class declname(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, valueOf_=''):

self.valueOf_ = valueOf_

def factory(*args_, **kwargs_):

if declname.subclass:

return declname.subclass(*args_, **kwargs_)

factory = staticmethod(factory)

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='declname', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='declname'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='declname'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='declname'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class declname

class defname(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, valueOf_=''):

self.valueOf_ = valueOf_

def factory(*args_, **kwargs_):

if defname.subclass:

return defname.subclass(*args_, **kwargs_)

factory = staticmethod(factory)

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='defname', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='defname'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='defname'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='defname'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class defname

class array(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, valueOf_=''):

self.valueOf_ = valueOf_

def factory(*args_, **kwargs_):

if array.subclass:

return array.subclass(*args_, **kwargs_)

factory = staticmethod(factory)

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='array', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='array'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='array'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='array'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class array

class linkedTextType(GeneratedsSuper):

subclass = None

superclass = None

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

if mixedclass_ is None:

self.mixedclass_ = MixedContainer

self.content_ = []

else:

self.content_ = content_

def factory(*args_, **kwargs_):

if linkedTextType.subclass:

return linkedTextType.subclass(*args_, **kwargs_)

def set_ref(self, ref): self.ref = ref

def add_ref(self, value): self.ref.append(value)

def insert_ref(self, index, value): self.ref[index] = value

def export(self, outfile, level, namespace_='', name_='linkedTextType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('>')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

def exportAttributes(self, outfile, level, namespace_='', name_='linkedTextType'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='linkedTextType'):

for item_ in self.content_:

item_.export(outfile, level, item_.name, namespace_)

def hasContent_(self):

if (

self.ref is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='linkedTextType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('content_ = [\n')

item_.exportLiteral(outfile, level, name_)

showIndent(outfile, level)

outfile.write('],\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

childobj_ = docRefTextType.factory()

childobj_.build(child_)

obj_ = self.mixedclass_(MixedContainer.CategoryComplex,

self.content_.append(obj_)

elif child_.nodeType == Node.TEXT_NODE:

obj_ = self.mixedclass_(MixedContainer.CategoryText,

self.content_.append(obj_)

# end class linkedTextType

class graphType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, node=None):

if node is None:

self.node = []

else:

self.node = node

def factory(*args_, **kwargs_):

if graphType.subclass:

return graphType.subclass(*args_, **kwargs_)

def set_node(self, node): self.node = node

def add_node(self, value): self.node.append(value)

def insert_node(self, index, value): self.node[index] = value

def export(self, outfile, level, namespace_='', name_='graphType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='graphType'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='graphType'):

for node_ in self.node:

node_.export(outfile, level, namespace_, name_='node')

def hasContent_(self):

if (

self.node is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='graphType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('node=[\n')

level -= 1

showIndent(outfile, level)

outfile.write('],\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

obj_ = nodeType.factory()

obj_.build(child_)

self.node.append(obj_)

class nodeType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, id=None, label=None, link=None, childnode=None):

self.id = id

self.label = label

self.childnode = []

else:

self.childnode = childnode

def factory(*args_, **kwargs_):

if nodeType.subclass:

return nodeType.subclass(*args_, **kwargs_)

def insert_childnode(self, index, value): self.childnode[index] = value

def get_id(self): return self.id

def set_id(self, id): self.id = id

def export(self, outfile, level, namespace_='', name_='nodeType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='nodeType'):

if self.id is not None:

def exportChildren(self, outfile, level, namespace_='', name_='nodeType'):

if self.label is not None:

showIndent(outfile, level)

if self.link:

self.link.export(outfile, level, namespace_, name_='link')

for childnode_ in self.childnode:

childnode_.export(outfile, level, namespace_, name_='childnode')

def hasContent_(self):

if (

self.label is not None or

self.link is not None or

self.childnode is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='nodeType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.id is not None:

showIndent(outfile, level)

outfile.write('id = %s,\n' % (self.id,))

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

if self.link:

showIndent(outfile, level)

outfile.write('link=model_.linkType(\n')

level -= 1

showIndent(outfile, level)

outfile.write('],\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('id'):

self.id = attrs.get('id').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

label_ = ''

for text__content_ in child_.childNodes:

label_ += text__content_.nodeValue

self.label = label_

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = linkType.factory()

obj_.build(child_)

self.set_link(obj_)

elif child_.nodeType == Node.ELEMENT_NODE and \

obj_ = childnodeType.factory()

obj_.build(child_)

self.childnode.append(obj_)

class label(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, valueOf_=''):

self.valueOf_ = valueOf_

def factory(*args_, **kwargs_):

if label.subclass:

return label.subclass(*args_, **kwargs_)

factory = staticmethod(factory)

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='label', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='label'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='label'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='label'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class label

class childnodeType(GeneratedsSuper):

subclass = None

superclass = None

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

self.relation = relation

self.refid = refid

self.edgelabel = []

else:

self.edgelabel = edgelabel

def factory(*args_, **kwargs_):

if childnodeType.subclass:

return childnodeType.subclass(*args_, **kwargs_)

def set_relation(self, relation): self.relation = relation

def get_refid(self): return self.refid

def set_refid(self, refid): self.refid = refid

def export(self, outfile, level, namespace_='', name_='childnodeType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

if self.hasContent_():

outfile.write('>\n')

self.exportChildren(outfile, level + 1, namespace_, name_)

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='childnodeType'):

if self.relation is not None:

outfile.write(' relation=%s' % (quote_attrib(self.relation), ))

if self.refid is not None:

def exportChildren(self, outfile, level, namespace_='', name_='childnodeType'):

for edgelabel_ in self.edgelabel:

showIndent(outfile, level)

def hasContent_(self):

if (

self.edgelabel is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='childnodeType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.relation is not None:

showIndent(outfile, level)

if self.refid is not None:

showIndent(outfile, level)

outfile.write('refid = %s,\n' % (self.refid,))

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('edgelabel=[\n')

level += 1

for edgelabel in self.edgelabel:

showIndent(outfile, level)

level -= 1

showIndent(outfile, level)

outfile.write('],\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('relation'):

self.relation = attrs.get('relation').value

if attrs.get('refid'):

self.refid = attrs.get('refid').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

edgelabel_ = ''

for text__content_ in child_.childNodes:

edgelabel_ += text__content_.nodeValue

class edgelabel(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, valueOf_=''):

self.valueOf_ = valueOf_

def factory(*args_, **kwargs_):

if edgelabel.subclass:

return edgelabel.subclass(*args_, **kwargs_)

factory = staticmethod(factory)

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='edgelabel', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='edgelabel'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='edgelabel'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='edgelabel'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class edgelabel

class linkType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, refid=None, external=None, valueOf_=''):

self.refid = refid

self.external = external

self.valueOf_ = valueOf_

def factory(*args_, **kwargs_):

if linkType.subclass:

return linkType.subclass(*args_, **kwargs_)

def set_external(self, external): self.external = external

def getValueOf_(self): return self.valueOf_

def setValueOf_(self, valueOf_): self.valueOf_ = valueOf_

def export(self, outfile, level, namespace_='', name_='linkType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='linkType'):

if self.refid is not None:

if self.external is not None:

def exportChildren(self, outfile, level, namespace_='', name_='linkType'):

outfile.write(value)

else:

outfile.write(quote_xml('%s' % self.valueOf_))

def hasContent_(self):

if (

self.valueOf_ is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='linkType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.refid is not None:

showIndent(outfile, level)

if self.external is not None:

showIndent(outfile, level)

outfile.write('external = %s,\n' % (self.external,))

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('valueOf_ = "%s",\n' % (self.valueOf_,))

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('refid'):

self.refid = attrs.get('refid').value

if attrs.get('external'):

self.external = attrs.get('external').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

self.valueOf_ += child_.nodeValue

elif child_.nodeType == Node.CDATA_SECTION_NODE:

# end class linkType

class listingType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, codeline=None):

if codeline is None:

self.codeline = []

else:

self.codeline = codeline

def factory(*args_, **kwargs_):

if listingType.subclass:

return listingType.subclass(*args_, **kwargs_)

def set_codeline(self, codeline): self.codeline = codeline

def add_codeline(self, value): self.codeline.append(value)

def insert_codeline(self, index, value): self.codeline[index] = value

def export(self, outfile, level, namespace_='', name_='listingType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='listingType'):

pass

def exportChildren(self, outfile, level, namespace_='', name_='listingType'):

for codeline_ in self.codeline:

codeline_.export(outfile, level, namespace_, name_='codeline')

def hasContent_(self):

if (

self.codeline is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='listingType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

pass

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('codeline=[\n')

level -= 1

showIndent(outfile, level)

outfile.write('],\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

pass

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

obj_ = codelineType.factory()

obj_.build(child_)

self.codeline.append(obj_)

class codelineType(GeneratedsSuper):

subclass = None

superclass = None

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

self.external = external

self.lineno = lineno

self.highlight = []

else:

self.highlight = highlight

def factory(*args_, **kwargs_):

if codelineType.subclass:

return codelineType.subclass(*args_, **kwargs_)

def set_refkind(self, refkind): self.refkind = refkind

def get_refid(self): return self.refid

def set_refid(self, refid): self.refid = refid

def export(self, outfile, level, namespace_='', name_='codelineType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))

outfile.write('</%s%s>\n' % (namespace_, name_))

else:

outfile.write(' />\n')

def exportAttributes(self, outfile, level, namespace_='', name_='codelineType'):

if self.external is not None:

outfile.write(' external=%s' % (quote_attrib(self.external), ))

if self.lineno is not None:

if self.refkind is not None:

outfile.write(' refkind=%s' % (quote_attrib(self.refkind), ))

if self.refid is not None:

def exportChildren(self, outfile, level, namespace_='', name_='codelineType'):

for highlight_ in self.highlight:

highlight_.export(outfile, level, namespace_, name_='highlight')

def hasContent_(self):

if (

self.highlight is not None

return True

else:

return False

def exportLiteral(self, outfile, level, name_='codelineType'):

level += 1

self.exportLiteralAttributes(outfile, level, name_)

if self.hasContent_():

self.exportLiteralChildren(outfile, level, name_)

def exportLiteralAttributes(self, outfile, level, name_):

if self.external is not None:

showIndent(outfile, level)

if self.refid is not None:

showIndent(outfile, level)

outfile.write('refid = %s,\n' % (self.refid,))

def exportLiteralChildren(self, outfile, level, name_):

showIndent(outfile, level)

outfile.write('highlight=[\n')

level -= 1

showIndent(outfile, level)

outfile.write('],\n')

def build(self, node_):

attrs = node_.attributes

self.buildAttributes(attrs)

for child_ in node_.childNodes:

nodeName_ = child_.nodeName.split(':')[-1]

self.buildChildren(child_, nodeName_)

def buildAttributes(self, attrs):

if attrs.get('external'):

self.external = attrs.get('external').value

self.refkind = attrs.get('refkind').value

if attrs.get('refid'):

self.refid = attrs.get('refid').value

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

obj_ = highlightType.factory()

obj_.build(child_)

self.highlight.append(obj_)

class highlightType(GeneratedsSuper):

subclass = None

superclass = None

def __init__(self, classxx=None, sp=None, ref=None, mixedclass_=None, content_=None):

self.classxx = classxx

if mixedclass_ is None:

self.content_ = []

else:

self.content_ = content_

def factory(*args_, **kwargs_):

if highlightType.subclass:

return highlightType.subclass(*args_, **kwargs_)

def insert_ref(self, index, value): self.ref[index] = value

def get_class(self): return self.classxx

def set_class(self, classxx): self.classxx = classxx

def export(self, outfile, level, namespace_='', name_='highlightType', namespacedef_=''):

showIndent(outfile, level)

outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))