libsbml.py

Go to the documentation of this file.

from __future__ import generators
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.40
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.
# This file is compatible with both classic and new-style classes.

from sys import version_info
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_libsbml', [dirname(__file__)])
        except ImportError:
            import _libsbml
            return _libsbml
        if fp is not None:
            try:
                _mod = imp.load_module('_libsbml', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _libsbml = swig_import_helper()
    del swig_import_helper
else:
    import _libsbml
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static) or hasattr(self,name):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

def _swig_setattr(self,class_type,name,value):
    return _swig_setattr_nondynamic(self,class_type,name,value,0)

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

def _swig_repr(self):
    try: strthis = "proxy of " + self.this.__repr__()
    except: strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0


class ModelCreatorList(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ModelCreatorList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ModelCreatorList, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _libsbml.new_ModelCreatorList()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _libsbml.delete_ModelCreatorList
    __del__ = lambda self : None;
    def add(self, *args): return _libsbml.ModelCreatorList_add(self, *args)
    def get(self, *args): return _libsbml.ModelCreatorList_get(self, *args)
    def prepend(self, *args): return _libsbml.ModelCreatorList_prepend(self, *args)
    def remove(self, *args): return _libsbml.ModelCreatorList_remove(self, *args)
    def getSize(self): return _libsbml.ModelCreatorList_getSize(self)
ModelCreatorList_swigregister = _libsbml.ModelCreatorList_swigregister
ModelCreatorList_swigregister(ModelCreatorList)

class DateList(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DateList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DateList, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _libsbml.new_DateList()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _libsbml.delete_DateList
    __del__ = lambda self : None;
    def add(self, *args): return _libsbml.DateList_add(self, *args)
    def get(self, *args): return _libsbml.DateList_get(self, *args)
    def prepend(self, *args): return _libsbml.DateList_prepend(self, *args)
    def remove(self, *args): return _libsbml.DateList_remove(self, *args)
    def getSize(self): return _libsbml.DateList_getSize(self)
DateList_swigregister = _libsbml.DateList_swigregister
DateList_swigregister(DateList)

class CVTermList(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CVTermList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CVTermList, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _libsbml.new_CVTermList()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _libsbml.delete_CVTermList
    __del__ = lambda self : None;
    def add(self, *args): return _libsbml.CVTermList_add(self, *args)
    def get(self, *args): return _libsbml.CVTermList_get(self, *args)
    def prepend(self, *args): return _libsbml.CVTermList_prepend(self, *args)
    def remove(self, *args): return _libsbml.CVTermList_remove(self, *args)
    def getSize(self): return _libsbml.CVTermList_getSize(self)
CVTermList_swigregister = _libsbml.CVTermList_swigregister
CVTermList_swigregister(CVTermList)

class ASTNodeList(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ASTNodeList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ASTNodeList, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _libsbml.new_ASTNodeList()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _libsbml.delete_ASTNodeList
    __del__ = lambda self : None;
    def add(self, *args): return _libsbml.ASTNodeList_add(self, *args)
    def get(self, *args): return _libsbml.ASTNodeList_get(self, *args)
    def prepend(self, *args): return _libsbml.ASTNodeList_prepend(self, *args)
    def remove(self, *args): return _libsbml.ASTNodeList_remove(self, *args)
    def getSize(self): return _libsbml.ASTNodeList_getSize(self)
ASTNodeList_swigregister = _libsbml.ASTNodeList_swigregister
ASTNodeList_swigregister(ASTNodeList)

class SwigPyIterator(_object):
    """Proxy of C++ swig::SwigPyIterator class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_SwigPyIterator
    __del__ = lambda self : None;
    def value(self):
        """value(self) -> PyObject"""
        return _libsbml.SwigPyIterator_value(self)

    def incr(self, n = 1):
        """
        incr(self, size_t n = 1) -> SwigPyIterator
        incr(self) -> SwigPyIterator
        """
        return _libsbml.SwigPyIterator_incr(self, n)

    def decr(self, n = 1):
        """
        decr(self, size_t n = 1) -> SwigPyIterator
        decr(self) -> SwigPyIterator
        """
        return _libsbml.SwigPyIterator_decr(self, n)

    def distance(self, *args):
        """distance(self, SwigPyIterator x) -> ptrdiff_t"""
        return _libsbml.SwigPyIterator_distance(self, *args)

    def equal(self, *args):
        """equal(self, SwigPyIterator x) -> bool"""
        return _libsbml.SwigPyIterator_equal(self, *args)

    def copy(self):
        """copy(self) -> SwigPyIterator"""
        return _libsbml.SwigPyIterator_copy(self)

    def next(self):
        """next(self) -> PyObject"""
        return _libsbml.SwigPyIterator_next(self)

    def __next__(self):
        """__next__(self) -> PyObject"""
        return _libsbml.SwigPyIterator___next__(self)

    def previous(self):
        """previous(self) -> PyObject"""
        return _libsbml.SwigPyIterator_previous(self)

    def advance(self, *args):
        """advance(self, ptrdiff_t n) -> SwigPyIterator"""
        return _libsbml.SwigPyIterator_advance(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SwigPyIterator x) -> bool"""
        return _libsbml.SwigPyIterator___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SwigPyIterator x) -> bool"""
        return _libsbml.SwigPyIterator___ne__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(self, ptrdiff_t n) -> SwigPyIterator"""
        return _libsbml.SwigPyIterator___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(self, ptrdiff_t n) -> SwigPyIterator"""
        return _libsbml.SwigPyIterator___isub__(self, *args)

    def __add__(self, *args):
        """__add__(self, ptrdiff_t n) -> SwigPyIterator"""
        return _libsbml.SwigPyIterator___add__(self, *args)

    def __sub__(self, *args):
        """
        __sub__(self, ptrdiff_t n) -> SwigPyIterator
        __sub__(self, SwigPyIterator x) -> ptrdiff_t
        """
        return _libsbml.SwigPyIterator___sub__(self, *args)

    def __iter__(self): return self
SwigPyIterator_swigregister = _libsbml.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

class string(_object):
    """Proxy of C++ std::basic_string<(char)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, string, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, string, name)
    __repr__ = _swig_repr
    def length(self):
        """length(self) -> size_type"""
        return _libsbml.string_length(self)

    def max_size(self):
        """max_size(self) -> size_type"""
        return _libsbml.string_max_size(self)

    def copy(self, *args):
        """
        copy(self, char __s, size_type __n, size_type __pos = 0) -> size_type
        copy(self, char __s, size_type __n) -> size_type
        """
        return _libsbml.string_copy(self, *args)

    def c_str(self):
        """c_str(self) -> char"""
        return _libsbml.string_c_str(self)

    def find(self, *args):
        """
        find(self, char __s, size_type __pos, size_type __n) -> size_type
        find(self, string __str, size_type __pos = 0) -> size_type
        find(self, string __str) -> size_type
        find(self, char __c, size_type __pos = 0) -> size_type
        find(self, char __c) -> size_type
        """
        return _libsbml.string_find(self, *args)

    def rfind(self, *args):
        """
        rfind(self, string __str, size_type __pos = std::basic_string< char >::npos) -> size_type
        rfind(self, string __str) -> size_type
        rfind(self, char __s, size_type __pos, size_type __n) -> size_type
        rfind(self, char __c, size_type __pos = std::basic_string< char >::npos) -> size_type
        rfind(self, char __c) -> size_type
        """
        return _libsbml.string_rfind(self, *args)

    def find_first_of(self, *args):
        """
        find_first_of(self, string __str, size_type __pos = 0) -> size_type
        find_first_of(self, string __str) -> size_type
        find_first_of(self, char __s, size_type __pos, size_type __n) -> size_type
        find_first_of(self, char __c, size_type __pos = 0) -> size_type
        find_first_of(self, char __c) -> size_type
        """
        return _libsbml.string_find_first_of(self, *args)

    def find_last_of(self, *args):
        """
        find_last_of(self, string __str, size_type __pos = std::basic_string< char >::npos) -> size_type
        find_last_of(self, string __str) -> size_type
        find_last_of(self, char __s, size_type __pos, size_type __n) -> size_type
        find_last_of(self, char __c, size_type __pos = std::basic_string< char >::npos) -> size_type
        find_last_of(self, char __c) -> size_type
        """
        return _libsbml.string_find_last_of(self, *args)

    def find_first_not_of(self, *args):
        """
        find_first_not_of(self, string __str, size_type __pos = 0) -> size_type
        find_first_not_of(self, string __str) -> size_type
        find_first_not_of(self, char __s, size_type __pos, size_type __n) -> size_type
        find_first_not_of(self, char __c, size_type __pos = 0) -> size_type
        find_first_not_of(self, char __c) -> size_type
        """
        return _libsbml.string_find_first_not_of(self, *args)

    def find_last_not_of(self, *args):
        """
        find_last_not_of(self, string __str, size_type __pos = std::basic_string< char >::npos) -> size_type
        find_last_not_of(self, string __str) -> size_type
        find_last_not_of(self, char __s, size_type __pos, size_type __n) -> size_type
        find_last_not_of(self, char __c, size_type __pos = std::basic_string< char >::npos) -> size_type
        find_last_not_of(self, char __c) -> size_type
        """
        return _libsbml.string_find_last_not_of(self, *args)

    def substr(self, *args):
        """
        substr(self, size_type __pos = 0, size_type __n = std::basic_string< char >::npos) -> string
        substr(self, size_type __pos = 0) -> string
        substr(self) -> string
        """
        return _libsbml.string_substr(self, *args)

    def empty(self):
        """empty(self) -> bool"""
        return _libsbml.string_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _libsbml.string_size(self)

    def swap(self, *args):
        """swap(self, string v)"""
        return _libsbml.string_swap(self, *args)

    def erase(self, *args):
        """
        erase(self, size_type __pos = 0, size_type __n = std::basic_string< char >::npos) -> string
        erase(self, size_type __pos = 0) -> string
        erase(self) -> string
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _libsbml.string_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(self, char __s, size_type __n) -> string
        __init__(self) -> string
        __init__(self, string arg0) -> string
        __init__(self, size_type size, value_type value) -> string
        """
        this = _libsbml.new_string(*args)
        try: self.this.append(this)
        except: self.this = this
    def assign(self, *args):
        """
        assign(self, string __str) -> string
        assign(self, string __str, size_type __pos, size_type __n) -> string
        assign(self, char __s, size_type __n) -> string
        assign(self, size_type n, value_type x)
        """
        return _libsbml.string_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _libsbml.string_resize(self, *args)

    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _libsbml.string_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _libsbml.string___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _libsbml.string___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _libsbml.string___len__(self)

    def __getslice__(self, *args):
        """__getslice__(self, difference_type i, difference_type j) -> string"""
        return _libsbml.string___getslice__(self, *args)

    def __setslice__(self, *args):
        """__setslice__(self, difference_type i, difference_type j, string v)"""
        return _libsbml.string___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _libsbml.string___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _libsbml.string___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, PySliceObject slice) -> string
        __getitem__(self, difference_type i) -> value_type
        """
        return _libsbml.string___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, PySliceObject slice, string v)
        __setitem__(self, difference_type i, value_type x)
        """
        return _libsbml.string___setitem__(self, *args)

    def insert(self, *args):
        """
        insert(self, size_type __pos1, string __str) -> string
        insert(self, size_type __pos1, string __str, size_type __pos2, size_type __n) -> string
        insert(self, size_type __pos, char __s, size_type __n) -> string
        insert(self, size_type __pos, size_type __n, char __c) -> string
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        insert(self, iterator __p, size_type __n, char __c)
        """
        return _libsbml.string_insert(self, *args)

    def replace(self, *args):
        """
        replace(self, size_type __pos, size_type __n, string __str) -> string
        replace(self, size_type __pos1, size_type __n1, string __str, size_type __pos2, 
            size_type __n2) -> string
        replace(self, size_type __pos, size_type __n1, char __s, size_type __n2) -> string
        replace(self, size_type __pos, size_type __n1, size_type __n2, char __c) -> string
        replace(self, iterator __i1, iterator __i2, string __str) -> string
        replace(self, iterator __i1, iterator __i2, char __s, size_type __n) -> string
        replace(self, iterator __i1, iterator __i2, size_type __n, char __c) -> string
        replace(self, iterator __i1, iterator __i2, char __k1, char __k2) -> string
        replace(self, iterator __i1, iterator __i2, const_iterator __k1, 
            const_iterator __k2) -> string
        """
        return _libsbml.string_replace(self, *args)

    def __iadd__(self, *args):
        """__iadd__(self, string v) -> string"""
        return _libsbml.string___iadd__(self, *args)

    def __add__(self, *args):
        """__add__(self, string v) -> string"""
        return _libsbml.string___add__(self, *args)

    def __radd__(self, *args):
        """__radd__(self, string v) -> string"""
        return _libsbml.string___radd__(self, *args)

    def __str__(self):
        """__str__(self) -> string"""
        return _libsbml.string___str__(self)

    def __rlshift__(self, *args):
        """__rlshift__(self, ostream out) -> ostream"""
        return _libsbml.string___rlshift__(self, *args)

    def __eq__(self, *args):
        """__eq__(self, string v) -> bool"""
        return _libsbml.string___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, string v) -> bool"""
        return _libsbml.string___ne__(self, *args)

    def __gt__(self, *args):
        """__gt__(self, string v) -> bool"""
        return _libsbml.string___gt__(self, *args)

    def __lt__(self, *args):
        """__lt__(self, string v) -> bool"""
        return _libsbml.string___lt__(self, *args)

    def __ge__(self, *args):
        """__ge__(self, string v) -> bool"""
        return _libsbml.string___ge__(self, *args)

    def __le__(self, *args):
        """__le__(self, string v) -> bool"""
        return _libsbml.string___le__(self, *args)

    __swig_destroy__ = _libsbml.delete_string
    __del__ = lambda self : None;
string_swigregister = _libsbml.string_swigregister
string_swigregister(string)
cvar = _libsbml.cvar
string.npos = _libsbml.cvar.string_npos

class ostream(_object):
    """Proxy of C++ std::basic_ostream<(char)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ostream, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ostream, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, std::basic_streambuf<(char,std::char_traits<(char)>)> __sb) -> ostream"""
        this = _libsbml.new_ostream(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _libsbml.delete_ostream
    __del__ = lambda self : None;
ostream_swigregister = _libsbml.ostream_swigregister
ostream_swigregister(ostream)

class ostringstream(ostream):
    """Proxy of C++ std::basic_ostringstream<(char)> class"""
    __swig_setmethods__ = {}
    for _s in [ostream]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ostringstream, name, value)
    __swig_getmethods__ = {}
    for _s in [ostream]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ostringstream, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, std::ios_base::openmode __mode = std::ios_base::out) -> ostringstream
        __init__(self) -> ostringstream
        """
        this = _libsbml.new_ostringstream(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _libsbml.delete_ostringstream
    __del__ = lambda self : None;
    def str(self, *args):
        """
        str(self) -> string
        str(self, string __s)
        """
        return _libsbml.ostringstream_str(self, *args)

ostringstream_swigregister = _libsbml.ostringstream_swigregister
ostringstream_swigregister(ostringstream)


def endl(*args):
  """endl(ostream arg0) -> ostream"""
  return _libsbml.endl(*args)

def flush(*args):
  """flush(ostream arg0) -> ostream"""
  return _libsbml.flush(*args)
import sys
import os.path


def conditional_abspath (filename):
  """conditional_abspath (filename) -> filename

  Returns filename with an absolute path prepended, if necessary.
  Some combinations of platforms and underlying XML parsers *require*
  an absolute path to a filename while others do not.  This function
  encapsulates the appropriate logic.  It is used by readSBML() and
  SBMLReader.readSBML().
  """
  if sys.platform.find('cygwin') != -1:
    return filename
  else:
    return os.path.abspath(filename)

def readSBML(*args):
  """readSBML(filename) -> SBMLDocument

  Reads an SBML document from the given file.  If filename does not exist
  or is not an SBML file, a fatal error will be logged.  Errors can be
  identified by their unique ids, e.g.:

    d = readSBML(filename)

    if d.getNumErrors() > 0:
      pm = d.getError(0)
      if pm.getErrorId() == libsbml.XMLFileUnreadable
      if pm.getErrorId() == libsbml.XMLTagMismatch: 

  """
  reader = SBMLReader()
  return reader.readSBML(args[0])


def ASTNode_true(*args):
  """ASTNode_true(ASTNode node) -> int"""
  return _libsbml.ASTNode_true(*args)
LIBSBML_DOTTED_VERSION = _libsbml.LIBSBML_DOTTED_VERSION
LIBSBML_VERSION = _libsbml.LIBSBML_VERSION
LIBSBML_VERSION_STRING = _libsbml.LIBSBML_VERSION_STRING

def getLibSBMLVersion():
  """
    getLibSBMLVersion() -> int

    Returns the libSBML version as an integer: version 1.2.3 becomes 10203.

    @return the libSBML version as an integer: version 1.2.3 becomes 10203.


    """
  return _libsbml.getLibSBMLVersion()

def getLibSBMLDottedVersion():
  """
    getLibSBMLDottedVersion() -> char

    Returns the libSBML version as a string of the form '1.2.3'.

    @return the libSBML version as a string of the form '1.2.3'.


    """
  return _libsbml.getLibSBMLDottedVersion()

def getLibSBMLVersionString():
  """
    getLibSBMLVersionString() -> char

    Returns the libSBML version as a string: version 1.2.3 becomes '10203'.

    @return the libSBML version as a string: version 1.2.3 becomes '10203'.


    """
  return _libsbml.getLibSBMLVersionString()
LIBSBML_OPERATION_RETURN_VALUES_H = _libsbml.LIBSBML_OPERATION_RETURN_VALUES_H
LIBSBML_OPERATION_SUCCESS = _libsbml.LIBSBML_OPERATION_SUCCESS
LIBSBML_INDEX_EXCEEDS_SIZE = _libsbml.LIBSBML_INDEX_EXCEEDS_SIZE
LIBSBML_UNEXPECTED_ATTRIBUTE = _libsbml.LIBSBML_UNEXPECTED_ATTRIBUTE
LIBSBML_OPERATION_FAILED = _libsbml.LIBSBML_OPERATION_FAILED
LIBSBML_INVALID_ATTRIBUTE_VALUE = _libsbml.LIBSBML_INVALID_ATTRIBUTE_VALUE
LIBSBML_INVALID_OBJECT = _libsbml.LIBSBML_INVALID_OBJECT
LIBSBML_DUPLICATE_OBJECT_ID = _libsbml.LIBSBML_DUPLICATE_OBJECT_ID
LIBSBML_LEVEL_MISMATCH = _libsbml.LIBSBML_LEVEL_MISMATCH
LIBSBML_VERSION_MISMATCH = _libsbml.LIBSBML_VERSION_MISMATCH
LIBSBML_INVALID_XML_OPERATION = _libsbml.LIBSBML_INVALID_XML_OPERATION
class SBMLReader(_object):
    """
    Methods for reading SBML from files and text strings.

    @htmlinclude libsbml-not-sbml-warning.html

    The SBMLReader class provides the main interface for reading SBML
    content from files and strings.  The methods for reading SBML all return
    an SBMLDocument object representing the results.

    In the case of failures (such as if the SBML contains errors or a file
    cannot be read), the errors will be recorded with the SBMLErrorLog object
    kept in the SBMLDocument returned by SBMLReader.  Callers should check
    for errors and warnings using the methods for this purpose provided on
    SBMLDocument.

    For convenience as well as easy access from other languages besides C++,
    this file also defines two global functions, readSBML() and
    readSBMLFromString().  They are equivalent to creating an SBMLReader
    object and then calling
    the @if clike SBMLReader::readSBML() @endif@if java SBMLReader::readSBML(String filename) @endif or
    @if clike SBMLReader::readSBMLFromString() @endif@if java SBMLReader::readSBMLFromString(String xml)  @endif methods, respectively.

    """
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLReader, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SBMLReader, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """
        __init__(self) -> SBMLReader

        Creates a new SBMLReader and returns it. 
          

        """
        this = _libsbml.new_SBMLReader()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _libsbml.delete_SBMLReader
    __del__ = lambda self : None;
    def readSBML(*args):
      """readSBML(filename) -> SBMLDocument

      Reads an SBML document from the given file.  If filename does not exist
      or is not an SBML file, a fatal error will be logged.  Errors can be
      identified by their unique ids, e.g.:

        reader = libsbml.SBMLReader()
        d      = reader.readSBML(filename)

        if d.getNumErrors() > 0:
          pm = d.getError(0)
          if pm.getErrorId() == libsbml.XMLFileUnreadable
          if pm.getErrorId() == libsbml.XMLTagMismatch: 
      """
      args_copy    = list(args)
      args_copy[1] = conditional_abspath(args[1])
      return _libsbml.SBMLReader_readSBML(*args_copy)


    def readSBMLFromFile(self, *args):
        """
        readSBMLFromFile(self, string filename) -> SBMLDocument

        Reads an SBML document from a file.

        If the file named @p filename does not exist or its content is not
        valid SBML, one or more errors will be logged with the SBMLDocument
        object returned by this method.  Callers can use the methods on
        SBMLDocument such as SBMLDocument::getNumErrors() and
        @if clike SBMLDocument::getError() @endif@if java SBMLDocument::getError(long n) @endif to get the errors.  The object returned by
        @if clike SBMLDocument::getError() @endif@if java SBMLDocument::getError(long n) @endif is an SBMLError object, and it has methods to
        get the error code, category, and severity level of the problem, as
        well as a textual description of the problem.  The possible severity
        levels range from informational messages to fatal errors; see the
        documentation for SBMLError for more information.

        If the file @p filename could not be read, the file-reading error will
        appear first.  The error code can provide a clue about what happened.
        For example, a file might be unreadable (either because it does not
        actually exist or because the user does not have the necessary access
        priviledges to read it) or some sort of file operation error may have
        bee reported by the underlying operating system.  Callers can check
        for these situations using code such as the following:
        @code
        SBMLReader* reader = new SBMLReader();
        SBMLDocument* doc  = reader.readSBML(filename);

        if (doc->getNumErrors() > 0)
        {
          if (doc->getError(0)->getId() == XMLError::FileUnreadable)
          {
            // Handle case of unreadable file here.
          } 
          else if (doc->getError(0)->getId() == XMLError::FileOperationError)
          {
            // Handle case of other file error here.
          }
          else
          {
            // Handle other cases -- see error codes defined in XMLErrorCode_t
            // for other possible cases to check.
          }
        }
        @endcode

        If the given filename ends with the suffix @c '.gz' (for example, @c
        'myfile.xml.gz'), the file is assumed to be compressed in @em gzip
        format and will be automatically decompressed upon reading.
        Similarly, if the given filename ends with @c '.zip' or @c '.bz2', the
        file is assumed to be compressed in @em zip or @em bzip2 format
        (respectively).  Files whose names lack these suffixes will be read
        uncompressed.  Note that if the file is in @em zip format but the
        archive contains more than one file, only the first file in the
        archive will be read and the rest ignored.

        @param filename the name or full pathname of the file to be read.

        @return a pointer to the SBMLDocument created from the SBML content.

        @see SBMLError

        @note LibSBML versions 2.x and 3.x behave differently in error
        handling in several respects.  One difference is how early some errors
        are caught and whether libSBML continues processing a file in the face
        of some early errors.  In general, libSBML 3.x stops parsing SBML
        inputs sooner than libSBML 2.x in the face of XML errors because the
        errors may invalidate any further SBML content.  For example, a
        missing XML declaration at the beginning of the file was ignored by
        libSBML 2.x but in version 3.x, it will cause libSBML to stop parsing
        the rest of the input altogether.  While this behavior may seem more
        severe and intolerant, it was necessary in order to provide uniform
        behavior regardless of which underlying XML parser (Expat, Xerces,
        libxml2) is being used by libSBML.  The XML parsers themselves behave
        differently in their error reporting, and sometimes libSBML has to
        resort to the lowest common denominator.

        @note To read a gzip/zip file, libSBML needs to be configured and
        linked with the <a href='http://www.zlib.net/'>zlib</a> library at
        compile time.  It also needs to be linked with the <a
        href=''>bzip2</a> library to read files in @em bzip2 format.  (Both of
        these are the default configurations for libSBML.)  Errors about
        unreadable files will be logged if a compressed filename is given and
        libSBML was @em not linked with the corresponding required library.

        @note SBMLReader::hasZlib() and SBMLReader::hasBzip2() can be used to
        check whether libSBML has been linked with each library.
          

        """
        return _libsbml.SBMLReader_readSBMLFromFile(self, *args)

    def readSBMLFromString(self, *args):
        """
        readSBMLFromString(self, string xml) -> SBMLDocument

        Reads an SBML document from the given XML string.

        This method is flexible with respect to the presence of an XML
        declaration at the beginning of the string.  In particular, if the
        string in @p xml does not begin with the XML declaration
        <code>&lt;?xml version='1.0' encoding='UTF-8'?&gt;</code>, then this
        method will automatically prepend the declaration to @p xml.

        This method will log a fatal error if the content given in the
        parameter @p xml is not SBML.  See the method documentation for
        @if clike SBMLReader::readSBML() @endif@if java SBMLReader::readSBML(String filename) @endif for an example of code for testing the returned
        error code.

        @param xml a string containing a full SBML model

        @return a pointer to the SBMLDocument created from the SBML content.

        @if clike @see SBMLReader::readSBML() @endif@if java @see SBMLReader::readSBML(String filename) @endif
          

        """
        return _libsbml.SBMLReader_readSBMLFromString(self, *args)

    def hasZlib():
        """
        hasZlib() -> bool

        Predicate returning @c true or @c false depending on whether
        libSBML is linked with zlib at compile time.

        @return @c true if zlib is linked, @c false otherwise.
          

        """
        return _libsbml.SBMLReader_hasZlib()

    if _newclass:hasZlib = staticmethod(hasZlib)
    __swig_getmethods__["hasZlib"] = lambda x: hasZlib
    def hasBzip2():
        """
        hasBzip2() -> bool

        Predicate returning @c true or @c false depending on whether
        libSBML is linked with bzip2 at compile time.

        @return @c true if bzip2 is linked, @c false otherwise.
          

        """
        return _libsbml.SBMLReader_hasBzip2()

    if _newclass:hasBzip2 = staticmethod(hasBzip2)
    __swig_getmethods__["hasBzip2"] = lambda x: hasBzip2
    def __eq__(self, rhs):
      if ((self is None) and (rhs is None)): return True
      if ((self is None) or  (rhs is None)): return False
      if (hasattr(self, 'this') and hasattr(rhs, 'this')):
        if (self.this == rhs.this): return True
      return False

    def __ne__(self, rhs):
      if ((self is None) and (rhs is None)): return False
      if ((self is None) or  (rhs is None)): return True
      if (hasattr(self, 'this') and hasattr(rhs, 'this')):
        if (self.this == rhs.this): return False
      return True

SBMLReader_swigregister = _libsbml.SBMLReader_swigregister
SBMLReader_swigregister(SBMLReader)
cout = cvar.cout
cerr = cvar.cerr
clog = cvar.clog

def SBMLReader_hasZlib():
  """
    SBMLReader_hasZlib() -> bool

    Predicate returning @c true or @c false depending on whether
    libSBML is linked with zlib at compile time.

    @return @c true if zlib is linked, @c false otherwise.
      

    """
  return _libsbml.SBMLReader_hasZlib()

def SBMLReader_hasBzip2():
  """
    SBMLReader_hasBzip2() -> bool

    Predicate returning @c true or @c false depending on whether
    libSBML is linked with bzip2 at compile time.

    @return @c true if bzip2 is linked, @c false otherwise.
      

    """
  return _libsbml.SBMLReader_hasBzip2()


def readSBMLFromFile(*args):
  """
    readSBMLFromFile(char filename) -> SBMLDocument_t

    Reads an SBML document from the given file @p filename.

    If @p filename does not exist, or it is not an SBML file, an error will
    be logged in the error log of the SBMLDocument object returned by this
    method.  Calling programs can inspect this error log to determine
    the nature of the problem.  Please refer to the definition of
    SBMLDocument for more information about the error reporting mechanism.

    @return a pointer to the SBMLDocument read.


    """
  return _libsbml.readSBMLFromFile(*args)

def readSBMLFromString(*args):
  """
    readSBMLFromString(char xml) -> SBMLDocument_t

    Reads an SBML document from a string assumed to be in XML format.

    If the string does not begin with XML declaration,
     @verbatim
     <?xml version='1.0' encoding='UTF-8'?>
     @endverbatim

    an XML declaration string will be prepended.

    This method will report an error if the given string @p xml is not SBML.
    The error will be logged in the error log of the SBMLDocument object
    returned by this method.  Calling programs can inspect this error log to
    determine the nature of the problem.  Please refer to the definition of
    SBMLDocument for more information about the error reporting mechanism.

    @return a pointer to the SBMLDocument read.


    """
  return _libsbml.readSBMLFromString(*args)
class SBMLWriter(_object):
    """
    Methods for writing SBML to files and text strings.

    @htmlinclude libsbml-not-sbml-warning.html

    The SBMLWriter class is the converse of SBMLReader, and provides the
    main interface for serializing SBML models into XML and writing the
    result to files and text strings.  The methods for writing SBML all take
    an SBMLDocument object and a destination.  They return a boolean value
    to indicate success or failure.

    """
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLWriter, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SBMLWriter, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """
        __init__(self) -> SBMLWriter

        Creates a new SBMLWriter.
          

        """
        this = _libsbml.new_SBMLWriter()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _libsbml.delete_SBMLWriter
    __del__ = lambda self : None;
    def setProgramName(self, *args):
        """
        setProgramName(self, string name) -> int

        Sets the name of this program, i.e., the program that is about to
        write out the SBMLDocument.

        If the program name and version are set (setProgramVersion()), the
        following XML comment, intended for human consumption, will be written
        at the beginning of the document:
          @verbatim
            <!-- Created by <program name> version <program version>
            on yyyy-MM-dd HH:mm with libsbml version <libsbml version>. -->
         @endverbatim

        @param name the name of this program (where 'this program' refers to
        program in which libSBML is embedded, not libSBML itself!)

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS

        @see setProgramVersion(const std::string& version)
          

        """
        return _libsbml.SBMLWriter_setProgramName(self, *args)

    def setProgramVersion(self, *args):
        """
        setProgramVersion(self, string version) -> int

        Sets the version of this program, i.e., the program that is about to
        write out the SBMLDocument.

        If the program version and name are set (setProgramName()), the
        following XML comment, intended for human consumption, will be written
        at the beginning of the document:
          @verbatim
            <!-- Created by <program name> version <program version>
            on yyyy-MM-dd HH:mm with libsbml version <libsbml version>. -->
         @endverbatim

        @param version the version of this program (where 'this program'
        refers to program in which libSBML is embedded, not libSBML itself!)

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS

        @see setProgramName(const std::string& name)
          

        """
        return _libsbml.SBMLWriter_setProgramVersion(self, *args)

    def writeSBML(self, *args):
        """
        writeSBML(self, SBMLDocument d, string filename) -> bool
        writeSBML(self, SBMLDocument d, ostream stream) -> bool

        Writes the given SBML document to the output stream.

        @param d the SBML document to be written

        @param stream the stream object where the SBML is to be written.

        @return @c true on success and @c false if one of the underlying
        parser components fail (rare).
          

        """
        return _libsbml.SBMLWriter_writeSBML(self, *args)

    def writeToString(self, *args):
        """
        writeToString(self, SBMLDocument d) -> char

        Writes the given SBML document to an in-memory string and returns a
        pointer to it.

        The string is owned by the caller and should be freed (with @c free())
        when no longer needed.

        @param d the SBML document to be written

        @return the string on success and @c 0 if one of the underlying parser
        components fail.
          

        """
        return _libsbml.SBMLWriter_writeToString(self, *args)

    def hasZlib():
        """
        hasZlib() -> bool

        Predicate returning @c true or @c false depending on whether
        underlying libSBML is linked with zlib.

        LibSBML supports reading and writing files compressed with either
        bzip2 or zip/gzip compression.  The facility depends on libSBML having
        been compiled with the necessary support libraries.  This method
        allows a calling program to inquire whether that is the case for the
        copy of libSBML it is running.

        @return @c true if libSBML is linked with zlib, @c false otherwise.
          

        """
        return _libsbml.SBMLWriter_hasZlib()

    if _newclass:hasZlib = staticmethod(hasZlib)
    __swig_getmethods__["hasZlib"] = lambda x: hasZlib
    def hasBzip2():
        """
        hasBzip2() -> bool

        Predicate returning @c true or @c false depending on whether
        underlying libSBML is linked with bzip2.

        LibSBML supports reading and writing files compressed with either
        bzip2 or zip/gzip compression.  The facility depends on libSBML having
        been compiled with the necessary support libraries.  This method
        allows a calling program to inquire whether that is the case for the
        copy of libSBML it is running.

        @return @c true if libSBML is linked with bzip2, @c false otherwise.
        @deprecated libSBML internal


        """
        return _libsbml.SBMLWriter_hasBzip2()

    if _newclass:hasBzip2 = staticmethod(hasBzip2)
    __swig_getmethods__["hasBzip2"] = lambda x: hasBzip2
    def __eq__(self, rhs):
      if ((self is None) and (rhs is None)): return True
      if ((self is None) or  (rhs is None)): return False
      if (hasattr(self, 'this') and hasattr(rhs, 'this')):
        if (self.this == rhs.this): return True
      return False

    def __ne__(self, rhs):
      if ((self is None) and (rhs is None)): return False
      if ((self is None) or  (rhs is None)): return True
      if (hasattr(self, 'this') and hasattr(rhs, 'this')):
        if (self.this == rhs.this): return False
      return True

SBMLWriter_swigregister = _libsbml.SBMLWriter_swigregister
SBMLWriter_swigregister(SBMLWriter)

def SBMLWriter_hasZlib():
  """
    SBMLWriter_hasZlib() -> bool

    Predicate returning @c true or @c false depending on whether
    underlying libSBML is linked with zlib.

    LibSBML supports reading and writing files compressed with either
    bzip2 or zip/gzip compression.  The facility depends on libSBML having
    been compiled with the necessary support libraries.  This method
    allows a calling program to inquire whether that is the case for the
    copy of libSBML it is running.

    @return @c true if libSBML is linked with zlib, @c false otherwise.
      

    """
  return _libsbml.SBMLWriter_hasZlib()

def SBMLWriter_hasBzip2():
  """
    SBMLWriter_hasBzip2() -> bool

    Predicate returning @c true or @c false depending on whether
    underlying libSBML is linked with bzip2.

    LibSBML supports reading and writing files compressed with either
    bzip2 or zip/gzip compression.  The facility depends on libSBML having
    been compiled with the necessary support libraries.  This method
    allows a calling program to inquire whether that is the case for the
    copy of libSBML it is running.

    @return @c true if libSBML is linked with bzip2, @c false otherwise.
    @deprecated libSBML internal


    """
  return _libsbml.SBMLWriter_hasBzip2()


def writeSBML(*args):
  """
    writeSBML(SBMLDocument_t d, char filename) -> int

    Writes the given SBML document to filename.  This convenience function
    is functionally equivalent to:

      SBMLWriter_writeSBML(SBMLWriter_create(), d, filename);

    @return non-zero on success and zero if the filename could not be opened
    for writing.


    """
  return _libsbml.writeSBML(*args)

def writeSBMLToString(*args):
  """
    writeSBMLToString(SBMLDocument_t d) -> char

    Writes the given SBML document to an in-memory string and returns a
    pointer to it.  The string is owned by the caller and should be freed
    (with free()) when no longer needed.  This convenience function is
    functionally equivalent to:

      SBMLWriter_writeSBMLToString(SBMLWriter_create(), d);

    @return the string on success and NULL if one of the underlying parser
    components fail (rare).


    """
  return _libsbml.writeSBMLToString(*args)
SBML_UNKNOWN = _libsbml.SBML_UNKNOWN
SBML_COMPARTMENT = _libsbml.SBML_COMPARTMENT
SBML_COMPARTMENT_TYPE = _libsbml.SBML_COMPARTMENT_TYPE
SBML_CONSTRAINT = _libsbml.SBML_CONSTRAINT
SBML_DOCUMENT = _libsbml.SBML_DOCUMENT
SBML_EVENT = _libsbml.SBML_EVENT
SBML_EVENT_ASSIGNMENT = _libsbml.SBML_EVENT_ASSIGNMENT
SBML_FUNCTION_DEFINITION = _libsbml.SBML_FUNCTION_DEFINITION
SBML_INITIAL_ASSIGNMENT = _libsbml.SBML_INITIAL_ASSIGNMENT
SBML_KINETIC_LAW = _libsbml.SBML_KINETIC_LAW
SBML_LIST_OF = _libsbml.SBML_LIST_OF
SBML_MODEL = _libsbml.SBML_MODEL
SBML_PARAMETER = _libsbml.SBML_PARAMETER
SBML_REACTION = _libsbml.SBML_REACTION
SBML_RULE = _libsbml.SBML_RULE
SBML_SPECIES = _libsbml.SBML_SPECIES
SBML_SPECIES_REFERENCE = _libsbml.SBML_SPECIES_REFERENCE
SBML_SPECIES_TYPE = _libsbml.SBML_SPECIES_TYPE
SBML_MODIFIER_SPECIES_REFERENCE = _libsbml.SBML_MODIFIER_SPECIES_REFERENCE
SBML_UNIT_DEFINITION = _libsbml.SBML_UNIT_DEFINITION
SBML_UNIT = _libsbml.SBML_UNIT
SBML_ALGEBRAIC_RULE = _libsbml.SBML_ALGEBRAIC_RULE
SBML_ASSIGNMENT_RULE = _libsbml.SBML_ASSIGNMENT_RULE
SBML_RATE_RULE = _libsbml.SBML_RATE_RULE
SBML_SPECIES_CONCENTRATION_RULE = _libsbml.SBML_SPECIES_CONCENTRATION_RULE
SBML_COMPARTMENT_VOLUME_RULE = _libsbml.SBML_COMPARTMENT_VOLUME_RULE
SBML_PARAMETER_RULE = _libsbml.SBML_PARAMETER_RULE
SBML_TRIGGER = _libsbml.SBML_TRIGGER
SBML_DELAY = _libsbml.SBML_DELAY
SBML_STOICHIOMETRY_MATH = _libsbml.SBML_STOICHIOMETRY_MATH
SBML_FORMULA_UNITS_DATA = _libsbml.SBML_FORMULA_UNITS_DATA
SBML_LIST_FORMULA_UNITS_DATA = _libsbml.SBML_LIST_FORMULA_UNITS_DATA
SBML_LISTOF_COMPARTMENTS = _libsbml.SBML_LISTOF_COMPARTMENTS
SBML_LISTOF_COMPARTMENT_TYPES = _libsbml.SBML_LISTOF_COMPARTMENT_TYPES
SBML_LISTOF_CONSTRAINTS = _libsbml.SBML_LISTOF_CONSTRAINTS
SBML_LISTOF_EVENTS = _libsbml.SBML_LISTOF_EVENTS
SBML_LISTOF_EVENT_ASSIGNMENTS = _libsbml.SBML_LISTOF_EVENT_ASSIGNMENTS
SBML_LISTOF_FUNCTION_DEFINITIONS = _libsbml.SBML_LISTOF_FUNCTION_DEFINITIONS
SBML_LISTOF_INITIAL_ASSIGNMENTS = _libsbml.SBML_LISTOF_INITIAL_ASSIGNMENTS
SBML_LISTOF_PARAMETERS = _libsbml.SBML_LISTOF_PARAMETERS
SBML_LISTOF_REACTIONS = _libsbml.SBML_LISTOF_REACTIONS
SBML_LISTOF_RULES = _libsbml.SBML_LISTOF_RULES
SBML_LISTOF_SPECIES = _libsbml.SBML_LISTOF_SPECIES
SBML_LISTOF_SPECIES_REFERENCES = _libsbml.SBML_LISTOF_SPECIES_REFERENCES
SBML_LISTOF_SPECIES_TYPES = _libsbml.SBML_LISTOF_SPECIES_TYPES
SBML_LISTOF_UNIT_DEFINITIONS = _libsbml.SBML_LISTOF_UNIT_DEFINITIONS
SBML_LISTOF_UNITS = _libsbml.SBML_LISTOF_UNITS

def SBMLTypeCode_toString(*args):
  """
    SBMLTypeCode_toString(SBMLTypeCode_t tc) -> char

    This method takes an SBML type code and returns a string representing
    the code.

    @if clike LibSBML attaches an identifying code to every
    kind of SBML object.  These are known as <em>SBML type codes</em>.
    The set of possible type codes is defined in the enumeration
    #SBMLTypeCode_t.  The names of the type codes all begin with the
    characters @c SBML_. @endif@if java LibSBML attaches an
    identifying code to every kind of SBML object.  These are known as
    <em>SBML type codes</em>.  In other languages, the set of type codes
    is stored in an enumeration; in the Java language interface for
    libSBML, the type codes are defined as static integer constants in
    interface class {@link libsbmlConstants}.  The names of the type codes
    all begin with the characters @c SBML_. @endif
    This method takes a type code as argument, and returns a string name
    corresponding to that code.  For example, passing it the type code
    <code>SBML_COMPARTMENT</code> will return the string
    '<code>Compartment</code>'. 

    @return a human readable name for the given SBMLTypeCode_t.

    @note The caller does not own the returned string and is therefore not
    allowed to modify it.


    """
  return _libsbml.SBMLTypeCode_toString(*args)
class SBase(_object):
    """
    LibSBML implementation of %SBase, the base class of all SBML objects.

    Most components in SBML are derived from a single abstract base type,
    SBase.  In addition to serving as the parent class for most other
    classes of objects in SBML, this base type is designed to allow a
    modeler or a software package to attach arbitrary information to each
    major element or list in an SBML model.

    SBase has an optional subelement called 'notes'.  It is intended to
    serve as a place for storing optional information intended to be seen by
    humans.  An example use of the 'notes' element would be to contain
    formatted user comments about the model element in which the 'notes'
    element is enclosed.  There are certain conditions on the XHTML content
    permitted inside the 'notes' element; these are described separately
    below.

    SBase has another optional subelement called 'annotation'.  Whereas the
    'notes' element described above is a container for content to be shown
    directly to humans, the 'annotation' element is a container for optional
    software-generated content @em not meant to be shown to humans.  The
    element's content type is XML type @c any, allowing essentially
    arbitrary data content.  SBML places only a few restrictions on the
    organization of the content; these are intended to help software tools
    read and write the data as well as help reduce conflicts between
    annotations added by different tools.  They are described separately
    below.

    It is worth pointing out that the 'annotation' element in the definition
    of SBase exists in order that software developers may attach optional
    application-specific data to the elements in an SBML model.  However, it
    is important that this facility not be misused.  In particular, it is
    <em>critical</em> that data essential to a model definition or that can
    be encoded in existing SBML elements is <em>not</em> stored in
    'annotation'. Parameter values, functional dependencies between model
    elements, etc., should not be recorded as annotations.  It is crucial to
    keep in mind the fact that data placed in annotations can be freely
    ignored by software applications.  If such data affects the
    interpretation of a model, then software interoperability is greatly
    impeded.

    Beginning with SBML Level 2, SBase also has an optional attribute named
    'metaid' for supporting metadata annotations using RDF (Resource
    Description Format). The attribute value has the data type 
    <a href='http://www.w3.org/TR/REC-xml/#id'>XML ID</a>, the
    XML identifier type, which means each 'metaid' value must be globally
    unique within an SBML file.  (Importantly, this uniqueness criterion
    applies across any attribute with type 
    <a href='http://www.w3.org/TR/REC-xml/#id'>XML ID</a>, not just the 'metaid'
    attribute used by SBML&mdash;something to be aware of if your
    application-specific XML content inside the 'annotation' subelement
    happens to use <a href='http://www.w3.org/TR/REC-xml/#id'>XML ID</a>.)
    The 'metaid' value serves to identify a model
    component for purposes such as referencing that component from metadata
    placed within 'annotation' subelements.

    Beginning with SBML Level 2 Version 3, SBase also has an optional
    attribute named 'sboTerm' for supporting the use of the Systems Biology
    Ontology.  In SBML proper, the data type of the attribute is a string of
    the form SBO:NNNNNNN, where NNNNNNN is a seven digit integer number;
    libSBML simplifies the representation by only storing the NNNNNNN
    integer portion.  Thus, in libSBML, the 'sboTerm' attribute on SBase has
    data type @c int, and SBO identifiers are stored simply as integers.
    SBO terms are a type of optional annotation, and each different class of
    SBML object derived from SBase imposes its own requirements about the
    values permitted for 'sboTerm'.  Please consult the SBML Level 2 Version
    4 specification for more information about the use of SBO and the
    'sboTerm' attribute.

    Finally, note that, in the list of methods on SBase, there is no public
    constructor because SBase is an abstract class.  The constructors reside
    in the subclasses derived from SBase.


    @section sbase-notes Requirements for the content of the 'notes' subelement

    The content of 'notes' elements must be in XHTML 1.0 format.  (Plain
    HTML would not be usable because whatever appears inside the 'notes'
    element must be compatible with XML, which HTML is not, and in any case,
    the requirement for using XHTML does not prevent users from entering
    plain-text content ,which they can do using the standard <code>&lt;pre&gt;
    ... &lt;/pre&gt;</code> elements of [X]HTML.)

    The XML content of a 'notes' subelement must declare the use of the
    XHTML XML namespace.  This can be done in multiple ways.  One way is to
    place a namespace declaration for the appropriate namespace URI (which
    for XHTML is <tt>'http://www.w3.org/1999/xhtml'</tt>) on the top-level
    <code>sbml</code> element and then reference the namespace in the
    'notes' element content using a prefix.  The following example
    illustrates this approach:
      @verbatim
     <sbml xmlns='http://www.sbml.org/sbml/level2/version4' level='2' version='4'
           xmlns:xhtml='http://www.w3.org/1999/xhtml'>
       ...
       <notes>
         <xhtml:body>
           <xhtml:center><xhtml:h2>A Simple Mitotic Oscillator</xhtml:h2></xhtml:center>
           <xhtml:p>A minimal cascade model for the mitotic oscillator
           involving cyclin and cdc2 kinase</xhtml:p>
         </xhtml:body>
       </notes>
       ...
     @endverbatim

    Another approach is to declare the XHTML namespace within the 'notes'
    element content itself, as in the following example:
      @verbatim
     ...
     <notes>
       <body xmlns='http://www.w3.org/1999/xhtml'>

         <center><h2>A Simple Mitotic Oscillator</h2></center>

         <p>A minimal cascade model for the mitotic oscillator
         involving cyclin and cdc2 kinase</p>

       </body>
     </notes>
     ...
     @endverbatim

    The <code>xmlns='http://www.w3.org/1999/xhtml'</code> declaration on @c
    body as shown above changes the default XML namespace within it, such
    that all of its content is by default in the XHTML namespace.  This is a
    particularly convenient approach because it obviates the need to prefix
    every element with a namespace prefix (i.e., <code>xhtml:</code>
    in the previous case).  Other approaches are also possible.

    SBML does not require the content of the 'notes' subelement to be any
    particular XHTML element; the content can be almost any well-formed
    XHTML content.  SBML Level 2 Versions 2, 3 and 4 added some small
    restrictions and clarifications for the allowable content in order to
    promote greater interoperability between software tools.  The first
    restriction comes from the requirements of XML: the 'notes'
    element must not contain an XML declaration nor a DOCTYPE declaration.
    That is, 'notes' must @em not contain
      @verbatim
     <?xml version='1.0' encoding='UTF-8'?>  
     @endverbatim
    nor (where the following is only one specific example of a DOCTYPE
    declaration)
      @verbatim
     <!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.0 Strict//EN'
           'http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd'>
     @endverbatim

    The second restriction is intended to balance freedom of content with
    the complexity of implementing software that can interpret the content.
    The content of the 'notes' subelement in SBML can consist only of the
    following possibilities:
    <ul>
    <li> A complete XHTML document (minus the XML and DOCTYPE declarations,
    of course), that is, XHTML content beginning with the @c html tag.
      @verbatim
     <notes>
       <html xmlns='http://www.w3.org/1999/xhtml'>
          ...
       </html>
     </notes>
     @endverbatim

    <li> The @c body element from an XHTML document.  The following is an
    example skeleton:
      @verbatim
     <notes>
         <body xmlns='http://www.w3.org/1999/xhtml'>
           ...
         </body>
     </notes>
     @endverbatim

    <li> Any XHTML content that would be permitted within a @c body element.
    If this consists of multiple elements, each one must declare the XML
    namespace separately.  The following is an example fragment:
      @verbatim
     <notes>
         <p xmlns='http://www.w3.org/1999/xhtml'>
           ...
         </p>
         <p xmlns='http://www.w3.org/1999/xhtml'>
           ...
         </p>
     </notes>
     @endverbatim
    </ul>

    Another way to summarize the restrictions above is simply to say that
    the content of an SBML 'notes' element can be only be a complete @c html
    element, a @c body element, or whatever is permitted inside a @c body
    element.  In practice, this does not limit in any meaningful way what
    can be placed inside a 'notes' element; for example, if an application
    or modeler wants to put a complete XHTML page, including a @c head
    element, it can be done by putting in everything starting with the @c
    html container.  However, the restrictions above do make it somewhat
    simpler to write software that can read and write the 'notes' content.


    @section sbase-annotation Requirements for the content of the 'annotation' subelement

    At the outset, software developers should keep in mind that multiple
    software tools may attempt to read and write annotation content.  To
    reduce the potential for collisions between annotations written by
    different applications, SBML Level 2 stipulates that tools must use XML
    namespaces to specify the intended vocabulary of every annotation.  The
    application's developers must choose a URI (Universal Resource
    Identifier) reference that uniquely identifies the vocabulary the
    application will use, and a prefix string for the annotations.

    A important requirement is that application-specific annotation data is
    entirely contained inside a single <em>top-level element</em> within the
    SBML 'annotation' subelement.  SBML Level 2 Versions 2, 3 and 4 place the
    following restrictions on annotations:
    <ul>
    <li> Within a given SBML 'annotation' element, there can only be one
    top-level element using a given namespace.  An annotation element can
    contain multiple top-level elements but each must be in a different
    namespace.

    <li> No top-level element in an 'annotation' may use an SBML XML
    namespace, either explicitly by referencing one of the SBML XML
    namespace URIs or implicitly by failing to specify any namespace on the
    annotation.

    <li> The ordering of top-level elements within a given 'annotation'
    element is <em>not</em> significant.  An application should not expect
    that its annotation content appears first in the 'annotation' element,
    nor in any other particular location.  Moreover, the ordering of
    top-level annotation elements may be changed by different applications
    as they read and write the same SBML file.
    </ul>

    The use of XML namespaces in this manner is intended to improve the
    ability of multiple applications to place annotations on SBML model
    elements with reduced risks of interference or name collisions.
    Annotations stored by different simulation packages can therefore
    coexist in the same model definition.  The rules governing the content
    of 'annotation' elements are designed to enable applications to easily
    add, change, and remove their annotations from SBML elements while
    simultaneously preserving annotations inserted by other applications
    when mapping SBML from input to output.

    As a further simplification for developers of software and to improve
    software interoperability, applications are only required to preserve
    other annotations (i.e., annotations they do not recognize) when those
    annotations are self-contained entirely within 'annotation', complete
    with namespace declarations.  The following is an example:
      @verbatim
     <annotation>
         <topLevelElement xmlns:'URI'>
            ... content in the namespace identified by 'URI' ...
         </topLevelElement>
     </annotation>
     @endverbatim

    Some more examples hopefully will make these points more clear.  The
    next example is invalid because it contains a top-level element in the
    SBML XML namespace&mdash;this happens because no namespace is declared
    for the <code>&lt;cytoplasm&gt;</code> element, which means by default it
    falls into the enclosing SBML namespace:
      @verbatim
     <annotation>
         <cytoplasm/>
     </annotation>
     @endverbatim

    The following example is also invalid, this time because it contains two
    top-level elements using the same XML namespace.  Note that it does not
    matter that these are two different top-level elements
    (<code>&lt;nodecolors&gt;</code> and <code>&lt;textcolors&gt;</code>); 
    what matters is that these separate elements are both in the same 
    namespace rather than having been collected and placed inside one 
    overall container element for that namespace.
      @verbatim
     <annotation>
         <mysim:nodecolors xmlns:mysim='http://www.mysim.org/ns'
             mysim:bgcolor='green' mysim:fgcolor='white'/>
         <mysim:textcolors xmlns:mysim='http://www.mysim.org/ns'
             mysim:bgcolor='green' mysim:fgcolor='white'/>
     </annotation>
     @endverbatim

    On the other hand, the following example is valid:
      @verbatim
     <annotation>
         <mysim:geometry xmlns:mysim='http://www.mysim.org/ns'
                  mysim:bgcolor='green' mysim:fgcolor='white'>
             <graph:node xmlns:graph='http://www.graph.org/ns' 
                  graph:x='4' graph:y='5' />
         </mysim:geometry>
         <othersim:icon xmlns:othersim='http://www.othersim.com/'>
             WS2002
         </othersim:icon>
     </annotation>
     @endverbatim

    It is worth keeping in mind that although XML namespace names must be
    URIs, they are (like all XML namespace names) <em>not required</em> to
    be directly usable in the sense of identifying an actual, retrieval
    document or resource on the Internet.  URIs such as
    <code>'http://www.mysim.org/'</code> may appear as though they are
    (e.g.) Internet addresses, but there are not the same thing.  This
    style of URI strings, using a domain name and other parts, is only a
    simple and commonly-used way of creating a unique name string.


    @section sbase-miriam Standard format for annotations linking data resources

    SBML Level 2 Versions 2, 3 and 4 define a proposed regular format for
    encoding two particular categories of annotations: (a) references to
    controlled vocabulary terms and database identifiers which define and
    describe biological and biochemical entities in a model; and (b)
    descriptions of the provenance of a model, including its author(s) and
    modification history.

    """
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SBase, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SBase, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_SBase
    __del__ = lambda self : None;
    def clone(self):
        """
        clone(self) -> SBase

        Creates and returns a deep copy of this SBase object.

        @return a (deep) copy of this SBase object
          

        """
        return _libsbml.SBase_clone(self)

    def getMetaId(self):
        """
        getMetaId(self) -> string

        Returns the value of the 'metaid' attribute of this object.

        The optional attribute named 'metaid', present on every major SBML
        component type, is for supporting metadata annotations using RDF
        (Resource Description Format). The attribute value has the data type
        <a href='http://www.w3.org/TR/REC-xml/#id'>XML ID</a>, the XML
        identifier type, which means each 'metaid' value must be globally
        unique within an SBML file.  (Importantly, this uniqueness criterion
        applies across any attribute with type <a
        href='http://www.w3.org/TR/REC-xml/#id'>XML ID</a>, not just the
        'metaid' attribute used by SBML&mdash;something to be aware of if your
        application-specific XML content inside the 'annotation' subelement
        happens to use <a href='http://www.w3.org/TR/REC-xml/#id'>XML ID</a>.)
        The 'metaid' value serves to identify a model
        component for purposes such as referencing that component from
        metadata placed within 'annotation' subelements.
         
        @return the metaid of this SBML object.

        @see isSetMetaId()
        @see setMetaId(const std::string& metaid)
          

        """
        return _libsbml.SBase_getMetaId(self)

    def getId(self):
        """
        getId(self) -> string

        Returns the value of the 'metaid' attribute of this object.

        The optional attribute named 'metaid', present on every major SBML
        component type, is for supporting metadata annotations using RDF
        (Resource Description Format). The attribute value has the data type
        <a href='http://www.w3.org/TR/REC-xml/#id'>XML ID</a>, the XML
        identifier type, which means each 'metaid' value must be globally
        unique within an SBML file.  (Importantly, this uniqueness criterion
        applies across any attribute with type <a
        href='http://www.w3.org/TR/REC-xml/#id'>XML ID</a>, not just the
        'metaid' attribute used by SBML&mdash;something to be aware of if your
        application-specific XML content inside the 'annotation' subelement
        happens to use <a href='http://www.w3.org/TR/REC-xml/#id'>XML ID</a>.)
        The 'metaid' value serves to identify a model
        component for purposes such as referencing that component from
        metadata placed within 'annotation' subelements.
         
        @return the metaid of this SBML object.

        @see isSetMetaId()
        @see setMetaId(const std::string& metaid)
        @deprecated libSBML internal


        """
        return _libsbml.SBase_getId(self)

    def getName(self):
        """
        getName(self) -> string

        Returns the value of the 'metaid' attribute of this object.

        The optional attribute named 'metaid', present on every major SBML
        component type, is for supporting metadata annotations using RDF
        (Resource Description Format). The attribute value has the data type
        <a href='http://www.w3.org/TR/REC-xml/#id'>XML ID</a>, the XML
        identifier type, which means each 'metaid' value must be globally
        unique within an SBML file.  (Importantly, this uniqueness criterion
        applies across any attribute with type <a
        href='http://www.w3.org/TR/REC-xml/#id'>XML ID</a>, not just the
        'metaid' attribute used by SBML&mdash;something to be aware of if your
        application-specific XML content inside the 'annotation' subelement
        happens to use <a href='http://www.w3.org/TR/REC-xml/#id'>XML ID</a>.)
        The 'metaid' value serves to identify a model
        component for purposes such as referencing that component from
        metadata placed within 'annotation' subelements.
         
        @return the metaid of this SBML object.

        @see isSetMetaId()
        @see setMetaId(const std::string& metaid)
        @deprecated libSBML internal


        """
        return _libsbml.SBase_getName(self)

    def getNotes(self):
        """
        getNotes(self) -> XMLNode

        Returns the content of the 'notes' subelement of this object as
        a tree of XML nodes.

        The optional element named 'notes', present on every major SBML
        component type, is intended as a place for storing optional
        information intended to be seen by humans.  An example use of the
        'notes' element would be to contain formatted user comments
        about the model element in which the 'notes' element is
        enclosed.  Every object derived directly or indirectly from type
        SBase can have a separate value for 'notes', allowing users
        considerable freedom when adding comments to their models.
        The format of 'notes' elements must be XHTML 1.0.  The SBML
        Level&nbsp;2 specification has considerable detail about how
        'notes' element content must be handled; please refer to the
        specifications.

        The 'notes' element content returned by this method will be in XML
        form, but libSBML does not provide an object model specifically for
        the content of notes.  Callers will need to traverse the XML tree
        structure using the facilities available on XMLNode and related
        objects.

        @return the content of the 'notes' subelement of this SBML object.

        @see getNotesString()
        @see isSetNotes()
        @see setNotes(const XMLNode* notes)
        @see setNotes(const std::string& notes)
        @see appendNotes(const XMLNode* notes)
        @see appendNotes(const std::string& notes)
        @see unsetNotes()
          

        """
        return _libsbml.SBase_getNotes(self)

    def getNotesString(self):
        """
        getNotesString(self) -> string

        Returns the content of the 'notes' subelement of this object as a
        string.

        The optional element named 'notes', present on every major SBML
        component type, is intended as a place for storing optional
        information intended to be seen by humans.  An example use of the
        'notes' element would be to contain formatted user comments
        about the model element in which the 'notes' element is
        enclosed.  Every object derived directly or indirectly from type
        SBase can have a separate value for 'notes', allowing users
        considerable freedom when adding comments to their models.
        The format of 'notes' elements must be XHTML 1.0.  The SBML
        Level&nbsp;2 specification has considerable detail about how
        'notes' element content must be handled; please refer to the
        specifications.

        @return the content of the 'notes' subelement of this SBML object.

        @see getNotes()
        @see isSetNotes()
        @see setNotes(const XMLNode* notes)
        @see setNotes(const std::string& notes)
        @see appendNotes(const XMLNode* notes)
        @see appendNotes(const std::string& notes)
        @see unsetNotes()
          

        """
        return _libsbml.SBase_getNotesString(self)

    def getAnnotation(self):
        """
        getAnnotation(self) -> XMLNode

        Returns the content of the 'annotation' subelement of this object as
        an XML node tree.

        Whereas the SBase 'notes' subelement is a container for content to be
        shown directly to humans, the 'annotation' element is a container for
        optional software-generated content @em not meant to be shown to
        humans.  Every object derived from SBase can have its own value for
        'annotation'.  The element's content type is XML type
        <code>any</code>, allowing essentially arbitrary well-formed XML data
        content.

        SBML places a few restrictions on the organization of the content of
        annotations; these are intended to help software tools read and write
        the data as well as help reduce conflicts between annotations added by
        different tools.  Please see the SBML specifications for more details.

        The annotations returned by this method will be in XML form.  LibSBML
        provides an object model and related interfaces for certain specific
        kinds of annotations, namely model history information and RDF
        content.  See the ModelHistory, CVTerm and RDFAnnotationParser classes
        for more information about the facilities available.

        @return the annotation of this SBML object as an XMLNode

        @see getAnnotationString()
        @see isSetAnnotation()
        @see setAnnotation(const XMLNode* annotation)
        @see setAnnotation(const std::string& annotation)
        @see appendAnnotation(const XMLNode* annotation)
        @see appendAnnotation(const std::string& annotation)
        @see unsetAnnotation()
          

        """
        return _libsbml.SBase_getAnnotation(self)

    def getAnnotationString(self):
        """
        getAnnotationString(self) -> string

        Returns the content of the 'annotation' subelement of this object as a
        character string.

        Whereas the SBase 'notes' subelement is a container for content to be
        shown directly to humans, the 'annotation' element is a container for
        optional software-generated content @em not meant to be shown to
        humans.  Every object derived from SBase can have its own value for
        'annotation'.  The element's content type is XML type
        <code>any</code>, allowing essentially arbitrary well-formed XML data
        content.

        SBML places a few restrictions on the organization of the content of
        annotations; these are intended to help software tools read and write
        the data as well as help reduce conflicts between annotations added by
        different tools.  Please see the SBML specifications for more details.

        The annotations returned by this method will be in string form.

        @return the annotation string of this SBML object.

        @see getAnnotation()
        @see isSetAnnotation()
        @see setAnnotation(const XMLNode* annotation)
        @see setAnnotation(const std::string& annotation)
        @see appendAnnotation(const XMLNode* annotation)
        @see appendAnnotation(const std::string& annotation)
        @see unsetAnnotation()
          

        """
        return _libsbml.SBase_getAnnotationString(self)

    def getNamespaces(self):
        """
        getNamespaces(self) -> XMLNamespaces

        Returns a list of the XML Namespaces declared on this SBML document.

        @return the XML Namespaces associated with this SBML object
          

        """
        return _libsbml.SBase_getNamespaces(self)

    def getSBMLDocument(self, *args):
        """
        getSBMLDocument(self) -> SBMLDocument
        getSBMLDocument(self) -> SBMLDocument

        Returns the parent SBMLDocument object.

        LibSBML uses the class SBMLDocument as a top-level container for
        storing SBML content and data associated with it (such as warnings and
        error messages).  An SBML model in libSBML is contained inside an
        SBMLDocument object.  SBMLDocument corresponds roughly to the class
        <i>Sbml</i> defined in the SBML Level&nbsp;2 specification, but it
        does not have a direct correspondence in SBML Level&nbsp;1.  (But, it
        is created by libSBML no matter whether the model is Level&nbsp;1 or
        Level&nbsp;2.)

        This method allows the SBMLDocument for the current object to be
        retrieved.

        @return the parent SBMLDocument object of this SBML object.
          

        """
        return _libsbml.SBase_getSBMLDocument(self, *args)

    def getParentSBMLObject(self):
        """
        getParentSBMLObject(self) -> SBase

        Returns the parent SBML object.

        This method is convenient when holding an object nested inside
        other objects in an SBML model.  It allows direct access to the
        <code>&lt;model&gt;</code> element containing it.

        @return the parent SBML object of this SBML object.
          

        """
        return _libsbml.SBase_getParentSBMLObject(self)

    def getAncestorOfType(self, *args):
        """
        getAncestorOfType(self, SBMLTypeCode_t type) -> SBase

        Returns the ancestor SBML object that corresponds to the 
        given SBMLTypeCode_t.

        This function allows any object to determine its exact
        location/function within a model. For example a StoichiometryMath
        object has ancestors of type SpeciesReference,
        ListOfProducts/ListOfReactants/ListOfModifiers, Reaction,
        ListOfReactions and Model; any of which can be accessed via this
        function.

        @param type the SBMLTypeCode_t of the ancestor to be returned.

        @return the ancestor SBML object of this SBML object, that 
        corresponds to the given SBMLTypeCode_t, NULL if none exists.
          

        """
        return _libsbml.SBase_getAncestorOfType(self, *args)

    def getSBOTerm(self):
        """
        getSBOTerm(self) -> int

        Returns the integer portion of the value of the 'sboTerm' attribute of
        this object.

        In SBML Level 2 Versions 2, 3 and 4, the data type of the attribute is a
        string of the form SBO:NNNNNNN, where NNNNNNN is a seven digit integer
        number; libSBML simplifies the representation by only storing the
        NNNNNNN integer portion.  Thus, in libSBML, the 'sboTerm' attribute on
        SBase has data type @c int, and SBO identifiers are stored simply as
        integers.  SBO terms are a type of optional annotation, and each
        different class of SBML object derived from SBase imposes its own
        requirements about the values permitted for 'sboTerm'.  Please consult
        the SBML Level 2 Version 4 specification for more information about
        the use of SBO and the 'sboTerm' attribute.

        @return the value of the 'sboTerm' attribute as an integer, or @c -1
        if the value is not set.
          

        """
        return _libsbml.SBase_getSBOTerm(self)

    def getSBOTermID(self):
        """
        getSBOTermID(self) -> string

        Returns the string representation of the 'sboTerm' attribute of
        this object.

        In SBML Level 2 Versions 2, 3 and 4, the data type of the attribute is a
        string of the form SBO:NNNNNNN, where NNNNNNN is a seven digit integer
        number; libSBML simplifies the representation by only storing the
        NNNNNNN integer portion.  Thus, in libSBML, the 'sboTerm' attribute on
        SBase has data type @c int, and SBO identifiers are stored simply as
        integers.  This function recreates the string representation from the
        stored value.  SBO terms are a type of optional annotation, and each
        different class of SBML object derived from SBase imposes its own
        requirements about the values permitted for 'sboTerm'.  Please consult
        the SBML Level 2 Version 4 specification for more information about
        the use of SBO and the 'sboTerm' attribute.

        @return the value of the 'sboTerm' attribute as a string of the form
        SBO:NNNNNNN, or  an empty string
        if the value is not set.
          

        """
        return _libsbml.SBase_getSBOTermID(self)

    def getLine(self):
        """
        getLine(self) -> unsigned int

        Returns the line number on which this object first appears in the XML
        representation of the SBML document.

        @return the line number of this SBML object.

        @see getColumn()
          

        """
        return _libsbml.SBase_getLine(self)

    def getColumn(self):
        """
        getColumn(self) -> unsigned int

        Returns the column number on which this object first appears in the XML
        representation of the SBML document.

        @return the column number of this SBML object.

        @see getLine()
          

        """
        return _libsbml.SBase_getColumn(self)

    def isSetMetaId(self):
        """
        isSetMetaId(self) -> bool

        Predicate returning @c true or @c false depending on whether this
        object's 'metaid' attribute has been set.

        The optional attribute named 'metaid', present on every major SBML
        component type, is for supporting metadata annotations using RDF
        (Resource Description Format). The attribute value has the data type
        <a href='http://www.w3.org/TR/REC-xml/#id'>XML ID</a>, the XML
        identifier type, which means each 'metaid' value must be globally
        unique within an SBML file.  (Importantly, this uniqueness criterion
        applies across any attribute with type <a
        href='http://www.w3.org/TR/REC-xml/#id'>XML ID</a>, not just the
        'metaid' attribute used by SBML&mdash;something to be aware of if your
        application-specific XML content inside the 'annotation' subelement
        happens to use <a href='http://www.w3.org/TR/REC-xml/#id'>XML ID</a>.)
        The 'metaid' value serves to identify a model
        component for purposes such as referencing that component from
        metadata placed within 'annotation' subelements.
         
        @htmlinclude libsbml-comment-set-methods.html

        @return @c true if the 'metaid' attribute of this SBML object has been
        set, @c false otherwise.

        @see getMetaId()
        @see setMetaId(const std::string& metaid)
          

        """
        return _libsbml.SBase_isSetMetaId(self)

    def isSetId(self):
        """
        isSetId(self) -> bool

        Predicate returning @c true or @c false depending on whether this
        object's 'metaid' attribute has been set.

        The optional attribute named 'metaid', present on every major SBML
        component type, is for supporting metadata annotations using RDF
        (Resource Description Format). The attribute value has the data type
        <a href='http://www.w3.org/TR/REC-xml/#id'>XML ID</a>, the XML
        identifier type, which means each 'metaid' value must be globally
        unique within an SBML file.  (Importantly, this uniqueness criterion
        applies across any attribute with type <a
        href='http://www.w3.org/TR/REC-xml/#id'>XML ID</a>, not just the
        'metaid' attribute used by SBML&mdash;something to be aware of if your
        application-specific XML content inside the 'annotation' subelement
        happens to use <a href='http://www.w3.org/TR/REC-xml/#id'>XML ID</a>.)
        The 'metaid' value serves to identify a model
        component for purposes such as referencing that component from
        metadata placed within 'annotation' subelements.
         
        @htmlinclude libsbml-comment-set-methods.html

        @return @c true if the 'metaid' attribute of this SBML object has been
        set, @c false otherwise.

        @see getMetaId()
        @see setMetaId(const std::string& metaid)
        @deprecated libSBML internal


        """
        return _libsbml.SBase_isSetId(self)

    def isSetName(self):
        """
        isSetName(self) -> bool

        Predicate returning @c true or @c false depending on whether this
        object's 'metaid' attribute has been set.

        The optional attribute named 'metaid', present on every major SBML
        component type, is for supporting metadata annotations using RDF
        (Resource Description Format). The attribute value has the data type
        <a href='http://www.w3.org/TR/REC-xml/#id'>XML ID</a>, the XML
        identifier type, which means each 'metaid' value must be globally
        unique within an SBML file.  (Importantly, this uniqueness criterion
        applies across any attribute with type <a
        href='http://www.w3.org/TR/REC-xml/#id'>XML ID</a>, not just the
        'metaid' attribute used by SBML&mdash;something to be aware of if your
        application-specific XML content inside the 'annotation' subelement
        happens to use <a href='http://www.w3.org/TR/REC-xml/#id'>XML ID</a>.)
        The 'metaid' value serves to identify a model
        component for purposes such as referencing that component from
        metadata placed within 'annotation' subelements.
         
        @htmlinclude libsbml-comment-set-methods.html

        @return @c true if the 'metaid' attribute of this SBML object has been
        set, @c false otherwise.

        @see getMetaId()
        @see setMetaId(const std::string& metaid)
        @deprecated libSBML internal


        """
        return _libsbml.SBase_isSetName(self)

    def isSetNotes(self):
        """
        isSetNotes(self) -> bool

        Predicate returning @c true or @c false depending on whether this
        object's 'notes' subelement exists and has content.

        The optional element named 'notes', present on every major SBML
        component type, is intended as a place for storing optional
        information intended to be seen by humans.  An example use of the
        'notes' element would be to contain formatted user comments
        about the model element in which the 'notes' element is
        enclosed.  Every object derived directly or indirectly from type
        SBase can have a separate value for 'notes', allowing users
        considerable freedom when adding comments to their models.
        The format of 'notes' elements must be XHTML 1.0.  The SBML
        Level&nbsp;2 specification has considerable detail about how
        'notes' element content must be handled; please refer to the
        specifications.

        @htmlinclude libsbml-comment-set-methods.html

        @return @c true if a 'notes' subelement exists, @c false otherwise.

        @see getNotes()
        @see getNotesString()
        @see setNotes(const XMLNode* notes)
        @see setNotes(const std::string& notes)
        @see appendNotes(const XMLNode* notes)
        @see appendNotes(const std::string& notes)
        @see unsetNotes()
          

        """
        return _libsbml.SBase_isSetNotes(self)

    def isSetAnnotation(self):
        """
        isSetAnnotation(self) -> bool

        Predicate returning @c true or @c false depending on whether this
        object's 'annotation' subelement exists and has content.

        Whereas the SBase 'notes' subelement is a container for content to be
        shown directly to humans, the 'annotation' element is a container for
        optional software-generated content @em not meant to be shown to
        humans.  Every object derived from SBase can have its own value for
        'annotation'.  The element's content type is XML type
        <code>any</code>, allowing essentially arbitrary well-formed XML data
        content.

        SBML places a few restrictions on the organization of the content of
        annotations; these are intended to help software tools read and write
        the data as well as help reduce conflicts between annotations added by
        different tools.  Please see the SBML specifications for more details.

        @htmlinclude libsbml-comment-set-methods.html

        @return @c true if a 'annotation' subelement exists, @c false
        otherwise.

        @see getAnnotation()
        @see getAnnotationString()
        @see setAnnotation(const XMLNode* annotation)
        @see setAnnotation(const std::string& annotation)
        @see appendAnnotation(const XMLNode* annotation)
        @see appendAnnotation(const std::string& annotation)
        @see unsetAnnotation()
          

        """
        return _libsbml.SBase_isSetAnnotation(self)

    def isSetSBOTerm(self):
        """
        isSetSBOTerm(self) -> bool

        Predicate returning @c true or @c false depending on whether this
        object's 'sboTerm' attribute has been set.

        @htmlinclude libsbml-comment-set-methods.html

        @return @c true if the 'sboTerm' attribute of this SBML object has been
        set, @c false otherwise.
          

        """
        return _libsbml.SBase_isSetSBOTerm(self)

    def setMetaId(self, *args):
        """
        setMetaId(self, string metaid) -> int

        Sets the value of the 'metaid' attribute of this object.

        The string @p metaid is copied.  The value of @p metaid must be an
        identifier conforming to the syntax defined by the XML 1.0 data type
        <a href='http://www.w3.org/TR/REC-xml/#id'>ID</a>.  Among other
        things, this type requires that a value is unique among all the values
        of type XML ID in an SBMLDocument.  Although SBML only uses <a
        href='http://www.w3.org/TR/REC-xml/#id'>XML ID</a> for the 'metaid'
        attribute, callers should be careful if they use
        <a href='http://www.w3.org/TR/REC-xml/#id'>XML ID</a>'s in XML
        portions of a model that are not defined by SBML, such as in the
        application-specific content of the 'annotation' subelement.

        @htmlinclude libsbml-comment-set-methods.html

        @param metaid the identifier string to use as the value of the
        'metaid' attribute

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_INVALID_ATTRIBUTE_VALUE
        @li LIBSBML_UNEXPECTED_ATTRIBUTE

        @see getMetaId()
        @see isSetMetaId()
          

        """
        return _libsbml.SBase_setMetaId(self, *args)

    def setId(self, *args):
        """
        setId(self, string sid) -> int

        Sets the value of the 'metaid' attribute of this object.

        The string @p metaid is copied.  The value of @p metaid must be an
        identifier conforming to the syntax defined by the XML 1.0 data type
        <a href='http://www.w3.org/TR/REC-xml/#id'>ID</a>.  Among other
        things, this type requires that a value is unique among all the values
        of type XML ID in an SBMLDocument.  Although SBML only uses <a
        href='http://www.w3.org/TR/REC-xml/#id'>XML ID</a> for the 'metaid'
        attribute, callers should be careful if they use
        <a href='http://www.w3.org/TR/REC-xml/#id'>XML ID</a>'s in XML
        portions of a model that are not defined by SBML, such as in the
        application-specific content of the 'annotation' subelement.

        @htmlinclude libsbml-comment-set-methods.html

        @param metaid the identifier string to use as the value of the
        'metaid' attribute

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_INVALID_ATTRIBUTE_VALUE
        @li LIBSBML_UNEXPECTED_ATTRIBUTE

        @see getMetaId()
        @see isSetMetaId()
        @deprecated libSBML internal


        """
        return _libsbml.SBase_setId(self, *args)

    def setName(self, *args):
        """
        setName(self, string name) -> int

        Sets the value of the 'metaid' attribute of this object.

        The string @p metaid is copied.  The value of @p metaid must be an
        identifier conforming to the syntax defined by the XML 1.0 data type
        <a href='http://www.w3.org/TR/REC-xml/#id'>ID</a>.  Among other
        things, this type requires that a value is unique among all the values
        of type XML ID in an SBMLDocument.  Although SBML only uses <a
        href='http://www.w3.org/TR/REC-xml/#id'>XML ID</a> for the 'metaid'
        attribute, callers should be careful if they use
        <a href='http://www.w3.org/TR/REC-xml/#id'>XML ID</a>'s in XML
        portions of a model that are not defined by SBML, such as in the
        application-specific content of the 'annotation' subelement.

        @htmlinclude libsbml-comment-set-methods.html

        @param metaid the identifier string to use as the value of the
        'metaid' attribute

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_INVALID_ATTRIBUTE_VALUE
        @li LIBSBML_UNEXPECTED_ATTRIBUTE

        @see getMetaId()
        @see isSetMetaId()
        @deprecated libSBML internal


        """
        return _libsbml.SBase_setName(self, *args)

    def setAnnotation(self, *args):
        """
        setAnnotation(self, XMLNode annotation) -> int
        setAnnotation(self, string annotation) -> int

        Sets the value of the 'annotation' subelement of this SBML object to a
        copy of @p annotation given as a character string.

        Whereas the SBase 'notes' subelement is a container for content to be
        shown directly to humans, the 'annotation' element is a container for
        optional software-generated content @em not meant to be shown to
        humans.  Every object derived from SBase can have its own value for
        'annotation'.  The element's content type is XML type
        <code>any</code>, allowing essentially arbitrary well-formed XML data
        content.

        SBML places a few restrictions on the organization of the content of
        annotations; these are intended to help software tools read and write
        the data as well as help reduce conflicts between annotations added by
        different tools.  Please see the SBML specifications for more details.

        Call this method will result in any existing content of the
        'annotation' subelement to be discarded.  Unless you have taken steps
        to first copy and reconstitute any existing annotations into the @p
        annotation that is about to be assigned, it is likely that performing
        such wholesale replacement is unfriendly towards other software
        applications whose annotations are discarded.  An alternative may be
        to use SBase::appendAnnotation(const XMLNode* annotation) or
        SBase::appendAnnotation(const std::string& annotation).

        @htmlinclude libsbml-comment-set-methods.html

        @param annotation an XML string that is to be used as the content
        of the 'annotation' subelement of this object

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_OPERATION_FAILED

        @see getAnnotationString()
        @see isSetAnnotation()
        @see setAnnotation(const XMLNode* annotation)
        @see appendAnnotation(const XMLNode* annotation)
        @see appendAnnotation(const std::string& annotation)
        @see unsetAnnotation()
          

        """
        return _libsbml.SBase_setAnnotation(self, *args)

    def appendAnnotation(self, *args):
        """
        appendAnnotation(self, XMLNode annotation) -> int
        appendAnnotation(self, string annotation) -> int

        Appends the annotation content given by @p annotation to any existing
        content in the 'annotation' subelement of this object.

        Whereas the SBase 'notes' subelement is a container for content to be
        shown directly to humans, the 'annotation' element is a container for
        optional software-generated content @em not meant to be shown to
        humans.  Every object derived from SBase can have its own value for
        'annotation'.  The element's content type is XML type
        <code>any</code>, allowing essentially arbitrary well-formed XML data
        content.

        SBML places a few restrictions on the organization of the content of
        annotations; these are intended to help software tools read and write
        the data as well as help reduce conflicts between annotations added by
        different tools.  Please see the SBML specifications for more details.

        Unlike SBase::setAnnotation(const XMLNode* annotation) or
        SBase::setAnnotation(const std::string& annotation), this method
        allows other annotations to be preserved when an application adds its
        own data.

        @htmlinclude libsbml-comment-set-methods.html

        @param annotation an XML string that is to be copied and appended
        to the content of the 'annotation' subelement of this object

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_OPERATION_FAILED

        @see getAnnotationString()
        @see isSetAnnotation()
        @see setAnnotation(const XMLNode* annotation)
        @see setAnnotation(const std::string& annotation)
        @see appendAnnotation(const XMLNode* annotation)
        @see unsetAnnotation()
          

        """
        return _libsbml.SBase_appendAnnotation(self, *args)

    def setNotes(self, *args):
        """
        setNotes(self, XMLNode notes) -> int
        setNotes(self, string notes) -> int

        Sets the value of the 'notes' subelement of this SBML object to a copy
        of the string @p notes.

        Any existing content of the 'notes' subelement is discarded.

        The optional element named 'notes', present on every major SBML
        component type, is intended as a place for storing optional
        information intended to be seen by humans.  An example use of the
        'notes' element would be to contain formatted user comments
        about the model element in which the 'notes' element is
        enclosed.  Every object derived directly or indirectly from type
        SBase can have a separate value for 'notes', allowing users
        considerable freedom when adding comments to their models.
        The format of 'notes' elements must be XHTML 1.0.  The SBML
        Level&nbsp;2 specification has considerable detail about how
        'notes' element content must be handled; please refer to the
        specifications.

        @htmlinclude libsbml-comment-set-methods.html

        @param notes an XML string that is to be used as the content of the
        'notes' subelement of this object

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_INVALID_OBJECT
        @li LIBSBML_OPERATION_FAILED

        @see getNotesString()
        @see isSetNotes()
        @see setNotes(const XMLNode* notes)
        @see appendNotes(const XMLNode* notes)
        @see appendNotes(const std::string& notes)
        @see unsetNotes()
          

        """
        return _libsbml.SBase_setNotes(self, *args)

    def appendNotes(self, *args):
        """
        appendNotes(self, XMLNode notes) -> int
        appendNotes(self, string notes) -> int

        Appends notes content to the 'notes' element attached to this
        object.

        The content in @p notes is copied.

        The optional element named 'notes', present on every major SBML
        component type, is intended as a place for storing optional
        information intended to be seen by humans.  An example use of the
        'notes' element would be to contain formatted user comments
        about the model element in which the 'notes' element is
        enclosed.  Every object derived directly or indirectly from type
        SBase can have a separate value for 'notes', allowing users
        considerable freedom when adding comments to their models.
        The format of 'notes' elements must be XHTML 1.0.  The SBML
        Level&nbsp;2 specification has considerable detail about how
        'notes' element content must be handled; please refer to the
        specifications.

        @param notes an XML string that is to appended to the content of
        the 'notes' subelement of this object

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_INVALID_OBJECT
        @li LIBSBML_OPERATION_FAILED

        @see getNotesString()
        @see isSetNotes()
        @see setNotes(const XMLNode* notes)
        @see setNotes(const std::string& notes)
        @see appendNotes(const XMLNode* notes)
        @see unsetNotes()
          

        """
        return _libsbml.SBase_appendNotes(self, *args)

    def setSBOTerm(self, *args):
        """
        setSBOTerm(self, int value) -> int
        setSBOTerm(self, string sboid) -> int

        Sets the value of the 'sboTerm' attribute.

        In SBML Level 2 Versions 2, 3 and 4, the data type of the SBML 'sboTerm'
        attribute is a string of the form SBO:NNNNNNN, where NNNNNNN is a
        seven digit integer number; libSBML simplifies the representation by
        only storing the NNNNNNN integer portion.  Thus, in libSBML, the
        'sboTerm' attribute on SBase has data type @c int, and SBO identifiers
        are stored simply as integers.  SBO terms are a type of optional
        annotation, and each different class of SBML object derived from SBase
        imposes its own requirements about the values permitted for 'sboTerm'.
        Please consult the SBML Level 2 Version 4 specification for more
        information about the use of SBO and the 'sboTerm' attribute.

        @htmlinclude libsbml-comment-set-methods.html

        @param value the NNNNNNN integer portion of the SBO identifier

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_INVALID_ATTRIBUTE_VALUE
        @li LIBSBML_UNEXPECTED_ATTRIBUTE
          

        """
        return _libsbml.SBase_setSBOTerm(self, *args)

    def setNamespaces(self, *args):
        """
        setNamespaces(self, XMLNamespaces xmlns) -> int

        Sets the namespaces relevant of this SBML object.

        @param xmlns the namespaces to set

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
          

        """
        return _libsbml.SBase_setNamespaces(self, *args)

    def unsetMetaId(self):
        """
        unsetMetaId(self) -> int

        Unsets the value of the 'metaid' attribute of this SBML object.

        The optional attribute named 'metaid', present on every major SBML
        component type, is for supporting metadata annotations using RDF
        (Resource Description Format). The attribute value has the data type
        <a href='http://www.w3.org/TR/REC-xml/#id'>XML ID</a>, the XML
        identifier type, which means each 'metaid' value must be globally
        unique within an SBML file.  (Importantly, this uniqueness criterion
        applies across any attribute with type <a
        href='http://www.w3.org/TR/REC-xml/#id'>XML ID</a>, not just the
        'metaid' attribute used by SBML&mdash;something to be aware of if your
        application-specific XML content inside the 'annotation' subelement
        happens to use <a href='http://www.w3.org/TR/REC-xml/#id'>XML ID</a>.)
        The 'metaid' value serves to identify a model
        component for purposes such as referencing that component from
        metadata placed within 'annotation' subelements.
         
        @htmlinclude libsbml-comment-set-methods.html

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_OPERATION_FAILED
          

        """
        return _libsbml.SBase_unsetMetaId(self)

    def unsetNotes(self):
        """
        unsetNotes(self) -> int

        Unsets the value of the 'notes' subelement of this SBML object.

        The optional element named 'notes', present on every major SBML
        component type, is intended as a place for storing optional
        information intended to be seen by humans.  An example use of the
        'notes' element would be to contain formatted user comments
        about the model element in which the 'notes' element is
        enclosed.  Every object derived directly or indirectly from type
        SBase can have a separate value for 'notes', allowing users
        considerable freedom when adding comments to their models.
        The format of 'notes' elements must be XHTML 1.0.  The SBML
        Level&nbsp;2 specification has considerable detail about how
        'notes' element content must be handled; please refer to the
        specifications.

        @htmlinclude libsbml-comment-set-methods.html

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS

        @see getNotesString()
        @see isSetNotes()
        @see setNotes(const XMLNode* notes)
        @see setNotes(const std::string& notes)
        @see appendNotes(const XMLNode* notes)
        @see appendNotes(const std::string& notes)
          

        """
        return _libsbml.SBase_unsetNotes(self)

    def unsetAnnotation(self):
        """
        unsetAnnotation(self) -> int

        Unsets the value of the 'annotation' subelement of this SBML object.

        Whereas the SBase 'notes' subelement is a container for content to be
        shown directly to humans, the 'annotation' element is a container for
        optional software-generated content @em not meant to be shown to
        humans.  Every object derived from SBase can have its own value for
        'annotation'.  The element's content type is XML type
        <code>any</code>, allowing essentially arbitrary well-formed XML data
        content.

        SBML places a few restrictions on the organization of the content of
        annotations; these are intended to help software tools read and write
        the data as well as help reduce conflicts between annotations added by
        different tools.  Please see the SBML specifications for more details.

        @htmlinclude libsbml-comment-set-methods.html

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS

        @see getAnnotation()
        @see getAnnotationString()
        @see isSetAnnotation()
        @see setAnnotation(const XMLNode* annotation)
        @see setAnnotation(const std::string& annotation)
        @see appendAnnotation(const XMLNode* annotation)
        @see appendAnnotation(const std::string& annotation)
          

        """
        return _libsbml.SBase_unsetAnnotation(self)

    def unsetSBOTerm(self):
        """
        unsetSBOTerm(self) -> int

        Unsets the value of the 'sboTerm' attribute of this SBML object.

        @htmlinclude libsbml-comment-set-methods.html

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_UNEXPECTED_ATTRIBUTE
          

        """
        return _libsbml.SBase_unsetSBOTerm(self)

    def addCVTerm(self, *args):
        """
        addCVTerm(self, CVTerm term) -> int

        Adds a copy of the given CVTerm to this SBML object.

        @param term the CVTerm to assign

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_OPERATION_FAILED
        @li LIBSBML_UNEXPECTED_ATTRIBUTE
        @li LIBSBML_INVALID_OBJECT

        @note Since the CV Term uses the metaid of the object as a 
        reference, if the object has no metaid set the CVTerm will
        not be added.

        @warning The fact that this method @em copies the object passed to it
        means that the caller will be left holding a physically different
        object instance than the one contained in @em this object.  Changes
        made to the original object instance (such as resetting attribute
        values) will <em>not affect the instance added here</em>.  In
        addition, the caller should make sure to free the original object if
        it is no longer being used, or else a memory leak will result.
          

        """
        return _libsbml.SBase_addCVTerm(self, *args)

    def getCVTerms(self):
      """
      getCVTerms(self) -> CVTermList

      Get the CVTermList of CVTerm objects in this SBase.

      @return the CVTermList for this SBase.


      """
      return _libsbml.SBase_getCVTerms(self)


    def getNumCVTerms(self):
        """
        getNumCVTerms(self) -> unsigned int

        Returns the number of CVTerm objects in the annotations of this SBML
        object.

        @return the number of CVTerms for this SBML object.
          

        """
        return _libsbml.SBase_getNumCVTerms(self)

    def getCVTerm(self, *args):
        """
        getCVTerm(self, unsigned int n) -> CVTerm

        Returns the nth CVTerm in the list of CVTerms of this SBML
        object.

        @param n unsigned int the index of the CVTerm to retrieve

        @return the nth CVTerm in the list of CVTerms for this SBML object.
          

        """
        return _libsbml.SBase_getCVTerm(self, *args)

    def unsetCVTerms(self):
        """
        unsetCVTerms(self) -> int

        Clears the list of CVTerms of this SBML
        object.

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_OPERATION_FAILED
          

        """
        return _libsbml.SBase_unsetCVTerms(self)

    def getResourceBiologicalQualifier(self, *args):
        """
        getResourceBiologicalQualifier(self, string resource) -> BiolQualifierType_t

        Returns the BiologicalQualifier associated with this resource,
        or BQB_UNKNOWN if the resource does not exist.

        @param resource string representing the resource; e.g.,
        'http://www.geneontology.org/#GO:0005892'

        @return the #BiolQualifierType_t value associated with the resource
          

        """
        return _libsbml.SBase_getResourceBiologicalQualifier(self, *args)

    def getResourceModelQualifier(self, *args):
        """
        getResourceModelQualifier(self, string resource) -> ModelQualifierType_t

        Returns the ModelQualifier associated with this resource,
        or BQM_UNKNOWN if the resource does not exist.

        @param resource string representing the resource; e.g.,
        'http://www.geneontology.org/#GO:0005892'

        @return the #ModelQualifierType_t value associated with the resource
          

        """
        return _libsbml.SBase_getResourceModelQualifier(self, *args)

    def getModel(self):
        """
        getModel(self) -> Model

        Returns the Model object in which the current object is located.

        @return the parent Model of this SBML object.
          

        """
        return _libsbml.SBase_getModel(self)

    def getLevel(self):
        """
        getLevel(self) -> unsigned int

        Returns the SBML Level of the overall SBML document.

        @return the SBML level of this SBML object.

        @see getVersion()
          

        """
        return _libsbml.SBase_getLevel(self)

    def getVersion(self):
        """
        getVersion(self) -> unsigned int

        Returns the Version within the SBML Level of the overall SBML document.

        @return the SBML version of this SBML object.

        @see getLevel()
          

        """
        return _libsbml.SBase_getVersion(self)

    def getTypeCode(self):
        """
        getTypeCode(self) -> SBMLTypeCode_t

        Returns the libSBML type code for this object.

        This method MAY return the typecode of this SBML object or it MAY
        return SBML_UNKNOWN.  That is, subclasses of SBase are not required to
        implement this method to return a typecode.  This method is meant
        primarily for the LibSBML C interface where class and subclass
        information is not readily available.

        @return the #SBMLTypeCode_t value of this SBML object or SBML_UNKNOWN
        (default).

        @see getElementName()
          

        """
        return _libsbml.SBase_getTypeCode(self)

    def hasValidLevelVersionNamespaceCombination(self):
        """
        hasValidLevelVersionNamespaceCombination(self) -> bool

        Predicate returning @c true or @c false depending on whether this
        object's level/version and namespace values correspond to a valid
        SBML specification.

        The valid combinations of SBML Level, Version and Namespace as of this release
        of libSBML are the following: 
        <ul>
        <li> Level&nbsp;1 Version&nbsp;2 'http://www.sbml.org/sbml/level1'
        <li> Level&nbsp;2 Version&nbsp;1 'http://www.sbml.org/sbml/level2'
        <li> Level&nbsp;2 Version&nbsp;2 'http://www.sbml.org/sbml/level2/version2'
        <li> Level&nbsp;2 Version&nbsp;3 'http://www.sbml.org/sbml/level2/version3'
        <li> Level&nbsp;2 Version&nbsp;4 'http://www.sbml.org/sbml/level2/version4'
        </ul>

        @return @c true if the level, version and namespace values of this 
        SBML object correspond to a valid set of values, @c false otherwise.
          

        """
        return _libsbml.SBase_hasValidLevelVersionNamespaceCombination(self)

    def getElementName(self):
        """
        getElementName(self) -> string

        Returns the XML element name of this object.

        This is overridden by subclasses to return a string appropriate to the
        SBML component.  For example, Model defines it as returning 'model',
        CompartmentType defines it as returning 'compartmentType', etc.
          

        """
        return _libsbml.SBase_getElementName(self)

    def toSBML(self):
        """
        toSBML(self) -> char

        Returns a string that consists of the partial SBML describing this
        object.  This is primarily provided for testing and debugging
        purposes.  It may be removed in a future version of libSBML.

        @return the partial SBML that describes this SBML object.
          

        """
        return _libsbml.SBase_toSBML(self)

    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(self) -> bool

        Subclasses should override this method to write out their contained
        SBML objects as XML elements.  Be sure to call your parents
        implementation of this method as well.  For example:

          SBase::writeElements(stream);
          mReactans.write(stream);
          mProducts.write(stream);
          ...
        @deprecated libSBML internal


        """
        return _libsbml.SBase_hasRequiredAttributes(self)

    def hasRequiredElements(self):
        """
        hasRequiredElements(self) -> bool

        Subclasses should override this method to write out their contained
        SBML objects as XML elements.  Be sure to call your parents
        implementation of this method as well.  For example:

          SBase::writeElements(stream);
          mReactans.write(stream);
          mProducts.write(stream);
          ...
        @deprecated libSBML internal


        """
        return _libsbml.SBase_hasRequiredElements(self)

    def __eq__(self, rhs):
      if ((self is None) and (rhs is None)): return True
      if ((self is None) or  (rhs is None)): return False
      if (hasattr(self, 'this') and hasattr(rhs, 'this')):
        if (self.this == rhs.this): return True
      return False

    def __ne__(self, rhs):
      if ((self is None) and (rhs is None)): return False
      if ((self is None) or  (rhs is None)): return True
      if (hasattr(self, 'this') and hasattr(rhs, 'this')):
        if (self.this == rhs.this): return False
      return True

SBase_swigregister = _libsbml.SBase_swigregister
SBase_swigregister(SBase)

class ListOf(SBase):
    """
    Parent class for the various SBML 'ListOfXYZ' classes.

    @htmlinclude libsbml-not-sbml-warning.html


    """
    __swig_setmethods__ = {}
    for _s in [SBase]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOf, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOf, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_ListOf
    __del__ = lambda self : None;
    def __init__(self, *args): 
        """
        __init__(self) -> ListOf
        __init__(self, ListOf orig) -> ListOf

        Copy constructor.  Creates a copy of this ListOf.
          

        """
        this = _libsbml.new_ListOf(*args)
        try: self.this.append(this)
        except: self.this = this
    def clone(self):
        """
        clone(self) -> SBase

        Creates and returns a deep copy of this ListOf.

        @return a (deep) copy of this ListOf.
          

        """
        return _libsbml.ListOf_clone(self)

    def append(self, *args):
        """
        append(self, SBase item)

        Adds item to the end of this ListOf.

        This variant of the method makes a clone of the @p item handed to it.
        This means that when the ListOf is destroyed, the original items will
        not be destroyed.

        @param item the item to be added to the list.

        @see appendAndOwn(SBase* item)
          

        """
        return _libsbml.ListOf_append(self, *args)

    def appendAndOwn(self, *args):
        """
        appendAndOwn(self, SBase item)

        Adds item to the end of this ListOf.

        This variant of the method does not clone the @p item handed to it;
        instead, it assumes ownership of it.  This means that when the ListOf
        is destroyed, the item will be destroyed along with it.

        @param item the item to be added to the list.

        @see append(const SBase* item)
          

        """
        if args[0] is not None: args[0].thisown = 0


        return _libsbml.ListOf_appendAndOwn(self, *args)

    def get(self, *args):
        """
        get(self, unsigned int n) -> SBase
        get(self, unsigned int n) -> SBase

        Get an item from the list based on its identifier.

        @param sid a string representing the the identifier of the item to get.

        @return item in this ListOf items with the given id or NULL if no such
        item exists.

        @see get(unsigned int n)
        @see size()
          

        """
        return _libsbml.ListOf_get(self, *args)

    def clear(self, doDelete = True):
        """
        clear(self, bool doDelete = True)
        clear(self)

        Removes all items in this ListOf object.

        If doDelete is true (default), all items in this ListOf object are deleted
        and cleared, and thus the caller doesn't have to delete those items.
        Otherwise, all items are just cleared from this ListOf object and the caller 
        is responsible for deleting all items (In this case, pointers to all items 
        should be stored elsewhere before calling this function by the caller).

        @param doDelete if true (default), all items are deleted and cleared.
        Otherwise, all items are just cleared and not deleted. 
           

        """
        return _libsbml.ListOf_clear(self, doDelete)

    def remove(self, *args):
        """
        remove(self, unsigned int n) -> SBase

        Removes item in this ListOf items with the given identifier.

        The caller owns the returned item and is responsible for deleting it.
        If none of the items in this list have the identifier @p sid, then @c
        NULL is returned.

        @param sid the identifier of the item to remove

        @return the item removed.  As mentioned above, the caller owns the
        returned item.
          

        """
        return _libsbml.ListOf_remove(self, *args)

    def size(self):
        """
        size(self) -> unsigned int

        Get the size of this ListOf.

        @return the number of items in this ListOf items.
          

        """
        return _libsbml.ListOf_size(self)

    def getTypeCode(self):
        """
        getTypeCode(self) -> SBMLTypeCode_t

        Returns the libSBML type code for this object, namely, @c
        SBML_LIST_OF.

        @if clike LibSBML attaches an identifying code to every
        kind of SBML object.  These are known as <em>SBML type codes</em>.
        The set of possible type codes is defined in the enumeration
        #SBMLTypeCode_t.  The names of the type codes all begin with the
        characters @c SBML_. @endif@if java LibSBML attaches an
        identifying code to every kind of SBML object.  These are known as
        <em>SBML type codes</em>.  In other languages, the set of type codes
        is stored in an enumeration; in the Java language interface for
        libSBML, the type codes are defined as static integer constants in
        interface class {@link libsbmlConstants}.  The names of the type codes
        all begin with the characters @c SBML_. @endif

        @return the SBML type code for this object, or @c SBML_UNKNOWN (default).

        @see getElementName()
          

        """
        return _libsbml.ListOf_getTypeCode(self)

    def getItemTypeCode(self):
        """
        getItemTypeCode(self) -> SBMLTypeCode_t

        Get the type code of the objects contained in this ListOf.

        @if clike LibSBML attaches an identifying code to every
        kind of SBML object.  These are known as <em>SBML type codes</em>.
        The set of possible type codes is defined in the enumeration
        #SBMLTypeCode_t.  The names of the type codes all begin with the
        characters @c SBML_. @endif@if java LibSBML attaches an
        identifying code to every kind of SBML object.  These are known as
        <em>SBML type codes</em>.  In other languages, the set of type codes
        is stored in an enumeration; in the Java language interface for
        libSBML, the type codes are defined as static integer constants in
        interface class {@link libsbmlConstants}.  The names of the type codes
        all begin with the characters @c SBML_. @endif

        @return the SBML type code for the objects contained in this ListOf
        instance, or @c SBML_UNKNOWN (default).
          

        """
        return _libsbml.ListOf_getItemTypeCode(self)

    def getElementName(self):
        """
        getElementName(self) -> string

        Returns the XML element name of this object, which for ListOf, is
        always @c 'listOf'.

        @return the XML name of this element.
          

        """
        return _libsbml.ListOf_getElementName(self)

    def __len__(self):
        """__len__(self) -> int"""
        return _libsbml.ListOf___len__(self)

    def __getitem__(self, key):

      try:
         keyIsSlice = isinstance(key, slice)
      except:
         keyIsSlice = 0

      if keyIsSlice:
        start = key.start
        if start is None:
          start = 0
        stop = key.stop
        if stop is None:
          stop = self.size()
        return [self[i] for i in range(
          self._fixNegativeIndex(start), self._fixNegativeIndex(stop)
        )]

      key = self._fixNegativeIndex(key)
      if key < 0 or key >= self.size():
        raise IndexError(key)
      return self.get(key)


    def _fixNegativeIndex(self, index):
      if index < 0:
        return index + self.size()
      else:
        return index


    def __iter__(self):
      for i in range(self.size()):
        yield self[i]


    def __repr__(self):
      return "[" + ", ".join([repr(self[i]) for i in range(len(self))]) + "]"


    def __str__(self):
      return repr(self)

ListOf_swigregister = _libsbml.ListOf_swigregister
ListOf_swigregister(ListOf)

class Model(SBase):
    """
    LibSBML implementation of %SBML's %Model construct.

    In an SBML model definition, a single object of class Model serves as
    the overall container for the lists of the various model components.
    All of the lists are optional, but if a given list container is present
    within the model, the list must not be empty; that is, it must have
    length one or more.  The following are the components and lists
    permitted in different Levels and Versions of SBML as of this version
    of libSBML (3.3):
    <ul>
    <li> In SBML Level 1, the components are: UnitDefinition, Compartment,
    Species, Parameter, Rule, and Reaction.  Instances of the classes are
    placed inside instances of classes ListOfUnitDefinitions,
    ListOfCompartments, ListOfSpecies, ListOfParameters, ListOfRules, and
    ListOfReactions.

    <li> In SBML Level 2 Version 1, the components are: FunctionDefinition,
    UnitDefinition, Compartment, Species, Parameter, Rule, Reaction and
    Event.  Instances of the classes are placed inside instances of classes
    ListOfFunctionDefinitions, ListOfUnitDefinitions, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfRules, ListOfReactions, and
    ListOfEvents.

    <li> In SBML Level 2 Versions 2, 3 and 4, the components are:
    FunctionDefinition, UnitDefinition, CompartmentType, SpeciesType,
    Compartment, Species, Parameter, InitialAssignment, Rule, Constraint,
    Reaction and Event.  Instances of the classes are placed inside
    instances of classes ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments, ListOfRules,
    ListOfConstraints, ListOfReactions, and ListOfEvents.
    </ul>

    Although all the lists are optional, there are dependencies between SBML
    components such that defining some components requires defining others.
    An example is that defining a species requires defining a compartment,
    and defining a reaction requires defining a species.  The dependencies
    are explained in more detail in the SBML specifications.

    @section approaches Approaches to creating objects using the libSBML API

    LibSBML provides two main mechanisms for creating objects: class
    constructors (e.g., @if clike @link Species::Species() Species()
    @endlink @endif@if java <a href='org/sbml/libsbml/Species.html'>Species()</a> @endif),
    and <code>create<i>Object</i>()</code> methods (such as
    Model::createSpecies()) provided by certain object classes such as
    Model.  These multiple mechanisms are provided by libSBML for
    flexibility and to support different use-cases, but they also have
    different implications for the overall model structure.

    In general, the recommended approach is to use the
    <code>create<i>Object</i>()</code> methods.  These methods both create
    an object @em and link it to the parent in one step.  Here is an
    example:
      @verbatim
     // Create an SBMLDocument object in Level 2 Version 4 format:

     SBMLDocument* sbmlDoc = new SBMLDocument(2, 4);

     // Create a Model object inside the SBMLDocument object and set
     // its identifier.  The call returns a pointer to the Model object
     // created, and methods called on that object affect the attributes
     // of the object attached to the model (as expected).

     Model* model = sbmlDoc->createModel();
     model->setId('MyModel');

     // Create a Species object inside the Model and set its identifier.
     // Similar to the lines above, this call returns a pointer to the Species
     // object created, and methods called on that object affect the attributes
     // of the object attached to the model (as expected).

     Species *sp = model->createSpecies();
     sp->setId('MySpecies');
     @endverbatim

    The <code>create<i>Object</i>()</code> methods return a pointer to the
    object created, but they also add the object to the relevant list of
    object instances contained in the parent.  (These lists become the
    <code>&lt;listOf<i>Object</i>s&gt;</code> elements in the finished XML
    rendition of SBML.)  In the example above, Model::createSpecies() adds
    the created species directly to the <code>&lt;listOfSpecies&gt;</code>
    list in the model.  Subsequently, methods called on the species change
    the species in the model (which is what is expected in most situations).

    By contrast, the other main way of creating an object and adding it to a
    parent makes a @em copy of the object, and requires more care on the
    part of the caller.  Here is an example of this alternative approach:
      @verbatim
     // Create a Species object and add it to the model.
     // This uses the Species class constructor:

     Species *newsp = Species('MySpecies');
     model->addSpecies(newsp); // Warning! This makes a COPY inside 'model'.

     // addSpecies(...) copies the object, with the result that
     // 'newsp' still refers to the original.  The following may not
     // do what is expected:

     newsp.setId('NewId');    // Warning -- doesn't change the species in 'model'!

     // If 'newsp' object isn't going to be used further, it needs
     // to be deleted to avoid a memory leak.

     delete newsp;
     @endverbatim

    The key point of the example above is that, because the @if clike
    Model::addSpecies() @endif@if java Model::addSpecies(Species s) @endif
    call makes a copy of the object handed to it, care is needed both when
    attempting to make changes to the object, and when the original object
    is no longer needed.

    @section checking Consistency and adherence to SBML specifications

    To make it easier for applications to do whatever they need,
    libSBML&nbsp;3.x is relatively lax when it comes to enforcing
    correctness and completeness of models during model construction and
    editing.  Essentially, libSBML @em will @em not in most cases check
    automatically that a model's components have valid attribute values, or
    that the overall model is consistent and free of errors&mdash;even
    obvious errors such as duplication of identifiers.  This allows
    applications great leeway in how they build their models, but it means
    that software authors must take deliberate steps to ensure that the
    model will be, in the end, valid SBML.  These steps include such things
    as keeping track of the identifiers used in a model, manually performing
    updates in certain situations where an entity is referenced in more than
    one place (e.g., a species that is referenced by multiple
    SpeciesReference objects), and so on.

    That said, libSBML does provide powerful features for deliberately
    performing validation of SBML when an application decides it is time to
    do so.  The interfaces to these facilities are on the SBMLDocument
    class, in the form of SBMLDocument::checkInternalConsistency() and
    SBMLDocument::checkConsistency().  Please refer to the documentation for
    SBMLDocument for more information about this.

    While applications may play fast and loose and live like free spirits
    during the construction and editing of SBML models, they should always
    make sure to call SBMLDocument::checkInternalConsistency() and/or
    SBMLDocument::checkConsistency() before writing out the final version of
    an SBML model.

    """
    __swig_setmethods__ = {}
    for _s in [SBase]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Model, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Model, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_Model
    __del__ = lambda self : None;
    def __init__(self, *args): 
        """
        __init__(self, unsigned int level, unsigned int version) -> Model
        __init__(self, SBMLNamespaces sbmlns) -> Model
        __init__(self, Model orig) -> Model

        Removes the Event object with the given identifier from this Model
        object and returns a pointer to it.

        The caller owns the returned object and is responsible for deleting it.
        If none of the Event objects in this Model object have the identifier 
        @p sid, then @c NULL is returned.

        @param sid the identifier of the Event object to remove

        @return the Event object removed.  As mentioned above, the 
        caller owns the returned object. NULL is returned if no Event
        object with the identifier exists in this Model object.

        @deprecated libSBML internal


        """
        this = _libsbml.new_Model(*args)
        try: self.this.append(this)
        except: self.this = this
    def clone(self):
        """
        clone(self) -> Model

        Creates and returns a deep copy of this Model object.

        @return a (deep) copy of this Model.
          

        """
        return _libsbml.Model_clone(self)

    def getId(self):
        """
        getId(self) -> string

        Returns the value of the 'id' attribute of this Model.

        @return the id of this Model.
          

        """
        return _libsbml.Model_getId(self)

    def getName(self):
        """
        getName(self) -> string

        Returns the value of the 'name' attribute of this Model.

        @return the name of this Model.
          

        """
        return _libsbml.Model_getName(self)

    def getModelHistory(self, *args):
        """
        getModelHistory(self) -> ModelHistory
        getModelHistory(self) -> ModelHistory

        Returns the ModelHistory of this Model.

        @return ModelHistory of this Model.
          

        """
        return _libsbml.Model_getModelHistory(self, *args)

    def isSetId(self):
        """
        isSetId(self) -> bool

        Predicate returning @c true or @c false depending on whether this
        Model's 'id' attribute has been set.

        @htmlinclude libsbml-comment-set-methods.html

        @return @c true if the 'id' attribute of this Model has been
        set, @c false otherwise.
          

        """
        return _libsbml.Model_isSetId(self)

    def isSetName(self):
        """
        isSetName(self) -> bool

        Predicate returning @c true or @c false depending on whether this
        Model's 'name' attribute has been set.

        @htmlinclude libsbml-comment-set-methods.html

        @return @c true if the 'name' attribute of this Model has been
        set, @c false otherwise.
          

        """
        return _libsbml.Model_isSetName(self)

    def isSetModelHistory(self):
        """
        isSetModelHistory(self) -> bool

        Predicate returning @c true or @c false depending on whether this
        Model's ModelHistory has been set.

        @htmlinclude libsbml-comment-set-methods.html

        @return @c true if the ModelHistory of this Model
        has been set, @c false otherwise.
          

        """
        return _libsbml.Model_isSetModelHistory(self)

    def setId(self, *args):
        """
        setId(self, string sid) -> int

        Sets the value of the 'id' attribute of this Model.

        The string @p sid is copied.  Note that SBML has strict requirements
        for the syntax of identifiers.  The following is summary of the
        definition of the SBML identifier type @c SId (here expressed in an
        extended form of BNF notation):
        @code
          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*
        @endcode
        The equality of SBML identifiers is determined by an exact character
        sequence match; i.e., comparisons must be performed in a
        case-sensitive manner.  In addition, there are a few conditions for
        the uniqueness of identifiers in an SBML model.  Please consult the
        SBML specifications for the exact formulations.

        @htmlinclude libsbml-comment-set-methods.html

        @param sid the string to use as the identifier of this Model

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_INVALID_ATTRIBUTE_VALUE
          

        """
        return _libsbml.Model_setId(self, *args)

    def setName(self, *args):
        """
        setName(self, string name) -> int

        Sets the value of the 'name' attribute of this Model.

        The string in @p name is copied.

        @htmlinclude libsbml-comment-set-methods.html

        @param name the new name for the Model

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_INVALID_ATTRIBUTE_VALUE
          

        """
        return _libsbml.Model_setName(self, *args)

    def setModelHistory(self, *args):
        """
        setModelHistory(self, ModelHistory history) -> int

        Sets the ModelHistory of this Model.

        @htmlinclude libsbml-comment-set-methods.html

        @param history ModelHistory of this Model.

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_INVALID_OBJECT
          

        """
        return _libsbml.Model_setModelHistory(self, *args)

    def unsetId(self):
        """
        unsetId(self) -> int

        Unsets the value of the 'id' attribute of this Model.

        @htmlinclude libsbml-comment-set-methods.html

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_OPERATION_FAILED
          

        """
        return _libsbml.Model_unsetId(self)

    def unsetName(self):
        """
        unsetName(self) -> int

        Unsets the value of the 'name' attribute of this Model.

        @htmlinclude libsbml-comment-set-methods.html

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_OPERATION_FAILED
          

        """
        return _libsbml.Model_unsetName(self)

    def unsetModelHistory(self):
        """
        unsetModelHistory(self) -> int

        Unsets the ModelHistory of this Model.

        @htmlinclude libsbml-comment-set-methods.html

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_OPERATION_FAILED
          

        """
        return _libsbml.Model_unsetModelHistory(self)

    def addFunctionDefinition(self, *args):
        """
        addFunctionDefinition(self, FunctionDefinition fd) -> int

        Adds a copy of the given FunctionDefinition object to this Model.

        @param fd the FunctionDefinition to add

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_LEVEL_MISMATCH
        @li LIBSBML_VERSION_MISMATCH
        @li LIBSBML_DUPLICATE_OBJECT_ID
        @li LIBSBML_OPERATION_FAILED

        @note This method should be used with some caution.  The fact that
        this method @em copies the object passed to it means that the caller
        will be left holding a physically different object instance than the
        one contained in this Model.  Changes made to the original object
        instance (such as resetting attribute values) will <em>not affect the
        instance in the Model</em>.  In addition, the caller should make sure
        to free the original object if it is no longer being used, or else a
        memory leak will result.  Please see Model::createFunctionDefinition()
        for a method that does not lead to these issues.

        @see createFunctionDefinition()
          

        """
        return _libsbml.Model_addFunctionDefinition(self, *args)

    def addUnitDefinition(self, *args):
        """
        addUnitDefinition(self, UnitDefinition ud) -> int

        Adds a copy of the given UnitDefinition object to this Model.

        @param ud the UnitDefinition object to add

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_LEVEL_MISMATCH
        @li LIBSBML_VERSION_MISMATCH
        @li LIBSBML_DUPLICATE_OBJECT_ID
        @li LIBSBML_OPERATION_FAILED

        @note This method should be used with some caution.  The fact that
        this method @em copies the object passed to it means that the caller
        will be left holding a physically different object instance than the
        one contained in this Model.  Changes made to the original object
        instance (such as resetting attribute values) will <em>not affect the
        instance in the Model</em>.  In addition, the caller should make sure
        to free the original object if it is no longer being used, or else a
        memory leak will result.  Please see Model::createUnitDefinition() for
        a method that does not lead to these issues.

        @see createUnitDefinition()
          

        """
        return _libsbml.Model_addUnitDefinition(self, *args)

    def addCompartmentType(self, *args):
        """
        addCompartmentType(self, CompartmentType ct) -> int

        Adds a copy of the given CompartmentType object to this Model.

        @param ct the CompartmentType object to add

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_LEVEL_MISMATCH
        @li LIBSBML_VERSION_MISMATCH
        @li LIBSBML_DUPLICATE_OBJECT_ID
        @li LIBSBML_OPERATION_FAILED

        @note This method should be used with some caution.  The fact that
        this method @em copies the object passed to it means that the caller
        will be left holding a physically different object instance than the
        one contained in this Model.  Changes made to the original object
        instance (such as resetting attribute values) will <em>not affect the
        instance in the Model</em>.  In addition, the caller should make sure
        to free the original object if it is no longer being used, or else a
        memory leak will result.  Please see Model::createCompartmentType()
        for a method that does not lead to these issues.

        @see createCompartmentType()
          

        """
        return _libsbml.Model_addCompartmentType(self, *args)

    def addSpeciesType(self, *args):
        """
        addSpeciesType(self, SpeciesType st) -> int

        Adds a copy of the given SpeciesType object to this Model.

        @param st the SpeciesType object to add

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_LEVEL_MISMATCH
        @li LIBSBML_VERSION_MISMATCH
        @li LIBSBML_DUPLICATE_OBJECT_ID
        @li LIBSBML_OPERATION_FAILED

        @note This method should be used with some caution.  The fact that
        this method @em copies the object passed to it means that the caller
        will be left holding a physically different object instance than the
        one contained in this Model.  Changes made to the original object
        instance (such as resetting attribute values) will <em>not affect the
        instance in the Model</em>.  In addition, the caller should make sure
        to free the original object if it is no longer being used, or else a
        memory leak will result.  Please see Model::createSpeciesType() for a
        method that does not lead to these issues.

        @see createSpeciesType()
          

        """
        return _libsbml.Model_addSpeciesType(self, *args)

    def addCompartment(self, *args):
        """
        addCompartment(self, Compartment c) -> int

        Adds a copy of the given Compartment object to this Model.

        @param c the Compartment object to add

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_LEVEL_MISMATCH
        @li LIBSBML_VERSION_MISMATCH
        @li LIBSBML_DUPLICATE_OBJECT_ID
        @li LIBSBML_OPERATION_FAILED

        @note This method should be used with some caution.  The fact that
        this method @em copies the object passed to it means that the caller
        will be left holding a physically different object instance than the
        one contained in this Model.  Changes made to the original object
        instance (such as resetting attribute values) will <em>not affect the
        instance in the Model</em>.  In addition, the caller should make sure
        to free the original object if it is no longer being used, or else a
        memory leak will result.  Please see Model::createCompartment() for a
        method that does not lead to these issues.

        @see createCompartment()
          

        """
        return _libsbml.Model_addCompartment(self, *args)

    def addSpecies(self, *args):
        """
        addSpecies(self, Species s) -> int

        Adds a copy of the given Species object to this Model.

        @param s the Species object to add

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_LEVEL_MISMATCH
        @li LIBSBML_VERSION_MISMATCH
        @li LIBSBML_DUPLICATE_OBJECT_ID
        @li LIBSBML_OPERATION_FAILED

        @note This method should be used with some caution.  The fact that
        this method @em copies the object passed to it means that the caller
        will be left holding a physically different object instance than the
        one contained in this Model.  Changes made to the original object
        instance (such as resetting attribute values) will <em>not affect the
        instance in the Model</em>.  In addition, the caller should make sure
        to free the original object if it is no longer being used, or else a
        memory leak will result.  Please see Model::createSpecies() for a
        method that does not lead to these issues.

        @see createSpecies()
          

        """
        return _libsbml.Model_addSpecies(self, *args)

    def addParameter(self, *args):
        """
        addParameter(self, Parameter p) -> int

        Adds a copy of the given Parameter object to this Model.

        @param p the Parameter object to add

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_LEVEL_MISMATCH
        @li LIBSBML_VERSION_MISMATCH
        @li LIBSBML_DUPLICATE_OBJECT_ID
        @li LIBSBML_OPERATION_FAILED

        @note This method should be used with some caution.  The fact that
        this method @em copies the object passed to it means that the caller
        will be left holding a physically different object instance than the
        one contained in this Model.  Changes made to the original object
        instance (such as resetting attribute values) will <em>not affect the
        instance in the Model</em>.  In addition, the caller should make sure
        to free the original object if it is no longer being used, or else a
        memory leak will result.  Please see Model::createParameter() for a
        method that does not lead to these issues.

        @see createParameter()
          

        """
        return _libsbml.Model_addParameter(self, *args)

    def addInitialAssignment(self, *args):
        """
        addInitialAssignment(self, InitialAssignment ia) -> int

        Adds a copy of the given InitialAssignment object to this Model.

        @param ia the InitialAssignment object to add

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_LEVEL_MISMATCH
        @li LIBSBML_VERSION_MISMATCH
        @li LIBSBML_DUPLICATE_OBJECT_ID
        @li LIBSBML_OPERATION_FAILED

        @note This method should be used with some caution.  The fact that
        this method @em copies the object passed to it means that the caller
        will be left holding a physically different object instance than the
        one contained in this Model.  Changes made to the original object
        instance (such as resetting attribute values) will <em>not affect the
        instance in the Model</em>.  In addition, the caller should make sure
        to free the original object if it is no longer being used, or else a
        memory leak will result.  Please see Model::createInitialAssignment()
        for a method that does not lead to these issues.

        @see createInitialAssignment()
          

        """
        return _libsbml.Model_addInitialAssignment(self, *args)

    def addRule(self, *args):
        """
        addRule(self, Rule r) -> int

        Adds a copy of the given Rule object to this Model.

        @param r the Rule object to add

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_LEVEL_MISMATCH
        @li LIBSBML_VERSION_MISMATCH
        @li LIBSBML_DUPLICATE_OBJECT_ID
        @li LIBSBML_OPERATION_FAILED

        @note This method should be used with some caution.  The fact that
        this method @em copies the object passed to it means that the caller
        will be left holding a physically different object instance than the
        one contained in this Model.  Changes made to the original object
        instance (such as resetting attribute values) will <em>not affect the
        instance in the Model</em>.  In addition, the caller should make sure
        to free the original object if it is no longer being used, or else a
        memory leak will result.  Please see the methods
        Model::createAlgebraicRule(), Model::createAssignmentRule() and
        Model::createRateRule() for methods that do not lead to these issues.

        @see createAlgebraicRule()
        @see createAssignmentRule()
        @see createRateRule()
          

        """
        return _libsbml.Model_addRule(self, *args)

    def addConstraint(self, *args):
        """
        addConstraint(self, Constraint c) -> int

        Adds a copy of the given Constraint object to this Model.

        @param c the Constraint object to add

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_LEVEL_MISMATCH
        @li LIBSBML_VERSION_MISMATCH
        @li LIBSBML_OPERATION_FAILED

        @note This method should be used with some caution.  The fact that
        this method @em copies the object passed to it means that the caller
        will be left holding a physically different object instance than the
        one contained in this Model.  Changes made to the original object
        instance (such as resetting attribute values) will <em>not affect the
        instance in the Model</em>.  In addition, the caller should make sure
        to free the original object if it is no longer being used, or else a
        memory leak will result.  Please see Model::createConstraint() for a
        method that does not lead to these issues.

        @see createConstraint()
          

        """
        return _libsbml.Model_addConstraint(self, *args)

    def addReaction(self, *args):
        """
        addReaction(self, Reaction r) -> int

        Adds a copy of the given Reaction object to this Model.

        @param r the Reaction object to add

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_LEVEL_MISMATCH
        @li LIBSBML_VERSION_MISMATCH
        @li LIBSBML_DUPLICATE_OBJECT_ID
        @li LIBSBML_OPERATION_FAILED

        @note This method should be used with some caution.  The fact that
        this method @em copies the object passed to it means that the caller
        will be left holding a physically different object instance than the
        one contained in this Model.  Changes made to the original object
        instance (such as resetting attribute values) will <em>not affect the
        instance in the Model</em>.  In addition, the caller should make sure
        to free the original object if it is no longer being used, or else a
        memory leak will result.  Please see Model::createReaction() for a
        method that does not lead to these issues.

        @see createReaction()
          

        """
        return _libsbml.Model_addReaction(self, *args)

    def addEvent(self, *args):
        """
        addEvent(self, Event e) -> int

        Adds a copy of the given Event object to this Model.

        @param e the Event object to add

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_LEVEL_MISMATCH
        @li LIBSBML_VERSION_MISMATCH
        @li LIBSBML_DUPLICATE_OBJECT_ID
        @li LIBSBML_OPERATION_FAILED

        @note This method should be used with some caution.  The fact that
        this method @em copies the object passed to it means that the caller
        will be left holding a physically different object instance than the
        one contained in this Model.  Changes made to the original object
        instance (such as resetting attribute values) will <em>not affect the
        instance in the Model</em>.  In addition, the caller should make sure
        to free the original object if it is no longer being used, or else a
        memory leak will result.  Please see Model::createEvent() for a method
        that does not lead to these issues.

        @see createEvent()
          

        """
        return _libsbml.Model_addEvent(self, *args)

    def createFunctionDefinition(self):
        """
        createFunctionDefinition(self) -> FunctionDefinition

        Creates a new FunctionDefinition inside this Model and returns it.

        @return the FunctionDefinition object created

        @see addFunctionDefinition(const FunctionDefinition* fd)
          

        """
        return _libsbml.Model_createFunctionDefinition(self)

    def createUnitDefinition(self):
        """
        createUnitDefinition(self) -> UnitDefinition

        Creates a new UnitDefinition inside this Model and returns it.

        @return the UnitDefinition object created

        @see addUnitDefinition(const UnitDefinition* ud)
          

        """
        return _libsbml.Model_createUnitDefinition(self)

    def createUnit(self):
        """
        createUnit(self) -> Unit

        Creates a new Unit object within the last UnitDefinition object
        created in this model and returns a pointer to it.

        The mechanism by which the UnitDefinition was created is not
        significant.  If a UnitDefinition object does not exist in this model,
        a new Unit is @em not created and NULL is returned instead.

        @return the Unit object created

        @see addUnitDefinition(const UnitDefinition* ud)
          

        """
        return _libsbml.Model_createUnit(self)

    def createCompartmentType(self):
        """
        createCompartmentType(self) -> CompartmentType

        Creates a new CompartmentType inside this Model and returns it.

        @return the CompartmentType object created

        @see addCompartmentType(const CompartmentType* ct)
          

        """
        return _libsbml.Model_createCompartmentType(self)

    def createSpeciesType(self):
        """
        createSpeciesType(self) -> SpeciesType

        Creates a new SpeciesType inside this Model and returns it.

        @return the SpeciesType object created

        @see addSpeciesType(const SpeciesType* st)
          

        """
        return _libsbml.Model_createSpeciesType(self)

    def createCompartment(self):
        """
        createCompartment(self) -> Compartment

        Creates a new Compartment inside this Model and returns it.

        @return the Compartment object created

        @see addCompartment(const Compartment *c)
          

        """
        return _libsbml.Model_createCompartment(self)

    def createSpecies(self):
        """
        createSpecies(self) -> Species

        Creates a new Species inside this Model and returns it.

        @return the Species object created

        @see addSpecies(const Species *s)
          

        """
        return _libsbml.Model_createSpecies(self)

    def createParameter(self):
        """
        createParameter(self) -> Parameter

        Creates a new Parameter inside this Model and returns it.

        @return the Parameter object created

        @see addParameter(const Parameter *p)
          

        """
        return _libsbml.Model_createParameter(self)

    def createInitialAssignment(self):
        """
        createInitialAssignment(self) -> InitialAssignment

        Creates a new InitialAssignment inside this Model and returns it.

        @return the InitialAssignment object created

        @see addInitialAssignment(const InitialAssignment* ia)
          

        """
        return _libsbml.Model_createInitialAssignment(self)

    def createAlgebraicRule(self):
        """
        createAlgebraicRule(self) -> AlgebraicRule

        Creates a new AlgebraicRule inside this Model and returns it.

        @return the AlgebraicRule object created

        @see addRule(const Rule* r)
          

        """
        return _libsbml.Model_createAlgebraicRule(self)

    def createAssignmentRule(self):
        """
        createAssignmentRule(self) -> AssignmentRule

        Creates a new AssignmentRule inside this Model and returns it.

        @return the AssignmentRule object created

        @see addRule(const Rule* r)
          

        """
        return _libsbml.Model_createAssignmentRule(self)

    def createRateRule(self):
        """
        createRateRule(self) -> RateRule

        Creates a new RateRule inside this Model and returns it.

        @return the RateRule object created

        @see addRule(const Rule* r)
          

        """
        return _libsbml.Model_createRateRule(self)

    def createConstraint(self):
        """
        createConstraint(self) -> Constraint

        Creates a new Constraint inside this Model and returns it.

        @return the Constraint object created

        @see addConstraint(const Constraint *c)
          

        """
        return _libsbml.Model_createConstraint(self)

    def createReaction(self):
        """
        createReaction(self) -> Reaction

        Creates a new Reaction inside this Model and returns it.

        @return the Reaction object created

        @see addReaction(const Reaction *r)
          

        """
        return _libsbml.Model_createReaction(self)

    def createReactant(self):
        """
        createReactant(self) -> SpeciesReference

        Creates a new SpeciesReference object for a reactant inside the last
        Reaction object in this Model, and returns a pointer to it.

        The mechanism by which the last Reaction object was created and added
        to this Model is not significant.  It could have been created in a
        variety of ways, for example using createReaction().  If a Reaction
        does not exist for this model, a new SpeciesReference is @em not
        created and NULL is returned instead.

        @return the SpeciesReference object created
          

        """
        return _libsbml.Model_createReactant(self)

    def createProduct(self):
        """
        createProduct(self) -> SpeciesReference

        Creates a new SpeciesReference object for a product inside the last
        Reaction object in this Model, and returns a pointer to it.

        The mechanism by which the last Reaction object was created and added
        to this Model is not significant.  It could have been created in a
        variety of ways, for example using createReaction().  If a Reaction
        does not exist for this model, a new SpeciesReference is @em not
        created and NULL is returned instead.

        @return the SpeciesReference object created
          

        """
        return _libsbml.Model_createProduct(self)

    def createModifier(self):
        """
        createModifier(self) -> ModifierSpeciesReference

        Creates a new ModifierSpeciesReference object for a modifier species
        inside the last Reaction object in this Model, and returns a pointer
        to it.

        The mechanism by which the last Reaction object was created and added
        to this Model is not significant.  It could have been created in a
        variety of ways, for example using createReaction().  If a Reaction
        does not exist for this model, a new ModifierSpeciesReference is @em
        not created and NULL is returned instead.

        @return the SpeciesReference object created
          

        """
        return _libsbml.Model_createModifier(self)

    def createKineticLaw(self):
        """
        createKineticLaw(self) -> KineticLaw

        Creates a new KineticLaw inside the last Reaction object created in
        this Model, and returns a pointer to it.

        The mechanism by which the last Reaction object was created and added
        to this Model is not significant.  It could have been created in a
        variety of ways, for example using createReaction().  If a Reaction
        does not exist for this model, or a Reaction exists but already has a
        KineticLaw, a new KineticLaw is @em not created and NULL is returned
        instead.

        @return the KineticLaw object created
          

        """
        return _libsbml.Model_createKineticLaw(self)

    def createKineticLawParameter(self):
        """
        createKineticLawParameter(self) -> Parameter

        Creates a new local Parameter inside the KineticLaw object of the last
        Reaction created inside this Model, and returns a pointer to it.

        The last KineticLaw object in this Model could have been created in a
        variety of ways.  For example, it could have been added using
        createKineticLaw(), or it could be the result of using
        Reaction::createKineticLaw() on the Reaction object created by a
        createReaction().  If a Reaction does not exist for this model, or the
        last Reaction does not contain a KineticLaw object, a new Parameter is
        @em not created and NULL is returned instead.

        @return the Parameter object created
          

        """
        return _libsbml.Model_createKineticLawParameter(self)

    def createEvent(self):
        """
        createEvent(self) -> Event

        Creates a new Event inside this Model and returns it.

        @return the Event object created
          

        """
        return _libsbml.Model_createEvent(self)

    def createEventAssignment(self):
        """
        createEventAssignment(self) -> EventAssignment

        Creates a new EventAssignment inside the last Event object created in
        this Model, and returns a pointer to it.

        The mechanism by which the last Event object in this model was created
        is not significant.  It could have been created in a variety of ways,
        for example by using createEvent().  If no Event object exists in this
        Model object, a new EventAssignment is @em not created and NULL is
        returned instead.

        @return the EventAssignment object created
          

        """
        return _libsbml.Model_createEventAssignment(self)

    def createTrigger(self):
        """
        createTrigger(self) -> Trigger

        Creates a new Trigger inside the last Event object created in
        this Model, and returns a pointer to it.

        The mechanism by which the last Event object in this model was created
        is not significant.  It could have been created in a variety of ways,
        for example by using createEvent().  If no Event object exists in this
        Model object, a new Trigger is @em not created and NULL is
        returned instead.

        @return the Trigger object created
          

        """
        return _libsbml.Model_createTrigger(self)

    def createDelay(self):
        """
        createDelay(self) -> Delay

        Creates a new Delay inside the last Event object created in
        this Model, and returns a pointer to it.

        The mechanism by which the last Event object in this model was created
        is not significant.  It could have been created in a variety of ways,
        for example by using createEvent().  If no Event object exists in this
        Model object, a new Delay is @em not created and NULL is
        returned instead.

        @return the Delay object created
          

        """
        return _libsbml.Model_createDelay(self)

    def setAnnotation(self, *args):
        """
        setAnnotation(self, XMLNode annotation) -> int
        setAnnotation(self, string annotation) -> int

        Sets the value of the 'annotation' subelement of this SBML object to a
        copy of @p annotation.

        Any existing content of the 'annotation' subelement is discarded.
        Unless you have taken steps to first copy and reconstitute any
        existing annotations into the @p annotation that is about to be
        assigned, it is likely that performing such wholesale replacement is
        unfriendly towards other software applications whose annotations are
        discarded.  An alternative may be to use appendAnnotation().

        @param annotation an XML string that is to be used as the content
        of the 'annotation' subelement of this object

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_OPERATION_FAILED

        @see appendAnnotation(const std::string& annotation)
          

        """
        return _libsbml.Model_setAnnotation(self, *args)

    def appendAnnotation(self, *args):
        """
        appendAnnotation(self, XMLNode annotation) -> int
        appendAnnotation(self, string annotation) -> int

        Appends annotation content to any existing content in the 'annotation'
        subelement of this object.

        The content in @p annotation is copied.  Unlike setAnnotation(), this 
        method allows other annotations to be preserved when an application
        adds its own data.

        @param annotation an XML string that is to be copied and appended
        to the content of the 'annotation' subelement of this object

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_OPERATION_FAILED

        @see setAnnotation(const std::string& annotation)
          

        """
        return _libsbml.Model_appendAnnotation(self, *args)

    def getListOfFunctionDefinitions(self, *args):
        """
        getListOfFunctionDefinitions(self) -> ListOfFunctionDefinitions
        getListOfFunctionDefinitions(self) -> ListOfFunctionDefinitions

        Get the ListOfFunctionDefinitions object in this Model.

        @return the list of FunctionDefinitions for this Model.
          

        """
        return _libsbml.Model_getListOfFunctionDefinitions(self, *args)

    def getListOfUnitDefinitions(self, *args):
        """
        getListOfUnitDefinitions(self) -> ListOfUnitDefinitions
        getListOfUnitDefinitions(self) -> ListOfUnitDefinitions

        Get the ListOfUnitDefinitions object in this Model.

        @return the list of UnitDefinitions for this Model.
          

        """
        return _libsbml.Model_getListOfUnitDefinitions(self, *args)

    def getListOfCompartmentTypes(self, *args):
        """
        getListOfCompartmentTypes(self) -> ListOfCompartmentTypes
        getListOfCompartmentTypes(self) -> ListOfCompartmentTypes

        Get the ListOfCompartmentTypes object in this Model.

        @return the list of CompartmentTypes for this Model.
          

        """
        return _libsbml.Model_getListOfCompartmentTypes(self, *args)

    def getListOfSpeciesTypes(self, *args):
        """
        getListOfSpeciesTypes(self) -> ListOfSpeciesTypes
        getListOfSpeciesTypes(self) -> ListOfSpeciesTypes

        Get the ListOfSpeciesTypes object in this Model.

        @return the list of SpeciesTypes for this Model.
          

        """
        return _libsbml.Model_getListOfSpeciesTypes(self, *args)

    def getListOfCompartments(self, *args):
        """
        getListOfCompartments(self) -> ListOfCompartments
        getListOfCompartments(self) -> ListOfCompartments

        Get the ListOfCompartments object in this Model.

        @return the list of Compartments for this Model.
          

        """
        return _libsbml.Model_getListOfCompartments(self, *args)

    def getListOfSpecies(self, *args):
        """
        getListOfSpecies(self) -> ListOfSpecies
        getListOfSpecies(self) -> ListOfSpecies

        Get the ListOfSpecies object in this Model.

        @return the list of Species for this Model.
          

        """
        return _libsbml.Model_getListOfSpecies(self, *args)

    def getListOfParameters(self, *args):
        """
        getListOfParameters(self) -> ListOfParameters
        getListOfParameters(self) -> ListOfParameters

        Get the ListOfParameters object in this Model.

        @return the list of Parameters for this Model.
          

        """
        return _libsbml.Model_getListOfParameters(self, *args)

    def getListOfInitialAssignments(self, *args):
        """
        getListOfInitialAssignments(self) -> ListOfInitialAssignments
        getListOfInitialAssignments(self) -> ListOfInitialAssignments

        Get the ListOfInitialAssignments object in this Model.

        @return the list of InitialAssignment for this Model.
          

        """
        return _libsbml.Model_getListOfInitialAssignments(self, *args)

    def getListOfRules(self, *args):
        """
        getListOfRules(self) -> ListOfRules
        getListOfRules(self) -> ListOfRules

        Get the ListOfRules object in this Model.

        @return the list of Rules for this Model.
          

        """
        return _libsbml.Model_getListOfRules(self, *args)

    def getListOfConstraints(self, *args):
        """
        getListOfConstraints(self) -> ListOfConstraints
        getListOfConstraints(self) -> ListOfConstraints

        Get the ListOfConstraints object in this Model.

        @return the list of Constraints for this Model.
          

        """
        return _libsbml.Model_getListOfConstraints(self, *args)

    def getListOfReactions(self, *args):
        """
        getListOfReactions(self) -> ListOfReactions
        getListOfReactions(self) -> ListOfReactions

        Get the ListOfReactions object in this Model.

        @return the list of Reactions for this Model.
          

        """
        return _libsbml.Model_getListOfReactions(self, *args)

    def getListOfEvents(self, *args):
        """
        getListOfEvents(self) -> ListOfEvents
        getListOfEvents(self) -> ListOfEvents

        Get the ListOfEvents object in this Model.

        @return the list of Events for this Model.
          

        """
        return _libsbml.Model_getListOfEvents(self, *args)

    def getFunctionDefinition(self, *args):
        """
        getFunctionDefinition(self, unsigned int n) -> FunctionDefinition
        getFunctionDefinition(self, unsigned int n) -> FunctionDefinition
        getFunctionDefinition(self, string sid) -> FunctionDefinition
        getFunctionDefinition(self, string sid) -> FunctionDefinition

        Get a FunctionDefinition object based on its identifier.

        @return the FunctionDefinition in this Model with the identifier
        @p sid or NULL if no such FunctionDefinition exists.
          

        """
        return _libsbml.Model_getFunctionDefinition(self, *args)

    def getUnitDefinition(self, *args):
        """
        getUnitDefinition(self, unsigned int n) -> UnitDefinition
        getUnitDefinition(self, unsigned int n) -> UnitDefinition
        getUnitDefinition(self, string sid) -> UnitDefinition
        getUnitDefinition(self, string sid) -> UnitDefinition

        Get a UnitDefinition based on its identifier.

        @return the UnitDefinition in this Model with the identifier @p sid or
        NULL if no such UnitDefinition exists.
          

        """
        return _libsbml.Model_getUnitDefinition(self, *args)

    def getCompartmentType(self, *args):
        """
        getCompartmentType(self, unsigned int n) -> CompartmentType
        getCompartmentType(self, unsigned int n) -> CompartmentType
        getCompartmentType(self, string sid) -> CompartmentType
        getCompartmentType(self, string sid) -> CompartmentType

        Get a CompartmentType object based on its identifier.

        @return the CompartmentType in this Model with the identifier @p sid
        or NULL if no such CompartmentType exists.
          

        """
        return _libsbml.Model_getCompartmentType(self, *args)

    def getSpeciesType(self, *args):
        """
        getSpeciesType(self, unsigned int n) -> SpeciesType
        getSpeciesType(self, unsigned int n) -> SpeciesType
        getSpeciesType(self, string sid) -> SpeciesType
        getSpeciesType(self, string sid) -> SpeciesType

        Get a SpeciesType object based on its identifier.

        @return the SpeciesType in this Model with the identifier @p sid or
        NULL if no such SpeciesType exists.
          

        """
        return _libsbml.Model_getSpeciesType(self, *args)

    def getCompartment(self, *args):
        """
        getCompartment(self, unsigned int n) -> Compartment
        getCompartment(self, unsigned int n) -> Compartment
        getCompartment(self, string sid) -> Compartment
        getCompartment(self, string sid) -> Compartment

        Get a Compartment object based on its identifier.

        @return the Compartment in this Model with the identifier @p sid or
        NULL if no such Compartment exists.
          

        """
        return _libsbml.Model_getCompartment(self, *args)

    def getSpecies(self, *args):
        """
        getSpecies(self, unsigned int n) -> Species
        getSpecies(self, unsigned int n) -> Species
        getSpecies(self, string sid) -> Species
        getSpecies(self, string sid) -> Species

        Get a Species object based on its identifier.

        @return the Species in this Model with the identifier @p sid or NULL
        if no such Species exists.
          

        """
        return _libsbml.Model_getSpecies(self, *args)

    def getParameter(self, *args):
        """
        getParameter(self, unsigned int n) -> Parameter
        getParameter(self, unsigned int n) -> Parameter
        getParameter(self, string sid) -> Parameter
        getParameter(self, string sid) -> Parameter

        Get a Parameter object based on its identifier.

        @return the Parameter in this Model with the identifier @p sid or NULL
        if no such Parameter exists.
          

        """
        return _libsbml.Model_getParameter(self, *args)

    def getInitialAssignment(self, *args):
        """
        getInitialAssignment(self, unsigned int n) -> InitialAssignment
        getInitialAssignment(self, unsigned int n) -> InitialAssignment
        getInitialAssignment(self, string symbol) -> InitialAssignment
        getInitialAssignment(self, string symbol) -> InitialAssignment

        Get an InitialAssignment object based on the symbol to which it
        assigns a value.

        @return the InitialAssignment in this Model with the given 'symbol'
        attribute value or NULL if no such InitialAssignment exists.
          

        """
        return _libsbml.Model_getInitialAssignment(self, *args)

    def getRule(self, *args):
        """
        getRule(self, unsigned int n) -> Rule
        getRule(self, unsigned int n) -> Rule
        getRule(self, string variable) -> Rule
        getRule(self, string variable) -> Rule

        Get a Rule object based on the variable to which it assigns a value.

        @return the Rule in this Model with the given 'variable' attribute
        value or NULL if no such Rule exists.
          

        """
        return _libsbml.Model_getRule(self, *args)

    def getConstraint(self, *args):
        """
        getConstraint(self, unsigned int n) -> Constraint
        getConstraint(self, unsigned int n) -> Constraint

        Get the nth Constraint object in this Model.

        @return the nth Constraint of this Model.
          

        """
        return _libsbml.Model_getConstraint(self, *args)

    def getReaction(self, *args):
        """
        getReaction(self, unsigned int n) -> Reaction
        getReaction(self, unsigned int n) -> Reaction
        getReaction(self, string sid) -> Reaction
        getReaction(self, string sid) -> Reaction

        Get a Reaction object based on its identifier.

        @return the Reaction in this Model with the identifier @p sid or NULL
        if no such Reaction exists.
          

        """
        return _libsbml.Model_getReaction(self, *args)

    def getEvent(self, *args):
        """
        getEvent(self, unsigned int n) -> Event
        getEvent(self, unsigned int n) -> Event
        getEvent(self, string sid) -> Event
        getEvent(self, string sid) -> Event

        Get an Event object based on its identifier.

        @return the Event in this Model with the identifier @p sid or NULL if
        no such Event exists.
          

        """
        return _libsbml.Model_getEvent(self, *args)

    def getNumFunctionDefinitions(self):
        """
        getNumFunctionDefinitions(self) -> unsigned int

        Get the number of FunctionDefinition objects in this Model.

        @return the number of FunctionDefinitions in this Model.
          

        """
        return _libsbml.Model_getNumFunctionDefinitions(self)

    def getNumUnitDefinitions(self):
        """
        getNumUnitDefinitions(self) -> unsigned int

        Get the number of UnitDefinition objects in this Model.

        @return the number of UnitDefinitions in this Model.
          

        """
        return _libsbml.Model_getNumUnitDefinitions(self)

    def getNumCompartmentTypes(self):
        """
        getNumCompartmentTypes(self) -> unsigned int

        Get the number of CompartmentType objects in this Model.

        @return the number of CompartmentTypes in this Model.
          

        """
        return _libsbml.Model_getNumCompartmentTypes(self)

    def getNumSpeciesTypes(self):
        """
        getNumSpeciesTypes(self) -> unsigned int

        Get the number of SpeciesType objects in this Model.

        @return the number of SpeciesTypes in this Model.
          

        """
        return _libsbml.Model_getNumSpeciesTypes(self)

    def getNumCompartments(self):
        """
        getNumCompartments(self) -> unsigned int

        Get the number of Compartment objects in this Model.

        @return the number of Compartments in this Model.
          

        """
        return _libsbml.Model_getNumCompartments(self)

    def getNumSpecies(self):
        """
        getNumSpecies(self) -> unsigned int

        Get the number of Specie objects in this Model.

        @return the number of Species in this Model.
          

        """
        return _libsbml.Model_getNumSpecies(self)

    def getNumSpeciesWithBoundaryCondition(self):
        """
        getNumSpeciesWithBoundaryCondition(self) -> unsigned int

        Get the number of Species in this Model having their
        'boundaryCondition' attribute value set to @c true.

        @return the number of Species in this Model with boundaryCondition set
        to true.
          

        """
        return _libsbml.Model_getNumSpeciesWithBoundaryCondition(self)

    def getNumParameters(self):
        """
        getNumParameters(self) -> unsigned int

        Get the number of Parameter objects in this Model.

        @return the number of Parameters in this Model.  Parameters defined in
        KineticLaws are not included.
          

        """
        return _libsbml.Model_getNumParameters(self)

    def getNumInitialAssignments(self):
        """
        getNumInitialAssignments(self) -> unsigned int

        Get the number of InitialAssignment objects in this Model.

        @return the number of InitialAssignments in this Model.
          

        """
        return _libsbml.Model_getNumInitialAssignments(self)

    def getNumRules(self):
        """
        getNumRules(self) -> unsigned int

        Get the number of Rule objects in this Model.

        @return the number of Rules in this Model.
          

        """
        return _libsbml.Model_getNumRules(self)

    def getNumConstraints(self):
        """
        getNumConstraints(self) -> unsigned int

        Get the number of Constraint objects in this Model.

        @return the number of Constraints in this Model.
          

        """
        return _libsbml.Model_getNumConstraints(self)

    def getNumReactions(self):
        """
        getNumReactions(self) -> unsigned int

        Get the number of Reaction objects in this Model.

        @return the number of Reactions in this Model.
          

        """
        return _libsbml.Model_getNumReactions(self)

    def getNumEvents(self):
        """
        getNumEvents(self) -> unsigned int

        Get the number of Event objects in this Model.

        @return the number of Events in this Model.
          

        """
        return _libsbml.Model_getNumEvents(self)

    def getTypeCode(self):
        """
        getTypeCode(self) -> SBMLTypeCode_t

        Returns the libSBML type code for this %SBML object.

        @if clike LibSBML attaches an identifying code to every
        kind of SBML object.  These are known as <em>SBML type codes</em>.
        The set of possible type codes is defined in the enumeration
        #SBMLTypeCode_t.  The names of the type codes all begin with the
        characters @c SBML_. @endif@if java LibSBML attaches an
        identifying code to every kind of SBML object.  These are known as
        <em>SBML type codes</em>.  In other languages, the set of type codes
        is stored in an enumeration; in the Java language interface for
        libSBML, the type codes are defined as static integer constants in
        interface class {@link libsbmlConstants}.  The names of the type codes
        all begin with the characters @c SBML_. @endif

        @return the SBML type code for this object, or @c SBML_UNKNOWN (default).

        @see getElementName()
          

        """
        return _libsbml.Model_getTypeCode(self)

    def getElementName(self):
        """
        getElementName(self) -> string

        Returns the XML element name of this object, which for Model, is
        always @c 'model'.

        @return the name of this element, i.e., @c 'model'.
          

        """
        return _libsbml.Model_getElementName(self)

    def populateListFormulaUnitsData(self):
        """
        populateListFormulaUnitsData(self)

        Populates the list of FormulaDataUnits with the units derived 
        for the model. The list contains elements of class
        FormulaUnitsData. 

        The first element of the list refers to the default units
        of 'substance per time' derived from the model and has the
        unitReferenceId 'subs_per_time'. This facilitates the comparison of units
        derived from mathematical formula with the expected units.

        The next elements of the list record the units of the 
        compartments and species established from either explicitly
        declared or default units.

        The next elements record the units of any parameters.

        Subsequent elements of the list record the units derived for
        each mathematical expression encountered within the model.

        @note This function is utilised by the Unit Consistency Validator.
        The list is populated prior to running the validation and thus
        the consistency of units can be checked by accessing the members
        of the list and comparing the appropriate data.
          

        """
        return _libsbml.Model_populateListFormulaUnitsData(self)

    def isPopulatedListFormulaUnitsData(self):
        """
        isPopulatedListFormulaUnitsData(self) -> bool

        Predicate returning @c true or @c false depending on whether 
        the list of FormulaUnitsData has been populated.

        @return @c true if the list of FormulaUnitsData has been populated, 
        @c false otherwise.
          

        """
        return _libsbml.Model_isPopulatedListFormulaUnitsData(self)

    def hasRequiredElements(self):
        """
        hasRequiredElements(self) -> bool

        Predicate returning @c true or @c false depending on whether
        all the required elements for this Model object
        have been set.

        @note The required elements for a Model object are:
        listOfCompartments (L1 only); listOfSpecies (L1V1 only);
        listOfReactions(L1V1 only)

        @return a boolean value indicating whether all the required
        elements for this object have been defined.
          

        """
        return _libsbml.Model_hasRequiredElements(self)

    def removeFunctionDefinition(self, *args):
        """
        removeFunctionDefinition(self, unsigned int n) -> FunctionDefinition
        removeFunctionDefinition(self, string sid) -> FunctionDefinition

        Removes the FunctionDefinition object with the given identifier from this Model 
        object and returns a pointer to it.

        The caller owns the returned object and is responsible for deleting it.
        If none of the FunctionDefinition objects in this Model object have the identifier 
        @p sid, then @c NULL is returned.

        @param sid the identifier of the FunctionDefinition object to remove

        @return the FunctionDefinition object removed.  As mentioned above, the 
        caller owns the returned object. NULL is returned if no FunctionDefinition
        object with the identifier exists in this Model object.
          

        """
        return _libsbml.Model_removeFunctionDefinition(self, *args)

    def removeUnitDefinition(self, *args):
        """
        removeUnitDefinition(self, unsigned int n) -> UnitDefinition
        removeUnitDefinition(self, string sid) -> UnitDefinition

        Removes the UnitDefinition object with the given identifier from this Model
        object and returns a pointer to it.

        The caller owns the returned object and is responsible for deleting it.
        If none of the UnitDefinition objects in this Model object have the identifier 
        @p sid, then @c NULL is returned.

        @param sid the identifier of the UnitDefinition object to remove

        @return the UnitDefinition object removed.  As mentioned above, the 
        caller owns the returned object. NULL is returned if no UnitDefinition
        object with the identifier exists in this Model object.
          

        """
        return _libsbml.Model_removeUnitDefinition(self, *args)

    def removeCompartmentType(self, *args):
        """
        removeCompartmentType(self, unsigned int n) -> CompartmentType
        removeCompartmentType(self, string sid) -> CompartmentType

        Removes the CompartmentType object with the given identifier from this Model
        object and returns a pointer to it.

        The caller owns the returned object and is responsible for deleting it.
        If none of the CompartmentType objects in this Model object have the identifier 
        @p sid, then @c NULL is returned.

        @param sid the identifier of the object to remove

        @return the CompartmentType object removed.  As mentioned above, the 
        caller owns the returned object. NULL is returned if no CompartmentType
        object with the identifier exists in this Model object.
          

        """
        return _libsbml.Model_removeCompartmentType(self, *args)

    def removeSpeciesType(self, *args):
        """
        removeSpeciesType(self, unsigned int n) -> SpeciesType
        removeSpeciesType(self, string sid) -> SpeciesType

        Removes the SpeciesType object with the given identifier from this Model
        object and returns a pointer to it.

        The caller owns the returned object and is responsible for deleting it.
        If none of the SpeciesType objects in this Model object have the identifier 
        @p sid, then @c NULL is returned.

        @param sid the identifier of the SpeciesType object to remove

        @return the SpeciesType object removed.  As mentioned above, the 
        caller owns the returned object. NULL is returned if no SpeciesType
        object with the identifier exists in this Model object.

          

        """
        return _libsbml.Model_removeSpeciesType(self, *args)

    def removeCompartment(self, *args):
        """
        removeCompartment(self, unsigned int n) -> Compartment
        removeCompartment(self, string sid) -> Compartment

        Removes the Compartment object with the given identifier from this Model
        object and returns a pointer to it.

        The caller owns the returned object and is responsible for deleting it.
        If none of the Compartment objects in this Model object have the identifier 
        @p sid, then @c NULL is returned.

        @param sid the identifier of the Compartment object to remove

        @return the Compartment object removed.  As mentioned above, the 
        caller owns the returned object. NULL is returned if no Compartment
        object with the identifier exists in this Model object.
          

        """
        return _libsbml.Model_removeCompartment(self, *args)

    def removeSpecies(self, *args):
        """
        removeSpecies(self, unsigned int n) -> Species
        removeSpecies(self, string sid) -> Species

        Removes the Species object with the given identifier from this Model
        object and returns a pointer to it.

        The caller owns the returned object and is responsible for deleting it.
        If none of the Species objects in this Model object have the identifier 
        @p sid, then @c NULL is returned.

        @param sid the identifier of the Species object to remove

        @return the Species object removed.  As mentioned above, the 
        caller owns the returned object. NULL is returned if no Species
        object with the identifier exists in this Model object.

          

        """
        return _libsbml.Model_removeSpecies(self, *args)

    def removeParameter(self, *args):
        """
        removeParameter(self, unsigned int n) -> Parameter
        removeParameter(self, string sid) -> Parameter

        Removes the Parameter object with the given identifier from this Model
        object and returns a pointer to it.

        The caller owns the returned object and is responsible for deleting it.
        If none of the Parameter objects in this Model object have the identifier 
        @p sid, then @c NULL is returned.

        @param sid the identifier of the Parameter object to remove

        @return the Parameter object removed.  As mentioned above, the 
        caller owns the returned object. NULL is returned if no Parameter
        object with the identifier exists in this Model object.
          

        """
        return _libsbml.Model_removeParameter(self, *args)

    def removeInitialAssignment(self, *args):
        """
        removeInitialAssignment(self, unsigned int n) -> InitialAssignment
        removeInitialAssignment(self, string symbol) -> InitialAssignment

        Removes the InitialAssignment object with the given 'symbol' attribute 
        from this Model object and returns a pointer to it.

        The caller owns the returned object and is responsible for deleting it.
        If none of the InitialAssignment objects in this Model object have the
        'symbol' attribute @p symbol, then @c NULL is returned.

        @param symbol the 'symbol' attribute of the InitialAssignment object to remove

        @return the InitialAssignment object removed.  As mentioned above, the 
        caller owns the returned object. NULL is returned if no InitialAssignment
        object with the 'symbol' attribute exists in this Model object.
          

        """
        return _libsbml.Model_removeInitialAssignment(self, *args)

    def removeRule(self, *args):
        """
        removeRule(self, unsigned int n) -> Rule
        removeRule(self, string variable) -> Rule

        Removes the Rule object with the given 'variable' attribute from this Model 
        object and returns a pointer to it.

        The caller owns the returned object and is responsible for deleting it.
        If none of the Rule objects in this Model object have the 'variable' attribute
        @p variable, then @c NULL is returned.

        @param variable the 'variable' attribute of the Rule object to remove

        @return the Rule object removed.  As mentioned above, the 
        caller owns the returned object. NULL is returned if no Rule
        object with the 'variable' attribute exists in this Model object.
          

        """
        return _libsbml.Model_removeRule(self, *args)

    def removeConstraint(self, *args):
        """
        removeConstraint(self, unsigned int n) -> Constraint

        Removes the nth Constraint object from this Model object and
        returns a pointer to it.

        The caller owns the returned object and is responsible for deleting it.

        @param n the index of the Constraint object to remove

        @return the Constraint object removed.  As mentioned above, 
        the caller owns the returned item. NULL is returned if the given index 
        is out of range.

          

        """
        return _libsbml.Model_removeConstraint(self, *args)

    def removeReaction(self, *args):
        """
        removeReaction(self, unsigned int n) -> Reaction
        removeReaction(self, string sid) -> Reaction

        Removes the Reaction object with the given identifier from this Model
        object and returns a pointer to it.

        The caller owns the returned object and is responsible for deleting it.
        If none of the Reaction objects in this Model object have the identifier 
        @p sid, then @c NULL is returned.

        @param sid the identifier of the Reaction object to remove

        @return the Reaction object removed.  As mentioned above, the 
        caller owns the returned object. NULL is returned if no Reaction
        object with the identifier exists in this Model object.

          

        """
        return _libsbml.Model_removeReaction(self, *args)

    def removeEvent(self, *args):
        """
        removeEvent(self, unsigned int n) -> Event
        removeEvent(self, string sid) -> Event

        Removes the Event object with the given identifier from this Model
        object and returns a pointer to it.

        The caller owns the returned object and is responsible for deleting it.
        If none of the Event objects in this Model object have the identifier 
        @p sid, then @c NULL is returned.

        @param sid the identifier of the Event object to remove

        @return the Event object removed.  As mentioned above, the 
        caller owns the returned object. NULL is returned if no Event
        object with the identifier exists in this Model object.

          

        """
        return _libsbml.Model_removeEvent(self, *args)

Model_swigregister = _libsbml.Model_swigregister
Model_swigregister(Model)

IdCheckON = _libsbml.IdCheckON
IdCheckOFF = _libsbml.IdCheckOFF
SBMLCheckON = _libsbml.SBMLCheckON
SBMLCheckOFF = _libsbml.SBMLCheckOFF
SBOCheckON = _libsbml.SBOCheckON
SBOCheckOFF = _libsbml.SBOCheckOFF
MathCheckON = _libsbml.MathCheckON
MathCheckOFF = _libsbml.MathCheckOFF
UnitsCheckON = _libsbml.UnitsCheckON
UnitsCheckOFF = _libsbml.UnitsCheckOFF
OverdeterCheckON = _libsbml.OverdeterCheckON
OverdeterCheckOFF = _libsbml.OverdeterCheckOFF
PracticeCheckON = _libsbml.PracticeCheckON
PracticeCheckOFF = _libsbml.PracticeCheckOFF
AllChecksON = _libsbml.AllChecksON
class SBMLDocument(SBase):
    """
    Container for an SBML document and interface for global operations
    on SBML documents.

    @if clike LibSBML uses the class SBMLDocument as a
    top-level container for storing SBML content and data associated with it
    (such as warnings and error messages).  The two primary means of reading
    an SBML model, SBMLReader::readSBML() and
    SBMLReader::readSBMLFromString(), both return a pointer to an
    SBMLDocument object.  From there, callers can inquire about any errors
    encountered (e.g., using SBMLDocument::getNumErrors()), access the Model
    object, and perform other actions such as consistency-checking and model
    translation. @endif@if java LibSBML uses the class
    SBMLDocument as a top-level container for storing SBML content and data
    associated with it (such as warnings and error messages).  The two
    primary means of reading an SBML model, SBMLReader::readSBML(String
    filename) and SBMLReader::readSBMLFromString(String xml), both return a
    pointer to an SBMLDocument object.  From there, callers can inquire
    about any errors encountered (e.g., using SBMLDocument::getNumErrors()),
    access the Model object, and perform other actions such as
    consistency-checking and model translation. @endif

    When creating fresh models programmatically, the starting point is
    typically the creation of an SBMLDocument object instance.  The
    SBMLDocument constructor accepts arguments for the SBML Level and
    Version of the model to be created.  After creating the SBMLDocument
    object, calling programs then typically call SBMLDocument::createModel()
    almost immediately, and then proceed to call the methods on the Model
    object to fill out the model's contents.

    SBMLDocument corresponds roughly to the class <i>Sbml</i> defined in the
    SBML Level&nbsp;2 specification.  It does not have a direct
    correspondence in SBML Level&nbsp;1.  (However, to make matters simpler
    for applications, libSBML creates an SBMLDocument no matter whether the model
    is Level&nbsp;1 or Level&nbsp;2.)  In its barest form, when written out
    in XML format for SBML Level&nbsp;2 Version&nbsp;4, the corresponding
    structure is the following:
      @verbatim
     <sbml xmlns='http://www.sbml.org/sbml/level2/version4' level='2' version='4'
       ...
     </sbml>
     @endverbatim

    SBMLDocument is derived from SBase, and therefore contains the usual SBase
    attributes (in SBML Level&nbsp;2 Version&nbsp;4) of 'metaid' and 'sboTerm', as
    well as the subelements 'notes' and 'annotation'.  It also contains the
    attributes 'level' and 'version' indicating the Level and Version of the
    SBML data structure.  These can be accessed using the methods defined by
    the SBase class for that purpose.

    @section checking Checking consistency and adherence to SBML specifications

    One of the most important features of libSBML is its ability to perform
    SBML validation to ensure that a model adheres to the SBML specification
    for whatever Level+Version combination the model uses.  SBMLDocument
    provides the methods for running consistency-checking and validation
    rules on the SBML content.

    First, a brief explanation of the rationale is in order.  In libSBML
    versions up to and including the version 3.3.x series, the individual
    methods for creating and setting attributes and other components are
    quite lenient, and allow a caller to compose SBML entities that may not,
    in the end, represent valid SBML.  This allows applications the freedom
    to do things such as save incomplete models (which is useful when models
    are being developed over long periods of time), but at the same time, it
    means that a separate validation step is necessary when a calling
    program finally wants to finish a complete SBML document.

    The primary interface to this facility is SBMLDocument's
    SBMLDocument::checkInternalConsistency() and
    SBMLDocument::checkConsistency().  The former verifies the basic
    internal consistency and syntax of an SBML document, and the latter
    implements more elaborate validation rules (both those defined by the
    SBML specifications, as well as additional rules offered by libSBML).

    @if clike The checks performed by
    SBMLDocument::checkInternalConsistency() are hardwired and cannot be
    changed by calling programs, but the validation performed by
    SBMLDocument::checkConsistency() is under program control using the
    method SBMLDocument::setConsistencyChecks().  Applications can
    selectively disable specific kinds of checks that they may not be
    interested in, by calling SBMLDocument::setConsistencyChecks() with
    appropriate parameters.  @endif@if java The checks
    performed by SBMLDocument::checkInternalConsistency() are hardwired and
    cannot be changed by calling programs, but the validation performed by
    SBMLDocument::checkConsistency() is under program control using the
    method SBMLDocument::setConsistencyChecks(int categ, boolean onoff).
    Applications can selectively disable specific kinds of checks that they
    may not be interested by calling SBMLDocument::setConsistencyChecks(int
    categ, boolean onoff) with appropriate parameters. @endif

    These methods have slightly different relevance depending on whether a
    model is created programmaticaly from scratch, or whether it is read in
    from a file or data stream.  The following table summarizes the possible
    scenarios.

    <center>
    <table border='0' class='text-table width80 normal-font alt-row-colors'>
     <tr style='background: lightgray; font-size: 14px;'>
         <th align='left' width='200'>Scenario</th>
         <th align='left'>Relevant methods</th>
     </tr>
    <tr><td>Creating a model from scratch</td>
    <td>Before writing out the model:<ol>

    <li style='margin-bottom: 0.5em'>Call
    SBMLDocument::checkInternalConsistency(), then inquire about the results by
    calling SBMLDocument::getNumErrors()</li>

    <li style='margin-bottom: 0.5em'>
    Call @if clike SBMLDocument::setConsistencyChecks() @endif@if java SBMLDocument::setConsistencyChecks(int categ, boolean onoff) @endif to configure which checks
    will be performed by SBMLDocument::checkConsistency()</li>

    <li>Call SBMLDocument::checkConsistency(), then inquire about the results by
    calling SBMLDocument::getNumErrors()</li>
    </ol>
    </td>
    <tr><td>Reading a model from a file or data stream</td>
    <td>After reading the model:<ol>

    <li style='margin-bottom: 0.5em'>Basic consistency checks will have been
    performed automatically by libSBML upon reading the content&mdash;only need
    to inquire about the results by using SBMLDocument::getNumErrors()</li>

    <li style='margin-bottom: 0.5em'>
    Call @if clike SBMLDocument::setConsistencyChecks() @endif@if java SBMLDocument::setConsistencyChecks(int categ, boolean onoff) @endif to configure which
    checks are performed by SBMLDocument::checkConsistency()</li>

    <li>Call SBMLDocument::checkConsistency(), then inquire about the results
    by calling SBMLDocument::getNumErrors()</li>
    </ol>
    </td>
    </table>
    </center>

    @if clike An example of using the consistency-checking
    and validation facilities is provided in this manual in the
    section @ref libsbml-example. @endif

    @section converting Converting documents between Levels and Versions of SBML

    LibSBML provides facilities for limited translation of SBML between
    Levels and Versions of the SBML specifications.  The method for doing is
    is @if clike SBMLDocument::setLevelAndVersion() @endif@if java SBMLDocument::setLevelAndVersion(long lev, long ver) @endif.  In 
    general, models can be converted upward without difficulty (e.g., from
    SBML Level&nbsp;1 to Level&nbsp;2, or from an earlier Version of
    Level&nbsp;2 to the latest Version of Level&nbsp;2).  Sometimes models
    can be translated downward as well, if they do not use constructs
    specific to more advanced Levels of SBML.

    Calling @if clike SBMLDocument::setLevelAndVersion() @endif@if java SBMLDocument::setLevelAndVersion(long lev, long ver) @endif will not @em necessarily lead
    to a successful conversion.  The method will return a boolean value
    to indicate success or failure.  Callers must check the error log (see 
    next section) attached to the SBMLDocument object after calling
    @if clike SBMLDocument::setLevelAndVersion() @endif@if java SBMLDocument::setLevelAndVersion(long lev, long ver) @endif in order to assess whether any
    problems arose.

    If an application is interested in translating to a lower Level and/or
    Version of SBML within a Level, the following methods allow for prior
    assessment of whether there is sufficient compatibility to make a
    translation possible:

    @li SBMLDocument::checkL1Compatibility(),
    @li SBMLDocument::checkL2v1Compatibility(),
    @li SBMLDocument::checkL2v2Compatibility(),
    @li SBMLDocument::checkL2v3Compatibility(), and
    @li SBMLDocument::checkL2v4Compatibility().

    Some changes between Versions of SBML Level&nbsp;2 may lead to
    unexpected behaviors when attempting conversions in either direction.
    For example, SBML Level&nbsp;2 Version&nbsp;4 relaxed the requirement
    for consistency in units of measurement between expressions annd
    quantities in a model.  As a result, a model written in Version&nbsp;4,
    if converted to Version&nbsp;3 with no other changes, may fail
    validation as a Version&nbsp;3 model because Version&nbsp;3 imposed
    stricter requirements on unit consistency.

    @section errors Error handling

    Upon reading a model, SBMLDocument logs any problems encountered while
    reading the model from the file or data stream.  The log contains
    objects that record diagnostic information about any notable issues that
    arose.  Whether the problems are warnings or errors, they are both
    reported through a single common interface involving the object class
    SBMLError.

    The methods SBMLDocument::getNumErrors(), @if clike SBMLDocument::getError() @endif@if java SBMLDocument::getError(long n) @endif and
    SBMLDocument::printErrors() allow callers to interact with the warnings
    or errors logged.  Alternatively, callers may retrieve the entire log as
    an SBMLErrorLog object using the method SBMLDocument::getErrorLog().
    The SBMLErrorLog object provides some alternative methods for
    interacting with the set of errors and warnings.  In either case,
    applications typically should first call SBMLDocument::getNumErrors() to
    find out if any issues have been logged after specific libSBML
    operations such as the ones discussed in the sections above.  If they
    have, then an application will should proceed to inspect the individual
    reports using either the direct interfaces on SBMLDocument or using the
    methods on the SBMLErrorLog object.

    @if clike An example of using the error facility is
    provided in this manual in the
    section @ref libsbml-example. @endif


    <hr style='margin: 1em auto'>

    """
    __swig_setmethods__ = {}
    for _s in [SBase]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLDocument, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SBMLDocument, name)
    __repr__ = _swig_repr
    def getDefaultLevel():
        """
        getDefaultLevel() -> unsigned int

        The default SBML Level of new SBMLDocument objects.

        This 'default level' corresponds to the most recent SBML specification
        Level available at the time this version of libSBML was released.  For
        this copy of libSBML, the value is <code>2</code>.  The default Level
        is used by SBMLDocument if no Level is explicitly specified at the
        time of the construction of an SBMLDocument instance. 

        @return an integer indicating the most recent SBML specification Level

        @see getDefaultVersion()
          

        """
        return _libsbml.SBMLDocument_getDefaultLevel()

    if _newclass:getDefaultLevel = staticmethod(getDefaultLevel)
    __swig_getmethods__["getDefaultLevel"] = lambda x: getDefaultLevel
    def getDefaultVersion():
        """
        getDefaultVersion() -> unsigned int

        The default Version of new SBMLDocument objects.

        This 'default version' corresponds to the most recent SBML Version
        within the most recent Level of SBML available at the time this
        version of libSBML was released.  For this copy of libSBML, the value
        is <code>4</code>.  The default Version is used by SBMLDocument if no
        Version is explicitly specified at the time of the construction of an
        SBMLDocument instance.

        @return an integer indicating the most recent SBML specification
        Version

        @see getDefaultLevel()
          

        """
        return _libsbml.SBMLDocument_getDefaultVersion()

    if _newclass:getDefaultVersion = staticmethod(getDefaultVersion)
    __swig_getmethods__["getDefaultVersion"] = lambda x: getDefaultVersion
    __swig_destroy__ = _libsbml.delete_SBMLDocument
    __del__ = lambda self : None;
    def __init__(self, *args): 
        """
        __init__(self, unsigned int level = 0, unsigned int version = 0) -> SBMLDocument
        __init__(self, unsigned int level = 0) -> SBMLDocument
        __init__(self) -> SBMLDocument
        __init__(self, SBMLDocument rhs) -> SBMLDocument

        Copy constructor; creates a copy of this SBMLDocument.
          

        """
        this = _libsbml.new_SBMLDocument(*args)
        try: self.this.append(this)
        except: self.this = this
    def clone(self):
        """
        clone(self) -> SBMLDocument

        Creates and returns a deep copy of this SBMLDocument.

        @return a (deep) copy of this SBMLDocument.
          

        """
        return _libsbml.SBMLDocument_clone(self)

    def getModel(self, *args):
        """
        getModel(self) -> Model
        getModel(self) -> Model

        Returns the Model object stored in this SBMLDocument.

        It is important to note that this method <em>does not create</em> a
        Model instance.  The model in the SBMLDocument must have been created
        at some prior time, for example using SBMLDocument::createModel() 
        or @if clike SBMLDocument::setModel() @endif@if java SBMLDocument::setModel(Model m) @endif.
        This method returns NULL if a model does not yet exist.

        @return the Model contained in this SBMLDocument.

        @see createModel()
          

        """
        return _libsbml.SBMLDocument_getModel(self, *args)

    def setLevelAndVersion(self, *args):
        """
        setLevelAndVersion(self, unsigned int level, unsigned int version, bool strict = True) -> bool
        setLevelAndVersion(self, unsigned int level, unsigned int version) -> bool

        Sets the SBML Level and Version of this SBMLDocument instance,
        attempting to convert the model as needed.

        This method is the principal way in libSBML to convert models between
        Levels and Versions of SBML.  Generally, models can be converted
        upward without difficulty (e.g., from SBML Level&nbsp;1 to
        Level&nbsp;2, or from an earlier Version of Level&nbsp;2 to the latest
        Version of Level&nbsp;2).  Sometimes models can be translated downward
        as well, if they do not use constructs specific to more advanced
        Levels of SBML.

        Before calling this method, callers may check compatibility directly
        using the methods SBMLDocument::checkL1Compatibility(),
        SBMLDocument::checkL2v1Compatibility(),
        SBMLDocument::checkL2v2Compatibility(),
        SBMLDocument::checkL2v3Compatibility() and
        SBMLDocument::checkL2v4Compatibility().

        The valid combinations of SBML Level and Version as of this release
        of libSBML are the following: 
        <ul>
        <li> Level&nbsp;1 Version&nbsp;2
        <li> Level&nbsp;2 Version&nbsp;1
        <li> Level&nbsp;2 Version&nbsp;2
        <li> Level&nbsp;2 Version&nbsp;3
        <li> Level&nbsp;2 Version&nbsp;4
        </ul>

        @param level the desired SBML Level
         
        @param version the desired Version within the SBML Level

        @param strict boolean indicating whether to check consistency
        of both the source and target model when performing
        conversion (defaults to <code> true </code>)

        @note Calling this method will not @em necessarily lead to a successful
        conversion.  If the conversion fails, it will be logged in the error
        list associated with this SBMLDocument.  Callers should consult
        getNumErrors() to find out if the conversion succeeded without
        problems.  For conversions from Level&nbsp;2 to Level&nbsp;1, callers
        can also check the Level of the model after calling this method to
        find out whether it is Level&nbsp;1.  (If the conversion to
        Level&nbsp;1 failed, the Level of this model will be left unchanged.)

        @see checkL1Compatibility()
        @see checkL2v1Compatibility()
        @see checkL2v2Compatibility()
        @see checkL2v3Compatibility()
        @see checkL2v4Compatibility()

        Strict conversion applies the additional criteria that both the source
        and the target model must be consistent SBML.  Users can control the
        consistency checks that are applied using the 
        SBMLDocument::setConsistencyChecksForConversion function.  If either 
        the source
        or the potential target model have validation errors, the conversion
        is not performed.  When a strict conversion is successful, the
        underlying SBML object model is altered to reflect the new level
        and version.  Thus information that cannot be converted (e.g. sboTerms)
        will be lost.   
          

        """
        return _libsbml.SBMLDocument_setLevelAndVersion(self, *args)

    def setModel(self, *args):
        """
        setModel(self, Model m) -> int

        Sets the Model for this SBMLDocument to a copy of the given Model.

        @param m the new Model to use.

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_LEVEL_MISMATCH
        @li LIBSBML_VERSION_MISMATCH

        @see createModel()
        @see getModel()
          

        """
        return _libsbml.SBMLDocument_setModel(self, *args)

    def createModel(self, sid = ""):
        """
        createModel(self, string sid = "") -> Model
        createModel(self) -> Model

        Creates a new Model inside this SBMLDocument, and returns a pointer to
        it.

        In SBML Level&nbsp;2, the use of an identifier on a Model object is
        optional.  This method takes an optional argument, @p sid, for setting
        the identifier.  If not supplied, the identifier attribute on the
        Model instance is not set.

        @param sid the identifier of the new Model to create.

        @docnote The native C++ implementation of this method defines a
        default argument value.  In the documentation generated for different
        libSBML language bindings, you may or may not see corresponding
        arguments in the method declarations.  For example, in Java, a default
        argument is handled by declaring two separate methods, with one of
        them having the argument and the other one lacking the argument.
        However, the libSBML documentation will be @em identical for both
        methods.  Consequently, if you are reading this and do not see an
        argument even though one is described, please look for descriptions of
        other variants of this method near where this one appears in the
        documentation.

        @see getModel()
        @see @if clike SBMLDocument::setModel() @endif@if java SBMLDocument::setModel(Model m) @endif
          

        """
        return _libsbml.SBMLDocument_createModel(self, sid)

    def setConsistencyChecks(self, *args):
        """
        setConsistencyChecks(self, SBMLErrorCategory_t category, bool apply)

        Controls the consistency checks that are performed when
        SBMLDocument::checkConsistency() is called.

        This method works by adding or subtracting consistency checks from the
        set of all possible checks that SBMLDocument::checkConsistency() knows
        how to perform.  This method may need to be called multiple times in
        order to achieve the desired combination of checks.  The first
        argument (@p category) in a call to this method indicates the category
        of consistency/error checks that are to be turned on or off, and the
        second argument (@p apply, a boolean) indicates whether to turn it on
        (value of @c true) or off (value of @c false).

        The possible categories (values to the argument @p category) are the
        set of values from the enumeration #SBMLErrorCategory_t.  The
        following are the possible choices in libSBML version&nbsp;3.3.x:

        @li @c LIBSBML_CAT_GENERAL_CONSISTENCY: Correctness and consistency of
        specific SBML language constructs.  Performing this set of checks is
        highly recommended.  With respect to the SBML specification, these
        concern failures in applying the validation rules numbered 2xxxx in
        the Level&nbsp;2 Versions&nbsp;2, 3 and&nbsp;4 specifications.

        @li @c LIBSBML_CAT_IDENTIFIER_CONSISTENCY: Correctness and consistency
        of identifiers used for model entities.  An example of inconsistency
        would be using a species identifier in a reaction rate formula without
        first having declared the species.  With respect to the SBML
        specification, these concern failures in applying the validation rules
        numbered 103xx in the Level&nbsp;2 Versions&nbsp;2, 3 and&nbsp;4
        specifications.

        @li @c LIBSBML_CAT_UNITS_CONSISTENCY: Consistency of measurement units
        associated with quantities in a model.  With respect to the SBML
        specification, these concern failures in applying the validation rules
        numbered 105xx in the Level&nbsp;2 Versions&nbsp;2, 3 and&nbsp;4
        specifications.

        @li @c LIBSBML_CAT_MATHML_CONSISTENCY: Syntax of MathML constructs.
        With respect to the SBML specification, these concern failures in
        applying the validation rules numbered 102xx in the Level&nbsp;2
        Versions&nbsp;2, 3 and&nbsp;4 specifications.

        @li @c LIBSBML_CAT_SBO_CONSISTENCY: Consistency and validity of SBO
        identifiers (if any) used in the model.  With respect to the SBML
        specification, these concern failures in applying the validation rules
        numbered 107xx in the Level&nbsp;2 Versions&nbsp;2, 3 and&nbsp;4
        specifications.

        @li @c LIBSBML_CAT_OVERDETERMINED_MODEL: Static analysis of
        whether the system of equations implied by a model is mathematically
        overdetermined.  With respect to the SBML specification, this is
        validation rule #10601 in the SBML Level&nbsp;2 Versions&nbsp;2, 3
        and&nbsp;4 specifications.

        @li @c LIBSBML_CAT_MODELING_PRACTICE: Additional checks for
        recommended good modeling practice. (These are tests performed by
        libSBML and do not have equivalent SBML validation rules.)

        <em>By default, all validation checks are applied</em> to the model in
        an SBMLDocument object @em unless @if clike SBMLDocument::setConsistencyChecks() @endif@if java SBMLDocument::setConsistencyChecks(int categ, boolean onoff) @endif is called to
        indicate that only a subset should be applied.  Further, this default
        (i.e., performing all checks) applies separately to <em>each new
        SBMLDocument object</em> created.  In other words, each time a model
        is read using @if clike SBMLReader::readSBML() @endif@if java SBMLReader::readSBML(String filename) @endif, @if clike SBMLReader::readSBMLFromString() @endif@if java SBMLReader::readSBMLFromString(String xml) @endif,
        or the global functions readSBML() and readSBMLFromString(), a new
        SBMLDocument is created and for that document, a call to
        SBMLDocument::checkConsistency() will default to applying all possible checks.
        Calling programs must invoke @if clike SBMLDocument::setConsistencyChecks() @endif@if java SBMLDocument::setConsistencyChecks(int categ, boolean onoff) @endif for each such new
        model if they wish to change the consistency checks applied.

        @param category a value drawn from #SBMLErrorCategory_t indicating the
        consistency checking/validation to be turned on or off

        @param apply a boolean indicating whether the checks indicated by
        @p category should be applied or not.

        @see SBMLDocument::checkConsistency()
          

        """
        return _libsbml.SBMLDocument_setConsistencyChecks(self, *args)

    def setConsistencyChecksForConversion(self, *args):
        """
        setConsistencyChecksForConversion(self, SBMLErrorCategory_t category, bool apply)

        Controls the consistency checks that are performed when
        SBMLDocument::setLevelAndVersion(level, version) is called.

        This method works by adding or subtracting consistency checks from the
        set of all possible checks that may be performed to avoid conversion
        to or from an invalid document.  This method may need to be called 
        multiple times in
        order to achieve the desired combination of checks.  The first
        argument (@p category) in a call to this method indicates the category
        of consistency/error checks that are to be turned on or off, and the
        second argument (@p apply, a boolean) indicates whether to turn it on
        (value of @c true) or off (value of @c false).

        The possible categories (values to the argument @p category) are the
        set of values from the enumeration #SBMLErrorCategory_t.  The
        following are the possible choices in libSBML version&nbsp;4.x.x:

        @li @c LIBSBML_CAT_GENERAL_CONSISTENCY: Correctness and consistency of
        specific SBML language constructs.  Performing this set of checks is
        highly recommended.  With respect to the SBML specification, these
        concern failures in applying the validation rules numbered 2xxxx in
        the Level&nbsp;2 Versions&nbsp;2, 3 and&nbsp;4 specifications.

        @li @c LIBSBML_CAT_IDENTIFIER_CONSISTENCY: Correctness and consistency
        of identifiers used for model entities.  An example of inconsistency
        would be using a species identifier in a reaction rate formula without
        first having declared the species.  With respect to the SBML
        specification, these concern failures in applying the validation rules
        numbered 103xx in the Level&nbsp;2 Versions&nbsp;2, 3 and&nbsp;4
        specifications.

        @li @c LIBSBML_CAT_UNITS_CONSISTENCY: Consistency of measurement units
        associated with quantities in a model.  With respect to the SBML
        specification, these concern failures in applying the validation rules
        numbered 105xx in the Level&nbsp;2 Versions&nbsp;2, 3 and&nbsp;4
        specifications.

        @li @c LIBSBML_CAT_MATHML_CONSISTENCY: Syntax of MathML constructs.
        With respect to the SBML specification, these concern failures in
        applying the validation rules numbered 102xx in the Level&nbsp;2
        Versions&nbsp;2, 3 and&nbsp;4 specifications.

        @li @c LIBSBML_CAT_SBO_CONSISTENCY: Consistency and validity of SBO
        identifiers (if any) used in the model.  With respect to the SBML
        specification, these concern failures in applying the validation rules
        numbered 107xx in the Level&nbsp;2 Versions&nbsp;2, 3 and&nbsp;4
        specifications.

        @li @c LIBSBML_CAT_OVERDETERMINED_MODEL: Static analysis of
        whether the system of equations implied by a model is mathematically
        overdetermined.  With respect to the SBML specification, this is
        validation rule #10601 in the SBML Level&nbsp;2 Versions&nbsp;2, 3
        and&nbsp;4 specifications.

        @li @c LIBSBML_CAT_MODELING_PRACTICE: Additional checks for
        recommended good modeling practice. (These are tests performed by
        libSBML and do not have equivalent SBML validation rules.)

        <em>By default, all validation checks are applied</em> to the model in
        an SBMLDocument object @em unless @if clike SBMLDocument::setConsistencyChecks() @endif@if java SBMLDocument::setConsistencyChecks(int categ, boolean onoff) @endif is called to
        indicate that only a subset should be applied.  Further, this default
        (i.e., performing all checks) applies separately to <em>each new
        SBMLDocument object</em> created.  In other words, each time a model
        is read using @if clike SBMLReader::readSBML() @endif@if java SBMLReader::readSBML(String filename) @endif, @if clike SBMLReader::readSBMLFromString() @endif@if java SBMLReader::readSBMLFromString(String xml) @endif,
        or the global functions readSBML() and readSBMLFromString(), a new
        SBMLDocument is created and for that document, a call to
        SBMLDocument::checkConsistency() will default to applying all possible checks.
        Calling programs must invoke @if clike SBMLDocument::setConsistencyChecks() @endif@if java SBMLDocument::setConsistencyChecks(int categ, boolean onoff) @endif for each such new
        model if they wish to change the consistency checks applied.

        @param category a value drawn from #SBMLErrorCategory_t indicating the
        consistency checking/validation to be turned on or off

        @param apply a boolean indicating whether the checks indicated by
        @p category should be applied or not.

        @see SBMLDocument::setLevelAndVersion()
          

        """
        return _libsbml.SBMLDocument_setConsistencyChecksForConversion(self, *args)

    def checkConsistency(self):
        """
        checkConsistency(self) -> unsigned int

        Performs consistency checking and validation on this SBML document.

        If this method returns a nonzero value (meaning, one or more
        consistency checks have failed for SBML document), the failures may be
        due to warnings @em or errors.  Callers should inspect the severity
        flag in the individual SBMLError objects returned by
        @if clike SBMLDocument::getError() @endif@if java SBMLDocument::getError(long n) @endif to determine the nature of the failures.

        @return the number of failed checks (errors) encountered.

        @see SBMLDocument::checkInternalConsistency()
          

        """
        return _libsbml.SBMLDocument_checkConsistency(self)

    def checkInternalConsistency(self):
        """
        checkInternalConsistency(self) -> unsigned int

        Performs consistency checking on libSBML's internal representation of 
        an SBML Model.

        Callers should query the results of the consistency check by calling
        @if clike SBMLDocument::getError() @endif@if java SBMLDocument::getError(long n) @endif.

        @return the number of failed checks (errors) encountered.

        The distinction between this method and
        SBMLDocument::checkConsistency() is that this method reports on
        fundamental syntactic and structural errors that violate the XML
        Schema for SBML; by contrast, SBMLDocument::checkConsistency()
        performs more elaborate model verifications and also validation
        according to the validation rules written in the appendices of the
        SBML Level&nbsp;2 Versions&nbsp;2&ndash;4 specification documents.

        @see SBMLDocument::checkConsistency()
          

        """
        return _libsbml.SBMLDocument_checkInternalConsistency(self)

    def checkL1Compatibility(self):
        """
        checkL1Compatibility(self) -> unsigned int

        Performs a set of consistency checks on the document to establish
        whether it is compatible with SBML Level&nbsp;1 and can be converted
        to Level&nbsp;1.

        Callers should query the results of the consistency check by calling
        @if clike SBMLDocument::getError() @endif@if java SBMLDocument::getError(long n) @endif.

        @return the number of failed checks (errors) encountered.
          

        """
        return _libsbml.SBMLDocument_checkL1Compatibility(self)

    def checkL2v1Compatibility(self):
        """
        checkL2v1Compatibility(self) -> unsigned int

        Performs a set of consistency checks on the document to establish
        whether it is compatible with SBML Level&nbsp;2 Version&nbsp;1 and can
        be converted to Level&nbsp;2 Version&nbsp;1.

        Callers should query the results of the consistency check by calling
        @if clike SBMLDocument::getError() @endif@if java SBMLDocument::getError(long n) @endif.

        @return the number of failed checks (errors) encountered.
          

        """
        return _libsbml.SBMLDocument_checkL2v1Compatibility(self)

    def checkL2v2Compatibility(self):
        """
        checkL2v2Compatibility(self) -> unsigned int

        Performs a set of consistency checks on the document to establish
        whether it is compatible with SBML Level&nbsp;2 Version&nbsp;2 and can
        be converted to Level&nbsp;2 Version&nbsp;2.

        Callers should query the results of the consistency check by calling
        @if clike SBMLDocument::getError() @endif@if java SBMLDocument::getError(long n) @endif.

        @return the number of failed checks (errors) encountered.
          

        """
        return _libsbml.SBMLDocument_checkL2v2Compatibility(self)

    def checkL2v3Compatibility(self):
        """
        checkL2v3Compatibility(self) -> unsigned int

        Performs a set of consistency checks on the document to establish
        whether it is compatible with SBML Level&nbsp;2 Version&nbsp;3 and can
        be converted to Level&nbsp;2 Version&nbsp;3.

        Callers should query the results of the consistency check by calling
        @if clike SBMLDocument::getError() @endif@if java SBMLDocument::getError(long n) @endif.

        @return the number of failed checks (errors) encountered.
          

        """
        return _libsbml.SBMLDocument_checkL2v3Compatibility(self)

    def checkL2v4Compatibility(self):
        """
        checkL2v4Compatibility(self) -> unsigned int

        Performs a set of consistency checks on the document to establish
        whether it is compatible with SBML Level&nbsp;2 Version&nbsp;4 and can
        be converted to Level&nbsp;2 Version&nbsp;4.

        Callers should query the results of the consistency check by calling
        @if clike SBMLDocument::getError() @endif@if java SBMLDocument::getError(long n) @endif.

        @return the number of failed checks (errors) encountered.
          

        """
        return _libsbml.SBMLDocument_checkL2v4Compatibility(self)

    def getError(self, *args):
        """
        getError(self, unsigned int n) -> SBMLError

        Returns the nth error or warning encountered during parsing,
        consistency checking, or attempted translation of this model.

        Callers can use method XMLError::getSeverity() on the result to assess
        the severity of the problem.  The possible severity levels range from
        informational messages to fatal errors.

        @return the error or warning indexed by integer @p n, or return @c
        NULL if <code>n &gt; (getNumErrors() - 1)</code>.

        @param n the integer index of the error sought.

        @see SBMLDocument::getNumErrors()
          

        """
        return _libsbml.SBMLDocument_getError(self, *args)

    def getNumErrors(self):
        """
        getNumErrors(self) -> unsigned int

        Returns the number of errors or warnings encountered during parsing,
        consistency checking, or attempted translation of this model.

        @return the number of errors or warnings encountered
          

        """
        return _libsbml.SBMLDocument_getNumErrors(self)

    def printErrors(self, *args):
        """
        printErrors(self, ostream stream = cerr)
        printErrors(self)

        Prints to the given output stream all the errors or warnings
        encountered during parsing, consistency checking, or attempted
        translation of this model.

        If no errors have occurred, i.e., <code>getNumErrors() == 0</code>, no
        output will be sent to the stream.

        The format of the output is:
          @verbatim
            N error(s):
              line NNN: (id) message
         @endverbatim

        @docnote The native C++ implementation of this method defines a
        default argument value.  In the documentation generated for different
        libSBML language bindings, you may or may not see corresponding
        arguments in the method declarations.  For example, in Java, a default
        argument is handled by declaring two separate methods, with one of
        them having the argument and the other one lacking the argument.
        However, the libSBML documentation will be @em identical for both
        methods.  Consequently, if you are reading this and do not see an
        argument even though one is described, please look for descriptions of
        other variants of this method near where this one appears in the
        documentation.
          

        """
        return _libsbml.SBMLDocument_printErrors(self, *args)

    def getTypeCode(self):
        """
        getTypeCode(self) -> SBMLTypeCode_t

        Returns the libSBML type code for this %SBML object.

        @if clike LibSBML attaches an identifying code to every
        kind of SBML object.  These are known as <em>SBML type codes</em>.
        The set of possible type codes is defined in the enumeration
        #SBMLTypeCode_t.  The names of the type codes all begin with the
        characters @c SBML_. @endif@if java LibSBML attaches an
        identifying code to every kind of SBML object.  These are known as
        <em>SBML type codes</em>.  In other languages, the set of type codes
        is stored in an enumeration; in the Java language interface for
        libSBML, the type codes are defined as static integer constants in
        interface class {@link libsbmlConstants}.  The names of the type codes
        all begin with the characters @c SBML_. @endif

        @return the SBML type code for this object, or @c SBML_UNKNOWN (default).

        @see SBMLDocument::getElementName()
          

        """
        return _libsbml.SBMLDocument_getTypeCode(self)

    def getElementName(self):
        """
        getElementName(self) -> string

        Returns the XML element name of this object, which for SBMLDocument,
        is always @c 'sbml'.

        @return the name of this element, i.e., @c 'sbml'.
          

        """
        return _libsbml.SBMLDocument_getElementName(self)

    def getErrorLog(self):
        """
        getErrorLog(self) -> SBMLErrorLog

        Returns the list of errors or warnings logged during parsing, 
        consistency checking, or attempted translation of this model.

        @return the SBMLErrorLog used for this SBMLDocument

        @see SBMLDocument::getNumErrors()
          

        """
        return _libsbml.SBMLDocument_getErrorLog(self)

    def getNamespaces(self):
        """
        getNamespaces(self) -> XMLNamespaces

        Returns a list of XML Namespaces associated with the XML content
        of this SBML document.

        @return the XML Namespaces associated with this SBML object
          

        """
        return _libsbml.SBMLDocument_getNamespaces(self)

SBMLDocument_swigregister = _libsbml.SBMLDocument_swigregister
SBMLDocument_swigregister(SBMLDocument)

def SBMLDocument_getDefaultLevel():
  """
    SBMLDocument_getDefaultLevel() -> unsigned int

    The default SBML Level of new SBMLDocument objects.

    This 'default level' corresponds to the most recent SBML specification
    Level available at the time this version of libSBML was released.  For
    this copy of libSBML, the value is <code>2</code>.  The default Level
    is used by SBMLDocument if no Level is explicitly specified at the
    time of the construction of an SBMLDocument instance. 

    @return an integer indicating the most recent SBML specification Level

    @see getDefaultVersion()
      

    """
  return _libsbml.SBMLDocument_getDefaultLevel()

def SBMLDocument_getDefaultVersion():
  """
    SBMLDocument_getDefaultVersion() -> unsigned int

    The default Version of new SBMLDocument objects.

    This 'default version' corresponds to the most recent SBML Version
    within the most recent Level of SBML available at the time this
    version of libSBML was released.  For this copy of libSBML, the value
    is <code>4</code>.  The default Version is used by SBMLDocument if no
    Version is explicitly specified at the time of the construction of an
    SBMLDocument instance.

    @return an integer indicating the most recent SBML specification
    Version

    @see getDefaultLevel()
      

    """
  return _libsbml.SBMLDocument_getDefaultVersion()

class FunctionDefinition(SBase):
    """
    LibSBML implementation of %SBML's %FunctionDefinition construct.

    The FunctionDefinition structure associates an identifier with a
    function definition.  This identifier can then be used as the function
    called in subsequent MathML content elsewhere in an SBML model.

    FunctionDefinition has one required attribute, 'id', to give the
    function a unique identifier by which other parts of an SBML model
    definition can refer to it.  A FunctionDefinition instance can also have
    an optional 'name' attribute of type @c string.  Identifiers and names
    must be used according to the guidelines described in the %SBML
    specification (e.g., Section 3.3 in the Level 2 Version 4
    specification).

    FunctionDefinition has a required 'math' subelement containing a MathML
    expression defining the function body.  The content of this element can
    only be a MathML 'lambda' element.  The 'lambda' element must begin with
    zero or more 'bvar' elements, followed by any other of the elements in
    the MathML subset allowed in SBML Level 2 @em except 'lambda' (i.e., a
    'lambda' element cannot contain another 'lambda' element).  This is the
    only place in SBML where a 'lambda' element can be used.  The function
    defined by a FunctionDefinition is only available for use in other
    MathML elements that @em follow the FunctionDefinition definition in the
    model.  (These restrictions prevent recursive and mutually-recursive
    functions from being expressed.)

    A further restriction on the content of 'math' is that it cannot contain
    references to variables other than the variables declared to the
    'lambda' itself.  That is, the contents of MathML 'ci' elements inside
    the body of the 'lambda' can only be the variables declared by its
    'bvar' elements, or the identifiers of other FunctionDefinition
    instances earlier in the model.  This means must be written so that all
    variables or parameters used in the MathML content are passed to them
    via their function parameters.

    @note Function definitions (also informally known as user-defined
    functions) were introduced in SBML Level 2.  They have purposefully
    limited capabilities.  A function cannot reference parameters or other
    model quantities outside of itself; values must be passed as parameters
    to the function.  Moreover, recursive and mutually-recursive functions
    are not permitted.  The purpose of these limitations is to balance power
    against complexity of implementation.  With the restrictions as they
    are, function definitions could be implemented as textual
    substitutions&mdash;they are simply macros.  Software implementations
    therefore do not need the full function-definition machinery typically
    associated with programming languages.

    @note Another important point to note is FunctionDefinition does not
    have a separate attribute for defining the units of the value returned
    by the function.  The units associated with the function's return value,
    when the function is called from within MathML expressions elsewhere in
    SBML, are simply the overall units of the expression in
    FunctionDefinition's 'math' subelement when applied to the arguments
    supplied in the call to the function.  Ascertaining these units requires
    performing dimensional analysis on the expression.  (Readers may wonder
    why there is no attribute.  The reason is that having a separate
    attribute for declaring the units would not only be redundant, but also
    lead to the potential for having conflicting information.  In the case
    of a conflict between the declared units and those of the value actually
    returned by the function, the only logical resolution rule would be to
    assume that the correct units are those of the expression anyway.)

    <!---------------------------------------------------------------------- -->


    """
    __swig_setmethods__ = {}
    for _s in [SBase]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FunctionDefinition, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FunctionDefinition, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_FunctionDefinition
    __del__ = lambda self : None;
    def __init__(self, *args): 
        """
        __init__(self, unsigned int level, unsigned int version) -> FunctionDefinition
        __init__(self, SBMLNamespaces sbmlns) -> FunctionDefinition
        __init__(self, FunctionDefinition orig) -> FunctionDefinition

        Predicate returning @c true or @c false depending on whether
        all the required elements for this FunctionDefinition object
        have been set.

        @note The required elements for a FunctionDefinition object are:
        math

        @return a boolean value indicating whether all the required
        elements for this object have been defined.
        @deprecated libSBML internal


        """
        this = _libsbml.new_FunctionDefinition(*args)
        try: self.this.append(this)
        except: self.this = this
    def clone(self):
        """
        clone(self) -> FunctionDefinition

        Creates and returns a deep copy of this FunctionDefinition.

        @return a (deep) copy of this FunctionDefinition.
          

        """
        return _libsbml.FunctionDefinition_clone(self)

    def getId(self):
        """
        getId(self) -> string

        Returns the value of the 'id' attribute of this FunctionDefinition.

        @return the id of this FunctionDefinition.
          

        """
        return _libsbml.FunctionDefinition_getId(self)

    def getName(self):
        """
        getName(self) -> string

        Returns the value of the 'name' attribute of this FunctionDefinition.

        @return the name of this FunctionDefinition.
          

        """
        return _libsbml.FunctionDefinition_getName(self)

    def getMath(self):
        """
        getMath(self) -> ASTNode

        Get the mathematical formula of this FunctionDefinition.

        @return an ASTNode, the value of the 'math' subelement of this
        FunctionDefinition
          

        """
        return _libsbml.FunctionDefinition_getMath(self)

    def isSetId(self):
        """
        isSetId(self) -> bool

        Predicate returning @c true or @c false depending on whether this
        FunctionDefinition's 'id' attribute has been set.

        @htmlinclude libsbml-comment-set-methods.html

        @return @c true if the 'id' attribute of this FunctionDefinition has been
        set, @c false otherwise.
          

        """
        return _libsbml.FunctionDefinition_isSetId(self)

    def isSetName(self):
        """
        isSetName(self) -> bool

        Predicate returning @c true or @c false depending on whether this
        FunctionDefinition's 'name' attribute has been set.

        @htmlinclude libsbml-comment-set-methods.html

        @return @c true if the 'name' attribute of this FunctionDefinition has been
        set, @c false otherwise.
          

        """
        return _libsbml.FunctionDefinition_isSetName(self)

    def isSetMath(self):
        """
        isSetMath(self) -> bool

        Predicate returning @c true or @c false depending on whether this
        FunctionDefinition's 'math' subelement contains a value.

        @return @c true if the 'math' for this FunctionDefinition has been set,
        @c false otherwise.
          

        """
        return _libsbml.FunctionDefinition_isSetMath(self)

    def setId(self, *args):
        """
        setId(self, string sid) -> int

        Sets the value of the 'id' attribute of this FunctionDefinition.

        The string @p sid is copied.  Note that SBML has strict requirements
        for the syntax of identifiers.  The following is summary of the
        definition of the SBML identifier type @c SId (here expressed in an
        extended form of BNF notation):
        @code
          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*
        @endcode
        The equality of SBML identifiers is determined by an exact character
        sequence match; i.e., comparisons must be performed in a
        case-sensitive manner.  In addition, there are a few conditions for
        the uniqueness of identifiers in an SBML model.  Please consult the
        SBML specifications for the exact formulations.

        @htmlinclude libsbml-comment-set-methods.html

        @param sid the string to use as the identifier of this FunctionDefinition

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_INVALID_ATTRIBUTE_VALUE
          

        """
        return _libsbml.FunctionDefinition_setId(self, *args)

    def setName(self, *args):
        """
        setName(self, string name) -> int

        Sets the value of the 'name' attribute of this FunctionDefinition.

        The string in @p name is copied.

        @htmlinclude libsbml-comment-set-methods.html

        @param name the new name for the FunctionDefinition

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_INVALID_ATTRIBUTE_VALUE
          

        """
        return _libsbml.FunctionDefinition_setName(self, *args)

    def setMath(self, *args):
        """
        setMath(self, ASTNode math) -> int

        Sets the 'math' subelement of this FunctionDefinition to the Abstract
        Syntax Tree given in @p math.

        @param math an AST containing the mathematical expression to
        be used as the formula for this FunctionDefinition.

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_INVALID_OBJECT
          

        """
        return _libsbml.FunctionDefinition_setMath(self, *args)

    def unsetName(self):
        """
        unsetName(self) -> int

        Unsets the value of the 'name' attribute of this FunctionDefinition.

        @htmlinclude libsbml-comment-set-methods.html

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_OPERATION_FAILED
          

        """
        return _libsbml.FunctionDefinition_unsetName(self)

    def getArgument(self, *args):
        """
        getArgument(self, unsigned int n) -> ASTNode
        getArgument(self, string name) -> ASTNode

        Get the argument named @p name to this FunctionDefinition.

        @param name the exact name (case-sensitive) of the sought-after
        argument

        @return the argument (bound variable) having the given name, or NULL if
        no such argument exists.
          

        """
        return _libsbml.FunctionDefinition_getArgument(self, *args)

    def getBody(self, *args):
        """
        getBody(self) -> ASTNode
        getBody(self) -> ASTNode

        Get the mathematical expression that is the body of this
        FunctionDefinition object.

        @return the body of this FunctionDefinition as an Abstract Syntax
        Tree, or NULL if no body is defined.
          

        """
        return _libsbml.FunctionDefinition_getBody(self, *args)

    def getNumArguments(self):
        """
        getNumArguments(self) -> unsigned int

        Get the number of arguments (bound variables) taken by this
        FunctionDefinition.

        @return the number of arguments (bound variables) that must be passed
        to this FunctionDefinition.
          

        """
        return _libsbml.FunctionDefinition_getNumArguments(self)

    def getTypeCode(self):
        """
        getTypeCode(self) -> SBMLTypeCode_t

        Returns the libSBML type code for this %SBML object.

        @if clike LibSBML attaches an identifying code to every
        kind of SBML object.  These are known as <em>SBML type codes</em>.
        The set of possible type codes is defined in the enumeration
        #SBMLTypeCode_t.  The names of the type codes all begin with the
        characters @c SBML_. @endif@if java LibSBML attaches an
        identifying code to every kind of SBML object.  These are known as
        <em>SBML type codes</em>.  In other languages, the set of type codes
        is stored in an enumeration; in the Java language interface for
        libSBML, the type codes are defined as static integer constants in
        interface class {@link libsbmlConstants}.  The names of the type codes
        all begin with the characters @c SBML_. @endif

        @return the SBML type code for this object, or @c SBML_UNKNOWN (default).

        @see getElementName()
          

        """
        return _libsbml.FunctionDefinition_getTypeCode(self)

    def getElementName(self):
        """
        getElementName(self) -> string

        Returns the XML element name of this object, which for
        FunctionDefinition, is always @c 'functionDefinition'.

        @return the name of this element, i.e., @c 'functionDefinition'.
          

        """
        return _libsbml.FunctionDefinition_getElementName(self)

    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(self) -> bool

        Predicate returning @c true or @c false depending on whether
        all the required attributes for this FunctionDefinition object
        have been set.

        @note The required attributes for a FunctionDefinition object are:
        id

        @return a boolean value indicating whether all the required
        attributes for this object have been defined.
          

        """
        return _libsbml.FunctionDefinition_hasRequiredAttributes(self)

    def hasRequiredElements(self):
        """
        hasRequiredElements(self) -> bool

        Predicate returning @c true or @c false depending on whether
        all the required elements for this FunctionDefinition object
        have been set.

        @note The required elements for a FunctionDefinition object are:
        math

        @return a boolean value indicating whether all the required
        elements for this object have been defined.
          

        """
        return _libsbml.FunctionDefinition_hasRequiredElements(self)

FunctionDefinition_swigregister = _libsbml.FunctionDefinition_swigregister
FunctionDefinition_swigregister(FunctionDefinition)

class ListOfFunctionDefinitions(ListOf):
    """
    LibSBML implementation of SBML's %ListOfFunctionDefinitions construct.

    The various ListOf___ classes in %SBML are merely containers used for
    organizing the main components of an %SBML model.  All are derived from
    the abstract class SBase, and inherit the various attributes and
    subelements of SBase, such as 'metaid' as and 'annotation'.  The
    ListOf___ classes do not add any attributes of their own.

    The relationship between the lists and the rest of an %SBML model is
    illustrated by the following (for %SBML Level&nbsp;2 Version&nbsp;4):

    @image html listof-illustration.jpg 'ListOf___ elements in an SBML Model'
    @image latex listof-illustration.jpg 'ListOf___ elements in an SBML Model'

    Readers may wonder about the motivations for using the ListOf___
    containers.  A simpler approach in XML might be to place the components
    all directly at the top level of the model definition.  We chose instead
    to group them within XML elements named after ListOf<em>Classname</em>,
    in part because we believe this helps organize the components and makes
    visual reading of models in XML easier.  More importantly, the fact that
    the container classes are derived from SBase means that software tools
    can add information about the lists themselves into each list
    container's 'annotation'.

    @see ListOfFunctionDefinitions
    @see ListOfUnitDefinitions
    @see ListOfCompartmentTypes
    @see ListOfSpeciesTypes
    @see ListOfCompartments
    @see ListOfSpecies
    @see ListOfParameters
    @see ListOfInitialAssignments
    @see ListOfRules
    @see ListOfConstraints
    @see ListOfReactions
    @see ListOfEvents

    """
    __swig_setmethods__ = {}
    for _s in [ListOf]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfFunctionDefinitions, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfFunctionDefinitions, name)
    __repr__ = _swig_repr
    def clone(self):
        """
        clone(self) -> ListOfFunctionDefinitions

        Creates and returns a deep copy of this ListOfFunctionDefinitions instance.

        @return a (deep) copy of this ListOfFunctionDefinitions.
          

        """
        return _libsbml.ListOfFunctionDefinitions_clone(self)

    def getTypeCode(self):
        """
        getTypeCode(self) -> SBMLTypeCode_t

        Returns the libSBML type code for this %SBML object.

        @if clike LibSBML attaches an identifying code to every
        kind of SBML object.  These are known as <em>SBML type codes</em>.
        The set of possible type codes is defined in the enumeration
        #SBMLTypeCode_t.  The names of the type codes all begin with the
        characters @c SBML_. @endif@if java LibSBML attaches an
        identifying code to every kind of SBML object.  These are known as
        <em>SBML type codes</em>.  In other languages, the set of type codes
        is stored in an enumeration; in the Java language interface for
        libSBML, the type codes are defined as static integer constants in
        interface class {@link libsbmlConstants}.  The names of the type codes
        all begin with the characters @c SBML_. @endif

        @return the SBML type code for this object, or @c SBML_UNKNOWN (default).

        @see getElementName()
          

        """
        return _libsbml.ListOfFunctionDefinitions_getTypeCode(self)

    def getItemTypeCode(self):
        """
        getItemTypeCode(self) -> SBMLTypeCode_t

        Returns the libSBML type code for the objects contained in this ListOf
        (i.e., FunctionDefinition objects, if the list is non-empty).

        @if clike LibSBML attaches an identifying code to every
        kind of SBML object.  These are known as <em>SBML type codes</em>.
        The set of possible type codes is defined in the enumeration
        #SBMLTypeCode_t.  The names of the type codes all begin with the
        characters @c SBML_. @endif@if java LibSBML attaches an
        identifying code to every kind of SBML object.  These are known as
        <em>SBML type codes</em>.  In other languages, the set of type codes
        is stored in an enumeration; in the Java language interface for
        libSBML, the type codes are defined as static integer constants in
        interface class {@link libsbmlConstants}.  The names of the type codes
        all begin with the characters @c SBML_. @endif

        @return the SBML type code for the objects contained in this ListOf
        instance, or @c SBML_UNKNOWN (default).

        @see getElementName()
          

        """
        return _libsbml.ListOfFunctionDefinitions_getItemTypeCode(self)

    def getElementName(self):
        """
        getElementName(self) -> string

        Returns the XML element name of this object.

        For ListOfFunctionDefinitions, the XML element name is @c
        'listOfFunctionDefinitions'.

        @return the name of this element, i.e., @c 'listOfFunctionDefinitions'.
          

        """
        return _libsbml.ListOfFunctionDefinitions_getElementName(self)

    def get(self, *args):
        """
        get(self, unsigned int n) -> FunctionDefinition
        get(self, unsigned int n) -> FunctionDefinition
        get(self, string sid) -> FunctionDefinition
        get(self, string sid) -> FunctionDefinition

        Get a FunctionDefinition from the ListOfFunctionDefinitions
        based on its identifier.

        @param sid a string representing the identifier 
        of the FunctionDefinition to get.

        @return FunctionDefinition in this ListOfFunctionDefinitions
        with the given id or NULL if no such
        FunctionDefinition exists.

        @see get(unsigned int n)
        @see size()
          

        """
        return _libsbml.ListOfFunctionDefinitions_get(self, *args)

    def remove(self, *args):
        """
        remove(self, unsigned int n) -> FunctionDefinition
        remove(self, string sid) -> FunctionDefinition

        Removes item in this ListOfFunctionDefinitions items with the given identifier.

        The caller owns the returned item and is responsible for deleting it.
        If none of the items in this list have the identifier @p sid, then @c
        NULL is returned.

        @param sid the identifier of the item to remove

        @return the item removed.  As mentioned above, the caller owns the
        returned item.
          

        """
        return _libsbml.ListOfFunctionDefinitions_remove(self, *args)

    def __init__(self): 
        """__init__(self) -> ListOfFunctionDefinitions"""
        this = _libsbml.new_ListOfFunctionDefinitions()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _libsbml.delete_ListOfFunctionDefinitions
    __del__ = lambda self : None;
