def __init__(self, object_desc, spec_name, number, package, pkg_ref): # members from object self.name = object_desc['name'] self.fullname = spec_name self.number = number self.package = package.lower() self.pkg_ref = pkg_ref self.up_package = strFunctions.upper_first(self.package) # useful repeated text strings self.valid = '\\validRule{' self.start_b = '{' self.end_b = '}' self.lower_name = strFunctions.lower_first(strFunctions.remove_prefix(self.name)) self.formatted_name = '\{0}'.format(strFunctions.remove_prefix(self.name)) self.indef = strFunctions.get_indefinite(self.lower_name) self.indef_u = strFunctions.upper_first(self.indef) self.reqd_att = [] self.opt_att = [] self.reqd_elem = [] self.opt_elem = [] self.reqd_child_lo_elem = [] self.opt_child_lo_elem = [] self.parse_attributes(self, object_desc['attribs']) self.parse_elements(self, object_desc['attribs'], object_desc['root']) self.rules = [] self.tc = 'TBC'
def print_typecode_strings(self, fileout): """ Write out the typecode strings, for each class represented in self.elements TODO not sure what typecode strings are :param fileout: object representing output file we are writing. """ for element in self.elements: # if not element['name'].endswith('Document'): name = SF.remove_prefix(element['name']) fileout.copy_line_verbatim(' , \"{0}\"\n'.format(name))
def write_core_attribute_rule(self, lo_child=None): if lo_child is None: text = '{0} {1} object may have the optional SBML Level~3 ' \ 'Core attributes {2} and {3}. No other attributes from the ' \ 'SBML Level~3 Core namespaces are permitted on {4} {1}.'\ .format(self.indef_u, self.formatted_name, strFunctions.wrap_token('metaid'), strFunctions.wrap_token('sboTerm'), self.indef) ref = 'SBML Level~3 Version~1 Core, Section~3.2.' sev = 'ERROR' lib_sev = '{0}_SEV_ERROR'.format(global_variables.up_full_lib) tc = '{0}{1}AllowedCoreAttributes'.format(self.up_package, self.name) short = 'Core attributes allowed on <{0}>.'.format(self.lower_name) lo = False else: loname = strFunctions.get_element_name(lo_child, leave_pkg_prefix=False) temp = strFunctions.remove_prefix(lo_child['element']) lo_name = loname[7:] #strFunctions.plural(temp) text = 'A {0} object may have the optional SBML Level~3 ' \ 'Core attributes {1} and {2}. No other attributes from the ' \ 'SBML Level~3 Core namespaces are permitted on a {0} object.'\ .format(strFunctions.get_element_name(lo_child, False), strFunctions.wrap_token('metaid'), strFunctions.wrap_token('sboTerm')) sec_name = 'listof' + lo_name.lower() ref = '{0}, {1}.'\ .format(self.pkg_ref, strFunctions.wrap_section(sec_name)) sev = 'ERROR' lib_sev = '{0}_SEV_ERROR'.format(global_variables.up_full_lib) tc = '{0}{1}LO{2}AllowedCoreAttributes'.format( self.up_package, self.name, lo_name) lo = True short = 'Core attributes allowed on <listOf{0}>.'.format(lo_name) lib_ref = 'L3V1 {0} V1 Section'.format(self.up_package) return dict({ 'number': self.number, 'text': text, 'reference': ref, 'severity': sev, 'typecode': tc, 'lib_sev': lib_sev, 'short': short, 'lib_ref': lib_ref, 'plugin': False, 'object': self.name, 'lo': lo, 'reqd': self.reqd_elem, 'opt': self.opt_elem })
def write_core_subobject_rule(self, lo_child=None): if lo_child is None: text = '{0} {1} object may have the optional SBML Level~3 ' \ 'Core subobjects for notes and annotations. No other ' \ 'elements from the SBML Level~3 Core namespaces are ' \ 'permitted on {2} {1}.'\ .format(self.indef_u, self.formatted_name, self.indef) ref = 'SBML Level~3 Version~1 Core, Section~3.2.' sev = 'ERROR' lib_sev = '{0}_SEV_ERROR'.format(global_variables.up_full_lib) tc = '{0}{1}AllowedCoreElements'.format(self.up_package, self.name) short = 'Core elements allowed on <{0}>.'.format(self.lower_name) lo = False else: loname = strFunctions.get_element_name(lo_child, leave_pkg_prefix=False) temp = strFunctions.remove_prefix(lo_child['element']) lo_name = loname[7:] #strFunctions.plural(temp) text = 'Apart from the general notes and annotations subobjects ' \ 'permitted on all SBML objects, a {0} container object ' \ 'may only contain \{1} objects.'\ .format(loname, temp) sec_name = 'listof' + lo_name.lower() ref = '{0}, {1}.'\ .format(self.pkg_ref, strFunctions.wrap_section(sec_name)) sev = 'ERROR' lib_sev = '{0}_SEV_ERROR'.format(global_variables.up_full_lib) tc = '{0}{1}LO{2}AllowedCoreElements'.format( self.up_package, self.name, lo_name) lo = True short = 'Core elements allowed on <listOf{0}>.'.format(lo_name) lib_ref = 'L3V1 {0} V1 Section'.format(self.up_package) return dict({ 'number': self.number, 'text': text, 'reference': ref, 'severity': sev, 'typecode': tc, 'lib_sev': lib_sev, 'short': short, 'lib_ref': lib_ref, 'plugin': False, 'object': self.name, 'lo': lo, 'reqd': self.reqd_elem, 'opt': self.opt_elem })
def adjust_line(line): lowerlibname = global_variables.library_name.lower() nonlibname = lowerlibname if lowerlibname.startswith('lib'): nonlibname = lowerlibname[3:] line = re.sub('nonlibsbml', nonlibname, line) line = re.sub('SBase', global_variables.std_base, line) line = re.sub('LIBSBML', global_variables.library_name.upper(), line) line = re.sub('LibSBML', strFunctions.upper_first(global_variables.library_name), line) line = re.sub('libSBML', strFunctions.lower_first(global_variables.library_name), line) line = re.sub('libsbml', lowerlibname, line) if lowerlibname.startswith('lib'): line = re.sub('sbmlfwd', '{0}fwd'.format(lowerlibname[3:]), line) else: line = re.sub('sbmlfwd', '{0}fwd'.format(lowerlibname), line) doctype = '{0}_DOCUMENT'.format(global_variables.language.upper()) if global_variables.document_class != 'SedDocument': doctype = 'LIB_{0}_{1}'.format(strFunctions.get_library_suffix(global_variables.library_name).upper(), strFunctions.remove_prefix(global_variables.document_class).upper()) line = re.sub('SBML_DOCUMENT', doctype, line) line = re.sub('SBMLDocument', global_variables.document_class, line) line = re.sub('toplevelname', strFunctions.lower_first(global_variables.top_level_element_name), line) line = re.sub('CAT_SBML', 'CAT_{0}'.format(global_variables.language.upper()), line) line = re.sub('SBML_Lang', '{0}'.format(global_variables.language.upper()), line) line = re.sub('SBML_', '{0}_'.format(global_variables.language.upper()), line) # hack for SedML if global_variables.prefix == 'Sed': line = re.sub('readSBML', 'read{0}ML'.format(global_variables.prefix), line) line = re.sub('writeSBML', 'write{0}ML'.format(global_variables.prefix), line) else: line = re.sub('readSBML', 'read{0}'.format(global_variables.language.upper()), line) line = re.sub('writeSBML', 'write{0}'.format(global_variables.language.upper()), line) line = re.sub('sbml', global_variables.language, line) line = re.sub('SBMLSBML', '{0}{1}'.format(strFunctions.upper_first(global_variables.language), global_variables.prefix), line) line = re.sub('SBML', global_variables.prefix, line) line = re.sub('ListOf', '{0}ListOf'.format(global_variables.prefix), line) line = re.sub('SPEC_NAMESPACE', '\"{0}\"'.format(global_variables.namespaces[0]['namespace']), line) line = re.sub('language_', '{0}'.format(global_variables.language.lower()), line) line = re.sub('LANGUAGE', '{0}'.format(global_variables.language.upper()), line) return line
def write_core_attribute_rule(self, lo_child=None): if lo_child is None: text = '{0} {1} object may have the optional SBML Level~3 ' \ 'Core attributes {2} and {3}. No other attributes from the ' \ 'SBML Level 3 Core namespaces are permitted on {4} {1}.'\ .format(self.indef_u, self.formatted_name, strFunctions.wrap_token('metaid'), strFunctions.wrap_token('sboTerm'), self.indef) ref = 'SBML Level~3 Version~1 Core, Section~3.2.' sev = 'ERROR' lib_sev = '{0}_SEV_ERROR'.format(global_variables.up_full_lib) tc = '{0}{1}AllowedCoreAttributes'.format(self.up_package, self.name) short = 'Core attributes allowed on <{0}>.'.format(self.lower_name) lo = False else: temp = strFunctions.remove_prefix(lo_child['element']) lo_name = strFunctions.plural(temp) text = 'A {0} object may have the optional SBML Level~3 ' \ 'Core attributes {1} and {2}. No other attributes from the ' \ 'SBML Level 3 Core namespaces are permitted on a {0} object.'\ .format(strFunctions.get_element_name(lo_child, False), strFunctions.wrap_token('metaid'), strFunctions.wrap_token('sboTerm')) sec_name = 'listof' + lo_name.lower() ref = '{0}, {1}.'\ .format(self.pkg_ref, strFunctions.wrap_section(sec_name)) sev = 'ERROR' lib_sev = '{0}_SEV_ERROR'.format(global_variables.up_full_lib) tc = '{0}{1}LO{2}AllowedCoreAttributes'.format(self.up_package, self.name, lo_name) lo = True short = 'Core attributes allowed on <listOf{0}>.'.format(lo_name) lib_ref = 'L3V1 {0} V1 Section'.format(self.up_package) return dict({'number': self.number, 'text': text, 'reference': ref, 'severity': sev, 'typecode': tc, 'lib_sev': lib_sev, 'short': short, 'lib_ref': lib_ref, 'plugin': False, 'object': self.name, 'lo': lo, 'reqd': self.reqd_elem, 'opt': self.opt_elem})
def print_document_errors(self, fileout): """ Write out the document errors to the file. TODO Sorry, I don't know what these are :param fileout: object representing output file we are writing. """ root = {'baseElements': self.elements} doc = query.get_class(gv.document_class, root) if not doc: docname = 'Document' else: docname = SF.remove_prefix(doc['name'], remove_package=False, remove_doc_prefix=True) libname = SF.get_library_suffix(gv.library_name) if not libname.endswith('ml'): libname = libname + 'ml' fileout.copy_line_verbatim((10 * '') + 'if ( errorId == {0}{1}Allowed' 'CoreAttributes\n'.format(libname, docname)) level = False version = False if doc and 'attribs' in doc: for a in doc['attribs']: if a['name'] == 'level': level = True elif a['name'] == 'version': version = True if level: fileout.copy_line_verbatim((12 * ' ') + '|| errorId == {0}{1}' 'LevelMustBeNonNegativeInteger\n' ''.format(libname, docname)) if version: fileout.copy_line_verbatim((12 * ' ') + '|| errorId == {0}{1}' 'VersionMustBeNonNegativeInteger\n' ''.format(libname, docname)) fileout.copy_line_verbatim(' || errorId == InvalidNamespace' 'On{0})\n'.format(gv.prefix))
def write_core_subobject_rule(self, lo_child=None): if lo_child is None: text = '{0} {1} object may have the optional SBML Level~3 ' \ 'Core subobjects for notes and annotations. No other ' \ 'elements from the SBML Level 3 Core namespaces are ' \ 'permitted on {2} {1}.'\ .format(self.indef_u, self.formatted_name, self.indef) ref = 'SBML Level~3 Version~1 Core, Section~3.2.' sev = 'ERROR' lib_sev = '{0}_SEV_ERROR'.format(global_variables.up_full_lib) tc = '{0}{1}AllowedCoreElements'.format(self.up_package, self.name) short = 'Core elements allowed on <{0}>.'.format(self.lower_name) lo = False else: loname = strFunctions.get_element_name_no_prefix(lo_child) temp = strFunctions.remove_prefix(lo_child['element']) lo_name = strFunctions.plural(temp) text = 'Apart from the general notes and annotations subobjects ' \ 'permitted on all SBML objects, a {0} container object ' \ 'may only contain \{1} objects.'\ .format(loname, temp) sec_name = 'listof' + lo_name.lower() ref = '{0}, {1}.'\ .format(self.pkg_ref, strFunctions.wrap_section(sec_name)) sev = 'ERROR' lib_sev = '{0}_SEV_ERROR'.format(global_variables.up_full_lib) tc = '{0}{1}LO{2}AllowedCoreElements'.format(self.up_package, self.name, lo_name) lo = True short = 'Core elements allowed on <listOf{0}>.'.format(lo_name) lib_ref = 'L3V1 {0} V1 Section'.format(self.up_package) return dict({'number': self.number, 'text': text, 'reference': ref, 'severity': sev, 'typecode': tc, 'lib_sev': lib_sev, 'short': short, 'lib_ref': lib_ref, 'plugin': False, 'object': self.name, 'lo': lo, 'reqd': self.reqd_elem, 'opt': self.opt_elem})
def write_level_version_constructor(self, index=0): # I want to write the equivalent constructor but without level and version if not global_variables.has_level_version: return self.write_class_constructor(index) if (len(self.concretes) == 0 and index == 0) or index == -1: ob_name = self.object_name create = 'create' elif self.is_cpp_api: ob_name = self.object_name create = 'create' else: if index == 0: return else: i = index - 1 ob_name = '{0}'.format(self.concretes[i]['element'], self.object_name) create = 'create{0}'.format( strFunctions.remove_prefix(self.concretes[i]['element'])) # create doc string header title_line = 'Creates a new {0} using the given {1} Level' \ .format(ob_name, self.cap_language) if global_variables.is_package: title_line += ', Version and “{0}” package ' \ 'version.'.format(strFunctions. lower_first(self.package)) else: title_line += ' and @ p version values.' params = [ '@param level an unsigned int, the {0} Level to ' 'assign to this {1}.'.format(self.cap_language, self.object_name), '@param version an unsigned int, the {0} Version to ' 'assign to this {1}.'.format(self.cap_language, self.object_name) ] if global_variables.is_package: params.append('@param pkgVersion an unsigned int, the {0} {1} ' 'Version to assign to this {2}.'.format( self.cap_language, self.package, self.object_name)) #changed following current documentation practice return_lines = ['@copydetails doc_note_setting_lv_pkg'] # return_lines = ['@throws {0}Constructor' # 'Exception'.format(self.cap_language), # 'Thrown if the given @p level and @p version ' # 'combination, or this kind of {0} object, are either ' # 'invalid or mismatched with respect to the parent ' # '{1} object.'.format(self.cap_language, # global_variables.document_class), # '@copydetails doc_note_setting_lv'] additional = [] if not self.is_cpp_api: additional.append('@copydetails doc_returned_owned_pointer') # create the function declaration if self.is_cpp_api: function = self.class_name return_type = '' else: function = '{0}_{1}'.format(self.class_name, create) if not ob_name.endswith('_t'): return_type = '{0}_t *'.format(ob_name) else: return_type = '{0} *'.format(ob_name) if global_variables.is_package: arguments = [ 'unsigned int level = ' '{0}Extension::getDefaultLevel()'.format(self.package), 'unsigned int version = ' '{0}Extension::getDefaultVersion()'.format(self.package), 'unsigned int pkgVersion = ' '{0}Extension::getDefaultPackageVersion()'.format(self.package) ] arguments_no_defaults = [ 'unsigned int level', 'unsigned int version', 'unsigned int pkgVersion' ] else: if self.is_cpp_api: arguments = [ 'unsigned int level = {0}_DEFAULT_' 'LEVEL'.format(global_variables.language.upper()), 'unsigned int version = {0}_DEFAULT_VERSI' 'ON'.format(global_variables.language.upper()) ] arguments_no_defaults = [ 'unsigned int level', 'unsigned int version' ] else: arguments = ['unsigned int level', 'unsigned int version'] arguments_no_defaults = [ 'unsigned int level', 'unsigned int version' ] # create the function implementation constructor_args = self.write_constructor_args(None) if global_variables.is_package: if self.is_cpp_api: implementation = [ 'set{0}NamespacesAndOwn(new {1}PkgNamespaces' '(level, version, ' 'pkgVersion))'.format(global_variables.prefix, self.package) ] if self.has_children: implementation.append('connectToChild()') else: if index == 0 or index == -1: name = self.class_name else: name = self.concretes[index - 1]['element'] implementation = [ 'return new {0}(level, version, ' 'pkgVersion)'.format(name) ] else: if self.is_cpp_api: implementation = [ 'set{0}NamespacesAndOwn(new {0}Namespaces(' 'level, ' 'version))'.format(global_variables.prefix) ] if self.document: for attrib in self.attributes: if attrib['name'] == 'level': implementation.append('setLevel(level)') elif attrib['name'] == 'version': implementation.append('setVersion(version)') implementation.append('set{0}(this)'.format( global_variables.document_class)) if self.has_children: for lo_element in self.child_lo_elements: if lo_element['name'].lower( ) != strFunctions.remove_prefix( lo_element['element']).lower(): implementation.append( '{0}.setElementName(\"{1}\")'.format( lo_element['memberName'], lo_element['name'])) implementation.append('connectToChild()') else: name_to_use = ob_name if ob_name.endswith('_t'): length = len(ob_name) name_to_use = ob_name[0:length - 2] implementation = [ 'return new {0}(level, ' 'version)'.format(name_to_use) ] code = [dict({'code_type': 'line', 'code': implementation})] return dict({ 'title_line': title_line, 'params': params, 'return_lines': return_lines, 'additional': additional, 'function': function, 'return_type': return_type, 'arguments': arguments, 'constant': False, 'virtual': False, 'object_name': self.object_name, 'implementation': code, 'args_no_defaults': arguments_no_defaults, 'constructor_args': constructor_args })
def write_namespace_constructor(self, index=0): if len(self.concretes) == 0 and index == 0: ob_name = self.object_name create = 'create' elif self.is_cpp_api: ob_name = self.object_name create = 'create' else: if index == 0: return else: i = index - 1 ob_name = '{0} ({1})'.format(self.concretes[i]['element'], self.object_name) create = 'create{0}'.format(self.concretes[i]['element']) # create doc string header title_line = 'Creates a new {0} using the given'\ .format(ob_name) if global_variables.is_package: title_line = title_line + ' {0}PkgNamespaces object.' \ .format(self.package) else: title_line = title_line + ' {0}Namespaces object @p {1}ns.' \ .format(global_variables.prefix, self.language) params = [] if global_variables.is_package: params.append('@copydetails doc_what_are_sbml_package_namespaces') params.append('@param {0}ns the {1}PkgNamespaces object.'.format( self.package.lower(), self.package)) else: params.append('@param {0}ns the {1}Namespaces object.'.format( self.language, global_variables.prefix)) #changed following current documentation practice return_lines = ['@copydetails doc_note_setting_lv_pkg'] # return_lines = ['@throws {0}Constructor' # 'Exception'.format(self.cap_language), # 'Thrown if the given @p level and @p version ' # 'combination, or this kind of {0} object, are either ' # 'invalid or mismatched with respect to the parent ' # '{1} object.'.format(self.cap_language, # global_variables.document_class), # '@copydetails doc_note_setting_lv'] additional = '' # create the function declaration if self.is_cpp_api: function = self.class_name return_type = '' else: function = '{0}_{1}WithNS'.format(self.class_name, create) return_type = '{0} *'.format(self.object_name) arguments = [] if global_variables.is_package: if self.is_cpp_api: arguments.append('{0}PkgNamespaces *{1}ns'.format( self.package, self.package.lower())) else: arguments.append('{0}PkgNamespaces_t *{1}ns'.format( self.package, self.package.lower())) ns = '{0}ns'.format(self.package.lower()) else: if self.is_cpp_api: arguments.append('{0}Namespaces *{1}ns'.format( global_variables.prefix, self.language)) else: arguments.append('{0}Namespaces_t *{1}ns'.format( global_variables.prefix, self.language)) ns = '{0}ns'.format(self.language) # create the function implementation constructor_args = self.write_constructor_args(ns) # if global_variables.is_package: implementation = ['setElementNamespace({0}' '->getURI())'.format(ns)] if self.document: for attrib in self.attributes: if attrib['name'] == 'level': implementation.append( 'setLevel({0}->getLevel())'.format(ns)) elif attrib['name'] == 'version': implementation.append( 'setVersion({0}->getVersion())'.format(ns)) implementation.append('set{0}(this)'.format( global_variables.document_class)) if self.has_children: for lo_element in self.child_lo_elements: if lo_element['name'].lower() != strFunctions.remove_prefix( lo_element['element']).lower(): implementation.append('{0}.setElementName(\"{1}\")'.format( lo_element['memberName'], lo_element['name'])) implementation.append('connectToChild()') if global_variables.is_package and not self.is_list_of: implementation.append('loadPlugins({0}ns)'.format( self.package.lower())) # else: # implementation = ['set{0}NamespacesAndOwn(new {0}Namespaces' # '(level, ' # 'version))'.format(global_variables.prefix)] code = [dict({'code_type': 'line', 'code': implementation})] return dict({ 'title_line': title_line, 'params': params, 'return_lines': return_lines, 'additional': additional, 'function': function, 'return_type': return_type, 'arguments': arguments, 'constant': False, 'virtual': False, 'object_name': self.object_name, 'implementation': code, 'constructor_args': constructor_args })
def expand_attributes(self, attributes): for i in range(0, len(attributes)): capname = strFunctions.upper_first(attributes[i]['name']) attributes[i]['name'] = strFunctions.lower_first(capname) attributes[i]['capAttName'] = capname attributes[i]['memberName'] = 'm' + capname attributes[i]['pluralName'] = \ strFunctions.plural(attributes[i]['name']) attributes[i]['isEnum'] = False attributes[i]['isArray'] = False attributes[i]['isVector'] = False attributes[i]['children_overwrite'] = False att_type = attributes[i]['type'] if att_type == 'SId' or att_type == 'SIdRef' or att_type == 'IDREF': attributes[i]['attType'] = 'string' attributes[i]['attTypeCode'] = 'std::string&' attributes[i]['CType'] = 'const char *' attributes[i]['isNumber'] = False attributes[i]['default'] = '""' elif att_type == 'UnitSId' or att_type == 'UnitSIdRef': attributes[i]['attType'] = 'string' attributes[i]['attTypeCode'] = 'std::string&' attributes[i]['CType'] = 'const char *' attributes[i]['isNumber'] = False attributes[i]['default'] = '""' elif att_type == 'string': attributes[i]['attType'] = 'string' attributes[i]['attTypeCode'] = 'std::string&' attributes[i]['CType'] = 'const char *' attributes[i]['isNumber'] = False attributes[i]['default'] = '""' elif att_type == 'double': attributes[i]['attType'] = 'double' attributes[i]['attTypeCode'] = 'double' attributes[i]['CType'] = 'double' attributes[i]['isNumber'] = True attributes[i]['default'] = 'util_NaN()' elif att_type == 'int': attributes[i]['attType'] = 'integer' attributes[i]['attTypeCode'] = 'int' attributes[i]['CType'] = 'int' attributes[i]['isNumber'] = True attributes[i]['default'] = '{0}_INT_' \ 'MAX'.format(self.cap_language) elif att_type == 'uint': attributes[i]['attType'] = 'unsigned integer' attributes[i]['attTypeCode'] = 'unsigned int' attributes[i]['CType'] = 'unsigned int' attributes[i]['isNumber'] = True attributes[i]['default'] = '{0}_INT_' \ 'MAX'.format(self.cap_language) elif att_type == 'bool' or att_type == 'boolean': attributes[i]['attType'] = 'boolean' attributes[i]['attTypeCode'] = 'bool' attributes[i]['CType'] = 'int' attributes[i]['isNumber'] = False attributes[i]['default'] = 'false' elif att_type == 'enum': attributes[i]['isEnum'] = True attributes[i]['attType'] = 'enum' attributes[i]['attTypeCode'] = attributes[i]['element'] + '_t' attributes[i]['CType'] = attributes[i]['element'] + '_t' attributes[i]['isNumber'] = False attributes[i]['default'] = \ query.get_default_enum_value(attributes[i]) elif att_type == 'element': el_name = attributes[i]['element'] at_name = attributes[i]['name'] attributes[i]['attType'] = 'element' if attributes[i]['name'] == 'math': if global_variables.is_package: attributes[i]['attTypeCode'] = 'ASTNode*' attributes[i]['CType'] = 'ASTNode_t*' else: attributes[i]['attTypeCode'] = 'LIBSBML_CPP_NAMESPACE_QUALIFIER ASTNode*' attributes[i]['CType'] = 'LIBSBML_CPP_NAMESPACE_QUALIFIER ASTNode_t*' else: attributes[i]['attTypeCode'] = attributes[i]['element']+'*' attributes[i]['CType'] = attributes[i]['element']+'_t*' if attributes[i]['attTypeCode'] == 'XMLNode*' and not global_variables.is_package: attributes[i]['attTypeCode'] = 'LIBSBML_CPP_NAMESPACE_QUALIFIER {0}*'.format(attributes[i]['element']) attributes[i]['CType'] = 'LIBSBML_CPP_NAMESPACE_QUALIFIER {0}_t*'.format(attributes[i]['element']) attributes[i]['isNumber'] = False attributes[i]['default'] = 'NULL' if strFunctions.compare_no_case(strFunctions.remove_prefix(el_name), at_name): attributes[i]['children_overwrite'] = False else: attributes[i]['children_overwrite'] = True elif att_type == 'lo_element' or att_type == 'inline_lo_element': name = strFunctions.list_of_name(attributes[i]['element']) plural = strFunctions.plural_no_prefix(attributes[i]['element']) attributes[i]['attType'] = 'lo_element' attributes[i]['attTypeCode'] = name attributes[i]['CType'] = 'ListOf_t' attributes[i]['memberName'] = 'm' + plural attributes[i]['isNumber'] = False attributes[i]['default'] = 'NULL' elif att_type == 'array': attributes[i]['isArray'] = True attributes[i]['element'] = \ strFunctions.lower_first(attributes[i]['element']) attributes[i]['attType'] = 'array' attributes[i]['attTypeCode'] = attributes[i]['element'] + '*' attributes[i]['CType'] = attributes[i]['attTypeCode'] attributes[i]['isNumber'] = False attributes[i]['default'] = 'NULL' elif att_type == 'vector': attributes[i]['isVector'] = True attributes[i]['element'] = \ strFunctions.lower_first(attributes[i]['element']) attributes[i]['attType'] = 'vector' attributes[i]['attTypeCode'] = 'std::vector<{0}>'.format(attributes[i]['element']) attributes[i]['CType'] = attributes[i]['attTypeCode'] attributes[i]['isNumber'] = False attributes[i]['default'] = 'NULL' else: global_variables.code_returned \ = global_variables.return_codes['unknown type used'] attributes[i]['attType'] = 'FIXME_{0}'.format(att_type) attributes[i]['attTypeCode'] = 'FIXME_{0}'.format(att_type) attributes[i]['CType'] = 'FIXME_{0}'.format(att_type) attributes[i]['isNumber'] = False attributes[i]['default'] = 'FIXME_{0}'.format(att_type) return attributes
def adjust_line(line): lowerlibname = global_variables.library_name.lower() nonlibname = lowerlibname if lowerlibname.startswith('lib'): nonlibname = lowerlibname[3:] line = re.sub('nonlibsbml', nonlibname, line) line = re.sub('SBase', global_variables.std_base, line) line = re.sub('LIBSBML', global_variables.library_name.upper(), line) line = re.sub('LibSBML', strFunctions.upper_first(global_variables.library_name), line) line = re.sub('libSBML', strFunctions.lower_first(global_variables.library_name), line) line = re.sub('libsbml', lowerlibname, line) if lowerlibname.startswith('lib'): line = re.sub('sbmlfwd', '{0}fwd'.format(lowerlibname[3:]), line) else: line = re.sub('sbmlfwd', '{0}fwd'.format(lowerlibname), line) doctype = '{0}_DOCUMENT'.format(global_variables.language.upper()) if global_variables.document_class != 'SedDocument': doctype = 'LIB_{0}_{1}'.format( strFunctions.get_library_suffix( global_variables.library_name).upper(), strFunctions.remove_prefix( global_variables.document_class).upper()) line = re.sub('SBML_DOCUMENT', doctype, line) line = re.sub('SBMLDocument', global_variables.document_class, line) line = re.sub( 'toplevelname', strFunctions.lower_first(global_variables.top_level_element_name), line) line = re.sub('CAT_SBML', 'CAT_{0}'.format(global_variables.language.upper()), line) line = re.sub('SBML_Lang', '{0}'.format(global_variables.language.upper()), line) line = re.sub('SBML_', '{0}_'.format(global_variables.language.upper()), line) # hack for SedML if global_variables.prefix == 'Sed': line = re.sub('readSBML', 'read{0}ML'.format(global_variables.prefix), line) line = re.sub('writeSBML', 'write{0}ML'.format(global_variables.prefix), line) else: line = re.sub('readSBML', 'read{0}'.format(global_variables.language.upper()), line) line = re.sub('writeSBML', 'write{0}'.format(global_variables.language.upper()), line) line = re.sub('sbml', global_variables.language, line) line = re.sub( 'SBMLSBML', '{0}{1}'.format( strFunctions.upper_first(global_variables.language), global_variables.prefix), line) line = re.sub('SBML', global_variables.prefix, line) line = re.sub('ListOf', '{0}ListOf'.format(global_variables.prefix), line) line = re.sub( 'SPEC_NAMESPACE', '\"{0}\"'.format(global_variables.namespaces[0]['namespace']), line) line = re.sub('language_', '{0}'.format(global_variables.language.lower()), line) line = re.sub('LANGUAGE', '{0}'.format(global_variables.language.upper()), line) return line
def print_typecode_strings(self, fileout): for element in self.elements: # if not element['name'].endswith('Document'): name = strFunctions.remove_prefix(element['name']) fileout.copy_line_verbatim(' , \"{0}\"\n' ''.format(name))
def print_typecode_strings(self, fileout): for element in self.elements: # if not element['name'].endswith('Document'): name = strFunctions.remove_prefix(element['name']) fileout.copy_line_verbatim(' , \"{0}\"\n' ''.format(name))
def write_create_object(self): if not self.is_cpp_api: return elif self.is_list_of: return if len(self.elements) == 0: return # create comment parts params = [] return_lines = [] additional = [] title_line = 'Creates and returns an new "elementName" object in this {0}.' \ .format(self.class_name) params.append('@param elementName, the name of the element to create.') return_lines.append('@return pointer to the element created.') # create the function declaration function = 'createChildObject' # if self.is_plugin: return_type = '{0}*'.format(global_variables.baseClass) arguments = ['const std::string& elementName'] code = [] # create the function implementation if self.is_plugin: first_line = ['{0}* obj = NULL'.format(global_variables.baseClass)] else: first_line = ['{0}* obj = NULL'.format(self.base_class)] last_line = ['return obj'] if not self.has_elements_with_same_xml_name(): first = True block = [] if_block = [] for elem in self.elements: if elem['concrete']: for conc in elem['concrete']: if not first: block.append('else if') else: first = False concname = conc['name'] concelem = conc['name'] if conc['name'].lower() != conc['element'].lower(): concelem = strFunctions.lower_first( strFunctions.remove_prefix(conc['element'])) # hack for render if self.package == 'Render' or self.package == 'render': remove_prefix = True prefix_to_remove = strFunctions.upper_first( self.package) concelem = strFunctions.remove_prefix( conc['element'], False, remove_prefix, prefix_to_remove) block.append('elementName == \"{0}\"'.format(concname)) block.append('return create{0}()'.format( strFunctions.upper_first(concelem))) if len(block) > 2: if_block = self.create_code_block('else_if', block) else: if_block = self.create_code_block('if', block) else: if not first: block.append('else if') else: first = False block.append('elementName == \"{0}\"'.format(elem['name'])) [elem_name, unused] = strFunctions.remove_hyphens(elem['name']) block.append('return create{0}()'.format( strFunctions.upper_first(elem_name))) if len(block) > 2: if_block = self.create_code_block('else_if', block) else: if_block = self.create_code_block('if', block) code = [ self.create_code_block('line', first_line), if_block, self.create_code_block('line', last_line) ] else: code = [ self.create_code_block('line', first_line), self.create_code_block('comment', ['TO DO']), self.create_code_block('line', last_line) ] # return the parts return dict({ 'title_line': title_line, 'params': params, 'return_lines': return_lines, 'additional': additional, 'function': function, 'return_type': return_type, 'arguments': arguments, 'constant': False, 'virtual': True, 'object_name': self.struct_name, 'implementation': code })