ListOfFunctionDefinitions_swigregister = _libsbml.ListOfFunctionDefinitions_swigregister
ListOfFunctionDefinitions_swigregister(ListOfFunctionDefinitions)

UNIT_KIND_AMPERE = _libsbml.UNIT_KIND_AMPERE
UNIT_KIND_BECQUEREL = _libsbml.UNIT_KIND_BECQUEREL
UNIT_KIND_CANDELA = _libsbml.UNIT_KIND_CANDELA
UNIT_KIND_CELSIUS = _libsbml.UNIT_KIND_CELSIUS
UNIT_KIND_COULOMB = _libsbml.UNIT_KIND_COULOMB
UNIT_KIND_DIMENSIONLESS = _libsbml.UNIT_KIND_DIMENSIONLESS
UNIT_KIND_FARAD = _libsbml.UNIT_KIND_FARAD
UNIT_KIND_GRAM = _libsbml.UNIT_KIND_GRAM
UNIT_KIND_GRAY = _libsbml.UNIT_KIND_GRAY
UNIT_KIND_HENRY = _libsbml.UNIT_KIND_HENRY
UNIT_KIND_HERTZ = _libsbml.UNIT_KIND_HERTZ
UNIT_KIND_ITEM = _libsbml.UNIT_KIND_ITEM
UNIT_KIND_JOULE = _libsbml.UNIT_KIND_JOULE
UNIT_KIND_KATAL = _libsbml.UNIT_KIND_KATAL
UNIT_KIND_KELVIN = _libsbml.UNIT_KIND_KELVIN
UNIT_KIND_KILOGRAM = _libsbml.UNIT_KIND_KILOGRAM
UNIT_KIND_LITER = _libsbml.UNIT_KIND_LITER
UNIT_KIND_LITRE = _libsbml.UNIT_KIND_LITRE
UNIT_KIND_LUMEN = _libsbml.UNIT_KIND_LUMEN
UNIT_KIND_LUX = _libsbml.UNIT_KIND_LUX
UNIT_KIND_METER = _libsbml.UNIT_KIND_METER
UNIT_KIND_METRE = _libsbml.UNIT_KIND_METRE
UNIT_KIND_MOLE = _libsbml.UNIT_KIND_MOLE
UNIT_KIND_NEWTON = _libsbml.UNIT_KIND_NEWTON
UNIT_KIND_OHM = _libsbml.UNIT_KIND_OHM
UNIT_KIND_PASCAL = _libsbml.UNIT_KIND_PASCAL
UNIT_KIND_RADIAN = _libsbml.UNIT_KIND_RADIAN
UNIT_KIND_SECOND = _libsbml.UNIT_KIND_SECOND
UNIT_KIND_SIEMENS = _libsbml.UNIT_KIND_SIEMENS
UNIT_KIND_SIEVERT = _libsbml.UNIT_KIND_SIEVERT
UNIT_KIND_STERADIAN = _libsbml.UNIT_KIND_STERADIAN
UNIT_KIND_TESLA = _libsbml.UNIT_KIND_TESLA
UNIT_KIND_VOLT = _libsbml.UNIT_KIND_VOLT
UNIT_KIND_WATT = _libsbml.UNIT_KIND_WATT
UNIT_KIND_WEBER = _libsbml.UNIT_KIND_WEBER
UNIT_KIND_INVALID = _libsbml.UNIT_KIND_INVALID

def UnitKind_equals(*args):
  """
    UnitKind_equals(UnitKind_t uk1, UnitKind_t uk2) -> int

    Tests for logical equality between two given UnitKind_t values.

    This function behaves exactly like C's <tt>==</tt> operator, except for
    the following two cases:

    @li UNIT_KIND_LITER <code>==</code> UNIT_KIND_LITRE
    @li UNIT_KIND_METER <code>==</code> UNIT_KIND_METRE

    C equality comparison would yield false (because each of the above is a
    distinct enumeration value), but UnitKind_equals() returns true.

    @param uk1 a UnitKind_t enumeration value 
    @param uk2 the UnitKind_t enumeration value to compare to @p uk1

    @return nonzero (for true) if uk1 is logically equivalent to uk2,
    zero (0) otherwise.

    @note For more information about the UnitKind_t enumeration, please
    refer to the class documentation for Unit.


    """
  return _libsbml.UnitKind_equals(*args)

def UnitKind_forName(*args):
  """
    UnitKind_forName(char name) -> UnitKind_t

    Converts a string to its corresponding UnitKind_t enumeration value.

    @param name a string, the name of a predefined base unit in SBML

    @return a value from UnitKind_t corresponding to the given name
    (determined in a case-insensitive manner).

    @note For more information about the UnitKind_t enumeration, please
    refer to the class documentation for Unit.


    """
  return _libsbml.UnitKind_forName(*args)

def UnitKind_toString(*args):
  """
    UnitKind_toString(UnitKind_t uk) -> char

    Converts a UnitKind_t enumeration value to a text string equivalent.

    @param uk the UnitKind_t value to convert

    @return the name of the given UnitKind.

    @note The string returned is a static data value.  The caller does not
    own the returned string and is therefore not allowed to modify it.

    @note For more information about the UnitKind_t enumeration, please
    refer to the class documentation for Unit.


    """
  return _libsbml.UnitKind_toString(*args)

def UnitKind_isValidUnitKindString(*args):
  """
    UnitKind_isValidUnitKindString(char string, unsigned int level, unsigned int version) -> int

    Predicate for testing whether a given string corresponds to a
    predefined UnitKind_t enumeration value.

    @return nonzero (for true) if string is the name of a valid
    UnitKind_t enumeration value, zero (0) otherwise.

    @note For more information about the UnitKind_t enumeration, please
    refer to the class documentation for Unit.


    """
  return _libsbml.UnitKind_isValidUnitKindString(*args)
class Unit(SBase):
    """
    LibSBML implementation of SBML's %Unit construct.

    The SBML unit definition facility uses two classes of objects,
    UnitDefinition and Unit.  The approach to defining units in %SBML is
    compositional; for example, <em>meter second<sup> &ndash;2</sup></em> is
    constructed by combining a Unit object representing <em>meter</em> with
    another Unit object representing <em>second<sup> &ndash;2</sup></em>.
    The combination is wrapped inside a UnitDefinition, which provides for
    assigning an identifier and optional name to the combination.  The
    identifier can then be referenced from elsewhere in a model.  Thus, the
    UnitDefinition class is the container, and Unit instances are placed
    inside UnitDefinition instances.

    A Unit structure has four attributes named 'kind', 'exponent', 'scale'
    and 'multiplier'.  It represents a (possibly transformed) reference to a
    base unit.  The attribute 'kind' on Unit indicates the chosen base unit.
    Its value in SBML Level&nbsp;2 Version&nbsp;4 must be one of the following
    predefined strings:

    @htmlinclude libsbml-base-units.html

    (See also the definition of the <code>UNIT_KIND_</code> constants in <a
    class='el' href='#UnitKind_t'>the section below</a>.)  For SBML
    Level&nbsp;2 Version&nbsp;1 models, the string @c Celsius is also
    permitted.  Note also that the table above contains two names not
    strictly defined in SBML Level&nbsp;2: @c liter and @c meter.  For
    convenience, libSBML defines the American English spellings of these
    units, although the SBML specification limits the valid unit names to
    those defined by SI.

    The optional attribute named 'exponent' on Unit represents an exponent
    on the unit.  Its default value is @c 1 (one).  A Unit structure also
    has an optional attribute called 'scale'; its value must be an integer
    exponent for a power-of-ten multiplier used to set the scale of the
    unit.  For example, a unit having a 'kind' value of @c gram and a
    'scale' value of @c -3 signifies 10<sup>&nbsp;&ndash;3</sup>
    * gram, or milligrams.  The default value of 'scale' is @c 0
    (zero), because 10<sup> 0</sup> = 1.  Lastly, the optional attribute
    named 'multiplier' can be used to multiply the kind unit by a
    real-numbered factor; this enables the definition of units that are not
    power-of-ten multiples of SI units.  For instance, a multiplier of
    0.3048 could be used to define @c foot as a measure of length in terms
    of a @c metre.  The 'multiplier' attribute has a default value of @c 1
    (one).

    <h3><a class='anchor' name='UnitKind_t'>UnitKind_t</a></h3>

    SBML defines a set of base units which serves as the starting point for
    new unit definitions.  This set of base units consists of the SI units
    and a small number of additional convenience units.

    @if clike Until SBML Level&nbsp;2 Version&nbsp;3, there
    existed a data type in the SBML specifications called @c UnitKind,
    enumerating the possible SBML base units.  Although SBML Level&nbsp;2
    Version&nbsp;3 removed this type from the language specification,
    libSBML maintains the corresponding enumeration type @c UnitKind_t as a
    convenience and as a way to provide backward compatibility to previous
    SBML Level/Version specifications.  (The removal in SBML Level&nbsp;2
    Version&nbsp;3 of the enumeration @c UnitKind was also accompanied by
    the redefinition of the data type @c UnitSId to include the previous @c
    UnitKind values as reserved symbols in the @c UnitSId space.  This
    change has no net effect on permissible models, their representation or
    their syntax.  The purpose of the change in the SBML specification was
    simply to clean up an inconsistency about the contexts in which these
    values were usable.)  The @c UnitKind_t enumeration in libSBML has a 
    small number of differences compared to the SBML specifications:
    @endif@if java In SBML Level&nbsp;2 Versions before
    Version&nbsp;3, there existed an enumeration of units called @c
    UnitKind.  In Version&nbsp;3, this enumeration was removed and the
    identifier class @c UnitSId redefined to include the previous @c
    UnitKind values as reserved symbols.  This change has no net effect on
    permissible models, their representation or their syntax.  The purpose
    of the change in the SBML specification was simply to clean up an
    inconsistency about the contexts in which these values were usable.
    However, LibSBML maintains UnitKind in the form of of a set of static
    integer constants whose names begin with the characters
    <code>UNIT_KIND_</code>.  These constants are defined in the class
    <code><a href='libsbmlConstants.html'>libsbmlConstants</a></code> This
    enumeration in libSBML has a small number of differences compared to the
    SBML specifications: @endif

    <ul>
    <li> The alternate spelling @c 'meter' is included in addition to the
    official SI spelling @c 'metre'.

    <li> The alternate spelling @c 'liter' is included in addition to the
    official SI spelling @c 'litre'.

    <li> The unit @c 'Celsius' is included because of its presence in
    specifications of SBML prior to SBML Level&nbsp;2 Version&nbsp;3.
    </ul>

    @if clike The table below lists the symbols defined in the
    @c UnitKind_t enumeration, and their
    meanings. @endif@if java The table below lists the unit
    constants defined in libSBML, and their meanings. @endif

    @htmlinclude libsbml-unitkind-table.html

    <!-- leave this next break as-is to work around some doxygen bug -->

    """
    __swig_setmethods__ = {}
    for _s in [SBase]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Unit, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Unit, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_Unit
    __del__ = lambda self : None;
    def __init__(self, *args): 
        """
        __init__(self, unsigned int level, unsigned int version) -> Unit
        __init__(self, SBMLNamespaces sbmlns) -> Unit
        __init__(self, Unit orig) -> Unit

        Predicate returning @c true or @c false depending on whether
        all the required attributes for this Unit object
        have been set.

        @note The required attributes for a Unit object are:
        kind

        @return a boolean value indicating whether all the required
        elements for this object have been defined.
        @deprecated libSBML internal


        """
        this = _libsbml.new_Unit(*args)
        try: self.this.append(this)
        except: self.this = this
    def clone(self):
        """
        clone(self) -> Unit

        Creates and returns a deep copy of this Unit.

        @return a (deep) copy of this Unit.
          

        """
        return _libsbml.Unit_clone(self)

    def initDefaults(self):
        """
        initDefaults(self)

        Initializes the attributes of this Unit (except for 'kind') to their
        defaults values.

        The default values are as follows:

        @li exponent   = 1
        @li scale      = 0
        @li multiplier = 1.0

        The 'kind' attribute is left unchanged.
          

        """
        return _libsbml.Unit_initDefaults(self)

    def getKind(self):
        """
        getKind(self) -> UnitKind_t

        Returns the 'kind' of Unit this is.

        @return the value of the 'kind' attribute of this Unit as a value from
        the <a class='el' href='#UnitKind_t'>UnitKind_t</a> enumeration
          

        """
        return _libsbml.Unit_getKind(self)

    def getExponent(self):
        """
        getExponent(self) -> int

        Returns the value of the 'exponent' attribute of this unit.

        @return the 'exponent' value of this Unit, as an integer
          

        """
        return _libsbml.Unit_getExponent(self)

    def getScale(self):
        """
        getScale(self) -> int

        Returns the value of the 'scale' attribute of this unit.

        @return the 'scale' value of this Unit, as an integer.
          

        """
        return _libsbml.Unit_getScale(self)

    def getMultiplier(self):
        """
        getMultiplier(self) -> double

        Returns the value of the 'multiplier' attribute of this Unit.

        @return the 'multiplier' value of this Unit, as a double
          

        """
        return _libsbml.Unit_getMultiplier(self)

    def getOffset(self):
        """
        getOffset(self) -> double

        Returns the value of the 'offset' attribute of this Unit.

        @warning The 'offset' attribute is only available in SBML Level&nbsp;2
        Version&nbsp;1.  This attribute is not present in SBML Level&nbsp;2
        Version&nbsp;2 or above.  When producing SBML models using these later
        specifications, modelers and software tools need to account for units
        with offsets explicitly.  The %SBML specification document offers a
        number of suggestions for how to achieve this.  LibSBML methods such
        as this one related to 'offset' are retained for compatibility with
        earlier versions of SBML Level&nbsp;2, but their use is strongly
        discouraged.

        @return the 'offset' value of this Unit, as a double
          

        """
        return _libsbml.Unit_getOffset(self)

    def isAmpere(self):
        """
        isAmpere(self) -> bool

        Predicate for testing whether this Unit is of the kind @c ampere.

        @return @c true if the kind of this Unit is @c ampere, @c false
        otherwise. 
          

        """
        return _libsbml.Unit_isAmpere(self)

    def isBecquerel(self):
        """
        isBecquerel(self) -> bool

        Predicate for testing whether this Unit is of the kind @c becquerel

        @return @c true if the kind of this Unit is @c becquerel, @c false
        otherwise. 
          

        """
        return _libsbml.Unit_isBecquerel(self)

    def isCandela(self):
        """
        isCandela(self) -> bool

        Predicate for testing whether this Unit is of the kind @c candela

        @return @c true if the kind of this Unit is @c candela, @c false
        otherwise. 
          

        """
        return _libsbml.Unit_isCandela(self)

    def isCelsius(self):
        """
        isCelsius(self) -> bool

        Predicate for testing whether this Unit is of the kind @c Celsius

        @return @c true if the kind of this Unit is @c Celsius, @c false
        otherwise. 

        @warning The predefined unit @c Celsius was removed from the list of
        predefined units in SBML Level&nbsp;2 Version&nbsp;2 at the same time
        that the 'offset' attribute was removed from Unit definitions.
        LibSBML methods such as this one related to @c Celsius are retained in
        order to support SBML Level&nbsp;2 Version&nbsp;1, but their use is
        strongly discouraged.
          

        """
        return _libsbml.Unit_isCelsius(self)

    def isCoulomb(self):
        """
        isCoulomb(self) -> bool

        Predicate for testing whether this Unit is of the kind @c coulomb

        @return @c true if the kind of this Unit is @c coulomb, @c false
        otherwise. 
          

        """
        return _libsbml.Unit_isCoulomb(self)

    def isDimensionless(self):
        """
        isDimensionless(self) -> bool

        Predicate for testing whether this Unit is of the kind @c
        dimensionless

        @return @c true if the kind of this Unit is @c dimensionless, @c false

        otherwise.
          

        """
        return _libsbml.Unit_isDimensionless(self)

    def isFarad(self):
        """
        isFarad(self) -> bool

        Predicate for testing whether this Unit is of the kind @c farad

        @return @c true if the kind of this Unit is @c farad, @c false
        otherwise. 
          

        """
        return _libsbml.Unit_isFarad(self)

    def isGram(self):
        """
        isGram(self) -> bool

        Predicate for testing whether this Unit is of the kind @c gram

        @return @c true if the kind of this Unit is @c gram, @c false
        otherwise. 
          

        """
        return _libsbml.Unit_isGram(self)

    def isGray(self):
        """
        isGray(self) -> bool

        Predicate for testing whether this Unit is of the kind @c gray

        @return @c true if the kind of this Unit is @c gray, @c false
        otherwise. 
          

        """
        return _libsbml.Unit_isGray(self)

    def isHenry(self):
        """
        isHenry(self) -> bool

        Predicate for testing whether this Unit is of the kind @c henry

        @return @c true if the kind of this Unit is @c henry, @c false
        otherwise. 
          

        """
        return _libsbml.Unit_isHenry(self)

    def isHertz(self):
        """
        isHertz(self) -> bool

        Predicate for testing whether this Unit is of the kind @c hertz

        @return @c true if the kind of this Unit is @c hertz, @c false
        otherwise. 
          

        """
        return _libsbml.Unit_isHertz(self)

    def isItem(self):
        """
        isItem(self) -> bool

        Predicate for testing whether this Unit is of the kind @c item

        @return @c true if the kind of this Unit is @c item, @c false
        otherwise. 
          

        """
        return _libsbml.Unit_isItem(self)

    def isJoule(self):
        """
        isJoule(self) -> bool

        Predicate for testing whether this Unit is of the kind @c joule

        @return @c true if the kind of this Unit is @c joule, @c false
        otherwise. 
          

        """
        return _libsbml.Unit_isJoule(self)

    def isKatal(self):
        """
        isKatal(self) -> bool

        Predicate for testing whether this Unit is of the kind @c katal

        @return @c true if the kind of this Unit is @c katal, @c false
        otherwise. 
          

        """
        return _libsbml.Unit_isKatal(self)

    def isKelvin(self):
        """
        isKelvin(self) -> bool

        Predicate for testing whether this Unit is of the kind @c kelvin

        @return @c true if the kind of this Unit is @c kelvin, @c false
        otherwise. 
          

        """
        return _libsbml.Unit_isKelvin(self)

    def isKilogram(self):
        """
        isKilogram(self) -> bool

        Predicate for testing whether this Unit is of the kind @c kilogram

        @return @c true if the kind of this Unit is @c kilogram, @c false
        otherwise. 
          

        """
        return _libsbml.Unit_isKilogram(self)

    def isLitre(self):
        """
        isLitre(self) -> bool

        Predicate for testing whether this Unit is of the kind @c litre

        @return @c true if the kind of this Unit is @c litre or 'liter', @c
        false 
        otherwise.
          

        """
        return _libsbml.Unit_isLitre(self)

    def isLumen(self):
        """
        isLumen(self) -> bool

        Predicate for testing whether this Unit is of the kind @c lumen

        @return @c true if the kind of this Unit is @c lumen, @c false
        otherwise. 
          

        """
        return _libsbml.Unit_isLumen(self)

    def isLux(self):
        """
        isLux(self) -> bool

        Predicate for testing whether this Unit is of the kind @c lux

        @return @c true if the kind of this Unit is @c lux, @c false
        otherwise. 
          

        """
        return _libsbml.Unit_isLux(self)

    def isMetre(self):
        """
        isMetre(self) -> bool

        Predicate for testing whether this Unit is of the kind @c metre

        @return @c true if the kind of this Unit is @c metre or 'meter', @c
        false 
        otherwise.
          

        """
        return _libsbml.Unit_isMetre(self)

    def isMole(self):
        """
        isMole(self) -> bool

        Predicate for testing whether this Unit is of the kind @c mole

        @return @c true if the kind of this Unit is @c mole, @c false
        otherwise. 
          

        """
        return _libsbml.Unit_isMole(self)

    def isNewton(self):
        """
        isNewton(self) -> bool

        Predicate for testing whether this Unit is of the kind @c newton

        @return @c true if the kind of this Unit is @c newton, @c false
        otherwise. 
          

        """
        return _libsbml.Unit_isNewton(self)

    def isOhm(self):
        """
        isOhm(self) -> bool

        Predicate for testing whether this Unit is of the kind @c ohm

        @return @c true if the kind of this Unit is @c ohm, @c false
        otherwise. 
          

        """
        return _libsbml.Unit_isOhm(self)

    def isPascal(self):
        """
        isPascal(self) -> bool

        Predicate for testing whether this Unit is of the kind @c pascal

        @return @c true if the kind of this Unit is @c pascal, @c false
        otherwise. 
          

        """
        return _libsbml.Unit_isPascal(self)

    def isRadian(self):
        """
        isRadian(self) -> bool

        Predicate for testing whether this Unit is of the kind @c radian

        @return @c true if the kind of this Unit is @c radian, @c false
        otherwise. 
          

        """
        return _libsbml.Unit_isRadian(self)

    def isSecond(self):
        """
        isSecond(self) -> bool

        Predicate for testing whether this Unit is of the kind @c second

        @return @c true if the kind of this Unit is @c second, @c false
        otherwise. 
          

        """
        return _libsbml.Unit_isSecond(self)

    def isSiemens(self):
        """
        isSiemens(self) -> bool

        Predicate for testing whether this Unit is of the kind @c siemens

        @return @c true if the kind of this Unit is @c siemens, @c false
        otherwise. 
          

        """
        return _libsbml.Unit_isSiemens(self)

    def isSievert(self):
        """
        isSievert(self) -> bool

        Predicate for testing whether this Unit is of the kind @c sievert

        @return @c true if the kind of this Unit is @c sievert, @c false
        otherwise. 
          

        """
        return _libsbml.Unit_isSievert(self)

    def isSteradian(self):
        """
        isSteradian(self) -> bool

        Predicate for testing whether this Unit is of the kind @c steradian

        @return @c true if the kind of this Unit is @c steradian, @c false
        otherwise. 
          

        """
        return _libsbml.Unit_isSteradian(self)

    def isTesla(self):
        """
        isTesla(self) -> bool

        Predicate for testing whether this Unit is of the kind @c tesla

        @return @c true if the kind of this Unit is @c tesla, @c false
        otherwise. 
          

        """
        return _libsbml.Unit_isTesla(self)

    def isVolt(self):
        """
        isVolt(self) -> bool

        Predicate for testing whether this Unit is of the kind @c volt

        @return @c true if the kind of this Unit is @c volt, @c false
        otherwise. 
          

        """
        return _libsbml.Unit_isVolt(self)

    def isWatt(self):
        """
        isWatt(self) -> bool

        Predicate for testing whether this Unit is of the kind @c watt

        @return @c true if the kind of this Unit is @c watt, @c false
        otherwise. 
          

        """
        return _libsbml.Unit_isWatt(self)

    def isWeber(self):
        """
        isWeber(self) -> bool

        Predicate for testing whether this Unit is of the kind @c weber

        @return @c true if the kind of this Unit is @c weber, @c false
        otherwise. 
          

        """
        return _libsbml.Unit_isWeber(self)

    def isSetKind(self):
        """
        isSetKind(self) -> bool

        Predicate to test whether the 'kind' attribute of this Unit has been set.

        @return @c true if the 'kind' attribute of this Unit has been set, @c
        false otherwise.
          

        """
        return _libsbml.Unit_isSetKind(self)

    def setKind(self, *args):
        """
        setKind(self, UnitKind_t kind) -> int

        Sets the 'kind' attribute value of this Unit.

        @param kind a value from the <a class='el'
        href='#UnitKind_t'>UnitKind_t</a> enumeration

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_INVALID_ATTRIBUTE_VALUE
          

        """
        return _libsbml.Unit_setKind(self, *args)

    def setExponent(self, *args):
        """
        setExponent(self, int value) -> int

        Sets the 'exponent' attribute value of this Unit.

        @param value the integer to which the attribute 'exponent' should be set

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
          

        """
        return _libsbml.Unit_setExponent(self, *args)

    def setScale(self, *args):
        """
        setScale(self, int value) -> int

        Sets the 'scale' attribute value of this Unit.

        @param value the integer to which the attribute 'scale' should be set

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
          

        """
        return _libsbml.Unit_setScale(self, *args)

    def setMultiplier(self, *args):
        """
        setMultiplier(self, double value) -> int

        Sets the 'multipler' attribute value of this Unit.

        @param value the floating-point value to which the attribute
        'multiplier' should be set

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_UNEXPECTED_ATTRIBUTE
          

        """
        return _libsbml.Unit_setMultiplier(self, *args)

    def setOffset(self, *args):
        """
        setOffset(self, double value) -> int

        Sets the 'offset' attribute value of this Unit.

        @param value the float-point value to which the attribute 'offset'
        should set

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_UNEXPECTED_ATTRIBUTE

        @warning The 'offset' attribute is only available in SBML Level&nbsp;2
        Version&nbsp;1.  This attribute is not present in SBML Level&nbsp;2
        Version&nbsp;2 or above.  When producing SBML models using these later
        specifications, modelers and software tools need to account for units
        with offsets explicitly.  The %SBML specification document offers a
        number of suggestions for how to achieve this.  LibSBML methods such
        as this one related to 'offset' are retained for compatibility with
        earlier versions of SBML Level&nbsp;2, but their use is strongly
        discouraged.
          

        """
        return _libsbml.Unit_setOffset(self, *args)

    def getTypeCode(self):
        """
        getTypeCode(self) -> SBMLTypeCode_t

        Returns the libSBML type code of this object instance.

        @if clike LibSBML attaches an identifying code to every
        kind of SBML object.  These are known as <em>SBML type codes</em>.
        The set of possible type codes is defined in the enumeration
        #SBMLTypeCode_t.  The names of the type codes all begin with the
        characters @c SBML_. @endif@if java LibSBML attaches an
        identifying code to every kind of SBML object.  These are known as
        <em>SBML type codes</em>.  In other languages, the set of type codes
        is stored in an enumeration; in the Java language interface for
        libSBML, the type codes are defined as static integer constants in
        interface class {@link libsbmlConstants}.  The names of the type codes
        all begin with the characters @c SBML_. @endif

        @return the SBML type code for this object, or @c SBML_UNKNOWN (default).

        @see getElementName()
          

        """
        return _libsbml.Unit_getTypeCode(self)

    def getElementName(self):
        """
        getElementName(self) -> string

        Returns the XML element name of this object, which for Unit, is
        always @c 'unit'.

        @return the name of this element, i.e., @c 'unit'. 
          

        """
        return _libsbml.Unit_getElementName(self)

    def isBuiltIn(*args):
        """
        isBuiltIn(string name, unsigned int level) -> bool

        Predicate to test whether a given string is the name of a
        predefined SBML unit.

        @param name a string to be tested against the predefined unit names

        @param level the Level of SBML for which the determination should be
        made.  This is necessary because there are a few small differences
        in allowed units between SBML Level&nbsp;1 and Level&nbsp;2.

        @return @c true if @p name is one of the five SBML predefined unit
        identifiers (@c 'substance', @c 'volume', @c 'area', @c 'length' or @c
        'time'), @c false otherwise.

        @note The predefined unit identifiers @c 'length' and @c 'area' were
        added in Level&nbsp;2 Version&nbsp;1
          

        """
        return _libsbml.Unit_isBuiltIn(*args)

    if _newclass:isBuiltIn = staticmethod(isBuiltIn)
    __swig_getmethods__["isBuiltIn"] = lambda x: isBuiltIn
    def isUnitKind(*args):
        """
        isUnitKind(string name, unsigned int level, unsigned int version) -> bool

        Predicate to test whether a given string is the name of a valid
        base unit in SBML (such as @c 'gram' or @c 'mole').

        This method exists because prior to SBML Level&nbsp;2 Version&nbsp;3,
        an enumeration called @c UnitKind was defined by SBML.  This enumeration
        was removed in SBML Level&nbsp;2 Version&nbsp;3 and its values were
        folded into the space of values of a type called @c UnitSId.  This method
        therefore has less significance in SBML Level&nbsp;2 Version&nbsp;3
        and Level&nbsp;2 Version&nbsp;4, but remains for backward
        compatibility and support for reading models in older Versions of
        Level&nbsp;2.

        @param name a string to be tested

        @param level an unsigned int representing the SBML specification
        Level 

        @param version an unsigned int representing the SBML specification
        Version

        @return @c true if name is a valid UnitKind, @c false otherwise

        @note The allowed unit names differ between SBML Levels&nbsp;1
        and&nbsp;2 and again slightly between Level&nbsp;2 Versions&nbsp;1
        and&nbsp;2.
          

        """
        return _libsbml.Unit_isUnitKind(*args)

    if _newclass:isUnitKind = staticmethod(isUnitKind)
    __swig_getmethods__["isUnitKind"] = lambda x: isUnitKind
    def areIdentical(*args):
        """
        areIdentical(Unit unit1, Unit unit2) -> bool

        Predicate returning @c true or @c false depending on whether two
        Unit objects are identical.

        Two Unit objects are considered to be @em identical if they match in
        all attributes.  (Contrast this to the method
        Unit::areEquivalent(Unit * unit1, %Unit * unit2), which compares
        Unit objects only with respect to certain attributes.)

        @param unit1 the first Unit object to compare
        @param unit2 the second Unit object to compare

        @return @c true if all the attributes of unit1 are identical
        to the attributes of unit2, @c false otherwise.

        @see areEquivalent(Unit * unit1, %Unit * unit2)
         

        """
        return _libsbml.Unit_areIdentical(*args)

    if _newclass:areIdentical = staticmethod(areIdentical)
    __swig_getmethods__["areIdentical"] = lambda x: areIdentical
    def areEquivalent(*args):
        """
        areEquivalent(Unit unit1, Unit unit2) -> bool

        Predicate returning @c true or @c false depending on whether 
        Unit objects are equivalent.

        Two Unit objects are considered to be @em equivalent if their 'kind'
        and 'exponent' attributes are equal.  (Contrast this to the method
        Unit::areIdentical(Unit * unit1, %Unit * unit2), which compares Unit
        objects with respect to all attributes, not just the kind and
        exponent.)

        @param unit1 the first Unit object to compare
        @param unit2 the second Unit object to compare

        @return @c true if the 'kind' and 'exponent' attributes of unit1 are
        identical to the kind and exponent attributes of unit2, @c false
        otherwise.

        @see areIdentical(Unit * unit1, %Unit * unit2)
         

        """
        return _libsbml.Unit_areEquivalent(*args)

    if _newclass:areEquivalent = staticmethod(areEquivalent)
    __swig_getmethods__["areEquivalent"] = lambda x: areEquivalent
    def removeScale(*args):
        """
        removeScale(Unit unit) -> int

        Manipulates the attributes of the Unit to express the unit with the 
        value of the scale attribute reduced to zero.

        For example, 1 millimetre can be expressed as a Unit with kind=@c
        'metre' multiplier=@c '1' scale=@c '-3' exponent=@c '1'. It can also be
        expressed as a Unit with kind=@c 'metre'
        multiplier=<code>'0.001'</code> scale=@c '0' exponent=@c '1'.

        @param unit the Unit object to manipulate.

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
         

        """
        return _libsbml.Unit_removeScale(*args)

    if _newclass:removeScale = staticmethod(removeScale)
    __swig_getmethods__["removeScale"] = lambda x: removeScale
    def merge(*args):
        """
        merge(Unit unit1, Unit unit2)

        Merges two Unit objects with the same 'kind' attribute value into a
        single Unit.

        For example, the following,
        @code
        <unit kind='metre' exponent='2'/>
        <unit kind='metre' exponent='1'/>
        @endcode
        would be merged to become
        @code
        <unit kind='metre' exponent='3'/>
        @endcode

        @param unit1 the first Unit object; the result of the operation is
        left as a new version of this unit, modified in-place.

        @param unit2 the second Unit object to merge with the first
         

        """
        return _libsbml.Unit_merge(*args)

    if _newclass:merge = staticmethod(merge)
    __swig_getmethods__["merge"] = lambda x: merge
    def convertToSI(*args):
        """
        convertToSI(Unit unit) -> UnitDefinition

        Returns a UnitDefinition object which contains the argument Unit
        converted to the appropriate SI unit.

        @param unit the Unit object to convert to SI

        @return a UnitDefinition object containing the SI unit.
         

        """
        return _libsbml.Unit_convertToSI(*args)

    if _newclass:convertToSI = staticmethod(convertToSI)
    __swig_getmethods__["convertToSI"] = lambda x: convertToSI
    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(self) -> bool

        Predicate returning @c true or @c false depending on whether
        all the required attributes for this Unit object
        have been set.

        @note The required attributes for a Unit object are:
        kind

        @return a boolean value indicating whether all the required
        elements for this object have been defined.
          

        """
        return _libsbml.Unit_hasRequiredAttributes(self)

Unit_swigregister = _libsbml.Unit_swigregister
Unit_swigregister(Unit)

def Unit_isBuiltIn(*args):
  """
    Unit_isBuiltIn(string name, unsigned int level) -> bool

    Predicate to test whether a given string is the name of a
    predefined SBML unit.

    @param name a string to be tested against the predefined unit names

    @param level the Level of SBML for which the determination should be
    made.  This is necessary because there are a few small differences
    in allowed units between SBML Level&nbsp;1 and Level&nbsp;2.

    @return @c true if @p name is one of the five SBML predefined unit
    identifiers (@c 'substance', @c 'volume', @c 'area', @c 'length' or @c
    'time'), @c false otherwise.

    @note The predefined unit identifiers @c 'length' and @c 'area' were
    added in Level&nbsp;2 Version&nbsp;1
      

    """
  return _libsbml.Unit_isBuiltIn(*args)

def Unit_isUnitKind(*args):
  """
    Unit_isUnitKind(string name, unsigned int level, unsigned int version) -> bool

    Predicate to test whether a given string is the name of a valid
    base unit in SBML (such as @c 'gram' or @c 'mole').

    This method exists because prior to SBML Level&nbsp;2 Version&nbsp;3,
    an enumeration called @c UnitKind was defined by SBML.  This enumeration
    was removed in SBML Level&nbsp;2 Version&nbsp;3 and its values were
    folded into the space of values of a type called @c UnitSId.  This method
    therefore has less significance in SBML Level&nbsp;2 Version&nbsp;3
    and Level&nbsp;2 Version&nbsp;4, but remains for backward
    compatibility and support for reading models in older Versions of
    Level&nbsp;2.

    @param name a string to be tested

    @param level an unsigned int representing the SBML specification
    Level 

    @param version an unsigned int representing the SBML specification
    Version

    @return @c true if name is a valid UnitKind, @c false otherwise

    @note The allowed unit names differ between SBML Levels&nbsp;1
    and&nbsp;2 and again slightly between Level&nbsp;2 Versions&nbsp;1
    and&nbsp;2.
      

    """
  return _libsbml.Unit_isUnitKind(*args)

def Unit_areIdentical(*args):
  """
    Unit_areIdentical(Unit unit1, Unit unit2) -> bool

    Predicate returning @c true or @c false depending on whether two
    Unit objects are identical.

    Two Unit objects are considered to be @em identical if they match in
    all attributes.  (Contrast this to the method
    Unit::areEquivalent(Unit * unit1, %Unit * unit2), which compares
    Unit objects only with respect to certain attributes.)

    @param unit1 the first Unit object to compare
    @param unit2 the second Unit object to compare

    @return @c true if all the attributes of unit1 are identical
    to the attributes of unit2, @c false otherwise.

    @see areEquivalent(Unit * unit1, %Unit * unit2)
     

    """
  return _libsbml.Unit_areIdentical(*args)

def Unit_areEquivalent(*args):
  """
    Unit_areEquivalent(Unit unit1, Unit unit2) -> bool

    Predicate returning @c true or @c false depending on whether 
    Unit objects are equivalent.

    Two Unit objects are considered to be @em equivalent if their 'kind'
    and 'exponent' attributes are equal.  (Contrast this to the method
    Unit::areIdentical(Unit * unit1, %Unit * unit2), which compares Unit
    objects with respect to all attributes, not just the kind and
    exponent.)

    @param unit1 the first Unit object to compare
    @param unit2 the second Unit object to compare

    @return @c true if the 'kind' and 'exponent' attributes of unit1 are
    identical to the kind and exponent attributes of unit2, @c false
    otherwise.

    @see areIdentical(Unit * unit1, %Unit * unit2)
     

    """
  return _libsbml.Unit_areEquivalent(*args)

def Unit_removeScale(*args):
  """
    Unit_removeScale(Unit unit) -> int

    Manipulates the attributes of the Unit to express the unit with the 
    value of the scale attribute reduced to zero.

    For example, 1 millimetre can be expressed as a Unit with kind=@c
    'metre' multiplier=@c '1' scale=@c '-3' exponent=@c '1'. It can also be
    expressed as a Unit with kind=@c 'metre'
    multiplier=<code>'0.001'</code> scale=@c '0' exponent=@c '1'.

    @param unit the Unit object to manipulate.

    @return integer value indicating success/failure of the
    function.  @if clike The value is drawn from the
    enumeration #OperationReturnValues_t. @endif The possible values
    returned by this function are:
    @li LIBSBML_OPERATION_SUCCESS
     

    """
  return _libsbml.Unit_removeScale(*args)

def Unit_merge(*args):
  """
    Unit_merge(Unit unit1, Unit unit2)

    Merges two Unit objects with the same 'kind' attribute value into a
    single Unit.

    For example, the following,
    @code
    <unit kind='metre' exponent='2'/>
    <unit kind='metre' exponent='1'/>
    @endcode
    would be merged to become
    @code
    <unit kind='metre' exponent='3'/>
    @endcode

    @param unit1 the first Unit object; the result of the operation is
    left as a new version of this unit, modified in-place.

    @param unit2 the second Unit object to merge with the first
     

    """
  return _libsbml.Unit_merge(*args)

def Unit_convertToSI(*args):
  """
    Unit_convertToSI(Unit unit) -> UnitDefinition

    Returns a UnitDefinition object which contains the argument Unit
    converted to the appropriate SI unit.

    @param unit the Unit object to convert to SI

    @return a UnitDefinition object containing the SI unit.
     

    """
  return _libsbml.Unit_convertToSI(*args)

class ListOfUnits(ListOf):
    """
    LibSBML implementation of SBML's %ListOfUnits construct.

    The various ListOf___ classes in %SBML are merely containers used for
    organizing the main components of an %SBML model.  All are derived from
    the abstract class SBase, and inherit the various attributes and
    subelements of SBase, such as 'metaid' as and 'annotation'.  The
    ListOf___ classes do not add any attributes of their own.

    ListOfUnits is entirely contained within UnitDefinition.

    """
    __swig_setmethods__ = {}
    for _s in [ListOf]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfUnits, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfUnits, name)
    __repr__ = _swig_repr
    def clone(self):
        """
        clone(self) -> ListOfUnits

        Creates and returns a deep copy of this ListOfUnits.

        @return a (deep) copy of this ListOfUnits.
          

        """
        return _libsbml.ListOfUnits_clone(self)

    def getTypeCode(self):
        """
        getTypeCode(self) -> SBMLTypeCode_t

        Returns the libSBML type code for this %SBML object.

        @if clike LibSBML attaches an identifying code to every
        kind of SBML object.  These are known as <em>SBML type codes</em>.
        The set of possible type codes is defined in the enumeration
        #SBMLTypeCode_t.  The names of the type codes all begin with the
        characters @c SBML_. @endif@if java LibSBML attaches an
        identifying code to every kind of SBML object.  These are known as
        <em>SBML type codes</em>.  In other languages, the set of type codes
        is stored in an enumeration; in the Java language interface for
        libSBML, the type codes are defined as static integer constants in
        interface class {@link libsbmlConstants}.  The names of the type codes
        all begin with the characters @c SBML_. @endif

        @return the SBML type code for this object, or @c SBML_UNKNOWN (default).

        @see getElementName()
          

        """
        return _libsbml.ListOfUnits_getTypeCode(self)

    def getItemTypeCode(self):
        """
        getItemTypeCode(self) -> SBMLTypeCode_t

        Returns the libSBML type code for the objects contained in this ListOf
        (i.e., Unit objects, if the list is non-empty).

        @if clike LibSBML attaches an identifying code to every
        kind of SBML object.  These are known as <em>SBML type codes</em>.
        The set of possible type codes is defined in the enumeration
        #SBMLTypeCode_t.  The names of the type codes all begin with the
        characters @c SBML_. @endif@if java LibSBML attaches an
        identifying code to every kind of SBML object.  These are known as
        <em>SBML type codes</em>.  In other languages, the set of type codes
        is stored in an enumeration; in the Java language interface for
        libSBML, the type codes are defined as static integer constants in
        interface class {@link libsbmlConstants}.  The names of the type codes
        all begin with the characters @c SBML_. @endif

        @return the SBML type code for the objects contained in this ListOf
        instance, or @c SBML_UNKNOWN (default).

        @see getElementName()
          

        """
        return _libsbml.ListOfUnits_getItemTypeCode(self)

    def getElementName(self):
        """
        getElementName(self) -> string

        Returns the XML element name of this object.

        For ListOfUnits, the XML element name is @c 'listOfUnits'.

        @return the name of this element, i.e., @c 'listOfUnits'.
          

        """
        return _libsbml.ListOfUnits_getElementName(self)

    def get(self, *args):
        """
        get(self, unsigned int n) -> Unit
        get(self, unsigned int n) -> Unit

        Get a Unit from the ListOfUnits.

        @param n the index number of the Unit to get.

        @return the nth Unit in this ListOfUnits.

        @see size()
          

        """
        return _libsbml.ListOfUnits_get(self, *args)

    def remove(self, *args):
        """
        remove(self, unsigned int n) -> Unit

        Removes the nth item from this ListOfUnits items and returns a pointer to
        it.

        The caller owns the returned item and is responsible for deleting it.

        @param n the index of the item to remove

        @see size()
          

        """
        return _libsbml.ListOfUnits_remove(self, *args)

    def __init__(self): 
        """__init__(self) -> ListOfUnits"""
        this = _libsbml.new_ListOfUnits()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _libsbml.delete_ListOfUnits
    __del__ = lambda self : None;
ListOfUnits_swigregister = _libsbml.ListOfUnits_swigregister
ListOfUnits_swigregister(ListOfUnits)

class UnitDefinition(SBase):
    """
    LibSBML implementation of %SBML's %UnitDefinition construct.

    Units of measurement may be supplied in a number of contexts in an %SBML
    model.  The units of the following mathematical entities can be
    specified explicitly: the size of a compartment, the initial amount of a
    species, and the units of constant and variable parameter values.  The
    overall units of any mathematical formula appearing in %SBML are those
    that arise naturally from the components and mathematical expressions
    comprising the formula, or in other words, the units obtained by doing
    dimensional analysis on the formula.

    Rather than requiring a complete unit definition on every construct,
    %SBML provides a facility for defining units that can be referenced
    throughout a model.  In addition, every kind of %SBML mathematical
    entity has units assigned to it from a set of predefined defaults (listed
    below); by redefining these predefined default units, it is possible to
    change the units used throughout a model in a simple and consistent
    manner.

    The %SBML unit definition facility uses two classes of objects,
    UnitDefinition and Unit.  The approach to defining units in %SBML is
    compositional; for example, <em>meter second<sup> &ndash;2</sup></em> is
    constructed by combining a Unit object representing <em>meter</em> with
    another Unit object representing <em>second<sup> &ndash;2</sup></em>.
    The combination is wrapped inside a UnitDefinition, which provides for
    assigning an identifier and optional name to the combination.  The
    identifier can then be referenced from elsewhere in a model.  Thus, the
    UnitDefinition class is the container, and Unit instances are placed
    inside UnitDefinition instances.

    @section unitdef-summary Summary of the UnitDefinition construct

    UnitDefinition in SBML Level&nbsp;2 has two attributes and one
    subelement.  The two attributes are 'id' and 'name', and the subelement
    is ListOfUnits.

    The required attribute 'id' and optional attribute 'name' are both
    strings.  The 'id' attribute is used to give the defined unit a unique
    identifier by which other parts of an SBML model definition can refer to
    it.  The 'name' attribute is intended to be used for giving the unit
    definition an optional human-readable name.

    There are two important restrictions about the use of unit definition
    'id' values in SBML Level&nbsp;2 Versions&nbsp;3&ndash;4:
    <ul>
    <li> The 'id' of a UnitDefinition must @em not contain a value from the
      list of reserved base unit names (i.e., the strings @c gram, @c liter,
      etc.; see the definition of Unit for the complete list).  This
      constraint simply prevents the redefinition of the base units.

    <li> There is a set of reserved identifiers for the predefined
      units in SBML; these identifiers are @c substance, @c volume, @c area,
      @c length, and @c time.  Using one of these values for the attribute
      'id' of a UnitDefinition has the effect of redefining the model-wide
      default units for the corresponding quantities.  The list of
      predefined units is given in the table below:

      @htmlinclude libsbml-predefined-units.html

      Also, two limitations are imposed on redefining the predefined
      unit @c substance, @c volume, @c area, @c length, and @c time:
      (1) The UnitDefinition of a predefined SBML unit can only
         contain a single Unit object within it.
      (2) The value of the 'kind' attribute in 
         a Unit instance must be drawn from one of the values
         in the second column of the table above.
    </ul>

    A UnitDefinition must contain exactly one ListOfUnits, and this list
    must contain one or more Unit definitions; see the definitions of these
    other object classes for more information about them.  The following
    example illustrates a complete unit definition (when written in XML)
    when they all the pieces are combined together.  This defines 'mmls'
    to be millimoles per litre per second.
    @code
    <listOfUnitDefinitions>
        <unitDefinition id='mmls'>
            <listOfUnits>
                <unit kind='mole'   scale='-3'/>
                <unit kind='litre'  exponent='-1'/>
                <unit kind='second' exponent='-1'/>
            </listOfUnits>
        </unitDefinition>
    </listOfUnitDefinitions>
    @endcode


    @section sbml-units-limits Further comments about SBML's unit definition system

    The vast majority of modeling situations requiring new %SBML unit
    definitions involve simple multiplicative combinations of base units and
    factors.  An example of this might be <em>moles per litre per
    second</em>.  What distinguishes these sorts of simpler unit definitions
    from more complex ones is that they may be expressed without the use of
    an additive offset from a zero point.  The use of offsets complicates
    all unit definition systems, yet in the domain of %SBML the real-life
    cases requiring offsets are few (and in fact, to the best of our
    knowledge, only involve temperature).  Consequently, the %SBML unit
    system has been consciously designed in a way that attempts to simplify
    implementation of unit support for the most common cases in systems
    biology.

    As of %SBML Level&nbsp;2 Version&nbsp;2, Unit no longer has the
    attribute called 'offset' introduced in SBML Level&nbsp;2
    Version&nbsp;1.  It turned out that the general case involving units
    with offsets was incorrectly defined, and few (if any) developers even
    attempted to support offset-based units in their software.  In the
    development of Level&nbsp;2 Version&nbsp;2, a consensus among %SBML
    developers emerged that a fully generalized unit scheme is @em so
    confusing and complicated that it actually @em impedes interoperability.
    SBML Level&nbsp;2 Version&nbsp;2, Version&nbsp;3 and Version&nbsp;4 acknowledge this
    reality by reducing and simplifying the unit system, specifically by
    removing the 'offset' attribute on Unit and @c Celsius as a pre-defined
    unit.

    The following guidelines suggest methods for handling units that do
    require the use of zero offsets for their definitions:
    <ul>
    <li> <em>Handling Celsius</em>.  A model in which certain quantities are
      temperatures measured in degrees Celsius can be converted
      straightforwardly to a model in which those temperatures are in
      kelvin.  A software tool could do this by performing a straightforward
      substitution using the following relationship: T<sub> kelvin</sub> =
      T<sub> Celsius</sub> + 273.15.  In every mathematical formula of the
      model where a quantity (call it @em x) in degrees Celsius appears,
      replace @em x with x<sub> k</sub>+ 273.15, where x<sub> k</sub> is now
      in kelvin.  An alternative approach would be to use a
      FunctionDefinition to define a function encapsulating this
      relationship above and then using that in the rest of the model as
      needed.  Since Celsius is a commonly-used unit, software tools could
      help users by providing users with the ability to express temperatures
      in Celsius in the tools' interfaces, and making substitutions
      automatically when writing out the SBML.

    <li> <em>Other units requiring offsets</em>.  One approach to handling
      other kinds of units is to use a FunctionDefinition to define a function
      encapsulating the necessary mathematical relationship, then
      substituting a call to this function wherever the original quantity
      appeared in the model.  For example, here is a possible definition for
      converting Fahrenheit to Celsius degrees:
      @code
    <functionDefinition id='Fahrenheit_to_kelvin'>
        <math xmlns='http://www.w3.org/1998/Math/MathML'>
            <lambda>
                <bvar><ci> temp_in_fahrenheit </ci></bvar>
                <apply>
                    <divide/>
                    <apply>
                        <plus/>
                        <ci> temp_in_fahrenheit </ci>
                        <cn> 459.67 </cn>
                    </apply>
                    <cn> 1.8 </cn>
                </apply>
            </lambda>
        </math>
    </functionDefinition>
      @endcode
        
    <li> An alternative approach not requiring the use of function definitions
      is to use an AssignmentRule for each variable in Fahrenheit units.
      The AssignmentRule could compute the conversion from Fahrenheit to
      (say) kelvin, assign its value to a variable (in Kelvin units), and
      then that variable could be used elsewhere in the model.

    <li> Still another approach is to rewrite the mathematical formulas of a
      model to directly incorporate the conversion formula wherever the
      original quantity appeared.
    </ul>

    Please consult the SBML specifications for more information about this
    and other issues involving units.
     
    <!-- leave this next break as-is to work around some doxygen bug -->

    """
    __swig_setmethods__ = {}
    for _s in [SBase]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, UnitDefinition, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, UnitDefinition, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_UnitDefinition
    __del__ = lambda self : None;
    def __init__(self, *args): 
        """
        __init__(self, unsigned int level, unsigned int version) -> UnitDefinition
        __init__(self, SBMLNamespaces sbmlns) -> UnitDefinition
        __init__(self, UnitDefinition orig) -> UnitDefinition

        Predicate returning @c true or @c false depending on whether
        all the required elements for this UnitDefinition object
        have been set.

        @note The required elements for a Constraint object are:
        listOfUnits (L2 only)

        @return a boolean value indicating whether all the required
        elements for this object have been defined.
        @deprecated libSBML internal


        """
        this = _libsbml.new_UnitDefinition(*args)
        try: self.this.append(this)
        except: self.this = this
    def clone(self):
        """
        clone(self) -> UnitDefinition

        Creates and returns a deep copy of this UnitDefinition.

        @return a (deep) copy of this UnitDefinition.
          

        """
        return _libsbml.UnitDefinition_clone(self)

    def getId(self):
        """
        getId(self) -> string

        Returns the value of the 'id' attribute of this UnitDefinition.

        @return the id of this UnitDefinition.
          

        """
        return _libsbml.UnitDefinition_getId(self)

    def getName(self):
        """
        getName(self) -> string

        Returns the value of the 'name' attribute of this UnitDefinition.

        @return the name of this UnitDefinition.
          

        """
        return _libsbml.UnitDefinition_getName(self)

    def isSetId(self):
        """
        isSetId(self) -> bool

        Predicate returning @c true or @c false depending on whether this
        UnitDefinition's 'id' attribute has been set.

        @htmlinclude libsbml-comment-set-methods.html

        @return @c true if the 'id' attribute of this UnitDefinition has been
        set, @c false otherwise.
          

        """
        return _libsbml.UnitDefinition_isSetId(self)

    def isSetName(self):
        """
        isSetName(self) -> bool

        Predicate returning @c true or @c false depending on whether this
        UnitDefinition's 'name' attribute has been set.

        @htmlinclude libsbml-comment-set-methods.html

        @return @c true if the 'name' attribute of this UnitDefinition has been
        set, @c false otherwise.
          

        """
        return _libsbml.UnitDefinition_isSetName(self)

    def setId(self, *args):
        """
        setId(self, string sid) -> int

        Sets the value of the 'id' attribute of this UnitDefinition.

        The string @p sid is copied.  Note that SBML has strict requirements
        for the syntax of identifiers.  The following is summary of the
        definition of the SBML identifier type @c SId (here expressed in an
        extended form of BNF notation):
        @code
          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*
        @endcode
        The equality of SBML identifiers is determined by an exact character
        sequence match; i.e., comparisons must be performed in a
        case-sensitive manner.  In addition, there are a few conditions for
        the uniqueness of identifiers in an SBML model.  Please consult the
        SBML specifications for the exact formulations.

        @htmlinclude libsbml-comment-set-methods.html

        @param sid the string to use as the identifier of this UnitDefinition

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_INVALID_ATTRIBUTE_VALUE
          

        """
        return _libsbml.UnitDefinition_setId(self, *args)

    def setName(self, *args):
        """
        setName(self, string name) -> int

        Sets the value of the 'name' attribute of this UnitDefinition.

        The string in @p name is copied.

        @htmlinclude libsbml-comment-set-methods.html

        @param name the new name for the UnitDefinition

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_INVALID_ATTRIBUTE_VALUE
          

        """
        return _libsbml.UnitDefinition_setName(self, *args)

    def unsetName(self):
        """
        unsetName(self) -> int

        Unsets the value of the 'name' attribute of this UnitDefinition.

        @htmlinclude libsbml-comment-set-methods.html

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_OPERATION_FAILED
          

        """
        return _libsbml.UnitDefinition_unsetName(self)

    def isVariantOfArea(self):
        """
        isVariantOfArea(self) -> bool

        Convenience function for testing if a given unit definition is a
        variant of the predefined unit identifier @c 'area'.

        @return @c true if this UnitDefinition is a variant of the predefined
        unit @c area, meaning square metres with only abritrary variations
        in scale or multiplier values; @c false otherwise.
          

        """
        return _libsbml.UnitDefinition_isVariantOfArea(self)

    def isVariantOfLength(self):
        """
        isVariantOfLength(self) -> bool

        Convenience function for testing if a given unit definition is a
        variant of the predefined unit identifier @c 'length'.

        @return @c true if this UnitDefinition is a variant of the predefined
        unit @c length, meaning metres with only abritrary variations in scale
        or multiplier values; @c false otherwise.
          

        """
        return _libsbml.UnitDefinition_isVariantOfLength(self)

    def isVariantOfSubstance(self):
        """
        isVariantOfSubstance(self) -> bool

        Convenience function for testing if a given unit definition is a
        variant of the predefined unit identifier @c 'substance'.

        @return @c true if this UnitDefinition is a variant of the predefined
        unit @c substance, meaning moles or items (and grams or kilograms from
        SBML Level&nbsp;2 Version&nbsp;2 onwards) with only abritrary variations
        in scale or multiplier values; @c false otherwise.
          

        """
        return _libsbml.UnitDefinition_isVariantOfSubstance(self)

    def isVariantOfTime(self):
        """
        isVariantOfTime(self) -> bool

        Convenience function for testing if a given unit definition is a
        variant of the predefined unit identifier @c 'time'.

        @return @c true if this UnitDefinition is a variant of the predefined
        unit @c time, meaning seconds with only abritrary variations in scale or
        multiplier values; @c false otherwise.
          

        """
        return _libsbml.UnitDefinition_isVariantOfTime(self)

    def isVariantOfVolume(self):
        """
        isVariantOfVolume(self) -> bool

        Convenience function for testing if a given unit definition is a
        variant of the predefined unit identifier @c 'volume'.

        @return @c true if this UnitDefinition is a variant of the predefined
        unit @c volume, meaning litre or cubic metre with only abritrary
        variations in scale or multiplier values; @c false otherwise.
          

        """
        return _libsbml.UnitDefinition_isVariantOfVolume(self)

    def isVariantOfDimensionless(self):
        """
        isVariantOfDimensionless(self) -> bool

        Convenience function for testing if a given unit definition is a
        variant of the unit @c 'dimensionless'.

        @return @c true if this UnitDefinition is a variant of @c
        dimensionless, meaning dimensionless with only abritrary variations in
        scale or multiplier values; @c false otherwise.
          

        """
        return _libsbml.UnitDefinition_isVariantOfDimensionless(self)

    def isVariantOfMass(self):
        """
        isVariantOfMass(self) -> bool

        Convenience function for testing if a given unit definition is a
        variant of the predefined unit identifier @c 'mass'.

        @return @c true if this UnitDefinition is a variant of mass units,
        meaning gram or kilogram with only abritrary variations in scale or
        multiplier values; @c false otherwise.
          

        """
        return _libsbml.UnitDefinition_isVariantOfMass(self)

    def isVariantOfSubstancePerTime(self):
        """
        isVariantOfSubstancePerTime(self) -> bool

        Convenience function for testing if a given unit definition is a
        variant of the predefined unit @c 'substance' divided by the predefined
        unit @c 'time'.

        @return @c true if this UnitDefinition is a variant of the predefined
        unit @c substance per predefined unit @c time, meaning it contains two
        units one of which is a variant of substance and the other is a
        variant of time which an exponent of -1; @c false otherwise.
          

        """
        return _libsbml.UnitDefinition_isVariantOfSubstancePerTime(self)

    def addUnit(self, *args):
        """
        addUnit(self, Unit u) -> int

        Adds a copy of the given Unit to this UnitDefinition.

        @param u the Unit instance to add to this UnitDefinition.

        @return integer value indicating success/failure of the
        function.  @if clike The value is drawn from the
        enumeration #OperationReturnValues_t. @endif The possible values
        returned by this function are:
        @li LIBSBML_OPERATION_SUCCESS
        @li LIBSBML_LEVEL_MISMATCH
        @li LIBSBML_VERSION_MISMATCH
        @li LIBSBML_DUPLICATE_OBJECT_ID
        @li LIBSBML_OPERATION_FAILED

        @note This method should be used with some caution.  The fact that
        this method @em copies the object passed to it means that the caller
        will be left holding a physically different object instance than the
        one contained in this UnitDefinition.  Changes made to the original
        object instance (such as resetting attribute values) will <em>not
        affect the instance in the UnitDefinition</em>.  In addition, the
        caller should make sure to free the original object if it is no longer
        being used, or else a memory leak will result.  Please see
        UnitDefinition::createUnit() for a method that does not lead to these
        issues.

        @see createUnit()
          

        """
        return _libsbml.UnitDefinition_addUnit(self, *args)

    def createUnit(self):
        """
        createUnit(self) -> Unit

        Creates a new and empty Unit, adds it to this UnitDefinition's list of
        units, and returns it.

        @return a newly constructed (and empty) Unit instance.

        @note It is worth emphasizing that the attribute 'kind' value of a
        Unit is a required attribute for a valid Unit definition.  The
        createUnit() method does not assign a valid kind to the constructed
        unit (instead, it sets the 'kind' to @c UNIT_KIND_INVALID).  Callers
        are cautioned to set the newly-constructed Unit's kind using
        Unit::setKind() soon after calling this method.

        @see addUnit(const Unit* u)
          

        """
        return _libsbml.UnitDefinition_createUnit(self)

    def getListOfUnits(self, *args):
        """
        getListOfUnits(self) -> ListOfUnits
        getListOfUnits(self) -> ListOfUnits

        Returns the list of Units for this UnitDefinition instance.
        @return the ListOfUnits value for this UnitDefinition.
          

        """
        return _libsbml.UnitDefinition_getListOfUnits(self, *args)

    def getUnit(self, *args):
        """
        getUnit(self, unsigned int n) -> Unit
        getUnit(self, unsigned int n) -> Unit

        Returns a specific Unit instance belonging to this UnitDefinition.

        @param n an integer, the index of the Unit to be returned.

        @return the nth Unit of this UnitDefinition
          

        """
        return _libsbml.UnitDefinition_getUnit(self, *args)

    def getNumUnits(self):
        """
        getNumUnits(self) -> unsigned int

        Returns the number of Unit objects contained within this
        UnitDefinition.

        @return an integer representing the number of Units in this
        UnitDefinition.
          

        """
        return _libsbml.UnitDefinition_getNumUnits(self)

    def removeUnit(self, *args):
        """
        removeUnit(self, unsigned int n) -> Unit

        Removes the nth Unit object from this UnitDefinition object and
        returns a pointer to it.

        The caller owns the returned object and is responsible for deleting it.

        @param n the index of the Unit object to remove

        @return the Unit object removed.  As mentioned above, 
        the caller owns the returned item. NULL is returned if the given index 
        is out of range.

          

        """
        return _libsbml.UnitDefinition_removeUnit(self, *args)

    def getTypeCode(self):
        """
        getTypeCode(self) -> SBMLTypeCode_t

        Returns the libSBML type code for this object instance.

        @if clike LibSBML attaches an identifying code to every
        kind of SBML object.  These are known as <em>SBML type codes</em>.
        The set of possible type codes is defined in the enumeration
        #SBMLTypeCode_t.  The names of the type codes all begin with the
        characters @c SBML_. @endif@if java LibSBML attaches an
        identifying code to every kind of SBML object.  These are known as
        <em>SBML type codes</em>.  In other languages, the set of type codes
        is stored in an enumeration; in the Java language interface for
        libSBML, the type codes are defined as static integer constants in
        interface class {@link libsbmlConstants}.  The names of the type codes
        all begin with the characters @c SBML_. @endif

        @return the SBML type code for this object, or @c SBML_UNKNOWN (default).

        @see getElementName()
          

        """
        return _libsbml.UnitDefinition_getTypeCode(self)

    def getElementName(self):
        """
        getElementName(self) -> string

        Returns the XML element name of this object, which for UnitDefinition,
        is always @c 'unitDefinition'.

        @return the name of this element, i.e., @c 'unitDefinition'.
          

        """
        return _libsbml.UnitDefinition_getElementName(self)

    def simplify(*args):
        """
        simplify(UnitDefinition ud)

        Simplifies the UnitDefinition so that any Unit objects occurring within
        the ListOfUnits occurs only once.

        For example, the following definition,
        @code
        <unitDefinition>
         <listOfUnits>
           <unit kind='metre' exponent='1'/>
           <unit kind='metre' exponent='2'/>
         </listOfUnits>
        <unitDefinition>
        @endcode
        will be simplified to 
        @code
        <unitDefinition>
          <listOfUnits>
            <unit kind='metre' exponent='3'/>
          </listOfUnits>
        <unitDefinition>
        @endcode

        @param ud the UnitDefinition object to be simplified.
         

        """
        return _libsbml.UnitDefinition_simplify(*args)

    if _newclass:simplify = staticmethod(simplify)
    __swig_getmethods__["simplify"] = lambda x: simplify
    def reorder(*args):
        """
        reorder(UnitDefinition ud)

        Orders alphabetically the Unit objects within the ListOfUnits of a
        UnitDefinition.

        @param ud the UnitDefinition object whose units are to be reordered.
          

        """
        return _libsbml.UnitDefinition_reorder(*args)

    if _newclass:reorder = staticmethod(reorder)
    __swig_getmethods__["reorder"] = lambda x: reorder
    def convertToSI(*args):
        """
        convertToSI(UnitDefinition arg0) -> UnitDefinition

        Convert a given UnitDefinition into a new UnitDefinition object
        that uses SI units.

        @param ud the UnitDefinition object to convert to SI

        @return a new UnitDefinition object representing the results of the
        conversion.
          

        """
        return _libsbml.UnitDefinition_convertToSI(*args)

    if _newclass:convertToSI = staticmethod(convertToSI)
    __swig_getmethods__["convertToSI"] = lambda x: convertToSI
    def areIdentical(*args):
        """
        areIdentical(UnitDefinition ud1, UnitDefinition ud2) -> bool

        Predicate returning @c true or @c false depending on whether two
        UnitDefinition objects are identical.

        For the purposes of performing this comparison, two UnitDefinition
        objects are considered identical when they contain identical lists of
        Unit objects.  Pairs of Unit objects in the lists are in turn
        considered identical if they satisfy the predicate
        Unit::areIdentical().  The predicate compares every attribute of the
        Unit objects.

        @param ud1 the first UnitDefinition object to compare
        @param ud2 the second UnitDefinition object to compare

        @return @c true if all the Unit objects in ud1 are identical to the
        Unit objects of ud2, @c false otherwise.

        @see areEquivalent(const UnitDefinition * ud1, const %UnitDefinition * ud2)
        @see Unit::areIdentical(Unit * unit1, %Unit * unit2)
          

        """
        return _libsbml.UnitDefinition_areIdentical(*args)

    if _newclass:areIdentical = staticmethod(areIdentical)
    __swig_getmethods__["areIdentical"] = lambda x: areIdentical
    def areEquivalent(*args):
        """
        areEquivalent(UnitDefinition ud1, UnitDefinition ud2) -> bool

        Predicate returning @c true or @c false depending on whether two
        UnitDefinition objects are equivalent.

        For the purposes of performing this comparison, two UnitDefinition
        objects are considered equivalent when they contain @em equivalent
        list of Unit objects.  Unit objects are in turn considered equivalent
        if they satisfy the predicate Unit::areEquivalent().  The predicate
        tests a subset of the objects's attributes.

        @param ud1 the first UnitDefinition object to compare

        @param ud2 the second UnitDefinition object to compare

        @return @c true if all the Unit objects in ud1 are equivalent
        to the Unit objects in ud2, @c false otherwise.

        @see areIdentical(const UnitDefinition * ud1, const %UnitDefinition * ud2)
        @see Unit::areEquivalent(Unit * unit1, %Unit * unit2)
          

        """
        return _libsbml.UnitDefinition_areEquivalent(*args)

    if _newclass:areEquivalent = staticmethod(areEquivalent)
    __swig_getmethods__["areEquivalent"] = lambda x: areEquivalent
    def combine(*args):
        """
        combine(UnitDefinition ud1, UnitDefinition ud2) -> UnitDefinition

        Combines two UnitDefinition objects into a single UnitDefinition
        object which expresses the product of the units of the two
        UnitDefinition's.

        @param ud1 the first UnitDefinition object 
        @param ud2 the second UnitDefinition object

        @return a UnitDefinition which represents the product of the 
        units of the two argument UnitDefinitions.
          

        """
        return _libsbml.UnitDefinition_combine(*args)

    if _newclass:combine = staticmethod(combine)
    __swig_getmethods__["combine"] = lambda x: combine
    def printUnits(*args):
        """
        printUnits(UnitDefinition ud, bool compact = False) -> string
        printUnits(UnitDefinition ud) -> string

        Returns a string that expresses the unit definition
        represented by this UnitDefinition object.

        For example printUnits applied to
        @code
        <unitDefinition>
         <listOfUnits>
           <unit kind='metre' exponent='1'/>
           <unit kind='second' exponent='-2'/>
         </listOfUnits>
        <unitDefinition>
        @endcode
        will return the string <code>'metre (exponent = 1, multiplier = 1, scale = 0) 
        second (exponent = -2, multiplier = 1, scale = 0)'</code> or, if 
        compact = true, the string <code>'(1 metre)^1 (1 second)^-2'</code>
        This may be useful for printing unit information to
        human users, or in debugging, or other situations.

        @param ud the UnitDefinition object
        @param compact boolean indicating whether the compact form
        should be used (defaults to false)

        @return a string expressing the unit definition
          

        """
        return _libsbml.UnitDefinition_printUnits(*args)

    if _newclass:printUnits = staticmethod(printUnits)
    __swig_getmethods__["printUnits"] = lambda x: printUnits
    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(self) -> bool

        Predicate returning @c true or @c false depending on whether
        all the required attributes for this UnitDefinition object
        have been set.

        @note The required attributes for a UnitDefinition object are:
        id (name in L1)

        @return a boolean value indicating whether all the required
        attributes for this object have been defined.
          

        """
        return _libsbml.UnitDefinition_hasRequiredAttributes(self)

    def hasRequiredElements(self):
        """
        hasRequiredElements(self) -> bool

        Predicate returning @c true or @c false depending on whether
        all the required elements for this UnitDefinition object
        have been set.

        @note The required elements for a Constraint object are:
        listOfUnits (L2 only)

        @return a boolean value indicating whether all the required
        elements for this object have been defined.
          

        """
        return _libsbml.UnitDefinition_hasRequiredElements(self)

UnitDefinition_swigregister = _libsbml.UnitDefinition_swigregister
UnitDefinition_swigregister(UnitDefinition)

def UnitDefinition_simplify(*args):
  """
    UnitDefinition_simplify(UnitDefinition ud)

    Simplifies the UnitDefinition so that any Unit objects occurring within
    the ListOfUnits occurs only once.

    For example, the following definition,
    @code
    <unitDefinition>
     <listOfUnits>
       <unit kind='metre' exponent='1'/>
       <unit kind='metre' exponent='2'/>
     </listOfUnits>
    <unitDefinition>
    @endcode
    will be simplified to 
    @code
    <unitDefinition>
      <listOfUnits>
        <unit kind='metre' exponent='3'/>
      </listOfUnits>
    <unitDefinition>
    @endcode

    @param ud the UnitDefinition object to be simplified.
     

    """
  return _libsbml.UnitDefinition_simplify(*args)

def UnitDefinition_reorder(*args):
  """
    UnitDefinition_reorder(UnitDefinition ud)

    Orders alphabetically the Unit objects within the ListOfUnits of a
    UnitDefinition.

    @param ud the UnitDefinition object whose units are to be reordered.
      

    """
  return _libsbml.UnitDefinition_reorder(*args)

def UnitDefinition_convertToSI(*args):
  """
    UnitDefinition_convertToSI(UnitDefinition arg0) -> UnitDefinition

    Convert a given UnitDefinition into a new UnitDefinition object
    that uses SI units.

    @param ud the UnitDefinition object to convert to SI

    @return a new UnitDefinition object representing the results of the
    conversion.
      

    """
  return _libsbml.UnitDefinition_convertToSI(*args)

def UnitDefinition_areIdentical(*args):
  """
    UnitDefinition_areIdentical(UnitDefinition ud1, UnitDefinition ud2) -> bool

    Predicate returning @c true or @c false depending on whether two
    UnitDefinition objects are identical.

    For the purposes of performing this comparison, two UnitDefinition
    objects are considered identical when they contain identical lists of
    Unit objects.  Pairs of Unit objects in the lists are in turn
    considered identical if they satisfy the predicate
    Unit::areIdentical().  The predicate compares every attribute of the
    Unit objects.

    @param ud1 the first UnitDefinition object to compare
    @param ud2 the second UnitDefinition object to compare

    @return @c true if all the Unit objects in ud1 are identical to the
    Unit objects of ud2, @c false otherwise.

    @see areEquivalent(const UnitDefinition * ud1, const %UnitDefinition * ud2)
    @see Unit::areIdentical(Unit * unit1, %Unit * unit2)
      

    """
  return _libsbml.UnitDefinition_areIdentical(*args)

def UnitDefinition_areEquivalent(*args):
  """
    UnitDefinition_areEquivalent(UnitDefinition ud1, UnitDefinition ud2) -> bool

    Predicate returning @c true or @c false depending on whether two
    UnitDefinition objects are equivalent.

    For the purposes of performing this comparison, two UnitDefinition
    objects are considered equivalent when they contain @em equivalent
    list of Unit objects.  Unit objects are in turn considered equivalent
    if they satisfy the predicate Unit::areEquivalent().  The predicate
    tests a subset of the objects's attributes.

    @param ud1 the first UnitDefinition object to compare

    @param ud2 the second UnitDefinition object to compare

    @return @c true if all the Unit objects in ud1 are equivalent
    to the Unit objects in ud2, @c false otherwise.

    @see areIdentical(const UnitDefinition * ud1, const %UnitDefinition * ud2)
    @see Unit::areEquivalent(Unit * unit1, %Unit * unit2)
      

    """
  return _libsbml.UnitDefinition_areEquivalent(*args)

def UnitDefinition_combine(*args):
  """
    UnitDefinition_combine(UnitDefinition ud1, UnitDefinition ud2) -> UnitDefinition

    Combines two UnitDefinition objects into a single UnitDefinition
    object which expresses the product of the units of the two
    UnitDefinition's.

    @param ud1 the first UnitDefinition object 
    @param ud2 the second UnitDefinition object

    @return a UnitDefinition which represents the product of the 
    units of the two argument UnitDefinitions.
      

    """
  return _libsbml.UnitDefinition_combine(*args)

def UnitDefinition_printUnits(*args):
  """
    printUnits(UnitDefinition ud, bool compact = False) -> string
    UnitDefinition_printUnits(UnitDefinition ud) -> string

    Returns a string that expresses the unit definition
    represented by this UnitDefinition object.

    For example printUnits applied to
    @code
    <unitDefinition>
     <listOfUnits>
       <unit kind='metre' exponent='1'/>
       <unit kind='second' exponent='-2'/>
     </listOfUnits>
    <unitDefinition>
    @endcode
    will return the string <code>'metre (exponent = 1, multiplier = 1, scale = 0) 
    second (exponent = -2, multiplier = 1, scale = 0)'</code> or, if 
    compact = true, the string <code>'(1 metre)^1 (1 second)^-2'</code>
    This may be useful for printing unit information to
    human users, or in debugging, or other situations.

    @param ud the UnitDefinition object
    @param compact boolean indicating whether the compact form
    should be used (defaults to false)

    @return a string expressing the unit definition
      

    """
  return _libsbml.UnitDefinition_printUnits(*args)

class ListOfUnitDefinitions(ListOf):
    """
    LibSBML implementation of SBML's %ListOfUnitDefinitions construct.

    The various ListOf___ classes in %SBML are merely containers used for
    organizing the main components of an %SBML model.  All are derived from
    the abstract class SBase, and inherit the various attributes and
    subelements of SBase, such as 'metaid' as and 'annotation'.  The
    ListOf___ classes do not add any attributes of their own.

    The relationship between the lists and the rest of an %SBML model is
    illustrated by the following (for %SBML Level&nbsp;2 Version&nbsp;4):

    @image html listof-illustration.jpg 'ListOf___ elements in an SBML Model'
    @image latex listof-illustration.jpg 'ListOf___ elements in an SBML Model'

    Readers may wonder about the motivations for using the ListOf___
    containers.  A simpler approach in XML might be to place the components
    all directly at the top level of the model definition.  We chose instead
    to group them within XML elements named after ListOf<em>Classname</em>,
    in part because we believe this helps organize the components and makes
    visual reading of models in XML easier.  More importantly, the fact that
    the container classes are derived from SBase means that software tools
    can add information about the lists themselves into each list
    container's 'annotation'.

    @see ListOfFunctionDefinitions
    @see ListOfUnitDefinitions
    @see ListOfCompartmentTypes
    @see ListOfSpeciesTypes
    @see ListOfCompartments
    @see ListOfSpecies
    @see ListOfParameters
    @see ListOfInitialAssignments
    @see ListOfRules
    @see ListOfConstraints
    @see ListOfReactions
    @see ListOfEvents

    """
    __swig_setmethods__ = {}
    for _s in [ListOf]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfUnitDefinitions, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfUnitDefinitions, name)
    __repr__ = _swig_repr
    def clone(self):
        """
        clone(self) -> ListOfUnitDefinitions

        Creates and returns a deep copy of this ListOfUnitDefinitions instance.

        @return a (deep) copy of this ListOfUnitDefinitions.
          

        """
        return _libsbml.ListOfUnitDefinitions_clone(self)

    def getTypeCode(self):
        """
        getTypeCode(self) -> SBMLTypeCode_t

        Returns the libSBML type code for this %SBML object.

        @if clike LibSBML attaches an identifying code to every
        kind of SBML object.  These are known as <em>SBML type codes</em>.
        The set of possible type codes is defined in the enumeration
        #SBMLTypeCode_t.  The names of the type codes all begin with the
        characters @c SBML_. @endif@if java LibSBML attaches an
        identifying code to every kind of SBML object.  These are known as
        <em>SBML type codes</em>.  In other languages, the set of type codes
        is stored in an enumeration; in the Java language interface for
        libSBML, the type codes are defined as static integer constants in
        interface class {@link libsbmlConstants}.  The names of the type codes
        all begin with the characters @c SBML_. @endif

        @return the SBML type code for this object, or @c SBML_UNKNOWN (default).

        @see getElementName()
          

        """
        return _libsbml.ListOfUnitDefinitions_getTypeCode(self)

    def getItemTypeCode(self):
        """
        getItemTypeCode(self) -> SBMLTypeCode_t

        Returns the libSBML type code for the objects contained in this ListOf
        (i.e., UnitDefinition objects, if the list is non-empty).

        @if clike LibSBML attaches an identifying code to every
        kind of SBML object.  These are known as <em>SBML type codes</em>.
        The set of possible type codes is defined in the enumeration
        #SBMLTypeCode_t.  The names of the type codes all begin with the
        characters @c SBML_. @endif@if java LibSBML attaches an
        identifying code to every kind of SBML object.  These are known as
        <em>SBML type codes</em>.  In other languages, the set of type codes
        is stored in an enumeration; in the Java language interface for
        libSBML, the type codes are defined as static integer constants in
        interface class {@link libsbmlConstants}.  The names of the type codes
        all begin with the characters @c SBML_. @endif

        @return the SBML type code for the objects contained in this ListOf
        instance, or @c SBML_UNKNOWN (default).

        @see getElementName()
          

        """
        return _libsbml.ListOfUnitDefinitions_getItemTypeCode(self)

    def getElementName(self):
        """
        getElementName(self) -> string

        Returns the XML element name of this object.

        For ListOfUnitDefinitions, the XML element name is @c
        'listOfUnitDefinitions'.

        @return the name of this element, i.e., @c 'listOfUnitDefinitions'.
          

        """
        return _libsbml.ListOfUnitDefinitions_getElementName(self)

    def get(self, *args):
        """
        get(self, unsigned int n) -> UnitDefinition
        get(self, unsigned int n) -> UnitDefinition
        get(self, string sid) -> UnitDefinition
        get(self, string sid) -> UnitDefinition

        Get a UnitDefinition from the ListOfUnitDefinitions
        based on its identifier.

        @param sid a string representing the identifier 
        of the UnitDefinition to get.

        @return UnitDefinition in this ListOfUnitDefinitions
        with the given id or NULL if no such
        UnitDefinition exists.

        @see get(unsigned int n)
        @see size()
          

        """
        return _libsbml.ListOfUnitDefinitions_get(self, *args)

    def remove(self, *args):
        """
        remove(self, unsigned int n) -> UnitDefinition
        remove(self, string sid) -> UnitDefinition

        Removes item in this ListOfUnitDefinitions items with the given identifier.

        The caller owns the returned item and is responsible for deleting it.
        If none of the items in this list have the identifier @p sid, then @c
        NULL is returned.

        @param sid the identifier of the item to remove

        @return the item removed.  As mentioned above, the caller owns the
        returned item.
          

        """
        return _libsbml.ListOfUnitDefinitions_remove(self, *args)

    def __init__(self): 
        """__init__(self) -> ListOfUnitDefinitions"""
        this = _libsbml.new_ListOfUnitDefinitions()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _libsbml.delete_ListOfUnitDefinitions
    __del__ = lambda self : None;
ListOfUnitDefinitions_swigregister = _libsbml.ListOfUnitDefinitions_swigregister
ListOfUnitDefinitions_swigregister(ListOfUnitDefinitions)

class CompartmentType(SBase):
    """
    LibSBML implementation of %SBML's %CompartmentType construct.

    A <em>compartment type</em> in %SBML is a grouping construct used to
    establish a relationship between multiple Compartment objects.
    In %SBML Level 2 Versions 2, 3 and 4, a compartment type only has an
    identity, and this identity can only be used to indicate that particular
    compartments belong to this type.  This may be useful for conveying a
    modeling intention, such as when a model contains many similar
    compartments, either by their biological function or the reactions they
    carry.  Without a compartment type construct, it would be impossible in
    the language of %SBML to indicate that all of the compartments share an
    underlying conceptual relationship because each %SBML compartment must be
    given a unique and separate identity.  Compartment types have no
    mathematical meaning in %SBML Level 2&mdash;they have no effect on a
    model's mathematical interpretation.  Simulators and other numerical
    analysis software may ignore CompartmentType definitions and references
    to them in a model.

    There is no mechanism in %SBML for representing hierarchies of
    compartment types.  One CompartmentType instance cannot be the subtype
    of another CompartmentType instance; %SBML provides no means of defining
    such relationships.

    As with other major structures in %SBML, CompartmentType has a mandatory
    attribute, 'id', used to give the compartment type an identifier.  The
    identifier must be a text %string conforming to the identifer syntax
    permitted in %SBML.  CompartmentType also has an optional 'name'
    attribute, of type @c string.  The 'id' and 'name' must be used
    according to the guidelines described in the %SBML specification (e.g.,
    Section 3.3 in the Level 2 Version 4 specification).

    CompartmentType was introduced in SBML Level 2 Version 2.  It is not
    available in earlier versions of Level 2 nor in any version of Level 1.

    @see Compartment